Arduino: controllare il movimento di un motore a spazzola con un transistor

Abbiamo visto a lezione in cosa consiste la Modulazione di Larghezza di Impulso, in altro modo conosciuta come PWM (Pulse Width Modulation). Questo tipo di modulazione permette ad un sistema digitale di controllare dispositivi di tipo analogico in corrente continua facendo variare in modo continuo la potenza erogata, quindi moduliamo la larghezza di un impulso, ovvero la durata temporale di una serie di impulsi che regolerà l’attivazione e disattivazione del motore. Con il PWM agiamo non sulla tensione di alimentazione per controllare la velocità del motore, ma bensì sul tempo, per maggiori informazioni vi rimando alle slide: Alfabeto Arduino – Lezione 2 in cui come esempio viene controllata l’intensità luminosa di LED. (Per i miei studenti fate riferimento al libro di testo e agli appunti di teoria).

Il transistor nell’immagine che segue viene fatto funzionare in modalità ON-OFF e quindi  possiamo assimilarlo ad un interruttore che si apre e si chiude in corrispondenza del segnale presente sulla base del transistor. Se il segnale sulla base è alto il transistor sarà in conduzione e il motore potrà essere alimentato (si chiude verso massa il collegamento del motore). Se il segnale sulla base del transistor è a livello basso il transistor è assimilabile ad un interruttore aperto per cui il motore risulta non alimentato (non si ha collegamento a massa). Quindi al motore verrà applicata una tensione continua proporzionale al duty cycle e quindi variando il duty cycle varieremo la velocità di rotazione del motore.

La generazione dell’onda quadra, che controlla la velocità del motore, viene eseguita da Arduino. Il diodo presente nel circuito è chiamato diodo di ricircolo ed è inserito in parallelo al motore (carico induttivo) per sopprimere i transienti elettrici ed è collegato in modo tale che non conduce quando il carico (il motore) viene alimentato.
Quando il motore viene disattivato rapidamente si avrà un picco di tensione in senso inverso perché l’induttore tenderà a mantenere costante la corrente che circola al suo interno, in questa situazione però il diodo sarà polarizzato direttamente e tutta la corrente scorrerà dall’induttore al diodo e l’energia che era stata immagazzinata dall’induttore  viene dissipata in calore dalla componente resistiva dell’induttore. Inserendo il diodo si eviterà di applicare una sovratensione sul collettore del transistor evitando quindi che si danneggi.

Controlliamo con Arduino il movimento del motore

Lista Componenti

  • Arduino UNO R3
  • Resistore da 1 K Ohm
  • Dido: 1N4001
  • Transistor: 2N2222
  • Condensatore: 0,1 microF

Pinout transistor 2N2222

Circuito 1 di montaggio: alimentazione del motore prelevata da Arduino

Circuito 2 di montaggio: alimentazione del motore esterna ad Arduino

Esempio 1
Si faccia riferimento al circuito 1. Realizziamo uno sketch che permette la regolazione della velocità del motore inserendo un numero compreso tra 0 e 9. Il valore 0 ferma il motore, il valore 9 permette di muovere il motore alla velocità massima, valori intermedi movimenteranno il motore ad una velocità proporzionale al numero inserito.

Valori fuori dall’intervallo impostato restituiscono un messaggio di errore.

Per la realizzazione di questo sketch si utilizza la funzione isDigit() che restituisce TRUE verifica se il carattere inviato sulla Serial Monitor è un numero, altrimenti restituisce FALSE.

/*
   Prof. Maffucci Michele
   Controllo motore a spazzola:
   accensione, spegnimento, controllo velocità.
   All'avvio del programma il motore è spento.

   La velocità del motore è impostata
   con un valore compreso tra 0 e 9

   Valori non numerici restituiscono
   un messaggio di errore
   
   Data: 19.01.2021
*/

// driver del motore collegato al pin 6
const byte pinMotore = 6; // motor driver is connected to pin 3

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

void setup()
{
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione OUTPUT del pin 6
  pinMode(pinMotore, OUTPUT);
}

void loop()
{
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio 
    delay(200);
    Serial.println("Controllo velocità motore");
    Serial.println("Inserire la velocità (0 - 9)");
    Serial.println();
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah
  
  if (Serial.available()) {        // Viene controllato se è disponibile un carattere

    // definizione di una variabile di tipo char in cui memorizzare
    // il carattere inviato ad Arduino mediante la Serial Monitor

    char carattere = Serial.read();

    // La funzione isDigit restituisce TRUE se se il carattere
    // inviato sulla Serial Monitor è un numero altrimenti restituisce FALSE

    if (isDigit(carattere)) // verifica se è un numero
    {
      // mappiamo l'intervallo dei caratteri da '0' a '9'
      // in un valore compreso tra 0 e 255, intervallo di valori
      // del Duty Cycle

      int vel = map(carattere, '0', '9', 0, 255);
      analogWrite(pinMotore, vel);
      
      Serial.print("Valore del Duty Cycle: ");
      Serial.println(vel);
      Serial.println("--------------------------");
      Serial.print("Velocità impostata: ");
      Serial.println(carattere);
      Serial.println("==========================");
            
    }
    else
    {
      // nel caso in cui il carattere inserito non è un numero
      // viene restituito un messaggio e stampa il carattere
      Serial.println();
      Serial.println("******************************");
      Serial.print("Carattere non riconosciuto: ");
      Serial.println(carattere);
      Serial.println("******************************");
      Serial.println();
    }
  }
}

Esempio 2
Si faccia riferimento al circuito 1. Realizziamo uno sketch che permette la regolazione della velocità del motore inserendo un numero compreso tra 0 e 9. Il valore 0 ferma il motore, il valore 9 permette di muovere il motore alla velocità massima, valori intermedi movimenteranno il motore ad una velocità proporzionale al numero inserito.

Valori fuori dall’intervallo impostato fermano il motore.

Per la realizzazione di questo sketch si utilizza la funzione Serial.parseInt() che legge i caratteri sulla seriali e restituisce la loro rappresentazione numerica (tipo long). I caratteri che non sono numeri interi (o con segno meno) vengono ignorati.

Nel dettaglio

  • I caratteri iniziali che non sono cifre o sono numeri negativi vengono ignorati;
  • L’analisi si interrompe quando non sono stati letti caratteri per un valore di tempo di timeout che può essere configurato oppure viene letta una non cifra;
  • Se non sono state lette cifre valide quando si verifica il timeout (vedere Serial.setTimeout ()), viene restituito 0; Serial.parseInt () eredita dalla classe Stream.
/*
   Prof. Maffucci Michele
   Controllo motore a spazzola:
   accensione, spegnimento, controllo velocità.
   All'avvio del programma il motore è spento.

   La velocità del motore è impostata
   con un valore compreso tra 0 e 9

   Valori non numerici fermano il motore.

   Viene utilizzata la funzione Serial.parseInt() per leggere

   Data: 19.01.2021

*/

// driver del motore collegato al pin 6
const byte pinMotore = 6; // motor driver is connected to pin 3

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup()
{
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione OUTPUT del pin 6
  pinMode(pinMotore, OUTPUT);
}

void loop()
{
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Controllo velocità motore");
    Serial.println("Inserire la velocità (0 - 9)");
    Serial.println();
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available()) {        // Viene controllato se è disponibile un carattere

    // definizione di una variabile di tipo char in cui memorizzare
    // il carattere inviato ad Arduino mediante la Serial Monitor

    // per maggior informazioni sull'uso di parseInt() consultare il link:
    // https://wp.me/p4kwmk-4Ah

    int valore = Serial.parseInt();

    // La funzione isDigit verifica se il carattere inviato è un numero
    // e restituisce TRUE se il carattere è un numero altrimenti restituisce FALSE

    // mappiamo l'intervallo dei caratteri da '0' a '9'
    // in un valore compreso tra 0 e 255, intervallo di valori
    // del Duty Cycle

    if (valore >= 0 && valore <= 9) {

      if (valore == 0) {
        Serial.println();
        Serial.println("************************************");
        Serial.println("MOTORE FERMO");
        Serial.println("Valore inserito 0 o fuori intervallo");
        Serial.println("************************************");
        Serial.println();
      }

      int vel = map(valore, 0, 9, 0, 255);
      analogWrite(pinMotore, vel);

      Serial.print("Valore del Duty Cycle: ");
      Serial.println(vel);
      Serial.println("--------------------------");
      Serial.print("Velocità impostata: ");
      Serial.println(valore);
      Serial.println("==========================");
    }
  }
}

Esercizio 1
Aggiungere al circuito 1 due pulsanti che permettono di aumentare o diminuire la velocità del motore. Fare in modo che la velocità impostata del motore sia proporzionale ai valori numerici interi nell’intervallo tra 0 e 9, così come fatto negli esempi precedenti. Ad ogni pressione del pulsante P1 si incrementa di una unità il valore della velocità. Ad ogni pressione del pulsante P2 si decrementa la velocità del motore i una unità. All’avvio di Arduino il motore è spento. Mostrare la velocità impostata sulla serial monitor.

Esercizio 2
Aggiungere all’esercizio precedente un pulsante P3 di emergenza che alla pressione ferma il motore. Se è stata azionata l’emergenza i pulsanti P1 e P2 di incremento e decremento non funzionano. Per poter riattivare il sistema bisogna premere nuovamente P3.

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

Supporto per motore a spazzola kit ELEGOO

La quasi totalità dei miei studenti, per svolgere le attività di sperimentazione di elettronica e automazione a casa e a scuola in questo periodo di crisi pandemica, ha acquistato uno dei molti kit ELEGOO in cui, anche nella versione base del kit, sono presenti tutti i componenti per svolgere le prime esercitazioni di automazione. All’interno dei diversi kit è presente un motore CC a spazzola 3-6 V come quello indicato nell’immagine che segue a cui è possibile connettere una ventola.

Questo semplice motore viene utilizzato in diverse esperienze di laboratorio: marcia e arresto, controllo di velocità e molto altro. Per far si che il banco di lavoro sia ordinato ho realizzato in 3D tre elementi che permettono di disporre il motore su un supporto di legno ricavato da una comune bacchetta di legno 20×20 mm che può essere acquistata in qualsiasi brico.

Condivido su Thingiverse i sorgenti grafici per la realizzazione del supporto.

Di seguito alcune immagini della semplice struttura… e quando farà caldo tutti avranno il proprio ventilatore personale 🙂

Buon Making a tutti 🙂

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

SumoFoam – per realizzare velocemente una struttura per robot didattico

“5 minuti da Maker” è orami un’abitudine che ho da qualche tempo: progettare in 5 minuti un oggetto o una soluzione e realizzarla. Alcune volte realizzarla mi richiede un po’ più di 5 minuti, ma cerco di non superare in tutto 60 minuti. E’ un’esercizio che mi sono imposto settimanalmente, un po’ come svago un po’ per dar sfogo ad idee nascenti che potrebbero diventare qualcosa di più importante.

Questa volta l’esercizio consiste nel rendere ancora più semplice la realizzazione del SumoBot, picco robot realizzato in compensato, trasformandolo in una versione realizzata con un materiale ancora più semplice da manipolare per gli studenti più giovani, il Foam Core, (per saperne di più continua la lettura 😉 ).

Durante una delle tante attività di PCTO feci realizzare ai miei studenti di 3′ automazione un il piccolo SumoBot su una base di compensato da 3mm, l’attività consisteva nel montare la struttura, l’elettronica e programmare i robot affinchè potessero gareggiare. Il tutto era stato realizzato con schede Arduino UNO R3 e anche con degli Arduino micro, due micro servo SG90 a rotazione continua ed un sensore ad ultrasuoni. Alcuni aggiunsero al robot una scheda Bluetooth per poter pilotare il robot anche via smartphone. Fu un’attività divertentissima che voglio riproporre ai ragazzi.

Nel riprendere in mano il progetto ho pensato di realizzare una versione della struttura in Foam Core, un materiale utilizzato dagli architetti per costruire plastici di abitazioni.  Si tratta di uno strato di spugna racchiuso da due fogli di cartoncino. Viene venduto in fogli di diverso spessore e dimensione, attualmente sto utilizzando fogli A3 di spessore 5mm. Le strutture che se ne ricavano sono sufficientemente solide. Utilizzo questo materiale quando voglio prototipare rapidamente oggetti per le mie sperimentazioni, come quello che vedete nell’immagine che segue, un supporto per un display 16×2.

In genere stampo su fogli adesivi bianchi A4 la struttura che voglio realizzare, dispongo i fogli adesivi sul Foam Core e con un cutter ne ritaglio il profilo. Tutti gli elementi poi vengono incastrati e incollati con normalissima colla vinilica.

Con il Foam Core ho provato a realizzare una serie di piccoli robot e sono rimasto più che soddisfatto.

Di seguito la sequenza fotografica delle fasi di montaggio, il taglio degli elementi non è perfetto, con un po’ più tempo e pazienza si può fare molto meglio.

Tra qualche giorno, quando terminerò di effettuare le ultime prove sul SumoFoam renderò pubblico il file pdf.

Stampo su foglio adesivo bianco il profilo del robot ed incollo su Foam Core.

Si nota la struttura a sandwich del pannello: cartoncino – materiale spugnoso – cartoncino

Oltre ad incastrare i vari elementi ho utilizzato della colla vinilica.

Prossimamente il montaggio dell’elettronica da parte dei miei studenti.

Buon Making a tutti 🙂

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

Siemens TIA Portal – Impossibile creare il collegamento al server. Come risolvere il problema.

In questi giorni sto progettando ulteriori esercitazioni per i miei studenti sull’uso di TIA Portal e questa attività mi ha portato anche ad eseguire una serie di aggiornamenti sul software. Attualmente ho installato sul mio computer e sui computer della scuola la versione 15.1. Eseguendo l’aggiornamento di TIA ho riscontrato un problema in TIA Software Updater nel collegarsi al server degli aggiornamenti, mi viene restituito il messaggio di errore: “Impossibile creare il collegamento al server”. Dopo tanta insistenza e ricerca online e lettura di forum ho trovato la soluzione agendo nella maniera più semplice, installazione cumulativa manuale degli aggiornamenti di TIA fino all’ultima versione, upd. 5, risalente al 08/2020. Procedendo in questo modo ho risolto e TIA Software Updater ora funziona e mi fornisce gli aggiornamenti.

Poiché questo problema lo riscontrerò anche su altri computer nei laboratori della mia scuola e sono sicuro che anche altri utenti avranno avuto il medesimo problema, ho deciso di realizzare un breve tutorial che servirà principalmente a me per mantenere memoria di come procedere nel caso in cui mi si ripresentasse il problema su altri computer.

Ma perché questo errore? Il motivo lo spiega direttamente Siemens sul suo sito:

“As of 02/2020, the Siemens Update Server will only support calls with the latest, secure protocols (at least TLS 1.2). The TIA Administrator, the TIA Updater and the TIA Updater Corporate Configuration Tool have therefore been expanded to include these new protocols. Older versions of these products will no longer be able to connect to the Siemens Update Server from 02/2020.”

Che tradotto:

“A partire dal 02/2020, Siemens Update Server supporterà solo le chiamate con i protocolli più recenti e sicuri (almeno TLS 1.2). TIA Administrator, TIA Updater e TIA Updater Corporate Configuration Tool sono stati quindi ampliati per includere questi nuovi protocolli. Le versioni precedenti di questi prodotti non saranno più in grado di connettersi al Siemens Update Server dal 02/2020.”

Procediamo con l’aggiornamento e la soluzione al problema.

Situazione di partenza, avvio di TIA Updater genera il messaggio di errore: “Impossibile creare il collegamento al server”

Controllo la versione di TIA Portal avviando TIA e selezionando: Software installato.

Vado al seguente link: Aggiornamenti per STEP 7 V15.1 e WinCC V15.1, effettuare il login

Nella pagina selezionare l’ultimo aggiornamento disponibile, alla data in cui scrivo questo post è: Update 5 (08/2020). Scaricare tutti i file che ho indicato nell’immagine con la freccia rossa.
Una volta che avrete prelevato tutti i file avviate l’installazione dal file .exe (l’ultimo nella lista indicata nell’immagine che segue).

Procedere facendo clic su “Avanti”.

Selezionata la lingua, se il vostr sistema operativo è impostato in italiano vi verrà proposto in automatico l’italiano, clic su “Avanti”.

Procedete come riportato nell’immagine, clic su “Avanti”.

Attendete l’estrazione di tutti i file, questa operazione richiede alcuni minuti.

Proseguite facendo clic su “Avanti”.

Lasciate tutto selezionato e proseguite facendo clic su “Avanti”.

Accettate le condizioni di licenza inserendo le spunte al fondo della finestra.

Anche in questo caso accettate le condizioni di sicurezza inserendo la spunta al fondo della finestra.

Confermate l’installazione facendo clic su “Installazione”.

Ora è il momento di prendersi un momento di pausa, prendete una tazza di te perché la fase di installazione durerà circa 25 minuti.

Al termine clic su “Riavvia” per riavviare il computer.

Avviate TIA Portal e controllate la versione del software installato: nel mio caso: Update 5.

Avviate nuovamente TIA Updater e noterete che il problema è stato risolto.

Buon Making a tutti 🙂

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

EduRobot Lift/Elevator

Nuova versione del kit EduRobot Lift, ascensore/montacarichi da utilizzare per le esercitazioni di laboratorio di sistemi elettronici e attività di PCTO negli istituti tecnici industriali e professionali.

Rispetto alla versione precedente alcune migliorie che ne facilitano la costruzione. Il controllo può essere effettuato in diverse modalità: Siemens Step 7 1200, Logo8!, Siemens IoT 2040, Arduino. La struttura è stata disegnata con Adobe Illustrator e tagliata a laser presso il Laboratorio Territoriale del mio istituto, l’ITIS G.B. Pininfarina di Moncalieri. Il materiale è costituito da compensato da 4 mm e due elementi stampati in 3D in PETG. Il montaggio della struttura richiede circa 40/45 min.

Se desideri realizzare il kit, seguire il link su Thingiverse, da cui potrete prelevare il file PDF per il taglio laser e i file STL per la stampa 3D della struttura del motore.

Volutamente per la realizzazione di questo kit sono stati scelti materiali economici in quanto il mio desiderio è quello di assegnarne un kit ad ogni studente.

  • foglio di compensato da 4mm 80×60 mm (costo indicativo: €4)
  • 24 viti M3 da 12 mm
  • 24 dadi M3
  • motorino passo passo 28BYJ-48
  • colla vinilica
  • due elementi stampati in 3D
  • spago

Nel kit viene utilizzato un motore passo passo economico il 28BYJ-48 in modo che possa essere acquistato da tutti gli studenti. Con qualche piccola modifica è possibile utilizzare anche un motorino DC da 6V, i classici “motorini gialli” utilizzati dagli studenti per la costruzione di piccoli robot.

Quattro gli obiettivi di questo progetto:

  1. offrire una guida fotografica per i miei studenti della classe 3′ che dovranno svolgere il PCTO (ex Alternanza Scuola Lavoro) facendo una simulazione di attività aziendale, quest’anno dovranno diventare tecnici di un’azienda che produce ascensori e montacarichi;
  2. mostrare agli studenti che è possibile imparare ad imparare attraverso attività laboratoriali che prevedono la progettazione e la costruzione dei propri strumenti di apprendimento;
  3. il mercato offre molteplici strumenti, kit robotici di ogni tipo che rispondono a molteplici esigenze didattiche, ma alcune volte non rispondono ad esigenze specifiche di un percorso di studio o di un argomento, ecco che la scuola diventa produttrice dei propri ausili didattici specifici;
  4. rispondere alle numerose richieste di realizzazione del kit pervenutemi da molti colleghi di scuole italiane dopo il mio intervento per SCE Siemens in cui ho mostrato le mie sperimentazioni didattiche nell’ambito dell’automazione, tra queste anche EduRobot Lift. Ringrazio tutti.

Di seguito un breve video che mostra la struttura generale del kit e di seguito una guida fotografica passo passo che ne dettaglia le fasi di costruzione.

In successive lezioni verranno proposti modalità di controllo del sistema.

Sentitevi liberi di apportare modifiche e migliorie alla struttura. Mi farebbe piacere avere un vostro parere ed eventualmente, se utilizzate il kit, inviatemi le fotografie dei vostri lavori in modo che io possa pubblicarle su questo sito.

Il progetto è rilasciato con la seguente licenza: Attribuzione 4.0 Internazionale (CC BY 4.0)

Come viene mostrato nell’immagine che segue il kit è costituito da 21 elementi di compensato e due elementi stampati in 3D, nell’immagine potete notare anche un 3′ elemento, una piccola rondella di plastica, che è stata poi sostituita da un dado M3 (i dettagli al fondo di questa lezione).

Struttura impiegata per fissare il motore passo passo e il rocchetto utilizzato per avvolgere lo spago a cui verrà fissata la cabina dell’ascensore.

Nell’immagine si vedono viti M3 da 12 mm e dadi M3.

La colla vinilica viene utilizzata solamente per fissare i piedini alla base della struttura.

Poiché sulla base del kit sono presenti delle viti, per evitare che queste raschino la base di appoggio, sono stati previsti dei piedini la cui altezza è di 8 mm, ciò si ottiene incollando tra loro due elementi.

Incollare i piedini sugli angoli della base.

Allineare i piedini come riportato nell’immagine che segue.

Fare in modo che ci sia anche un allineamento rispetto alla verticale.

Predisporre il montaggio della cabina dell’ascensore. Si consiglia di inserire prima il dato nella fessura così come riportato nell’immagine. La parte inferiore della cabina è identica a quella superiore con la differenza che la parte superiore ha un foro in cui andremo ad inserire lo spago.

Inserire la parete laterale e dalla parte opposta inserire la vite. Bloccare i due elementi, ma attenzione a non avvitare con forza.

Procedere allo stesso modo per la parte posteriore della cabina dell’ascensore: Inserire i dadi, incastrare nella fessura la parete ed avvitare con le due viti.

Inserire la parte superiore della cabina contraddistinta da un foro centrale.

Passiamo ora alle colonne. Sono presenti 6 colonne di due tipi: con fori e senza fori, hanno tutte la stessa dimensione. Le colonne con fori hanno un’orientamento, nell’immagine si nota che i fori hanno distanze diverse dal bordo che va incastrato alle basi. I fori che hanno una distanza di 4 cm dalla base vanno rivolti verso la base di appoggio dell’ascensore.

Tre sono le colonne frontali ed andranno inserite nelle apposite fessure. Anche in questo caso si consiglia di inserire prima i dadi.

Posizione in cui devono essere inserite le colonne frontali.

Inserire le viti dalla parte inferiore della base.

Inserire le colonne laterali. Prima di inserirle nelle fessure incastrare i dadi M3.

Bloccare con viti.

Montare la colonna posteriore.

Procedere nel montaggio così come fatto per le altre colonne.

Inserire la cabina dell’ascensore, con la parte aperta disposta frontalmente.

Le scanalature laterali permettono di far scorrere la cabina tra le guide.

Fissare la base superiore del kit. Inserire nelle colonne i dadi e successivamente inserire nella posizione indicata dalle frecce le viti.

Avvitare, ma attenzione a non serrare con forza, rischiereste di rompere il compensato.

Inserire 4 viti nella posizione indicate dalle frecce.

Avvitare i dadi.

Inserire il rocchetto all’interno dell’asse del motore. Attenzione che il rocchetto ha un’orientamento, ciò è mostrato nel video ad inizio di questa lezione. Come si nota l’asse del motore non è cilindrico.

Inserire la vite nella posizione indicata dalla freccia, questa costituisce un supporto per il rocchetto. Avvitare il motore alla struttura.

Fissiamo lo spago alla cabina. Inserite lo spago nel foro dalla parte superiore e legateci un dado.

Poggiate la cabina sulla base della struttura e fate in modo che il filo sia ben dritto ed incollatelo sul rocchetto. Il risultato dovrebbe essere il seguente:

Buon Making a tutti 🙂

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

Arduino – Uso di LED RGB – approfondimento

Scrivo questa lezione come approfondimento della guida realizzata tempo fa: Arduino – lezione 09: uso di LED RGB in cui mostravo come funzionano e come si gestiscono i LED RGB con Arduino. Negli esercizi proposti utilizzavo un LED ad ANODO comune. In questa nuova lezione utilizzerò un diodo a CATODO comune e mostrerò tre esempi, nel primo ripropongo in una modalità diversa l’esercizio della prima lezione in cui faccio alcuni approfondimenti sull’uso della direttiva #define, mentre nel secondo e terzo esercizio viene mostrato come impostare il colore emesso dal LED RGB mediante input da tastiera su Serial Monitor richiamando con questi esempi l’uso del qualificatore const per una variabile e l’utilizzo della funzione parseInt(). Come sempre nei commenti, all’interno del codice, trovate la spiegazione del funzionamento di ogni parte dello sketch.

Esempio 01

Variazione colore continuo di un LED RGB secondo lo schema:

ROSSO > VERDE, VERDE > BLU, BLU > ROSSO

Scema di collegamento

/*  Prof. Maffucci Michele
    06.01.2021

    Esempio 01
    Variazione colore continuo
    di un LED RGB secondo lo schema:

    ROSSO > VERDE, VERDE > BLU, BLU > ROSSO

*/

/* Utilizzo della direttiva #define per definire una costante
   La direttiva viene utilizzata per definire una MACRO ovvero
   un simbolo.

   La sintassi per la definizione di una macro è:
   #define nome-MACRO  valore_MACRO

   Per convenzione il nome della macro viene scritta in maiuscolo.

   Il preprocessore legge la definizione di ogni MACRO e ogni volta che
   ne incontra il nome all'interno del programma (file sorgente) sostituisce
   al simbolo il valore corrispondente, senza che venga effettuata la verifica
   della correttezza sintattica dell'espressione risultante.
*/

#define VERDE 9
#define BLU 10
#define ROSSO 11

// tempo di dissolvenza tra i colori
#define tempoRitardo 10

void setup()
{
  // impostazione ad OUTPUT dei pin
  pinMode(ROSSO, OUTPUT);
  pinMode(VERDE, OUTPUT);
  pinMode(BLU, OUTPUT);

  // all'avvio viene emesso il colorore ROSSO
  digitalWrite(BLU, LOW);
  digitalWrite(VERDE, LOW);
  digitalWrite(ROSSO, HIGH);
}

// definizione di variabili
int valoreRosso;
int valoreVerde;
int valoreBlu;

void loop()
{
  // Impostazioni variabili per avere partire con LED:
  // ROSSO accesso, VERDE spento, BLU spento.
  valoreRosso = 255;
  valoreVerde = 0;
  valoreBlu = 0;

  // partendo dal ROSSO si sfuma al VERDE pieno quando i = 255
  for (int i = 0; i < 255; i += 1)
  {
    valoreRosso -= 1;
    valoreVerde += 1;

    // L'intensità del ROSSO viene diminuita ad ogni ciclo, mentre
    // l'intensità del VERDE viene aumentata ad ogni ciclo
    analogWrite(ROSSO, valoreRosso);
    analogWrite(VERDE, valoreVerde);
    delay(tempoRitardo);
  }

  // Impostazioni variabili per avere partire con LED:
  // ROSSO spento, VERDE acceso, BLU spento.
  valoreRosso = 0;
  valoreVerde = 255;
  valoreBlu = 0;

  // partendo dal VERDE si sfuma al BLU pieno quando i = 255
  for (int i = 0; i < 255; i += 1)
  {
    valoreVerde -= 1;
    valoreBlu += 1;

    // L'intensità del VERDE viene diminuita ad ogni ciclo, mentre
    // l'intensità del BLU viene aumentata ad ogni ciclo
    analogWrite(VERDE, valoreVerde);
    analogWrite(BLU, valoreBlu);
    delay(tempoRitardo);
  }

  // Impostazioni variabili per avere partire con LED:
  // ROSSO spento, VERDE spento, BLU acceso.
  valoreRosso = 0;
  valoreVerde = 0;
  valoreBlu = 255;

  // partendo dal BLU si sfuma al ROSSO pieno quando i = 255
  for (int i = 0; i < 255; i += 1)
  {
    valoreBlu -= 1;
    valoreRosso += 1;

    // L'intensità del BLU viene diminuita ad ogni ciclo, mentre
    // l'intensità del ROSSO viene aumentata ad ogni ciclo
    analogWrite(BLU, valoreBlu);
    analogWrite(ROSSO, valoreRosso);
    delay(tempoRitardo);
  }
}

Esempio 02

Inserimento da Serial Monitor dei valori di intensità del colore. La stringa di richiesta inserimento dei valori RGB viene ripetuta una sola volta e ad ogni nuovo inserimento non viene stampato sulla serial monitor il valore inserito.

Lo schema di collegamento è il medesimo dell’esempio 01.

/*  Prof. Maffucci Michele
    06.01.2021

    Esempio 02
    Inserimento da Serial Monitor dei valori
    di intensità del colore.
    La stringa di richiesta inserimento viene ripetuta una sola volta.
    Ad ogni nuovo inserimento non viene stampato sulla serial monitor
    il valore inserito.

    L'inserimento dei tre valori potrà essere effettuato
    in una delle due modalità:
    1. separando i tre numeri con spazio
    2. separando i tre numeri con la virgola
*/

/*
   Una variabile const indica al compilatore che il valore della
   variabile non può essere modificato durante l'esecuzione del programma.
   Una variabile const viene inizializzata nel momento della dichiarazione,
   se ciò viene fatto in un momento successivo il compilatore rileverà un
   errore che segnalerà anche errore in ogni operazione che comportano la
   modifica del valore dell avariabile definita come const
*/

const byte pinRosso = 11;
const byte pinBlu = 10;
const byte pinVerde = 9;

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

  // Impostazione dei pin come OUTPUT
  pinMode(pinRosso, OUTPUT);
  pinMode(pinBlu, OUTPUT);
  pinMode(pinVerde, OUTPUT);

  // Messaggio sulla serial monitor
  Serial.println("Inserisci i valori R G B (es. 125, 50, 255)");
  Serial.println("-------------------------------------------");
  delay(1000);
}

void loop() {

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available()) {
    // memorizzazione dei colori nelle variabili
    int rosso = Serial.parseInt();
    int verde = Serial.parseInt();
    int blu = Serial.parseInt();

    // impostazione del PWM
    analogWrite(pinRosso, rosso);
    analogWrite(pinVerde, verde);
    analogWrite(pinBlu, blu);
  }
}

Esempio 3

Inserimento da Serial Monitor dei valori di intensità del colore.
Il valore inserito verrà stampato sulla Serial Monitor e ad ogni invio verrà richiesto di inserire un nuovo valore.

Lo schema di collegamento è il medesimo dell’esempio 01.

/*  Prof. Maffucci Michele
    06.01.2021

    Esempio 03
    Inserimento da Serial Monitor dei valori
    di intensità del colore.
    Il valore inserito verrà stampato sulla Serial Monitor e ad ogni
    invio verrà richiesto di inserire un nuovo valore.

    L'inserimento dei tre valori potrà essere effettuato
    in una delle due modalità:
    1. separando i tre numeri con spazio
    2. separando i tre numeri con la virgola
*/

/*
   Una variabile const indica al compilatore che il valore della
   variabile non può essere modificato durante l'esecuzione del programma.
   Una variabile const viene inizializzata nel momento della dichiarazione,
   se ciò viene fatto in un momento successivo il compilatore rileverà un
   errore che segnalerà anche errore in ogni operazione che comportano la
   modifica del valore dell avariabile definita come const
*/

const byte pinRosso = 11;
const byte pinBlu = 10;
const byte pinVerde = 9;

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

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

  // Impostazione dei pin come OUTPUT
  pinMode(pinRosso, OUTPUT);
  pinMode(pinBlu, OUTPUT);
  pinMode(pinVerde, OUTPUT);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.print("Inserisci i valori R G B (es. 125, 50, 255): ");
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah


  if (Serial.available()) {
    // memorizzazione dei colori nelle variabili
    int rosso = Serial.parseInt();
    int verde = Serial.parseInt();
    int blu = Serial.parseInt();
    Serial.print(rosso);
    Serial.print(", ");
    Serial.print(verde);
    Serial.print(", ");
    Serial.println(blu);
    Serial.println("-------------------------------------------");

    // impostazione del PWM
    analogWrite(pinRosso, rosso);
    analogWrite(pinVerde, verde);
    analogWrite(pinBlu, blu);

    // abilita alla stampa di una nuova stringa:
    // "Inserisci il ritardo in millisecondi: "
    abilitaMessaggio = 0;
  }
}

Esercizi per i miei studenti

Esercizio 1

Utilizzare tre pulsanti che funzionino come interruttori che permettono di accendere e spegnere un solo LED alla volta:

  • pulsante 1: LED ROSSO
  • pulsante 2: LED VERDE
  • pulsante 3: LED BLU

Ogni cambiamento di stato deve essere segnalato sulla Serial Monitor.

Esercizio 2

Utilizzare due pulsanti in gredo di realizzare la seguente automazione:

  • pulsante 1: attivare/disattivare la modalità di variazione continua del colore, così come esposta nell’esempio 01
  • pulsante 2: attivare/disattivare la generazione casuale di un colore

Ogni cambiamento di stato deve essere segnalato sulla Serial Monitor.

Esercizio 3

Utilizzando la Serial Monitor come unico strumento per inviare comandi ad Arduino, realizzare un menù di selezione che permette di impostare le funzionalità dell’esercizio 01 e dell’esercizio 03.

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

Arduino: utilizzo di buzzer attivi e passivi – lezione 1

Nella progettazione di un sistema di automazione sono molto spesso previsti apparati di interazione e di allarme che potranno essere visivi o sonori. Per quanto riguarda gli apparati sonori spesso vengono utilizzati dei buzzer, chiamati anche cicalini. Con questo dispositivo potremo quindi segnalare lo stato di un sistema.

I buzzer possono essere di due tipi:

  • attivi
  • passivi

I buzzer possono essere di tipo magnetico o piezoelettrici la scelta del tipo dipende sostanzialmente da tre fattori:

  1. segnale di pilotaggio
  2. potenza di uscita richiesta
  3. spazio fisico disponibile

Buzzer attivo

Un buzzer attivo usa un oscillatore interno che permette di emettere un tono a frequenza fissa se viene alimentato con una tensione continua.

L’oscillatore interno è in grado di modificare il campo magnetico di una bobina a cui è connesso meccanicamente una membrana che oscillerà alla frequenza fissata dall’oscillatore.

Con Arduino si potrà realizzare un sistema di automazione in grado di comandare l’emissione del suono abilitando o disabilitando l’alimentazione del buzzer.

Caratteristiche tecniche di un buzzer attivo

  • Tensione nominale: 6V DC
  • Tensione di esercizio: 4-8V DC
  • Corrente nominale: < 30mA
  • Tipo di suono: segnale acustico continuo
  • Frequenza di risonanza: ~2300 Hz

Buzzer passivo

Un buzzer passivo non possiede un oscillatore interno e quindi è indispensabile un circuito esterno in grado di generare un’onda quadra che mettere in oscillazione la membrana interna del buzzer, questi attuatori potranno così emettere toni a diversa frequenza.

Con Arduino si potrà realizzare un sistema di automazione in grado di comandare l’emissione del suono per un certo tempo ad una determinata frequenza utilizzando il la modulazione digitale PWM.

Caratteristiche tecniche di un buzzer attivo

  • Tensione nominale: 5V DC
  • Tensione di esercizio: 4-8V DC
  • Corrente nominale massima: ≤ 32 mA
  • Min. Uscita audio a 10 cm: 85 dB
  • Temperatura di esercizio: da 20°C a 45°C

Pilotare un buzzer con Arduino

Per produrre un suono con Arduino si utilizza la funzione tone, il link vi rimanda al references di Arduino in cui troverete tutti i dettagli di utilizzo della funzione.

L’istruzione che verrà utilizzata è:

tone(pin, frequenza)
tone(pin,frequenza,durata)
  • pin: sarà il pin (PWM) su cui sarà presente il segnale modulato a cui verrà connesso il buzzer.
  • frequenza: frequenza del suono emesso. (unsigned int)
  • durata: la durata del tono espressa in millisecondi. (unsigned long)

Come indicato nel references:

Genera un’onda quadra alla frequenza specificata ( e duty cycle al 50% ) su un pin. Una durata puà essere specificata, altrimenti l’onda continua fino alla chiamata di noTone(). Il pin può essere connesso ad un buzzer piezoelettrico o altro speaker per riprodurre toni.

Solo un tono alla volta può essere generato. Se un tono è gia in riproduzione su un pin differente, la chiamata a tone() non avrà alcun effetto. Se il tono è in riproduzione sullo stesso pin, la chiamata ne imposterà la frequenza.

L’uso della funzione tone() interferirà con l’output PWM sui pin 3 e 11 (sulle schede diverse dalla Mega ).

Non è possibile generare toni inferioni a 31Hz. Per i dettagli tecnici, vedi le note di Brett Hagman.

NOTA: Se vuoi riprodurre toni differenti su pin multipli, hai bisogno di chiamare noTone() su un pin prima di chiamare tone() sul pin successivo.

La funzione noTone() interrompe la generazione dell’onda quadra causata da tone(). L’uso di noTone() non ha alcun effetto se non si sta generando alcun tono.

Sintassi:

noTone(pin);

Con Arduino è possibile riprodurre un solo tono alla volta in quanto l’utilizzo della funzione tone è legato ad un timer specifico del microcontrollore, il timer2 e se questo è richiesto da altre funzioni, come ad esempio un analogRead su pin PWM la funzione tone non potrà essere utilizzata. Per aggirare questo limite è possibile utilizzare la libreria Tone.h che vedremo nella prossime lezioni.

Il suono che può essere riprodotto mediante un altoparlante o un buzzer passivo collegato ad Arduino sarà un suono “metallico”, non sarà simile a quello di uno strumento musicale, e questo verrà ottenuto utilizzando un’onda quadra alla frequenza specificata.

Per riprodurre suoni simili a quelli di uno strumento musicale bisognerà utilizzare una scheda elettronica esterna che verrà controllata da Arduino, ma vedremo questa possibilità in una lezione successiva.

Per questa lezione utilizzerò prima un buzzer attivo e successivamente un buzzer passivo.

Esempio 1 – utilizzo buzzer attivo

 

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 01
   Utilizzo di un buzzer attivo
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int buzzerRitardo = 1000;      

void setup() {
  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 02 – utilizzo buzzer attivo

Per richiamare l’uso di valori interi dalla Serial Monitor di seguito uno sketch che permette di inserire da computer il valore del delay che regola l’ON e l’OFF del buzzer attivo.

Lo schema di collegamento è il medesimo dell’esempio precedente.

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 02
   Utilizzo di un buzzer attivo
   Inserimento delay da Serial Monitor
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int  buzzerRitardo = 0;      

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

void setup() {
   
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio 
    delay(200);
    Serial.print("Inserisci il ritardo in millisecondi: ");
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available())
  {
    // in r viene memorizzato il valore inserito
    // attraverso la Serial Monitor
    int r = Serial.parseInt();
    if (r != 0) {
      buzzerRitardo = r;
      Serial.println(buzzerRitardo);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      abilitaMessaggio = 0;
    }
  }
  
  // funzione permette di fare suonare il Buzzer
  suona();
}

void suona() {
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 03 – utilizzo buzzer attivo

Utilizziamo ora un trimmer per modificare il delay che varia tra 100 e 1000 millisecondi, per fare questa operazione utilizzeremo la funzione map che rimapperà i valori presenti su A0 nell’intervallo 100, 1000.

 

/* Prof. Michele Maffucci
   data: 01.01.2021

   Esempio 03
   Utilizzo di un buzzer attivo
   Inserimento delay da Trimmer per impostare
   un ritardo tra 100 e 1000 millisecondi
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int  buzzerRitardo = 0;      

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

// variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

void setup() {
   
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  // valore analogico letto su A0 inserito con il trimmer
  val = analogRead(A0);

// Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 100, 1000
  
  buzzerRitardo = map(val, 285, 719, 100, 1000);

  // funzione permette di fare suonare il Buzzer
  suona();
}

void suona() {
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 4 – utilizzo buzzer passivo

Utilizziamo ora un buzzer passivo per riprodurre un tono in base alla frequenza impostata da un trimmer collegato al pin A0. Si faccia attenzione che ora il buzzer è collegato al pin 5 di tipo PWM

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 04
   Utilizzo di un buzzer passivo per riprodurre
   un tono in base alla frequenza impostata
   da un trimmer collegato al pin A0
*/

// pin (PWM) a cui è collegato il buzzer
byte buzzerPin = 5;

// variabile in cui memorizzare la frequenza del tono
int  intonazionePin = 0;

 // variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

// frequenza del tono
unsigned int frequenza;

// durata del tono
unsigned long durata = 10;

void setup()
{
  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop()
{
   // valore analogico letto su A0 inserito con il trimmer
   val = analogRead(A0);

 // Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 1000, 5000

  // frequenza assunerà un valore tra 1000 Hz e 5000 Hz
  frequenza = map(val, 285, 719, 1000, 5000);

  // emissione del tono
  tone(buzzerPin, frequenza, durata);

  // pausa di 1 millisecondo
  delay(1);
}

Nella prossime lezioni, utilizzando un buzzer passivo, realizzeremo dei brevi brani musicali e successivamente sostituiremo il buzzer con un altoparlante da 8 Ohm.

Buon Making a tutti 🙂

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

Arduino: controllo sequenziale uscite digitali

Durante la progettazione di un sistema di automazione accade frequentemente di avere la necessità di ripetere, sequenzialmente e in modo continuo, l’attivazione di apparati (ad es. motori) oppure la lettura continua dei dati provenienti da più sensori. Come attività di ripasso per i miei studenti ho deciso di riprendere alcuni argomenti affrontati nelle scorse settimane con specifiche esperienze di laboratorio:

  • automi a stati finiti;
  • utilizzo degli array;
  • input valori interi da serial monitor;
  • marcia, arresto, pausa di sequenze;
  • controllo uscite digitali mediante ingressi analogici;
  • realizzazione di commutatori con pulsanti con uno o più pulsanti;
  • utilizzo corretto dei tipi di dati per risparmiare memoria;
  • e molto altro

Di seguito 9 sketch in cui vengono ripresi gli argomenti sopra elencati e che potranno essere utilizzati nei prossimi mesi per sviluppare ulteriori sperimentazioni.
Come sempre all’interno degli sketch proposti trovate le spiegazioni di ogni parte del codice ed in alcuni casi trovate link di approfondimento che rimandano a questo sito.

Per ripercorrere gli argomenti svolti partirò dal classico sketch che permette di realizza l’accensione sequenziale di LED, come quello che potete trovare nelle mie slice: Alfabeto Arduino – Lezione 2 a pagina 66.
I LED nel circuito identificano gli apparati da attivare sequenzialmente, realizzando così il classico effetto “super car” (i diversamente giovani 🙂 sanno perché si chiama così).
Circuito e sketch verranno poi modificati per rispondere alle specifiche indicate ad inizio di ogni esempio.

Sketch 01

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED con tempo di accensione di 100 millisecondi.

 

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 01
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED con
   tempo di accensione di 100 millisecondi.
   
   Questo codice è di dominio pubblico 
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
byte ritardoLed = 100;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

void setup() {                
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }
    
  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  
  tempoTrascorso = millis();
}

void loop() {
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x=0; x<8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Sketch 02

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED. Con un trimmer è possibile variare il tempo di accensione nell’intervallo da 50 millisecondi a 1000 millisecondi (1 secondo).

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 02
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED controllato
   da un trimmer che permetterà di variare il tempo di accensione
   da 50 millisecondi a 1000 millisecondi (1 secondo).
   
   Questo codice è di dominio pubblico 
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
int ritardoLed;

// variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

void setup() {
  Serial.begin(9600);            
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }
    
  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  
  tempoTrascorso = millis();
}

void loop() {

  // valore analogico letto su A0 inserito con il trimmer
  val = analogRead(A0);

// Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 50, 1000
  
  ritardoLed = map(val, 285, 719, 50, 1000);
  
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x=0; x<8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Sketch 03

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED. L’accensione di ogni LED è fissato in partenza a 100 millisecondi. Con un messaggio sulle Serial Monitor viene richiesto di inserire un nuovo tempo di accensione e spegnimento di ogni LED (delay), tempo che può essere scelto a piacimento.

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 01.

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 03
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED.

   Partenza sequenza con 100 millisecondi e messaggio sulla
   Serial Monitor per modificare il tempo di
   accensione e spegnimento del singolo LED (delay)
   
   Questo codice è di dominio pubblico 
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
int ritardoLed = 100;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della serial monitor
  Serial.begin(9600);
               
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }

  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  tempoTrascorso = millis();
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio 
    delay(200);
    Serial.print("Inserisci il ritardo in millisecondi: ");
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available())
  {
    // in r viene memorizzato il valore inserito
    // attraverso la Serial Monitor
    int r = Serial.parseInt();
    if (r != 0) {
      ritardoLed = r;
      Serial.println(ritardoLed);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      abilitaMessaggio = 0;
    }
  }
  
  // funzione che fa lampeggiare il LED su Arduino
  lampeggio();
}

void lampeggio() {
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x = 0; x < 8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Continua a leggere

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

BBC micro:bit – Esercizio: Realizzare un timer per il lavaggio delle mani

In una situazione di didattica a distanza fare laboratorio può essere complicato, ma con un po’ di fantasia e l’aiuto degli studenti si può fare molto. Alcuni mesi fa avevo proposto ai miei allievi questa stessa esercitazione però realizzata con Arduino: Arduino – Esercizio: Realizzare un timer per il lavaggio delle mani.

Ho realizzato la medesima esercitazione questa volta con BBC micro:bit in tre modalità diverse che vi condivido, nel codice trovate anche i commenti che spiegano sommariamente il codice. Ovviamente al sistema potrebbe essere aggiunto:

  • allarme sonoro
  • servomotore su cui inserire indice rotante, così come fatto per la sperimentazione con Arduino.

Spero che questa proposta possa essere utile anche ad altri.

Versione 1 (link al codice sorgente)

Versione 2 (link al codice sorgente)

Versione 3 (link al codice sorgente)

Buon making a tutti.

Pubblicato in i miei allievi, micro:bit | Contrassegnato , , | Lascia un commento