WEBVTT

00:01.140 --> 00:09.900
Bene, abbiamo visto solo un esempio di un loop in Arduino che era effettivamente necessario nello sketch

00:09.920 --> 00:13.130
di Arduino per la funzione loop.

00:13.400 --> 00:21.550
Quindi diciamo che il mio robot è lì in piedi a fare i piatti e io ottengo il grande bottone rosso.

00:21.620 --> 00:29.100
Dovrebbe smettere di fare i piatti correre in cerchio tre volte urlando al grande bottone rosso.

00:29.420 --> 00:32.100
E poi forse avere un gioco da ragazzi.

00:32.160 --> 00:34.230
Fai fuoco un paio di volte.

00:34.520 --> 00:35.950
Abbiamo un problema.

00:36.020 --> 00:39.470
Come posso farlo eseguire un ciclo.

00:39.470 --> 00:42.520
Solo un certo numero di volte.

00:43.190 --> 00:49.920
Ora, se lo inseriamo nella funzione di loop, finiamo con il nostro robot che corre continuamente in cerchio,

00:49.920 --> 00:54.870
urlando che ha colpito il grosso pulsante rosso e ha sparato al fuoco.

00:54.870 --> 01:01.010
I piatti non saranno mai fatti perché Dio sa che non li farò mai.

01:01.260 --> 01:01.920
Mai aver paura.

01:01.920 --> 01:03.650
Arduino hai coperto.

01:03.660 --> 01:13.380
Esistono più tipi di loop che è possibile riconoscere come simili ad altri linguaggi di programmazione.

01:13.380 --> 01:22.410
Se hai avuto esperienza nella programmazione di altre lingue, il primo è il ciclo while.

01:22.490 --> 01:29.600
È la parola mentre si accorge che non c'è una lettera maiuscola.

01:29.610 --> 01:38.340
Assicurati che il testo cambi quel colore kaki indicando che è riconosciuta l'istruzione seguita da

01:38.340 --> 01:42.200
una condizione da spuntare tra parentesi.

01:43.000 --> 01:52.090
E poi alcune delle parentesi graffe che contengono tutte le istruzioni che si desidera eseguire mentre la condizione da

01:52.600 --> 01:56.520
controllare è stata soddisfatta o trovata vera.

01:57.100 --> 02:02.940
Nota anche l'unica cosa che può essere al di fuori di una funzione è la dichiarazione delle variabili.

02:03.010 --> 02:14.770
Quindi assicurati che questa istruzione sia all'interno di una funzione come la funzione di loop o la funzione di setup

02:14.770 --> 02:24.360
su come funziona, quando incontra D durante il ciclo eseguirà tutto all'interno delle parentesi graffe.

02:25.180 --> 02:35.840
Finché questa condizione è vera, verrà ripetuta continuamente all'interno di questo ciclo mentre la condizione è vera.

02:35.950 --> 02:42.700
Nel momento in cui la condizione non viene soddisfatta, salta le parentesi graffe e continua con

02:42.700 --> 02:47.350
il programma che esegue qualsiasi codice venga dopo le parentesi graffe.

02:48.100 --> 02:56.020
Quindi apri uno schizzo minimo e usiamo i nostri pin interni appena scoperti e scrivi un

02:56.050 --> 02:57.600
ciclo while.

02:57.790 --> 03:10.210
Impostiamo il pin come input pull up e configureremo anche una connessione seriale in modo da poter utilizzare il monitor seriale come indicatore

03:10.210 --> 03:13.380
di ciò che sta accadendo.

03:13.450 --> 03:19.120
Daremo uno schiaffo al nostro ciclo while nella funzione di setup.

03:19.150 --> 03:28.310
In questo modo sappiamo che legge questo ciclo solo una volta che leggerà l'input digitale e fintanto che

03:28.310 --> 03:37.940
viene tenuto in alto da quel resistore pullup, valuta la stampa della linea seriale dicendo qualcosa che indica che siamo

03:37.940 --> 03:41.710
effettivamente in loop all'interno del ciclo while.

03:42.140 --> 03:50.420
Poi, dopo il funzionamento, tutto ciò che accade è qui quando il pintu si è abbassato

03:50.420 --> 03:58.560
e quindi la nostra condizione non è soddisfatta, quindi salterà questa funzione e scenderà qui.

03:58.600 --> 04:04.990
Che cosa succede se vogliamo fare una semplice stampa veloce sul monitor seriale che indica che siamo

04:04.990 --> 04:14.500
fuori dal ciclo il ciclo while in modo da poter semplicemente mettere un filo da pintu e usarlo come un interruttore collegando il pin a

04:14.500 --> 04:19.400
fare uno qualsiasi dei collegamenti a terra tirando l'ingresso verso il basso.

04:19.510 --> 04:24.730
O se lo desideri, puoi mettere un pulsante tra pintu e terra.

04:24.730 --> 04:27.910
Ora qualcosa che ho omesso di menzionare in precedenza.

04:27.940 --> 04:34.850
Mi scuso per poter configurare il monitor seriale come mostrato in precedenza attraverso i menu.

04:38.010 --> 04:48.830
Tuttavia questo pulsante qui sopra è un rapido clic del pulsante su di esso per far apparire il monitor

04:48.830 --> 05:01.120
seriale in modo da caricare il tuo schizzo e quindi aprire il monitor seriale e lo vedrai in loop lo vedrai seduto

05:02.020 --> 05:06.320
lì in loop continuo nel ciclo while.

05:06.340 --> 05:10.460
Non abbiamo scritto il nostro codice nella funzione loop.

05:10.600 --> 05:13.500
L'abbiamo scritto nella sottofunzione.

05:13.690 --> 05:19.800
Così lo abbiamo fatto in modo che sappiamo che sta solo leggendo quel ciclo e correndo contemporaneamente.

05:19.810 --> 05:25.410
Quindi questo è in realtà in loop con il ciclo while stesso.

05:25.450 --> 05:38.210
Ora, nell'istante in cui collego pintu a terra, tirando giù l'input, salta fuori dal ciclo while all'interno di R un messaggio che indica che

05:39.020 --> 05:46.990
ha lasciato il loop e lo fa solo una volta perché abbiamo scritto il codice

05:46.990 --> 05:49.730
nella funzione di setup.

05:49.730 --> 05:59.080
Quindi esegue il codice solo una volta che un'altra forma del ciclo while è il do mentre le

05:59.110 --> 06:05.300
istruzioni sono scritte come fanno le parentesi graffe con tutte le

06:08.760 --> 06:11.870
istruzioni che vuoi che faccia.

06:12.210 --> 06:21.960
Poi mentre e la condizione in cui la differenza sta qui, prima farà tutto ciò che vuoi fatto nelle

06:21.960 --> 06:26.690
parentesi graffe almeno una volta che verificherà la condizione.

06:26.700 --> 06:31.490
E se la condizione è soddisfatta, farà di nuovo il lavoro e le parentesi graffe.

06:32.350 --> 06:37.510
Ovviamente continuerà a farlo mentre le condizioni sono soddisfatte.

06:37.510 --> 06:43.960
Quindi la differenza principale qui è che eseguirà tutte le istruzioni presenti nelle parentesi graffe almeno una

06:43.960 --> 06:44.560
volta.

06:44.590 --> 06:52.990
A prescindere dal fatto che le condizioni siano soddisfatte o meno, controllerà la condizione.

06:53.230 --> 06:59.530
E se la condizione non fosse soddisfatta lascerebbe il ciclo se la condizione è

06:59.530 --> 07:11.250
soddisfatta, allora salterà di nuovo in alto e salterà di nuovo su per fare e continuare a fare il ciclo fino a quando la condizione non è soddisfatta.

07:11.320 --> 07:15.910
Si noti il punto e virgola dopo il bianco la linea del tempo.

07:16.050 --> 07:21.330
Questo è fuori e dopo le parentesi graffe.

07:21.520 --> 07:25.470
Quindi dobbiamo indicare la fine della linea.

07:27.570 --> 07:30.880
Il ciclo successivo è il ciclo for.

07:30.880 --> 07:36.120
Ora questo è il mio preferito perché questo richiama i miei giorni di programmazione di base

07:36.210 --> 07:37.610
quando avevo 12 anni.

07:37.620 --> 07:42.080
Quindi mi ricordo dei giorni in cui programmavo i videogiochi su tutti i miei Vic 20.

07:42.120 --> 07:51.840
Quelli erano i giorni in cui Lou è molto potente in quanto mantiene un conteggio e puoi usare quel

07:51.840 --> 07:59.320
conteggio nelle istruzioni che programmi ma il conteggio viene mantenuto in una variabile.

07:59.730 --> 08:06.720
Quindi è qui che diventa davvero potente perché puoi modificare il conteggio in qualsiasi modo tu

08:06.720 --> 08:11.550
voglia eseguire matematica sia con che con la variabile stessa.

08:12.030 --> 08:18.170
Puoi farlo contare fino al conto alla rovescia in passi di tre ecc.

08:18.660 --> 08:20.140
Quindi funziona così.

08:20.160 --> 08:36.320
La parola per e quindi tra parentesi l'inizializzazione quindi un punto e virgola la condizione che indica quando si desidera terminare il

08:36.320 --> 08:40.750
ciclo e l'altro punto e virgola.

08:41.060 --> 08:44.970
E infine come vuoi arrivare a quella condizione.

08:45.790 --> 08:54.100
Quindi nelle parentesi graffe hai messo le istruzioni che avresti voluto eseguire durante il conteggio.

08:54.220 --> 08:57.190
Voglio che tu veda quanto questo loop possa essere potente.

08:57.340 --> 09:01.580
Quindi useremo un'uscita modulata a larghezza d'impulso per guidare in profondità.

09:01.900 --> 09:11.440
Usiamo il pin tre salti di fili dal pin 3 e macinati alla breadboard e colleghiamo un LCD

09:11.440 --> 09:14.110
e un resistore in serie.

09:14.110 --> 09:21.040
Manterremo il filo o il pulsante su pintu e continueremo a usarlo come modo per fornire input al tuo

09:21.040 --> 09:21.750
programma.

09:22.670 --> 09:32.460
Quindi vai avanti ed elimina la funzione WOW dal tuo setup e imposta il pin 3 per P. W. quando.

09:32.650 --> 09:39.010
Programmeremo 2 cicli per loop e lo faremo nella funzione loop.

09:39.010 --> 09:40.750
Quindi li esegue continuamente.

09:40.750 --> 09:43.810
Quello che faremo è impostare due diversi quattro anelli.

09:43.810 --> 09:52.490
Il primo aumenta il WMO fino a raggiungere il massimo e quindi aumenta la luminosità dello schermo LCD

09:52.490 --> 09:54.290
fino al massimo.

09:54.520 --> 10:02.200
Quindi lascerà quel ciclo e passerà al ciclo successivo per il quale diminuirà la luminosità del display LCD

10:02.200 --> 10:04.800
finché non sarà completamente spento.

10:04.870 --> 10:11.980
Lasceranno quindi quello per loop e loop all'interno della funzione loop di nuovo al primo ciclo.

10:12.040 --> 10:13.990
Quindi facciamolo prima.

10:13.990 --> 10:15.840
Configurare un programma come questo.

10:17.150 --> 10:27.400
La parola per poi impostiamo la nostra variabile che sono variabili che la data è giusta in tutte le lettere

10:28.240 --> 10:31.840
minuscole e iniziamo il conteggio a zero.

10:33.550 --> 10:42.430
Questo è il conteggio per il ciclo for continuerà a eseguire il ciclo for fintanto che la

10:42.430 --> 10:46.060
variabile bright è inferiore a 256.

10:46.120 --> 10:50.680
Questo finché la variabile non raggiunge il conteggio di 255.

10:50.680 --> 11:00.650
Stiamo andando a contare aggiungendo un 1 alla variabile ogni volta che il ciclo viene eseguito con le parentesi graffe.

11:01.810 --> 11:10.540
All'interno delle parentesi graffe utilizziamo semplicemente la stessa variabile, una scrittura analogica che imposta sul pin 3

11:10.840 --> 11:15.690
il pin che guida il set che abbiamo configurato.

11:15.920 --> 11:24.650
Dedichiamo un brevissimo ritardo altrimenti il D sembrerà pulsante perché il conto alla rovescia

11:24.650 --> 11:27.140
è così veloce.

11:27.350 --> 11:33.950
Se sei come me e hai una cronologia di programmazione di base normalmente ti aspetteresti la parola

11:34.490 --> 11:36.530
Avanti che incrementerebbe il conteggio.

11:36.680 --> 11:43.320
Ma in programmazione C è in realtà la parentesi graffa di chiusura che lo fa.

11:43.500 --> 11:49.270
Questo è l'indicatore per tornare all'istruzione 4.

11:49.290 --> 11:56.970
Quindi fintanto che la condizione è soddisfatta in questo caso il nostro conteggio è ancora inferiore a 256.

11:57.240 --> 12:06.910
Quindi aumenterà il conteggio di 1 e il ciclo tornerà all'istruzione 4, quindi scriveremo il secondo ciclo

12:07.240 --> 12:09.260
per questo modo.

12:10.060 --> 12:12.010
Quindi molte cose che voglio che tu noti qui.

12:12.010 --> 12:16.130
Abbiamo iniziato a contare su un numero completamente diverso.

12:16.360 --> 12:19.920
Abbiamo iniziato a contare a 255.

12:20.320 --> 12:26.250
Conto alla rovescia che è dove sono i due simboli di sottrazione.

12:26.370 --> 12:28.560
Sottrarrà 1.

12:28.830 --> 12:36.150
Ogni volta che passa attraverso il ciclo for continuerà a sottrarre 1 finché la variabile è

12:36.150 --> 12:39.870
maggiore o uguale a zero quando raggiunge zero.

12:39.870 --> 12:44.840
Quindi lascerà il ciclo proprio come prima dell'analogico.

12:45.050 --> 12:45.640
Destra.

12:45.660 --> 12:55.400
La variabile da pin 3 vie a una frazione di secondo, poi torna ai quattro avanti e scrivi questa nota e

12:55.430 --> 12:59.240
fai lampeggiare con Dwina e controlla che funzioni.

12:59.300 --> 13:07.080
Dovresti avere un LCD che impiega circa tre secondi per aumentare alla massima luminosità.

13:07.250 --> 13:16.320
Poi altri tre secondi circa per raggiungere la luminosità minima, facciamo tutte le scimmie con le quattro impostazioni in modo da poter

13:16.410 --> 13:18.560
vedere tutto in azione.

13:18.600 --> 13:24.900
E abbiamo un ritardo decente in corso, ma voglio rallentare ancora di più il ritardo perché ci

13:24.900 --> 13:30.920
sposteremo su grandi gradini che sono visibili ad occhio nudo se i tuoi occhi hanno indumenti.

13:30.960 --> 13:32.230
Togliti quei vestiti.

13:32.250 --> 13:37.010
Abbiamo bisogno dei tuoi occhi nudi ok era un cattivo gioco di parole mi dispiace.

13:37.030 --> 13:39.780
Andiamo avanti come se fossimo normali.

13:40.010 --> 13:43.100
Bene, faremo aumentare il ritardo a

13:46.170 --> 13:48.350
mezzo secondo o più.

13:48.480 --> 13:51.530
Puoi impostarlo su qualsiasi cosa desideri, ma qualcosa di lungo.

13:51.580 --> 13:55.080
Quindi puoi vedere i cambiamenti in atto.

13:55.080 --> 14:05.940
Invece di aggiungerne uno ogni volta che si passa a quattro, aumenteremo o diminuiremo di 51.

14:05.940 --> 14:12.330
Ora ho ottenuto quel numero semplicemente prendendo il numero massimo di 255 e l'ho diviso per cinque.

14:12.330 --> 14:17.660
Quindi abbiamo cinque passi uguali nella luminosità che saremo in grado di vedere.

14:18.120 --> 14:19.530
Vai avanti e fai il

14:22.780 --> 14:25.910
flash o lo sappiamo e speriamo che questo si mostri bene sulla fotocamera.

14:26.020 --> 14:32.500
Il P. W. M potrebbe rovinare la fotocamera perché regolerà l'iride sulla fotocamera.

14:33.750 --> 14:40.980
Quindi quello che stai vedendo è il ciclo for che passa attraverso il conteggio in passi di 51.

14:41.000 --> 14:43.360
Ora puoi cambiare quel numero con quello che vuoi.

14:43.550 --> 14:53.360
Ricorda solo che se il tuo conteggio supera 255, il diritto analogico scriverà solo 255 perché è il più

14:53.360 --> 14:54.610
alto possibile.

14:54.770 --> 14:59.120
E può andare solo a zero.

14:59.150 --> 15:11.470
Quindi programmiamo il nostro modifichiamo il nostro programma in un altro modo, giriamo il ritorno a uno in entrambi i loop e poi lanciamo

15:15.690 --> 15:25.280
questa linea subito dopo il ritardo della funzione di ritardo in ogni ciclo, quindi ora stiamo trattando il conteggio

15:25.280 --> 15:28.210
proprio come qualsiasi altra variabile.

15:29.790 --> 15:32.950
E facendo un po 'di matematica su di esso.

15:33.830 --> 15:36.940
Ora può essere matematica molto complessa o matematica molto semplice.

15:36.950 --> 15:38.050
Lo lascerò a te.

15:38.150 --> 15:43.800
Tutto quello che ho fatto qui è stato il conteggio più o meno del 51 di nuovo.

15:44.120 --> 15:53.810
Quindi ogni volta che esegue il ciclo for, fa un passo di 51 sul flind count arduino e vedrai che si comporta fondamentalmente allo stesso modo

15:54.200 --> 15:56.040
in cui è stato.

15:56.300 --> 15:59.830
Ma ora lo sta facendo con un metodo completamente diverso.

16:05.930 --> 16:07.540
Non facciamo un ulteriore passo avanti.

16:07.540 --> 16:12.860
Se mi sbarazzo di questa linea diciamo commentando,

16:16.790 --> 16:28.150
ci vuole un passo di uno sull'impulso con la modulazione ogni 500 millisecondi di mezzo secondo, quindi contare fino a

16:28.300 --> 16:36.130
mezzo secondo finché arriveremo a 255 impiegherà circa due due minuti e 15 secondi.

16:36.160 --> 16:41.700
Questo è un passo molto lento e visibile che dura per sempre.

16:42.100 --> 16:47.470
Quindi modifichiamo questa linea in modo tale che quando spingiamo il

16:50.570 --> 16:59.810
nostro pulsante o connettiamo un filo dal pin di ingresso a quello di massa, allora il nostro conteggio segna per 51.

16:59.810 --> 17:06.650
Quindi qui puoi vedere l'azione che si verifica quando collego il pin 2 in

17:06.650 --> 17:16.490
basso influenzando il passaggio nel conteggio nel ciclo for, eventualmente cogli la potenza di questi loop con questi semplici esperimenti di programmazione.
