AVR Assembler Tutorial 9: 7 stappen

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

Welkom bij les 9.

Vandaag laten we zien hoe u zowel een 7-segments display als een 4-cijferig display kunt bedienen met behulp van onze ATmega328P en AVR assembleertaalcode. Terwijl we dit doen, zullen we omleidingen moeten nemen om de stapel te gebruiken om het aantal registers dat we moeten vastbinden te verminderen. We zullen een paar condensatoren (laagdoorlaatfilters) toevoegen om te proberen de ruis op ons toetsenbord te verminderen. We zullen een spanningsversterker maken van een paar transistors, zodat onze INT0-onderbrekingsschakelaar beter werkt voor de lagere spanningsknoppen op de onderste rij van het toetsenbord. En we zullen een beetje met onze kop tegen de muur bonzen om de juiste weerstanden te krijgen, zodat het ding goed werkt.

We gebruiken ons toetsenbord uit Tutorial 7

Om deze tutorial te doen, heb je naast de standaard dingen nodig:

1. Een 7-segments display

   www.sparkfun.com/products/8546

2. Een 4-cijferig display

   www.sparkfun.com/products/11407

3. een drukknop

   www.sparkfun.com/products/97

4. De datasheets voor het display die kunnen worden gedownload van hun respectievelijke pagina's waarnaar hierboven is gelinkt.
5. Een keramische condensator van 68 pf, een paar 104 condensatoren, een heleboel weerstanden, twee 2N3904 NPN-transistoren.

Hier is een link naar de volledige verzameling van mijn AVR-assembler-tutorials:

Stap 1: Bedrading van het 7-seg-display

We gaan dezelfde code gebruiken die we in Tutorial 7 hebben gebruikt voor het toetsenbord om het 7-segments display te bedienen. U moet daar dus een kopie van maken en wij zullen het aanpassen.

We zullen de segmenten als volgt toewijzen aan de pinnen van onze microcontroller:

(dp, g, f, e, d, c, b, a) = (PD7, PD6, PB5, PB4, PB3, PB2, PB1, PB0)

waar de letters van de segmenten in de afbeelding worden weergegeven, samen met de pinout die overeenkomt met gewone 5V en elk van de LED-segmenten inclusief de komma (dp) rechtsonder in het scherm. De reden hiervoor is dat we het hele nummer in een enkel register kunnen invoeren en dat register kunnen uitvoeren naar poorten B en D om de segmenten te verlichten. Zoals u kunt zien, zijn de bits opeenvolgend genummerd van 0 tot 7 en worden ze dus toegewezen aan de juiste pinnen zonder dat u afzonderlijke bits hoeft in te stellen en te wissen.

Zoals je kunt zien aan de code die we in de volgende stap hebben toegevoegd, hebben we onze weergaveroutine naar een macro verplaatst en hebben we de SDA- en SCL-pinnen vrijgemaakt voor toekomstig gebruik in de volgende zelfstudie.

Ik moet hieraan toevoegen dat je een weerstand moet plaatsen tussen de gemeenschappelijke anode van het display en de 5V-rail. Ik koos zoals gewoonlijk voor een weerstand van 330 ohm, maar als je wilt, kun je de minimale weerstand berekenen die nodig is om de maximale helderheid uit het scherm te krijgen zonder het te braden. Hier is hoe dat te doen:

Kijk eerst naar het gegevensblad en merk op dat het op de eerste pagina verschillende eigenschappen van het display geeft. De belangrijke grootheden zijn de "Forward Current" (I_f = 20mA) en de "Forward Voltage" (V_f = 2.2V). Deze vertellen u dat de spanningsval over het scherm zal zijn als de stroom gelijk is aan de voorwaartse stroom. Dit is de maximale stroom die het display kan opnemen zonder te braden. Het is dus ook de maximale helderheid die je uit de segmenten kunt halen.

Laten we dus de wet van Ohm en de lusregel van Kirchoff gebruiken om erachter te komen welke minimale weerstand we in serie met het scherm zouden moeten zetten om de maximale helderheid te krijgen. De regel van Kirchoff zegt dat de som van de spanningsveranderingen rond een gesloten lus in een circuit gelijk is aan nul en de wet van Ohm zegt dat de spanningsval over een weerstand met weerstand R is: V = I R waarbij I de stroom is die door de weerstand vloeit.

Dus gegeven een bronspanning van V en rond ons circuit gaan we:

V - V_f - IK R = 0

wat betekent (V - V_f)/I = R. Dus de weerstand die nodig is om de maximale helderheid te krijgen (en waarschijnlijk de segmenten te braden) zou zijn:

R = (V - V_f)/I_f = (5,0V - 2,2V)/0,02A = 140 ohm

Dus als je zou willen, zou je zonder zorgen 150 ohm kunnen gebruiken. Ik denk echter dat 140 ohm het naar mijn smaak te helder maakt en daarom gebruik ik 330 ohm (wat een soort van mijn persoonlijke Goldilocks-weerstand is voor LED's)

Stap 2: Montagecode en video

Ik heb de montagecode bijgevoegd en een video die de werking van het toetsenbord met het display laat zien. Zoals u kunt zien, hebben we de Redial-toets eenvoudig toegewezen aan "r", de flash-toets aan "F", de asterisk aan "A" en het hekje aan "H". Deze kunnen worden toegewezen aan verschillende bewerkingen zoals backspace, enter en wat niet als u het toetsenbord wilt blijven gebruiken voor het typen van cijfers op LCD-schermen of 4-cijferige schermen. Ik zal de code deze keer niet regel voor regel doornemen, omdat het erg lijkt op wat we al in eerdere tutorials hebben gedaan. De verschillen zijn vooral meer van dezelfde dingen die we al weten, zoals interrupts en opzoektabellen. Je moet gewoon de code doornemen en kijken naar de nieuwe dingen die we hebben toegevoegd en de dingen die we hebben veranderd en het vanaf daar uitzoeken. We gaan terug naar de regel-voor-regel analyse in de volgende zelfstudie wanneer we nieuwe aspecten van assembleertaalcodering op AVR-microcontrollers introduceren.

Laten we nu kijken naar een 4-cijferig display.

Stap 3: Bedrading van het 4-cijferige display

Volgens de datasheet heeft het 4-cijferige display een voorwaartse stroom van 60 mA en een voorwaartse spanning van 2,2 volt. Dus, volgens dezelfde berekening als voorheen, zou ik een weerstand van 47 ohm kunnen gebruiken als ik dat wilde. In plaats daarvan ga ik een… hrm.. eens kijken… wat dacht je van 330 ohm.

De manier waarop het 4-cijferige display is bedraad, is dat er 4 anodes zijn, één voor elk van de cijfers, en de andere pinnen bepalen welk segment in elk wordt weergegeven. U kunt 4 cijfers tegelijk weergeven omdat ze gemultiplext zijn. Met andere woorden, net zoals we deden voor het paar dobbelstenen, laten we de stroom eenvoudig om de beurt door elk van de anodes gaan en het zal ze een voor een laten knipperen. Het zal dit zo snel doen dat onze ogen het knipperen niet zullen zien en het zal lijken alsof alle vier de cijfers aan staan. Maar om zeker te zijn, de manier waarop we het coderen is om alle vier de cijfers in te stellen en vervolgens de anodes te laten draaien, in plaats van in te stellen, te verplaatsen, in te stellen, te verplaatsen, enz. Op die manier kunnen we een precieze timing krijgen tussen het oplichten van elk cijfer.

Laten we voor nu testen of de segmenten allemaal werken.

Plaats uw weerstand van 330 ohm tussen de positieve rail van uw breadboard en de eerste anode op het display. De datasheet vertelt ons dat de pinnen zijn genummerd van 1 tot 16 tegen de klok in beginnend linksonder (als je normaal naar het scherm kijkt… met de decimale punten onderaan) en er staat dat de anodes pinnummers 6 zijn., 8, 9 en 12.

Dus we verbinden pin 6 met 5V en nemen dan een negatieve kabel van je GND-rail en steken deze in alle andere pinnen en zien dat alle segmenten oplichten op het cijfer waarmee het overeenkomt (wat eigenlijk het tweede cijfer is van het recht). Zorg ervoor dat alle 7 segmenten en de komma oplichten.

Steek nu je GND-draad in een van de pinnen om een van de segmenten te verlichten en verplaats deze keer de weerstand naar de andere 3 anodes en zie dat hetzelfde segment oplicht in elk van de andere cijfers.

Iets ongewoons?

Het blijkt dat de pinout op de datasheet niet klopt. Dit komt omdat het de datasheet en pinout is voor een 12-pins, 4-cijferig display. D.w.z. een zonder dubbele punt of bovenste decimale punt. Het display dat ik kreeg toen ik het bestelde, is een 16-pins, 4-cijferig display. In feite bevinden de segmentanodes zich op de mijne op pinnen 1, 2, 6 en 8. De dubbele puntanode is pin 4 (kathodepin 12) en de bovenste dp-anode is pin 10 (kathode is pin 9)

Oefening 1: Gebruik je weerstand en aarddraad om in kaart te brengen welke pin overeenkomt met welk segment en decimaalteken op het display, zodat we de juiste segmenten oplichten wanneer we het coderen.

De manier waarop we de segmentkaart willen coderen is precies zoals we deden met de eencijferige 7-segments display hierboven -- we hoeven niets in de code te veranderen, het enige dat we veranderen is hoe de draden zijn aangesloten op het bord. Sluit gewoon de juiste poortpin op de microcontroller aan op de corresponderende pin op het 4-cijferige display, zodat bijvoorbeeld PB0 nog steeds naar de pin gaat die overeenkomt met segment a, PB1 naar segment B gaat, enz.

Het enige verschil is dat we nu 4 extra pinnen nodig hebben voor de anodes aangezien we niet meer zomaar naar de 5V rail kunnen. We hebben de microcontroller nodig om te beslissen welk cijfer het sap krijgt.

Dus we zullen PC1, PC2, PC3 en PD4 gebruiken om de anodes van de 4 cijfers te besturen.

Je kunt net zo goed doorgaan en de draden aansluiten. (vergeet de weerstanden van 330 ohm op de anodedraden niet!)

Stap 4: Het 4-cijferige display coderen

Laten we nadenken over hoe we dit scherm willen coderen.

We willen dat de gebruiker op de toetsen op het toetsenbord drukt en dat de nummers opeenvolgend op het display verschijnen als ze op elke knop drukken. Dus als ik op een 1 druk, gevolgd door een 2, wordt het op het display weergegeven als 12. Ik zou ook die waarde, 12, willen opslaan voor intern gebruik, maar daar komen we later op terug. Voor nu wil ik gewoon een nieuwe macro schrijven die je toetsaanslagen neemt en ze weergeeft. Omdat we echter maar 4 cijfers hebben, wil ik ervoor zorgen dat u slechts vier cijfers kunt typen.

Een ander probleem is dat de manier waarop het gemultiplexte 4-cijferige display werkt, is door de anodes te laten draaien, zodat elk cijfer slechts een fractie van een seconde aan is voordat het de volgende en dan de volgende weergeeft en uiteindelijk weer terug naar de eerste, enz. Dus we een manier nodig om dit te coderen.

We willen ook dat de "cursor" een spatie naar rechts verplaatst wanneer we het volgende cijfer typen. Zodat als ik bijvoorbeeld 1234 wil typen, nadat ik de 1 heb getypt, de cursor zal bewegen zodat het volgende cijfer dat ik typ op het volgende 7-segments display verschijnt, enzovoort. Terwijl dit gebeurt, wil ik nog steeds kunnen zien wat ik heb getypt, dus het moet nog steeds door de cijfers bladeren en ze weergeven.

Klinkt als een grote opdracht?

Dingen zijn eigenlijk nog erger. We hebben 4 meer algemene registers nodig die we kunnen gebruiken om de huidige waarden op te slaan van de 4 cijfers die we willen weergeven (als we er doorheen gaan, moeten we ze ergens opslaan) en het probleem hiermee is dat we gebruikt als een gek registers voor algemene doeleinden en als we niet oppassen, hebben we er geen meer over. Het is dus waarschijnlijk een goed idee om dat probleem eerder vroeger dan later aan te pakken en u te laten zien hoe u registers kunt vrijmaken met behulp van de stapel.

Dus laten we beginnen met de dingen een beetje te vereenvoudigen, de stapel te gebruiken en wat registers vrij te maken en dan zullen we proberen de taak te volbrengen om onze nummers te lezen en weer te geven op het 4-cijferige display.

Stap 5: Push 'n Pop

Er zijn slechts een paar "General Purpose Registers" die we tot onze beschikking hebben en als ze eenmaal zijn gebruikt, zijn er geen meer. Het is dus een goede programmeerpraktijk om ze alleen te gebruiken voor een paar variabelen die worden gebruikt als tijdelijke opslag die u nodig hebt voor het lezen van en schrijven naar poorten en SRAM met, of anders die u overal in subroutines nodig zult hebben en dus u noem ze. Dus wat ik heb gedaan, nu we de Stack hebben geïnitialiseerd en leren gebruiken, is door de code te gaan en de genoemde registers voor algemene doeleinden te vinden die alleen binnen een enkele subroutine of interrupt worden gebruikt en nergens anders in de code en vervangen ze met een van onze tijdelijke registers en een push en pop naar de stapel. Als je kijkt naar code die is geschreven voor kleinere microcontrollers, of als je teruggaat in de tijd naar toen alle chips kleiner waren, zie je slechts een paar registers voor algemene doeleinden die voor alles moesten worden gebruikt, dus je kon niet sla daar gewoon een waarde op en laat het met rust, omdat je zeker weet dat je dat register voor andere dingen nodig hebt. Dus je zult overal in de code pushin' en een poppin' zien. Misschien had ik onze tijdelijke registers voor algemene doeleinden AX en BX moeten noemen als een respectvol eerbetoon aan die vervlogen tijden.

Een voorbeeld zal dit duidelijker maken.

Merk op dat we in onze analoog naar digitaal conversie complete interrupt ADC_int een register voor algemene doeleinden gebruiken dat we buttonH hebben genoemd en dat we hebben gebruikt om de waarde van ADCH te laden en deze te vergelijken met onze opzoektabel van analoog naar knoppersconversies. We gebruiken dit buttonH register alleen binnen de ADC_int subroutine en nergens anders. Dus in plaats daarvan zullen we onze variabele temp2 gebruiken die we gebruiken als een tijdelijke variabele die we binnen een bepaalde subroutine kunnen gebruiken en de waarde ervan heeft geen invloed op iets buiten die subroutine (dwz de waarde die we eraan geven in ADC_int zal nergens worden gebruikt anders).

Een ander voorbeeld is in onze vertragingsmacro. We hebben een register dat we "milliseconden" hebben genoemd en dat onze vertragingstijd in milliseconden bevat. In dit geval zit het in een macro en we herinneren ons dat de manier waarop macro werkt, is dat de assembler de hele macrocode op de plek van het programma plaatst waar het wordt aangeroepen. In dit geval willen we de variabele "milliseconden" verwijderen en vervangen door een van onze tijdelijke variabelen. In dit geval zal ik het een beetje anders doen om je te laten zien hoe, zelfs als de waarde van de variabele ergens anders nodig zal zijn, we deze nog steeds kunnen gebruiken door de stapel te gebruiken. Dus in plaats van milliseconden gebruiken we "temp" en om te voorkomen dat we andere dingen verknoeien die ook de waarde van temp gebruiken, beginnen we gewoon de "delay"-macro door temp op de stapel te "duwen", dan gebruiken we het in plaats van milliseconden, en dan "poppen" we aan het einde van de macro de vorige waarde terug van de stapel.

Het netto resultaat is dat we temp en temp2 hebben "geleend" voor tijdelijk gebruik en ze vervolgens hebben hersteld naar hun vorige waarden wanneer we klaar zijn.

Hier is de ADC_int interrupt-routine na het aanbrengen van deze wijziging:

ADC_int:

druk temp; save temp aangezien we het hier wijzigen push temp2; bewaar temp2 lds temp2, ADCH; toetsdruk laden ldi ZH, hoog (2*cijfers) ldi ZL, laag (2*cijfers) cpi temp2, 0 breq return; als ruistriggers niet veranderen 7segnummer setkey: lpm temp, Z+; laden uit tabel en post increment clc cp temp2, temp; vergelijk toetsaanslag met de tabel brlo PC+4; als ADCH lager is, probeer het dan opnieuw lpm 7segnumber, Z; laad anders sleutelwaardetabel incl. cijfer; verhoog het cijfernummer rjmp return; en retourneer adiw ZH:ZL, 1; increment Z rjmp setkey; en ga terug naar boven return: pop temp2; herstel temp2 poptemp; herstel temp reti

Merk op dat de manier waarop de stapel werkt, is dat de eerste aan de laatste is. Net als een stapel papieren. Je ziet dat we in onze eerste twee regels de waarde van temp op de stapel duwen, dan duwen we temp2 op de stapel, dan gebruiken we ze in de subroutine voor andere dingen, en tenslotte herstellen we ze weer naar hun vorige waarden door eerst temp2 uitzetten (aangezien het de laatste was die erop werd geduwd, staat het bovenaan de stapel en zal de eerste zijn die we er weer uit laten springen) en dan temp.

Dus vanaf nu zullen we altijd deze methode gebruiken. De enige keer dat we een register daadwerkelijk aanwijzen voor iets anders dan een tijdelijke variabele, is wanneer we het overal nodig zullen hebben. Het register genaamd "overflows" is er bijvoorbeeld een dat we op verschillende plaatsen in het programma gebruiken en daarom willen we het een naam geven. Natuurlijk kunnen we het nog steeds gebruiken zoals we hebben gedaan met temp en temp2, omdat we de waarde ervan zouden herstellen nadat we klaar waren. Maar dat zou de zaken te veel op de spits drijven. Ze zijn niet voor niets zo genoemd en we hebben uitzendkracht en uitzendkracht2 al aangewezen voor die functie.

Stap 6: Laagdoorlaatfilters en spanningsversterker

Om de ruis een beetje op te ruimen en ons toetsenbord beter te laten werken, willen we een paar laagdoorlaatfilters toevoegen. Deze filteren de hoogfrequente ruis en laten het laagfrequente signaal door. In wezen is de manier om dit te doen eenvoudigweg een condensator van 68 pf toe te voegen tussen onze analoge ingang en aarde en ook een condensator van 0,1 microfarad (d.w.z. 104) tussen onze PD4 (INT0) interrupt en aarde. Als je hiermee speelt terwijl je op knoppen op het toetsenbord drukt, kun je zien wat ze doen.

Vervolgens willen we een spanningsversterker maken. Het blijkt dat de onderste rij toetsen op het toetsenbord (evenals de herkiestoets) een te lage spanning afgeven om de INT0-interrupt uit te schakelen. De analoge poort is gevoelig genoeg om de lage spanningen van deze toetsen te lezen, maar onze interrupt-pin krijgt niet voldoende stijgende flank om te onderbreken wanneer we op die toetsen drukken. Daarom willen we op een of andere manier ervoor zorgen dat een mooie stijgende spanningsflank PD4 raakt, maar dezelfde lage spanning ADC0 raakt. Dit is een vrij grote opdracht, aangezien beide signalen afkomstig zijn van dezelfde uitgangsdraad van ons toetsenbord. Er zijn een aantal geavanceerde manieren om dit te doen, maar we zullen ons toetsenbord na deze tutorial niet meer gebruiken, dus laten we gewoon een methode samenvoegen die (nauwelijks) werkt.

U moet eerst een externe knop aansluiten om de INT0-interrupt te vervangen en het display te bedienen door een toets op het toetsenbord ingedrukt te houden en op de knop te klikken. Hierdoor zijn er minder toetsenbordproblemen en kunt u erop vertrouwen dat uw spanningen correct zijn ingesteld in de opzoektabel van het toetsenbord. Zodra u weet dat het toetsenbord correct is aangesloten, verwijdert u de knop en plaatst u de INT0-interrupt terug. Er zijn serieuze geluids- en spanningsproblemen die het toetsenbord op deze manier besturen, dus het is goed om te weten dat alles werkt, zodat toekomstige problemen kunnen worden geïsoleerd op de INT0-toets.

Wanneer u uw toetsenbord en uw spanningsversterker bedraden, is het zeer waarschijnlijk dat dezelfde weerstandswaarden die ik heb gebruikt niet zullen werken. U zult dus wat moeten experimenteren om waarden te krijgen die voor u werken.

Als je naar het diagram kijkt dat ik bij deze stap heb gevoegd, zul je zien hoe de spanningsversterker gaat werken. We gebruiken enkele weerstanden en twee transistoren. De manier waarop transistors werken (zie de gegevensbladen!) Is dat er een minimale spanning is die u moet invoeren in de basispin op de transister (de middelste pin) die deze zal verzadigen en stroom tussen de collectorpin en de emitter zal laten vloeien pin. In het geval van de 2N3904-transistor die we hier gebruiken, is de spanning 0,65V. Nu nemen we die spanning van onze output van het toetsenbord en we willen die output niet veranderen, dus zullen we een grote weerstand plaatsen tussen de output van het toetsenbord en de basis van de eerste transistor (ik gebruikte 1 Mohm). Ik heb dit in het diagram aangeduid als R_1. Dan willen we een spanningsdeler opzetten zodat de basis van de transistor al "bijna" op 0,65 volt staat en slechts een heel klein beetje meer zal hem over de top duwen en verzadigen. Dat piepkleine stukje komt uit de uitgang van het toetsenbord als we op een knop drukken. Omdat de onderste toetsen op het toetsenbord slechts een kleine spanning afgeven, moeten we al heel dicht bij verzadiging zijn om voldoende te zijn. De spanningsdelerweerstanden zijn in het diagram gelabeld met R_a en R_b. Ik heb R_a = 1Mohm en R_b = 560Kohm gebruikt, maar het is vrijwel zeker dat je met deze getallen moet spelen om het goed te krijgen voor je setup. Misschien wil je een muur in de buurt hebben om je hoofd tegen te stoten en twee of drie glazen whisky bij de hand (ik zou Laphroaig aanraden - duur, maar de moeite waard als je van rook houdt. Als het echt krankzinnig wordt, koop dan gewoon een kan van BV en regelen voor de nacht)

Laten we nu eens kijken hoe de transistors ons een mooie stijgende flank zullen geven die naar de INT0-toets gaat en onze toetsdrukonderbreking genereert. Laten we eerst eens kijken wat er gebeurt als ik geen toets indruk. In dat geval staat de eerste transistor (met T1 in het schema) uit. Er loopt dus geen stroom tussen de collector- en emitterpennen. Dus de basis van de andere transistor (met het label T2) zal hoog worden getrokken en dus zal deze verzadigen, waardoor stroom tussen de pinnen kan vloeien. Dit betekent dat de emitter van T2 laag zal worden getrokken omdat deze is verbonden met de collector die zelf is verbonden met aarde. De uitvoer die naar onze INT0-toetsdrukonderbrekingspen (PD4) gaat, zal dus laag zijn en er zal geen onderbreking zijn.

Wat gebeurt er als ik op een toets druk? Welnu, dan gaat de basis van T1 boven 0,65V (in het geval van de lagere toetsen gaat het maar nauwelijks boven!) en dan zal er stroom kunnen vloeien die de basis van T2 naar een lage spanning zal trekken en dit zal T2 uitschakelen. Maar we zien dat wanneer T2 uit is, de output hoog wordt getrokken en daarom krijgen we een 5V-signaal naar onze INT0-pin en dit zal een interrupt veroorzaken.

Merk op wat hier het netto resultaat is. Als we op de 1-toets drukken, krijgen we 5V die naar PD4 gaat zonder de uitvoer aanzienlijk te veranderen naar ADC0, en nog belangrijker, zelfs als we op Asterisk, 0, Hash of Redial drukken, krijgen we ook een 5V-signaal dat naar INT0 gaat en ook een onderbreking veroorzaken! Dit is belangrijk, want als we gewoon rechtstreeks van de toetsenborduitgang naar de INT0-pin gaan, genereren die toetsen bijna geen spanning en zullen ze niet genoeg zijn om die interrupt-pin te activeren. Onze spanningsversterker heeft dit probleem opgelost.

Stap 7: 4-cijferige displaycode en video

Dat is alles voor les 9! Ik heb de code bijgevoegd en een video die de operatie laat zien.

Dit is de laatste keer dat we het analoge toetsenbord gebruiken (godzijdank). Het was moeilijk te gebruiken, maar het was ook erg handig om ons te helpen meer te weten te komen over analoog-naar-digitaal conversie, analoge poorten, interrupts, multiplexing, ruisfilters, spanningsversterkers en vele aspecten van assemblagecodering van opzoektabellen tot timer/tellers, enz. Daarom hebben we besloten om het te gebruiken. (plus het is leuk om dingen op te ruimen).

Nu gaan we weer naar communicatie kijken en onze 7-segment en onze 4-cijferige displays krijgen om onze dobbelstenen uit te lezen van onze dobbelsteenroller op dezelfde manier als we deden met onze registeranalysator. Deze keer zullen we de tweedraadsinterface gebruiken in plaats van onze gehackte morsecodemethode.

Zodra de communicatie werkt en de rollen op de displays verschijnen, kunnen we eindelijk het eerste stuk van ons eindproduct maken. Je zult merken dat zonder al het analoge poortmateriaal onze code aanzienlijk korter en waarschijnlijk gemakkelijker te lezen zal zijn.

Voor degenen onder u die ambitieus zijn. Hier is een "project" dat je zou kunnen proberen en waarvan je op dit moment zeker de kennis hebt om het te doen als je al deze tutorials tot nu toe hebt doorlopen:

Project: Maak een rekenmachine! Gebruik ons 4-cijferige display en ons toetsenbord en voeg een externe druk op de knop toe die werkt als een "enter" -toets. Wijs de asterisk toe aan "tijden", de hash om het opnieuw kiezen te "delen" naar "plus" en de flitser naar "min" en schrijf een rekenmachineroutine die werkt als een van die oude HP "reverse polish" rekenmachines die alle ingenieurs hadden vroeger. D.w.z. de manier waarop ze werken is dat je een nummer invoert en op "enter" drukt. Dit duwt dat nummer op de stapel, dan voer je een tweede nummer in en druk je op "enter", wat het tweede nummer op de stapel duwt. Ten slotte drukt u op een van de bewerkingen zoals X, /, + of - en het zal die bewerking toepassen op de bovenste twee getallen op de stapel, het resultaat weergeven en het resultaat op de stapel duwen zodat u het opnieuw kunt gebruiken als u Leuk vinden. Om bijvoorbeeld 2+3 toe te voegen, doet u: 2, "enter", 3, "enter", "+" en op het display staat dan 5. U weet hoe u de stapel, het display, het toetsenbord en u moet gebruiken. hebben de meeste achtergrondcode al geschreven. Voeg gewoon de enter-toets en de subroutines toe die nodig zijn voor de rekenmachine. Het is iets ingewikkelder dan je in eerste instantie zou denken, maar het is leuk en goed te doen.

Tot de volgende keer!