WEBVTT

00:01.800 --> 00:09.780
Facciamo uso di uno strumento molto utile disponibile nell'ID Arduino, si chiama il monitor dei cereali e possiamo aprirlo come una

00:09.780 --> 00:17.460
nuova finestra e monitorerà e visualizzerà qualsiasi comunicazione seriale sull'U. S.

00:17.580 --> 00:21.090
porto dal nostro Arduino.

00:21.120 --> 00:28.560
È stato bello ottenere un riscontro diretto dal microcontrollore, specialmente quando abbiamo iniziato a utilizzare la

00:28.560 --> 00:31.390
conversione da analogico a digitale.

00:31.590 --> 00:33.530
Boy Sarà utile lì.

00:33.870 --> 00:40.940
Ma quello che sto per fare è mostrarti l'esperimento di cui ti ho parlato con i miei micro servi.

00:41.310 --> 00:51.920
Quindi ho il circuito usato per la lezione del servo driver e lo stesso schizzo lo modifico in pochi modi

00:51.920 --> 00:55.880
e poi sperimenteremo con il monitor seriale.

00:56.060 --> 01:02.330
Voglio vedere qual è il polso per ogni posizione di quel servo.

01:02.620 --> 01:09.250
Ora non so quale sia quel numero perché lo sai nascosto nell'elettronica o nel microcontrollore.

01:09.320 --> 01:18.380
Quindi otterrò l'Arduino per trasmettere il ritardo che sta usando al monitor dei cereali in modo da ottenere un feedback diretto direttamente

01:18.590 --> 01:20.540
dalla bocca del cavallo.

01:20.630 --> 01:24.460
Così stanno facendo sai che mi dirà esattamente cosa sta facendo.

01:24.740 --> 01:28.370
Quindi se non hai il tuo programma aperto già vai avanti e aprilo.

01:30.620 --> 01:33.030
Lo modificheremo.

01:33.680 --> 01:45.150
Quindi, qui nella funzione di impostazione, inseriremo le istruzioni per aprire le linee di comunicazione seriali con il daut

01:45.150 --> 01:53.850
seriale Daut e noteremo che la S maiuscola si distacca dalla convenzione di istruzioni

01:53.850 --> 01:54.540
qui.

01:54.600 --> 02:00.390
Finora tutte le nostre istruzioni avevano una piccola lettera sulla prima parola e la seconda parola nell'istruzione era in

02:00.390 --> 02:03.440
maiuscolo, ma non è così che l'hanno fatto qui.

02:04.520 --> 02:10.210
Ora ovviamente sai che ora sai che questa è una connessione seriale asincrona.

02:10.490 --> 02:17.870
Quindi per comunicare attraverso una linea seriale dobbiamo stabilire cose come il baud rate e

02:17.870 --> 02:19.590
concordare tale diritto.

02:19.610 --> 02:28.870
Quindi, se semplicemente forniamo la frequenza del bug, la spinta assumerà tutte le altre impostazioni predefinite per te.

02:29.280 --> 02:35.760
Quindi mettiamo il baud rate tra parentesi con 96 cento che è il default più comune.

02:35.970 --> 02:39.320
E non dimenticare il punto e virgola alla fine della riga.

02:40.680 --> 02:49.070
Abbiamo ora stabilito linee di comunicazione seriali in modo che ora possiamo inviare comunicazioni tramite la connessione seriale.

02:49.200 --> 02:51.480
Questo viene

02:54.530 --> 02:59.960
fatto con il comando seriale serial whoops print.

02:59.960 --> 03:07.410
Notate di nuovo la S maiuscola tra parentesi, ora diciamo cosa stampare.

03:07.410 --> 03:09.360
Quindi se

03:12.300 --> 03:14.850
metto qualcosa tra virgolette come

03:19.210 --> 03:29.530
sono intrappolato in questo computer, convertirà tutto nelle quotazioni in un codice ASCII trasmesso attraverso la connessione seriale e quindi

03:30.100 --> 03:36.970
il monitor seriale lo riassembla dall'altra parte nelle lettere e nei numeri che

03:36.970 --> 03:39.020
mettere tra le virgolette.

03:39.070 --> 03:46.050
Quindi non dimenticare di chiudere le virgolette per chiudere le parentesi e mettere il punto e virgola alla fine della riga.

03:46.900 --> 03:48.430
Quindi apriamo il monitor seriale.

03:48.430 --> 03:57.020
Vai a Tools serial monitor e questo farà apparire questa finestra.

03:57.120 --> 04:04.160
E poi questa finestra è dove si svolge tutta l'azione, guarda c'è un paio di opzioni dropdown

04:04.170 --> 04:08.080
qui di cui una è la velocità di trasmissione.

04:08.460 --> 04:14.460
Quindi, qual era la cosa più importante che dovevamo fare quando impostavamo un collegamento di comunicazione seriale.

04:14.640 --> 04:22.090
Dovevamo assicurarci che le impostazioni su entrambe le estremità fossero identiche a quelle del trasmettitore e del ricevitore.

04:22.910 --> 04:29.540
Bene, l'Arduino è il trasmettitore e gli abbiamo appena detto novanta seicento baht proprio qui nel

04:30.500 --> 04:33.580
programma il monitor seriale è il ricevitore.

04:33.740 --> 04:38.300
Quindi dobbiamo assicurarci che anche questo sia a 96 cento baud.

04:38.720 --> 04:44.480
Vedrai tra un minuto cosa succede se sono diversi, ma assicurati che siano entrambi a

04:44.480 --> 04:48.560
seicento al momento e vai avanti e abbaglia gli occhi.

04:48.560 --> 05:00.110
Sappiamo cosa è il nuovo schizzo quando Arduino si ripristina ed esegue il suo programma voilà si ottiene il messaggio

05:00.110 --> 05:11.420
stampato sul monitor dei cereali, quindi inviamo un'altra linea sulla connessione seriale proprio sotto il primo comando di stampa

05:11.690 --> 05:12.780
seriale.

05:12.800 --> 05:13.940
Ho

05:17.070 --> 05:26.350
messo un altro serial altro un altro tra virgolette con qualcosa di simile a non so.

05:26.640 --> 05:27.750
Stavo solo scherzando.

05:30.010 --> 05:32.510
O qualunque cosa tu voglia inserire lì.

05:32.600 --> 05:36.940
Vai avanti e fai lampeggiare facendo no e guarda cosa succede.

05:42.650 --> 05:47.990
Li sto stampando entrambi sulla stessa riga.

05:49.640 --> 05:51.680
Ora per fare qualcosa al riguardo.

05:51.680 --> 06:02.240
Posso cambiare le istruzioni per una stampa su linea seriale inserendo un LN alla fine delle istruzioni, in modo che

06:02.300 --> 06:07.280
la stampa seriale e la stampa seriale si comportino

06:10.530 --> 06:21.060
esattamente allo stesso modo in cui entrambe si comportano esattamente allo stesso modo, tranne che nella linea di stampa seriale.

06:21.060 --> 06:27.570
quei caratteri di controllo ASCII alla fine di qualsiasi cosa tu invii.

06:27.660 --> 06:32.640
Invia un carattere di ritorno a capo e un carattere di nuova riga.

06:32.640 --> 06:40.080
Quindi questi sono i codici ASCII 13 e 10, quindi non li vedi mai, ma sicuramente fa un mondo di

06:40.350 --> 06:46.320
differenza quando carichi il tuo programma su Arduino che lo farà ed eseguirlo di nuovo.

06:50.890 --> 07:00.190
Mette il testo su una nuova riga OK, puoi lasciare quelli lì, se vuoi, andremo

07:00.190 --> 07:02.250
qui in

07:09.130 --> 07:14.770
basso alla funzione di loop e proprio in alto.

07:15.070 --> 07:17.800
Voglio stampare una stampa su

07:24.640 --> 07:27.900
linea seriale di ritardo del servo

07:35.800 --> 07:41.240
in modo da non notare citazioni perché questa è una variabile.

07:41.320 --> 07:49.180
Se lo metto tra virgolette, sarà sufficiente stampare le parole servo underscore delay nel monitor seriale e non

07:49.180 --> 07:50.950
è quello che voglio.

07:50.950 --> 08:00.580
Quello che voglio è sapere esattamente quale sia il mio ritardo in millisecondi che sta dettando l'ampiezza

08:01.420 --> 08:06.400
dell'impulso del tick nel battito del mio servomotore.

08:06.430 --> 08:14.750
Non dimenticare il punto e virgola alla fine e piatto andare avanti e flash il tuo Arduino una volta

08:20.210 --> 08:24.480
che inizia a correre inizierà la stampa del ritardo.

08:25.500 --> 08:32.220
Sullo schermo del monitor dei cereali No, è iniziato alle 1300 perché è così che l'abbiamo programmato proprio lì.

08:35.260 --> 08:46.830
E se premo un pulsante quel numero sale di conseguenza o giù di conseguenza posso ora guardare il monitor del cereale guardare la

08:47.070 --> 08:54.330
posizione del clacson e vedere esattamente che cosa corrisponde a DeLay in quale posizione sul

08:54.330 --> 08:55.270
servo.

08:55.680 --> 09:03.090
Ovviamente questo è molto utile perché se sto progettando un robot e usando un

09:03.090 --> 09:15.750
servo per posizionare il suo braccio o qualcosa posso ora vedere quale numero fa cosa spostare il braccio in una posizione ripetibile abbastanza precisa.

09:15.750 --> 09:20.290
Ora un'altra cosa che posso fare qui che puoi fare, ma con cautela.

09:20.410 --> 09:28.350
Ora ti ricordi che ho detto che i servo possono tipicamente ruotare al di fuori dei loro parametri progettati.

09:28.360 --> 09:31.250
Scopriremo fino a che punto potrei trasformare questi servi.

09:31.320 --> 09:33.960
Posso eseguire un esperimento.

09:33.960 --> 09:36.720
Posso abbassare il ritardo

09:39.580 --> 09:51.850
minimo da 1000 a 300 millisecondi e posso modificare il ritardo massimo da 2000 a dire 4000 millisecondi di

09:51.880 --> 09:52.750
microsecondi.

09:52.750 --> 09:55.540
Scusa microsecondi non millisecondi.

09:55.540 --> 10:02.860
Ora i miei ritardi dovrebbero cercare di guidare il servo ben oltre il normale intervallo operativo.

10:02.860 --> 10:09.820
Ora, se lo fai, fai attenzione perché stai guidando il tuo servomotore proprio contro di esso si ferma

10:09.820 --> 10:15.910
proprio e soprattutto perché ho questo potente potente pacchetto da sei volt collegato ad esso.

10:16.120 --> 10:22.480
Probabilmente posso guidarlo così forte che si romperà cercando di arrivare a una posizione dove non può andare.

10:22.720 --> 10:26.830
Quindi sarò gentile e lento spostandolo fino alle fermate.

10:26.830 --> 10:35.960
Faccio lampeggiare il mio Arduino e una volta resettato si posizionerà al servo al centro proprio come ho

10:35.960 --> 10:36.910
programmato.

10:36.920 --> 10:42.930
Ora posso abbassare il ritardo sempre di più fino a quando il servo non girerà più.

10:46.190 --> 10:49.580
K. Sembra proprio

10:49.590 --> 10:57.020
Quindi il minimo ritardo assoluto che posso inviare è di circa 500 microsecondi.

10:57.030 --> 11:00.960
Ora è come la metà di un migliaio di microsecondi.

11:00.990 --> 11:02.740
Quindi questo è in realtà un po 'più lontano.

11:02.750 --> 11:07.200
Ora andiamo su finché non raggiungiamo l'altro Stop OK

11:16.120 --> 11:18.110
che sembra lì.

11:21.670 --> 11:30.920
Quindi sembra che il numero più grande che posso inviare sia ventitrecentonovanta microsecondi.

11:30.910 --> 11:33.900
Ancora una volta è un po 'più ampio.

11:33.910 --> 11:43.110
Posso uscire dal serval ora sto per girarlo attentamente più verso il centro.

11:43.310 --> 11:45.030
Solo per evitare di sforzarti.

11:45.890 --> 11:54.830
Quindi, usando il monitor seriale, posso scoprire esattamente cosa sta facendo Arduino e collegarlo alla mia progettazione e

11:54.830 --> 11:56.970
programmazione del mio robot.

11:57.020 --> 11:59.980
Adesso il monitor dei cereali sta funzionando proprio ora.

12:00.260 --> 12:07.040
Cosa succede se il baud rate non corrisponde a quello impostato per il monitor

12:07.080 --> 12:09.080
seriale a diciannovemiladuecento baud.

12:09.140 --> 12:10.760
È strano, vero.

12:10.760 --> 12:12.670
L'Arduino sta inviando.

12:12.950 --> 12:13.790
E cosa otteniamo.

12:14.000 --> 12:16.830
Diventiamo senza senso.

12:16.840 --> 12:23.800
Il motivo è perché il monitor seriale sta andando e leggendo un po 'impostato da Arduino che

12:23.800 --> 12:25.390
potrebbe essere uno.

12:25.390 --> 12:32.710
Ritorna di nuovo e un altro diciannovemiladuecento secondi legge di nuovo pensando che

12:32.710 --> 12:34.480
questo è prossimo.

12:34.480 --> 12:39.100
Ma l'Arduino funziona a metà della velocità.

12:39.500 --> 12:42.740
Quindi c'è ancora uno sulla linea, sempre lo stesso bit.

12:42.830 --> 12:50.720
Quindi il monitor ne legge un altro il prossimo bit e l'Arduino inviato era uno 0 non un 1, ma ora

12:50.720 --> 12:52.690
il monitor legge due zeri.

12:52.790 --> 12:55.090
Quindi rovina totalmente le cose.

12:55.100 --> 13:00.590
Quindi se nel tuo cereale Monder diventi un po 'banale, quella è la prima cosa che cerchi sono le

13:00.710 --> 13:02.030
velocità di trasmissione uguali.

13:02.030 --> 13:03.350
Probabilmente no.

13:05.440 --> 13:05.920
OK.

13:05.920 --> 13:07.930
Divertiti con quello nella prossima lezione.

13:07.950 --> 13:15.280
Entreremo nel convertitore analogico-digitale e utilizzeremo nuovamente il monitor dei cereali per fornirci un feedback diretto

13:15.280 --> 13:19.470
su ciò che l'Arduino sta effettivamente vedendo e misurando.