WEBVTT

00:01.240 --> 00:09.350
Sei eccitato, stiamo lampeggiando ed Elodie come il nostro programma Hello World che abbiamo fatto con il plettro ed

00:09.350 --> 00:12.010
è un processo molto simile.

00:12.020 --> 00:19.400
Diamo un'occhiata di nuovo a Arduino nel codice lampeggiante per vedere quanto sia simile.

00:19.610 --> 00:27.590
Ora la ragione per cui ho detto di non cambiare nulla nel codice, tranne che per il

00:27.590 --> 00:35.500
ritardo, è perché proprio come il pick ogni pin del microcontrollore Mel può avere più funzioni.

00:35.870 --> 00:45.400
Quindi, se tu avessi cambiato dire che sai per la spilla che hai eseguito il diritto proprio su di esso non avrebbe funzionato

00:45.400 --> 00:46.750
per due motivi.

00:46.750 --> 00:55.780
Uno non ha un LCD su quel pin perché c'è un solo LCD preinstallato sulla scheda per

00:56.350 --> 01:05.330
notare che solo il pin 13 è stato impostato come uscita digitale proprio lì come 20.

01:05.350 --> 01:14.770
Quindi, proprio come la scelta, i pin Atmel possono avere più funzioni, può essere un ingresso digitale o un'uscita

01:14.770 --> 01:22.900
digitale o potrebbe avere l'opzione di un impulso con uscita modulata o forse un convertitore digitale-analogico

01:23.110 --> 01:26.050
o forse un convertitore analogico-digitale.

01:26.470 --> 01:29.500
Quindi, proprio come nella foto, abbiamo dovuto impostare i pin.

01:29.800 --> 01:33.170
Ti ricordi di aver impostato il registro Tristate.

01:33.220 --> 01:41.200
Abbiamo impostato il corrispondente a un pin su una porta in quanto uno per un input o uno zero per un output era

01:42.220 --> 01:43.400
la stessa idea.

01:43.410 --> 01:52.700
Qui diciamo che imposteremo la modalità pin per il pin 13 e la configureremo come output.

01:52.830 --> 01:57.330
Hubble cambierà questo a 12.

01:57.340 --> 02:08.920
Quindi ora il pin 12 è impostato come uscita digitale, quindi, proprio come nella foto, possiamo inviare un massimo o un minimo a quel

02:08.920 --> 02:09.570
pin.

02:09.580 --> 02:15.890
Quindi veniamo qui e cambiamo i 13 pozzi.

02:16.270 --> 02:24.270
Quindi stiamo scrivendo un high digitale e poi un digitazione digitale bassa 12.

02:24.300 --> 02:29.300
Quindi se guardi sulla tua scheda puoi vedere che hanno tutti i pin opportunamente numerati per te.

02:29.790 --> 02:36.330
Quindi, se si limita a lampeggiare il programma modificato sulla scheda, non accadrà nulla, eccetto che il

02:36.330 --> 02:39.360
display LCD della scheda smetterà di lampeggiare.

02:39.380 --> 02:46.030
Tuttavia se metti un LCD dal pin 12 a terra vedrai che l'uscita di uscita ora pulsa.

02:46.050 --> 02:49.250
Ora non dimenticare il tuo attuale resistore limitante.

02:49.340 --> 02:58.340
Questo è un LCD e se si limita un LCD direttamente su quella porta si friggerà sia l'LCD che la

02:58.460 --> 02:58.920
finestra.

02:59.030 --> 03:00.660
Non lo vogliamo.

03:00.890 --> 03:04.470
Quindi queste porte possono essere utilizzate proprio come fa una breadboard.

03:04.490 --> 03:12.170
Attaccare un filo nel ponticello 12 alla basetta e il cavo positivo.

03:12.170 --> 03:22.190
Quindi esegui il tuo LSD in serie con un resistore da 200 ohm a 1 ohm che rimbalza a

03:22.250 --> 03:25.590
terra sulla tua nota Arduino comodamente.

03:25.620 --> 03:34.420
Ho un intero casino di queste Ltd per officine che hanno una resistenza già integrata.

03:34.770 --> 03:45.780
Quindi sto facendo passare il filo positivo nel pin 12 e il filo negativo a terra e puoi vedere che

03:45.780 --> 03:50.290
il pin 12 sta lampeggiando sul display LCD.

03:50.520 --> 03:52.440
Diamo un'occhiata al layout del codice.

03:52.440 --> 03:57.410
Ricorderai che quasi tutti i nostri programmi sono stati disposti in modo simile.

03:57.450 --> 04:03.330
Abbiamo avuto un'intera serie di linee che impostano il plettro per l'uso.

04:03.510 --> 04:11.690
Ha impostato le porte come volevamo usarle per impostare la velocità di clock che non possiamo fare

04:11.700 --> 04:14.620
su Arduino solo per ecc.

04:15.400 --> 04:25.070
Ora, questo set in genere è stato fatto solo una volta nella scrittura, quindi abbiamo quasi sempre avuto un ciclo principale nel nostro programma, una

04:25.080 --> 04:31.570
parte del nostro programma o l'intero programma stesso, che abbiamo appena ripetuto più e più volte.

04:31.850 --> 04:34.270
Bene, è lo stesso con l'Arduino.

04:34.640 --> 04:37.460
Abbiamo istituito le funzioni.

04:37.490 --> 04:45.570
Ora, a cosa serve ora una funzione che ha una funzione nella vita, svolge una funzione che svolge

04:45.570 --> 04:46.710
un lavoro.

04:47.220 --> 04:57.620
In questo caso viene impostata la prima funzione, eseguiamo solo questo codice una volta e tutto ciò che vuoi che tutto

04:57.620 --> 05:07.670
ciò che vuoi venga eseguito una volta entra tra questa parentesi aperta e questa parentesi chiusa le parentesi contrassegna

05:07.670 --> 05:11.420
l'inizio e la fine di quella funzione.

05:12.440 --> 05:16.960
Ora esploreremo questo piccolo vuoto un po 'più avanti.

05:17.100 --> 05:27.780
Ma per ora lasciatemi solo spiegare che se avessimo un robot che eseguiva una funzione può andare ed eseguire un

05:27.780 --> 05:29.190
determinato lavoro.

05:29.400 --> 05:32.850
Ora forse quel lavoro è andare a lavare la tua auto.

05:33.150 --> 05:37.150
Così va e svolge la sua funzione.

05:37.350 --> 05:43.580
Lava la tua auto e poi ritorna quando è pronta per svolgere la sua funzione.

05:43.620 --> 05:45.440
La prossima volta che lo chiami.

05:46.050 --> 05:51.360
O forse la funzione era di andare a prendere il giornale.

05:51.360 --> 05:58.450
Quindi, quando il robot ritorna dalla sua funzione, restituisce qualcosa dalla sua funzione.

05:58.620 --> 06:00.420
Ti dà qualcosa da quella funzione.

06:00.540 --> 06:10.680
Il giornale nella programmazione delle nostre funzioni può a volte andare a fare un lavoro e potrebbe riportarci

06:10.680 --> 06:20.230
qualcosa leggendo da una tastiera o una misurazione della temperatura durante la sua funzione o potrebbe

06:20.230 --> 06:22.310
non restituire nulla.

06:22.570 --> 06:30.010
E quindi questo è ciò che vuol dire che è una funzione, ma non restituisce nulla per te.

06:30.010 --> 06:35.750
Fa semplicemente tutto ciò che c'è tra le parentesi graffe e basta.

06:35.770 --> 06:40.240
Non ti riporta nulla quando termina questa funzione.

06:40.240 --> 06:48.450
Ora la prossima funzione è una nota di loop, proprio come con il plettro, se lo desideri, puoi

06:48.450 --> 06:58.340
progettare il tuo programma in modo che venga eseguito solo una volta, ma quasi sempre vorrai eseguire un ciclo continuo come routine principale.

06:58.770 --> 07:08.730
Bene, tutto in questa funzione ogni riga di codice tra la parentesi e la controvena viene eseguita

07:08.730 --> 07:11.480
in un ciclo continuo.

07:11.550 --> 07:12.320
Quindi qui è giusto.

07:12.330 --> 07:25.560
Dì da hi a pin 12 pesi da 1000 millisecondi scrive da basso a pin da 12 a mille millisecondi.

07:25.560 --> 07:33.900
E questa funzione è un ciclo in modo che salti indietro fino alla parentesi aperta ricominci da capo sopra

07:34.140 --> 07:36.900
di nuovo eseguendo il codice.

07:36.900 --> 07:45.650
Ora, se hai ancora la finestra aperta originale aperta da quando hai iniziato l'ID,

07:46.370 --> 07:55.800
qui non hai questa finestra, vai solo alle basi di esempi di file e al minimo.

07:55.800 --> 07:57.850
Ora guarda questo codice.

08:00.080 --> 08:05.740
Questo è il minimo indispensabile per avere un programma completo.

08:05.750 --> 08:13.640
Questo programma non fa assolutamente nulla ma puoi compilarlo e persino inviarlo al tuo Arduino e non

08:13.640 --> 08:15.050
si bloccherà.

08:15.050 --> 08:16.270
Perché.

08:16.400 --> 08:20.350
Perché soddisfa i requisiti minimi di codifica.

08:20.660 --> 08:27.850
Devi avere almeno una funzione di impostazione e una funzione di loop.

08:28.980 --> 08:35.850
Anche se non hai istruzioni, devi avere queste funzioni anche nello stato di nudo.

08:36.570 --> 08:43.950
Quindi, se ha scritto un programma che volevi eseguire solo una volta in una di quelle rare occasioni

08:43.950 --> 08:53.350
in cui scrivevi le tue linee di codice tra la parentesi aperta e la parentesi chiusa del setup, dovresti comunque avere la funzione

08:53.350 --> 08:59.670
loop anche se non c'erano linee di codice da eseguire all'interno di quel ciclo.

08:59.710 --> 09:02.380
Hai solo un ciclo vuoto.

09:02.520 --> 09:08.790
Ora alcune ultime cose e poi ti lancerò fuori dal nido per scrivere il tuo programma tutto da

09:08.790 --> 09:09.360
solo.

09:09.450 --> 09:14.430
Perché voi ragazzi siete incredibilmente intelligenti e so benissimo che potete farlo.

09:14.490 --> 09:14.720
OK.

09:14.730 --> 09:18.220
Torna al tuo programma Blinkx.

09:19.870 --> 09:25.030
Questo è fondamentale e sarà probabilmente l'errore più comune che commetti.

09:25.030 --> 09:31.150
Si noti che ogni riga di codice ha un punto e virgola alla fine.

09:32.640 --> 09:40.890
Devi avere questo punto e virgola alla fine di ogni singola riga di codice mentre dice al compilatore che è

09:40.950 --> 09:42.990
la fine della linea.

09:42.990 --> 09:45.260
Se lo dimentichi e

09:48.990 --> 09:59.230
provi a compilarlo tutto era alla ricerca di altro codice e invece si imbatté in un'istruzione e andò in crash.

09:59.280 --> 10:07.980
Devi avere quel punto e virgola alla fine di ogni riga ma prestare attenzione alla barra dei messaggi che ti diceva

10:07.980 --> 10:14.970
qual era l'errore ma anche evidenziare la riga in cui si è verificato l'errore o in

10:14.970 --> 10:18.310
questo caso la riga dopo l'errore effettivo.

10:18.380 --> 10:21.690
Ma ti aiuta a risolvere il tuo programma.

10:22.310 --> 10:30.180
Si noti inoltre che ogni riga di codice deve essere rientrata proprio come la programmazione di selezione a destra.

10:30.320 --> 10:38.280
E, ultimo ma non meno importante, puoi aggiungere il tuo codice ai commenti proprio come in laboratorio.

10:38.280 --> 10:44.670
I commenti vengono ignorati dal compilatore e puoi scrivere note a se stessi o ad altre persone.

10:44.700 --> 10:47.170
Perché questo è Arduino.

10:47.550 --> 10:51.410
È tutta la condivisione open source e condivide allo stesso modo.

10:51.810 --> 10:55.860
Ora puoi scegliere di condividere i tuoi programmi con altri.

10:55.860 --> 10:59.970
In questo modo puoi lasciare note per gli altri.

10:59.970 --> 11:07.080
Quindi se condividi il tuo codice con gli altri capiscono cosa hai fatto come e perché e così via.

11:07.080 --> 11:14.260
I commenti sono contrassegnati da due sezioni per l'inoltro di fette come questo

11:17.280 --> 11:18.050
OK.

11:18.190 --> 11:19.690
È ora di allargare le ali.

11:19.690 --> 11:24.680
Ecco la tua sfida dal modulo elettronico analogico.

11:24.730 --> 11:32.100
Dovresti avere alcune Green Ltd gialle e rosse, così come alcuni resistori e una breadboard.

11:32.650 --> 11:45.640
Quindi, fai uscire alcuni ponticelli dalla connessione di terra di arge wino e i pin 13 12 11 10 9 e 8.

11:45.640 --> 11:53.030
Ora vuoi due set di prodotti software come quelli che ho qui, ma puoi collegare tutti i negativi LCD

11:54.510 --> 11:58.950
e poi eseguire un resistore da lì al terreno Arduino.

12:00.490 --> 12:08.620
Quindi far passare i fili da positivo di ogni LCD ai pin da 8 a 13 e lascia il cablaggio verso l'alto.

12:08.620 --> 12:16.990
L'ho eseguito in modo che questo gruppo di Ltd's Green passasse al pin 8 giallo al pin 9 e rosso al pin 10 in questo

12:16.990 --> 12:17.510
gruppo.

12:17.530 --> 12:26.280
Green è andato al pin 11, il nastro giallo 12 rosso, al pin 13 I, quindi ho programmato l'Arduino per accendere e spegnere le

12:26.280 --> 12:34.390
donne in una sequenza temporale e abbiamo ottenuto i semafori in modo che questa luce stia controllando il traffico in una

12:34.390 --> 12:34.960
direzione.

12:34.960 --> 12:42.130
Questa luce sta controllando il traffico nell'altro semplice, così come il nostro.

12:42.310 --> 12:49.210
La tua sfida dovrebbe scegliere di accettare è di programmare semafori o un inseguimento leggero

12:49.210 --> 12:54.500
o se preferisci semplicemente accenderli in una sorta di fantasia animata.
