Archivi tag: robot

Tube Follower – EduRobotKids un piccolo robot per la scuola dell’infanzia e la scuola elementare

Un progetto che nasce qualche giorno fa da una richiesta specifica di un’amica collega.

Qualche giorno fa squilla il telefono…

Conversazione:

Collega: “Ciao Michele ti ricordi di me sono V., ho seguito il tuo corso sulla realizzazione di robot a basso costo, avrei bisogno di un aiuto per inventare un progetto per i miei allievi”

Io: “certo dimmi”

Collega: “voglio provare a realizzare qualcosa di molto semplice, un robottino che deve seguire un percorso, i bambini potranno modificare a piacimento con molta semplicità il tragitto senza toccare il robot. I tragitto diventerà poi uno storytelling fisico, un plastico in cui si muoverà il robottino, in questo modo credo di riuscire a realizzare attività di geografia, italiano e matematica coinvolgenti e divertenti. I bimbi inseriranno oggetti da loro costruiti all’interno di questo plastico che realizzeremo in classe. Vorrei se possibile che il tutto costi pochissimo, in modo da poter replicare il progetto per più classi”.

Io: ”facciamo due versioni, una prima versione semplicissima ed una seconda semplice :-).

Prima versione
Sarà una piccola macchinina che avrà un solo motorino alimentato da un piccolo pacco batterie con interruttore, il suo movimento sarà in una sola direzione. I bambini potranno impostare il tragitto a piacimento senza utilizzare la programmazione, dovranno concentrasi solamente sul movimento e la direzione.

Seconda versione
I bimbi potranno controllare la marcia e lo stop usando un micro:bit remoto che comunica con un micro:bit che controlla il motore.

Con 1 ora di progettazione su Tinkercad nasce: EduRobotKids

In realtà più che un robot si tratta di una semplicissima macchinina, pensata per sviluppare attività di storytelling per gli studenti più giovani, si tratta quindi di una piccola macchinina elettrica che potrà essere secondo necessità modificato e abbellito dai bambini, ciò che vi condivido si tratta di una prima versione che sto aggiornando in questi giorni, nella versione successiva, più compatta nelle dimensione, aggiungerò elementi che facilitano la modifica della struttura da parte dei bambini.
La piccola macchinina elettrica viene direzionata attraverso una monorotaia realizzata con un tubo flessibile corrugato da elettricista da 10 mm.
Le attività che si possono realizzare sono molte, per esempio potrebbe essere utilizzato per l’apprendimento della geografia e collegare luoghi su una mappa con la scelta di un percorso realizzando spostando la rotaia, ma per gli studenti più grandi (5’ elementare) potrebbe essere anche un modo per riprogettare il rover imparando ad utilizzare Tinkercad.

Materiali:

Tubo corrugato da 15 m sezione 10 mm

Pacco batterie con interruttore per due batterie AA da 1,5V

2 Cappellotti piccoli da (sezione filo 1,5 mm^2) oppure un mammut da 3A

Un motore da 3-6 Vcc

Due ruote da 70 mm

Tutto può essere trovato a bassissimo costo su qualsiasi store online.

Allego i sorgenti grafici che potete prelevare da Thingiverse per la stampa 3D della prima versione in modo che anche altri possano realizzare il progetto.

Spero che EduRobotKids possa essere utile.

Buon Making a tutti

Materiali per il corso: creare un kit di robotica educativa a basso costo

Lascia una risposta

Sto ricevendo diverse mail da colleghi che mi chiedono quali materiali acquistare affinché possano produrre insieme a me durante il corso gli stessi robot che andremo prima a progettare e poi costruire.
L’idea, come esposta nella presentazione del corso, è quella di creare qualcosa a bassissimo costo con materiali economici.
Io vi mostrerò come progetto e come ho progettato alcuni kit che ho utilizzato per i miei allievi che ho poi modificato nella struttura per renderli più semplici da assemblare da parte di utenti che non hanno mai affrontato queste sperimentazioni.

Partirò dalla realizzazione di una struttura realizzata in Foam Core su cui disporremo dei servomotori a rotazione continua il tutto controllato da un micro:bit che programmeremo per far fare semplici movimenti al robot. Successivamente vi mostrerò come controllare remotamente il robot mediante un secondo micro:bit. Successivamente aggiungeremo qualcosa per rendere il robot autonomo nei movimenti e cercare il più possibile di evitare ostacoli.

Questo che vedete di seguito è uno dei prototipi realizzati per preparare il corse, ne saranno mostrati anche altri e molto probabilmente vi proporrò anche altre soluzioni di piccoli bracci robot ed insetti robot, nel caso i tempi non consentissero di mostrare tutti i progetti lascerò ai corsisti i sorgenti grafici per la realizzazione.

Vi mostrerò inoltre come realizzare una struttura diversa interamente stampata in 3D simile a quelle che trovate nella sezione BBC micro:bit di questo sito.

Di seguito la lista dei materiali per poter realizzare il robot mostrato sopra.
Potete trovate i materiali su diversi store online.

Foma Core da 5 mm
(pannello costituito da una struttura a sadwitch costituito da due superfici di carta rigida e una parte centrale di spugna)
Colla vinilica
Stuzzicadenti
Carta adesiva bianca formato A4
2 Cappellotti piccoli da (sezione filo 1,5 mm^2) oppure un mammut da 3A
Contenitore 4 batterie AA con interruttore
2 micro servomotori a rotazione continua (360°) a cui connetteremo le ruote
2 ruote da 60 mm per servomotori
1 biglia di vetro da 15 mm
1 mini breadboard da 170 punti
jumper corti maschio/maschio (fili da usare per la breadboard)
in alternativa filo elettrico AWG 22 oppure un pezzo di cavo di rete che dovrete sguainare e ricavarne dei pezzi di filo
Jumper maschio femmina
4 batterie AA da 1,5V (da utilizzare per alimentare i servomotori)
2 batterie AAA 1,5 V (per l’alimentazione del micro:bit, già comprese nel kit base di micro:bit)
1 contenitore per le due batterie da 1,5V AAA (già comprese nel kit base di micro:bit)
Fascette elettriche da 2mm
1 kit micro:bit base V1 oppure V2
Edge Connector Breakout Board per micro:bit
Sensore ad ultrasuoni HC-SR04
opzionale – Kitronik Servo:Lite board (che potrà essere utilizzati con progetti simili a quelli indicati nella sezione BBC micro:bit di questo sito)

Se sarà possibile mostrerò una soluzione per realizzare robot che utilizzano motori più potenti, ma per questo tipologia di progetto sarà necessario avere un po’ più di dimestichezza nella realizzazione di semplici circuiti elettronici e disporre di un saldatore elettrico a stagno, ovviamente vi lascerò tutte le indicazioni tecniche per svolgere in autonomia questa seconda tipologia di robot

2 motori elettrici in CC 3-6V
a cui verranno collegate le ruote
2 ruote per motori elettrici 3-6V
1 ponte H L298N

Vi aspetto al corso per fare insieme una rilassante attività di making

I miei corsi per Tecnica della Scuola: creare un kit di robotica educativa a basso costo

Lascia una risposta

Mediante una metodologia laboratoriale, si forniranno competenze digitali finalizzate alla realizzazione di robot didattici a bassissimo costo permettendo al docente si strutturare un percorso di base per avvicinare gli studenti ai principi della programmazione e della robotica.
Il corso si sviluppa in 3 moduli e permetterà di costruire un robot partendo da zero.

Il primo modulo introduce all’uso di BBC micro:bit ed alla programmazione con Blocks Editor, un tool grafico che semplifica l’utilizzo della scheda elettronica che controllerà il robot;
Il secondo modulo introduce all’utilizzo modellazione 3D con TinkerCAD che permetterà di stampare in 3D le proprie creazioni, oppure generare i progetti necessari per realizzare i robot con compensato o cartone;
Il terzo modulo mette insieme le due competenze consentendo la costruzione ed il controllo del proprio robot didattico.

Saranno svolti 3 incontri in webinar di 2 ore ciascuno, per un totale di 6 ore

Venerdì 18 giugno 2021 – Dalle 17.00 alle 19.00
Martedì 22 giugno 2021 – Dalle 17.00 alle 19.00
Venerdì 25 giugno 2021 – Dalle 17.00 alle 19.00

BBC micro:bit per la robotica

possibilità didattiche della scheda BBC micro:bit
specifiche tecniche
programmare con JavaScript Blocks Editor
programmi di base per gestire un robot
utilizzo dell’ambiente di sviluppo e del simulatore.

Uso di TinkerCad

l’interfaccia di progettazione
piano di lavoro e manipolazione degli oggetti
operazioni tra solidi e allineamenti
duplicazione e rotazione
uso del righello
creare i propri elementi
esportazione dei file per il taglio e la stampa 3D
progettare la struttura del robot.

Assemblare il robot

componenti elettronici di base:
breadboard;
motori elettrici:
sensori;
led
programmare il robot
comandare a distanza il robot
esperienze di laboratorio.

Per maggiori informazioni sui contenuti del corso e modalità di iscrizione seguire il link allegato.

Convegno: Metodologie didattiche innovative Making Robotica e Dobotica Educative

Lascia una risposta

Nella giornata di domani, 30 Marzo, dalle 9.30 alle 17.00 parteciperò alla: Giornata di studio per la scuola sui temi del Making, della Domotica e della Robotica Educative.
Rappresenterò il mio istituto, l’ITIS G.B. Pininfarina di Moncalieri e il FutureLabs di Moncalieri. Il mio intervento previsto dalle 10,30 alle 11,00, avrà come titolo: “Didattica e IOT: l’intelligenza delle cose”, parlerò di making a scuola e “del futuro prossimo venturo” della didattica laboratoriale dal mio punto di vista. L’evento, in diretta streaming su YouTube vuole essere anche il momento per l’inaugurazione della rete nazionale: Robot School che ha tra i suoi obiettivi:

…creare, promuovere e sostenere, tramite l’attuazione delle misure previste dal PNSD, un sistema sinergico tra scuola, agenzie educative, enti, associazioni e tutti gli attori della comunità educante, diretto a favorire la più ampia diffusione dei processi di innovazione digitale e di didattica innovativa condividendo i principi e gli obiettivi dell’innovazione metodologico-didattica e digitale e ricercando costantemente l’incontro e la collaborazione con altre istituzioni scolastiche presenti su tutto il territorio nazionale, al fine di creare sempre maggiori sinergie e moltiplicare l’impatto della sperimentazione…

Rete capofila della rete: Liceo Scientifico “Leonardo da Vinci” Floridia (SR).

Programma della giornata:

- 9.30 – 10.00 Saluti istituzionali – relatori on. Lucia Azzolina (ex Ministro Pubblica Istruzione), dott. S. Suraniti (Direttore – USR Sicilia) , dott. N. Neri Serneri (Dirigente AT Siracusa)
- 10.00 – 10-30 Presentazione del progetto – relatori prof. M. Pisani (Dirigente Scolastico Liceo L. Da Vinci ), prof.ssa V. Martorino (referente Progetto Robot School)
- 10.30- 11.00 “Didattica e IOT : l’intelligenza delle cose” –relatore prof. Maffucci (Future Lab Pininfarina di Torino)
- 11.00 -11.30 “ Innovazioni tra Making ed IoT ” – relatore prof. F. Piana (vincitore Premio Scuola Digitale)
- 11.30-12.00 “La tecnologia nello spazio : prospettive e scenari futuri“ – relatore ing. Farina (Microgravity Research Center – Brussels)
- 12.00-12.30 – Saluti del dirigente del Future Lab di Gallarate – prof. G. Martino
- “STEM : Tinkering, IoT e Robotica Educativa” – Proposte formative e buone pratiche dal FutureLab” – relatori prof. M. Sabella, V. Belloni (Future Lab di Gallarate)
- 12.30-13.00 -“Spazio Domande e Contributi”
- 13:00 – 14:30 Pausa
- 14.30 – 15.00 “Strategie e processi di ragionamento durante la programmazione robotica: riflessioni teoriche ed empiriche”, relatori Edoardo Datteri e Gilda Bozzi – (Università Milano Bicocca- coordinatore del Laboratorio di Robotica per le Scienze Cognitive e Sociali)
- 15.00- 15.30 Pepper recita Dante – Buone pratiche nella robotica umanoide – relatore prof R. Delle Monache (Future Lab Volta – Pescara)
- 15:30 -16.30 Workshop Immersivo: “Umanoidi e Disabilità”, relatori dott. G. Pioggia , dott.ssa Flavia Marino (CNR Messina, Istituto Marino)
- 16.30-17.00 -“Spazio Domande e Contributi”

PCTO A.S. 2020 – 2021 – SumoBot – lezione 4

Lascia una risposta

Come probabilmente avrete avuto modo di verificare gestendo i due servomotori a rotazione continua, pur provenendo dal medesimo costruttore e impostando le medesime configurazione di velocità, hanno un comportamento non sempre identico. Ricordo che si tratta di apparati economici che devono rispondere a specifiche esigenze didattiche, ma in ogni caso è possibile effettuare alcune regolazioni che ne possono migliorare le prestazioni.
Un’altra funzionalità utile è quella dello start/stop del robot che potrebbe servire per evitare immediati movimenti non appena trasferiamo il codice sul robot.

In questa lezione vi dettaglio gli sketch di esempio, lasciando a voi modifiche e miglioramenti.

Regolazione dei motori

Per poter valutare la velocità e l’angolo di rotazione da impostare all’interno dello sketch è possibile attivare la funzione di calibrazione collegando a GND il pin 3, in questo modo sarà possibile dalla Serial Monitor verificare quali sono i giusti valori per:

velocità di rotazione;
durata della rotazione;
motore/i da impostare

e quindi ciò consentirà di impostare i parametri corretti per le funzioni:

orarioRobot()
antiorarioRobot()

Pertanto da serial monitor potremo comprendere come far compiere una rotazione di 90° in un senso, oppure come far avanzare di una certa quantità di centimetri il robot e molto altro, tenendo però bene a mente che tutto ciò dipenderà fortemente dalla carica della batteria.

La scelta del pin3 è puramente casuale se ritenete potete scegliere un altro pin digitale.

Esempio 1

1/*
2   Prof. Maffucci Michele
3   SumoRobot
4   Data: 26.01.2021
5 
6   Sketch 03: rotazione oraria e antioraria continua
7              con funzioni parametrizzate
8 
9              Per valutare la velocità e l'angolo di rotazione è possibile
10              attivare la funzione di calibrazione collegando a GND il pin 3,
11              in questo modo sarà possibile dalla Serial Monitor verificare
12              quali sono i giusti valori per:
13              - velocità di rotazione;
14              - durata della rotazione;
15              - motore/i da impostare
16 
17              Ciò consentirà di impostare i parametri corretti per le funzioni:
18 
19              - orarioRobot()
20              - antiorarioRobot()
21 
22   Note:
23            L'orientamento dei motori è fatto
24            guardano il robot anteriormente
25 
26            180: max velocità in senso antiorario
27            90 : servomotori fermi
28            0  : max velocità in senso orario
29 
30*/
31 
32// inclusione della libreria servo.h per il controllo dei servomotori
33#include <Servo.h>
34 
35// Creazione oggetti servo
36Servo motoreDX;  // Inizializzazione del servomotore destro
37Servo motoreSX;  // Inizializzazione del servomotore sinistro
38 
39byte pinDx = 4;     // Inizializza del pin 4 a cui è connesso il pin segnale del servo destro
40byte pinSx = 5;     // Inizializza del pin 5 a cui è connesso il pin segnale del servo sinistro
41 
42// Per Calibrazione
43 
44// per stampare una sola volta il messaggio sulla Serial Monitor
45bool abilitaMessaggio = 0;
46 
47// per attivare la calibrazione impostare startCalibrazione a 0
48bool startCalibrazione = 1;
49 
50// Pin di calibrazione se a LOW abilita modalità calibrazione
51byte pinCal = 3;
52 
53void setup() {
54 
55  // inizializzazione della seriale
56  Serial.begin(9600);
57 
58  // attach() consente di definire a quale pin viene connesso il servomotore
59  // e lo collega all'oggetto che gestisce il servomotore
60 
61  motoreDX.attach(pinDx); // pinDx collegato al motore destro
62  motoreSX.attach(pinSx); // pinSx collegato al motore sinistro
63 
64  pinMode(pinCal, INPUT);
65}
66 
67void loop() {
68 
69  // se sul pinCal è LOW è possibile impostare i motori
70  if (digitalRead(pinCal) == LOW) {
71    calibrazione();
72  }
73  else
74  {
75    orarioRobot(30, 250);      // Rotazione in senso orario del robot
76    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
77    antiorarioRobot(150, 250); // Rotazione in senso antiorario del robot
78    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
79  }
80}
81 
82// Funzione da utilizzare una sola volta per impostare
83// i tempi necessari per effettuare uno specifico angolo
84// di rotazione e la velocità di rotazione desiderata
85 
86void calibrazione() {
87 
88  // consente di visualizzare sulla Serial Monitor
89  // una sola stampa delle stringa
90  if (abilitaMessaggio == 0) {
91    // ritardo che evita la doppia stampa del messaggio
92    delay(200);
93    Serial.println("Calibrazione tempo rotazione");
94    Serial.println("velocità (0-180), durata(ms), motore(1: DX, 2: SX, 3: SX+DX)");
95    Serial.println();
96    abilitaMessaggio = 1;
97  }
98 
99  // Controlla se è disponibile almeno un carattere sulla seriale
100  // La Serial.available() restituisce
101  // 1 se presente un cattere,
102  // 0 se non è presente un carattere
103 
104  if (Serial.available()) {        // Viene controllato se è disponibile un carattere
105 
106    // per maggior informazioni sull'uso di parseInt() consultare il link:
107    // https://wp.me/p4kwmk-4Ah
108 
109    // inserimento da tastiera su Serial Monitor dei parametri di controllo
110    // separati da spazio o virgola
111    int velocita = Serial.parseInt();
112    int durata   = Serial.parseInt();
113    int motore   = Serial.parseInt();
114 
115    // funzione per il movimento dei servomotori con i parametri
116    // inseriti sulla serial monitor.
117    calMotoreRobot(velocita, durata, motore);
118  }
119}
120 
121// funzione movimento servomotori per impostazione
122// velocità, durata, motore/i 
123 
124void calMotoreRobot(int calVel, int calDurata, int nMotore) {
125  if (nMotore == 1) { // motore DX
126    motoreDX.write(calVel);
127    delay(calDurata);
128    motoreDX.write(90);   // Ferma il motore DX
129    motoreSX.write(90);   // Ferma il motore SX
130    Serial.println("Fine calibrazione motore DX");
131    Serial.println();
132  }
133  if (nMotore == 2) { // motore SX
134    motoreSX.write(calVel);
135    delay(calDurata);
136    motoreDX.write(90);   // Ferma il motore DX
137    motoreSX.write(90);   // Ferma il motore SX
138    Serial.println("Fine calibrazione motore SX");
139    Serial.println();
140  }
141  if (nMotore == 3) { // motore SX+DX
142    motoreDX.write(calVel);  // Rotazione oraria del motore DX
143    motoreSX.write(calVel);  // Rotazione antioraria del motore SX
144    delay(calDurata);
145    motoreDX.write(90);   // Ferma il motore DX
146    motoreSX.write(90);   // Ferma il motore SX
147    Serial.println("Fine calibrazione motore DX e SX");
148    Serial.println();
149  }
150}
151 
152// rotazione del robot in senso antiorario
153// velMaxOraria: velocità massima in senso antiorario
154// durata: durata della rotazione
155 
156void antiorarioRobot(int velMaxAntioraria, int durata) {
157  motoreDX.write(velMaxAntioraria);  // Rotazione oraria del motore DX
158  motoreSX.write(velMaxAntioraria);  // Rotazione antioraria del motore SX
159  delay(durata);                     // durata: durata della rotazione
160}
161 
162// rotazione del robot in senso orario
163// velMaxOraria: velocità massima in senso orario
164// durata: durata della rotazione
165 
166void orarioRobot(int velMaxOraria, int durata) {
167  motoreDX.write(velMaxOraria);    // Rotazione antioraria del motore DX
168  motoreSX.write(velMaxOraria);    // Rotazione oraria del motore SX
169  delay(durata);                   // durata: durata della rotazione
170}
171 
172// stop del robot
173// ferma: durata dello stop del robot
174 
175void stopRobot(int ferma) {
176  motoreDX.write(90);   // Ferma il motore DX
177  motoreSX.write(90);   // Ferma il motore SX
178  delay(ferma);         // Durata dello stop
179}

La calibrazione viene attivata se la condizione ad inizio loop è vera:

1...
2// se sul pinCal è LOW è possibile impostare i motori
3  if (digitalRead(pinCal) == LOW) {
4    calibrazione();
5  }
6  else
7  {
8    orarioRobot(30, 250);      // Rotazione in senso orario del robot
9    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
10    antiorarioRobot(150, 250); // Rotazione in senso antiorario del robot
11    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
12  }
13}
14...

Se la condizione dell’if risulta vera viene attivata la calibrazione:

1...
2// se sul pinCal è LOW è possibile impostare i motori
3  if (digitalRead(pinCal) == LOW) {
4    calibrazione();
5  }
6  else
7  {
8    orarioRobot(30, 250);      // Rotazione in senso orario del robot
9    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
10    antiorarioRobot(150, 250); // Rotazione in senso antiorario del robot
11    stopRobot(3000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
12  }
13}
14...

In tal caso viene chiamata la funzione calibrazione:

1...
2void calibrazione() {
3 
4  // consente di visualizzare sulla Serial Monitor
5  // una sola stampa delle stringa
6  if (abilitaMessaggio == 0) {
7    // ritardo che evita la doppia stampa del messaggio
8    delay(200);
9    Serial.println("Calibrazione tempo rotazione");
10    Serial.println("velocità (0-180), durata(ms), motore(1: DX, 2: SX, 3: SX+DX)");
11    Serial.println();
12    abilitaMessaggio = 1;
13  }
14 
15  // Controlla se è disponibile almeno un carattere sulla seriale
16  // La Serial.available() restituisce
17  // 1 se presente un cattere,
18  // 0 se non è presente un carattere
19 
20  if (Serial.available()) {        // Viene controllato se è disponibile un carattere
21 
22    // per maggior informazioni sull'uso di parseInt() consultare il link:
23    // https://wp.me/p4kwmk-4Ah
24 
25    // inserimento da tastiera su Serial Monitor dei parametri di controllo
26    // separati da spazio o virgola
27    int velocita = Serial.parseInt();
28    int durata   = Serial.parseInt();
29    int motore   = Serial.parseInt();
30 
31    // funzione per il movimento dei servomotori con i parametri
32    // inseriti sulla serial monitor.
33    calMotoreRobot(velocita, durata, motore);
34  }
35}
36...

La prima parte della funzione calibrazione() esegue una sola volta la stampa sulla Serial Monitor dell’help che spiega come inserire i dati:

velocità (0-180), durata(ms), motore(1: DX, 2: SX, 3: SX+DX)

che sono tutti valori interi separati da virgola.

Nella parte restante del codice della funzione viene verificato con il metodo available() se sono presenti sulla seriale caratteri. Serial.available() restituisce TRUE se sono presenti caratteri e il corpo dell’if verrà eseguito. I valori inseriti vengono letti utilizzando la funzione parseInt() di cui trovate spiegazione approfondita con esercizi seguendo il link.

1...
2if (Serial.available()) {        // Viene controllato se è disponibile un carattere
3 
4    // per maggior informazioni sull'uso di parseInt() consultare il link:
5    // https://wp.me/p4kwmk-4Ah
6 
7    // inserimento da tastiera su Serial Monitor dei parametri di controllo
8    // separati da spazio o virgola
9    int velocita = Serial.parseInt();
10    int durata   = Serial.parseInt();
11    int motore   = Serial.parseInt();
12 
13    // funzione per il movimento dei servomotori con i parametri
14    // inseriti sulla serial monitor.
15    calMotoreRobot(velocita, durata, motore);
16  }
17...

Non appena premiamo invio sulla tastiera, questi valori vegono acquisiti e passati alla funzione calMotoreRobot()

1...
2calMotoreRobot(velocita, durata, motore);
3...

Tra i parametri che vengono passati alla funzione calMotoreRobot() è presente l’indicazione di quale/i motore/i devono essere controllati, questo parametro può assumere i valori: 1, 2, 3 e questi valori vengono utilizzati per selezionare, tramite i blocchi if corrispondenti, quale azione è da compiere. Nei commenti i dettagli di funzionamento.

1...
2void calMotoreRobot(int calVel, int calDurata, int nMotore) {
3  if (nMotore == 1) { // motore DX
4    motoreDX.write(calVel);
5    delay(calDurata);
6    motoreDX.write(90);   // Ferma il motore DX
7    motoreSX.write(90);   // Ferma il motore SX
8    Serial.println("Fine calibrazione motore DX");
9    Serial.println();
10  }
11  if (nMotore == 2) { // motore SX
12    motoreSX.write(calVel);
13    delay(calDurata);
14    motoreDX.write(90);   // Ferma il motore DX
15    motoreSX.write(90);   // Ferma il motore SX
16    Serial.println("Fine calibrazione motore SX");
17    Serial.println();
18  }
19  if (nMotore == 3) { // motore SX+DX
20    motoreDX.write(calVel);  // Rotazione oraria del motore DX
21    motoreSX.write(calVel);  // Rotazione antioraria del motore SX
22    delay(calDurata);
23    motoreDX.write(90);   // Ferma il motore DX
24    motoreSX.write(90);   // Ferma il motore SX
25    Serial.println("Fine calibrazione motore DX e SX");
26    Serial.println();
27  }
28}
29...

La parte restante dello sketch riguarda funzioni già analizzate spiegate nelle lezioni precedenti.

Start/stop del robot

Questa semplice funzionalità viene ottenuta nel medesimo modo della calibrazione, utilizziamo il pin2 cortocircuitato a massa per evitare l’avvio del robot, secondo questa regola:

Pin 2 a GND: robot fermo
Pin 2 a Vcc: robot start

Questo lo sketch generale:

1/*
2   Prof. Maffucci Michele
3   SumoRobot
4   Data: 26.01.2021
5 
6   Sketch 04: rotazione oraria e antioraria continua
7              con funzioni parametrizzate con Start e Stop sistema.
8 
9              Per evitare in avvio immediato del robot si realizza un
10              un interruttore di start/stop utilizzando il pin 2:
11               
12              - Pin 2 a GND: robot fermo
13              - Pin 2 a Vcc: robot start
14   Note:
15            L'orientamento dei motori è fatto
16            guardano il robot anteriormente
17 
18            180: max velocità in senso antiorario
19            90 : servomotori fermi
20            0  : max velocità in senso orario
21 
22            Per avviare il robot collegare a GND il pin 2
23 
24*/
25 
26// inclusione della libreria servo.h per il controllo dei servomotori
27#include <Servo.h>
28 
29// Creazione oggetti servo
30Servo motoreDX;  // Inizializzazione del servomotore destro
31Servo motoreSX;  // Inizializzazione del servomotore sinistro
32 
33byte pinDx = 4;     // Inizializza del pin 4 a cui è connesso il pin segnale del servo destro
34byte pinSx = 5;     // Inizializza del pin 5 a cui è connesso il pin segnale del servo sinistro
35byte pinStart = 2;  // Pin di avvio, se a LOW Start sistema
36 
37void setup() {
38 
39  // inizializzazione della seriale
40  Serial.begin(9600);
41 
42  // attach() consente di definire a quale pin viene connesso il servomotore
43  // e lo collega all'oggetto che gestisce il servomotore
44 
45  motoreDX.attach(pinDx); // pinDx collegato al motore destro
46  motoreSX.attach(pinSx); // pinSx collegato al motore sinistro
47 
48  pinMode(pinStart, INPUT); // pin per avviare il sistema
49}
50 
51void loop() {
52 
53  // se pinStart a LOW il sistema è in stop
54  if (digitalRead(pinStart) == LOW) {
55    stopRobot(1);
56  }
57 
58  // se pinStart è diverso da LOW si avvia la sequenza
59  else
60  {
61    orarioRobot(70, 500);      // Rotazione in senso orario del robot
62    stopRobot(1000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
63    antiorarioRobot(130, 500); // Rotazione in senso antiorario del robot
64    stopRobot(1000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
65 
66  }
67}
68 
69// rotazione del robot in senso antiorario
70// velMaxOraria: velocità massima in senso antiorario
71// durata: durata della rotazione
72 
73void antiorarioRobot(int velMaxAntioraria, int durata) {
74  motoreDX.write(velMaxAntioraria);  // Rotazione antioraria del motore DX
75  motoreSX.write(velMaxAntioraria);  // Rotazione antioraria del motore SX
76  delay(durata);                     // durata: durata della rotazione
77}
78 
79// rotazione del robot in senso orario
80// velMaxOraria: velocità massima in senso orario
81// durata: durata della rotazione
82 
83void orarioRobot(int velMaxOraria, int durata) {
84  motoreDX.write(velMaxOraria);    // Rotazione oraria del motore DX
85  motoreSX.write(velMaxOraria);    // Rotazione oraria del motore SX
86  delay(durata);                   // durata: durata della rotazione
87}
88 
89// stop del robot
90// ferma: durata dello stop del robot
91 
92void stopRobot(int ferma) {
93  motoreDX.write(90);   // Ferma il motore DX
94  motoreSX.write(90);   // Ferma il motore SX
95  delay(ferma);         // Durata dello stop
96}

Come si può notare lo start/stop è regolato dalla parte di codice:

1...
2// se pinStart a LOW il sistema è in stop
3  if (digitalRead(pinStart) == LOW) {
4    stopRobot(1);
5  }
6 
7  // se pinStart è diverso da LOW si avvia la sequenza
8  else
9  {
10    orarioRobot(70, 500);      // Rotazione in senso orario del robot
11    stopRobot(1000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
12    antiorarioRobot(130, 500); // Rotazione in senso antiorario del robot
13    stopRobot(1000);           // Stop rotazione per un tempo fissato (vedere variabile ferma)
14 
15  }
16}
17...

Se il pin è collegato a GND, quindi al LOW il robot è in stop, infatti viene chiamata la funzione stopRobot(1);

Nella prossima lezione vedremo come integrare le due funzionalità:

calibrazione
start/stop

Buon Making a tutti

Michele Maffucci

… my stories, life and work

Archivi tag: robot

Tube Follower – EduRobotKids un piccolo robot per la scuola dell’infanzia e la scuola elementare

Materiali per il corso: creare un kit di robotica educativa a basso costo

I miei corsi per Tecnica della Scuola: creare un kit di robotica educativa a basso costo

Convegno: Metodologie didattiche innovative Making Robotica e Dobotica Educative

PCTO A.S. 2020 – 2021 – SumoBot – lezione 4

Regolazione dei motori

Start/stop del robot

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Regolazione dei motori

Start/stop del robot

Condividi:

Articoli correlati: