WEBVTT

00:01.540 --> 00:10.870
Quindi torniamo alla nostra routine principale ora per vedere cosa succede una volta che abbiamo ricevuto la lettera dal tavolo.

00:12.230 --> 00:20.210
La prima cosa che facciamo è memorizzare ciò che è tornato nel registro in una delle nostre auto che si

00:20.300 --> 00:22.600
trova all'indirizzo 0 7 2.

00:22.670 --> 00:24.380
Quindi cancelliamo il registro.

00:24.380 --> 00:32.090
Il registro perché eseguiremo una funzione matematica per verificare se siamo tornati con un esagono 0

00:32.090 --> 00:39.470
0 nel registro W che abbiamo progettato come marcatore per la fine del tavolo.

00:39.860 --> 00:44.750
Quindi, se è zero, non vogliamo scriverlo sul display LCD.

00:44.780 --> 00:46.650
Quindi controlleremo prima questo.

00:47.120 --> 00:54.550
Quello che facciamo è eseguire un'operazione logica tra il numero binario che ci è tornato dalla nostra tabella e lo 0 0 0 0

00:55.280 --> 01:02.130
0 0 0 0 0 che è attualmente nel nostro W. Registrare.

01:02.810 --> 01:11.120
Le operazioni logiche funzionano esattamente come le porte logiche di cui abbiamo parlato nella lezione 4, possiamo eseguire una funzione e una

01:11.780 --> 01:18.870
funzione esclusiva o una funzione inclusiva o una funzione che è in realtà solo una funzione OR.

01:18.890 --> 01:32.820
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

01:32.820 --> 01:39.760
fine sul 2 otteniamo 8 0 1 0 1 0 0 0 0 in arrivo.

01:40.280 --> 01:48.100
È come se il processore inserisse un fine tra ciascun bit nei due registri e sputasse un risultato.

01:49.640 --> 01:59.720
Un'esclusiva o una funzione sputerebbe 1 0 0 0 1 0 1 1 un inclusivo o una funzione è solo una funzione OR.

01:59.750 --> 02:03.980
Quindi se qualsiasi offerta è alta sputa un 1 sul bit corrispondente.

02:04.190 --> 02:09.420
Quindi otteniamo 1 1 0 1 1 0 1 1.

02:10.010 --> 02:16.550
Nel nostro caso usiamo un inclusivo o una funzione I O R W F.

02:16.790 --> 02:26.810
Quindi inseriamo un gate OR tra ogni bit nel registro W e il file che abbiamo chiamato, in questo

02:26.810 --> 02:31.940
caso i nostri GP sono a 0 7 2.

02:31.990 --> 02:39.040
Ora ci interessa solo di JPR 0 7 2 0 perché è quello che stiamo usando per segnare la fine

02:39.040 --> 02:45.340
della nostra tabella se qualche bit 0 7 2 è alto perché è ored con il W.

02:45.460 --> 02:50.110
Quindi la funzione matematica logica sputerà un 1 su quel bit.

02:50.380 --> 02:53.480
Abbiamo quella virgola zero alla fine.

02:54.240 --> 03:02.960
Delle nostre istruzioni che dicono al compilatore di mettere i risultati della funzione matematica logica nel W.

03:03.140 --> 03:04.770
Registrare.

03:04.820 --> 03:10.790
Quindi, se colpissimo la fine del nostro tavolo e tornassimo e mettessimo uno zero nella chitarra, l'intero bit

03:10.790 --> 03:17.750
tornerà con tutti gli zeri che verranno messi in W. Registrare.

03:17.810 --> 03:23.870
Ti ricordi quel pezzo di Kerry di cui ho parlato in una lezione precedente quando eseguivamo un turno di

03:23.870 --> 03:28.100
sinistra o uno di destra su un registro e andava a un'estremità.

03:28.160 --> 03:36.020
È andato bene al bit di carry che il bit di Kerry è solo uno dei numerosi bit

03:36.140 --> 03:45.590
di funzioni speciali in un registro chiamato status, il registro di stato mostra fondamentalmente lo stato di una funzione matematica che hai eseguito.

03:45.680 --> 03:54.440
Ciò include le funzioni matematiche logiche come e e oppure è possibile visualizzare i bit del registro

03:54.440 --> 04:00.800
di stato a pagina 27 del proprio foglio dati di prelievo e

04:04.520 --> 04:09.150
notare il bit su Zed o 0 bit.

04:09.190 --> 04:12.820
Ora puoi probabilmente indovinare cosa fa questo disegno di legge.

04:12.910 --> 04:13.670
Giusto.

04:13.680 --> 04:19.540
Se il risultato della tua funzione matematica o logica si traduce in un grande zero grasso.

04:19.720 --> 04:22.980
Questo pezzo è alto.

04:23.110 --> 04:27.100
Quindi questo può essere molto utile per un certo numero di cose.

04:27.100 --> 04:33.130
E in questo caso particolare stiamo cercando di vedere se il numero che abbiamo riportato dal tavolo

04:33.130 --> 04:34.170
fosse zero.

04:34.600 --> 04:44.260
Se è perché abbiamo eseguito una funzione matematica confrontando quel numero con uno 0 nel registro W se è una corrispondenza,

04:44.260 --> 04:49.690
allora il bit Z va nel registro di stato diventa alto.

04:49.690 --> 04:55.510
Ora tutto quello che dobbiamo fare è controllare con il nostro programma è quello di verificare che sia più alto o meno.

04:55.510 --> 04:59.940
Lì è proprio lì bit test su un file.

05:00.090 --> 05:01.610
Salta la prossima istruzione.

05:01.620 --> 05:03.940
Se l'offerta è chiara.

05:04.170 --> 05:09.870
Abbiamo testato due sul registro di stato che è il 0 bit.

05:09.870 --> 05:13.350
Quindi se tornassimo con lo 0 questo bit verrà impostato.

05:13.350 --> 05:17.580
Non chiaro se abbiamo trovato uno 0.

05:18.000 --> 05:24.400
Salterà fuori da questa routine principale e andrà a questa prossima etichetta andare su questa etichetta.

05:24.450 --> 05:36.150
Il prossimo passo se tornassimo con un personaggio di un tipo dalla tabella, il risultato della nostra funzione o non

05:36.540 --> 05:38.260
sarà zero.

05:38.500 --> 05:42.330
Il bit 0 nel registro di stato sarà chiaro.

05:42.330 --> 05:45.580
Quindi salteremo questa prossima linea.

05:46.230 --> 05:49.350
Questo test significa che non siamo ancora arrivati alla fine del tavolo.

05:49.440 --> 05:54.240
In realtà abbiamo un carattere memorizzato in GBR 0 7 2.

05:54.420 --> 05:59.880
Ora dobbiamo inviare tutto ciò che è in quella memoria sul display LCD.

05:59.880 --> 06:05.430
Ora stiamo lavorando in modalità forbit con il display, quindi dobbiamo fare due

06:05.430 --> 06:15.370
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.

06:15.440 --> 06:25.100
Ora, tenendo presente che se dovessi inviare un qualsiasi byte alla porta C, i supporti di supporto superiore C non sono

06:25.110 --> 06:26.450
collegati nulla.

06:26.640 --> 06:35.790
Quindi estraggo un coniglio da un cappello con un piccolo trucco che uso questa istruzione qui chiamata scambia

06:36.310 --> 06:37.670
un file.

06:38.190 --> 06:46.290
Ciò che fa la funzione di scambio è che scambia letteralmente i bocconcini superiore e inferiore in un byte che

06:46.290 --> 06:47.220
li commuta.

06:47.230 --> 06:54.330
Quindi il bocconcino più significativo diventa il meno significativo e il meno significativo

06:54.330 --> 06:56.650
diventa il più significativo.

06:57.240 --> 07:02.760
Quindi il mio primo personaggio che stavo inviando era un capitale B.

07:02.820 --> 07:07.110
Il compilatore cercò il suo elegante grafico ad alta tecnologia.

07:07.440 --> 07:15.960
Scoperto che il capitale B era rappresentato da 0 1 0 0 0 0 1 0 in binario.

07:15.960 --> 07:18.420
Metti quel numero in 0 7.

07:18.420 --> 07:28.480
Dobbiamo prima inviare 0 1 0 0 sul display LCD e poi 0 0 1 0.

07:29.830 --> 07:39.010
Quindi immagina cosa succederebbe se avessi inviato il contenuto di JPR 0 7 2 direttamente alla porta C.

07:39.400 --> 07:43.320
Non c'è niente collegato a questi quattro bit superiori.

07:43.390 --> 07:44.660
Quindi non vanno da nessuna parte.

07:45.160 --> 07:50.490
E i 4 bit più bassi verrebbero inviati al display.

07:50.830 --> 07:57.910
Quando tolgo la funzione swap, scambia i due nibbles in Gods 0 7 2.

07:57.970 --> 08:03.130
Quindi otteniamo 0 0 0 1 0 0 1 0 0.

08:03.280 --> 08:11.980
Ma nota nelle mie istruzioni c'è quel piccolo comando potente a più stadi.

08:12.050 --> 08:21.340
Ho una virgola zero alla fine che dice al compilatore di mettere il risultato nel registro W non il GPS

08:21.490 --> 08:23.990
qui a sette per registrarsi.

08:23.990 --> 08:31.520
Quindi se puoi immaginare cosa è successo ora è che 0 7 2 contiene ancora il codice binario ASCII per

08:31.610 --> 08:38.140
il capitale B e il W ha lo stesso codice binario ma con i due nibble scambiati.

08:38.600 --> 08:47.540
Quindi ora se invio il registro W a porto, per prima cosa lo schermo LCD è collegato solo al livello più basso. Quindi, boom, ora

08:47.780 --> 08:50.640
ha il morso superiore della capitale B.

08:50.750 --> 08:53.600
Diamo impulso alla linea per caricarla.

08:53.690 --> 08:57.910
Quindi inviamo il contenuto di JPR 0 7 2 alla porta C.

08:58.010 --> 09:03.220
Ma ancora perché i quattro bit superiori non sono collegati a qualcosa che non vanno da nessuna parte.

09:03.410 --> 09:09.700
Ma guarda questo i 4 bit più bassi della capitale B sono ciò che vede il display LCD.

09:09.710 --> 09:13.940
Quindi noi controlliamo solo la linea che carica in quel boccone più basso ora.

09:14.060 --> 09:14.570
Boom.

09:14.690 --> 09:18.440
Abbiamo appena mandato la nostra capitale B sul display.

09:18.890 --> 09:25.000
Quindi questo è tutto ciò che questi comandi fanno proprio qui.

09:26.780 --> 09:36.650
Una volta inviato il carattere sul display LCD, ne aggiungiamo uno al nostro contatore carica il conteggio

09:36.650 --> 09:49.440
nel registro W perché lo useremo nella subroutine della tabella, quindi torniamo indietro e andiamo a prendere il prossimo carattere in la

09:49.590 --> 09:57.070
squadra di periferia e spero di fare tutto ciò che ha senso.

09:57.090 --> 10:08.740
Quindi una volta raggiunta la fine del nostro primo tavolo otteniamo uno zero che ci salta fuori dalla prima routine principale e

10:08.740 --> 10:12.430
saltiamo giù fino al prossimo passo.

10:12.430 --> 10:14.280
Ora puoi ancora fare quello che vuoi qui.

10:14.290 --> 10:16.500
Questo è quello che ho fatto con il codice.

10:16.840 --> 10:20.210
Ho impostato la linea arest sullo zero per indicare allo

10:23.400 --> 10:26.480
schermo LCD che sto per inviare al comando.

10:26.670 --> 10:34.510
Quindi posiziono il cursore sul primo blocco di caratteri della seconda riga.

10:39.510 --> 10:44.800
Questo ora mi prepara a scrivere il prossimo messaggio sulla riga successiva del display.

10:44.820 --> 10:50.170
Tuttavia, ricorderai che alcuni di questi comandi richiedevano fino a due millisecondi.

10:50.580 --> 10:53.430
Bene, questo era uno di quei comandi.

10:53.430 --> 11:03.160
Quindi, dopo aver inviato i comandi, chiamiamo una subroutine breve una breve routine di delay.

11:03.200 --> 11:06.510
Questo è semplicemente un ritardo come abbiamo visto prima.

11:09.300 --> 11:11.760
Solo il conto alla rovescia da 255.

11:11.760 --> 11:18.480
Solo una volta tocca solo tre millisecondi, quindi è più lungo del necessario.

11:18.490 --> 11:19.590
Perfezionare.

11:20.890 --> 11:23.170
Arriviamo quindi alla seconda

11:26.590 --> 11:27.460
routine

11:30.410 --> 11:37.870
che andremo a cercare anche nella seconda tabella di caratteri chiamata Elenco messaggi.

11:38.030 --> 11:43.490
Esegue esattamente gli stessi passaggi della routine precedente, ma carica la

11:48.480 --> 11:51.110
seconda tabella del messaggio casuale.

11:51.150 --> 11:56.190
Ora non ripercorrerò come funziona di nuovo ma farà un punto significativo contrassegnando la

11:56.190 --> 11:59.250
fine della tabella con un esadecimale 0 0.

11:59.250 --> 12:01.920
Ora avrei potuto scegliere davvero qualcosa per quello.

12:02.280 --> 12:08.240
Ma 0 0 è stato facile da testare facendo uso del flag di zero e del registro di stato.

12:08.280 --> 12:14.350
Per esempio diciamo che volevo usare la lettera maiuscola Q come il marcatore per la fine del tavolo.

12:14.640 --> 12:17.360
Inserisco una Q maiuscola in

12:25.470 --> 12:37.930
quotazioni, il compilatore cerca il suo elegante valore binari di alta tecnologia ascii che è 0 1 0 1 0 0 0 1.

12:37.930 --> 12:45.990
Quindi ora come verificherebbe se i contenuti del tuo registro sono l'ASCII binario della lettera maiuscola

12:45.990 --> 12:47.000
Q ..

12:47.790 --> 12:54.020
Beh, ci sono alcuni modi in cui puoi farlo, ma un modo sarebbe utilizzare un esclusivo o una funzione.

12:54.270 --> 13:00.130
Confrontando quel registro con 0 1 0 1 0 0 0 1.

13:00.150 --> 13:07.940
Ora ho scelto quel numero perché è la corrispondenza esatta per la lettera maiuscola Q del carattere ASCII.

13:08.100 --> 13:15.050
Ovunque c'è corrispondenza con 0 uscite 0 e ovunque ce n'è una corrispondente.

13:15.090 --> 13:24.770
Mette anche uno 0 perché era esclusivo o funzione solo un bit o l'altro può essere alto.

13:24.960 --> 13:29.850
Se entrambi sono alti, l'uscita è zero.

13:29.850 --> 13:35.010
Ora puoi caricare il risultato nel doppio registro, controllare il flag zero

13:38.460 --> 13:45.930
e se è impostato, allora sai che hai il numero binario per una Q maiuscola in codice

13:45.930 --> 13:46.490
ASCII.

13:48.270 --> 13:51.140
Ma prestate anche molta attenzione qui.

13:51.150 --> 13:57.210
Si noti che la mia ultima voce nella tabella era 0 senza citazione.

13:57.240 --> 14:03.520
Questo è molto importante se inserisco lo 0 tra virgolette.

14:04.050 --> 14:11.820
Quindi il compilatore considera ciò che si trova in queste virgolette come una stringa, non un valore, quindi lo vede.

14:11.820 --> 14:17.150
Cosa pensi che inserirà nel registro W.

14:17.170 --> 14:27.190
Non è zero, sta andando a cercare i caratteri zero nel grafico ascii che è proprio qui e caricherà il numero binario di 0 0

14:27.190 --> 14:33.640
1 1 0 0 0 0 nel W. Registrare.

14:33.640 --> 14:35.620
Non tutti gli zeri.

14:36.400 --> 14:42.340
Se metto non mettere lo 0 tra virgolette.

14:42.340 --> 14:45.920
Ora presume che sia un numero quindi ha un valore.

14:45.970 --> 14:51.900
In questo caso il valore di 0.

14:51.910 --> 14:57.780
Quindi caricherà 0 0 0 0 0 0 0 0 nel W. Registrare.

14:57.820 --> 15:00.230
Ha senso.

15:00.250 --> 15:06.670
Bene, compila il codice con esso inviando alcuni messaggi personalizzati al tuo schermo LCD e

15:06.700 --> 15:08.040
sperimenta cose.

15:08.050 --> 15:13.970
Cambia il messaggio nella tabella e sperimenta con i personaggi che invii.

15:13.970 --> 15:22.300
Ora forse, se sei davvero coraggioso, puoi programmarlo per inviare due righe di un messaggio, attendere cinque o

15:22.300 --> 15:28.450
dieci secondi, quindi inviare un altro messaggio su una o entrambe le righe.

15:28.450 --> 15:29.220
Divertiti con quello.