Quindi torniamo alla nostra routine principale ora per vedere cosa succede una volta che abbiamo ricevuto la lettera dal tavolo.
La prima cosa che facciamo è memorizzare ciò che è tornato nel registro in una delle nostre auto che si
trova all'indirizzo 0 7 2.
Quindi cancelliamo il registro.
Il registro perché eseguiremo una funzione matematica per verificare se siamo tornati con un esagono 0
0 nel registro W che abbiamo progettato come marcatore per la fine del tavolo.
Quindi, se è zero, non vogliamo scriverlo sul display LCD.
Quindi controlleremo prima questo.
Quello che facciamo è eseguire un'operazione logica tra il numero binario che ci è tornato dalla nostra tabella e lo 0 0 0 0
0 0 0 0 0 che è attualmente nel nostro W. Registrare.
Le operazioni logiche funzionano esattamente come le porte logiche di cui abbiamo parlato nella lezione 4, possiamo eseguire una funzione e una
funzione esclusiva o una funzione inclusiva o una funzione che è in realtà solo una funzione OR.
Quindi per esempio se abbiamo 1 1 0 1 0 0 1 1 in un file e 0 1 0 1 1 0 0 0 nel registro W e eseguiamo una funzione di
fine sul 2 otteniamo 8 0 1 0 1 0 0 0 0 in arrivo.
È come se il processore inserisse un fine tra ciascun bit nei due registri e sputasse un risultato.
Un'esclusiva o una funzione sputerebbe 1 0 0 0 1 0 1 1 un inclusivo o una funzione è solo una funzione OR.
Quindi se qualsiasi offerta è alta sputa un 1 sul bit corrispondente.
Quindi otteniamo 1 1 0 1 1 0 1 1.
Nel nostro caso usiamo un inclusivo o una funzione I O R W F.
Quindi inseriamo un gate OR tra ogni bit nel registro W e il file che abbiamo chiamato, in questo
caso i nostri GP sono a 0 7 2.
Ora ci interessa solo di JPR 0 7 2 0 perché è quello che stiamo usando per segnare la fine
della nostra tabella se qualche bit 0 7 2 è alto perché è ored con il W.
Quindi la funzione matematica logica sputerà un 1 su quel bit.
Abbiamo quella virgola zero alla fine.
Delle nostre istruzioni che dicono al compilatore di mettere i risultati della funzione matematica logica nel W.
Registrare.
Quindi, se colpissimo la fine del nostro tavolo e tornassimo e mettessimo uno zero nella chitarra, l'intero bit
tornerà con tutti gli zeri che verranno messi in W. Registrare.
Ti ricordi quel pezzo di Kerry di cui ho parlato in una lezione precedente quando eseguivamo un turno di
sinistra o uno di destra su un registro e andava a un'estremità.
È andato bene al bit di carry che il bit di Kerry è solo uno dei numerosi bit
di funzioni speciali in un registro chiamato status, il registro di stato mostra fondamentalmente lo stato di una funzione matematica che hai eseguito.
Ciò include le funzioni matematiche logiche come e e oppure è possibile visualizzare i bit del registro
di stato a pagina 27 del proprio foglio dati di prelievo e
notare il bit su Zed o 0 bit.
Ora puoi probabilmente indovinare cosa fa questo disegno di legge.
Giusto.
Se il risultato della tua funzione matematica o logica si traduce in un grande zero grasso.
Questo pezzo è alto.
Quindi questo può essere molto utile per un certo numero di cose.
E in questo caso particolare stiamo cercando di vedere se il numero che abbiamo riportato dal tavolo
fosse zero.
Se è perché abbiamo eseguito una funzione matematica confrontando quel numero con uno 0 nel registro W se è una corrispondenza,
allora il bit Z va nel registro di stato diventa alto.
Ora tutto quello che dobbiamo fare è controllare con il nostro programma è quello di verificare che sia più alto o meno.
Lì è proprio lì bit test su un file.
Salta la prossima istruzione.
Se l'offerta è chiara.
Abbiamo testato due sul registro di stato che è il 0 bit.
Quindi se tornassimo con lo 0 questo bit verrà impostato.
Non chiaro se abbiamo trovato uno 0.
Salterà fuori da questa routine principale e andrà a questa prossima etichetta andare su questa etichetta.
Il prossimo passo se tornassimo con un personaggio di un tipo dalla tabella, il risultato della nostra funzione o non
sarà zero.
Il bit 0 nel registro di stato sarà chiaro.
Quindi salteremo questa prossima linea.
Questo test significa che non siamo ancora arrivati alla fine del tavolo.
In realtà abbiamo un carattere memorizzato in GBR 0 7 2.
Ora dobbiamo inviare tutto ciò che è in quella memoria sul display LCD.
Ora stiamo lavorando in modalità forbit con il display, quindi dobbiamo fare due
cose molto importanti che abbiamo bisogno di spezzare il byte in due bocconcini mandare prima il nibble superiore e poi il secondo nibble sul display LCD.
Ora, tenendo presente che se dovessi inviare un qualsiasi byte alla porta C, i supporti di supporto superiore C non sono
collegati nulla.
Quindi estraggo un coniglio da un cappello con un piccolo trucco che uso questa istruzione qui chiamata scambia
un file.
Ciò che fa la funzione di scambio è che scambia letteralmente i bocconcini superiore e inferiore in un byte che
li commuta.
Quindi il bocconcino più significativo diventa il meno significativo e il meno significativo
diventa il più significativo.
Quindi il mio primo personaggio che stavo inviando era un capitale B.
Il compilatore cercò il suo elegante grafico ad alta tecnologia.
Scoperto che il capitale B era rappresentato da 0 1 0 0 0 0 1 0 in binario.
Metti quel numero in 0 7.
Dobbiamo prima inviare 0 1 0 0 sul display LCD e poi 0 0 1 0.
Quindi immagina cosa succederebbe se avessi inviato il contenuto di JPR 0 7 2 direttamente alla porta C.
Non c'è niente collegato a questi quattro bit superiori.
Quindi non vanno da nessuna parte.
E i 4 bit più bassi verrebbero inviati al display.
Quando tolgo la funzione swap, scambia i due nibbles in Gods 0 7 2.
Quindi otteniamo 0 0 0 1 0 0 1 0 0.
Ma nota nelle mie istruzioni c'è quel piccolo comando potente a più stadi.
Ho una virgola zero alla fine che dice al compilatore di mettere il risultato nel registro W non il GPS
qui a sette per registrarsi.
Quindi se puoi immaginare cosa è successo ora è che 0 7 2 contiene ancora il codice binario ASCII per
il capitale B e il W ha lo stesso codice binario ma con i due nibble scambiati.
Quindi ora se invio il registro W a porto, per prima cosa lo schermo LCD è collegato solo al livello più basso. Quindi, boom, ora
ha il morso superiore della capitale B.
Diamo impulso alla linea per caricarla.
Quindi inviamo il contenuto di JPR 0 7 2 alla porta C.
Ma ancora perché i quattro bit superiori non sono collegati a qualcosa che non vanno da nessuna parte.
Ma guarda questo i 4 bit più bassi della capitale B sono ciò che vede il display LCD.
Quindi noi controlliamo solo la linea che carica in quel boccone più basso ora.
Boom.
Abbiamo appena mandato la nostra capitale B sul display.
Quindi questo è tutto ciò che questi comandi fanno proprio qui.
Una volta inviato il carattere sul display LCD, ne aggiungiamo uno al nostro contatore carica il conteggio
nel registro W perché lo useremo nella subroutine della tabella, quindi torniamo indietro e andiamo a prendere il prossimo carattere in la
squadra di periferia e spero di fare tutto ciò che ha senso.
Quindi una volta raggiunta la fine del nostro primo tavolo otteniamo uno zero che ci salta fuori dalla prima routine principale e
saltiamo giù fino al prossimo passo.
Ora puoi ancora fare quello che vuoi qui.
Questo è quello che ho fatto con il codice.
Ho impostato la linea arest sullo zero per indicare allo
schermo LCD che sto per inviare al comando.
Quindi posiziono il cursore sul primo blocco di caratteri della seconda riga.
Questo ora mi prepara a scrivere il prossimo messaggio sulla riga successiva del display.
Tuttavia, ricorderai che alcuni di questi comandi richiedevano fino a due millisecondi.
Bene, questo era uno di quei comandi.
Quindi, dopo aver inviato i comandi, chiamiamo una subroutine breve una breve routine di delay.
Questo è semplicemente un ritardo come abbiamo visto prima.
Solo il conto alla rovescia da 255.
Solo una volta tocca solo tre millisecondi, quindi è più lungo del necessario.
Perfezionare.
Arriviamo quindi alla seconda
routine
che andremo a cercare anche nella seconda tabella di caratteri chiamata Elenco messaggi.
Esegue esattamente gli stessi passaggi della routine precedente, ma carica la
seconda tabella del messaggio casuale.
Ora non ripercorrerò come funziona di nuovo ma farà un punto significativo contrassegnando la
fine della tabella con un esadecimale 0 0.
Ora avrei potuto scegliere davvero qualcosa per quello.
Ma 0 0 è stato facile da testare facendo uso del flag di zero e del registro di stato.
Per esempio diciamo che volevo usare la lettera maiuscola Q come il marcatore per la fine del tavolo.
Inserisco una Q maiuscola in
quotazioni, il compilatore cerca il suo elegante valore binari di alta tecnologia ascii che è 0 1 0 1 0 0 0 1.
Quindi ora come verificherebbe se i contenuti del tuo registro sono l'ASCII binario della lettera maiuscola
Q ..
Beh, ci sono alcuni modi in cui puoi farlo, ma un modo sarebbe utilizzare un esclusivo o una funzione.
Confrontando quel registro con 0 1 0 1 0 0 0 1.
Ora ho scelto quel numero perché è la corrispondenza esatta per la lettera maiuscola Q del carattere ASCII.
Ovunque c'è corrispondenza con 0 uscite 0 e ovunque ce n'è una corrispondente.
Mette anche uno 0 perché era esclusivo o funzione solo un bit o l'altro può essere alto.
Se entrambi sono alti, l'uscita è zero.
Ora puoi caricare il risultato nel doppio registro, controllare il flag zero
e se è impostato, allora sai che hai il numero binario per una Q maiuscola in codice
ASCII.
Ma prestate anche molta attenzione qui.
Si noti che la mia ultima voce nella tabella era 0 senza citazione.
Questo è molto importante se inserisco lo 0 tra virgolette.
Quindi il compilatore considera ciò che si trova in queste virgolette come una stringa, non un valore, quindi lo vede.
Cosa pensi che inserirà nel registro W.
Non è zero, sta andando a cercare i caratteri zero nel grafico ascii che è proprio qui e caricherà il numero binario di 0 0
1 1 0 0 0 0 nel W. Registrare.
Non tutti gli zeri.
Se metto non mettere lo 0 tra virgolette.
Ora presume che sia un numero quindi ha un valore.
In questo caso il valore di 0.
Quindi caricherà 0 0 0 0 0 0 0 0 nel W. Registrare.
Ha senso.
Bene, compila il codice con esso inviando alcuni messaggi personalizzati al tuo schermo LCD e
sperimenta cose.
Cambia il messaggio nella tabella e sperimenta con i personaggi che invii.
Ora forse, se sei davvero coraggioso, puoi programmarlo per inviare due righe di un messaggio, attendere cinque o
dieci secondi, quindi inviare un altro messaggio su una o entrambe le righe.
Divertiti con quello.