Étape 3: Convertir les signaux en Code
Étape 3: conversion des oscillogrammes en CodeL’environnement de développement Arduino évite à l’utilisateur d’un grand nombre de détails code malpropre. C’est bon quand vous êtes débutant et voulez clignoter une LED. Quand on veut s’interfacer avec d’autres circuits électroniques, cependant, nous devons interagir plus directement avec le microprocesseur.
Première nous allons discuter de comment lire efficacement dans les 16 broches dans le bus de données. Depuis que je suis sur l’Arduino Mega car il a beaucoup de broches d’e/s, je peux utiliser Port A et Port C pour être mon bus de données 16 bits. Port A et Port C sont pins 22 – 37 sur l’Arduino Mega. Le bus de données est bidirectionnel, ce qui signifie que parfois, les broches sont utilisés comme sorties et d’autres fois comme entrées et nous devons donc définir les modes de broche rapidement ainsi que lecture/écriture aux broches eux-mêmes. La lente façon d’utiliser ces broches serait comme suit :
pinMode(22,INPUT) ;
pinMode(23,INPUT) ;
pinMode(24,INPUT) ;
…
pinMode(37,INPUT) ;
BIT1 = digitalRead(22) ;
BIT2 = digitalRead(23) ;
BIT3 = digitalRead(24) ;
…
Bit16 = digitalRead(37) ;
À ce rythme, nous perdrions données comme nous liriez que les données plus lentes que les données sont en cours de réception. Nous devons accélérer En interfaçant directement avec le microprocesseur de l’Arduino.
Le microprocesseur de l’Arduino est comme le moteur à l’intérieur de la Porsche. Plus de temps un chauffeur d’une voiture vraiment seulement besoin de comprendre comment faire de la voiture, arrêtez et aller et n’a pas besoin de bien comprendre le fonctionnement interne du moteur de la voiture. Un pilote de voiture de course, toutefois, doit comprendre les limites et les capacités du moteur de la pousser pour gagner la course. De même, nous avons besoin de comprendre les détails de l’AVR d’ATMEL qui est moteur de l’Arduino à l’interface avec d’autres circuits électroniques.
Pour comprendre le microcontrolleur Arduino, nous lisons la datasheet AVR. L’Arduino Mega utilise le ATMEGA1280 qui peut être trouvé ici : www.atmel.com/dyn/resources/prod_documents/doc2549.pdf
Oui, c’est de 444 pages d’informations détaillées qui peut être intimidant au premier regard. Vous trouverez aux pages 100 et 101 que vous pouvez définir toutes les broches sur le port A et port C avec une écriture unique vers des adresses PORTA et PORTC. Nous pouvons également lire de ces ports, mais nous le faisons ne pas par la lecture de la PORTA et PORTC adresses, mais depuis les adresses PINA et PINC. De même, nous pouvons définir les modes de broche pour toutes les broches du port à la fois en écrivant à DDRA et DDRC adresses, un « 1 » affecte la broche de sortie et « 0 » à saisir.
Maintenant, nous pouvons définir les broches d’entrées et lisez-les bien plus rapidement en utilisant ces commandes :
DDRA = 0 X 00 ;
DDRC = 0 X 00 ;
Octet1 = PINA ;
Octet2 = PINC ;
Et d’écrire sur les broches du port :
DDRA = 0XFF ;
DDRC = 0XFF ;
PORTA = octet1 ;
PORTC = octet2 ;
Maintenant que nous pouvons efficacement lire et écrire les broches de l’autobus, que nous devons examiner comment efficacement lire et écrire les autres broches normales. Dans mon exemple de projet j’ai utilisé les broches de l’Arduino 2 – 12 pour contrôler les signaux de commande non-bus 11 passe entre le DEI1016 et l’Arduino. Si nous voulons écrire du code efficace pour ces broches également (et nous le faisons) nous devons éviter les routines digitalWrite et digitalRead qui sont lents parce qu’ils font les choses comme vérifier pour voir que les broches sont réglés sur le mode correct, etc.. Pour écrire très vite encore une fois, on peut écrire directement aux broches matériel évitant la surcharge de l’Arduino. L’avrio.h de fichier include inclut les fonctions avrio_WritePin et avrio_ReadPin qui effectuent des lectures et des rapides. J’ai pris un indice de la bibliothèque de glcd et défini ma propre routine de fastWrite qui est #defined pour avrio_WritePin pour rendre le code plus lisible. Si vous le souhaitez que vous pouvez passer en revue comment la bibliothèque glcd résout leurs écritures rapides, bien que vous devrez traverser les quelques couches d’indirection.
Un dernier morceau de difficulté que nous avons à traduire les oscillogrammes en code – juste comment nous retarder pendant le nombre spécifié de nanosecondes ? Combien de temps dure une nanoseconde ? Question : Combien de temps il prendre pour vous glisser sur une pelure et tombent ? Réponse : Un bananosecond. Désolé pour le mauvais jeu de mots. L’Arduino possède un delay(milliseconds) et delayMicroseconds(), mais n’a pas de fonction delayNanoseconds(). Lorsque vous travaillez à un langage de haut niveau comme le C, nous avons moins de connaissance de combien de temps un microcontrôleur aura pour exécuter nos commandes. Cela devient vraiment compliqué car les processeurs deviennent plus complexes et ont des pipelines d’instruction avec L1 et L2 mémoire caches, etc.. Dans notre cas de l’Arduino, il n’est pas trop difficile car nous pouvons utiliser la capacité du langage C pour inclure le code assembleur inline. À l’aide de l’Assemblée, nous pouvons compter les instructions et savoir combien d’horloge cycles (généralement 1/16000000 de seconde) prend une opération. En utilisant l’assembly « inline », nos instructions ne pas obtenir implémentées comme sous-routines et donc ne prennent pas plus de temps au processus avec le saut à la sous-routine et poussant et éclater les données de la pile. L’inconvénient d’assembly inline est que le code objet compilé s’allonge, mais ce n’est acceptable étant donné que nous ne sommes pas fait beaucoup de ces retards de nanosecondes.
Encore une fois, j’ai voler la solution à l’intérieur de la bibliothèque de glcd. Là, ils incluent le fichier delay.h qui contient la fonction _delay_cycles. Je définis ensuite cette fonction comme le DelayNanoseconds plus lisible comme suit :
Routine de Hans Heinrichs retard cycle :
#define DelayNanoseconds(__ns) _delay_cycles ((double) (F_CPU) * ((double) __ns) / 1.0e9 + 0.5)
Vous remarquerez qu’il y a double flottante point math passait ici qui est généralement évité parce que c’est beaucoup de votre temps et nous voulons des retards minimes. Cette routine utilise la virgule flottante routines mathématiques pour ajuster automatiquement à la fréquence d’horloge de microcontrôleur pour insérer la bonne quantité d’Assemblée code en ligne avec le code C et la meilleure partie est que la virgule flottante les calculs sont effectués lorsque vous compilez et ne sont pas exécutées par l’Arduino lors de l’exécution ! Cette méthode peut entraîner une instruction unique « NOP » être inséré comme un retard occupé.
