WEBVTT

00:02.470 --> 00:03.240
Va bene.

00:03.360 --> 00:04.860
Sulla tua squadra

00:04.860 --> 00:09.690
Sedici e trentotto hanno pulsanti.

00:10.050 --> 00:17.410
Molto probabilmente hai solo otto pulsanti, ma il chip del controller può gestire fino a 16 pulsanti.

00:17.550 --> 00:24.510
Quindi se hai fornito la tua scheda personale chissà quanti pulsanti ha su di esso il controller

00:24.630 --> 00:27.460
legge quattro righe di pulsanti Multiplex.

00:27.570 --> 00:35.140
Quindi, quando richiedi una lettura dei pulsanti, il controller restituirà i byte.

00:35.280 --> 00:42.810
Fornisce questi dati in un formato simile alle altre istruzioni e dati che la strobo va bassa.

00:42.810 --> 00:46.230
Si invia un'istruzione con un registro a scorrimento.

00:46.470 --> 00:52.980
Quell'istruzione è seguita dai byte di dati e quindi lo stroboscopio diventa alto.

00:52.980 --> 00:54.780
Ora c'è una differenza significativa.

00:54.780 --> 01:06.550
Il controllore sta ora inviando i dati sulla linea d i o che non lo riceve ora sulle nostre schede Hitachi controlliamo la direzione delle

01:06.570 --> 01:10.740
linee dati utilizzando la riga di scrittura read.

01:10.740 --> 01:15.010
Se tenessimo la linea RW bassa stavamo scrivendo alla lavagna.

01:15.120 --> 01:21.560
Se tenevamo alta la linea RW, stavamo leggendo il tabellone della squadra.

01:21.590 --> 01:29.970
Sedici e trenta la direzione dei dati non viene commutata da una linea di controllo ma attraverso le

01:30.030 --> 01:32.220
istruzioni del controllore stesso.

01:32.220 --> 01:39.540
Ora c'è solo un'istruzione che lo fa cambiare direzione sulla linea di uscita dell'ingresso digitale e

01:40.050 --> 01:43.060
questo è l'esadecimine due per due.

01:43.110 --> 01:46.620
L'istruzione di leggere i pulsanti così

01:53.080 --> 02:00.640
nel momento in cui viene ricevuta l'istruzione quarantadue i sedici e trentaquattro della squadra commutano la

02:00.700 --> 02:12.190
linea di uscita dell'ingresso digitale in uscita e utilizza un registro di shift out per inviare i quattro byte dalla matrice della tastiera.

02:12.220 --> 02:18.920
Ora, una volta impostati questi byte, il controller reimposta la linea desiderata su input.

02:19.000 --> 02:25.500
Ovviamente dobbiamo cambiare le modalità sul nostro pin di uscita dell'ingresso digitale Arduino.

02:25.600 --> 02:34.510
Lo stavamo usando come output, quindi abbiamo ottenuto un passaggio dall'output all'ingresso ricevuto i 4 byte utilizzando uno shift in

02:34.630 --> 02:42.050
register e poi abbiamo impostato la linea di uscita dell'ingresso digitale R dinos nuovamente in uscita.

02:42.340 --> 02:53.020
Ma a pagina 2 della scheda tecnica si legge la nota D I dati di output Io sono n pipe open drain.

02:53.020 --> 03:02.380
Uscita quando leggere richiesta chiave collegare resistenza da 1 a 10 K aumentando la resistenza in aumento di 10 K, i dati

03:02.710 --> 03:11.200
letti sono instabili durante il controllo D I O e l'azione del tubo sul fronte di discesa del cambio si

03:11.200 --> 03:13.970
farebbe riferimento al grafico 6 sottostante.

03:14.140 --> 03:22.720
I dati sono stabili durante l'ascesa e se guardi il bel disegno inizi a capire il significato del

03:22.720 --> 03:23.710
formicolio.

03:25.150 --> 03:34.330
Quindi, in sostanza, quello che stanno dicendo è che hai bisogno di un resistore di pull-up qui è sulla linea D Io quando stai

03:34.330 --> 03:36.970
ricevendo i dati su di esso.

03:37.060 --> 03:44.800
La ragione è che usano un effetto di massa sull'output che ha una resistenza così elevata quando è spento che

03:44.800 --> 03:53.050
la linea D I low a d d i o sarà come un filo fluttuante e si ricorda cosa hanno fatto i

03:53.050 --> 03:57.340
cavi fluttuanti sui nostri ingressi digitali ad alta impedenza di ingresso.

03:57.550 --> 04:05.980
Erano così sensibili che avrebbero assorbito il rumore elettrico indotto quindi inserendo un resistore di pull up da 10

04:05.980 --> 04:15.850
k Il filo non è più fluttuante ma tenuto alto per eliminare i segnali errati comodamente sia sul pick che su Arduino

04:16.290 --> 04:23.620
abbiamo la possibilità di utilizzare il segnale interno resistori di pull up che si trovano intorno

04:23.620 --> 04:26.200
al valore di 10 K.

04:26.200 --> 04:27.080
Perfezionare.

04:27.250 --> 04:37.780
Quindi, quando cambiamo la linea dati designata su Arduino dall'output all'entrata, useremo l'istruzione pull

04:37.930 --> 04:40.310
up di input.

04:40.310 --> 04:47.100
Ora ho codice di esempio nella sezione download.

04:47.110 --> 04:56.890
Se ti piace, abbiamo impostato tutto come facevamo prima e se vuoi lasciare il tuo display spento puoi

04:56.890 --> 04:57.970
farlo.

04:58.150 --> 05:02.830
L'ho fatto, ma non importa.

05:02.830 --> 05:13.900
Quindi impostiamo lo strobe troppo basso per inviare un'istruzione che è di quarantadue avvisi, non impostiamo la linea dello stroboscopio

05:13.900 --> 05:15.610
in alto.

05:15.610 --> 05:22.080
Dopo questa istruzione, il controller cambia immediatamente la linea desiderata in uscita.

05:22.180 --> 05:33.910
Quando ottiene quell'istruzione, così cambiamo la linea di dati dell'hardware sul naso in input pull up prendi i quattro byte con 4 shift

05:33.910 --> 05:34.600
nelle

05:37.450 --> 05:44.710
istruzioni e puoi vedere che ho chiamato i miei byte da 1 a 4.

05:45.220 --> 05:48.580
Una volta ricevuti i 4 byte.

05:48.580 --> 06:00.360
Commuta la linea di uscita dell'ingresso digitale R Dino in uscita e imposta la linea stroboscopica in alto.

06:00.570 --> 06:06.840
Siamo tutti di nuovo pronti per inviare più istruzioni ora nel mio schizzo.

06:06.840 --> 06:15.960
Ho impostato la comunicazione seriale e nella funzione loop ho inviato un identificatore

06:18.570 --> 06:31.990
per ogni byte e poi il numero che era effettivamente nel byte ho inserito un ritorno di riga sull'ultimo numero.

06:32.160 --> 06:37.490
Quindi la prossima serie di numeri sarà su una linea separata.

06:37.920 --> 06:45.180
Mi prendo solo una volta che si rompe e poi ricomincia daccapo.

06:45.200 --> 06:48.810
Ora quando flash il mio arduino eseguo il

06:56.610 --> 07:05.310
monitor seriale e ora ricevo un feed di azione dal vivo mentre premo i pulsanti e posso vedere esattamente ciò

07:08.830 --> 07:11.950
che il byte legge che questi

07:26.960 --> 07:33.960
numeri dipenderanno dalla tua scheda perché il controller è costruito per leggere una matrice .

07:34.010 --> 07:41.810
Ora ciò che i pulsanti fanno dipenderà dal modo in cui il produttore ha progettato e cablato la scheda.

07:41.840 --> 07:51.410
Quindi con questo schizzo puoi vedere direttamente quale output stai ottenendo ora sul tuo cheat sheet

07:58.990 --> 08:10.040
jet pack Ho mostrato quali pulsanti influenzano quali bit in quale byte per le schede sono forniti nei miei figli.

08:10.110 --> 08:18.380
Ora, a causa del modo in cui hanno progettato e cablato la scheda, è possibile leggere più pulsanti contemporaneamente.

08:18.420 --> 08:32.710
Quindi se premo s 1 e s allo stesso tempo, Byte 0 leggerà 17 perché entrambi i bit 0 e 4 saranno alti.

08:33.000 --> 08:41.790
Anche a causa del cablaggio di questa scheda, tutti i bit contrassegnati con una X leggeranno sempre 0 perché semplicemente

08:41.790 --> 08:44.200
non sono collegati a nulla.

08:44.280 --> 08:50.620
Quindi quello che fai ora con le tue letture dei pulsanti è limitato solo dalla tua creatività.

08:50.700 --> 09:01.290
Ad esempio, ho un codice di esempio numero 2 che è il primo codice di esempio 4 tranne che ho abbandonato il monitor seriale che ho

09:01.290 --> 09:01.770
abbandonato

09:07.720 --> 09:13.570
la scrittura del monitor seriale e aggiunto alcune linee extra nella funzione loop.

09:13.670 --> 09:20.610
Ho dichiarato una nuova variabile chiamata LCD array in quanto ne avrò bisogno momentaneamente.

09:20.610 --> 09:26.980
Ho quindi configurato la scheda ma ho fatto lampeggiare tutti gli LCD.

09:27.620 --> 09:32.880
Ho spento tutte le OLED prima di accendere il display.

09:33.050 --> 09:45.410
Ho semplicemente messo in modalità sequenziale l'impostazione della modalità di indirizzamento per un ciclo proprio qui per cancellare tutti i 16 indirizzi e

09:45.890 --> 09:52.130
quindi ho attivato il display e l'ho acceso in piena luminosità.

09:52.130 --> 10:02.360
Quindi nella funzione loop ho usato lo stesso codice e le stesse variabili per leggere i pulsanti su quattro byte.

10:02.360 --> 10:12.680
Ho quindi scritto i singoli bit nella variabile dell'array LCD in modo che ogni bit della variabile si allinea con il pulsante

10:12.830 --> 10:22.910
in modo che 0 il bit più a destra nel byte sia premuto il pulsante 8 il bit pulsante 7 di

10:23.560 --> 10:24.590
destra 7

10:29.460 --> 10:38.840
bit 7 sia il più lontano bit di sinistra e viene attivato dal pulsante numero uno di estrema sinistra.

10:38.940 --> 10:43.320
Così ora che ho un singolo

10:46.570 --> 10:54.790
byte con 8 bit che rappresentano tutti gli 8 pulsanti, posso impostare l'indirizzo

10:54.790 --> 11:08.140
sequenziale scrivendo sulla scheda e usare un ciclo for per scrivere la sequenza che scrivo hex 0 0 ai display del

11:08.200 --> 11:23.730
segmento meridionale e poi semplicemente leggi il bit corrente che stiamo leggendo nel nostro byte dell'array LCD e invia quel valore al registro LCD discreto.

11:23.980 --> 11:28.090
Quel valore sarà 0 o 0.

11:28.480 --> 11:36.540
Quindi, quello che succede ora è premere un pulsante per accendere il display LCD corrispondente.

11:36.940 --> 11:43.430
Il codice è essenzialmente lo stesso per scrivere sul segmento sud. I caratteri che scrivi su

11:43.450 --> 11:46.820
un LCD non corrispondono ai loro valori esadecimali.

11:46.840 --> 11:54.820
Ad esempio, se voglio scrivere il carattere 6 su un display a 7 segmenti, non invierò un valore esadecimale

11:54.820 --> 11:55.870
di 6.

11:55.870 --> 12:05.500
In effetti ho mostrato quel personaggio come uno degli esempi sul Cheat Sheet Page 2 per visualizzare un 6.

12:05.770 --> 12:15.550
Vorrei inviare un 7 D esadecimale quindi se dovessi scrivere caratteri da 1 a 8 sul settimo display di

12:15.910 --> 12:24.220
segmenti avrei bisogno di una lunga lista di istruzioni che controllano i singoli bit nel byte

12:24.220 --> 12:31.300
LCD che poi invierebbero un numero esadecimale specifico per visualizzare uno specifico personaggio.

12:31.300 --> 12:33.540
Ora puoi farlo anche con un array.

12:33.550 --> 12:36.560
Non sono entrato negli array nel nostro Dino.

12:36.790 --> 12:46.120
In ogni caso ci vorrà un bel po 'di codice e fondamentalmente alcune tabelle di caratteri per visualizzare correttamente

12:46.120 --> 12:51.710
i singoli numeri sul segmento meridionale mostrano un altro progetto.

12:51.710 --> 13:00.110
Si potrebbe fare è si potrebbe montare questa scheda sul muro al di fuori della porta della camera da letto gli otto pulsanti sono

13:00.110 --> 13:05.970
un modo per inserire il codice top secret per sbloccare la porta della camera da letto.

13:06.110 --> 13:13.700
Potresti avere il tuo Dino che controlla un motore server all'interno che blocca o sblocca un chiavistello sulla tua

13:13.700 --> 13:14.500
porta.

13:14.810 --> 13:23.090
Ad ogni pressione di tasto viene visualizzato il numero che è stato premuto in sequenza sul display del segmento sud digitare il

13:23.090 --> 13:24.260
codice corretto.

13:24.260 --> 13:29.000
Trasforma il servomotore d'argento in posizione di sblocco e sblocca la porta.

13:30.440 --> 13:38.290
Se hai fatto un progetto del genere dovresti eseguire una sorta di quasi rimbalzo dei tasti D.

13:38.450 --> 13:42.530
Si vedono questi pulsanti R D rimbalzati.

13:42.530 --> 13:52.030
Ma se tengo premuto il pulsante ogni volta che passa e legge i tasti, leggerà quel tasto premuto.

13:52.130 --> 14:00.980
Quindi vuoi prima registrare un pulsante, ma poi continuare a tornare indietro e leggere i tasti fino a quando non hai

14:00.980 --> 14:04.250
letto che il pulsante è stato rilasciato.

14:04.250 --> 14:09.320
Quindi puoi procedere a leggere i tasti cercando il pulsante successivo.

14:09.380 --> 14:09.920
Stampa.