Lecture des commutateurs avec ATtiny2313 : 9 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:10

Il y a eu plusieurs Instructables traitant des sorties de l'ATtiny2313 et des appareils AVR similaires. Par exemple, https://www.instructables.com/id/Ghetto-Programming%3a-Getting-started-with-AVR-micro/, https://www.instructables.com/id/Drive-a-Stepper- Moteur-avec-un-AVR-Microprocesseur/. En travaillant sur le dernier de The Real Elliot, qui montrait comment contrôler les moteurs pas à pas, j'ai trouvé qu'il serait vraiment utile de pouvoir exécuter d'autres sections de code dans le même programme, donc je n'ai pas eu à reprogrammer l'ATtiny2313 chacun fois, je voulais essayer une légère variation de code (comme un demi-pas ou l'exécution du moteur pas à pas à l'envers). Bien qu'il soit facile d'écrire du code à l'aide d'une instruction switch/case pour permettre la sélection de variantes alternatives, un moyen de sélectionner la casse est nécessaire. Cela signifie qu'une sorte de périphérique d'entrée doit être lu pour contrôler le boîtier. Heureusement, l'ATtiny2313 possède de nombreuses broches d'E/S et est bien conçu pour lire les entrées des commutateurs. Ce Instructable montrera comment lire les entrées et prendre des décisions en fonction de leur état. Étant donné que cela seul ferait un Instructable assez ennuyeux, je vais expliquer un moyen simple d'utiliser la capacité de minuterie/compteur de l'ATtiny2313 pour piloter un petit haut-parleur comme un bip. Il y aura également une petite digression sur les techniques de débogage simples.

Étape 1: Le périphérique d'entrée

Ce Instructable s'appuie sur l'excellent travail de The Real Elliot et utilise le système de développement ATtiny2313 Ghetto qu'il décrit. La fiche technique ATtiny2313 d'Atmel est la référence ultime pour toutes les fonctions, mais elle n'est pas forcément facile à lire. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (Le lien contient toutes les fiches techniques de l'AVR, localisez le 2313.) La figure montre un ensemble simple de commutateurs d'entrée. Il s'agit simplement d'un ensemble de quatre interrupteurs marche/arrêt; également connu sous le nom de commutateurs unipolaires unidirectionnels (SPST). En règle générale, une connexion, ou pôle, de chaque commutateur est reliée à la terre tandis que l'autre connexion est tirée vers le haut via une résistance de limitation de courant (10K environ). Une entrée du microcontrôleur est connectée au pôle avec la résistance. Si l'interrupteur est ouvert, le microcontrôleur lira l'entrée comme HI. Si l'interrupteur est fermé, le microcontrôleur lira l'entrée LO. Reportez-vous au schéma pour plus de détails. L'ATtiny2313 simplifie les choses en fournissant des résistances de rappel programmables sur les broches d'E/S lorsqu'elles sont configurées comme entrées. Cela signifie que les commutateurs peuvent simplement avoir un pôle lié à la terre (LO) et l'autre pôle connecté à une entrée de processeur. Le premier exemple montre seulement deux commutateurs. Les commutateurs sont lus et configurés avec le code suivant. Configurez les commutateurs en tant qu'entrées: (aucun code requis; c'est la valeur par défaut.)Activez les résistances de rappel: PORTB = _BV(PB0) | _BV(PB1);Lire les entrées: but1 = ~PINB & 0x03; Notez l'utilisation de l'inversion et du masquage pour obtenir la valeur correcte.

Étape 2: Clignotements pour un signal

Nous utiliserons ces deux commutateurs pour faire clignoter une LED un nombre de fois programmable. Les LED que nous utiliserons seront les clignotants que The Real Elliot a rendus célèbres. Les commutateurs 1 et 2 seront traités comme deux chiffres binaires, de sorte que la combinaison peut représenter les nombres 0, 1, 2 et 3. Notre programme lira les deux commutateurs et fera clignoter la LED le nombre de fois approprié, mais seulement si le commutateur les paramètres ont changé. Les commutateurs sont anti-rebonds pendant 500 millisecondes (non optimisé). L'algorithme anti-rebond est assez simple. Les interrupteurs sont lus et la lecture est notée. Si elle est différente de la valeur oldBut (la dernière valeur enregistrée), le programme est retardé de 500 millisecondes et les commutateurs sont relus. Si la valeur est la même que précédemment lue, la valeur de oldBut sera mise à jour et la LED clignotera le nombre de fois impliqué par la valeur binaire des deux commutateurs. Notez l'inversion de la valeur puisqu'un interrupteur qui est "on" lit LO. Les commutateurs seront scannés en continu pour d'autres modifications. Veuillez vous reporter aux instructions précédentes de The Real Elliot pour en savoir plus sur les clignotants. Jetez un œil à ce https://www.ganssle.com/debouncing.pdf pour en savoir plus sur les commutateurs anti-rebond. Voici le code ATtiny2313 pour cet exemple. En fonctionnement, ce programme fera clignoter la LED sur PB4 (broche physique 8) deux fois pour indiquer qu'il est initialisé. Il lira ensuite les commutateurs un et deux, et clignotera une à trois fois en fonction du réglage du commutateur chaque fois qu'ils sont modifiés. Lorsque les commutateurs ne changent pas, la LED clignote lentement. Pour exécuter ce code, créez un nouveau répertoire (appelez-le "Basic" si vous le souhaitez) et téléchargez le fichier de code C suivant et le makefile dedans. Renommez Makefile1.txt en Makefile. En utilisant WinAVR, compilez le programme et chargez-le dans votre ATtiny2313.

Étape 3: Une digression mineure sur le débogage

Si vous êtes comme moi (et tous les autres programmeurs dans le monde), vous avez probablement connu des moments où le code "sans erreur" que vous avez soigneusement tapé et compilé ne fait pas ce que vous attendez de lui. Peut-être que ça ne fait tout simplement rien ! Donc quel est le problème? Comment allez-vous le découvrir ? Heureusement, il existe plusieurs approches pour faire fonctionner les choses. (Obtenez ce livre pour un excellent traitement du sujet du débogage. https://www.debuggingrules.com/) J'aimerais offrir quelques suggestions simples concernant le sujet du débogage des applications de microcontrôleur. La première étape consiste à s'appuyer sur ce que tu sais. Si vous avez fait fonctionner un clignotant une fois, utilisez-le à nouveau pour voir où vous en êtes dans votre programme. J'aime que la LED clignote deux fois pour signaler le début du programme. Vous pouvez mettre le code pour le faire initialement au début de votre programme. Une fois que vous savez que rien ne va pas avec votre matériel, créez une fonction pour faire le clignotement. Voici la fonction que j'utilise./*------------------------------------------- ------------------------------** blinkEm - fonction pour faire clignoter la LED en utilisant PD4** PD4 doit être configuré comme sortie. ** ------------------------------------------------ ---------------------*/void blinkEm(uint8_t count){ while (count > 0){ PORTD = _BV(PD4); _delay_ms(1000); PORTD = ~_BV(PD4); _delay_ms(1000); compter--; }} Il est maintenant possible d'utiliser cette fonction à divers points de votre code pour signaler que le code a été exécuté jusque-là. Savoir que le code est en cours d'exécution signifie que vous pouvez examiner attentivement chaque section qui a été exécutée, mais n'a pas fait ce que vous attendiez, pour trouver des erreurs. Changer une chose à la fois est une technique clé pour le débogage également (décrit dans la référence ci-dessus). Cette méthode classique fonctionne avec « diviser pour mieux régner »: faire des petits pas pour ajouter progressivement des fonctionnalités. Cela peut sembler une approche lente, mais ce n'est pas aussi lent que d'essayer de déboguer une grande partie de code qui ne fonctionne pas d'un seul coup.

Étape 4: Plus de débogage

Il y a de nombreuses fois où nous voulons vérifier une section de code en sautant la plupart des lignes qu'elle contient, puis en les activant une par une pendant que nous vérifions que chacune fonctionne. Typiquement, nous le faisons en "commentant" les lignes que nous voulons sauter. Une extension de cette technique consiste à couper et coller un bloc de code, commenter l'original (afin de ne pas le perdre) et pirater la copie. C a quatre façons simples de commenter des lignes. Mettre "//" devant une ligne commente cette ligne. Inclure une ou plusieurs lignes dans "/*" et "*/" commentera une section entière. Pour que cette méthode fonctionne efficacement, il ne doit pas y avoir d'autre "*/" dans le bloc de code (autre que celui de fin). Une discipline efficace consiste donc à utiliser // pour les commentaires dans les blocs de code et à réserver la construction /* */ pour les blocs de commentaires et pour commenter des sections de code. Placer "#if 0" au début d'un bloc pour commenter et terminer la section par "#endif". Un contrôle plus sélectif est possible en utilisant "#ifdef (identifiant)" au début d'un bloc et "#endif" à la fin. Si vous souhaitez que le bloc soit compilé, utilisez "#define (identifiant)" plus tôt dans le programme. Notez que les guillemets servent uniquement à mettre l'accent et ne doivent pas être inclus. La combinaison de ces techniques devrait fournir une approche utile pour déboguer vos programmes ATtiny2313. Vous pouvez trouver ces outils utiles au fur et à mesure que nous procédons à travers ce Instructable.

Étape 5: Utilisation de la minuterie/compteur 0 pour les bips

L'ATtiny2313 dispose de deux puissantes ressources de minuterie/compteur: une 8 bits et une 16 bits. Ceux-ci peuvent être configurés comme des générateurs de fréquence, des contrôleurs de modulation de largeur d'impulsion variable et des registres de comparaison de sortie. La pleine fonctionnalité de ceux-ci est décrite dans 49 pages de la fiche technique. Cependant, nous utiliserons un cas simple. Seul le Timer/Counter 0 (le 8 bits) sera utilisé et il servira simplement de générateur de fréquence. La fréquence sera acheminée vers un petit haut-parleur pour produire un bip. Timer/Counter 0 est décrit en détail aux pages 66 à 83 de la fiche technique ATtiny2313. Une lecture attentive de ce matériel fournira une compréhension complète de Time/Counter 0. Heureusement, un mode assez simple, Clear Timer on Compare (CTC), est tout ce qui est nécessaire pour générer le bip que nous voulons.

Pour le mode que nous utiliserons, le fonctionnement de la minuterie/compteur est simple. Lorsqu'un signal d'horloge est sélectionné, le compteur démarre à zéro et incrémente chaque impulsion d'horloge. Lorsque la valeur du compteur atteint la valeur dans le registre de comparaison de sortie (TOP), le compteur est remis à zéro et le comptage recommence. Le bit de sortie associé à la minuterie/compteur est basculé pour produire une sortie d'onde carrée. Cela entraîne directement un transducteur audio pour émettre un bip. Un petit transducteur audio TDK produit le bip. Une unité appropriée est Digikey 445-2530-ND, TDK SD1209T3-A1 (j'ai utilisé une première version de celle-ci). Il s'agit d'une version 3 volts; la version 5 volts fonctionnera également je pense. Je le pilote directement sur le port de sortie de l'Attiny2313 et cela semble bien fonctionner. Sparkfun a un appareil similaire.

Étape 6: Configuration de la minuterie/compteur 0

Le mode CTC peut être utilisé pour basculer la sortie OC0A sur la broche 2, port B (broche physique 14). Pour activer la sortie sur cette broche, DDRB doit être défini de manière appropriée. Le code C pour cela est comme la configuration d'une sortie pour un clignotant. DDRB = _BV(PB2); // Le port B2 est une sortie. L'étape suivante consiste à fournir un signal d'horloge et à charger le registre de comparaison de sortie pour produire une forme d'onde sous forme de fréquence. L'équation de la fréquence résultante est donnée dans la fiche technique (page 72). Les termes de l'équation seront décrits ci-dessous. Voici l'équation: fOC0A = fclk_I/O / 2*N*(1+OCR0A)Où fOC0A:= fréquence de sortie fclk_I/O:= fréquence de la source d'horloge N:= facteur de pré-échelle d'horloge OCR0A:= valeur dans le registre de comparaison de sortie pour Timer/ Counter 0A. Clock Source Frequency, fclk_I/OCil s'agit de la fréquence de l'horloge système. La valeur par défaut est 1MHz. Les bits CS00, CS01 et CS02 de TCCR0B contrôlent cette sélection. Étant donné que ces bits sélectionnent également la valeur de N, elle est décrite ci-après. Valeur de pré-échelonnage, NN est la valeur utilisée pour diviser, ou pré-échelonner, l'horloge système. Les bits CS00, CS01 et CS02 de TCCR0B contrôlent cette sélection. Le tableau 41 à la page 81 de la fiche technique ATtiny2313 décrit les combinaisons. Puisqu'une fréquence proche de 1 kHz est souhaitée, les bits CS00 et CS01 de TCCR0B seront définis. Notez que le réglage des trois bits à 0, ne sélectionnant ainsi aucune source d'horloge, arrête effectivement la sortie. C'est la méthode qui sera utilisée pour démarrer et arrêter le bip. Valeur TOP, OCR0ACette valeur est la valeur TOP pour le compteur qui est chargé dans le registre de comparaison de sortie pour le temporisateur/compteur 0A. Lorsque cette valeur est atteinte, le compteur est remis à zéro et le comptage recommence jusqu'à ce que TOP soit atteint et que le cycle se répète. TOP est facilement modifiable, donc la fréquence du bip est facile à changer. Étant donné qu'une fréquence proche de 1 kHz est souhaitée, TOP est défini sur 7. (Notez que le pré-échelonneur aurait pu être défini sur 8 et TOP défini sur 63. Même résultat - votre choix.) Fréquence de sortie, fOC0AUUtilisation de l'équation pour calculer les résultats de la fréquence de sortie dans: fOC0A = 1, 000, 000 / 2 * 64 * (1+7) fOC0A = 977Hz Assez proche ! Voici le code pour charger le registre de comparaison de sortie et le registre de contrôle de compteur de minuterie 0B. Veuillez consulter le code du programme réel pour comprendre comment ils sont utilisés. OCR0A = 7; // Valeur de temps TCCR0B = _BV(CS01) | _BV(CS00); // Sélectionnez l'horloge interne & prescale=8 TCCR0B = 0; // aucune source d'horloge n'éteint la tonalité. Réglage du mode heure/compteurEn dernier détail, nous allons spécifier le mode minuterie/compteur que nous désirons en réglant les bits appropriés dans le registre de contrôle minuterie/compteur 0A. Le mode CTC est sélectionné en réglant le bit WGM01 comme décrit dans le Tableau 40, page 79 de la fiche technique. Puisque nous voulons que la sortie bascule à chaque cycle, le bit COM0A0 doit également être défini comme décrit dans le Tableau 34 à la page 77. Voici le code: TCCR0A = _BV(COM0A0) | _BV(WGM01); // Mode de basculement CTC

Étape 7: Utilisation de quatre commutateurs

Alors que nous implémentons le beeper, étendons notre matériel et nos logiciels pour gérer quatre commutateurs. Étant donné que la sortie du compteur de temps 0A est sur le port B, broche 2, nous ne pouvons pas simplement connecter plus de commutateurs séquentiellement au port B. Une solution simple serait d'utiliser le port D, mais gardons ce port disponible pour d'autres fonctions (peut-être un moteur pas à pas). Relions donc les commutateurs supplémentaires à PB3 et PB4. La lecture des commutateurs est pratiquement inchangée. La valeur du masque est changée en 0x1B (00011011 binaire) pour masquer le bit 2 avec 5, 6 et 7. Une autre astuce est utilisée pour créer un nombre binaire de 4 bits. Décalez les bits 3 et 4 vers la droite d'un bit et combinez-les avec les bits 0 et 1 en un nombre binaire de 4 bits. Il s'agit de la syntaxe C standard pour le décalage et la combinaison de bits, mais elle n'est peut-être pas bien connue du novice. but1a = (but1 & 0x03) | ((mais1 & 0x18) >> 1); // but1 a un commutateur de lectureEn fonctionnement, le programme clignote deux fois et émet deux bips pour signaler l'initialisation. Chaque fois que les commutateurs sont modifiés, le numéro qu'ils représentent sera émis un bip. Lorsque les commutateurs ne changent pas, le voyant clignote. Pour exécuter ce code, créez un nouveau répertoire (appelez-le Bip si vous le souhaitez) et téléchargez le fichier de code C suivant et le makefile dedans. Renommez Makefile2.txt en Makefile. En utilisant WinAVR, compilez le programme et chargez-le dans votre Attiny2313.

Étape 8: Utilisation de la construction Switch/case

La dernière étape est "juste le logiciel": comme promis, nous allons implémenter la construction switch/case. Bien que cet exemple ne montre que deux actions alternatives, il devrait être très clair comment utiliser cette construction pour sélectionner l'une des sections de code alternatives. En fonctionnement, ce programme surveille les interrupteurs et s'il y a un changement, il bipera le numéro approprié s'il est impair; il clignotera si le nombre est pair. Il ne fait rien à moins qu'un interrupteur ne change.

Pour exécuter ce code, créez un nouveau répertoire (appelez-le Switch si vous le souhaitez) et téléchargez le fichier de code C suivant et le makefile dedans. Renommez Makefile3.txt en Makefile. En utilisant WinAVR, compilez le programme et chargez-le dans votre Attiny2313.

Étape 9: Conclusion

Alors c'est tout! Vous savez maintenant comment utiliser les commutateurs pour contrôler l'exécution de votre programme en les lisant et en sélectionnant une action en fonction du réglage du commutateur. Vous savez également comment créer un bip et avez également appris une stratégie de débogage.

Si vous souhaitez tester votre compréhension, essayez de modifier le dernier programme pour émettre un bip aigu s'il est pair, émettre un bip grave s'il est impair et faire clignoter la LED en continu s'il n'y a pas de changement dans les commutateurs. de retour à la section sur le débogage pour obtenir de l'aide.