Schakelaars lezen met ATtiny2313: 9 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

Er zijn verschillende Instructables geweest die te maken hebben met uitgangen van de ATtiny2313 en soortgelijke AVR-apparaten. Bijvoorbeeld https://www.instructables.com/id/Ghetto-Programming%3a-Getting-started-with-AVR-micro/, https://www.instructables.com/id/Drive-a-Stepper- Motor-met-een-AVR-Microprocessor/. Toen ik aan de laatste van The Real Elliot werkte, die liet zien hoe je stappenmotoren kunt besturen, ontdekte ik dat het erg handig zou zijn om alternatieve codesecties in hetzelfde programma te kunnen uitvoeren, zodat ik de ATtiny2313 niet elk opnieuw hoefde te programmeren keer dat ik een kleine codevariatie wilde proberen (zoals halve stappen of de stepper in omgekeerde volgorde uitvoeren). Hoewel het gemakkelijk is om code te schrijven met een switch/case-statement om alternatieve variaties te selecteren, is er een manier nodig om de case te selecteren. Dat betekent dat er een soort invoerapparaat moet worden gelezen om de behuizing te besturen. Gelukkig heeft de ATtiny2313 veel I/O-pinnen en is hij goed ontworpen voor het lezen van ingangen van schakelaars. Deze Instructable laat zien hoe u invoer kunt lezen en beslissingen kunt nemen op basis van hun status. Omdat dat alleen al een behoorlijk saaie Instructable zou zijn, zal ik een eenvoudige manier uitleggen om de timer/teller-functie van de ATtiny2313 te gebruiken om een kleine luidspreker als pieper aan te drijven. Er zal ook een kleine uitweiding zijn over eenvoudige debugging-technieken.

Stap 1: Het invoerapparaat

Deze Instructable bouwt voort op het uitstekende werk van The Real Elliot en maakt gebruik van het ATtiny2313 Ghetto-ontwikkelingssysteem dat hij beschrijft. Het ATtiny2313 datablad van Atmel is de ultieme referentie voor alle functies, maar het is niet per se gemakkelijk te lezen. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (Link heeft alle AVR-gegevensbladen, zoek de 2313.) De afbeelding toont een eenvoudige set ingangsschakelaars. Dit is gewoon een pakket van vier aan/uit schakelaars; ook bekend als enkelpolige, enkelvoudige worpschakelaars (SPST). Gewoonlijk is één verbinding of pool van elke schakelaar verbonden met aarde, terwijl de andere verbinding hoog wordt getrokken door een stroombeperkende weerstand (10K of zo). Een microcontroller-ingang is verbonden met de pool met de weerstand. Als de schakelaar open is, leest de microcontroller de ingang als HI. Als de schakelaar gesloten is, leest de microcontroller de ingang LO. Raadpleeg het schema voor details. De ATtiny2313 vereenvoudigt dingen door programmeerbare pull-up-weerstanden op I/O-pinnen te leveren wanneer ze als ingangen zijn geconfigureerd. Dit betekent dat de schakelaars eenvoudig een pool kunnen verbinden met aarde (LO) en de andere pool verbonden met een processoringang. Het eerste voorbeeld toont slechts twee schakelaars. De schakelaars worden gelezen en geconfigureerd met de volgende code. Configureer de schakelaars als ingangen: (Geen code vereist; dit is de standaardinstelling.) Zet de pull-up weerstanden aan: PORTB = _BV(PB0) | _BV(PB1);Lees de ingangen: but1 = ~PINB & 0x03; Let op het gebruik van inversie en maskering om de juiste waarde te krijgen.

Stap 2: Knipperlichten voor een signaal

We zullen deze twee schakelaars gebruiken om een LED een programmeerbaar aantal keren te laten knipperen. De LED's die we zullen gebruiken, zijn de knipperlichten die The Real Elliot beroemd heeft gemaakt. Schakelaars 1 en 2 worden behandeld als twee binaire cijfers, dus de combinatie kan de nummers 0, 1, 2 en 3 vertegenwoordigen. Ons programma zal de twee schakelaars lezen en de LED het juiste aantal keren laten knipperen, maar alleen als de schakelaar instellingen zijn veranderd. De switches worden gedurende 500 milliseconden gedebounced (niet geoptimaliseerd). Het debounce-algoritme is vrij eenvoudig. De schakelaars worden gelezen en de lezing wordt genoteerd. Als deze afwijkt van de oldBut-waarde (de laatst opgeslagen waarde), wordt het programma 500 milliseconden vertraagd en worden de schakelaars opnieuw gelezen. Als de waarde hetzelfde is als eerder gelezen, wordt de waarde van oldBut bijgewerkt en knippert de LED het aantal keren dat wordt geïmpliceerd door de binaire waarde van de twee schakelaars. Let op de inversie van de waarde, aangezien een schakelaar die "aan" is, LO aangeeft. De schakelaars worden continu gescand op verdere wijzigingen. Raadpleeg eerdere Instructables van The Real Elliot voor meer informatie over blinkenlights. Kijk eens op https://www.ganssle.com/debouncing.pdf voor meer informatie over het debouncen van switches. Hier is de ATtiny2313-code voor dit voorbeeld. In werking zal dit programma de LED op PB4 (fysieke pin 8) twee keer knipperen om aan te geven dat het is geïnitialiseerd. Het zal dan schakelaars één en twee lezen en één tot drie keer knipperen, afhankelijk van de schakelaarinstelling, wanneer ze worden gewijzigd. Als de schakelaars niet veranderen, knippert de LED langzaam. Om deze code uit te voeren, maakt u een nieuwe map aan (noem deze "Basic" als u wilt) en downloadt u het volgende C-codebestand en de makefile erin. Hernoem Makefile1.txt naar alleen Makefile. Gebruik WinAVR, compileer het programma en laad het in uw ATtiny2313.

Stap 3: Een kleine uitweiding over foutopsporing

Als je net als ik (en elke andere programmeur ter wereld) bent, heb je waarschijnlijk wel eens meegemaakt dat de "foutloze" code die je zorgvuldig hebt ingetypt en gecompileerd niet doet wat je ervan verwacht. Misschien doet het gewoon niets! Wat is het probleem? Hoe ga je erachter komen? Gelukkig zijn er verschillende manieren om dingen werkend te krijgen. (Koop dit boek voor een uitstekende behandeling van het onderwerp debuggen. https://www.debuggingrules.com/) Ik wil graag een paar eenvoudige suggesties geven met betrekking tot het onderwerp debuggen van microcontroller-toepassingen. Stap één is om voort te bouwen op wat je weet. Als je een keer een knipperlicht hebt laten werken, gebruik het dan opnieuw om te zien waar je bent in je programma. Ik wil graag dat de LED twee keer knippert om de start van het programma aan te geven. U kunt de code hiervoor in eerste instantie aan het begin van uw programma invoeren. Zodra u weet dat er niets mis is met uw hardware, maakt u een functie om het knipperen te doen. Dit is de functie die ik gebruik./*------------------------------------------ ------------------------------** blinkEm - functie om LED te laten knipperen met PD4** PD4 moet worden geconfigureerd als een uitgang. ** ------------------------------------------------ ---------------------*/void blinkEm(uint8_t count){ while (count > 0){ PORTD = _BV(PD4); _delay_ms(1000); POORT = ~_BV(PD4); _delay_ms(1000); Graaf--; }}Het is nu mogelijk om deze functie op verschillende punten in je code te gebruiken als een signaal dat de code zover is uitgevoerd. Als u weet dat de code actief is, kunt u zorgvuldig elke sectie onderzoeken die is uitgevoerd, maar niet heeft gedaan wat u verwachtte, om fouten te vinden. Eén ding tegelijk veranderen is ook een sleuteltechniek voor het debuggen (beschreven in de referentie hierboven). Deze klassieke methode werkt samen met "verdeel en heers": kleine stapjes nemen om stapsgewijs functionaliteit toe te voegen. Dit lijkt misschien een langzame aanpak, maar het is lang niet zo traag als proberen een groot deel van niet-werkende code in één keer te debuggen.

Stap 4: Meer foutopsporing

Het komt vaak voor dat we een gedeelte van de code willen controleren door de meeste regels erin over te slaan en ze vervolgens een voor een in te schakelen terwijl we controleren of ze allemaal werken. Meestal doen we dit door "commentaar uit" lijnen die we willen overslaan. Een uitbreiding van deze techniek is om een codeblok te knippen en te plakken, commentaar te geven op het origineel (zodat we het niet kwijtraken) en de kopie te hacken. C heeft vier eenvoudige manieren om commentaar te geven op regels. Door "//" voor een regel te plaatsen, wordt die regel becommentarieerd. Als u een of meer regels tussen "/*" en "*/" plaatst, wordt een hele sectie becommentarieerd. Om deze methode effectief te laten werken, mag er geen andere "*/" in het codeblok staan (behalve het eindblok). Een effectieve discipline is dus om // te gebruiken voor opmerkingen binnen codeblokken, en de constructie /* */ te reserveren voor commentaarblokken en voor het uitcommentariëren van secties van code. Plaats "#if 0" aan het begin van een blok om commentaar te geven en de sectie beëindigen met "#endif". Meer selectieve controle is mogelijk door "#ifdef (identifier)" aan het begin van een blok en "#endif" aan het einde te gebruiken. Als u wilt dat het blok wordt gecompileerd, gebruikt u "#define (identifier)" eerder in het programma. Merk op dat de aanhalingstekens alleen ter benadrukking zijn en niet mogen worden toegevoegd. Het combineren van deze technieken zou een nuttige benadering moeten bieden voor het debuggen van uw ATtiny2313-programma's. Mogelijk vindt u deze hulpmiddelen nuttig als we door deze Instructable gaan.

Stap 5: Timer/Teller 0 gebruiken voor pieptonen

De ATtiny2313 heeft twee krachtige timer/teller-bronnen: een 8-bit en een 16-bit. Deze kunnen worden geconfigureerd als frequentiegeneratoren, regelaars voor variabele pulsbreedtemodulatie en uitgangsvergelijkingsregisters. De volledige functionaliteit hiervan wordt beschreven in 49 pagina's van het gegevensblad. We zullen echter een eenvoudig geval gebruiken. Alleen Timer/Counter 0 (de 8-bits versie) wordt gebruikt en deze wordt alleen als frequentiegenerator gebruikt. De frequentie wordt naar een kleine luidspreker geleid om een pieptoon te produceren. Timer/Teller 0 wordt volledig beschreven op pagina's 66 tot 83 van het ATtiny2313-gegevensblad. Een nauwkeurige lezing van dit materiaal zal iemand een volledig begrip van Tijd/Teller 0 verschaffen. Gelukkig is een vrij eenvoudige modus, Clear Timer on Compare (CTC), alles wat nodig is om de gewenste pieptoon te genereren.

Voor de modus die we zullen gebruiken, is de bediening van de timer/teller eenvoudig. Wanneer een kloksignaal wordt geselecteerd, begint de teller bij nul en verhoogt elke klokpuls. Wanneer de tellerwaarde de waarde in het Output Compare Register (TOP) bereikt, wordt de teller teruggezet op nul en begint het tellen opnieuw. Het uitgangsbit dat bij de timer/teller hoort, wordt omgeschakeld om een blokgolfuitgang te produceren. Deze stuurt direct een audiotransducer aan om een pieptoon te maken. Een kleine TDK Audio Transducer produceert de pieptoon. Een geschikte unit is Digikey 445-2530-ND, TDK SD1209T3-A1 (ik gebruikte een vroege versie hiervan). Dit is een 3 volt uitvoering; de 5 volt versie zal ook werken verwacht ik. Ik stuur dit rechtstreeks van de uitvoerpoort van de Attiny2313 en het lijkt goed te werken. Sparkfun heeft een soortgelijk apparaat.

Stap 6: Timer/Teller 0. configureren

De CTC-modus kan worden gebruikt om de uitgang OC0A op pin 2, poort B (fysieke pin 14) te schakelen. Om output op deze pin mogelijk te maken, moet DDRB correct zijn ingesteld. De C-code hiervoor is net als het instellen van een uitgang voor een knipperlicht. DDRB = _BV(PB2); // Poort B2 is een uitgang. De volgende stap is het leveren van een kloksignaal en het laden van het uitgangsvergelijkingsregister om een golfvorm als frequentie te produceren. De vergelijking voor de resulterende frequentie staat in het datablad (pagina 72). Termen in de vergelijking zullen hieronder worden beschreven. Hier is de vergelijking: fOC0A = fclk_I/O / 2*N*(1+OCR0A)Waar fOC0A:= uitgangsfrequentie fclk_I/O:= klokbronfrequentie N:= klokvoorschaalfactor OCR0A:= waarde in uitvoervergelijkingsregister voor Timer/ Teller 0A. Clock Source Frequency, fclk_I/ODit is de frequentie van de systeemklok. De standaardwaarde is 1 MHz. Bits CS00, CS01 en CS02 van TCCR0B besturen deze selectie. Aangezien deze bits ook de waarde van N selecteren, wordt deze hierna beschreven. Prescaler Value, NN is de waarde die wordt gebruikt om de systeemklok te delen of vooraf te schalen. Bits CS00, CS01 en CS02 van TCCR0B besturen deze selectie. Tabel 41 op pagina 81 van het ATtiny2313 datablad beschrijft de combinaties. Aangezien een frequentie in de buurt van 1 kHz gewenst is, worden bits CS00 en CS01 van TCCR0B ingesteld. Merk op dat het instellen van alle drie de bits op 0, dus het selecteren van geen klokbron, de uitvoer effectief stopt. Dit is de methode die zal worden gebruikt om de pieptoon te starten en te stoppen. TOP-waarde, OCR0ADeze waarde is de TOP-waarde voor de teller die wordt geladen in het uitvoervergelijkingsregister voor timer/teller 0A. Wanneer deze waarde is bereikt, wordt de teller op nul gezet en begint het tellen opnieuw totdat TOP is bereikt en de cyclus wordt herhaald. TOP is eenvoudig aan te passen, dus de frequentie van de pieper is eenvoudig te wijzigen. Aangezien een frequentie in de buurt van 1 kHz gewenst is, is TOP ingesteld op 7. (Let op: de prescaler had op 8 kunnen worden ingesteld en TOP op 63. Hetzelfde resultaat - uw keuze.) Uitgangsfrequentie, fOC0AUDe vergelijking gebruiken om de resultaten van de uitgangsfrequentie te berekenen in: fOC0A = 1, 000, 000 / 2 * 64 * (1+7) fOC0A = 977HzDicht genoeg! Hier is de code om het Output Compare Register en het Timer Counter Control Register 0B te laden. Raadpleeg de eigenlijke programmacode om te begrijpen hoe deze worden gebruikt. OCR0A = 7; // Tijdswaarde TCCR0B = _BV(CS01) | _BV(CS00); // Selecteer interne klok & prescale=8 TCCR0B = 0; // geen klokbron zet toon uit De tijd/teller-modus instellen Als laatste detail specificeren we de gewenste timer/teller-modus door de juiste bits in te stellen in Timer/Counter Control Register 0A. De CTC-modus wordt geselecteerd door bit WGM01 in te stellen zoals beschreven in Tabel 40, pagina 79 van het gegevensblad. Omdat we willen dat de uitvoer elke cyclus omschakelt, moet bit COM0A0 ook worden ingesteld zoals beschreven in Tabel 34 op pagina 77. Dit is de code: TCCR0A = _BV(COM0A0) | _BV(WGM01); // CTC-schakelmodus

Stap 7: Vier schakelaars gebruiken

Laten we, terwijl we de pieper implementeren, onze hardware en software uitbreiden om vier schakelaars aan te kunnen. Aangezien de uitgang van Timer Counter 0A op poort B, pin 2 staat, kunnen we niet zomaar meer schakelaars achter elkaar aansluiten op poort B. Een gemakkelijke oplossing zou zijn om poort D te gebruiken, maar laten we die poort beschikbaar houden voor andere functies (misschien een stappenmotor). Dus laten we de extra schakelaars aansluiten op PB3 en PB4. Het uitlezen van de schakelaars is grotendeels ongewijzigd. De maskerwaarde wordt gewijzigd in 0x1B (00011011 binair) om bit 2 samen met 5, 6 en 7 te maskeren. Er wordt nog een truc gebruikt om een 4-bits binair getal te maken. Verschuif bits 3 en 4 een bit naar rechts en combineer ze met bits 0 en 1 tot een 4-bits binair getal. Dit is de standaard C-syntaxis voor het verschuiven en combineren van bits, maar is misschien niet goed bekend bij de beginner. but1a = (but1 & 0x03) | ((maar1 & 0x18) >> 1); // but1 heeft schakelaaruitlezing Tijdens de werking zal het programma twee keer knipperen en twee keer piepen om initialisatie aan te geven. Telkens wanneer de schakelaars worden gewijzigd, klinkt het nummer dat ze vertegenwoordigen. Als de schakelaars niet veranderen, zal de LED knipperen. Om deze code uit te voeren, maakt u een nieuwe map aan (noem het Beep als u wilt) en downloadt u het volgende C-codebestand en de makefile erin. Hernoem Makefile2.txt naar alleen Makefile. Gebruik WinAVR, compileer het programma en laad het in uw Attiny2313.

Stap 8: De schakelaar/case-constructie gebruiken

De laatste stap is "gewoon software": zoals beloofd, zullen we de switch/case-constructie implementeren. Hoewel dit voorbeeld slechts twee alternatieve acties laat zien, zou het heel duidelijk moeten zijn hoe deze constructie moet worden gebruikt om een van de verschillende alternatieve codesecties te selecteren. In bedrijf controleert dit programma de schakelaars en als er een verandering is, zal het het juiste nummer piepen als het oneven is; het knippert als het getal even is. Het doet niets tenzij een schakelaar verandert.

Om deze code uit te voeren, maakt u een nieuwe map (noem het Switch als u wilt) en downloadt u het volgende C-codebestand en de makefile erin. Hernoem Makefile3.txt naar alleen Makefile. Gebruik WinAVR, compileer het programma en laad het in uw Attiny2313.

Stap 9: Conclusie

Dus dat is het! Nu weet u hoe u schakelaars kunt gebruiken om de uitvoering van uw programma te regelen door ze in te lezen en een actie te selecteren op basis van de schakelaarinstelling. Je weet ook hoe je een pieptoon kunt maken en hebt ook een debug-strategie geleerd.

Als je je begrip wilt testen, probeer dan het laatste programma aan te passen zodat het een hoge pieptoon geeft als het even is, een lage toon als het oneven is en de LED continu knippert als er geen verandering in de schakelaars is. terug naar de sectie over foutopsporing voor hulp.