WEBVTT

00:01.950 --> 00:10.850
Come un assemblatore di microprocessori possiamo creare variabili in Arduino in assemblatore di micro-chip, abbiamo dovuto definire la variabile nel

00:11.060 --> 00:17.540
nostro sappiamo che è la stessa cosa, solo che lo chiamiamo dichiarare una variabile.

00:17.570 --> 00:22.510
Quindi dobbiamo fare una dichiarazione al compilatore Arduino.

00:22.700 --> 00:27.430
Userò la parola supercalifragilistic con un d non

00:33.230 --> 00:35.140
un J.

00:35.990 --> 00:44.760
Ma devi dire al compilatore Arduino cosa stai andando a memorizzare lì.

00:45.390 --> 00:50.760
Se si tratta di numeri devi dire che sono numeri delle sue lettere che devi dire in

00:50.760 --> 00:58.860
modo tale che le lettere del negozio sono chiamate variabili di caratteri o di stringa e tutte dedicare una lezione o due solo a quelle successive

00:58.860 --> 00:59.760
su OK.

00:59.970 --> 01:08.580
Per ora dichiareremo solo le variabili che contengono un numero in modo da poter fare casino con qualche logica

01:08.580 --> 01:10.200
e matematica booleana.

01:10.380 --> 01:17.150
Inizieremo dichiarando un numero intero e il formato sarà come questo.

01:17.190 --> 01:22.800
Dichiariamo che sarà un numero intero con il numero in lettere minuscole.

01:22.800 --> 01:28.640
Si noti che cambia il colore quando riconosce il comando.

01:28.860 --> 01:30.870
Quindi il nome della variabile.

01:30.870 --> 01:33.200
Quindi questa è la parola vera.

01:33.660 --> 01:38.320
Utilizzerai la tua variabile come Supercalifragilistic.

01:38.330 --> 01:40.620
Ora posso dire.

01:40.760 --> 01:42.040
Fatto proprio lì.

01:42.050 --> 01:46.700
Attacca un bastone con un punto e virgola alla fine della linea e fallo con esso.

01:46.700 --> 01:49.770
Quella variabile è ora dichiarata.

01:50.270 --> 01:56.960
Quindi il compilatore ha messo da parte la memoria per memorizzare qualsiasi numero io voglia inserire lì.

01:56.960 --> 02:08.870
E ora ogni volta che faccio riferimento a supercalifragilistico nel mio programma, va a cercare quella posizione di memoria.

02:08.870 --> 02:12.690
È riservato solo per quella variabile ora.

02:12.710 --> 02:14.270
Proprio come un laboratorio vuoto.

02:14.270 --> 02:16.320
I nomi delle variabili sono case sensitive.

02:16.400 --> 02:22.520
Quindi se dichiaro una variabile supercalifragilista e poi

02:26.900 --> 02:31.250
più avanti nel programma

02:35.000 --> 02:43.540
faccio un riferimento a supercalifragilistico con una S maiuscola ..

02:43.560 --> 02:53.460
Entrambi sono scritti esattamente allo stesso modo, ma sono variabili diverse a causa di quel capitale S,

02:53.460 --> 02:58.400
quindi stai attento quando usi le variabili.

02:58.490 --> 03:07.590
Inoltre, proprio come in laboratorio, non è possibile utilizzare lo stesso nome di una variabile come istruzione o una costante

03:07.760 --> 03:10.800
preassegnata come la parola in maiuscolo.

03:11.060 --> 03:20.110
Ciao, questo è riservato come comando per un high digitale è stato pre-assegnato all'interno del compilatore in modo da non poterlo

03:20.110 --> 03:20.740
usare.

03:20.740 --> 03:32.290
Non ti è permesso che tu abbia notato anche che ci sono costanti come LHD integrate.

03:32.330 --> 03:35.550
Potresti averlo visto nel più recente programma di esempio Blinkx.

03:35.570 --> 03:41.870
L'ho ignorato perché volevo che vedessi come funzionava il comando digitale giusto.

03:41.870 --> 03:51.010
Ma invece di scrivere il pin 13 è possibile sostituirlo con LCD integrato.

03:51.030 --> 03:51.900
Quindi,

04:00.270 --> 04:09.540
come quando usi quella costante, il compilatore va e cerca il file include per la scheda che stai

04:09.540 --> 04:20.550
usando la scheda che hai impostato nella sezione strumenti quando punti a quella scheda e dici che sto usando questa scheda Arduino

04:20.550 --> 04:27.580
sai che il compilatore ha fondamentalmente aggiunto un file include quando non stavi cercando.

04:27.810 --> 04:39.030
E che include il file include la costante LHD costruita in cui indica quale pin sulla scheda ha la built-in Ltd perché l'Arduino l'altra

04:39.030 --> 04:45.240
una scheda tweener può avere quella Ltd su un pin completamente diverso quindi

04:45.240 --> 04:52.020
il tuo programma non funzionerebbe su un altro tipo della scheda Arduino perché lampeggiava,

04:52.020 --> 04:54.370
conosci il pin sbagliato.

04:54.760 --> 04:58.950
Ad ogni modo, dico tutto questo per dire che puoi dare un nome variabile.

04:58.950 --> 05:06.630
Non è possibile dare un nome variabile come Leidy integrato perché è una costante ed è già utilizzato.

05:06.630 --> 05:21.230
Quindi, se vedi la tua variabile cambiare quel colore turchese cambia il nome perché sta riconoscendo il nome digitato come costante o

05:21.230 --> 05:28.790
comando il nome della variabile dovrebbe rimanere di colore nero.

05:28.790 --> 05:37.380
Ora se voglio posso anche assegnare un valore alla

05:40.240 --> 05:44.240
variabile quando la dichiaro.

05:44.250 --> 05:48.990
Semplicemente metto un segno di uguale e poi il valore che voglio dargli.

05:48.990 --> 05:52.330
Quindi questa dichiarazione è anche valida.

05:52.500 --> 05:59.670
Entrambi abbiamo dichiarato le variabili supercalifragilistic e siamo andati avanti e gli abbiamo dato un valore di un

05:59.670 --> 06:01.370
valore iniziale di 32.

06:01.830 --> 06:10.600
Se non ho dato un valore iniziale e un valore iniziale, lo imposta e gli assegna un valore pari a zero.

06:11.130 --> 06:18.590
Quindi, una volta impostata la variabile, puoi fare un sacco di

06:26.220 --> 06:35.960
cose con essa come aggiungere 1 ad esso ogni volta che esegue la funzione di loop.

06:36.030 --> 06:41.130
Quindi questo è come il comando di incremento che abbiamo fatto nel linguaggio assembly.

06:41.130 --> 06:44.510
Prende la variabile e aggiunge un 1 ad essa.

06:45.440 --> 06:51.000
Quindi questa variabile può variare in tutto il programma quindi la variabile name.

06:51.320 --> 06:55.640
Tuttavia, dove dichiariamo che la variabile è molto importante.

06:55.670 --> 07:03.920
Notare se dichiaro la variabile nel set di funzioni ma lavoro sulla variabile

07:07.740 --> 07:17.730
all'interno della funzione loop se provo a compilare che ottengo questo strano errore parlando di come

07:17.730 --> 07:20.050
non l'ho dichiarato.

07:21.250 --> 07:24.240
Ma ho dichiarato che bugiardo.

07:24.520 --> 07:27.320
Ehi, leggiamo il messaggio di errore Ole.

07:27.390 --> 07:31.320
Non è stato dichiarato in questo ambito sulla terra.

07:31.420 --> 07:33.250
OK, ecco cosa sta succedendo.

07:33.540 --> 07:35.840
Ci possono essere molti scopi.

07:35.940 --> 07:39.120
Praticamente ogni volta che vedi un

07:42.100 --> 07:46.460
tutore aperto e un tutore chiuso è un obiettivo.

07:46.470 --> 07:55.730
Quindi qui nel programma minimo ci sono due diversi ambiti con un set up e il loop.

07:55.730 --> 08:03.200
Ora se faccio una dichiarazione nel set di scope non si applica all'ambito del ciclo.

08:03.200 --> 08:09.710
Ora ci sono alcuni evidenti vantaggi a questo riguardo che penso che la gente dovrebbe discutere riguardo alla

08:09.740 --> 08:10.920
risoluzione dei problemi.

08:11.030 --> 08:17.450
E fondamentalmente se tutti gli ambiti possono cambiare la variabile e hai un problema, può essere difficile

08:17.450 --> 08:21.380
stabilire dove si trova il problema nel tuo programma.

08:21.380 --> 08:27.710
Quindi se si ha la variabile dichiarata in un unico scope e si ha un problema, allora lo

08:27.710 --> 08:28.940
si restringe rapidamente.

08:29.150 --> 08:35.930
Personalmente non vedo me stesso usare variabili come questa in qualsiasi momento, ma è così che viene impostato

08:35.930 --> 08:36.740
il sistema.

08:36.830 --> 08:41.960
Ora puoi dichiarare la variabile in modo che si applichi ovunque.

08:43.180 --> 08:51.970
Questa è chiamata dichiarazione di dichiarazione globale e lo fai facendo le tue dichiarazioni al di fuori di tutti gli

08:53.090 --> 08:54.810
ambiti qui sopra.

08:59.700 --> 09:02.980
Il programma verrà compilato ora.

09:04.670 --> 09:15.380
E ogni riferimento a tutto il mio intero programma ora riconoscerà l'accesso e modificherà la mia neve variabile.

09:15.410 --> 09:20.020
Voglio tornare alla nostra dichiarazione IF.

09:20.250 --> 09:23.580
Possiamo usare variabili in istruzioni if.

09:23.580 --> 09:25.660
Questo li rende molto potenti, naturalmente.

09:25.680 --> 09:31.230
Quindi diciamo che vogliamo controllare il valore della nostra variabile.

09:31.230 --> 09:37.260
La tua variabile può memorizzare un numero fino a 30 2007 167.

09:37.260 --> 09:39.640
Più su questo in un secondo ma vediamo.

09:39.660 --> 09:47.580
Contando sulla mia variabile e accendo la signora quando arriva a dodicimila o più.

09:47.580 --> 09:52.170
Posso scrivere un'istruzione IF nel punto di funzione

09:58.450 --> 09:59.970
del ciclo

10:05.070 --> 10:10.340
per dichiarare prima dichiarare la variabile e poi quaggiù e

10:26.030 --> 10:28.030
fare apparire quella dichiarazione.

10:28.280 --> 10:34.950
E poi aggiungeremo uno a una variabile ogni volta che viene eseguito attraverso il ciclo.

10:35.540 --> 10:43.610
Quindi, nel momento in cui la variabile conta fino a 12000, accenderà l'LCD.

10:43.610 --> 10:52.240
Perché il valore delle variabili sarà maggiore o uguale a dodici mila maggiore o uguale a, ma cosa

10:54.380 --> 10:57.800
succede se voglio controllare un numero specifico.

10:57.800 --> 11:05.090
Che cosa succede se volevo solo accendere lo schermo LCD solo quando il mio supercalifragile aveva un valore di

11:05.100 --> 11:06.130
esattamente dodicimila.

11:06.290 --> 11:13.530
Ora penseresti istintivamente di mettere il segno giusto, ma ti sbaglieresti.

11:14.120 --> 11:15.660
Ero comunque.

11:15.800 --> 11:19.470
Voglio dire, è così che l'abbiamo fatto nella programmazione BASIC.

11:19.790 --> 11:26.510
Ma perché assegniamo i valori alle variabili usando il segno di uguale.

11:26.900 --> 11:31.880
Immagino che il compilatore venga capovolto se si tenta di farlo viene confuso Mi chiedo

11:31.880 --> 11:39.130
se stai cercando di dichiarare una variabile o assegnare un valore a una variabile nel mezzo di una funzione o qualcosa del genere.

11:39.350 --> 11:46.850
Quindi tutto si confonde e si blocca ciò che vuoi sono due segni di uguale.

11:46.910 --> 11:54.820
Ora il modo in cui mi ricordo è che queste cose sono chiamate operatori e questo è un modo per sapere che si

11:55.030 --> 11:56.650
tratta di un'operazione composta.

11:56.680 --> 12:06.700
Potrebbe essere maggiore o uguale o minore o uguale a o se supercalifragile è uguale e

12:06.760 --> 12:09.020
uguale a 12000.

12:09.130 --> 12:11.320
Quindi accendiamo l'LCD.

12:11.350 --> 12:17.920
Quindi, anche se non ha senso per te, memorizza questo perché è il formato che

12:17.920 --> 12:20.640
deve eseguire un controllo uguale.

12:20.710 --> 12:27.760
È inoltre possibile eseguire più controlli contemporaneamente se si desidera con e o o.

12:27.850 --> 12:34.510
Ma ti ricordi che potremmo eseguire una logica e due byte a destra.

12:34.510 --> 12:39.160
Oppure potremmo anche eseguire una logica o due byte.

12:39.160 --> 12:50.160
Quindi per salvare la confusione, rappresentiamo le e e o le funzioni all'interno di un'istruzione if come questa.

13:10.990 --> 13:22.760
Quindi se una lettura digitale sul pin 2 è alta e una lettura digitale su 5 è alta allora facciamo cose.

13:22.780 --> 13:31.240
Quindi, in questa affermazione se entrambi i pintu e il pin 5 fossero tenuti in alto,

13:31.240 --> 13:42.170
farebbero il resto tra le parentesi graffe o inseriremo queste due linee verticali su un tasto sulla tastiera della mia tastiera.

13:42.170 --> 13:45.340
È la stessa chiave del backslash e tieni premuto il tasto Maiusc.

13:46.060 --> 13:53.860
Quindi questa affermazione dovrebbe verificare se il pintu era alto o il pin 5 era alto.

13:53.860 --> 14:01.970
Se uno di noi in alto farebbe il resto tra i Brace, continueranno a tornare alla variabile, le

14:01.980 --> 14:05.180
tue variabili intere sono 16 bit.

14:05.220 --> 14:09.830
Quindi possono memorizzare un numero enorme ma è firmato.

14:09.840 --> 14:12.100
Cioè può essere positivo o negativo.

14:12.300 --> 14:20.070
Quindi puoi impostare un negozio di dire 12000 negativi nella tua variabile se vuoi.

14:20.070 --> 14:28.800
Ora il modo in cui funziona è che memorizza il numero in byte i primi 15 byte contengono il numero e il

14:28.860 --> 14:32.600
16 bit funge da indicatore positivo o negativo.

14:33.450 --> 14:37.940
Quindi, quanto può essere grande un numero in 15 bit.

14:39.430 --> 14:42.320
Trentaduemilasettecentosessantasette.

14:42.390 --> 14:45.520
E questo può essere positivo o negativo.

14:45.570 --> 14:49.270
Quindi assegni il valore come faresti normalmente.

14:49.350 --> 14:56.760
E tu hai appena gettato un negativo di fronte ad esso una cosa importante da notare qui,

14:56.940 --> 15:04.980
anche se qui ho questo all'interno del mio ciclo che aggiunge uno a supercalifragilistico ogni volta che viene eseguito

15:05.010 --> 15:14.980
attraverso il ciclo, quindi continuerà ad aggiungere un 1 alla mia variabile Bene, arriva a 32000 767 e poi vede di nuovo questa linea.

15:16.740 --> 15:24.890
E quello che accadrà è che il numero si avvolgerà attorno a quello che è supercalifragile andrà a zero.

15:25.350 --> 15:29.700
Quindi tienilo a mente quando gestisci le tue variabili.
