WEBVTT

00:01.300 --> 00:08.050
Prima di passare a una programmazione più complessa, dobbiamo imparare a programmare le subroutine in

00:08.590 --> 00:16.900
Arduino che è in realtà in programmazione nel linguaggio C ora le subroutine in C sono chiamate funzioni

00:16.900 --> 00:26.560
e le abbiamo già utilizzate ma non come subroutine se ricorderete il nostro nuda lo schizzo minimo deve avere un minimo di

00:26.560 --> 00:35.440
due funzioni di configurazione e loop e, proprio come le subroutine e altri linguaggi di programmazione, le funzioni verranno eseguite

00:35.440 --> 00:42.100
in sequenza o possiamo chiamare una funzione da qualsiasi punto all'interno del programma.

00:42.220 --> 00:49.050
Infatti nella prossima lezione chiameremo le funzioni da un altro programma completamente diverso.

00:49.420 --> 00:51.280
Quindi facciamo una funzione.

00:51.280 --> 00:54.790
Per prima cosa ha bisogno di un

00:57.710 --> 01:02.120
tipo di ritorno che è stato quel vuoto parola.

01:02.120 --> 01:07.520
Ho detto che quando abbiamo iniziato ad arduino e poi il nome della funzione, questo è il nome

01:07.520 --> 01:09.400
che userete per chiamare questa subroutine.

01:09.500 --> 01:11.410
Quindi non può avere spazi.

01:11.540 --> 01:18.680
Deve essere composto da numeri di lettere o il carattere di sottolineatura e non può avere un numero come primo carattere.

01:18.680 --> 01:20.970
È anche case sensitive.

01:21.080 --> 01:28.320
Ovviamente la parola non può essere un'istruzione o una parola prestabilita come alta.

01:28.410 --> 01:34.640
Gli stessi problemi con le variabili di denominazione saranno schiaffi su due parentesi.

01:34.810 --> 01:36.870
Torneremo su questo in un secondo.

01:37.180 --> 01:44.180
E infine tutto all'interno della funzione stessa è chiuso tra due parentesi.

01:44.200 --> 01:50.330
Si noti che non vi è alcun punto e virgola dopo la dichiarazione della funzione.

01:51.220 --> 01:57.130
Quindi ricostruirò il mio schizzo Dance Dance con le funzioni.

01:57.280 --> 01:58.870
Ora il mio

02:02.100 --> 02:07.710
schizzo originale era davvero lungo a causa di tutti i passaggi della danza.

02:07.700 --> 02:09.810
Siamo in una serie di istruzioni.

02:10.050 --> 02:17.580
Ora dividiamo i miei passi di danza in funzioni separate e poi chiamiamo quelle funzioni dalla

02:17.670 --> 02:19.620
funzione di loop.

02:19.620 --> 02:24.720
Ora la mia prima mossa di danza è semplicemente un passo avanti.

02:24.720 --> 02:30.660
Quindi chiamo la mia funzione con quel nome un passo avanti.

02:30.660 --> 02:33.150
Copio quella mossa

02:46.300 --> 02:52.210
completa con i miei tempi precedenti nella funzione Farò

02:56.630 --> 02:58.520
una

03:01.590 --> 03:05.070
seconda funzione chiamata step back

03:10.300 --> 03:14.710
e copiare la mossa per quella dalla

03:21.120 --> 03:38.530
mia Dance Dance Party Dal mio ballo Dance Party a quella funzione quindi ora ho due funzioni su cui chiamare ho intenzione di copiare e incollare

03:38.530 --> 03:41.860
la configurazione dallo schizzo dance

03:49.040 --> 03:51.020
Dance Dance originale

03:59.950 --> 04:03.900
e ora siamo pronti per partire.

04:04.030 --> 04:13.200
Quindi, nella funzione loop, chiamerò ora le mie subroutine le mie funzioni come ho bisogno di loro.

04:13.390 --> 04:20.610
Inizierò la mia routine di ballo facendo quattro movimenti avanti e indietro per non chiamare una funzione.

04:20.680 --> 04:23.860
Digito semplicemente il nome

04:30.640 --> 04:36.040
della funzione, due parentesi non contengono ancora nulla.

04:36.220 --> 04:42.010
Tutto torneremo su questo in un secondo e un punto e virgola.

04:42.010 --> 04:47.440
Così ho chiamato il passo avanti e poi ho fatto un passo indietro.

04:47.500 --> 04:48.190
Funziona

04:51.090 --> 04:52.550
e poi lo faccio

04:55.800 --> 04:56.780
altre tre volte.

04:59.930 --> 05:09.290
Tutto ciò che il robot farà è andare avanti e indietro in avanti e indietro, sperare in tempo con la musica. In

05:09.290 --> 05:13.000
questo caso ho intenzione di lanciare un ritardo

05:15.510 --> 05:22.840
di un secondo solo così possiamo vedere la fine delle mosse prima che ritorni di nuovo all'inizio.

05:22.890 --> 05:26.540
Ricorda che questa funzione del loop scorre continuamente.

05:26.610 --> 05:36.330
Quindi, poiché ho tutte le funzioni dopo la funzione loop, il programma non andrà mai oltre la fine della

05:36.330 --> 05:37.710
funzione loop.

05:38.040 --> 05:43.690
Tornerà all'infinito all'inizio del ciclo.

05:43.710 --> 05:44.310
Funzione

05:47.610 --> 05:50.400
quando flash il robot con

05:54.770 --> 06:01.710
questo schizzo il robot inizierà la sua sequenza di quattro movimenti in avanti all'indietro.

06:02.480 --> 06:08.720
Metti in pausa un secondo e poi esegui nuovamente i movimenti.

06:09.150 --> 06:18.850
Sta chiamando questi movimenti per funzioni di subroutine.

06:19.500 --> 06:25.080
Se aggiungo altre funzioni come il punto CDO

06:29.110 --> 06:35.880
che ruotava sul posto o rimescola indietro a sinistra oa destra.

06:36.130 --> 06:47.050
Posso costruire una sequenza di danza complessa semplicemente richiamando tutte le funzioni in sequenza di movimento

06:47.230 --> 06:48.800
dal ciclo.

06:48.810 --> 06:49.430
Funziona

07:03.800 --> 07:12.110
rende davvero facile cambiare la routine di ballo e salva tutto un sacco di codice perché in passato ogni

07:12.110 --> 07:19.010
volta che volevo fare un passo avanti avrei dovuto inserire tutte queste righe di codice.

07:19.700 --> 07:30.320
Ho appena sostituito pagine di codice con un paio di chiamate e una copia di ciascuna mossa in una funzione.

07:30.330 --> 07:36.030
Ora potrei impostare anche alcune variabili globali per conoscere i ritardi di temporizzazione

07:39.250 --> 07:47.020
e quindi posso cambiare i tempi dell'intera sequenza di danza modificando un paio di variabili globali o anche

07:47.170 --> 07:51.630
una variabile globale del tempo di battito nella musica.

07:52.030 --> 07:59.890
Chiedi alle subroutine di eseguire alcuni calcoli matematici per calcolare i ritardi necessari durante il movimento

07:59.950 --> 08:06.250
o le pause tra i movimenti in base al tempo di battimento.

08:06.580 --> 08:13.000
Posso quindi farlo ballare più accuratamente al ritmo di musica diversa semplicemente cambiando

08:13.000 --> 08:16.500
una variabile globale all'inizio dello schizzo.

08:16.540 --> 08:27.010
Ora nessuna di queste funzioni ha inviato o restituito alcuna informazione e quindi tutte le funzioni e le chiamate di funzione avevano

08:27.010 --> 08:31.000
queste parentesi vuote, ma siamo in grado sia

08:37.430 --> 08:44.830
di inviare informazioni a una funzione sia di ottenere informazioni indietro quando la funzione ritorna.

08:44.870 --> 08:55.970
Questo è quello che usiamo queste parentesi perché prima di tutto inviamo alcune informazioni a una funzione, invieremo una funzione

08:55.970 --> 08:59.980
nulla, quindi invieremo le informazioni alla funzione.

09:00.080 --> 09:03.340
Ma la funzione non invierà nulla in modo

09:16.180 --> 09:18.780
da rendere la funzione come prima.

09:18.970 --> 09:26.770
Solo tu metti i nomi delle variabili all'interno delle parentesi separate da virgole e spazi.

09:26.770 --> 09:33.190
Se c'è più di un esempio in poche brevi lezioni impareremo come utilizzare

09:34.030 --> 09:36.340
il nostro schermo TFT.

09:36.340 --> 09:45.520
Schermo LCD TFT in modo da dipingere effettivamente ogni singolo pixel sullo schermo fornendo una coordinata X e Y per il

09:45.910 --> 09:53.160
pixel specifico che si desidera dipingere e quindi il colore che si desidera dipingere quel pixel.

09:53.200 --> 10:01.150
È una serie di istruzioni per inviare quel colore sul bus di comunicazione, quindi scriveremo

10:01.360 --> 10:09.070
una funzione per svolgere questo compito chiameremo la nostra funzione void paint pixel.

10:09.070 --> 10:17.150
E tra parentesi inseriremo le variabili x y e spaziate a colori e separate da virgola.

10:18.100 --> 10:26.110
E devi dichiarare il tipo di variabile che si tratti di un intero o di un altro tipo.

10:26.200 --> 10:31.800
Ne parleremo più in dettaglio nella lezione di matematica e microprocessori.

10:31.800 --> 10:42.150
Così ora ho messo tutte le mie istruzioni all'interno delle parentesi su cosa fare con queste variabili.

10:42.150 --> 10:50.490
Ora spero che tu abbia capito cosa sto dicendo qui perché le istruzioni per dipingere sullo schermo

10:50.940 --> 10:53.940
TFT sono piuttosto complicate da capire.

10:53.940 --> 10:55.490
Quindi non voglio confonderti.

10:55.510 --> 11:03.790
Quindi immagina che tra le parentesi ci sia una serie di istruzioni qui.

11:03.830 --> 11:04.930
Va bene.

11:05.460 --> 11:12.350
Mettere l'indirizzo X su strobe bus.

11:13.740 --> 11:24.240
La linea giusta mette l'indirizzo sul flash del bus a destra.

11:24.240 --> 11:31.380
Line ha inserito il valore del colore sullo strobe del bus.

11:32.160 --> 11:33.170
La

11:37.380 --> 11:41.850
linea retta per sapere che ora ho la funzione impostata,

11:45.720 --> 11:47.310
chiamo semplicemente quella funzione

11:52.140 --> 12:00.510
da un'altra parte come la funzione loop e quando la chiamo fornisco i valori per le tre variabili in

12:09.510 --> 12:16.770
ordine e separati da virgole in modo che le variabili all'interno le parentesi sono chiamate argomenti.

12:16.770 --> 12:29.820
Quindi questa chiamata dirà alla funzione di dipingere l'ottavo pixel dal lato sinistro sull'asse x.

12:29.820 --> 12:40.200
Il quarto pixel dall'alto verso il basso sull'asse y e dipingeremo quel pixel con il colore A E doppio qualunque sia

12:40.200 --> 12:41.660
il colore.

12:43.080 --> 12:49.940
Quindi inviamo i dati alla funzione quando li abbiamo chiamati.

12:50.140 --> 12:58.840
Ma quando la funzione termina il suo compito, torna da dove viene e non porta nulla in

12:58.870 --> 12:59.410
cambio.

12:59.410 --> 13:03.190
Lo schizzo continua proprio lì, proprio dove avevo lasciato.

13:03.190 --> 13:12.850
Quindi, supponiamo di voler inviare informazioni dalla funzione, la funzione esegue alcuni calcoli e restituisce

13:12.850 --> 13:16.190
il risultato al suo ritorno.

13:16.210 --> 13:27.220
Quando costruisci la funzione non è più una funzione di vuoto perché restituisce qualcosa che devi specificare di

13:27.220 --> 13:33.360
cosa restituisce riportando un numero intero in virgola mobile.

13:33.460 --> 13:37.300
Quindi restituiamo un numero intero.

13:37.360 --> 13:39.600
Basta che sia semplice.

13:39.790 --> 13:43.790
Quindi iniziamo con l'I. UN..

13:44.410 --> 13:56.220
Quindi il nome della funzione e se avete argomenti, vengono messi tra parentesi come al solito.

13:56.260 --> 13:59.350
Ora per semplificare non userò alcun argomento.

13:59.530 --> 14:03.910
Non stiamo inviando alcuno dei dati alla funzione.

14:04.240 --> 14:10.180
Abbiamo quindi la funzione stessa tra le parentesi graffe.

14:10.180 --> 14:18.240
Ora in questo caso userò una lettura analogica e poi eseguirò alcuni calcoli matematici.

14:19.180 --> 14:25.830
Quindi diciamo che uno zero è collegato a un terzo Mr per leggere la temperatura.

14:26.050 --> 14:32.650
No perché le letture analogiche restituiscono semplicemente un numero che rappresenta la tensione sul pin nel pin 0.

14:32.710 --> 14:41.170
Dobbiamo convertire quella tensione in una temperatura, quindi calibrando le letture analogiche ho

14:41.170 --> 14:49.630
capito che per convertire il numero analogico che ho letto in gradi Celsius.

14:49.630 --> 14:52.120
Ho dovuto usare questa formula

14:55.340 --> 15:01.740
ora perché posso eseguire il mio arduino su 5 volt o tre virgola tre volt.

15:01.740 --> 15:09.120
Fornisco la dichiarazione della tensione di alimentazione altrove nello schizzo, quindi

15:12.800 --> 15:17.480
qui è dove chiamo la subroutine.

15:17.480 --> 15:21.120
È molto poco appariscente, ma è così.

15:21.230 --> 15:31.940
Ho appena detto di chiamare la subroutine della calcolatrice temporanea che salta alla funzione nella mia funzione

15:32.150 --> 15:36.230
eseguirà il calcolo e ritorna da

15:38.780 --> 15:43.880
dove proviene con il valore che ho calcolato.

15:43.880 --> 15:50.930
In questo caso, creo la variabile C temp valida, quindi quando chiamo la funzione la funzione

15:50.930 --> 15:52.640
esegue il calcolo.

15:52.640 --> 16:01.060
Ma si noti che lo schizzo non riconosce la variabile stessa solo il suo valore.

16:01.100 --> 16:07.100
Ho assegnato una temperatura di nome variabile diversa.

16:07.100 --> 16:13.850
Ora l'ho fatto deliberatamente in modo da poter vedere come lo schizzo gestisce le variabili che

16:14.330 --> 16:16.100
passa tra le funzioni.

16:16.100 --> 16:17.470
L'ho praticamente detto.

16:17.600 --> 16:24.380
Chiama la funzione calcolatrice temporanea e qualunque numero ti dia.

16:24.380 --> 16:34.940
Mettilo nella variabile di temperatura, così ha fatto anche se la variabile stessa è stata chiamata C temp nella funzione

16:34.940 --> 16:38.800
solo per farti confondere le cose.

16:39.560 --> 16:39.920
Si.

16:41.030 --> 16:43.660
Quindi ricorda che i computer si occupano solo di numeri.

16:43.700 --> 16:51.110
Non si cura del nome della variabile che si preoccupa di ciò che il numero

16:51.110 --> 17:01.410
è contenuto in quella variabile e quel numero è ciò che viene trasmesso alla variabile che ho assegnato che era la temperatura.

17:01.890 --> 17:08.250
Invia quindi una stampa seriale al monitor seriale mettendo la

17:08.430 --> 17:20.730
stampa delle parole la temperatura corrente e quindi l'avviso di temperatura calcolato Ho usato la variabile di temperatura per la stampa seriale.

17:20.730 --> 17:24.360
Se avessi usato C temp in

17:29.960 --> 17:38.930
loro avrei ricevuto un errore perché non ho dichiarato la variabile C temp nell'ambito del ciclo.

17:38.930 --> 17:48.440
È stato dichiarato nell'ambito della calcolatrice temporanea, così come andiamo avanti, ci immergiamo nelle librerie e useremo

17:48.470 --> 17:51.410
tutte queste funzioni molto.

17:51.560 --> 18:00.530
Nel frattempo, perché non costruisci uno schizzo di danza per esercitarti a scrivere e usando funzioni come quelle

18:00.830 --> 18:11.280
che mi piacciono, faccio solo una serie di mosse di danza con ogni mossa in cui ogni mossa ha una sua funzione.

18:11.280 --> 18:17.760
Quindi chiama semplicemente le funzioni una alla volta per costruire la tua routine di danza.

18:17.820 --> 18:22.530
Guarda tu stesso quanto lavoro e quanto codice ti salva.