WEBVTT

00:01.300 --> 00:05.510
Fai un salto al tuo caffè, poi saliamo al

00:09.540 --> 00:18.940
nostro codice top-secret, quindi impostiamo la pubblicità prima con l'output giustificato e usando l'orologio completo, abbiamo appena impostato i bit come abbiamo

00:18.940 --> 00:21.390
capito usando la scheda tecnica.

00:22.990 --> 00:31.120
Quindi procediamo oltre aggiungendo con 0 e impostandolo usando i bit che abbiamo scoperto dalla scheda tecnica, ma abbiamo

00:31.120 --> 00:39.460
notato che il bit 1 ADD I è un po 'il bit GO GO che abbiamo lasciato basso per ora.

00:39.460 --> 00:45.000
Lo metteremo in alto quando saremo pronti per eseguire la nostra conversione.

00:45.280 --> 00:45.740
Tutto ok.

00:45.740 --> 00:54.720
Quindi il prossimo codice segreto contiene tutte le informazioni di configurazione per il display LCD che abbiamo appena fatto prima di copiare

00:54.720 --> 01:02.880
e incollare dal nostro progetto precedente, che imposta lo schermo LCD per la modalità forbit accende il cursore e tutto

01:02.880 --> 01:04.090
il resto.

01:04.110 --> 01:11.880
L'unica cosa che vorrei sottolineare è che quando inviamo i bit sul display si nota che il

01:12.240 --> 01:18.380
bit per on lache see è ora la nostra linea R S.

01:18.380 --> 01:27.620
Questi sono i comandi per l'LCD, quindi mi sono assicurato che il bit 4 fosse tenuto basso durante questo tempo di configurazione.

01:27.980 --> 01:36.470
Arriviamo quindi alla nostra stessa routine che avevamo prima di chiamare il nostro messaggio dal tavolo e visualizzarlo

01:36.470 --> 01:38.060
sul display LCD.

01:38.060 --> 01:43.370
Ora noterai che ho cambiato il messaggio è tutto ciò che ho fatto.

01:43.420 --> 01:53.520
Mi sono sbarazzato del secondo tavolo e ho scritto solo una riga di testo che legge un

01:53.520 --> 02:06.610
vecchio log, leggi Colin sulla prima riga del display, quindi torna alla riga settantadue CVS visto tutto questo già utilizzato e sapere

02:06.610 --> 02:07.860
come funziona.

02:07.870 --> 02:16.790
Impostiamo il convertitore in azione impostando il bit Go alto.

02:19.750 --> 02:21.930
Questo è il convertitore.

02:21.940 --> 02:27.820
Ora inizia il processo inizia a elaborare la sua conversione analogica.

02:28.210 --> 02:35.000
Quando arriviamo alla linea 104, l'etichetta aggiunge check, è qui che arriviamo al business.

02:35.050 --> 02:38.340
Il convertitore sta già lavorando alla sua prima conversione.

02:39.300 --> 02:46.470
Quindi, quello che dobbiamo fare è controllare il bit di go go per vedere se il convertitore ha finito e

02:46.470 --> 02:48.750
ha azzerato quel bit a zero.

02:49.140 --> 02:52.630
Lo facciamo con un test.

02:52.800 --> 03:02.270
È un po 'test su un file saltare l'istruzione successiva se è chiaro sul bit numero uno se è ancora impostato su alto non

03:02.940 --> 03:04.500
è ancora finito.

03:04.510 --> 03:08.430
Quindi torniamo indietro e controlliamo.

03:08.530 --> 03:13.070
Continuiamo a farlo fino al completamento del convertitore.

03:14.300 --> 03:21.150
Quando cancella il bit, controlliamo e vediamo che è ora cancellato e saltiamo la linea 106.

03:21.250 --> 03:26.330
Saltiamo ora le istruzioni e passiamo ad afferrare i numeri dal buffer.

03:28.170 --> 03:30.720
Non dimenticare la selezione della tua banca.

03:30.900 --> 03:35.220
Anche se stai per leggere un registro, devi selezionare la banca.

03:35.250 --> 03:41.940
So che la selezione della banca è un po 'dura, ma come vedrai quando arriveremo ad

03:41.940 --> 03:49.910
Arduino ci sono pro e contro per ogni sistema, quindi selezioniamo la banca per i nostri risultati bassi e alti.

03:51.000 --> 03:59.370
E mettiamo questi risultati in due auto GP, la bici bassa entra nel 78 0 07 8 nell'alto

03:59.710 --> 04:03.800
livello e morde nel nostro 0 7 9.

04:03.830 --> 04:10.530
Ora, prima di andare avanti nel nostro modo allegro per elaborare i numeri che abbiamo appena ottenuto, andiamo avanti

04:10.640 --> 04:12.860
e impostiamo il bit Go alto.

04:13.160 --> 04:18.970
Quindi il convertitore HD può iniziare a lavorare sulla conversione del testo che richiede tempo.

04:19.010 --> 04:19.560
Destra.

04:20.360 --> 04:23.780
Quindi ci vorrà del tempo per fare tutta la nostra conversione.

04:24.200 --> 04:29.440
E così, si spera, sarà fatta la sua conversione quando torneremo.

04:29.450 --> 04:34.360
Quindi, sappiamo che abbiamo iniziato a correre e andremo a giocare con i nostri numeri.

04:34.610 --> 04:42.770
Ora passiamo al complicato processo di conversione dei nostri due byte in caratteri ASCII che invieremo

04:43.590 --> 04:50.170
due snack al display LCD che prenderanno il caffè prima di iniziare il

04:54.210 --> 04:57.370
prossimo processo di piegatura della mente.

04:57.900 --> 05:03.910
Andiamo avanti un po 'e torniamo a questo primo sgranocchiare e poco tempo.

05:03.960 --> 05:07.530
Diamo un'occhiata al secondo nable prima.

05:09.070 --> 05:13.550
Perché è più complesso scorrere fino a qui riga 148.

05:13.630 --> 05:14.800
Nel mio

05:17.600 --> 05:29.650
codice il primo passo è caricare il byte inferiore nel W. registrati ma lo facciamo usando la funzione swap.

05:29.650 --> 05:36.490
Ora, naturalmente, questo scambio i bocconcini superiore e inferiore perché vogliamo inviare prima il bocconcino superiore.

05:36.490 --> 05:44.920
La seconda cosa che facciamo è eseguire il byte attraverso una funzione AND che rimuove il nibble superiore.

05:45.140 --> 05:53.560
Quindi inviamo una copia di W. registrati ad un altro registro generale 0 7 a.

05:53.670 --> 05:59.960
Useremo quel registro per trasferire il morso ai nostri sottotemi matematici.

05:59.970 --> 06:03.590
Ora questo non cancella il registro W.

06:03.600 --> 06:11.790
Quindi ora abbiamo due copie di questo nobile nello 0 7 di un cimitero e un'altra

06:11.790 --> 06:17.990
copia ancora detenuta nel registro W per sapere cosa dobbiamo fare dopo.

06:18.000 --> 06:25.170
Abbiamo bisogno di determinare se il nibble è un valore di 9 o meno e così visualizzato come

06:25.830 --> 06:35.250
un numero di una sola cifra o se è 10 o superiore viene visualizzato come una lettera per verificare ciò che facciamo è sottrarre

06:35.250 --> 06:41.720
ciò che è nel registro W dal numero 9 e verificare se otteniamo un risultato negativo.

06:41.730 --> 06:50.030
Quindi se il boccone nel registro è 10 o superiore, quindi un esadecimale da a a f otterremo un risultato negativo

06:50.030 --> 06:53.600
perché nove meno 10 equivale a negativo 1.

06:53.600 --> 06:55.860
In questo momento è tutto ciò che ci interessa.

06:55.880 --> 07:04.100
Perché se otteniamo un risultato negativo, verranno impostati i bit di carry Boral nel registro di stato.

07:04.100 --> 07:07.220
È facile da controllare con un po 'di test.

07:07.220 --> 07:18.010
Quindi, se il carry bit è impostato, sappiamo che il numero che abbiamo ottenuto deve essere visualizzato come una lettera.

07:18.070 --> 07:25.510
Da lì possiamo dedurre quale valore di offset dobbiamo aggiungere al Nivelle per inviarlo al

07:25.540 --> 07:28.360
display LCD come carattere ASCII.

07:28.360 --> 07:30.490
Prendilo.

07:33.400 --> 07:41.790
Quindi, se il bit di riporto è impostato, significa che il numero è un 9 o meno.

07:41.910 --> 07:50.910
E così lo inviamo a una subroutine chiamata chiedendo il prep basso che semplicemente aggiunge un offset inferiore al livello

07:51.030 --> 07:52.910
e lo rimanda indietro.

07:53.490 --> 07:54.880
Aggiungerà l'offset.

07:54.900 --> 07:59.740
Abbiamo capito prima che sia 0 0 1 1 0 0 0 0.

08:00.300 --> 08:08.250
Se il carry bit è chiaro, significa che il risultato matematico è negativo e indica che il nibble

08:08.250 --> 08:10.100
deve visualizzare una lettera.

08:10.320 --> 08:21.180
Quindi salterà questo comando di chiamata e chiamerà invece la subroutine di prep di Aski che aggiunge l'offset per convertire il romanzo in

08:21.180 --> 08:24.990
una lettera ASCII da A a F ..

08:24.990 --> 08:30.480
Ora, prima di andare a guardare i sottomarini, voglio solo che tu

08:30.900 --> 08:41.420
te ne accorga e ricorda che quando chiamiamo la subroutine bassa prep di Aski quando ritorna chiamerà immediatamente il separte prep di Aski.

08:41.460 --> 08:43.020
Quindi vediamo cosa succede lì.

08:43.020 --> 08:53.050
Scorrendo verso il basso verso le due subroutine che stanno iniziando qui alla riga duecento otto nel mio codice.

08:53.050 --> 08:55.280
Cerca solo le etichette.

08:55.400 --> 09:01.160
Quindi la subroutine di prep basso in ASCII aggiunge semplicemente l'offset.

09:01.160 --> 09:02.090
Abbiamo capito prima

09:05.030 --> 09:05.910
e

09:08.510 --> 09:15.590
poi lo rispediamo immediatamente sequestrato la prossima linea che chiama il subthme alto prep di ASCII.

09:15.680 --> 09:17.840
Quindi viene qui.

09:18.300 --> 09:27.570
Carichiamo il registro W con il byte che è o una lettera esadecimale o il livello inferiore o un numero

09:27.570 --> 09:30.870
che è già stato convertito in ASCII.

09:30.870 --> 09:36.580
In questo precedente sottoprogramma facciamo un rapido controllo per vedere quale è.

09:36.600 --> 09:41.650
Ora diciamo che era un esadecimale A che è decimale 10.

09:41.850 --> 09:47.630
Saltò la chiamata al Peploe 17 ASCII.

09:47.750 --> 09:55.070
Quindi, quando i dati vengono trasferiti qui utilizzando il GPS 0 7 8, ricorderai che abbiamo cancellato quel punto superiore

09:55.910 --> 09:59.640
quando abbiamo memorizzato il numero in quel registro generale.

09:59.660 --> 10:08.130
Quindi se fosse in un registro che leggerà 0 0 0 0 1 0 1 0 i 4

10:11.320 --> 10:14.140
bit superiori saranno tutti zeri.

10:14.140 --> 10:22.270
Tuttavia se è già stato convertito in un numero ASCII significa che abbiamo aggiunto l'offset di 0 0 1 1

10:22.270 --> 10:24.380
0 0 0 0.

10:24.490 --> 10:29.010
Il bocconcino superiore avrà il set di Savitz.

10:29.030 --> 10:34.000
Infatti saranno le quattro e le cinque.

10:34.000 --> 10:41.140
Quindi dobbiamo fare un rapido test di bit che facciamo qui alla riga 216.

10:41.170 --> 10:49.430
Ora l'ho usato cinque, ma avrei potuto usarlo anche se il bit 5 è impostato su alto, il che significa che

10:49.430 --> 10:51.530
è già stato convertito qui.

10:51.620 --> 10:54.380
Non cambiamo nulla.

10:54.380 --> 10:58.700
Lo rimandiamo indietro da dove proviene.

10:58.700 --> 11:04.090
Se tuttavia il bit non è impostato ad alto significa che il valore è esadecimale da A a F ..

11:04.160 --> 11:06.910
Quindi saltiamo il comando di ritorno.

11:07.280 --> 11:20.450
Aggiungi al Nessus l'offset necessario per convertirlo in una lettera da A a Sandbach.

11:20.530 --> 11:25.710
Ora c'è un sacco di modi in cui puoi farlo, ma questo è un modo e il modo in cui l'ho fatto.

11:25.810 --> 11:28.820
Se non ti piace, non scrivere il tuo codice.

11:33.440 --> 11:41.100
OK torniamo al punto in cui abbiamo chiamato la nostra linea di subroutine.

11:41.100 --> 11:43.850
Centocinquantotto, quindi ora abbiamo detto

11:46.810 --> 11:54.940
che ora abbiamo il nostro numero che è stato convertito in un valore ASCII e ora inviamo

11:54.940 --> 12:02.010
il nostro un byte al display LCD un nibble alla volta proprio come facevamo prima.

12:02.020 --> 12:03.910
Niente che tu non abbia già visto.

12:04.120 --> 12:11.790
Facciamo uno scambio mettendo il morso nel registro con i bocconcini girati intorno.

12:11.920 --> 12:22.290
Cancelliamo il file stampabile e quindi copiamo il piccolo bocconcino superiore con il fermo C e lo inseriamo nei perni

12:22.290 --> 12:23.390
di babordo.

12:23.970 --> 12:32.880
Ora non dimenticare il bit per Port C deve essere impostato in alto perché questa è la linea r per il display LCD.

12:33.300 --> 12:40.350
Quindi lo impostiamo in modo che il display sappia che questo è un personaggio che non inviamo a un comando.

12:40.530 --> 12:46.650
Quindi eseguiamo il trigger della linea utilizzando lo stesso esatto impulso di ciascuna subroutine che abbiamo usato prima.

12:46.710 --> 12:51.650
Quindi carichiamo nel boccone inferiore.

12:51.780 --> 12:52.500
Scusate.

12:53.900 --> 13:01.310
Mandalo sul display esattamente nello stesso modo e voilà abbiamo convertito il nostro personaggio in

13:01.310 --> 13:04.950
ASCII e lo abbiamo inviato al display.

13:05.000 --> 13:13.130
Il cursore si sposta su uno pronto per ricevere il carattere successivo dopo la conversione e la scrittura di tutti e

13:13.130 --> 13:15.290
tre i caratteri sul display.

13:15.320 --> 13:19.590
Ci fermiamo quindi per un momento.

13:19.680 --> 13:25.680
Puoi rimuoverlo se vuoi, ma ciò dà al display solo un secondo effettivamente superiore a zero secondi

13:25.680 --> 13:33.210
di otto secondi se ti ricorderai di visualizzare effettivamente il numero in modo che i numeri lo cambieranno sopra gli intervalli

13:33.240 --> 13:35.610
di otto secondi a zero punti.

13:35.610 --> 13:43.880
Torna quindi all'inizio della routine principale.

13:48.620 --> 13:51.530
Controllando per vedere se il convertitore da

13:54.450 --> 14:00.990
A a D inizia a controllare il convertitore EDT per vedere se ha il nostro numero per noi.

14:08.170 --> 14:10.500
OK, facciamo prima un backup qui.

14:10.500 --> 14:22.260
Esegui il backup fino alla prima conversione che è la riga 27 nel mio codice perché stiamo valutando il nostro display

14:22.320 --> 14:24.640
da sinistra a destra.

14:25.410 --> 14:32.820
Invieremo prima il più alto nibble del secondo nibble, che è il più alto nibble del byte

14:32.820 --> 14:35.550
inferiore uscito dal convertitore A D.

14:36.510 --> 14:44.040
Quindi il terzo nibble che è il livello più basso del byte inferiore perché il numero con cui abbiamo a che fare è

14:44.040 --> 14:45.710
solo di 10 bit.

14:45.750 --> 14:53.490
Il byte superiore ha tutti gli zeri nel nibble superiore che possiamo ignorare completamente quel nibble.

14:54.500 --> 14:57.990
Il nibble inferiore ha solo i due bit più bassi.

14:58.040 --> 15:02.130
Quindi il numero più alto di una preoccupazione sarebbe tre.

15:02.690 --> 15:10.610
Quindi possiamo effettivamente imbrogliare e tralasciare un'intera pila di questo codice perché non abbiamo bisogno di controllare se è un numero

15:10.610 --> 15:17.840
o una lettera che sarà mai superiore a 3 e B non abbiamo bisogno di eliminare il nibble superiore.

15:18.200 --> 15:25.880
Quindi qui puoi vedere che in realtà ho lasciato tutto il codice, anche se questo non è necessario, non abbiamo bisogno

15:25.910 --> 15:28.730
di chiamare la preparazione ASCII in alto.

15:28.910 --> 15:33.770
Non è necessario eseguire un controllo di sottrazione e controllare il bit di stato.

15:33.860 --> 15:37.560
Non fa male nulla di ciò che abbiamo fatto, ma non ne abbiamo avuto bisogno.

15:37.940 --> 15:46.040
Potrei aver appena aggiunto l'offset per i numeri sputare fuori il LCD sputare sul display LCD e due stuzzichini

15:46.280 --> 15:49.770
e voilà siamo stati sul nostro primo personaggio.

15:50.180 --> 15:51.990
Ma dov'è il divertimento in questo.

15:52.250 --> 15:57.280
Quindi ho lasciato tutto questo codice in modo da poter vedere comunque il processo.

15:57.560 --> 16:06.230
Tutto ciò è stato molto complesso e non volevo confondere le cose, quindi costruisci il tuo circuito copia e incolla

16:06.230 --> 16:10.790
il codice in un progetto e programma la tua scelta.

16:10.790 --> 16:19.030
Abbiamo fatto tutto ciò solo per poter vedere una lettura diretta dal nostro plettro e dal convertitore A D.

16:19.040 --> 16:22.020
Ora puoi vedere qui ho usato un pod.

16:22.100 --> 16:35.250
Quindi potrei ottenere il pieno swing da zero a 3 F F che è il numero più alto che puoi ottenere e 10 bit puoi sostituire il

16:35.250 --> 16:42.700
pot con un termistore e un resistore è un partitore di tensione o sei CSL.

16:42.840 --> 16:49.500
Ma ora puoi calibrare le cose perché sai esattamente quali sono i numeri che

16:50.100 --> 16:55.160
il convertitore produce in base alle condizioni dei tuoi sensori.

16:55.230 --> 16:55.850
Tutto ok.

16:56.130 --> 16:56.850
Finisci il tuo caffè.

16:56.850 --> 16:58.170
Te lo sei meritato.