WEBVTT

00:01.080 --> 00:05.700
OK, ci divertiremo un po 'di più con le nostre luci, aggiungendo un altro paio di Ltd, se

00:05.700 --> 00:06.570
lo si desidera.

00:06.570 --> 00:11.310
E ti sfido a scrivere il tuo codice questa volta.

00:11.400 --> 00:18.720
Ora ti presenterò due nuove istruzioni e come utilizzarle ti forniranno un paio di suggerimenti e alcuni

00:18.810 --> 00:20.150
fogli di codice.

00:20.400 --> 00:24.710
Ma lascerò a te la responsabilità di scrivere il programma da solo.

00:24.720 --> 00:31.110
Ora ti ricordi l'auto KITT di Knight Rider, la luce nella parte anteriore ti farebbe andare avanti e indietro.

00:31.610 --> 00:33.990
Lo faremo con l'LSD.

00:34.100 --> 00:41.080
E in effetti alziamo un po 'la posta e ti sfido a creare vari schemi ora.

00:41.090 --> 00:53.110
Jake Wolf su YouTube dimostra qui alcuni dei modelli che ha sulla sua auto.

00:53.140 --> 01:02.500
Quindi ricorda che hai l'intero set di istruzioni di prelievo completo di come ogni istruzione funziona nella tua scheda

01:02.500 --> 01:05.130
tecnica per la tua scelta.

01:05.360 --> 01:11.170
E ti senti libero di attaccarlo come preferisci, ma ti presenterò due nuove

01:11.170 --> 01:13.410
istruzioni dal set di istruzioni.

01:13.420 --> 01:24.550
L s l f per uno spostamento logico a sinistra e ls sono F per il giusto spostamento logico.

01:24.620 --> 01:28.820
Diciamo che ho un file o registro e contiene questo numero binario.

01:28.910 --> 01:34.740
Invio l'istruzione l s l f che è uno spostamento logico lasciato su un file.

01:35.090 --> 01:42.350
Prende ogni bit nel registro e lo sposta a sinistra di un bit, mette uno 0 nel bit meno

01:42.470 --> 01:49.670
significativo e il bit che esce l'altro capo viene spinto su uno speciale registro a bit singolo chiamato registro

01:49.820 --> 01:50.590
carry.

01:51.720 --> 01:56.520
Usiamo quel registro per le operazioni matematiche e lo affronteremo più in dettaglio più avanti.

01:57.000 --> 02:04.020
Quindi puoi vedere come questa istruzione può essere utile per il nostro carico di luce della tua auto kit. Laxey up con

02:04.020 --> 02:06.990
tutti gli zeri tranne uno sul bit meno significativo.

02:07.170 --> 02:09.020
Hai fino a sei birilli.

02:09.090 --> 02:14.140
Quindi colleghiamo e ho fatto tutti e sei i pin che ora posso spostare il registro a sinistra.

02:14.310 --> 02:21.060
E ogni volta che lo sposto a sinistra, spegne l'attuale Delly e accende il successivo LCD in sequenza.

02:21.060 --> 02:25.890
Ora questo è bello fino alla fine, perché ora possiamo andare nella direzione opposta.

02:26.040 --> 02:26.890
Non è un problema.

02:26.940 --> 02:33.900
Rilasciamo uno spostamento logico delle istruzioni su un file.

02:34.050 --> 02:39.610
Fa esattamente la stessa cosa che fa solo nella direzione opposta.

02:39.840 --> 02:46.980
Carica uno zero nel bit più significativo sposta tutti i bit nel registro un bit a destra

02:47.970 --> 02:51.910
e il bit meno significativo va nel registro carry.

02:53.540 --> 02:58.270
Ora non ci interessa il registro di carry in questo caso perché non stiamo facendo calcoli.

02:58.370 --> 03:04.800
Quindi l'istruzione di spostarsi a sinistra sarebbe simile a questa.

03:04.890 --> 03:10.020
Abbiamo l'istruzione di eseguire uno spostamento logico lasciato su un file.

03:10.200 --> 03:17.150
Quindi diciamo quale file su cui vogliamo eseguire il turno.

03:17.420 --> 03:20.280
E poi c'è di nuovo quel numero di destinazione.

03:20.720 --> 03:27.230
Questa è una di quelle istruzioni passo-passo sempre così potenti in cui

03:27.230 --> 03:35.000
una volta eseguita la traslazione logica possiamo inserire il numero risultante nel registro di lavoro

03:35.000 --> 03:46.260
o direttamente nel file da cui proviene A-one vuol dire che abbiamo restituito il risultato giusto nel registro C registro spostamento logico.

03:46.280 --> 03:46.660
Destra.

03:46.660 --> 03:52.650
Segue lo stesso formato esattamente lo stesso formato.

03:52.660 --> 03:55.770
OK, ecco un modo per rendere Lightwork il kit per auto.

03:55.780 --> 04:02.500
Potresti anche fare una serie di passaggi in cui carichi il registro di lavoro con il numero che desideri,

04:03.160 --> 04:07.600
quindi trasferisci il registro di lavoro alla latenza in questo modo.

04:10.630 --> 04:18.370
Quindi mentre scorre il programma hai appena detto manualmente che quale output vuoi che Manimal

04:18.370 --> 04:22.490
abbia programmato manualmente il pattern di luce.

04:23.830 --> 04:30.910
Questo ha un vantaggio in quanto puoi semplicemente programmare schemi molto complessi perché stai mettendo il tuo

04:31.090 --> 04:35.410
supercomputer incredibilmente ben progettato al lavoro invece del plettro.

04:35.800 --> 04:43.400
Ad esempio, potresti facilmente creare uno schema di luci multiple in due sequenze diverse.

04:57.900 --> 05:05.130
Il vantaggio di usare l'istruzione di spostamento logico è che puoi metterlo in un loop con un bit test.

05:05.130 --> 05:12.540
Quindi, nello spazio per le istruzioni, potresti continuare a spostarti a sinistra finché il tuo test più grande non vedrà che

05:12.540 --> 05:15.100
il bit più alto è ora alto.

05:15.150 --> 05:19.650
Ora nel nostro caso abbiamo solo queste quattro società.

05:19.650 --> 05:25.520
Quindi il bit tre è il bit più alto con un LCD.

05:25.590 --> 05:30.270
Può quindi lasciare quel ciclo e inviarlo al ciclo.

05:30.300 --> 05:35.270
Lo spostamento a destra di un bit zero diventa alto.

05:36.060 --> 05:41.360
Quindi torna al loop spostando a sinistra.

05:41.380 --> 05:47.910
Quindi, se avessi un registro a 16 bit con 16 diversi cavi collegati, ovviamente questo sarebbe

05:48.080 --> 05:49.800
un modo più semplice.

05:50.230 --> 05:54.650
Così come puoi già iniziare a vedere ci sono un sacco di modi diversi per farlo.

05:54.750 --> 05:56.940
E sono tutti corretti.

05:57.100 --> 05:58.700
Funzionano tutti.

05:58.960 --> 06:05.190
Ora ricorda che l'orologio funziona a 16 milioni di cicli al secondo.

06:05.620 --> 06:11.680
Quindi, anche se dai a ciascuna istruzione una media di otto cicli di clock per completare il loro

06:11.680 --> 06:14.830
lavoro sono ancora due milioni di istruzioni al secondo.

06:15.370 --> 06:23.110
Ovviamente è necessario inserire ritardi, altrimenti sembrerà che le donne siano costantemente in movimento.

06:23.170 --> 06:31.660
Non hai accesso alla ram generica delle auto GPS, quindi puoi utilizzarla e impostare un ciclo di conto alla rovescia come quello

06:31.660 --> 06:35.210
che abbiamo fatto con il programma di rimbalzo.

06:35.470 --> 06:39.460
Ma possiamo solo memorizzare un numero di un byte nella nostra ram.

06:39.460 --> 06:44.170
Ciò significa che possiamo contare solo da 255 a 0.

06:44.180 --> 06:50.280
Ora fai un po 'di matematica grezza qui e una media di due milioni di istruzioni al secondo.

06:50.650 --> 06:59.010
Quello è diviso per 2 milionesimi di secondo o 0. 00 0 0 0 0 5 secondi per istruzione.

06:59.080 --> 07:08.860
Quindi, per il conto alla rovescia da 205 a 255, prenderà il punto zero 0 0 0 1 2 7 5 secondi.

07:08.860 --> 07:11.310
Non è un gran ritardo ora.

07:11.770 --> 07:14.360
Quindi devi raddoppiare i tuoi conteggi.

07:14.560 --> 07:22.870
Se impostiamo due registri con un numero decimale di 255 e il conto alla rovescia da

07:22.870 --> 07:35.260
255 a 0 duecentocinquanta cinque volte, 255 volte 255 volte zero punto zero zero zero zero zero cinque secondi equivale a zero punto zero o

07:35.260 --> 07:38.140
da tre a cinque secondi.

07:38.170 --> 07:43.860
Così ora il ritardo sta diventando abbastanza lungo che il tuo occhio potrebbe vederlo ma è ancora molto veloce.

07:43.930 --> 07:47.340
Quindi abbiamo questo tipo di loop ritardato

07:50.270 --> 07:56.170
nel codice di esempio che puoi copiare e incollare e usarlo se vuoi.

07:56.300 --> 07:58.350
E ho già capito i tempi.

07:58.970 --> 08:05.150
Quindi ti ricordi di nuovo nel nostro primo programma di immagini che abbiamo visto che il numero di cicli

08:05.150 --> 08:10.120
di clock necessari per eseguire una funzione può cambiare radicalmente dalla funzione alla funzione destra.

08:10.190 --> 08:13.190
Alcuni passaggi hanno richiesto solo uno o due cicli di clock.

08:13.190 --> 08:15.330
Altri ne hanno fatti otto.

08:15.380 --> 08:19.570
In realtà ho impostato e cronometrato il programma per ottenere una gestione dei tempi.

08:19.880 --> 08:24.860
E ha funzionato a circa sei cicli di clock per istruzione nel mio programma.

08:25.340 --> 08:34.780
Quindi questo può ritardare il ciclo di circa zero punto cinque secondi per eseguire ora.

08:35.040 --> 08:37.570
Ci andrò ma ci andrò comunque.

08:37.590 --> 08:39.910
In realtà è piuttosto semplice.

08:39.960 --> 08:47.040
L'ho impostato come subroutine con il ritorno alla fine.

08:47.310 --> 09:01.790
Per prima cosa carichiamo la prima e la seconda posizione della RAM generica con 255 Quindi impostiamo un ciclo con il

09:01.920 --> 09:10.990
conto alla rovescia 255 volte sulla RAM numero uno quando premiamo 0.

09:11.120 --> 09:14.510
Facciamo il conto alla rovescia sul secondo Ramm,

09:18.950 --> 09:27.110
poi torniamo indietro e torniamo a contare da 255 di nuovo sul primo Ramm continuiamo a farlo finché anche la

09:27.110 --> 09:29.490
seconda RAM raggiunge lo zero.

09:29.840 --> 09:36.920
A quel punto torniamo semplicemente indietro dove mai chiami la subroutine Snel.

09:36.920 --> 09:44.720
Se usassimo un terzo registro, possiamo semplicemente chiamare quel ciclo di Candler tutte le volte che è

09:44.720 --> 09:52.370
necessario per ottenere il ritardo che vogliamo ogni volta che chiamiamo che può ritardare il ciclo.

09:52.400 --> 09:58.660
Otteniamo uno 0. Ritardo di 5 secondi che anche il terzo registro Ramme è un singolo byte.

09:58.660 --> 10:05.530
Quindi possiamo contare fino a duecentocinquantacinque volte e a 0. 05 secondi per chiamata possiamo ritardare fino a dodici

10:05.530 --> 10:11.330
virgola sette cinque secondi prima che sia necessario ottenere un quarto Ramme coinvolto nel conto alla rovescia.

10:13.010 --> 10:21.260
Quindi diamo un'occhiata a un codice di esempio presumendo che abbiamo già impostato tutto e le nostre Ltd sono

10:21.260 --> 10:23.440
sulla porta C ..

10:23.640 --> 10:26.580
Quindi impostiamo un ciclo principale, quindi

10:30.870 --> 10:38.030
impostiamo tutto l'ultimo C a tutti i più alti in modo che tutti i primi giorni siano attivi.

10:38.070 --> 10:50.230
Quindi carichiamo il nostro terzo indirizzo ram registro hex indirizzo 0 7 2 con un conteggio decimale 10 impostato.

10:50.230 --> 10:58.750
Quante volte chiamiamo la subroutine del programma di utilità e a 0. 05 secondi ogni volta che lo chiamiamo che ci dà

10:58.750 --> 11:02.440
circa uno 0. 5 secondi di pausa.

11:02.500 --> 11:12.010
Quindi, dopo aver impostato un'etichetta che segna l'inizio di dove teniamo

11:12.190 --> 11:24.220
queste derivazioni, chiamiamo l'utility delay utility la subroutine che è in basso qui in

11:24.340 --> 11:40.240
basso, che lega il processore per circa 0. Dopo 5 secondi e dopo averlo restituito, contiamo 1 sulla terza RAM e poi

11:40.240 --> 11:44.570
torniamo al rivenditore con il ritardo dell'etichetta.

11:44.680 --> 11:54.040
Quindi torniamo al ritardo di utilità per un altro 0. 05 secondi ritorna indietro con il conto alla rovescia e fallo di nuovo.

11:54.070 --> 11:58.780
Continuiamo a farlo finché il nostro terzo ram non raggiunge lo zero.

12:00.880 --> 12:05.470
Quindi disattiviamo tutti i primi DS su pt. S..

12:06.530 --> 12:16.230
Ricarichiamo la nostra terza posizione del ram con un valore di 10 e quindi ciclichiamo le chiamate di ritardo per l'utility

12:16.230 --> 12:17.060
Eataly.

12:17.420 --> 12:21.990
Quindi inviamo il programma all'inizio del ciclo principale.

12:22.340 --> 12:31.660
Accendere i primi giorni e fare nuovamente il conto alla rovescia ha senso.

12:32.400 --> 12:39.300
Quindi puoi davvero lanciare questo codice in un progetto e flashare la tua foto con te se lo desideri

12:39.300 --> 12:46.440
e se sei davvero coraggioso, sostituisci il terzo registro di ram con una variabile in modo da poter cambiare

12:46.440 --> 12:50.850
semplicemente e facilmente il tempo del lampeggio cambiando un numero .

12:50.850 --> 12:54.120
Quindi ora è il tuo momento di brillare.

12:54.120 --> 12:59.250
Ti darò alcuni errori o problemi comuni in cui ti imbatterai quando stai cercando di

12:59.760 --> 13:04.380
scrivere il tuo programma e alcuni suggerimenti prima di provare a lampeggiare.

13:04.440 --> 13:12.030
Salva il tuo progetto per prima cosa costruisci il tuo programma.

13:12.600 --> 13:22.620
Quindi, se per costruire un successo, il flash pick può appendere il laboratorio vuoto se si tenta di lampeggiare o raccogliere e la compilazione fallisce

13:22.630 --> 13:27.790
a causa di un errore e si otterrà un sacco di cose.

13:27.790 --> 13:30.090
Questa è solo una parte della programmazione.

13:30.100 --> 13:31.980
Non essere troppo duro con te stesso.

13:32.620 --> 13:40.670
Ora, per i principianti, vai avanti e copia e incolla il codice di installazione nel tuo programma.

13:40.910 --> 13:45.650
Questo ti farà iniziare e come la tua programmazione.

13:46.000 --> 13:52.070
Si noti che riconosce i comandi li trasforma in blu scuro.

13:52.080 --> 13:55.240
Diciamo che ho fatto un refuso.

13:56.370 --> 14:04.630
W L invece di L W nota che diventa viola.

14:04.630 --> 14:09.880
Non lo riconosce come un comando quindi assume che sia una variabile di qualche tipo.

14:09.880 --> 14:11.360
Variabili in viola.

14:11.590 --> 14:14.220
Quindi ricontrollalo.

14:14.420 --> 14:15.780
Qualcosa è incasinato lì.

14:17.160 --> 14:26.630
Le etichette sono nere e quando hai bisogno di creare un'etichetta hai bisogno di quei due punti alla fine.

14:27.110 --> 14:37.510
Ma quando si invia il programma a un'etichetta con il comando go o un comando di chiamata.

14:37.620 --> 14:40.950
Non ci sono due punti alla fine del nome di questa etichetta.

14:42.070 --> 14:45.520
Quindi ricorda le uniche linee che dovrebbero essere nella prima colonna.

14:45.580 --> 14:52.060
L'estrema sinistra dovrebbe essere etichette, tutto il resto deve essere rientrato di almeno uno spazio.

14:52.300 --> 14:58.150
In caso contrario, verrà generato un errore quando lo creerai e ti dirà quale fosse la riga

14:58.150 --> 15:03.240
incriminata e probabilmente ti dirà che ha trovato un comando quando si aspettava un'etichetta.

15:03.250 --> 15:14.110
Tutti i commenti dovrebbero diventare verdi se non verdi Hai dimenticato il punto e virgola all'inizio della cometa.

15:14.140 --> 15:18.130
Uno degli errori più comuni che si otterranno è l'etichetta non definita.

15:18.190 --> 15:22.460
Ti dirà quale linea e quale etichetta è andata cercando.

15:22.810 --> 15:25.370
Ci sono diversi motivi per cui questo può accadere.

15:25.480 --> 15:41.190
Uno metti la tua subroutine o etichetta dopo il comando di fine o hai sbagliato a scrivere l'etichetta o il nome dell'etichetta in cui

15:41.190 --> 15:45.850
hai fatto una chiamata o vai a.

15:45.960 --> 15:50.380
Hai usato una capitale da qualche parte.

15:50.430 --> 15:58.470
Hai accidentalmente digitato due lettere di seguito nel nome o tre hai semplicemente dimenticato di

15:58.470 --> 16:04.650
creare un'etichetta se hai dimenticato i due punti alla fine dell'etichetta.

16:07.050 --> 16:15.330
5 Se hai dimenticato di dichiarare una variabile ma hai usato una variabile nel tuo programma.

16:15.840 --> 16:23.520
Questo può accadere se lo scrivi in un comando da qualche parte e sai che intendi inserire la dichiarazione

16:23.520 --> 16:24.670
più tardi.

16:24.810 --> 16:32.400
E poi hai semplicemente dimenticato un altro errore comune che può causare tutti i tipi di stranezza: ti

16:32.400 --> 16:40.790
dimentichi di selezionare una banca ogni volta che esegui qualsiasi comando che implica il cambiamento comporta la modifica di un registro.

16:40.920 --> 16:46.170
Lancia il comando di selezione bancaria solo per essere sicuro che ti farà risparmiare un sacco di capelli che tirano il dolore.

16:46.170 --> 16:47.530
Fidati di me su questo.

16:47.700 --> 16:54.420
L'ho fatto esattamente quando stavo scrivendo questa lezione e mi ci è voluto un tempo per capire

16:54.480 --> 16:56.910
perché il mio programma non funzionava.

16:56.910 --> 17:00.340
Il tuo programma deve avere un comando di fine.

17:01.410 --> 17:07.980
Ma assicurati che sia alla fine, se ti piace che ho provato a fare un paio di volte

17:08.130 --> 17:09.480
e hai messo

17:16.150 --> 17:22.820
il tuo sottomarino che sai dopo il comando, il compilatore sputerà strani errori su come non hai definito un'etichetta.

17:22.840 --> 17:28.520
La verità è che sta cercando un'etichetta dopo il comando di fine.

17:29.040 --> 17:36.770
Ma quando il compilatore lo vede e lo comanda, presuppone che sia la fine del programma.

17:36.790 --> 17:41.360
Quindi un'ultima cosa che in realtà non è un errore comune ma può accadere.

17:41.560 --> 17:45.940
Otterrai uno stack overflow o un underflow dello stack.

17:46.420 --> 17:51.350
L'occorrenza più comune di un overflow dello stack è quando chiami la tua super squadra.

17:51.400 --> 17:52.630
Ma poi stai scherzando.

17:52.750 --> 17:57.260
E invece di inserire un ritorno alla fine della subroutine, metti un goto.

17:57.400 --> 18:03.650
Quindi torna qui e fa di nuovo tutto per ottenere la chiamata al sottomarino.

18:04.120 --> 18:10.690
Alla fine si riversa lo stack perché si hanno troppe chiamate e non si ottengono sufficienti ritorni.

18:12.500 --> 18:16.910
Un underflow dello stack accade più spesso in questo modo.

18:16.950 --> 18:24.380
Non c'è niente qui che mi rimandi all'inizio.

18:24.440 --> 18:35.550
Quindi, una volta completato il ciclo continua, passa attraverso il ciclo temporale, quindi visualizza un comando di ritorno.

18:35.620 --> 18:37.080
Non ha mai avuto il comando del codice.

18:37.300 --> 18:39.280
Quindi lo stack è effettivamente vuoto.

18:39.430 --> 18:43.610
Quindi quando vede il comando return ottieni una condizione di underflow dello stack.

18:43.720 --> 18:47.680
Troppi ritorni non sufficienti chiamate.

18:47.710 --> 18:54.240
Così mentre costruisci il tuo codice guarda gli errori ti dirà spesso esattamente quale sia l'errore.

18:54.310 --> 18:56.860
E a volte anche come risolverlo.

18:56.930 --> 18:59.700
Va bene ti lascio attaccare il programma se funziona.

18:59.770 --> 19:00.310
Hey.

19:00.400 --> 19:02.460
Video nella sezione domande o commenti.

19:02.590 --> 19:03.780
Mostraci cosa hai fatto.

19:03.940 --> 19:10.210
Se non funziona e non riesci a capirlo, pubblica il tuo codice nella sezione delle domande che cosa stai

19:10.210 --> 19:13.140
cercando di fare e che cosa sta facendo.

19:13.150 --> 19:16.790
Un altro insieme di occhi può a volte fare una grande differenza.