Tutorial Assembler AVR 9: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 09:59

Benvenuto nell'esercitazione 9.

Oggi mostreremo come controllare sia un display a 7 segmenti che un display a 4 cifre utilizzando il nostro codice in linguaggio assembly ATmega328P e AVR. Nel fare ciò dovremo prendere deviazioni su come utilizzare lo stack per ridurre il numero di registri che dobbiamo legare. Aggiungeremo un paio di condensatori (filtri passa basso) per cercare di ridurre il rumore sulla nostra tastiera. Creeremo un amplificatore di tensione da un paio di transistor in modo che il nostro interruttore di interruzione INT0 funzioni meglio per i pulsanti a tensione inferiore sulla riga inferiore della tastiera. E sbatteremo un po' la testa contro il muro cercando di ottenere i resistori corretti in modo che la cosa funzioni correttamente.

Useremo la nostra tastiera dal Tutorial 7

Per fare questo tutorial, oltre alle cose standard, avrai bisogno di:

1. Un display a 7 segmenti

   www.sparkfun.com/products/8546

2. Un display a 4 cifre

   www.sparkfun.com/products/11407

3. Un pulsante

   www.sparkfun.com/products/97

4. Le schede tecniche del display scaricabili dalle rispettive pagine linkate sopra.
5. Un condensatore ceramico da 68 pf, una coppia di 104 condensatori, un gruppo di resistori, due transistor NPN 2N3904.

Ecco un link alla raccolta completa dei miei tutorial sull'assemblatore AVR:

Passaggio 1: cablaggio del display a 7 segmenti

Useremo lo stesso codice che abbiamo usato nel Tutorial 7 per la tastiera per controllare il display a 7 segmenti. Quindi dovrai farne una copia e noi la modificheremo.

Mapperemo i segmenti ai pin del nostro microcontrollore come segue:

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

dove in figura sono mostrate le lettere dei segmenti insieme al pinout corrispondente al comune 5V e ciascuno dei segmenti LED compreso il punto decimale (dp) in basso a destra del display. La ragione di ciò è che possiamo inserire l'intero numero in un singolo registro e inviare quel registro alle porte B e D per illuminare i segmenti. Come puoi vedere i bit sono numerati in sequenza da 0 a 7 e quindi verranno mappati ai pin corretti senza dover impostare e cancellare i singoli bit.

Come puoi vedere dal codice che abbiamo allegato nel passaggio successivo, abbiamo spostato la nostra routine di visualizzazione su una macro e abbiamo liberato i pin SDA e SCL per un uso futuro nel prossimo tutorial.

Aggiungo che è necessario inserire un resistore tra l'anodo comune del display e il binario 5V. Ho scelto come al solito una resistenza da 330 ohm ma volendo potresti calcolare la resistenza minima necessaria per ottenere la massima luminosità dal display senza friggerlo. Ecco come farlo:

Prima guarda la scheda tecnica e nota che nella prima pagina fornisce varie proprietà del display. Le grandezze importanti sono la "Forward Current" (I_f = 20mA) e la "Forward Voltage" (V_f = 2.2V). Questi dicono che vuoi che la caduta di tensione sul display sia se la corrente è uguale alla corrente diretta. Questa è la corrente massima che il display assumerà senza friggere. Di conseguenza è anche la massima luminosità che si può ottenere dai segmenti.

Usiamo quindi la legge di Ohm e la regola del loop di Kirchoff per capire quale resistenza minima avremmo bisogno di mettere in serie al display per ottenere la massima luminosità. La regola di Kirchoff dice che la somma delle variazioni di tensione attorno a un circuito chiuso in un circuito è uguale a zero e la legge di Ohm dice che la caduta di tensione attraverso un resistore di resistenza R è: V = I R dove I è la corrente che scorre attraverso il resistore.

Quindi data una tensione sorgente di V e girando intorno al nostro circuito abbiamo:

V - V_f - I R = 0

il che significa (V - V_f)/I = R. Quindi la resistenza necessaria per ottenere la massima luminosità (e probabilmente friggere i segmenti) sarebbe:

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

Quindi, se lo volessi, potresti tranquillamente usare 150 ohm senza preoccupazioni. Tuttavia, penso che 140 ohm lo rendano troppo luminoso per i miei gusti e quindi uso 330 ohm (che è una specie di resistenza personale di Riccioli d'oro per i LED)

Passaggio 2: codice di montaggio e video

Ho allegato il codice di montaggio e un video che mostra il funzionamento della tastiera con il display. Come puoi vedere, abbiamo semplicemente mappato il tasto Redial su "r", il tasto flash su "F", l'asterisco su "A" e il cancelletto su "H". Questi potrebbero essere associati a varie operazioni come backspace, invio e altro se si desidera continuare a utilizzare la tastiera per digitare i numeri sui display LCD o sui display a 4 cifre. Questa volta non esaminerò il codice riga per riga poiché è molto simile a quello che abbiamo già fatto nei tutorial precedenti. Le differenze sono principalmente solo più delle stesse cose che sappiamo già come fare come gli interrupt e le tabelle di ricerca. Dovresti semplicemente esaminare il codice e guardare le nuove cose che abbiamo aggiunto e le cose che abbiamo cambiato e capirlo da lì. Torneremo all'analisi riga per riga nel prossimo tutorial quando introdurremo nuovi aspetti della codifica in linguaggio assembly sui microcontrollori AVR.

Diamo ora un'occhiata a un display a 4 cifre.

Passaggio 3: cablaggio del display a 4 cifre

Secondo la scheda tecnica, il display a 4 cifre ha una corrente diretta di 60 mA e una tensione diretta di 2,2 volt. Quindi, con lo stesso calcolo di prima, potrei usare un resistore da 47 ohm se lo volessi. Invece userò un… hm… fammi vedere… che ne dici di 330 ohm.

Il modo in cui è cablato il display a 4 cifre è che ci sono 4 anodi, uno per ciascuna delle cifre, e gli altri pin controllano quale segmento si accende in ciascuno. È possibile visualizzare 4 cifre contemporaneamente perché sono multiplexate. In altre parole, proprio come abbiamo fatto per la coppia di dadi, facciamo semplicemente scorrere l'alimentazione attraverso ciascuno degli anodi a turno e li lampeggerà uno dopo l'altro. Lo farà così velocemente che i nostri occhi non vedranno il lampeggiamento e sembrerà che tutte e quattro le cifre siano accese. Tuttavia, solo per essere sicuri, il modo in cui lo codificheremo è impostare tutte e quattro le cifre, quindi eseguire il ciclo degli anodi, piuttosto che impostare, spostare, impostare, spostare, ecc. In questo modo possiamo ottenere un tempo preciso tra l'accensione di ogni cifra.

Per ora, testiamo che tutti i segmenti funzionino.

Posiziona la tua resistenza da 330 ohm tra il binario positivo della breadboard e il primo anodo sul display. Il datasheet ci dice che i pin sono numerati da 1 a 16 in senso antiorario partendo in basso a sinistra (quando si guarda normalmente il display.. con i punti decimali in basso) e si afferma che gli anodi sono pin numero 6, 8, 9 e 12.

Quindi colleghiamo il pin 6 a 5V e poi prendiamo un cavo negativo dalla tua guida GND e lo inseriamo in tutti gli altri pin e vediamo che tutti i segmenti si accendono sulla cifra a cui corrisponde (che in realtà è la seconda cifra da la destra). Assicurati che tutti e 7 i segmenti e il punto decimale si illuminino.

Ora inserisci il tuo filo GND in uno dei pin per illuminare uno dei segmenti e questa volta sposta il resistore sugli altri 3 anodi e vedi che lo stesso segmento si illumina in ciascuna delle altre cifre.

Qualcosa di insolito?

Si scopre che il pinout sulla scheda tecnica è sbagliato. Questo perché è la scheda tecnica e il pinout per un display a 12 pin e 4 cifre. Cioè. uno senza due punti o punto decimale superiore. Il display che ho ricevuto quando l'ho ordinato è un display a 16 pin e 4 cifre. Infatti, sul mio, gli anodi del segmento sono ai pin 1, 2, 6 e 8. L'anodo del colon è il pin 4 (pin 12 del catodo) e l'anodo dp superiore è il pin 10 (il catodo è pin 9)

Esercizio 1: Usa la resistenza e il filo di terra per mappare quale pin corrisponde a quale segmento e punto decimale sul display in modo che i segmenti corretti si accendano quando lo codifichiamo.

Il modo in cui vogliamo codificare la mappa dei segmenti è esattamente come abbiamo fatto con il display a 7 segmenti a una cifra sopra: non dobbiamo cambiare nulla nel codice, l'unica cosa che cambiamo è il modo in cui i fili sono collegati sulla lavagna. Basta collegare il pin della porta corretta sul microcontrollore al pin corrispondente sul display a 4 cifre in modo che, ad esempio, PB0 vada ancora al pin corrispondente al segmento a, PB1 vada al segmento B, ecc.

L'unica differenza è che ora abbiamo bisogno di 4 pin in più per gli anodi poiché non possiamo più semplicemente andare al binario 5V. Abbiamo bisogno del microcontrollore per decidere quale cifra ottiene il succo.

Quindi useremo PC1, PC2, PC3 e PD4 per controllare gli anodi delle 4 cifre.

Potresti anche andare avanti e collegare i fili. (non dimenticare le resistenze da 330 ohm sui fili dell'anodo!)

Passaggio 4: codifica del display a 4 cifre

Pensiamo a come vogliamo codificare questo display.

Vorremmo che l'utente prema i pulsanti della tastiera e che i numeri appaiano in sequenza sul display mentre premono ciascun pulsante. Quindi, se premo un 1 seguito da un 2, verrà visualizzato sul display come 12. Vorrei anche memorizzare quel valore, 12, per uso interno, ma ci arriveremo un po' più tardi. Per ora voglio solo scrivere una nuova macro che prenda i tasti premuti e li visualizzi. Tuttavia, poiché abbiamo solo 4 cifre, voglio assicurarmi che ti permetta di digitare solo quattro numeri.

Un altro problema è che il modo in cui funziona il display a 4 cifre multiplexato è quello di ciclare gli anodi in modo che ogni cifra sia accesa solo per una frazione di secondo prima che venga visualizzata la successiva e poi la successiva e infine di nuovo alla prima, ecc. bisogno di un modo per codificare questo.

Vogliamo anche che sposti il "cursore" a destra di uno spazio quando digitiamo la cifra successiva. Quindi se voglio digitare 1234 per esempio, dopo aver digitato 1, il cursore si sposterà in modo che la cifra successiva che digiterò appaia sul successivo display a 7 segmenti e così via. Nel frattempo, voglio ancora essere in grado di vedere cosa ho digitato, quindi deve ancora scorrere le cifre e visualizzarle.

Suona come un compito arduo?

Le cose in realtà sono anche peggio. Abbiamo bisogno di 4 registri più generici che possiamo usare per memorizzare i valori correnti delle 4 cifre che vogliamo visualizzare (se vogliamo scorrerli dobbiamo tenerli memorizzati da qualche parte) e il problema è che abbiamo abbiamo usato come un matto i registri di uso generale e se non stiamo attenti non ne avremo più. Quindi è probabilmente una buona idea affrontare questo problema prima piuttosto che dopo e mostrarti come liberare i registri usando lo stack.

Cominciamo quindi semplificando un po' le cose, usiamo lo stack, e liberiamo alcuni registri e poi cercheremo di svolgere il compito di leggere e visualizzare i nostri numeri sul display a 4 cifre.

Passaggio 5: premi e fai scoppiare

Ci sono solo pochi "Registri per scopi generici" che abbiamo a nostra disposizione e una volta utilizzati non ce ne sono più. Quindi è buona pratica di programmazione usarli solo per un paio di variabili che vengono utilizzate come memoria temporanea di cui hai bisogno per leggere e scrivere su porte e SRAM con, oppure quelle di cui avrai bisogno nelle subroutine ovunque e così tu Nominali. Quindi quello che ho fatto, ora che abbiamo inizializzato e stiamo imparando a usare lo Stack, è passare attraverso il codice e trovare i registri generici denominati che vengono utilizzati solo all'interno di una singola subroutine o interrupt e da nessun'altra parte nel codice e sostituire li con uno dei nostri registri temporanei e un push and pop allo stack. Infatti, se guardi il codice scritto per microcontrollori più piccoli, o se torni indietro nel tempo a quando tutti i chip erano più piccoli, vedrai solo un paio di registri generici che dovevano essere usati per tutto, quindi non puoi basta memorizzare un valore lì dentro e lasciarlo da solo poiché avevi sicuramente bisogno di quel registro per altre cose. Quindi vedrai premere e schioccare dappertutto nel codice. Forse avrei dovuto chiamare i nostri registri temporanei per uso generale AX e BX come un rispettoso complimento per quei giorni passati.

Un esempio aiuterà a rendere questo più chiaro.

Si noti che nel nostro interrupt completo di conversione da analogico a digitale ADC_int usiamo un registro per scopi generici che abbiamo chiamato buttonH che abbiamo usato per caricare il valore di ADCH e confrontarlo con la nostra tabella di ricerca delle conversioni da analogico a pulsante. Usiamo questo registro buttonH solo all'interno della subroutine ADC_int e da nessun'altra parte. Quindi useremo invece la nostra variabile temp2 che usiamo come variabile temporanea che possiamo usare all'interno di una data subroutine e il suo valore non influenzerà nulla al di fuori di quella subroutine (cioè il valore che gli diamo in ADC_int non saràutilizzato da nessuna parte altro).

Un altro esempio è nella nostra macro di ritardo. Abbiamo un registro che abbiamo chiamato "millisecondi" che contiene il nostro tempo di ritardo in millisecondi. In questo caso è in una macro e ricordiamo che il modo in cui funziona la macro è che l'assemblatore inserisce l'intero codice della macro nel punto del programma in cui viene chiamato. In questo caso vorremmo sbarazzarci della variabile "millisecondi" e sostituirla con una delle nostre variabili temporanee. In questo caso lo farò in modo leggermente diverso per mostrarti come, anche se il valore della variabile sarà necessario altrove, possiamo comunque usarlo usando lo stack. Quindi invece di millisecondi usiamo "temp" e per non rovinare altre cose che usano anche il valore di temp, iniziamo semplicemente la macro "delay" "spingendo" temp sullo stack, quindi lo usiamo invece di millisecondi, e poi alla fine della macro "riprendiamo" il suo valore precedente dallo stack.

Il risultato netto è che abbiamo "preso in prestito" temp e temp2 per un uso temporaneo e poi li abbiamo ripristinati ai loro valori precedenti quando abbiamo finito.

Ecco la routine di interrupt ADC_int dopo aver apportato questa modifica:

ADC_int:

premere temperatura; save temp poiché lo modifichiamo qui push temp2; salva temp2 lds temp2, ADCH; load keypress ldi ZH, high(2*numeri) ldi ZL, low(2*numeri) cpi temp2, 0 breq return; se i trigger di rumore non cambiano 7segnumber setkey: lpm temp, Z+; carica da tabella e post incremento clc cp temp2, temp; confronta keypress con la tabella brlo PC+4; se ADCH è inferiore, riprovare lpm 7segnumber, Z; altrimenti carica la tabella keyvalue inc digit; incrementa il numero della cifra rjmp return; e restituisci adiw ZH:ZL, 1; incremento Z rjmp setkey; e torna all'inizio return: pop temp2; ripristinare temp2 pop temp; ripristinare la temp

Si noti che il modo in cui funziona lo stack è che il primo acceso è l'ultimo spento. Proprio come una pila di carte. Vedete che nelle nostre prime due righe inseriamo il valore di temp nello stack, quindi inseriamo temp2 nello stack, quindi li usiamo nella subroutine per altre cose e infine li ripristiniamo ai loro valori precedenti di nuovo prima spegniamo temp2 (dal momento che è stato l'ultimo a essere spinto su di esso è in cima allo stack e sarà il primo che sbloccheremo) e poi spegniamo temp.

Quindi d'ora in poi useremo sempre questo metodo. L'unica volta che designeremo effettivamente un registro per qualcosa di diverso da una variabile temporanea è quando ne avremo bisogno ovunque. Ad esempio, il registro chiamato "overflow" è uno che usiamo in diversi punti del programma e quindi vorremmo dargli un nome. Ovviamente potremmo ancora usarlo come abbiamo fatto con temp e temp2 poiché ripristineremo il suo valore dopo aver finito. Ma questo spaccherebbe troppo le cose. Sono nominati per un motivo e abbiamo già designato temp e temp2 per quel lavoro.

Passaggio 6: filtri passa basso e amplificatore di tensione

Per ripulire un po' il rumore e far funzionare meglio la nostra tastiera, vogliamo aggiungere un paio di filtri passa-basso. Questi filtrano il rumore ad alta frequenza e consentono il passaggio del segnale a bassa frequenza. In sostanza, il modo per farlo è semplicemente aggiungere un condensatore da 68 pf tra il nostro ingresso analogico e la massa e anche un condensatore da 0,1 microfarad (cioè 104) tra il nostro interrupt PD4 (INT0) e la massa. Se giochi con questi mentre premi i pulsanti sulla tastiera sarai in grado di vedere cosa fanno.

Quindi vogliamo creare un amplificatore di tensione. Si scopre che la fila inferiore di tasti sulla tastiera (così come il tasto di ricomposizione) sta emettendo una tensione troppo bassa per far scattare l'interrupt INT0. La porta analogica è abbastanza sensibile da leggere le basse tensioni da questi tasti, ma il nostro pin di interruzione non sta ottenendo un fronte di salita abbastanza buono da interrompere quando premiamo quei tasti. Quindi vorremmo un modo per assicurarci che un bel fronte di salita della tensione colpisca PD4 ma la stessa bassa tensione colpisca ADC0. Questo è un compito piuttosto arduo poiché entrambi i segnali provengono dallo stesso cavo di uscita della nostra tastiera. Ci sono molti modi sofisticati per farlo, ma non useremo più la nostra tastiera dopo questo tutorial, quindi mettiamo insieme un metodo che funziona (a malapena).

Dovresti prima collegare un pulsante esterno per sostituire l'interrupt INT0 e controllare il display tenendo premuto un tasto sulla tastiera e facendo clic sul pulsante. Questo ha meno problemi con la tastiera e ti consentirà di essere sicuro che i tuoi voltaggi siano impostati correttamente sulla tabella di ricerca della tastiera. Una volta che sai che la tastiera è cablata correttamente, liberati del pulsante e rimetti l'interrupt INT0. Ci sono alcuni seri problemi di rumore e tensione che controllano la tastiera in questo modo, quindi è bene sapere che tutto funziona in modo che i problemi futuri possano essere isolati sul tasto INT0.

Quando colleghi la tastiera e l'amplificatore di tensione, è molto probabile che gli stessi valori di resistori che ho usato non funzioneranno. Quindi dovrai fare qualche sperimentazione per ottenere valori che funzionino per te.

Se guardi il diagramma che ho allegato a questo passaggio vedrai come funzionerà l'amplificatore di tensione. Usiamo alcuni resistori e due transistor. Il modo in cui funzionano i transistor (vedi le schede tecniche!) è che c'è una tensione minima che devi inserire nel pin di base del transistor (il pin centrale) che lo satura e consente alla corrente di fluire tra il pin del collettore e l'emettitore spillo. Nel caso del transistor 2N3904 che stiamo usando qui la tensione è 0,65V. Ora stiamo prendendo quella tensione dalla nostra uscita dalla tastiera e non vogliamo cambiare quell'uscita, quindi metteremo un grosso resistore tra l'uscita dalla tastiera e la base del primo transistor (ho usato 1Mohm). L'ho etichettato come R_1 nel diagramma. Quindi vogliamo impostare un partitore di tensione in modo che la base del transistor sia già "quasi" a 0,65 volt e solo un pochino in più lo spingerà sopra e lo saturerà. Quel piccolissimo pezzettino verrà dall'uscita della tastiera quando premiamo un pulsante. Poiché i tasti inferiori della tastiera emettono solo una piccola tensione, dobbiamo essere già molto vicini alla saturazione affinché siano sufficienti. I resistori del partitore di tensione sono etichettati R_a e R_b sul diagramma. Ho usato R_a = 1Mohm e R_b = 560Kohm ma è quasi certo che dovrai giocare con questi numeri per farlo bene alla tua configurazione. Potresti voler avere un muro vicino contro cui sbattere la testa e due o tre bicchieri di scotch a portata di mano (consiglierei Laphroaig - costoso, ma ne vale la pena se ti piace il fumo. Se le cose si fanno davvero folli, allora prendi una caraffa di BV e sistemarsi per la notte)

Ora diamo un'occhiata a come i transistor ci daranno un bel fronte di salita entrando nel tasto INT0 e generando il nostro keypress interrupt. Per prima cosa vediamo cosa succede quando non sto premendo un tasto. In tal caso il primo transistor (etichettato T1 nel diagramma) è spento. Quindi nessuna corrente scorre tra i pin del collettore e dell'emettitore. Quindi la base dell'altro transistor (etichettato T2) sarà tirata in alto e quindi si satura permettendo alla corrente di fluire tra i suoi pin. Ciò significa che l'emettitore di T2 sarà abbassato poiché è collegato al collettore che a sua volta è collegato a massa. Pertanto, l'output che va al nostro pin di interruzione della pressione dei tasti INT0 (PD4) sarà basso e non ci saranno interruzioni.

Ora cosa succede quando premo un tasto? Bene, allora la base di T1 va sopra 0,65V (nel caso dei tasti inferiori va appena sopra!) e quindi verrà lasciata scorrere la corrente che porterà la base di T2 a bassa tensione e questo spegnerà T2. Ma vediamo che quando T2 è spento, l'uscita viene alzata e quindi otterremo un segnale a 5 V che va al nostro pin INT0 e causerà un'interruzione.

Nota qual è il risultato netto qui. Se premiamo il tasto 1, otteniamo 5V andando su PD4 senza cambiare significativamente l'uscita andando su ADC0 e, cosa più importante, anche se premiamo Asterisco, 0, Hash o Redial, otteniamo anche un segnale 5V che va a INT0 e anche causando un'interruzione! Questo è importante poiché se siamo passati direttamente dall'uscita della tastiera al pin INT0, quei tasti non generano quasi alcuna tensione e non saranno sufficienti per attivare quel pin di interruzione. Il nostro amplificatore di tensione ha risolto questo problema.

Passaggio 7: codice display a 4 cifre e video

Questo è tutto per il tutorial 9! Ho allegato il codice e un video che mostra l'operazione.

Questa sarà l'ultima volta che utilizzeremo la tastiera analogica (grazie a Dio). È stato difficile da usare, ma è stato anche molto utile per aiutarci a conoscere la conversione da analogico a digitale, le porte analogiche, gli interrupt, il multiplexing, i filtri di rumore, gli amplificatori di tensione e molti aspetti della codifica degli assembly dalle tabelle di ricerca ai timer/contatori, ecc. Ecco perché abbiamo deciso di usarlo. (in più è divertente cercare roba).

Ora esamineremo di nuovo la comunicazione e faremo in modo che i nostri display a 7 segmenti ea 4 cifre leggano i nostri tiri di dadi dal nostro rullo di dadi nello stesso modo in cui abbiamo fatto con il nostro analizzatore di registro. Questa volta utilizzeremo l'interfaccia a due fili anziché il nostro metodo di codice morse hackerato insieme.

Una volta che abbiamo le comunicazioni funzionanti e i rotoli che appaiono sugli espositori, possiamo finalmente realizzare il primo pezzo del nostro prodotto finale. Noterai che senza tutte le porte analogiche il nostro codice sarà significativamente più breve e probabilmente più facile da leggere.

Per quelli di voi che sono ambiziosi. Ecco un "progetto" che potresti provare e che sicuramente hai le conoscenze per fare a questo punto se hai seguito tutti questi tutorial fino a questo punto:

Progetto: crea una calcolatrice! Usa il nostro display a 4 cifre e la nostra tastiera e aggiungi un pulsante esterno che agirà come un tasto "invio". Mappa l'asterisco su "times", l'hash per "dividere" la ricomposizione in "più" e il flash su "meno" e scrivi una routine di calcolatrice che si comporti come una di quelle vecchie calcolatrici HP "reverse polish" che tutti gli ingegneri avevano indietro nel corso della giornata. Cioè. il modo in cui funzionano è che inserisci un numero e premi "invio". Questo spinge quel numero nello stack, quindi inserisci un secondo numero e premi "invio", che spinge il secondo numero nello stack. Alla fine premi una delle operazioni come X, /, + o - e applicherà quell'operazione ai primi due numeri sullo stack, visualizzerà il risultato e inserirà il risultato nello stack in modo che tu possa usarlo di nuovo se Come. Ad esempio per aggiungere 2+3 dovresti fare: 2, "enter", 3, "enter", "+" e il display dovrebbe quindi leggere 5. Sai come usare lo stack, il display, la tastiera e tu avere la maggior parte del codice in background già scritto. Basta aggiungere il tasto Invio e le subroutine necessarie per la calcolatrice. È un po' più complicato di quanto si possa pensare a prima vista, ma è divertente e fattibile.

Arrivederci alla prossima!