Mi è stato chiesto qualche mese fa di pensare a nuove proposte per l’insegnamento dell’informatica sia negli istituti tecnici/professionali che nei licei.

La maggior parte delle metodologie sperimentate in questi anni facevano uso della robotica, prima con i Lego Mindstorms NXT e successivamente con robot basati su Arduino costruiti progettando ogni singolo elemento.

La realizzazione integrale del robot basato su Arduino è di estremo interesse e valenza didattica in quanto come ben comprenderete consente di affrontare molteplici aspetti: meccanici, fisici ed elettronici, ma presenta uno svantaggio, richiede molto tempo.
Ed è proprio il tempo che manca, soprattutto da quando la nuova riforma scolastica ha tolto moltissime ore di laboratorio.

Non mi dilungo oltre ed evito inoltre di parlare delle anomalie dell’insegnamento dell’informatica nel biennio della scuola superiore. Spesso viene confuso il termine “informatica” con la frase “addestramento all’uso di software”. Informatica è insegnare a manipolare, modellare e gestire l’informazione, imparare a ragionare ecc…

Per far fronte a queste anomalie in tempo e contenuti desidero indirizzare la mia attenzione all’uso di strumenti più versatili e creativi, che lasciano ampio spazio alla personalizzazione didattica e alla soluzione di problemi complessi, una sperimentazione basata su Arduino Robot.

Lo strumento, come ben sapete è nuovissimo ed in questi giorni e in fase di consegna ed anche io sono in attesa di un kit che ho acquistato.

Ma il desiderio è quello di sperimentare subito e fortunatamente grazie alla disponibilità e gentilezza di Officine Arduino ho avuto la possibilità di ricevere in prestito d’uso, prima che mi venisse consegnato il kit acquistato, un Arduino Robot.

Ringrazio per questo gli amici di Officine Arduino (grazie Stefano) ed in particolar modo Davide Gomba che ha reso possibile il rapido avvio di questo mio nuovo progetto didattico.

Partirò quindi già da questa settimana, con un ristretto numero di allievi, ad operare con Arduino Robot e progettare un nuovo percorso per l’insegnamento dell’informatica.

Ciò che di seguito leggerete è il risultato di una rapida traduzione della pagina di riferimento: Arduino Robot a cui ho aggiunto alcune cose. Nel brevissimo potrei apportare variazioni: espandere le spiegazioni con altro codice e l’inserimento dei filmati dimostrativi, filmati che aggiungerò nelle prossime… devo solo attendere che le batterie dell’Arduino Robot si carichino 🙂

Come sempre, non posso promettere una serie di lezioni/tutorial, ma sicuramente dovrò documentare ciò che faccio, quindi partendo dagli esempi presenti sul sito Arduino cercherò di aggiungere o esporre in modo diverso le funzionalità del dispositivo sforzandomi di costruire su di essi un percorso didattico ben strutturato.

Per quanto riguarda le caratteristiche tecniche del prodotto vi rimando al mio precedente post.

Quindi parto con la versione “alfa” di queste lezioni su Arduino Robot.

Fin da ora un grazie a chi vorrà segnalarmi correzioni/aggiunte da effettuare a questa lezione.

Configurazione

Prima di operare con il robot bisogna procedere con alcune impostazioni.

In primo luogo è necessario inserire la scheda SD nello slot sul retro dello schermo TFT:

Attenzione all’orientamento della scheda:

Un click vi darà la percezione del blocco della scheda nell’alloggiamento:

inserire il display nella presa sulla scheda di controllo del robot.

Il display deve essere orientato in modo che il testo in blu “SD Card” sia vicino ai tasti e l’altoparlante:

Il passo successivo consiste nell’inserire il coperchio protettivo al di sotto della scheda, ciò eviterà che eventuali oggetti possano rovinare la scheda motore. Fissate la copertura come mostrato nell’immagine.

Contenuto dell’SD card

La scheda SD viene utilizzata per memorizzare le informazioni che dovrà leggere il robot. Sulla scheda vengono precaricati immagini e file audio utilizzati. Quando prenderete confidenza con le funzionalità del robot sarete in grado di aggiungere i vostri file. Se accidentalmente rimuovete i file di esempio potrete copiarli dalla directory SD che trovate nella libreria del robot.

Connessione del robot al computer

Ciascuna delle schede del robot presenta un microcontrollore e possono essere programmati in modo indipendente l’uno dall’altro.
La raccomandazione e quella di imparare a programmare prima la scheda di controllo (quella in alto) fino a quando non avrete preso dimestichezza con tutte le funzionalità del robot.
La scheda del motore (la scheda in basso) è dotato di un firmware che soddisfa le applicazioni più comuni.

Connettete la control board al computer con il cavo USB

Dopo aver collegato la scheda, il LED verde, etichettato come PWR sulla Control Board, si accende. Il LED1 sotto di esso lampeggia un paio di volte.

Sulla Motor Board, i LED rosso etichettati come LED1 a LED5 (lato opposto al pulsante di accensione) si accendono se è tutto ok.

Installazione dei driver

MacOSX

La prima volta che collegate il robot al Mac verrà lanciato “Keyboard Setup Assistant”, non è necessaria nessun configurazione per il robot, potete tranquillamente chiudere la finestra (click in alto a sinistra).

Linux

Per i sistemi Linux non è necessaria nessuna installazione di driver. (Testato con Ubuntu 12.04).

Windows

Seguire la procedura descritta sul sito Arduino.

Il primo sketch: Hello User!

Il Robot Arduino viene fornito con un’applicazione precaricata che vi chiederà il vostro nome, il nome che si desidera assegnare al robot e dove vi trovate. Guardate lo schermo del robot per informazioni su come inserire le informazioni utilizzando i pulsanti e potenziometro.
È possibile alimentare il robot con 4 batterie AAA oppure collegando con un cavo USB la scheda motore o la scheda di controllo.

Quando avete concluso la fase di configurazione, potrete incominciare a scrivere i programmi per il controllo del robot.

Fare l’upload dello sketch test

Per programmare il robot connettere la Control Board al computer attraverso il cavo USB e aprite lo sketch che si trova in File > Examples > Robot_Control > learn > MotorTest.

Come succede per le altre schede Arduino, anche in questo caso dovete dire all’IDE che ciò che vi accingete a programmare è l’Arduino robot, per far ciò aprite: Tools > Board e selezionate: Arduino Robot Control.

L’IDE Arduino deve sapere a quale porta USB collegare il robot. Dal menù Tools > Serial trovate le porte disponibili.

Nel mio caso:

• se visualizzate un solo elemento fate click su di esso
• se vengono visualizzate due o più porte, è possibile scollegare la scheda di controllo e riaprire il menu Serial, la voce che scompare dovrebbe essere il robot. Collegare nuovamente la scheda e selezionare quella porta seriale.

Fate click sul pulsante “Upload” in alto a sinistra della finestra dell’IDE, aspettate qualche secondo, dovreste notare che i led RX e TX lampeggiano. Se l’upload ha successo apparirà nella status bar il messaggio “Done uploading.”, e una volta che appare tale messaggio potere scollegare il cavo USB.

Con le batterie inserite nel robot, ponetelo a terra e accendetelo. Il robot dovrebbe eseguire alcuni movimenti di base.

Congratulazioni! Avete messo in funzione il robot.

Se il robot non si muove, ponete ad off l’interruttore di accensione. Collegate la motor board al computer mediante il cavo USB e caricate lo sketch: File > Examples > Robot_Motor > Robot_Motor_Core selezionate Arduino Robot Motor dal menù Boards. Fate l’upload dello sketch, disconnettete dal computer e provate a attivarlo nuovamente.

Nota: se dopo aver collegato il robot non è presente nessuna porta seriale riavviare l’IDE e provate a scollegare-ricollegare il robot, se questa operazione non da nessun risultato positivo seguire la procedura riportata di seguito:

• aprite uno sketch semplice, come Blink o BareMinimum
• premere il pulsante di upload
• quando la barra di stato mostra “Uploading…”, premere due volte il pulsante di reset sulla scheda di controllo
• la porta seriale dovrebbe apparire normalmente.

Analizziamo il codice dello scketch Motor Test

Per poter utilizzare il robot bisogna necessariamente includere la Robot library:

#include <ArduinoRobot.h>

E’ obbligatorio inoltre inizializzare nel setup() il robot, ciò si realizza usando la classe begin():

void setup() {
  // initialize the robot
  Robot.begin();
}

Nel loop() sono presenti le azioni che fanno muovere il robot, analizziamole per passi:

 Robot.motorsWrite(255,255);   // move forward
 delay(2000);

La classe motorsWrite() consente di controllare la direzione dei motori collegati alle rute del robot.

motorsWrite() accetta due parametri:

Robot.motorsWrite(speedLeft, speedRight)

speedLeft: velocità del motore di sinistra
speedRight: velocità del motore di destra

i valori dei parametri di velocità sono compresi tra -255 e 255, se il valore è maggiore di 0 il motore gira in avanti, se minore di zero il motore ruota all’indietro, quindi nel caso in analisi il robot andrà alla massima velocità in avanti.
Nello sketch è presente subito dopo il Robot.motorsWrite(255,255) un delay(2000) che ferma il loop per 2000 millisecondi, ovvero 2 secondi, cioè lo sketch viene bloccato per 2 secondi sull’istruzione: Robot.motorsWrite(255,255)

Nelle successive due istruzioni vengono bloccate immediatamente le ruote del robot e questo stato persiste per 1 secondo:

 Robot.motorsStop();           // fast stop
 delay(1000);

motorsStop() non ha nessun parametro.

Il robot cambia direzione ed entrambe le ruote gireranno in senso contrario, il robot torna indietro per 1 secondo:

  Robot.motorsWrite(-255,-255); // backward
  delay(1000);

Il robot si ferma per 1 secondo:

  Robot.motorsWrite(0,0);       // slow stop
  delay(1000);

Rispetto al Robot.motorsStop() usato in precedenza in questo caso viene utilizzato Robot.motorsWrite(0,0) che è un modo diverso per fermare il robot, con motorsWrite(0,0) la fermata avviene in modo più morbida, si ha un rallentamento graduale delle ruote, mentre l’uso di Robot.motorsStop() blocca i motori in modo brusco.

La parte di codice che segue consente di far girare verso sinistra il robot, infatti i valori che definiscono la velocità sono di segno opposto, il fatto che abbiano stesso valore implica che il robot girerà sul proprio asse (la perpendicolare passante per il centro della circonferenza del robot).
La velocità di rotazione è massima e durerà per 2 secondi.

  Robot.motorsWrite(-255,255);  // turn left
  delay(2000);

Successivamente il robot verrà fermare in maniera “brusca”, la fermata durerà per 1 secondo.

  Robot.motorsStop();           // fast stop
  delay(1000);

Si cambia poi senso di rotazione ed il robot girerà sul proprio asse verso destra per 2 secondi alla massima velocità

  Robot.motorsWrite(255,-255);  // turn right
  delay(2000);

Segue la fermata “brusca” che durerà per 1 secondo.

  Robot.motorsStop();           // fast stop
  delay(1000);

Muovere il robot

Lo sketch muove ripetutamente avanti e indietro il robot.

Ogni volta che si scrive codice per il robot, assicurarsi di includere all’inizio dello sketch . Ciò permetterà di importare le librerie necessarie per controllare il robot.

Non c’è bisogno di inizializzare l’oggetto Robot.

Ripeto quanto già detto in precedenza:

Per far si che le ruote si muovano, effettuare la chiamata Robot.motorsWrite(). motorsWrite() richiede due argomenti, la velocità del motore di sinistra e la velocità del motore di destra. Questi valori vanno da -255 a 255, dove -255 è velocità massima inversa, mentre 255 è massima velocità in avanti. Se si passa un valore pari a 0, il motore si fermerà.

Dopo aver caricato lo sketch, scollegare il cavo USB che collega il robot. Ogni volta che viene collegato il cavo USB, i motori del robot vengono fermati.
Ora date alimentazione e guardate il robot muoversi!

#include <ArduinoRobot.h>// import the robot library

void setup(){
  Robot.begin(); // initialize the library
}

void loop(){
  // move forward for one second
  Robot.motorsWrite(255,255);
  delay(1000);

  Robot.motorsWrite(0,0); // stop moving
  delay(1000);

  // move backwards for one second
  Robot.motorsWrite(-255,-255);
  delay(1000);

  Robot.motorsWrite(0,0); // stop moving
  delay(1000);
}

Identificare i pulsanti premuti

Scriveremo lo sketch che ci permette di visualizzare quale bottone è stato premuto sullo schermo.

Prima di ogni cosa bisogna includere la libreria Robot library:

#include <ArduinoRobot.h>

In setup() inizializziamo il robot e il display

void setup(){
  Robot.begin();
  Robot.beginLCD();
}

Nel loop(), ogni 100ms, leggiamo lo stato dei bottoni. Se uno di questi è premuto, verrà scritto il suo nome sul display.

void loop(){
  Robot.debugPrint(Robot.keyboardRead(), 10, 10);
  delay(100);
}

Nella cartella explore trovate uno sketch chiamato Logo, che incorpora questo esempio con i movimenti del robot

Cambiare la velocità dei motori con il potenziometro

Questo consente di controllare la velocità con cui il robot si muove in linea retta. Ruotando il potenziometro viene mappata la velocità ed il senso di rotazione delle ruote usando valori che variano nell’intervallo da -255 a 255.

Per prima cosa includete la Robot library.

#include <ArduinoRobot.h>

In setup() inizializziamo il robot e il display

void setup(){
  Robot.begin();
  Robot.beginLCD();
}

Nel loop(), leggiamo i valori del potenziometro con Robot.knobRead(). Mappiamo il valore (che è un numero tra 0 e 1023) nell’intervallo tra -255 e 255. Stampiamo su display questo valore ed usiamolo per cambiare la velocità dei motori.

void loop(){
  int val=map(Robot.knobRead(),0,1023,-255,255);
  Robot.debugPrint(val);
  Robot.motorsWrite(val,val);
  delay(10);
}

I motori del robot vengono fermati non appena collegate il cavo USB. Dopo la programmazione del robot, scollegare il cavo USB e aggiungere le batterie. Accendere l’interruttore di alimentazione e guardare il movimento del robot. Provate a cambiare la sua velocità.

Produciamo un po’ di rumore

Il robot è dotato di due modi per produrre suoni. Potete emettere un semplice beep, ma anche riprodurre suoni più complessi mediante la lettura di brani sequenziati letti sulla scheda SD. In questo esempio si inizia con un beep semplice. Per apprendere coe vengono riprodotti melodie complesse, guardate la cartella Melody presente nella cartella learn.

Per prima cosa includete la Robot library.

#include <ArduinoRobot.h>

In setup() dobbiamo chiamare:

• Robot.begin() per inizializzare le funzioni del robot
• Robot.beginSpeaker() per inizializzare l’altoparlante

void setup(){
  Robot.begin();
  Robot.beginSpeaker();
}

Nel loop() bisogna chiamare Robot.beep() per generare un beep. Ci sono tre differenti segnali acustici: il beep semplice, il doppio beep e il beep lungo,

void loop() {
  Robot.beep(BEEP_SIMPLE);
  delay(1000);
  Robot.beep(BEEP_DOUBLE);
  delay(1000);
  Robot.beep(BEEP_LONG);
  delay(1000);
}

Passo successivo

Ci sono molte cose che potete fare con il robot, per analizzare esempi più complessi guardate gli sketch che trovate nella cartella Explore che vi mostrano diverse applicazioni del robot.
Per conoscere le funzionalità degli ingressi e delle uscite del robot guardate gli esempi della cartella learn in robot examples.

Per conoscere tutti gli aspetti tecnici del robot fate riferimento alle pagine:

• Robot’s library
• hardware page