Arduino – Interrupts – lezione 2

Ormai sono passati diversi anni da quando scrissi il primo post sull’uso degli interrupt e durante gli anni a scuola puntualmente svolgo diversi esercizi, pertanto ho deciso di riprendere ed ampliare quanto detto nel precedente post e sicuramente più avanti ci saranno occasioni per aggiungere ulteriori esempi.

La maggior parte dei microcontrollori permette la gestione degli interrupt. Possiamo pensare all’intterrupt come a un sistema che ci permette di rispondere agli eventi “esterni” mentre facciamo qualcos’altro.

Riprendo quindi il post: Appunti su Arduino: interrupts da cui partire per comprendere cosa sono e come usare gli interrupts con Arduino UNO e con questa lezione voglio proporre alcuni esempi in modo che l’argomento spero possa essere più chiaro.

Per comprendere meglio cos’è un interrupt immaginate la seguente situazione:

tornate a casa dopo la scuola e desiderate cucinarvi un piatto di spaghetti. Fate bollire l’acqua ed inserite gli spaghetti in pentola fissando un tempo di 8 minuti, aspettate che gli spaghetti cucinino e poi mangiate. Possiamo paragonare questa azione all’esecuzione del codice nel loop() di Arduino.

In modo diverso potreste avviare un timer che scade ad 8 minuti e in questo intervallo di tempo potreste guardate il notiziario in TV. Quando il timer suona interromperà (interrupt) la vostra visione che vi ricorderà che dovrete porre attenzione alla pasta in pentola. Quindi verrà eseguito un interrupt (il suono del timer) che permetterà di eseguire il programma: “scola la pasta”.

In altro modo, riprendendo ciò che avevo scritto in passato:

Supponete di dover rilevare lo stato di alcuni sensori esterni. All’interno del loop() tutte le istruzioni sono eseguite in modo sequenziale e quindi anche la rilevazione del cambiamento di stato dei sensori collegati ad Arduino avviene in modo sequenziale. Supponete di dover eseguire il controllo della variazione di stato di 3 sensori, il vostro sketch eseguirà il controllo sul primo sensore, sul secondo e poi sul terzo.

Supponete che tutti i sensori si trovino al medesimo stato iniziale che chiameremo S1 e che il controllo di Arduino sia in un determinato istante sul secondo sensore, potrebbe capitare nello stesso istante una variazione repentina di stato sul primo sensore che passa da S1 a S2 e poi a S1, Arduino non si accorgerà di nulla perché la sua attenzione è sul secondo sensore; ecco che in questa situazione potrebbe essere utile l’utilizzo degli interrupt.

In ambito elettronico possiamo avere due tipi di interrupt:

  • Interrupt hardware: si verificano in risposta ad un evento esterno, come un pin che assume uno stato HIGH o LOW
  • Interrupt software: si verificano in risposta a un’istruzione software.

In questo post ci concentreremo sugli interrupt hardware.

Sulla scheda Arduino UNO, Nano, Mini e altre schede basate sul microcontrollore ATmega328 due sono i pin su cui realizzare un interrupt hardware:

pin digitale 2: interrupt 0
pin digitale 3: interrupt 1

Mentre per altre schede Arduino:

  • Uno WiFi Rev.2, Nano Every
    tutti i pin sono utilizzabili per l’interrupt
  • Mega, Mega2560, MegaADK
    2, 3, 18, 19, 20, 21
  • Micro, Leonardo e schede basate sull’ATmega32u4
    0, 1, 2, 3, 7
  • Zero
    tutti i pin eccetto il 4
  • Tutta la famiglia MKR
    0, 1, 4, 5, 6, 7, 8, 9, A1, A2
  • Nano 33 IoT
    2, 3, 9, 10, 11, 13, 15, A5, A7
  • Nano 33 BLE, Nano 33 BLE Sense
    tutti i pin
  • Due
    tutti i pin
  • 101
    tutti i pin e solo i pin 2, 5, 7, 8, 10, 11, 12, 13 lavorano in modalità CHANGE

Ma come funziona un interrupt?
In estrema sintesi quando si verifica l’interrupt (interruzione), il microcontrollore salva il suo stato di esecuzione attuale ed esegue una piccola porzione di codice che l’utente desidera venga eseguita in presenza di un interrupt, questa porzione di codice prende anche il nome di: interrupt handler o interrupt service routine (in italiano gestore di interrupt o routine di servizio interrupt).

Il programmatore quindi definisce il codice del gestore di interrupt che deve essere eseguito quando si verifica un particolare interrupt all’interno del programma stesso e per fare ciò in Arduino, come indicato nella mia precedente lezione, utilizziamo una funzione chiamata attachInterrupt():

attachInterrupt(digitalPinToInterrupt(PIN), ISR, modo);
  • digitalPinToInterrupt(PIN)
    è la funzione che consente di convertire il numero del pin su cui effettuare l’interrupt con il numero dell’interrupt quindi nel caso di Arduino UNO si avrà:
    digitalPinToInterrupt (2) > 0
    digitalPinToInterrupt (3) > 1
    PIN è quindi il pin abilitato all’interrupt, che indica al microcontrollore qual è il PIN da monitorare e come indicato nell’elenco sopra Il PIN dipende dal microcontrollore utilizzato.
  • ISR è la porzione di codice che deve essere eseguito se l’interrupt viene attivato
  • modo
    è il tipo di trigger che attiva l’interrupt che, come indicato nella precedente lezione, può essere di 4 tipi:

    • LOW l’interrupt viene eseguito quando il livello del segnale è basso
    • CHANGE l’interrupt viene eseguito quando avviene un cambiamento di stato sul pin
    • RISING l’interrupt viene eseguito quando si passa da un livello LOW ad un livello HIGH
    • FALLING l’interrupt viene eseguito quando si passa da un livello HIGH ad un livello LOW

Nota: all’interno della funzione utilizzata in attachInterrupt:

  • delay() non funziona;
  • il valore restituito dalla funzione millis() non verrà incrementato.
  • i dati seriali ricevuti durante l’esecuzione della funzione di interrupt possono essere sbagliati.
  • qualsiasi variabile modificabile all’interno della funzione attached (chiamata all’interno attachInterrupt) devono essere dichiarare come volatili.
  • le funzione non può avere parametri di ingresso

Esempio 01

Realizziamo uno sketch che al verificarsi di un interrupt sul pin 2 cambia lo stato in cui si trova il LED sulla scheda di Arduino

Circuito

/*
   Prof. Michele Maffucci
   Data 03.03.2021

   Oggetto: utilizzo degli interrupt

   Esempio 01

*/

int pinLed = 13;
volatile int stato = LOW;
int pulsante = 2;

/* dichiariamo volatile la variabile
  state usata nella funzione usata all'interno di attachInterrupt */

void setup()
{
  pinMode(pinLed, OUTPUT);       // definiamo pin output
  pinMode(pulsante, INPUT);      // pulsante collegato al pin 2
  attachInterrupt(digitalPinToInterrupt(2), cambiaStato, FALLING);

  // usiamo l'interrupt 0 che è associato al pin digitale 2
  // attachInterrupt chiamerà la funzione collegata, cambiaStato
  // il modo per la rilevazione del cambiamento di stato
  // sarà di tipo: FALLING
  // cioè l’interrupt viene eseguito quando si passa
  // da un livello HIGH ad un livello LOW

}

void loop()
{
  digitalWrite(pinLed, stato);
  // il pin digitale 13 viene impostato a "state"
  // che può essere LOW o HIGH
  // all'avvio di Arduino il LED sarà spento
}

void cambiaStato()
// la funzione cambiaStato() esegue la funzione NOT di "stato" cioè
// se stato = LOW viene cambiato in HIGH, se stato = HIGH viene cambiato in LOW

{
  stato = !stato;
}

quindi il cambiamento di stato avviene solo e soltanto se cambiamo lo stato sul pin 2.

Non si confonda l’azione del cambiamento di stato del LED con l’azione che si potrebbe avere con un semplice controllo sul pin 2 fatto con un’istruzione IF: “se il pulsante è premuto allora cambia stato al LED”.
In questo caso il funzionamento è totalmente diverso, non è presente un’istruzione di controllo di flusso, ma solamente il cambiamento di stato su un pin di interrupt, quando presente questo cambiamento viene invocata la funzione cambiaStato().

Si noti che le variabili utilizzate nella routine di servizio interrupt devono sempre essere globali e volatili.
Nel nostro caso la variabile “stato” utilizzate nella routine di servizio interrupt che abbiamo chiamato cambiaStato() è una variabile di tipo globale e volatile.

Ma cosa vuol dire dichiarare una variabile volatile? Come si può notare la variabile “stato” non è presente all’interno del loop(). Se il compilatore si accorge che sono presenti variabili non usate nel setup() e nel loop(), allora in fase di compilazione, per risparmiare memoria queste variabili vengono cancellate.

Dichiarare quindi “stato” volatile garantisce che il compilatori non elimini questa variabile perchè ci servirà all’interno della routine di servizio interrupt che abbiamo chiamato cambiaStato().
Una variabile volatile indicherà al compilatore di non memorizzare il contenuto della variabile in uno dei registri del microcontrollore, ma di leggerlo quando necessario dalla memoria. Attenzione però che questa modalità di azione rallenterà l’elaborazione del programma, pertanto non bisogna mai rendere volatile ogni variabile, ma l’operazione è da fare solamente quando necessario.

In generale una variabile dovrebbe essere dichiarata come volatile solamente se è utilizzata sia all’interno dell’ISR (interrupt service routine, in italiano gestore di interrupt) che all’esterno dell’ISR.

Esempio 02

Per comprendere meglio quanto scritto nell’esempio precedente facciamo alcune modifiche allo sketch precedente, il circuito rimane invariato.

/*
   Prof. Michele Maffucci
   Data 03.03.2021

   Oggetto: utilizzo degli interrupt

   Esempio 02

*/

int pin = 13;
volatile int stato = LOW;
int pulsante = 2;

/* dichiariamo volatile la variabile
  state usata nella funzione usata all'interno di attachInterrupt */

void setup()
{
  pinMode(pin, OUTPUT);       // definiamo pin output
  pinMode(pulsante, INPUT);   // pulsante collegato al pin 2
  attachInterrupt(digitalPinToInterrupt(2), cambiaStato, FALLING);

  // usiamo l'interrupt 0 che è associato al pin digitale 2
  // attachInterrupt chiamerà la funzione collegata, cambiaStato()
  // il modo per la rilevazione del cambiamento di stato
  // sarà di tipo: FALLING
  // cioè l’interrupt viene eseguito quando si passa
  // da un livello HIGH ad un livello LOW

}

void loop()
{
  delay(5000); // intervallo di 5 secondi
}

void cambiaStato()
// la funzione cambiaStato() esegue la funzione NOT di "stato" cioè
// se stato = LOW viene cambiato in HIGH, se stato = HIGH viene cambiato in LOW

{
  stato = !stato;
  digitalWrite(pin, stato);
  // il pin digitale 13 viene impostato a "stato"
  // che può essere LOW o HIGH
  // all'avvio di Arduino il LED sarà spento
}

L’unica variazione al codice è stato l’inserimento di:

delay(5000); // intervallo di 5 secondi

che interrompe l’esecuzione del loop per 5 secondi.

Si noti però che non appena premiamo il pulsante avviene una modifica istantanea del codice indipendentemente dal delay di 5 secondi

Attenzione che il LED rosso poteva essere controllato internamente al loop, ma in questo caso il codice, eseguito sequenzialmente, avrebbe prima eseguito il blink del LED verde e successivamente controlla se il pulsante è premuto per poter accendere il LED verde, ciò non accade con l’uso dell’interrupt.

Esempio 03

Nell’esempio che segue potrete notare il ritardo con cui si manifesta la variazione di stato se il controllo viene effettuato all’interno del loop().

Circuito

/*
   Prof. Michele Maffucci
   Data 03.03.2021

   Oggetto: controllo di stato subordinato dai delay

   Esempio 03

*/

int pinRosso = 5; // pin a cui è connesso il LED rosso
int pinVerde = 4; // pin a cui è connesso il LED verde
int pulsante = 2;
int stato = LOW;

void setup()
{
  pinMode(pinRosso, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pulsante, INPUT);   // pulsante collegato al pin 2
}

void loop()
{ 
  digitalWrite(pinVerde, HIGH);
  delay(3000);
  digitalWrite(pinVerde, LOW);
  delay(3000);

  if (digitalRead(pulsante)) {
    digitalWrite(pinRosso, !stato);
    stato = !stato; 
  }
}

// Il controllo sul LED rosso potrà avvenire solamente dopo 6 secondi
// La pressione ripetuta del pulsante nei primi 6 secondi non modifica
// lo stato del LED fino a quando il controllo non giunge all'IF.

Esempio 04

Realizziamo ora un quarto sketch in cui abbiamo un LED verde che lampeggia controllato dal codice all’interno del loop ed un secondo LED rosso che cambia stato se premiamo il pulsante connesso al pin 2. Noterete che la pressione del pulsante, che varia lo stato del LED rosso, non influirà sulla normale esecuzione del loop().

Il circuito è il medesimo dell’esercizio precedente.

/*
   Prof. Michele Maffucci
   Data 03.03.2021

   Oggetto: utilizzo degli interrupt

   Esempio 04

*/

int pinRosso = 5;
int pinVerde = 4;
int pulsante = 2;
volatile int stato = LOW;

/* dichiariamo volatile la variabile
  state usata nella funzione usata all'interno di attachInterrupt */

void setup()
{
  pinMode(pinRosso, OUTPUT);
  pinMode(pinVerde, OUTPUT); 
  pinMode(pulsante, INPUT);   // pulsante collegato al pin 2
  
  attachInterrupt(digitalPinToInterrupt(2), cambiaStato, FALLING);

  // usiamo l'interrupt 0 che è associato al pin digitale 2
  // attachInterrupt chiamerà la funzione collegata, cambiaStato()
  // il modo per la rilevazione del cambiamento di stato
  // sarà di tipo: FALLING
  // cioè l’interrupt viene eseguito quando si passa
  // da un livello HIGH ad un livello LOW

}

void loop()
{
  digitalWrite(pinVerde, HIGH);
  delay(3000);
  digitalWrite(pinVerde, LOW);
  delay(3000);
}

// Durante i 6 secondi di accensione e spegnimento del LED verde
// non saremo bloccati dai delay presenti nel loop, potremo modificare
// lo stato del LED rosso ogni volta nei 6 secondi di pausa del loop

void cambiaStato()
// la funzione cambiaStato() esegue la funzione NOT di "stato" cioè
// se stato = LOW viene cambiato in HIGH, se stato = HIGH viene cambiato in LOW

{
  stato = !stato;
  digitalWrite(pinRosso, stato);
  // il pin digitale 5 viene impostato a "stato"
  // che può essere LOW o HIGH
  // all'avvio di Arduino il LED sarà spento
}

Esempio 05

Vediamo ora un’altro esempio dove con due pulsanti controlliamo l’incremento e il decremento di una variabile che viene stampata sulla Serial Monitor.
Notate all’interno del loop() che viene implementato un blink lento e ll’incremento e il decremento della variabile non è influenzata dai delay() del blink, ma risulta immediata.

Circuito

/*
   Prof. Michele Maffucci
   Data 03.03.2021

   Oggetto: utilizzo degli interrupt

   Esempio 05

*/

volatile int valore = 10;

int pulsanteIncrementa = 2;
int pulsanteDecrementa = 3;

/* dichiariamo volatile la variabile
  state usata nella funzione usata all'interno di attachInterrupt */

void setup()
{
  Serial.begin(9600);
  
  pinMode(pulsanteIncrementa, INPUT);   // pulsante collegato al pin 2
  pinMode(pulsanteDecrementa, INPUT);   // pulsante collegato al pin 3 
   
  attachInterrupt(digitalPinToInterrupt(2), incrementa, FALLING);
  attachInterrupt(digitalPinToInterrupt(3), decrementa, FALLING);

  // usiamo l'interrupt 0 e 1 che sono associati ai pin digitali 2 e 3
  // attachInterrupt chiamerà la funzione collegata, cambiaStato
  // il modo per la rilevazione del cambiamento di stato
  // sarà di tipo: FALLING
  // cioè l'interrupt viene eseguito quando vi è un passaggio da HIGH a LOW

}

void loop()
{
  Serial.println(valore);
}

void incrementa() {
  valore++;
}

void decrementa() {
  valore--;
}

Attenzione che durante le prove potreste notare qualche problema nella gestione dei pulsanti su cui dovrebbe essere effettuato un controllo di antirimbalzo, in questo caso però potrà essere realizzato solamente in modo hardware (in modo elettronico) e non per via software in cui viene richiesto un controllo del tempo di pressione del pulsante mediante il delay() o di calcoli di intervalli di tempo e tutto ciò non è permesso all’interno dell’interrupt service routine .

Buon coding a tutti 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato , , , , | Lascia un commento

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

In questa lezione vedremo come collegare e controllare i servomotori a rotazione continua di SumoBot.
Fate riferimento allo schema di collegamento che segue, in cui i servomotori vengono connessi ai pin 4 e 5 della Sensor Shield per Arduino Uno Nano V3, come si nota a fianco di ogni pin è disponibile l’alimentazione, infatti troviamo sempre il positivo, indicato con la lettera V e il GND indicato con la lettera G. Come ribadito nella lezione 1 utilizziamo una Sensor Shield perchè permette rapidamente di realizzare tutti i collegamenti senza la necessità i dover ricorrere ad una breadboard oppure alla saldatura dei cavi.

Per questa lezione vengono indicati solo i collegamenti ai motori, non verranno collegati ne il sensore ad ultrasuoni e ne i sensori ad infrarossi.

Per quanto riguarda l’utilizzo dei servomotori a rotazione continua fare riferimento alla slide: Alfabeto di Arduino – Lezione 6, ma per completezza riporto di seguito la spiegazione adattandola all’utilizzo con SumoBot.

Il servomotore è costituito in genere da tre cavi connessi ad un connettore femmina con passo standard tra i fori di 2,54 mm quindi facilmente utilizzabile con qualsiasi strip che ne permette il collegamento ad esempio su una breadboard oppure ai pin maschio della Sensor Shield che utilizziamo per SumoBot.

I fili di connessione possono assumere colori diversi in funzione della marca del servo.

Pinout del servomotore

  • Filo ROSSO: +V
  • Filo NERO o MARRONE: GND
  • Filo BIANCO o ARANCIO o BIANCO o BLU: Segnale

Nel servomotori adottati per questa esperienza i fili di connessione sono:

  • Filo ROSSO: +V
  • Filo MARRONE: GND
  • Filo ARANCIO: Segnale

Collegamenti

Guardando SumoBot frontalmente, collegheremo il motore di destra al pin 4 e il motore di sinistra al pin 5.

Principio di funzionamento del servomotore a rotazione continua

Notoriamente i servomotori possono effettuare una rotazione che oscilla tipicamente da 0 a 180, esistono inoltre modelli che consentono una rotazione inferiore tra 0 e 120 gradi, questi tipi di servomotori possono essere modificati facendo in modo che possano effettuare una rotazione continua, ovvero tra 0 e 360 gradi, ma in commercio sono disponibili servomotori di diverse dimensioni che funzionano in questa modalità. Nel kit utilizzato per la realizzazione di SumoBot utilizziamo due servomotori FS90R.

Sul servomotore a rotazione continua possiamo controllare da programma il senso di rotazione e in modo non molto preciso anche la velocità.

Il funzionamento di un servomotore a rotazione continua è simile a quella di un motore in corrente continua con la differenza che non necessitano di appositi shield per poter funzionare.
Rispetto ad altri tipi di motori in CC offrono scelte limitate per il controllo della velocità e limitazioni di alimentazione.

L’alimentazione potrà avvenire direttamente Attraverso Arduino o mediante alimentazione esterna. L’alimentazione dei motori di SumoBot avverrà direttamente dalla scheda Arduino.

Caratteristiche tecniche

  • Velocità di funzionamento a 4,8V: 110RPM
  • Velocità di funzionamento a 6V: 130RPM
  • Coppia di stallo a 4,8V: 1.3kg.cm/18.09oz.in
  • Coppia di stallo a 6V: 1.5kg.cm/20.86oz.in
  • Tensione operativa: 4.8-6V
  • Sistema di controllo: Analogico
  • Angolo di rotazione: 360 gradi
  • Impulso richiesto: 900-2100us
  • Materiale ingranaggi: Plastica
  • Dimensioni: 2,32×1,25×2,2 cm
  • Peso: 9g

Programmazione

/*
 * Prof. Maffucci Michele
 * SumoRobot
 * Data: 26.01.2021
 * 
 * Sketch 01: rotazione oraria e antioraria continua
 * 
 * Note:
 *          Per l'orientamento del robot 
 *          guardare SumoBot anteriormente
 *       
 *          180: max velocità in senso antiorario
 *          90 : servomotori fermi
 *          0  : max velocità in senso orario
 *            
 */

// inclusione della libreria servo.h per il controllo dei servomotori
#include <Servo.h>

// Creazione oggetti servo
Servo motoreDX;  // Inizializzazione del servomotore destro
Servo motoreSX;  // Inizializzazione del servomotore sinistro

byte pinDx = 4;     // Inizializza del pin 4 a cui è connesso il pin segnale del servo destro
byte pinSx = 5;     // Inizializza del pin 5 a cui è connesso il pin segnale del servo sinistro
int  durata = 250;  // Durata movimento (orario/antiorario)
int  ferma = 3000;  // Durata dello stop

void setup() {

  // attach() consente di definire a quale pin viene connesso il servomotore
  // e lo collega all'oggetto che gestisce il servomotore
  
  motoreDX.attach(pinDx); // pinDx collegato al motore destro
  motoreSX.attach(pinSx); // pinSxcollega to al motore sinistro
}

void loop() {
  orarioRobot();     // Rotazione in senso orario del robot
  stopRobot();       // Stop rotazione per un tempo fissato (vedere variabile ferma)
  antiorarioRobot(); // Rotazione in senso antiorario del robot
  stopRobot();       // Stop rotazione per un tempo fissato (vedere variabile ferma)
}

// rotazione del robot in senso antiorario
void antiorarioRobot(void) {
  motoreDX.write(150);  // Rotazione oraria del motore DX
  motoreSX.write(150);  // Rotazione antioraria del motore SX
  delay(durata);        // durata: durata della rotazione
}

// rotazione del robot in senso orario
void orarioRobot(void) {
  motoreDX.write(30);    // Rotazione antioraria del motore DX
  motoreSX.write(30);    // Rotazione oraria del motore SX
  delay(durata);         // durata: durata della rotazione
}

// stop del robot
void stopRobot(void) {
  motoreDX.write(90);   // Ferma il motore DX
  motoreSX.write(90);   // Ferma il motore SX
  delay(ferma);         // Durata dello stop
}

Per quanto riguarda il controllo dei servomotori seguire la spiegazione inserita come commento all’interno del codice, ricordo comunque che per controllare i servomotori sono necessarie  4 operazioni:

  1. includere la libreria Servo.h
  2. creazione dell’oggetto Servo. motoreDx e motoreSx saranno i due oggetti su cui opererete
  3. assegnare un nome al pin di controllo del servomotore (filo arancione nello schema)
  4. indicare nel setup il metodo attach() che permette di legare gli oggetti motoreDx e motoreSx ai pin su Arduino nell’esempio 4 e 5 a cui abbiamo assegnato i nomi pinDx e pinSx.

All’interno del codice utilizziamo il metodo write() che per i servomotori a rotazione continua permette il passaggio, all’oggetto motoreDx e motoreSx, la direzione e la velocità di rotazione del motore:

  • passando il valore 0 gradi al metodo write() il servo ruota alla massima velocità in una direzione.
  • passando il valore 90 gradi al metodo write() poniamo il servo in stop (posizione “neutra”)
  • passando il valore 180 gradi al metodo write() il servo di ruotare in senso opposto alla massima velocità.

Nel codice che segue SumoBot ripeterà continuamente una rotazione oraria di 250 millisecondi, si fermerà per 3 secondi e riprenderà la rotazione in senso antiorario per 250 millisecondi.

Per effettuare questa operazione vengono definite 3 funzioni:

  • orarioRobot()
  • stopRobot()
  • antiorarioRobot()

Nel codice si può notare che nella funzione antiorarioRobot() viene passato al metodo write() non il valore 180 che farebbe ruotare il robot alla massima velocità, ma un valore inferiore, nel nostro caso 150, ciò ridurrà la velocità di rotazione.

In  modo analogo accade per la funzione orarioRobot() in cui invece di passare il valore 0 alla metodo write(), che lo farebbe ruotare alla massima velocità in senso orario, passiamo un valore maggiore, 30, che lo farà ruotare ad una velocità inferiore.

La fermata del robot avviene utilizzando la funzione stopRobot() in cui viene passato il valore 90 al metodo write(), ciò fermerà i motori.

Si noti che i motori potranno ruoteranno in un senso o in un altro, oppure potranno essere fermati non solo invocando il metodo write, ma bisognerà sempre inserire un delay() in cui viene specificato per quanto tempo il metodo deve agire.

Esercizio 01

Far compiere a SumoBot rotazioni continue di 90 gradi in senso orario inserendo un intervallo di 3 secondi ad ogni quarto di giro

Esercizio 02

Far compiere a SumoBot una rotazione continua di 360° con intervalli di 3 secondi ad ogni quarto di giro, raggiunti i 360° far cambiare il senso di rotazione ripetendo le fermate di 3 secondi ad ogni quarto di giro.

Esercizio 03

Individuare quanto tempo necessita per far effettuare una rotazione di 45° in senso orario a SumoBot e realizzare un programma che permetta di fare le seguenti operazioni:

  1. rotazione di 45° in senso orario
  2. fermate di 3 secondi
  3. rotazione in senso antiorario di 90°
  4. fermata

Buon Making a tutti 🙂

Pubblicato in arduino, elettronica, i miei allievi | Contrassegnato , , , , , , | Lascia un commento

Arduino – realizzare un sensore di seduta a pressione con un tubo di gomma

Questa mattina, durante la realizzazione e l’analisi dei problemi per il progetto di PCTO: “misura di sedentarietà delle persone sedute alla scrivania” che stanno realizzando i miei studenti di 3′ Elettronica, è nata l’esigenza di associare un doppio controllo per la valutazione della presenza della persona seduta alla scrivania, un controllo effettuato con PIR HC-SR501 ed un sensore di forza resistivo (FSR) inserito all’interno del cuscino della seduta.

Per evitare l’acquisto di un sensore di forza resistivo e non pesare sulle finanze dei ragazzi le modalità sono tre:

  • richiesta alla scuola
  • compra il Prof.
  • farlo costruire ai ragazzi

l’acquisto da parte della scuola o mia non è un problema, ma la terza soluzione è quella che in questo momento prediligo, perché può essere realizzata in 5 minuti, credo che possa gratificare di più lo studente Maker in erba 🙂 , inoltre ritengo importante che gli allievi assumano la capacità di costruire il sensore perché ne dovranno ottimizzare l’uso, scontrandosi inevitabilmente con una serie di variabili fisiche che dovranno gestire.

Ma come si costruisce il sensore?

E’ indispensabile piccolo tubo cilindrico non trasparente, preferibilmente nero che possa essere compresso e al termine della compressioni ritorni abbastanza velocemente nella sua posizione di riposo. Possiamo ricavare il tubo sguainando un cavo elettrico o cavo di rete, oppure come ho fatto in questo tutorial, prendendo una guaina termorestingente.

Inserire un diodo LED ad un’estremità del cilindro e dalla parte opposta inserire un LDR.
Collegare il sistema nella solita modalità, inserendo in serie al LED un resistore da 220 Ohm e creando un partitore di tensione tra l’LDR e un resistore da 10KOhm, così come indicato nel circuito indicato di seguito.

Come test di funzionamento utilizzare il semplice sketch che trovate di seguito, nei commenti la spiegazione di tutte le parti del codice.

Aprite la Serial Monitor e premete e rilasciate il tubo

/*
 * Prof. Michele Maffucci
 * Data 01.03.2021
 * 
 * Oggetto: sensore di seduta a pressione
 * 
*/

// variabile in cui verrà memorizzato il valore presente sul pin A0
const int misura = A0;

// valore restituito dall'analogRead
int val = 0;

// pin a cui è connesso il LED del sensore di seduta
int pinLed = 2;

// LED che segnala la seduta della persona
int pinLedAlert = 13;

void setup() {
  // Inizializzazione della Serial Monitor
  Serial.begin(9600);

  // ledPin è il pin a cui è connesso il LED del sensore di seduta
  pinMode(pinLed, OUTPUT);

  // pinLedAlert è il pin a cui è connesso il LED che segnala la seduta della persona
  pinMode(pinLedAlert, OUTPUT);

  // Attivazione del LED del sensore di seduta
  digitalWrite(pinLed, HIGH);

  // Messaggio di avvio
  Serial.println("Sistema di rilevazione seduta");
  Serial.println("-----------------------------");
  Serial.println(""); 
  delay(1000);
}

void loop() {
  // analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
  val = analogRead(misura);

  // il valore di controllo nell'if deve essere sperimentato in funzione
  // delle necessità costruttive (ad es. la lunghezza del tubo)

  // se vero la persona è seduta
  if (val >= 100) {
    digitalWrite(pinLedAlert, HIGH);                      // accensione del LED di avviso
    Serial.println("Persona NON seduta alla scrivania");  // segnalazione di assenza persona
    Serial.print("Valore letto dal sensore = ");          // Stringa di stampa 
    Serial.println(val);                                  // Valore restituito dall'AnalogRead
    Serial.println("");                                   // Stampa linea vuota di separazione
    delay(1000);                                          // Intervallo di 1 secondo tra ogni stampa
  }
  else
  {
    digitalWrite(pinLedAlert, LOW);                       // spegnimento del LED di avviso
    Serial.println("Persona seduta alla scrivania");      // segnalazione di presenza persona
    Serial.print("Valore letto dal sensore = ");          // Stringa di stampa 
    Serial.println(val);                                  // Valore restituito dall'AnalogRead
    Serial.println("");                                   // Stampa linea vuota di separazione
    delay(1000);                                          // Intervallo di 1 secondo tra ogni stampa
  }
}

Il risultato sulla Serial Monitor è il seguente

Il valore di soglia scelto deve essere ricavato sperimentalmente in funzione della lunghezza e della trasparenza del tubo.

Buon Making a tutti 🙂

Pubblicato in arduino, elettronica, i miei allievi | Contrassegnato , , , , , , , | Lascia un commento

Arduino – usare un PIR HC-SR501

Noto spesso nei progetti dei miei studenti il divertimento che nasce nell’utilizzo di un sensore ad infrarossi passivo che viene utilizzato per realizzare dei semplici dispositivi antintrusione, attualmente alcuni allievi li stanno utilizzando in due diversi progetti:

  • all’interno del kit EduRobot Home in cui il PIR HC-SR501 viene utilizzato come sensore di rilevamento per realizzare un antifurto
  • attività di PCTO in cui i ragazzi devono implementare un misuratore di sedentarietà, la rilevazione dell’essere umano davanti la computer avviene mediante un PIR.

Questa tipologia di sensore è molto diffuso, li utilizziamo ogni giorno: antifurto di casa, interruttori automatici di luci e molto altro in generale in tutti quei sistemi in cui è indispensabile attivare un’azione nel caso in cui venga rilevata la presenza di un essere umano o di un animale.

Come funziona il sensore di movimento PIR?

Come sicuramente saprete tutti gli oggetti con una temperatura superiore allo zero assoluto (0 Kelvin / -273,15 ° C) emettono energia termica sotto forma di radiazione infrarossa, inclusi i corpi umani. Più un oggetto è caldo, più radiazioni emette.

Il sensore PIR è appositamente progettato per rilevare tali livelli di radiazione infrarossa, è in grado di percepire oggetti caldi in movimento con uno lunghezza d’onda compreso tra i 700 nm e 1 mm . Nel caso della rilevazione di esseri umani la lunghezza d’onda da rilevare è compresa tra 8-14 micrometri.

Il mercato offre diverse tipologie di PIR in funzione del campo di impiego, i più comuni, quelli a lente di Fresnel hanno un range tra i 10 m e i 12 m con un campo di visivo di 300°. E’ possibile trovare sul mercato PIR con un campo visivo che raggiunge i 360° e distanze dell’oggetto rilevato fino a 30 m.

Il PIR fondamentalmente si compone di due parti principali: un sensore piroelettrico e una lente speciale chiamata lente di Fresnel che focalizza i segnali a infrarossi sul sensore piroelettrico.

Un sensore piroelettrico è dotato di due fessure rettangolari al suo interno fatte di un materiale che permette il passaggio della radiazione infrarossa, ciò che verrà rilevato dal sensore sarà la variazione della quantità di raggi infrarossi causata ad esempio dal passaggio di un essere umano e non la quantità di infrarossi totale dell’ambiente.
Le due fessure sono da considerare come due finestre che verranno colpite dai raggi infrarossi e se attraverso le due fessure viene rilevata la stessa quantità di infrarosso allora il segnale risultante di uscita sarà pari a zero, ovvero corpo non rilevato.
Quando però davanti al sensore passa un corpo caldo, come un essere umano, attraverso una finestra verrà rilevata una certa quantità di infrarosso che causerà una differenza di potenziale positiva tra le due finestra, quando il corpo caldo lascia l’area di rilevamento, avviene il contrario, per cui il sensore genera una variazione differenziale negativa. L’impulso di segnali corrispondente fa sì che il sensore imposti il pin di uscita alto, indicandoci quindi la presenza di una persona.

Il sensore HC-SR501, trattandosi di un sensore molto economico, possiede caratteristiche  limitate rispetto a quelli che potremo utilizzare per scopi civili o industriali, ma il loro principio di funzionamento è il medesimo.

Analizziamo la scheda

Pinout

Caratteristiche tecniche

  • Tensione continua di lavoro compresa tra i 4,5V e i 20V
  • Livelli di tensione di uscita: 3,3V HIGH – 0V LOW
  • Massimo angolo di visione 110°
  • Distanza rilevata compresa tra i 3 m e i 7 m

Sulla scheda sono presenti i due trimmer

  • PIR Range Adjustment (Sensibilità)
    Ruotando in senso orario si avrà una diminuzione della sensibilità con decremento della distanza di rilevamento, a fine corsa si avranno approssimativamente una sensibilità di 3 metri.
    Ruotando in senso antiorario aumentiamo la sensibilità per raggiungere approssimativamente 7 m.
  • Time Delay Adjustment (Tempo di delay)
    determina la quantità di tempo in cui l’output del sensore PIR rimarrà alto dopo il rilevamento del movimento. L’intervallo è compreso tra circa 3 secondi e 5 minuti. Girando in senso orario, a fine corsa si avrà un delay di 5 minuti, ruotando in senso antiorario, a fine corsa si otterrà un delay di circa 3 secondi.

Si ricordi che impostato il tempo di delay, ad esempio a 5 secondi, ciò comporterà che se viene rilevato il passaggio di un essere umano l’uscita del sensore sarà alta per 5 secondi e in questi 5 secondi il sensore è bloccato, cioè non sarà in grado di rilevare altri movimenti causati da altri corpi.

IMPORTANTE
Dopo il completamento del Time Delay  l’uscita sarà a LOW (off)  per circa 3 secondi , ciò vuol dire che in questi 3 secondi non verrà rilevato nulla dal sensore.

Sulla scheda è presente un jumper che ha la seguente funzionalità:

Con questo Jumper è possibile impostare le seguenti modalità:

Single Trigger Mode
Il Time Delay viene avviato immediatamente al rilevamento del movimento e il rilevamento continuo viene bloccato.
Questo vuol dire che se ad esempio viene impostato un Time Delay di 5 secondi, al rilevamento di una persona l’uscita passa ad HIGH, se nei 5 secondi passano davanti al sensore un’altra persone questa non viene rilevata e non viene aggiunto un’ulteriore Time Delay.

Immaginate di essere in modalità Single Trigger Mode con un Time Delay di 5 secondi.

  • Il PIR rileverà il movimento e lo imposterà ad HIGH per 5 secondi.
  • Dopo cinque secondi il PIR imposta la sua uscita bassa per circa 3 secondi.
  • Durante i tre secondi, il PIR non rileverà il movimento.
  • Dopo tre secondi di di LOW, il PIR è abilitato nuovamente al rilevamento di movimenti, al passaggio di una persona verrà impostata nuovamente l’uscita alta per il Time Delay impostato.

Repetable Trigger
Ogni movimento rilevato ripristina il Time Delay, pertanto il Time Delay inizia con l’ultimo movimento rilevato.
Questo vuol dire che se ad esempio viene impostato un Time Delay di 5 secondi, al rilevamento di una persona l’uscita passa ad HIGH se nei 5 secondi viene rilevato il passaggio di un’altra persona il Time Delay riparte nuovamente. Quindi supponendo che:

  • Persona 1 passa davanti al PIR, parte il Time Delay
  • Persona 2 passa davanti al PIR al secondo 3, se non passa nessuna persona il Time Delay cesserà ad 8 secondi ed il sensore potrà leggere nuovamente il passaggio di una persona al secondo 11.

IMPORTANTE

Prima di progettare un sistema in cui sono presenti dei PIR ricordare che questi sensori richiedono un po’ di tempo prima di adattarsi alla quantità di energia infrarossa presente nella stanza in cui vengono inseriti, per l’HC-SR501 sono necessari dai 30 ai 60 secondi da quando il sensore viene alimentato.
Ricordare inoltre che il sensore ha un periodo di reset che può oscillare dai 3 ai 6 secondi dopo aver effettuato la lettura, durante tale periodo non verrà rilevato nessun movimento.

Esempio 01
Lettura dello stato del PIR e relativa accensione del LED 13

Schema di collegamento

Il codice per l’utilizzo del sensore è estremamente semplice, è necessario solamente rilevare se il pin OUT si trova a valore alto o basso. Il funzionamento è dettagliato nei commenti.

/*
 * Prof. Michele Maffucci
 * data: 28.02.2021
 * 
 * Esempio 01
 * Utilizzo del sensore PIR: PIR HC-SR501
 * Lettura dello stato del PIR e relativa accensione 
 * del LED 13
 * 
 */
 
byte pinLed = 13;   // pin a cui è collegato il LED
byte pinInput = 8;  // pin di input a cui è collegato l'OUT del PIR
bool valPIR = 0;    // variabile utilizzata per memorizzre lo stato del PIR
 
void setup() {
  pinMode(pinLed, OUTPUT);    // pin a cui è collegato il LED è un output
  pinMode(pinInput, INPUT);   // pin a cui è collegato il PIR è un input
 
  Serial.begin(9600);
}

void loop() {
  valPIR = digitalRead(pinInput);  // viene letto il valore restituito dal PIR
  digitalWrite(pinLed, valPIR);    // il LED sulla scheda verrà acceso se viene
                                   // rilevata una persona altrimenti il LED
                                   // resterà spento. valPIR assume i valori 0 o 1
 }

Esempio 02
Lettura dello stato del PIR e relativa accensione del LED 13 e stampa dello stato sulla Serial Monitor

/*
 * Prof. Michele Maffucci
 * data: 28.02.2021
 * 
 * Esempio 02
 * Utilizzo del sensore PIR: PIR HC-SR501
 * Lettura dello stato del PIR e relativa accensione 
 * del LED 13 e stampa dello stato sulla Serial Monitor
 */
 
byte pinLed = 13;   // pin a cui è collegato il LED
byte pinInput = 8;  // pin di input a cui è collegato l'OUT del PIR
bool valPIR = 0;    // variabile utilizzata per memorizzre lo stato del PIR
 
void setup() {
  pinMode(pinLed, OUTPUT);    // pin a cui è collegato il LED è un output
  pinMode(pinInput, INPUT);   // pin a cui è collegato il PIR è un input
 
  Serial.begin(9600);
}

void loop() {
  valPIR = digitalRead(pinInput);  // viene letto il valore restituito dal PIR
  Serial.println(valPIR);          // stampa sulla Serial Monitor il valore letto
  delay(150);                      // ritardo per rallentare la frequenza di stampa
                                   // sulla Serial Monitor

  // Viene controllato se il PIR rileva una persona
  // Nota: scrivere "if (valPIR)" è analogo che scrivere
  // "if (valPIR == HIGH)" in quanto valPIR assume i valori 0 o 1
  
  if (valPIR) {
    digitalWrite(pinLed, HIGH);
    Serial.println("Rilevata una persona");
  }
  else
  {
    digitalWrite(pinLed, LOW);
    Serial.println("Non è presente nessuno");
  }
 }

Esercizio 01

Realizzare un semplice sistema di allarme costituito dal sensore PIR, un buzzer e due LED uno rosso ed uno verde.

  • Se il PIR non rileva nessuna persona il LED verde risulta acceso, il LED rosso spento ed il buzzer non emette nessun suono.
  • Se il PIR rileva una persona il LED verde risulta spento, il LED rosso acceso ed il buzzer emette un suono.

Esercizio 02

Realizzare le medesime funzionalità dell’esercizio 01 ed aggiungere un display I2C su cui inviare l’output:

  • Allarme
  • No presenza

Buon Making a tutti 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato , , , , , | Lascia un commento

Arduino – Sensore di temperatura digitale DS18B20 utilizzo in modalità singola

Nelle attività di laboratorio di Sistemi e TPSEE usiamo molto spesso il sensore di temperatura TMP36, ma un’alternativa interessante al TPM36 è il sensore temperatura digitale DS18B20 utilizzato in modalità diversa dal TPM36.
Questo tipo di sensore è adatto per misure di temperatura ambiente, ma anche del terreno o per rilevare temperature nei liquidi.
Il sensore di solito è disponibile in due form factor, uno che viene fornito nel package TO-92, forma ampiamente utilizzato per i  transistor, mentre un’altro, quello utilizzato da me è inserito all’interno di una sonda impermeabile a forma di siluro, utilissimo quando si ha la necessità di misurare temperature sottoterra, sott’acqua, o lontane dal microcontrollore.

Particolarmente utile inoltre in queste settimane in cui i miei studenti di 4′ automazione stanno realizzando come progetto di PCTO una serra idroponica in cui è essenziale misurare la temperatura dell’acqua del sistema.

Il DS18B20 è abbastanza preciso può misurare temperature da -55 ° C a + 125 ° C con una precisione di ± 0,5 ° C.

Il sensore si basa sul protocollo OneWire introdotto da Dallas Semiconductor ora Maxim e richiede due librerie. La prima è la libreria e la DallasTemperature di Miles Burton, la seconda è la libreria OneWire.
La prima libreria da installare è la DallasTemperature di Miles Burton. Sono disponibili diverse librerie con il nome OneWire, quella che vi consiglio di utilizzare è la Wire Library di Jim Studt, Tom Pollard e altri.

Noterete comunque che durante l’installazione della libreria DallasTemperature vi verrà chiesto in automatico se volete installare anche la OneWire, procedete installando in automatico entrambe le librerie. Leggete attentamente le fasi descritte di seguito in cui riporto tutte le schermate delle fasi di installazione.

Il collegamento è estremamente semplice, come indicato nell’immagine che segue collegate il cavo rosso a 5V o a 3,3V su schede a 3,3V, il cavo nero va connesso al GND e il cavo del segnale “Out”, in genere di colore giallo, bianco o di altro colore, collegatelo ad un pin digitale, nell’esempio viene connesso al pin 2 con una resistenza da 4,7 K Ohm tra il segnale e il pin di alimentazione (5 V o 3,3 V).

Pinout

GND: collegamento al ground
Out: Bus Dati 1-Wire, deve essere collegato a un pin digitale sul microcontrollore.
Vdd: da collegare alla tensione di alimentazione (3,3 – 5 V)

Per tutti i dati tecnici del sensore vi rimando al datasheet.

Schema di collegamento

Circuito – sensore con package TO-92

Circuito – sonda impermeabile

Installazione delle librerie

Il protocollo Dallas OneWire è piuttosto complesso e per nascondere questa complessità installeremo  la libreria DallasTemperature.h in modo da poter impartire semplici comandi per ottenere letture di temperatura dal sensore.

Per installare la libreria, Sketch > Include Library > Manage Libraries

Inserite nel campo di ricerca: ds18b20. Dovrebbero esserci un paio di voci. Tra le varie possibilità selezionate, quella indicata nell’immagine

Il sensore per poter comunicare ha necessità anche della libreria OneWire, libreria che non è specifica per questo sensore, ma viene utilizzata con tutti i dispositivi che utilizzano il protocollo One Wire.

Nel momento in cui installate la prima libreria della Dallas Semiconductor viene chiesto con una finestra aggiuntiva se volete installare anche la libreria OneWire fate click su Install all.

Nel caso in cui avete dimenticato di installare la libreria OneWire potrete cercare sempre attraverso il Manage Libraries inserendo nel campo di ricerca

Esempio 01

Stampa della temperatura rilevata in gradi Celsius.
Il funzionamento del codice è dettagliato nei commenti.

/* 
 *  Prof. Maffucci Michele
 *  data: 24.02.2021
 *  Utilizzo del sensore di temperatura
 *  resistente all'acqua DS18B20
 *  
 *  Sketch 01: stampa delle temperature rilevate
 *  in gradi Celsius 
*/

// librerie per il funzionamento del sensore
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin Arduino a cui colleghiamo il pin DQ del sensore
const int pinLed = LED_BUILTIN; // Utilizzo del LED su scheda 

const int soglia = 25; // Accende il LED su scheda se si superano i 25°C

OneWire oneWire(ONE_WIRE_BUS); // Imposta la connessione OneWire

DallasTemperature sensore(&oneWire); // Dichiarazione dell'oggetto sensore

void setup(void)
{
  Serial.begin(9600);       // Inizializzazione della serial monitor
  sensore.begin();          // Inizializzazione del sensore
  pinMode(pinLed, OUTPUT);  // pinLed definito come OUTPUT

  // Stampa del messaggio di avvio
  Serial.println("Temperatura rilevata dal sensore DS18B20");
  Serial.println("----------------------------------------");
  delay(1000);
}

void loop()
{
  sensore.requestTemperatures(); // richiesta lettura temperatura
  
  // Restituzione della temperatura letta
  // in gradi Celsius

  // temperatura in Celsius
  float celsius = sensore.getTempCByIndex(0);
  
  // Visualizzazione delle letture 
  // della temperatura sulla Serial monitor
  
  Serial.print("C:");
  Serial.println(celsius);

  // se la temperatura è oltre la soglia
  // viene accesso il LED su scheda
  // altrimenti rimane spento
  
  if (celsius > soglia) {
    digitalWrite(pinLed, HIGH);
  } else {
    digitalWrite(pinLed, LOW);
  }
  // stampe delle temperature ogni secondo
  delay(1000);
}

All’interno del loop, lo sketch richiede una lettura della temperatura, quindi legge la temperatura in Celsius. Notare che non è necessario eseguire alcuna conversione aritmetica su
i risultati ottenuti dal sensore, tutto viene gestito dalla libreria. Tenete in conto che non è necessario apportare modifiche al codice, ma assicurati di cablare correttamente l’alimentazione del sensore, 3,3 V su schede che funzionano a questa tensione di riferimento o a 5V per schede che funzionano a 5V.

Esempio 02

Stampa della temperatura rilevata in gradi Celsius e Fahrenheit
Il funzionamento del codice è dettagliato nei commenti.

/* 
 *  Prof. Maffucci Michele
 *  data: 24.02.2021
 *  Utilizzo del sensore di temperatura
 *  resistente all'acqua DS18B20
 *  
 *  Sketch 02: stampa delle temperature rilevate
 *  in gradi Celsius e gradi Fahrenheit 
*/

// librerie per il funzionamento del sensore
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin Arduino a cui colleghiamo il pin DQ del sensore
const int pinLed = LED_BUILTIN; // Utilizzo del LED su scheda 

const int soglia = 25; // Accende il LED su scheda se si superano i 25°C
// La soglia di 25°C corrisponde a 77 °F
// Formula di conversione (Tc°C × 9/5) + 32 = Tf°F
// dove:
// Tc: temperatura in gradi Celsius
// Tf: temperatura in gradi Fahrenheit

OneWire oneWire(ONE_WIRE_BUS); // Imposta la connessione OneWire

DallasTemperature sensore(&oneWire); // Dichiarazione dell'oggetto sensore

void setup(void)
{
  Serial.begin(9600);       // Inizializzazione della serial monitor
  sensore.begin();          // Inizializzazione del sensore
  pinMode(pinLed, OUTPUT);  // pinLed definito come OUTPUT

  // Stampa del messaggio di avvio
  Serial.println("Temperatura rilevata dal sensore DS18B20");
  Serial.println("----------------------------------------");
  delay(1000);
}

void loop()
{
  sensore.requestTemperatures(); // richiesta lettura temperatura
  
  // Restituzione della temperatura letta
  // in gradi Celsius e gradi Fahrenheit

  // temperatura in Celsius
  float celsius = sensore.getTempCByIndex(0);

  // temperatura in Fahrenheit
  float fahrenheit = sensore.getTempFByIndex(0);
  
  // Visualizzazione delle letture 
  // della temperatura sulla Serial monitor
  
  Serial.print("C:");
  Serial.print(celsius);
  Serial.print(",");
  Serial.print(" F:");
  Serial.println(fahrenheit);

  // se la temperatura è oltre la soglia
  // viene accesso il LED su scheda
  // altrimenti rimane spento
  
  if (celsius > soglia) {
    digitalWrite(pinLed, HIGH);
  } else {
    digitalWrite(pinLed, LOW);
  }
  // stampe delle temperature ogni secondo
  delay(1000);
}

Il codice è molto simile al precedente, all’interno del loop, lo sketch richiede una lettura della temperatura, quindi legge la temperatura in Celsius, poi Fahrenheit.

Sono disponibili alcune utili funzioni che possono essere usate con l’oggetto DallasTemperature di seguito il dettaglio di alcune di esse:

La funzione setResolution() function imposta la risoluzione del convertitore Analogico-Digitale del DS18B20 a 9, 10, 11, or 12-bit, che corrispondono ad incrementi di  0.5°C, 0.25°C, 0.125°C e  0.0625°C.

La funzione setHighAlarmTemp() e setLowAlarmTemp () imposta gli allarmi interni di alta e bassa temperatura in gradi Celsius. L’intervallo valido è compreso tra -55 e 125 ° C

La funzione bool hasAlarm () restituisce true se il sensore rileva una condizione di superamento dei limiti minimo o massimo di temperatura.

Esercizio 1

  • Rilevare ogni 2 secondi 10 misurazioni, memorizzare questi valori in un Array
  • Visualizzare la temperatura minima, media e massima ogni 10 secondi su un display 16×2 I2C
  • Se la temperatura scende sotto il valore minimo o supera il valore massimo impostati viene emesso un allarme (messaggio su display, emissione di un suono, accensione di un LED rosso per il superamento del valore massimo, azzurro se la temperatura scende al di sotto del valore minimo impostato)

Esercizio 2

Realizzare le medesime funzionalità dell’esercizio precedente aggiungendo:

  • Ridurre la luminosità del display dopo 15 secondi di funzionamento
  • Alla pressione di un pulsante viene attivata la retroilluminazione del display
  • Se viene attivato un allarme si attiva la retroilluminazione

Nella prossima lezione vedremo come collegare sullo stesso bus più sensori DS18B20.

Buon Coding a tutti 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato , , , , , , | Lascia un commento

FutureLabs – Corso: Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari

Presso il FutureLabs dell’ITIS Pininfarina, istituto presso cui insegno, svolgerò il corso di formazione gratuito:

Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari.

Il corso intende fornire, mediante una metodologia laboratoriale, competenze digitali finalizzate alla comunicazione digitale e produzione di mediatori didattici multidisciplinari realizzabili da docenti e studenti. Il corso è indirizzato a tutti i docenti di ogni ordine e grado.

Tutti gli incontri si svolgeranno on-line e verranno proposte attività di laboratorio a distanza da svolgere in modalità sincrona ed asincrona.

Destinatari: docenti di scuola dell’infanzia, primaria e secondaria di 1° e 2° grado Periodo di svolgimento: n.6 incontri di 3 ore ciascuno nel periodo compreso tra il 23/03.2021 e il 15/04/2021. Per ogni incontro sarà riconosciuta una ulteriore ora in autoformazione.
Iscrizioni: dal 23/2/2021 al 1/3/2021 compilando il form al seguente link. Nel form selezionare come prima scelta: Attività laboratoriale per fornire competenze per la comunicazione digitale e produzione di mediatori didattici multidisciplinari.

Si precisa che al corso saranno ammessi 40 partecipanti. Al corso saranno accettate le domande in ordine cronologico di arrivo e i docenti ammessi riceveranno  mail di conferma entro il 4/3/2021.

Argomento del corso sarà la didattica laboratoriale, con particolare attenzione all’uso di specifiche tecnologie: micro:bit, micro:bit Arcade, Arduino, Raspberry Pi, Raspberry Micro. Verranno offerte percorsi didattici completi su Coding e Robotica, proponendo soluzioni opensource e bassissimo costo per ogni ordine di scuola.

Contenuti del corso

Contenuti generali del corso che potranno essere declinati in funzione delle necessità dei corsisti

  • Progetto dell’attività di laboratorio: dalla ricerca delle fonti alla produzione dell’attività di laboratorio (organizzazione)
  • Processi di apprendimento: il ruolo dei nuovi media nella didattica
  • Progettazione di ambienti per la didattica con il digitale: gestire la classe e il laboratorio online
  • Tecniche di costruzione di contenuti digitali per la didattica – metodologie
  • L’utilizzo di video e della fotografia nella didattica – tecnologie e strumenti
  • Costruire strumenti didattici per il Mobile Learning: tecnologie e strategie
  • L’uso di piattaforme per la didattica – dalla creazione alla gestione
  • La didattica inclusiva e le opportunità dei nuovi media – strumenti
  • Coding e Robotica educativa.
    • Realizzazione di sistemi di interazione con il mondo reale: tecnologie e loro utilizzo
    • Creazione di robot: dal disegno al montaggio del robot alla programmazione
    • STEAM con la stampa 3D: disegnare modelli 3D utilizzando il Coding conoscere la tecnologia della stampa 3D
    • Simulatori online per la realizzazione di attività laboratoriali di Coding e Robotica.

Competenze in uscita

  • Sviluppo attività di insegnamento/apprendimento, con capacità nell’indicare la funzione svolta dai media e il modello didattico su cui si basano.
  • Scegliere e fornire indicazioni consapevoli per la progettazione di ambienti scolastici inclusivi coerenti con le attività didattiche programmate.
  • Utilizzare software per la realizzazione di contenuti digitali per la didattica, per la creazione di contenuti e abilità nel costruire strumenti didattici in modalità collaborativa con altri docenti e/o con i propri studenti.
  • Utilizzare software ed hardware specifico per la realizzazione di contenuti attività laboratoriali online ed in presenza, per la creazione di  contenuti e abilità nel costruire strumenti didattici in modalità collaborativa con altri docenti e/o con i propri studenti.
  • Conoscere le fasi di utilizzo dei filmati in un contesto didattico: dall’individuazione o realizzazione del video, alla condivisione e successivo confronto in classe. Utilizzo del funzionamento di software open source per editare i video, per effettuare lo “screencast” e realizzare video-lezioni utilizzando varie tipologie di contenuti.
  • Utilizzo dei principali Social Network e modalità di integrazione nelle classi per una didattica più vicina agli studenti e un uso del Mobile Learning (m-learning).
  • Creazione e gestione di una classe virtuale mediante l’uso dei principali applicativi on-line, tecniche di coinvolgimento degli studenti, condivisione di risorse, utilizzo di strumenti integrati, collaborazione con altri docenti.
  • Saper progettare attività didattiche che valorizzano il ruolo inclusivo delle tecnologie per l’intera classe e nello specifico per alunni con BES e nello specifico saper analizzare e valutare le caratteristiche di uno strumento didattico digitale in ottica inclusiva.
  • Progettare e gestire attività didattiche basate sulla programmazione di robot (soluzione di labirinti, storytelling, realizzazione di giochi didattici, controllo comportamento e interazione del robot con oggetti esterni). Analisi delle tecnologie e soluzioni didattiche.
  • Utilizzo di tecnologie specifiche per la realizzazione di attività di laboratorio per il potenziamento delle STEAM mediante specifiche tecnologie: micro:bit, micro:bit Arcade, Arduino, Raspberry Pi, Raspberry Micro. Realizzazione di attività di laboratorio.
  • Coding on line: piattaforme online gratuiti e ambienti di sviluppo fortemente interattivi.

Vi aspetto 🙂

Pubblicato in corsi | Contrassegnato , , , , , , , , , | Lascia un commento

Raspberry Pi Pico – conosciamo la scheda ed installiamo MicroPython

Raspberry Pi Pico è una nuovissima scheda di prototipazione elettronica estremamente potente ed economica che monta il microcontrollore RP2040 costituito da un Cortex-M0+. La scheda è prodotta da Raspberry Pi ed ha un costo estremamente contenuto, circa € 4,5.
La scheda ha una dimensione simile a quella di un Arduino Nano, però rispetto alle  schede della famiglia Arduino che montano microcontrollori ATmega, possiede una potenza di calcolo e di memoria superiore. Inoltre è possibile programmarla in MicroPython, C e C++.

La scheda è stata messa in vendita qualche settimana fa e non appena commercializzata ho deciso di acquistarne 10 schede, ulteriori 10 schede mi arriveranno tra qualche giorno ciò mi permetterà di gestire un’intera classe di studenti e le prime sperimentazioni le effettuerò con i miei studenti di  5′ Elettronica e Automazione a cui assegnerò il compito di sviluppare le esercitazioni che poi utilizzerò nel prossimo anno scolastico con i miei studenti di 3′ del percorso elettronica e automazione.
Come prima attività in DaD ho chiesto ai miei allievi di realizzare in autonomia un documento di presentazione del prodotto e una tabella di confronto con le schede Arduino che montano microcontrollori ATmega tutto ciò mi farà risparmiare tempo e ci permetterà di concentraci sull’attività pratica in laboratorio.

Con questo post ne voglio presentare  le caratteristiche tecniche e la modalità di installazione del firmware ed un esempio di programmazione in MicroPython. Sul sito di riferimento potete trovare tutta la documentazione necessaria per utilizzare la scheda.

Pico viene venduto senza piedini di collegamento, quindi dovrete acquistarli e procedere poi voi a sedarli sulla scheda, quindi armatevi di tanta pazienza ed utilizzando una breadboard per fissare i pin, procedete con la saldatura.

Per maggiori informazioni seguire il link per la pagina di riferimento della scheda.

Caratteristiche tecniche

L’RP2040 è il primo microcontrollore di Raspberry Pi. I due core del processore Cortex-M0+ del  Pico funzionano a 48 MHz, anche se questo può essere modificato nel software fino a 133 MHz.

La RAM del microcontrollore è incorporata nello stesso chip dei core del processore, è costituita da sei banchi di memoria  per un totale di 264kB (264.000 byte) di RAM statica (SRAM). La RAM viene utilizzata per memorizzare i vostri programmi e i dati di cui hanno bisogno i programmi.

L’RP2040 include 30 pin GPIO (general-purpose input / output) multifunzione, 26 dei quali sono collegati a connettori pin fisici sul vostro Pico e uno dei quali è collegato a un LED integrato sulla scheda. Tre di questi pin GPIO sono collegati a un convertitore analogico-digitale (ADC), mentre un altro canale ADC è collegato a un sensore di temperatura su chip.

L’RP2040 include due UART (ricevitore-trasmettitore asincrono universale), due SPI (Serial Periferal Interface) e due bus I2C (Inter-Integrated Circuit) per i collegamenti a dispositivi hardware esterni come sensori, display, convertitori digitale-analogico (DAC) e molto altro. Il microcontrollore include anche un ingresso/uscita programmabile (PIO), che consente al programmatore di definire nuove funzioni hardware e bus nel software.

Il  Pico include un connettore micro USB, che permette un collegamento seriale UART-over-USB al microcontrollore RP2040 per la programmazione e l’interazione e che alimenta il chip. Tenendo premuto il pulsante BOOTSEL quando si collega il cavo, il microcontrollore passerà alla modalità “Dispositivo di archiviazione di massa USB”, consentendo di caricare il nuovo firmware.

L’RP2040 include anche un on-chip clock e timer, che permette di tenere traccia in modo preciso dell’ora e della data. Il clock può memorizzare l’anno, il mese, il giorno, il giorno della settimana, l’ora, i minuti e i secondi e tiene automaticamente traccia del tempo trascorso finché viene fornita l’alimentazione alla scheda. RP2040 include il single-wire debug (SWD)  un debug hardware a tre fili nella parte inferiore del tuo Pico.

Pinout del Raspberry Pi Pico

 

 

 

Caratteristiche tecniche

  • CPU: 32-bit dual-core ARM Cortex-M0+ at 48MHz, configurabile fino a 133MHz
  • RAM: SRAM da 264kB disposi in 6 banchi indipendenti configurabili
  • Memoria: flash RAM esterna da 2MB
  • GPIO: 26 pins
  • ADC: 3 × 12-bit ADC pin
  • PWM: 16
  • Clock: Orologio e timer accurati su chip con anno, mese, giorno, giorno della settimana, ora, secondi e calcolo automatico dell’anno bisestile
  • Sensori: Sensore di temperatura On-chip connesso connesso ad un ADC 12-bit
  • LED: LED su scheda indirizzabile dall’utente
  • Connessioni bus: 2 × UART, 2 × SPI, 2 × I2C, Programmable Input/Output (PIO)
  • Hardware Debug: Single-Wire Debug (SWD)
  • Mount Options: pin passanti
  • Alimentazione: 5 V via micro USB, 3.3 V via 3V3 pin, o 2–5V via VSYS pin

Installare MicroPython

Dopo che avete effettuato le saldature dei pin abbiamo bisogno di installare MicroPython sulla scheda. Colleghiamo un cavo micro USB alla porta micro USB del vostro Pico.
Per installare MicroPython sul vostro Pico dovrete scaricarlo da Internet. Questa operazione è da fare una sola volta, dopo averlo installato rimarrà sul vostro Pico a meno che voi non decidiate di sostituirlo con qualcos’altro.

Mantenete premuto “BOOTSEL” nella parte superiore del tuo Pico, vicino al connettore USB, quindi, tenendolo ancora premuto, collega l’altra estremità del cavo micro USB a una delle porte USB del vostro computer Raspberry Pi o altro computer. Contate tre secondi, dopo di che rilasciate il pulsante “BOOTSEL”. Dovreste vedere il vostro  Pico apparire come un’unità rimovibile, come se avessimo collegato un’unità flash USB o un disco rigido esterno. Sul vostro computer verrà aperta una finestra per aprire l’unità (la scheda) che avete connesso.

Nella finestra del vostro File Manager, vedrete due file sul  Pico: INDEX.HTM e INFO_UF2.TXT. Il file  INFO_UF2.TXT contiene informazioni sul  Pico tra cui la versione del bootloader attualmente in esecuzione sul Pico.

Il file, INDEX.HTM, contiene tutte le informazioni utili per usare il Pico, fate doppio clic, sarete reindirizzati sulla pagina di benvenuto da cui reperire tutte le informazioni che servono per iniziare. Fate clic sulle schede scorrete la pagina per accedere alle guide, ai progetti e alla raccolta di libri: una libreria di documentazione tecnica dettagliata che copre tutto, dal funzionamento interno del microcontrollore RP2040 il cuore della vostra scheda, alla programmazione in Python e C / C ++.

Leggete tutte le informazioni sulla pagina, andate in “Getting started with MicroPython” e fate clic sul pulsante “Scarica file UF2” per scaricare il firmware MicroPython, che è un piccolo file che contiene MicroPython per il vostro Pico. Il download dal sito di riferimento richiede pochissimi secondi.

Una volta scaricato, andate nella vostra cartella Download cercate il file “micropython” seguito da una data e dall’estensione “uf2”. Fare clic e tenere premuto il pulsante del mouse sul file UF2, quindi trascinatelo sull’unità di archiviazione rimovibile di Pico (quindi all’interno del Pico). Posizionalo sulla finestra e rilascia il pulsante del mouse per rilasciare il file sul vostro Pico.

Dopo qualche secondo il vostro Pico scomparirà dal vostro File Manager e potreste anche vedere un messaggio del vostro sistema operativo che vi dice che un’unità è stata rimossa senza essere stata espulsa: non preoccupatevi, non è successo nulla di grave, ciò accade perchè quando avete trascinato il file del firmware MicroPython sul Pico, avete detto di eseguire il flashing del firmware nella  memoria interna di Pico. Per fare il flashing il Pico esce dalla modalità speciale in cui lo avete  inserito con il pulsante “BOOTSEL” (modalità periferica USB), vedrete lampeggiare il LED sulla scheda, ciò indica che Pico ora esegue MicroPython.

Bene! Ora siete pronti per iniziare a programmare in MicroPython su Raspberry Pi Pico! 🙂

Installiamo l’IDE Thonny per programmare in MicroPython.

Scarichiamo ora l’IDE di programmazione Thonny, vedremo in una lezione successiva come utilizzare Visual Studio Code.

Andate sul sito https://thonny.org e scaricate la versione per il vostro sistema operativo

Doppio click sull’applicazione, si aprirà la seguente finestra:

Configuriamo ora l’IDE per poter programmare il Pico, dal menù > Strumenti > Opzioni… selezionare “Interprete”

Scegliere MicroPython (Raspberry Pi Pico)

Determiniamo ora la porta seriale di connessione a cui abbiamo collegato il Pico, possiamo effettuare questa operazione oppure manualmente selezionate quella identificata da una lunga serie di 0 che termina con 1

Dal menù Strumenti > Gestione plug-in… inserire nel campo di ricerca “machine”

Si avvierà l’installazione, al termine chiudete la finestra.

Vediamo ora come effettuare il blink del LED sulla scheda.
Scrivimi all’interno dell’area di programmazione il seguente codice, fate attenzione all’indentazione, come sapete in Python è importante.

import machine
import utime

led_onboard = machine.Pin(25, machine.Pin.OUT)

while True:
    led_onboard.value(1)
    utime.sleep(1)
    led_onboard.value(0)
    utime.sleep(1)

La prima linea di codice:

import machine

Questa prima linea di codice è importantissima in quanto vi consentirà di lavorare con MicroPython sul Pico, importerà la libreria “machine” che contiene tutte le istruzioni necessarie che permettono per fare comunicare MicroPython con Pico ed altri dispositivi compatibili con MicroPython.
Senza questa linea di codice non sarete in grado di controllare nessuno dei pin GPIO di Pico e non potrete controllare il LED sulla scheda.

La seconda linea di codice

import utime

Importa la libreria di MicroPython: “utime”. Questa libreria gestisce tutto ciò che ha a che fare con il tempo, dalla misurazione all’inserimento di ritardi.

led_onboard = machine.Pin(25, machine.Pin.OUT)

Questa riga definisce un oggetto chiamato led_onboard, che è il nome che assegniamo noi per fare riferimento al LED sulla scheda, possiamo tecnicamente utilizzare qualsiasi nome, possibilmente meglio scegliere nomi che abbiamo attinenza con la funzionalità dell’oggetto in modo da rendere più semplice la lettura del programma.
Come si può notare la funzione machine.Pin() è costituita da due parametri: il pin a cui è connesso il LED, il 25, seguito dalla modalità con cui viene usato il pin, OUT. Per chi ha familiarità con la programmazione con Arduino noterà che l’azione è la medesima, cambia solo la sintassi.

Definiamo un loop infinito in cui andremo ad inserire le istruzioni che vogliamo vengano ripetute per sempre.

while True:

Analizziamo le istruzioni nel corpo del while

led_onboard.value(1)

Questa linea di codice imposta il pin ad HIGH però da sola non permetterà ancora l’accensione del LED, è necessario indicare per quanto tempo il LED starà ad HIGH con la riga di codice che segue manteniamo ad 1 (HIGH) il Led per 1 secondo

utime.sleep(1)

Allo stesso modo impostiamo a 0 (LOW) il il pin a cui è connesso il LED

led_onboard.value(0)

facciamo in modo che questo stato duri per 1 secondo:

utime.sleep(1)

Fare ora clic sull’icona play per eseguire lo script:

il LED sulla scheda inizierà a lampeggiare

Per fermare l’esecuzione dello script sulla scheda fare click su STOP

Nel caso in cui invece desiderate rendere l’esecuzione automatica non appena il Pico viene connesso ad una fonte di alimentazione, rinominate il file in main.py e salvatelo sulla scheda

Buon Coding a tutti 🙂

Pubblicato in elettronica, i miei allievi, Raspberry Pi Pico | Contrassegnato , , | Lascia un commento

SumoBot in Foam: SumoFoam

Dopo la la pubblicazione dei sorgenti grafici del SumoBot ho ricevuto mail da parte di colleghi in cui mi veniva chiesto di condividere i file pdf per la versione Foam Core del piccolo robot, come mostrato nel post: SumoFoam – per realizzare velocemente una struttura per robot didattico.

Il materiale, come dettagliato nel link, si presta molto bene per realizzare agevolmente innumerevoli strutture utili per le nostre sperimentazioni di laboratorio (qualche esempio nel link allegato), il costo del materiale non è elevatissimo ed è semplice tagliarlo con un semplice cutter. Architetti e studenti di architettura conoscono bene il Foam Core in quanto lo utilizzano per realizzare plastici di ogni tipo, ho utilizzato io stesso questo materiale in passato per costruire plastici di alloggi per la realizzazione di esercitazioni di domotica con Arduino.

Condivido pertanto i file pdf che potete stampare su un foglio A4 adesivo ed incollare poi su un foglio di Foam Core.

Condivido una versione con colore del tratto rosso per il taglio laser ed una versione con tratto nero per la stampa su foglio adesivo A4

Nell’immagine che segue potete vedere le due versioni di SumoFoam tagliato a laser a sinistra e con con cutter a destra.

Spero che questo lavoro possa servire anche ad altri e se ritenete, per scopi didattici, modificate i sorgenti secondo le vostre necessità.

Buon Making a tutti.

Pubblicato in i miei allievi, robotica | Contrassegnato , , , , | Lascia un commento

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

Lavoro di PCTO a.s. 2020-2021. Anno scolastico difficile, la pandemia non aiuta assolutamente nello sviluppo di attività laboratoriali a scuola e in azienda e a tal proposito ho pensato di rivedere completamente il laboratorio iniziando dalle attività di laboratorio degli studenti del 3′ anno.
Come molti colleghi e studenti sapranno il PCTO (ex alternanza scuola lavoro) svolto al terzo anno consiste nello svolgimento di un’attività che viene integralmente realizzata a scuola in cui viene svolta una simulazione d’impresa, dalla progettazione alla creazione di un prodotto, ma il periodo è complicato e lo svolgimento delle attività avverrà in parte online ed in parte in presenza, online si effettueranno tutte le operazioni progettuali e di documentazione mentre in presenza si assemblerà l’oggetto che dovrà poi essere reso prodotto. Come per gli anni passati per le classi terze propongo un’attività basata su un kit da me progettato che i ragazzi poi dovranno modificare e migliorare sia dal punto di vista meccanico che dal punto di vista elettronico e informatico. Parto da un prodotto progettato in partenza semplicemente perché i tempi, i costi ed il periodo non permettono una progettazione da zero, ma come accade ogni anno molti ragazzi a fine attività rivedono integralmente il progetto riformulando una nuova proposta.


La robotica attrae sempre e prototipare piccoli robot affascina sempre i giovani studenti, pertanto ho modificato la prima versione del SumoRobot disegnato nello scorso anno scolastico, formulando una versione che potesse essere realizzata con semplicità e a costi molto bassi.
Tutti i miei studenti, di qualsiasi classe, ormai posseggono un kit Arduino con una buona dotazione di componentistica elettronica, pertanto le esercitazioni  in DaD non avvengono solamente usando simulatori, ma svolgendo praticamente loro a casa ed io a casa o a scuola le esercitazioni e allo stesso modo si opererà per l’attività di PCTO, fornendo un kit agli allievi.

Il kit consiste in un supporto di compensato da 4 mm tagliato a laser a scuola le cui parti verranno fissate utilizzando colla vinilica. Il controllo avviene mediante un Arduino Nano connesso ad una Sensor Shield V03 che permetterà agevolmente di connettere sensori e attuatori mediante semplici jumper evitando saldature.

I motori sono costituiti da due servomotori a rotazione continua, ciò consentirà di alimentare direttamente i motori dalla scheda Arduino evitando l’aggiunto di una ponte H per controllare i motori, azione che i ragazzi svolgeranno in altre esercitazioni. Due i sensori utilizzati sul robot: sensore ad ultrasuoni e sensori IR. L’alimentazione avverrà tramite una batteria da 9V. Il controllo dei movimenti del robot potrà avvenire anche remotamente via Bluetooth con Smartphone. Due gli elementi stampati in 3D, una ball caster in cui viene inserita una biglia di vetro e un supporto per il sensore ad ultrasuoni.

Durante la prima lezione gli allievi dovranno, seguendo il video allegato, assemblare tutte le parti, ricordando prima di ogni cosa di fissare la sensoristica e l’elettronica e successivamente procedere con l’incollaggio delle varie parti di compensato della struttura.

Per poter assemblare il robot bisognerà seguire il video allegato e le fotografie che seguono in cui sono evidenziate alcune parti.

E’ importante inoltre porre attenzione alla parte superiore di compensato che ha un orientamento specifico, seguire attentamente le indicazioni del video e delle fotografie.

A questa prima lezione allego la presentazione del progetto e i sorgenti grafici (pdf) in modo che anche altri colleghi o studenti possano duplicare e migliorare l’attività.

Nelle successive lezioni verranno mostrati i collegamenti elettrici delle varie parti e proposti alcuni sketch di esempio da cui partire per aggiungere le funzionalità richieste.

Presentazione del progetto.

Titolo del progetto: SumoRobot

Simulare la progettazione e la realizzazione da parte di un’azienda di un kit robotico per l’apprendimento del Coding e della Robotica per studenti della scuola media e primi due anni delle superiori.
Il Robot deve avere caratteristiche tali da poter essere impiegato in diverse tipologie di sperimentazioni didattiche:

  • evita ostacoli
  • segui linea
  • comando a distanza via Smartphone
  • modalità gara Sumo

Il kit dovrà essere corredato da:

  • Titolo Azienda
  • Titolo del prodotto (non deve essere quello dell’attività di PCTO) corredato da logo
  • Brochoure pubblicitaria
  • Manuale di istruzioni per il montaggio composto da: lista materiali e componenti, fasi di montaggio, il tutto arricchito con immagini e disegni tecnici
  • Manuale introduttivo alla programmazione con Arduino indirizzata alla programmazione del robot
  • Lista di sketch di esempi commentati e funzionanti da allegare al kit
  • Slide di presentazione del progetto
  • Sito internet di riferimento in cui raccogliere tutta la documentazione per il cliente

Note

  • Tutta la documentazione dovrà essere prodotta in lingua italiana ed inglese.
  • Il sito internet dovrà essere realizzato con Google Site e sarà visibile solo mediante account personale dello studente al gruppo di lavoro e ai docenti del Consiglio di Classe
  • Il diario di bordo dovrà essere prodotto con Google Documenti e dovrà collezionare l’attività svolta durante ogni giornata di lavoro
  • Nel diario di bordo bisognerà includere una sezione di “considerazioni personali” espresse da ogni singolo studente sull’attività svolta ed eventuali suggerimenti per il miglioramento del progetto.
  • La presentazione del prodotto dovrà essere realizzata con Google Presentazioni
  • Ogni fase costruttiva dovrà essere documentata in modo fotografico e con brevi video

Lista componenti

  • Sensore ultrasuoni HC-SR04
  • Sensor Shield per Arduino Uno Nano V3
  • Servomotori a rotazione continua 360° –  FS90R con ruote
  • Arduino Nano (originale o compatibile) nella versione compatibile che utilizza un convertitore da USB a Seriale tipo CH340G è indispensabile installare un driver specifico
  • Cavo di Alimentazione 9V con cavo jack maschio 2.1 X 5.5 mm
  • Batteria 9V
  • Jumper Femmina-Femmina

Orientamento delle varie parti della struttura del robot

Vista frontale del robot

Vista dal basso del robot, si notano i due sensori IR fissati con vite M3 da 12 mm

Blocco supporto sensore ultrasuoni mediante due viti M3 da 12 mm

I servomotori sono fissati alla struttura mediante due fascette stringicavo. Seguire l’orientamento dei servomotori così come indicato nelle immagini che seguono, i cavi di uscita dei servomotori devono essere rivolti verso l’esterno

Nell’immagine si nota in quali fessure far passare la fascetta stringicavo

La chiusura della fascetta deve avvenire nella parte inferiore del robot mantenendo il nodo di chiusura così come indicato nell’immagine

Le ruote vanno fissate al mozzo del motore mediante apposita vite

La scheda Sensor Shield V03 va fissata ai giunti esagonali mediante vite M3 da 10 mm

Nella prossima lezione vedremo come collegare le varie parti elettroniche ed inizieremo con la programmazione del robot.

Buon Making a tutti 🙂

Pubblicato in elettronica, i miei allievi, robotica | Contrassegnato , , , , , | Lascia un commento