WEBVTT

00:01.460 --> 00:07.080
OK, quindi se lo hai capito, il conteggio sembra erratico.

00:07.080 --> 00:12.220
In effetti se si preme il pulsante molto lentamente diventa davvero irregolare.

00:12.230 --> 00:16.910
Quindi, ecco cosa sta succedendo quando si preme quel pulsante i contatti si uniscono.

00:16.920 --> 00:24.860
E a livello microscopico i contatti si scontrano uno contro l'altro e poi si rimbalzano

00:25.040 --> 00:26.710
letteralmente l'uno dall'altro.

00:26.780 --> 00:34.370
Questi contatti possono rimbalzare più volte a seconda di come si preme il pulsante e le condizioni del

00:34.370 --> 00:35.210
pulsante.

00:35.780 --> 00:40.850
Questo orologio a microprocessore è in realtà molto lento rispetto a me.

00:40.850 --> 00:49.940
Voglio dire, il mio microprocessore per laptop el cheapo è in esecuzione ad un punto otto giga Hertz 1. 8 miliardi di cicli di clock al secondo a 112

00:49.940 --> 00:55.830
volte più veloce di quanto il nostro pick non sia ancora in esecuzione.

00:55.940 --> 01:03.300
L'immagine è così incredibilmente veloce che può letteralmente contare i rimbalzi microscopici del tuo pulsante.

01:03.920 --> 01:08.960
Quindi, se il tuo conteggio binario sembra aumentare di uno solo quando premi il pulsante,

01:08.960 --> 01:12.410
ci sono davvero buone probabilità che contino fino a 17.

01:12.440 --> 01:20.150
Ha letteralmente avvolto il conteggio attorno a 0 e ha contato un numero dopo il punto in cui era stato interrotto

01:20.150 --> 01:25.280
quando si preme il pulsante per indicare la velocità di esecuzione del programma.

01:25.280 --> 01:29.890
Quindi questo è un grosso problema che dovrai affrontare nei microprocessori.

01:29.900 --> 01:36.680
Ora ci sono alcuni modi in cui puoi gestirlo con il tuo programma e uno comune è una serie di passaggi.

01:36.800 --> 01:43.690
Si legge che hai premuto il pulsante su cui conta che hai premuto il pulsante e poi torna indietro e controlla

01:43.690 --> 01:44.680
di nuovo.

01:45.370 --> 01:52.810
Se il pulsante è ancora premuto o chiuso, aggiunge al conteggio se il pulsante è ora rilasciato perché è

01:52.810 --> 01:53.970
stato rimbalzato.

01:53.980 --> 02:00.590
Imposta il conteggio su 0 e torna indietro e controlla ancora per vedere se premi il pulsante che hai.

02:00.590 --> 02:08.950
Quindi ricomincia a contare, ma rimbalza di nuovo e quindi imposta il conteggio a 0 e ricomincia a contare quando

02:08.980 --> 02:11.860
rileva che hai premuto il pulsante.

02:11.860 --> 02:17.710
Ora attenderà fino a quando non sarà tornato, per esempio, a fare 50

02:17.710 --> 02:27.110
cicli consecutivi in cui si teneva premuto il pulsante, quindi conta che premendo un pulsante, si aspetta che tu rilasci il pulsante.

02:27.440 --> 02:33.230
Ma mentre stai rilasciando il pulsante, i contatti possono creare o interrompere più volte.

02:33.620 --> 02:40.580
Quindi continua a contare e non considera di aver rilasciato il pulsante finché non conta 50 cicli di

02:40.580 --> 02:43.850
fila in cui viene rilasciato il pulsante.

02:43.850 --> 02:52.490
Ora può sembrare ridicolo, ma questo ti dà un'idea di quanto siano veloci e potenti anche

02:52.490 --> 02:53.870
i microprocessori.

02:54.050 --> 02:56.660
Questo processo è chiamato De rimbalzi.

02:56.780 --> 03:03.540
E sì, il tuo computer desktop analizza la tua tastiera con una frequenza di un secondo, non solo per

03:03.540 --> 03:07.970
vedere cosa hai premuto, ma per quanto tempo è rimasto premuto.

03:08.000 --> 03:10.600
Puoi anche fare un po 'di bilanciamento profondo con l'hardware.

03:11.000 --> 03:13.630
Un condensatore attraverso il pulsante, per esempio.

03:13.750 --> 03:15.710
Ci vuole tempo per ricaricare.

03:15.710 --> 03:22.820
In teoria ci vuole più tempo per caricarsi di quanto non ci vuole per il tempo necessario

03:22.820 --> 03:24.590
per il rimbalzo.

03:24.590 --> 03:30.140
Quindi stiamo andando a modificare il nostro contatore binario del pulsante e lanciare alcuni loop

03:30.170 --> 03:36.170
e contare quanti cicli viene premuto il pulsante e poi fare lo stesso per il rilascio del pulsante.

03:36.170 --> 03:42.230
Ora stiamo andando a imbrogliare un po 'solo per semplificare le cose per questa lezione e

03:42.230 --> 03:51.870
ci limiteremo a contare fino a 50 volte dove il pulsante è stato letto e mostrato in alto non reimposterà il conteggio a 0 nel mezzo

03:51.870 --> 03:53.010
di contare

03:53.310 --> 03:59.640
Se rileviamo che il pulsante che conoscete è stato rilasciato da noi, per esempio, contiamo

03:59.640 --> 04:06.020
semplicemente fino a 50 Hy in rosso sul pulsante e lo chiameremo premendo un solo pulsante.

04:06.030 --> 04:12.310
Questo è semplicemente supponendo che 50 cicli richiederanno più tempo per eseguirsi di quanto occorra affinché

04:12.360 --> 04:14.370
il rimbalzo si fermi.

04:14.370 --> 04:21.990
Verrai introdotto anche nella RAM all'interno del processore che puoi utilizzare per i tuoi programmi.

04:21.990 --> 04:31.780
Hai 16 byte che sono facilmente accessibili e si trovano all'indirizzo di memoria esadecimale 0 0 7 0 e in realtà è un

04:31.820 --> 04:33.730
indirizzo a 12 bit.

04:33.780 --> 04:35.550
Quindi i primi quattro bit non sono usati.

04:35.590 --> 04:39.760
Non ci sono circuiti lì quindi non importa quello che hai messo lì.

04:40.050 --> 04:47.520
E noterai la scheda tecnica in cui scrivono l'indirizzo a volte come x 0 7 0.

04:47.850 --> 04:51.840
X significa solo che non ha importanza perché non è valido.

04:52.470 --> 04:55.280
Diamo un'occhiata al nostro codice.

04:55.830 --> 05:05.710
Tutto nella configurazione è esattamente lo stesso di prima della porta C come output e Port A.

05:05.760 --> 05:07.090
Come input.

05:07.160 --> 05:10.620
Che cosa è.

05:10.780 --> 05:17.450
E iniziamo il nostro ciclo principale controllando per vedere se il pulsante viene

05:21.350 --> 05:25.060
premuto quando si preme il pulsante.

05:25.060 --> 05:28.980
Veniamo inviati al pulsante press loop.

05:29.030 --> 05:30.160
È qui che

05:33.270 --> 05:38.390
diventa divertente perché questo è ancora un contatore binario, la prima cosa che facciamo è incrementare

05:41.570 --> 05:43.980
il numero di pt. S..

05:44.060 --> 05:51.230
Quindi controlliamo per assicurarsi che non abbia ancora raggiunto il numero 16 e se è stato impostato il conteggio a

05:51.230 --> 05:57.410
0 0 proprio come prima, quindi carichiamo il registro W con un numero decimale di 50.

05:57.410 --> 06:00.110
Ora puoi giocare con questo numero se vuoi.

06:00.110 --> 06:07.680
Questo è il numero di cicli che il processore deve visitare e conteggia il valore massimo del pulsante.

06:07.970 --> 06:10.300
Prima di lasciar proseguire il programma.

06:10.640 --> 06:19.150
Prendiamo quindi quel numero e trasferiamo i commenti del registro al file all'indirizzo hecks 0 0 7 0.

06:19.520 --> 06:22.580
Questa è la nostra memoria RAM generica.

06:22.580 --> 06:29.410
Noterai che non dovevo selezionare la banca prima di aver memorizzato quel numero nella memoria generale.

06:29.450 --> 06:35.540
Ci sono alcuni registri nella foto che sono indirizzati in ogni singola banca e queste posizioni generali

06:35.540 --> 06:37.390
sono alcune di queste.

06:38.240 --> 06:44.340
Ora qui nella scheda tecnica vediamo che contengono i byte inferiori in ogni singola banca.

06:44.430 --> 06:50.480
C'è un sacco di motivi per cui l'hanno fatto in questo modo ma per ora basta seguire il flusso.

06:50.480 --> 06:59.700
Una volta che il nostro numero è stato memorizzato nella RAM, andiamo a questo ciclo di controllo per assicurarci che il

06:59.700 --> 07:07.860
pulsante sia ancora premuto ogni volta che il programma passa attraverso il loop. Decora immensa il numero e registra

07:07.860 --> 07:10.530
l'indirizzo 0 0 7 0.

07:10.530 --> 07:13.420
Conta giù un numero alla volta.

07:13.560 --> 07:17.730
Ma questo comando non danneggia solo il numero nel registro.

07:17.730 --> 07:26.190
Fa anche un rapido controllo se il registro è zero salta il prossimo comando.

07:26.190 --> 07:33.290
Quindi questa intera riga è un file di decremento saltare il comando successivo se 0.

07:33.300 --> 07:36.700
Ora ci sono alcuni comandi come questo con una funzione utile.

07:36.780 --> 07:43.410
È già un potente comando a più passaggi, non solo sottrarre uno da qualsiasi registro a cui

07:43.410 --> 07:44.640
lo dico.

07:44.640 --> 07:48.960
Controlla anche quel registro per vedere se è ancora 0 a zero ancora.

07:49.110 --> 07:52.760
E vedi questa virgola e un 1 dopo.

07:53.070 --> 07:54.320
Ho due opzioni lì.

07:54.330 --> 08:01.050
Se metto uno zero lì, toglie il numero dal registro che gli ho detto di sottrarre 1 e poi

08:01.050 --> 08:03.850
inserisce il numero nel registro di lavoro.

08:03.900 --> 08:09.690
Posso quindi continuare a eseguire un po 'di elaborazione matematica su di esso, se mi piace o

08:09.720 --> 08:16.200
se inserisco un 1 lì come è stato fatto, ma inserisco il numero risultante proprio nel registro da cui proviene.

08:16.200 --> 08:22.830
Quindi questo è un comando molto potente e ce ne sono alcuni che vorrebbe visitare

08:22.830 --> 08:28.920
mentre andiamo qui li puoi vedere tutti nelle istruzioni che hai scaricato o

08:29.010 --> 08:34.500
nel foglio dati Pick sotto le pagine del set di istruzioni.

08:34.550 --> 08:42.020
Quindi, se il programma è passato in rassegna e ha contato 50 volte in cui il pulsante è stato premuto quando lo

08:42.530 --> 08:47.060
ha visitato, salta ora questa riga successiva per andare al conteggio 1 comando.

08:47.060 --> 08:52.630
Ora ricarica la nostra memoria RAM generica con il numero decimale di 50.

08:52.640 --> 08:56.840
Anche in questo caso si trova in questo ciclo in attesa

09:00.390 --> 09:04.220
di rilasciare il pulsante se si preme il pulsante.

09:04.230 --> 09:09.510
Salta questo prossimo comando che è il comando per contare 1 nella nostra memoria.

09:09.510 --> 09:18.360
Salterà il conto alla rovescia per saltare al conteggio per comandare il salto al conteggio 2 e continuare a controllare il

09:18.360 --> 09:26.280
ciclo per vedere che hai rilasciato il pulsante ogni volta che conta il pulsante rilasciato sottraete 1 dal numero

09:26.280 --> 09:28.850
in memoria fino colpisce 0.

09:29.930 --> 09:37.850
Quando raggiunge zero, l'istruzione è di saltare l'istruzione successiva che sta per contare su di essa

09:37.940 --> 09:43.100
salta sopra quella istruzione e vede il comando di ritorno.

09:43.220 --> 09:53.580
Ora torna indietro al comando di chiamata da dove era stato interrotto e ricomincia a ripetere il ciclo cercando la prima

09:53.580 --> 09:58.240
volta che si preme di nuovo il pulsante.

09:59.000 --> 09:59.440
OK.

09:59.460 --> 10:01.980
Spero che non sia stato troppo confuso.

10:01.980 --> 10:03.090
Il circuito è già stato costruito.

10:03.090 --> 10:06.340
Hai solo bisogno di flashare il tuo plettro con questo nuovo programma.

10:06.510 --> 10:08.900
OK, vai a vedere come si comporta.

10:08.940 --> 10:15.460
Puoi cambiare il numero di conteggi come vuoi e vedere come si comporta in particolare se premi i

10:15.530 --> 10:22.750
pulsanti Luli che è il momento in cui ottieni il massimo che sai fare e rompere il contatto nello switch.