Leesskakelaars met ATtiny2313: 9 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:28

Daar was verskeie instruksies wat handel oor uitsette van die ATtiny2313 en soortgelyke AVR -toestelle. Byvoorbeeld, https://www.instructables.com/id/Ghetto-Programming%3a-Getting-started-with-AVR-micro/, https://www.instructables.com/id/Drive-a-Stepper- Motor-met-'n-AVR-mikroverwerker/. Ek werk aan die nuutste een van The Real Elliot, wat wys hoe om stappermotors te beheer, en ek het gevind dat dit baie nuttig sou wees om alternatiewe gedeeltes kode in dieselfde program te laat loop, sodat ek nie die ATtiny2313 elk hoef te herprogrammeer nie. Ek wou 'n bietjie kodevariasie probeer (soos om halfstap te stap of om die stepper in trurat te laat loop). Alhoewel dit maklik is om kode te skryf met 'n skakelaar-/saakverklaring om alternatiewe variasies te kies, is 'n manier om die saak te kies, nodig. Dit beteken dat 'n soort invoertoestel gelees moet word om die saak te beheer. Gelukkig het die ATtiny2313 baie I/O-penne en is dit goed ontwerp om insette van skakelaars te lees. Hierdie instruksie sal wys hoe om insette te lees en besluite te neem op grond van hul toestand. Aangesien dit alleen 'n taamlik vervelige instruksie sou wees, sal ek 'n eenvoudige manier verduidelik om die timer/tellerfunksie van die ATtiny2313 te gebruik om 'n klein luidspreker as 'n piep te bestuur. Daar is ook 'n klein afwyking van eenvoudige ontfoutingstegnieke.

Stap 1: Die invoertoestel

Hierdie instruksie bou voort op die uitstekende werk van The Real Elliot en gebruik die ATtiny2313 Ghetto -ontwikkelingstelsel wat hy beskryf. Die ATtiny2313 -gegewensblad van Atmel is die uiteindelike verwysing vir alle funksies, maar dit is nie noodwendig maklik om te lees nie. https://www.atmel.com/dyn/products/datasheets.asp?family_id=607 (Link bevat alle AVR -gegewensblaaie, vind die 2313.) Die figuur toon 'n eenvoudige stel ingangskakelaars. Dit is eenvoudig 'n pakket van vier aan/af skakelaars; ook bekend as enkelpolige, enkel gooi skakelaars (SPST). Gewoonlik word een verbinding, of paal, van elke skakelaar aan die grond vasgemaak terwyl die ander verbinding hoog deur 'n stroombeperkende weerstand (10K of so) getrek word. 'N Mikrokontroleerder -ingang word met die weerstand aan die paal gekoppel. As die skakelaar oop is, sal die mikrobeheerder die invoer as HI lees. As die skakelaar gesluit is, sal die mikrobeheerder die invoer LO lees. Raadpleeg die skematiese inligting vir meer inligting. Die ATtiny2313 vereenvoudig dinge deur programmeerbare optrekweerstands op I/O-penne te verskaf wanneer dit as insette gekonfigureer word. Dit beteken dat die skakelaars eenvoudig een pool aan die grond (LO) en die ander pool aan 'n verwerkeringang kan koppel. Die eerste voorbeeld toon slegs twee skakelaars. Die skakelaars word gelees en gekonfigureer met die volgende kode. Konfigureer die skakelaars as insette: (Geen kode benodig nie; dit is die standaard.) Skakel die optrekweerstands aan: PORTB = _BV (PB0) | _BV (PB1); Lees die insette: but1 = ~ PINB & 0x03; Let op die gebruik van inversie en maskering om die korrekte waarde te kry.

Stap 2: Blinklights vir 'n sein

Ons gebruik hierdie twee skakelaars om 'n programmeerbare aantal kere 'n LED te knip. Die LED's wat ons sal gebruik, is die blinkenligte wat The Real Elliot bekend gemaak het. Skakelaars 1 en 2 word as twee binêre syfers behandel, sodat die kombinasie die getalle 0, 1, 2 en 3. kan verteenwoordig. Ons program sal die twee skakelaars lees en die LED die gepaste aantal kere knip, maar slegs as die skakelaar instellings verander het. Die skakelaars word vir 500 millisekondes afgebreek (nie geoptimaliseer nie). Die debounce -algoritme is redelik eenvoudig. Die skakelaars word gelees en die lesing word opgemerk. As dit verskil van die oldBut -waarde (die laaste gestoorde waarde), word die program 500 millisekondes vertraag en die skakelaars word weer gelees. As die waarde dieselfde is as wat voorheen gelees is, sal die waarde van oldBut opgedateer word en die LED sal die aantal kere wat die binêre waarde van die twee skakelaars impliseer, knip. Let op die inversie van die waarde aangesien 'n skakelaar wat "aan" is, LO aandui. Die skakelaars sal deurlopend geskandeer word vir verdere veranderinge. Raadpleeg vroeër Instructables deur The Real Elliot vir meer inligting oor blinkenlights. Kyk na hierdie https://www.ganssle.com/debouncing.pdf vir meer inligting oor die afskakel van skakelaars. Hier is die ATtiny2313 -kode vir hierdie voorbeeld. In werking sal die program die LED op PB4 (fisiese pen 8) twee keer knip om aan te toon dat dit geïnitialiseer is. Dit sal dan skakelaars een en twee lees, en een tot drie keer knip, afhangende van die skakelaarinstelling wanneer hulle verander word. As die skakelaars nie verander nie, sal die LED stadig knip. Om hierdie kode uit te voer, skep 'n nuwe gids (noem dit "Basic" as u wil) en laai die volgende C -kode lêer af en maak 'n lêer daarin. Hernoem Makefile1.txt na net Makefile. Stel WinAVR op en stel die program saam en laai dit in u ATtiny2313.

Stap 3: 'n Geringe ontleding by ontfouting

As u soos ek (en elke ander programmeerder ter wêreld) is, het u waarskynlik tye beleef dat die 'foutvrye' kode wat u noukeurig ingevoer en saamgestel het nie doen wat u verwag nie. Miskien doen dit eenvoudig niks! So, wat is die probleem? Hoe gaan jy uitvind? Gelukkig is daar verskillende maniere om dinge te laat werk. (Kry hierdie boek vir 'n uitstekende behandeling van die onderwerp ontfouting. Http://www.debuggingrules.com/) Ek wil graag 'n paar eenvoudige voorstelle bied oor die onderwerp van ontfouting van mikrobeheertoepassings. Stap een is om voort te bou op wat jy weet. As u een keer 'n blinkenlight aan die werk gekry het, gebruik dit dan weer om te sien waar u in u program is. Ek hou daarvan om die LED twee keer te laat knip om die begin van die program aan te dui. U kan die kode eers aan die begin van u program invoer. Sodra u weet dat niks met u hardeware verkeerd is nie, kan u 'n funksie skep om te knip. Hier is die funksie wat ek gebruik./*------------------------------------------ ------------------------------ ** blinkEm-funksie om LED met PD4 te knipper ** PD4 moet as uitset gekonfigureer word. ** ------------------------------------------------ ---------------------*/void blinkEm (uint8_t count) {while (count> 0) {PORTD = _BV (PD4); _vertraging_ms (1000); PORTD = ~ _BV (PD4); _vertraging_ms (1000); tel--; }} Dit is nou moontlik om hierdie funksie op verskillende punte in u kode te gebruik as 'n teken dat die kode tot dusver uitgevoer is. As u weet dat die kode werk, beteken dit dat u elke afdeling wat uitgevoer is, noukeurig kan ondersoek, maar nie gedoen het wat u verwag het nie, om foute op te spoor. Om een ding op 'n slag te verander, is ook 'n belangrike tegniek vir ontfouting (beskryf in die verwysing hierbo). Hierdie klassieke metode werk saam met 'verdeel en oorwin': neem babastappe om funksionaliteit geleidelik toe te voeg. Dit lyk miskien na 'n stadige benadering, maar dit is nie naastenby so stadig soos om 'n groot deel van die nie-werkende kode tegelyk te probeer ontfout nie.

Stap 4: Meer ontfouting

Daar is baie kere dat ons 'n gedeelte kode wil kontroleer deur die meeste reëls daarin oor te slaan en dit dan een vir een moontlik te maak terwyl ons verifieer dat elkeen werk. Gewoonlik doen ons dit deur reëls wat ons wil oorslaan, te "kommentaar lewer". 'N Uitbreiding van hierdie tegniek is om 'n blok kode te knip en te plak, die oorspronklike kommentaar te lewer (sodat ons dit nie verloor nie) en die kopie weg te kap. Om '//' voor 'n reël te plaas, gee 'n opmerking oor die reël. Deur een of meer reëls in '/*' en '*/' te sluit, word 'n hele afdeling opgemerk. Om hierdie metode effektief te laat werk, mag daar geen ander "*/" in die kodeblok wees nie (behalwe die eindpunt). 'N Doeltreffende dissipline is dus om // vir kommentaar binne kodeblokke te gebruik, en die / * * / konstruksie te behou vir kommentaarblokke en om kommentaar te lewer op gedeeltes van kode. Plaas "#if 0" aan die begin van 'n blok om kommentaar te lewer en die gedeelte eindig met "#endif". Meer selektiewe beheer is moontlik met behulp van "#ifdef (identifiseerder)" aan die begin van 'n blok en "#endif" aan die einde. As u wil hê dat die blok saamgestel moet word, gebruik '#define (identifier)' vroeër in die program. Let op dat die aanhalingstekens slegs vir nadruk is en dat dit nie ingesluit moet word nie. Die kombinasie van hierdie tegnieke behoort 'n nuttige benadering tot die ontfouting van u ATtiny2313 -programme te bied. U kan hierdie gereedskap nuttig vind as ons deur hierdie instruksies gaan.

Stap 5: Gebruik timer/teller 0 vir piep

Die ATtiny2313 het twee kragtige timer/toonbank hulpbronne: een 8-bis en een 16-bis. Dit kan gekonfigureer word as frekwensieopwekkers, modulêre beheerders vir veranderlike polswydte en registers vir vergelyking van uitsette. Die volledige funksionaliteit hiervan word op 49 bladsye van die gegewensblad beskryf. Ons sal egter 'n eenvoudige saak gebruik. Slegs Timer/Counter 0 (die 8-bis-een) sal gebruik word en dit sal bloot as 'n frekwensiegenerator gebruik word. Die frekwensie word na 'n klein luidspreker gestuur om 'n piep te gee. Timer/Counter 0 word volledig beskryf op bladsye 66 tot 83 van die ATtiny2313 -gegewensblad. Deur hierdie materiaal deeglik te lees, sal u 'n volledige begrip van Time/Counter 0 kry. Gelukkig is 'n redelik eenvoudige modus, Clear Timer on Compare (CTC), alles wat nodig is om die piep toon te gee wat ons wil hê.

Vir die modus wat ons gebruik, is die werking van die timer/teller eenvoudig. As 'n kloksein gekies word, begin die teller op nul en verhoog elke klokpuls. As die tellerwaarde die waarde in die Output Compare Register (TOP) bereik, word die teller teruggestel na nul en begin weer met tel. Die uitsetbit wat met die timer/teller geassosieer word, word aangeskakel om 'n vierkantgolfuitset te lewer. Dit dryf 'n klankopnemer direk om 'n piepgeluid te maak. 'N Klein TDK -klankopnemer gee die piep. 'N Geskikte eenheid is Digikey 445-2530-ND, TDK SD1209T3-A1 (ek het 'n vroeë weergawe hiervan gebruik). Dit is 'n 3 volt weergawe; die 5 volt weergawe sal ook werk, verwag ek. Ek ry dit direk van die uitvoerpoort van die Attiny2313 af en dit lyk asof dit goed werk. Sparkfun het 'n soortgelyke toestel.

Stap 6: Stel timer/teller 0 in

Die CTC -modus kan gebruik word om die uitset OC0A op pen 2, poort B (fisiese pen 14) te skakel. Om die uitvoer van hierdie pen moontlik te maak, moet DDRB gepas wees. Die C -kode hiervoor is net soos die opstel van 'n uitset vir 'n blinkenlight. DDRB = _BV (PB2); // Poort B2 is 'n uitset. Die volgende stap is om 'n kloksignaal te lewer en die uitsetvergelykeregister te laai om 'n golfvorm as 'n frekwensie te lewer. Die vergelyking vir die resulterende frekwensie word in die gegewensblad (bladsy 72) gegee. Terme in die vergelyking sal hieronder beskryf word. Hier is die vergelyking: fOC0A = fclk_I/O/2*N*(1+OCR0A) Waar fOC0A: = uitsetfrekwensie fclk_I/O: = klokbronfrekwensie N: = klokvoorskaalfaktor OCR0A: = waarde in uitset vergelyk register vir Timer/ Teller 0A. Klokbronfrekwensie, fclk_I/O Dit is die frekwensie van die stelselklok. Die standaardwaarde is 1MHz. Bits CS00, CS01 en CS02 van TCCR0B beheer hierdie keuse. Aangesien hierdie stukkies ook die waarde van N kies, word dit vervolgens beskryf. Voorverkoopwaarde, NN is die waarde wat gebruik word om die stelselklok te verdeel of te voorskaal. Bits CS00, CS01 en CS02 van TCCR0B beheer hierdie keuse. Tabel 41 op bladsy 81 van die ATtiny2313 -gegewensblad beskryf die kombinasies. Aangesien 'n frekwensie naby 1kHz verlang word, word bits CS00 en CS01 van TCCR0B ingestel. Let daarop dat al drie bisse op 0 gestel word, dus geen klokbron gekies word nie, die uitset effektief stop. Dit is die metode wat gebruik sal word om die piep te begin en te stop. TOP Waarde, OCR0A Hierdie waarde is die TOP waarde vir die teller wat in die Output Compare Register vir Timer/Counter 0A gelaai word. As hierdie waarde bereik word, word die teller op nul teruggestel en begin weer tel totdat TOP bereik is en die siklus herhaal word. TOP kan maklik verander word, so die frekwensie van die piep kan maklik verander word. Aangesien 'n frekwensie naby 1kHz verlang word, word TOP op 7. gestel (let op dat die voorskaler op 8 en TOP op 63 gestel het. Dieselfde resultaat - u keuse.) Uitvoerfrekwensie, fOC0A Gebruik die vergelyking om die uitsetfrekwensie -resultate te bereken in: fOC0A = 1, 000, 000 /2 * 64 * (1+7) fOC0A = 977Hz Maak genoeg! Hier is die kode om die Output Compare Register en die Timer Counter Control Register 0B te laai. Sien die werklike programkode om te verstaan hoe dit gebruik word. OCR0A = 7; // Tydwaarde TCCR0B = _BV (CS01) | _BV (CS00); // Kies interne klok & prescale = 8 TCCR0B = 0; // geen klokbron skakel die toon af nie Stel die tyd-/tellermodus in As 'n laaste detail, sal ons die tydteller/tellermodus spesifiseer wat ons verlang deur die toepaslike stukkies in die timer-/tellerbeheerregister 0A in te stel. Die CTC -modus word gekies deur bit WGM01 in te stel soos beskryf in tabel 40, bladsy 79 van die datablad. Aangesien ons wil hê dat die uitset elke siklus moet wissel, moet bit COM0A0 ook gestel word soos beskryf in tabel 34 op bladsy 77. Hier is die kode: TCCR0A = _BV (COM0A0) | _BV (WGM01); // CTC -skakelmodus

Stap 7: Gebruik vier skakelaars

Terwyl ons die pieper implementeer, laat ons ons hardeware en sagteware uitbrei om vier skakelaars te hanteer. Aangesien die uitset van Timer Counter 0A op poort B, pen 2 is, kan ons nie meer meer skakelaars agtereenvolgens aansluit by poort B. 'n Maklike oplossing sou wees om poort D te gebruik, maar laat ons die poort vir ander funksies beskikbaar hou (miskien 'n stapmotor). Laat ons dus die ekstra skakelaars aansluit by PB3 en PB4. Die lees van die skakelaars is meestal onveranderd. Die maskerwaarde word verander na 0x1B (00011011 binêre) na bit 2 saam met 5, 6 en 7. 'n Verdere truuk word gebruik om 'n 4-bis binêre getal te skep. Skuif stukkies 3 en 4 regs een bis en kombineer dit met bisse 0 en 1 in 'n 4 bis binêre getal. Dit is 'n standaard C -sintaksis vir die verskuiwing en kombinasie van stukkies, maar dit is moontlik nie goed bekend vir die beginner nie. but1a = (but1 & 0x03) | ((but1 & 0x18) >> 1); // but1 het skakelaarlesing In werking, sal die program twee keer knip en twee keer piep om die inisialisering aan te dui. Elke keer as die skakelaars verander word, word die nommer wat hulle verteenwoordig, gepiep. As die skakelaars nie verander nie, sal die LED knipper. Om hierdie kode uit te voer, skep 'n nuwe gids (noem dit piep as u wil) en laai die volgende C -kode lêer af en maak 'n lêer daarin. Hernoem Makefile2.txt na net Makefile. Stel die program saam met WinAVR en laai dit in u Attiny2313.

Stap 8: Gebruik die skakelaar/omhulselkonstruksie

Die laaste stap is 'net sagteware': soos belowe, implementeer ons die skakelaar/kas -konstruksie. Alhoewel hierdie voorbeeld slegs twee alternatiewe aksies toon, moet dit baie duidelik wees hoe om hierdie konstruk te gebruik om een van die verskillende alternatiewe kodeseksies te kies. In werking, monitor hierdie program die skakelaars en as daar 'n verandering is, sal dit die gepaste nommer piep as dit vreemd is; dit sal knip as die getal gelyk is. Dit doen niks tensy 'n skakelaar verander nie.

Om hierdie kode uit te voer, skep 'n nuwe gids (noem dit Switch as u wil) en laai die volgende C -kode lêer af en maak 'n lêer daarin. Hernoem Makefile3.txt na net Makefile. Stel die program saam met WinAVR en laai dit in u Attiny2313.

Stap 9: Gevolgtrekking

So dit is dit! Nou weet u hoe om skakelaars te gebruik om die uitvoering van u program te beheer deur dit in te lees en 'n aksie te kies op grond van die skakelaarinstelling. U weet ook hoe u 'n pieptoon kan skep, en u het ook 'n paar ontfoutingstrategie geleer.

As u u begrip wil toets, probeer om die laaste program aan te pas om op 'n hoë toon te piep, selfs as dit 'n lae noot is, en knip die LED voortdurend as die skakelaars nie verander nie. terug na die afdeling oor ontfouting vir hulp.