Michele Maffucci

Il Coding con il nuovo Scratch 3: per una didattica attiva – 2ª edizione

Pubblicato il Maggio 3, 2019 da admin

Innegabile, l’uso di Scratch interessa tantissimo, ne ho continuamente riscontro anche quando svolgo corsi in presenza. Appassionano tantissmo le nuove possibilità di connessione ai dispositi esterni: Lego Mindstorms Ev3, Lego WeDo 2.0, BBC micro:bit, MakeyMakey e molte delle domande che mi sono state fatte durante la passata edizione riguardavano l’interazione con questi kit didattici utilissimi per fare Coding e Robotica.
Ecco che la proposta di Tecnica della Scuola non si è fatta attendere e pertanto condurrò dalla prossima settimana un corso che ha i medesimi contenuti, però metterò ancor di più in evidenza le nuove caratteristiche di interattività con nuove proposte di sperimentazione.

Nel caso foste interessati si solgeranno 4 incontri in webinar di 2 ore ciascuno per un totale di 8 ore di formazione

 Mercoledì 8 maggio 2019 – Ore 17.00/19.00
Mercoledì 15 maggio 2019 – Ore 17.00/19.00
Giovedì 30 maggio 2019 – Ore 17.00/19.00
Venerdì 31 maggio 2019 – Ore 17.00/19.00

Per i contenuti e per la la modalità di iscrizione vi rimando al sito di Tecnica della Scuola.

Articoli simili:

Pubblicato in corsi | Contrassegnato BBC micro:bit, coding, Lego Mindstorms EV3, Lego WeDo 2.0, MakeyMakey, pensiero computazionale, robotica, Scratch 3, Tecnica della Scuola | Lascia un commento

Arduino – Approfondimenti sulla modulazione di larghezza di impulso (PWM)

Pubblicato il Maggio 3, 2019 da admin

Scrivo questo post ad integrazione della lezione: Arduino – lezione 06: modulazione di larghezza di impulso (PWM) che sto utilizzando con i miei studenti di 4′ informatica per illustrare le modulazioni di tipo digitali. L’obiettivo è quello di mostrare sull’oscilloscopio come varia il Duty Cycle di un’onda quadra su un pin di tipo PWM di Arduino utilizzato per impostare l’intensità luminosa di un LED mediante una regolazione applicata attraverso un trimmer connesso al pin A0 di Arduino.

Oltre alla visualizzazione sull’oscilloscopio si desidera, come riscontro, la stampa sulla Serial Monitor dei seguenti valori:

Tensione in input sul pin A0
Valore restituito dalla funzione analogRead() – (tra 0 e 1023)
Valore restituito dall’analogWrite – (tra 0 e 254)
Valore percentuale del Duty Cycle (tra 0% e 100%)

Il circuito da realizzare con l’indicazione delle connessioni all’oscilloscopio è il seguente:

Sul canale X verrà visualizzata l’onda quadra in uscita dal pin 11 il cui Duty Cycle sarà regolato agendo sul trimmer.

Sul canale Y verrà visualizzata la tensione continua in input sul pin A0, che sarà convertita dal convertitore Analogico Digitale di Arduino in un valore compreso tra 0 e 1023 (risoluzione di 10 bit). Ricordo che tale conversione sarà fatta con l’istruzione analogRead(pin).

Poiché uno degli obiettivi è quello di visualizzare la tensione rilevata sul pin A0, ricordo che tale misurazione viene fatta utilizzando la funzione analogRead(pin) che legge il valore di tensione (compreso tra 0 e 5V) applicato sul piedino analogico ‘pin’ con una risoluzione di 10 bit e la converte in un valore numerico compreso tra 0 e 1023, corrispondente quindi ad un intervallo di 1024 valori, pertanto ogni intervallo corrisponde ad un valore di tensione Vu di:

Per sapere quindi il valore di tensione rilevato (nell’intervallo tra 0V e 5V) sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), valore quantizzato indicato con Vq compreso tra 0 e 1023:

Sapendo che Vu corrisponde a 4,88 mV

possiamo anche scrivere che:

Questa formula sarà inserita all’interno dello sketch.

Di seguito la schermata dell’oscilloscopio che visualizza la situazione indicata dai dati stampati sulla Serial Monitor:

Vmax(2) indica la tensione in ingresso ad A0 (la piccola discrepanza tra valore indicato sull’oscilloscopio e la stampa sulla Serial Monitor dipende dalle approssimazioni di calcolo).
Vmax(1) indica il valore di picco della tensione sul pin 11.

La spiegazione del funzionamento dello sketch sono dettagliate nei commenti:

/* Prof. Michele Maffucci
   03.06.2019
 
   Regolazione luminosità LED mediante
   trimmer, si utilizza la funzione map

   Stampa sulla seriale:
   - del valore di tensione sul pin A0
   - del valore restituito dall'analogRead
   - del valore restituito dall'analogWrite
   - del valore del Duty Cycle %
 
   Questo codice è di dominio pubblico 
*/

// pin analogico su cui inviare la tensione analogica (pin A0)
int misura = 0;

// pin a cui è connesso il LED
int pinLed = 11;

// variabile in cui conservare il valore inserito su A0
long val = 0;

// variabile in cui memorizzare il Duty Cycle
int inputVal = 0;

const long VoltRiferimento = 5.0; // valore di riferimento


void setup(){
  Serial.begin(9600);      // inizializzazione della comunicazione seriale
  pinMode(pinLed, OUTPUT); // definizione di ledPin come output
}

void loop(){
  // analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Qd
  val = analogRead(misura);

  // analogWrite() accetta come secondo parametro (PWM) valori tra 0 e 254
  // pertanto "rimappiamo" i valori letti da analogRead() nell'intervallo
  // tra 0 e 254 usando la funzione map
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Tu
  inputVal = map(val, 0, 1023, 0, 254);
  
  // accendiamo il LED con un valore del Duty Cycle pari a val
  analogWrite(pinLed,inputVal);

  // Tensione inviata sul pin analogico A0.
  // Valore in virgola mobile.

  float volt = (VoltRiferimento/1024.0)*val;

  // visualizzazione il valore della tensione su A0,
  // del valore restituito dalla analogRead,
  // del valore restituito dall'analogWrite
  // e del Duty Cycle %

  // per approfondimenti sull'uso di String si consulti il link: https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/
  
  Serial.println(String("Tensione su A0: ") + volt + "V" + String(";  ") + "analogRead: " + val + String(";  ") + String("Valore analogWrite: ") + inputVal + String("; ") + String("Duty Cycle %: ") + (inputVal/255.0)*100 + String("%;"));
  delay(500); // stampa una strina di valori ogni mezzo secondo
}

/* Prof. Michele Maffucci

03.06.2019

Regolazione luminosità LED mediante

trimmer, si utilizza la funzione map

Stampa sulla seriale:

- del valore di tensione sul pin A0

- del valore restituito dall'analogRead

- del valore restituito dall'analogWrite

- del valore del Duty Cycle %

Questo codice è di dominio pubblico

// pin analogico su cui inviare la tensione analogica (pin A0)

int misura = 0;

// pin a cui è connesso il LED

int pinLed = 11;

// variabile in cui conservare il valore inserito su A0

long val = 0;

// variabile in cui memorizzare il Duty Cycle

int inputVal = 0;

const long VoltRiferimento = 5.0; // valore di riferimento

void setup(){

Serial.begin(9600); // inizializzazione della comunicazione seriale

pinMode(pinLed, OUTPUT); // definizione di ledPin come output

}

void loop(){

// analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023

// per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Qd

val = analogRead(misura);

// analogWrite() accetta come secondo parametro (PWM) valori tra 0 e 254

// pertanto "rimappiamo" i valori letti da analogRead() nell'intervallo

// tra 0 e 254 usando la funzione map

// per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Tu

inputVal = map(val, 0, 1023, 0, 254);

// accendiamo il LED con un valore del Duty Cycle pari a val

analogWrite(pinLed,inputVal);

// Tensione inviata sul pin analogico A0.

// Valore in virgola mobile.

float volt = (VoltRiferimento/1024.0)*val;

// visualizzazione il valore della tensione su A0,

// del valore restituito dalla analogRead,

// del valore restituito dall'analogWrite

// e del Duty Cycle %

// per approfondimenti sull'uso di String si consulti il link: https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/

Serial.println(String("Tensione su A0: ") + volt + "V" + String("; ") + "analogRead: " + val + String("; ") + String("Valore analogWrite: ") + inputVal + String("; ") + String("Duty Cycle %: ") + (inputVal/255.0)*100 + String("%;"));

delay(500); // stampa una strina di valori ogni mezzo secondo

}

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato analogRead, analogWrite, arduino, duty cycle, oscilloscopio, pwm | 2 commenti

Coding a scuola con BBC micro:bit – inviamo messaggi via radio

Pubblicato il Maggio 2, 2019 da admin

Condivido una scheda didattica che ho utilizzato durante i miei corsi, è una variante alle sperimentazioni proposte sul sito ufficiale di micro:bit. Alla fine di questa lezione propongo una serie di attività di approfondimento suddivise per scuola elementare e scuola media e superiore. Per rendere più agevolo lo svolgimento della sperimentazione in classe, al fondo di questo tutorial condivido il file in formato PDF.

OBIETTIVO

Alla pressione del pulsante A inviare un messaggio di testo utilizzando la funzione radio di micro:bit

REQUISITI

Per lo svolgimento dell’attività è indispensabile avere almeno due micro:bit

Usare la funzione radio di micro:bit

Il micro:bit può funzionare come una radio, può inviare e ricevere messaggi attraverso un segnale radio
Una radio che può inviare e ricevere informazioni è chiamata ricetrasmettitore
Attraverso il segnale radio di micro:bit è possibile inviare testo, numeri o anche informazioni dai sensori collegati al micro:bit

Configurazione della trasmissione radio

Così come accade per una trasmissione radio che deve essere selezionata per ascoltarla, così anche con micro:bit bisogna selezionare una stazione, nel caso di micro:bit viene chiamato canale o gruppo, in questo modo due o più micro:bit “sintonizzandosi” sul medesimo gruppo potranno ricevere ed inviare messaggi sul gruppo.
L’impostazione del gruppo avviene selezionando un numero da 0 a 255, per fare un’analogia con la radio con cui ascolti la musica e come se ci fossero 255 stazioni radio su cui però non puoi solo ascoltare, ma anche inviare i tuoi messaggi.

IMPOSTAZIONE DEL micro:bit CHE INVIA IL MESSAGGIO

PASSO 1

Cancellare l’istruzione forever trascinarla sulla sezioni istruzioni oppure click con tasto destro sull’istruzione e successivamente “Delete Block”

PASSO 2

Dalla sezione Radio trascinare l’istruzione “radio set group 1“ all’interno dell’istruzione “on start“

PASSO 3

Il messaggio dovrà essere inviato quando viene premuto il pulsante A. Dalla sezione Input inserire nell’area di programmazione un’istruzione “on button A pressed“

PASSO 4

Dalla sezione Radio trascinare l’istruzione radio “ send string “ ” ” all’interno dell’istruzione “on button A pressed“

PASSO 5

All’interno dell’istruzione “radio send string “ ” ” all’interno delle virgolette, inserire il vostro messaggio, ad esempio: “Ciao”:

PASSO 6

Fate click su Download per trasferire il programma sul primo micro:bit

IMPOSTAZIONE DEL micro:bit CHE RICEVE IL MESSAGGIO

PASSO 7

Per visualizzare il messaggio ricevuto dalla sezione Radio trascinare l’istruzione
“on radio received receivedString“ nell’area di programmazione:

PASSO 8

Dalla sezione Basic selezionare le istruzioni “show string“ e trascinarla all’interno dell’istruzione on “radio received receivedString“

PASSO 9

Dalla sezione Variables trascinare la variabile “receivedString“ all’interno del campo di testo dell’istruzione “show string“

PASSO 10

Fate click su Download per trasferire il programma sul secondo micro:bit

PASSO 11

Provate a premere il pulsante A sul primo micro:bit, il messaggio “Ciao” comparirà sul secondo micro:bit

Esercizi per gli studenti di scuola elementare

Fate in modo che il primo micro:bit sia in grado di ricevere messaggi
Fate in modo che il secondo micro:bit sia in grado di inviare messaggi
Inviare messaggi diversi in funzione del pulsante premuto
Inviare e ricevere valori numerici invece di testo
(suggerimento: usare “radio send number“ e on “radioreceivedNumber“)

Esercizi per gli studenti di scuola media e superiore

Predisporre i due micro:bit un di fianco all’altro come indicato nella figura.
Quando viene premuto il pulsante B del micro:bit 1 compare sul suo display una freccia che scorre da sinistra verso destra puntando in direzione del micro:bit 2. Una volta che la freccia scompare dal display del micro:bit 1 comparirà scorrendo da sinistra verso destra sul display del micro:bit 2 e scorrendo uscirà dal display del micro:bit 2.
Allo stesso modo quando viene premuto il pulsante A del micro:bit 2 compare sul suo display una freccia che scorre da destra verso sinistra puntando in direzione del micro:bit 1. Una volta che la freccia scompare dal display del micro:bit 2 comparirà scorrendo da destra verso sinistra sul display del micro:bit 1 e scorrendo uscirà dal display del micro:bit 1.
Premendo il pulsante A sul display viene visualizzato il numero casuale e premendo il pulsante B il numero casuale viene inviato al secondo micro:bit
Quando su entrambi i micro:bit viene premuto un pulsante, su entrambi viene visualizzato un conto alla rovescia da 5 a 0 e successivamente viene visualizzata la stessa immagine su entrambi i micro:bit tra tre scelte possibili: carta, sasso o forbice

Per rendere più agevole l’utilizzo in classe, allego questa scheda di lavoro impaginata in formato PDF.

scheda di lavoro – inviamo messaggi via radio (PDF)

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in corsi, micro:bit | Contrassegnato coding, elementare, laboratorio, micro:bit, pensiero computazionale, radio, scheda, scuola media, scuola primaria, scuola superiore | Lascia un commento

M5Stack FIRE

Pubblicato il Aprile 30, 2019 da admin

Da qualche giorno utilizzo l’M5stack Fire development kit, si tratta di un un kit di prototipazione basato su un chip ESP32 che permette di realizzare in tempi rapidissimi, applicazioni IoT con la possibilità di utilizzare una serie di schede di espansione di diverso tipo, oppure potete costruirne di vostre. Le schede di espansione si aggiungono impilandole, al di sotto del cuore del kit (la parte in rosso nell’immagine) una sull’altra e sono tra esse vincolate con dei magneti.

Perché ho acquistato M5Stack? Ho la necessità di sviluppare un prototipo di un robot per un progetto didattico in tempi brevi, il progetto necessita di display touch con connessione WiFi, Bluetooth. Ho l’esigenza di costruire rapidamente un’interfaccia grafica su un display da cui gestire il comportamento del robot, inoltre ho bisogno di avere anche degli output sonori e luminosi, quindi leggendo le specifiche dell’M5stack e guardando alcuni video dimostrativi, ho pensato di sperimentarne l’uso. Ovviamente non nego la curiosità nell’utilizzare l’oggetto 🙂

M5Stack Fire è costituito da tre unità separabili. Nell’unità superiore è alloggia tutta l’elettronica principale, l’ESP32, l’antenna 2.4G, l’elettronica per la gestione dell’alimentazione, schermo LCD touch. La parte centrale è chiamata base M5GO, all’interno trova posto una batteria al litio, una presa M-BUS, due strisce LED RGB e altre due porte GROVE. La parte inferiore è adibita alla ricarica, può essere collegata alla base M5GO tramite pin POGO. All’interno dell’M5Stack si trova anche una IMU in grado di fornire la posizione nello spazio del dispositivo.
I moduli disponibili sono moltissimi ed un elenco completo può essere visto seguendo il link, si va dai moduli GSM, moduli PLC, LORA, telecamere e sensoristica di ogni genere, gestione motori, interfacce per Lego Mindstorms e molto altro.

Caratteristiche

5V DC power supply
USB Type-C
ESP32-based
16 MB Flash
4 MB PSRAM
MPU9250
Speaker, 3 Pulsanti, LCD(320*240), 1 Reset
2.4G Antenna: Proant 440
TF card slot (Dimensione massima 16G)
Battery Socket & 1Batteria Lipo da 50 mAh
Connessioni Pins & Holes per l’espansione
Grove Port
M-Bus Socket & Pins
Piattaforme di sviluppo UIFlow, MicroPython, Arduino

Caratteristice ESP32

240 MHz dual core Tensilica LX6 microcontroller con 600 DMIPS
Memoria integrata: 520 KB SRAM
Integrata sulla scheda: 802.11b/g/n HT40 Wi-Fi transceiver, baseband, stack e LWIP
Integrata sulla scheda: dual mode Bluetooth (classic and BLE)
Hall sensor
Interfaccia capacitiva touch 10x
32 kHz crystal oscillator
PWM/timer input/output available per ogni pin GPIO
SDIO master/salve 50MHz
Supporto SD-card

Per maggiori informazioni

Sito di riferimento: https://m5stack.com
da cui accedere alla documentazione, esempi di utilizzo ed accesso all’interfaccia di programmazione a blocchi.
Caratteristiche tecniche dettagliate seguendo il link.
Canale YouTube da cui potete vedere diverse sperimentazioni

Ho acquistato M5Stack FIRE su Amazon, ma trovate il dispositivo e schede di espansione anche su diversi store cinesi (sul sito di riferimento trovate tutti i link).

Nel breve pubblicherò alcuni risultati sulle sperimentazioni condotte con M5Stack FIRE.

Buon making a tutti 🙂

Articoli simili:

Pubblicato in elettronica | Contrassegnato development kit, ESP32, iot, M5Stack | Lascia un commento

Appunti di programmazione su Arduino: Rispondere ad un telecomando ad infrarossi

Pubblicato il Aprile 28, 2019 da admin

In preparazione delle prossime lezioni con i miei studenti condivido la traccia dell’attività di laboratorio in cui mostro come con Arduino è possibile comandare i dispositivi collegati al microcontrollore utilizzando un telecomando ad infrarossi.

La comunicazione ad infrarossi (IR) è una tecnologia wireless ampiamente utilizzata e facilmente realizzabile. Tra gli impieghi più noti: telecomandi TV, termometri ad infrarossi, sensori di movimento (PIR) utilizzati ad esempio per gli antifurti.

Utilizzando Arduino si potrebbero realizzare sperimentazioni che utilizzano la comunicazione IR per realizzare telecomandi per il controllo di robot, telecomandi per TV o fotocamere DSLR, oppure sistemi per monitorare la frequenza cardiaca o realizzare sensori di distanza.

In questa lezione spiegherò, spero in maniera in maniera accessibile a studenti ed appassionati di elettronica cosa sono gli infrarossi e come funzionano e successivamente mostrerò come utilizzare qualsiasi telecomando IR e comandare qualsiasi dispositivo connesso ad Arduino.

Cosa sono gli infrarossi

La radiazione infrarossa è una forma di luce simile alla luce che vediamo intorno a noi, la differenza tra la luce visibile la la radiazione IR risiede nella frequenza e nella lunghezza d’onda. La radiazione infrarossa si trova al di fuori della gamma di luce visibile, quindi gli esserti umani non possono vederla.

Lo spettro elettromagnetico

Di Annuale. Original version in English by Inductiveload – Translation from English version, Pubblico dominio, Collegamento

Luce visibile

Di Teolindo04 – Opera propria, CC0, Collegamento

La comunicazione IR richiede che tra trasmettitore e ricevitore non vi siano ostacoli, si devono trovare in condizione di visibilità reciproca, non sarà quindi possibile trasmettere attraverso ostacoli, come i muri, come invece risulta possibile per la comunicazione WiFi o Bluetooth.

Come funzionano i trasmettitori ed i ricevitori IR

Un tipico sistema di comunicazione ad infrarossi richiede un trasmettitore IR e un ricevitore IR. Il trasmettitore è contenuto molto spesso in un contenitore simile a quello di un LED standard, con la differenza che produce una redazione elettromagnetica nel campo IR invece che nello spettro visibile.

Se guardate la parte anteriore di un telecomando del TV noterete il LED del trasmettitore IR:

Modulazione di un segnale IR

La radiazione elettromagnetica IR viene emessa da molte fonti: dal sole, dalle lampadine e da qualsiasi altra fonte di calore, ciò implica che queste fonti possono disturbare la comunicazione tra i nostri dispositivi IR comportandosi come dei veri e propri segnali di rumore. Per evitare che il rumore IR interferisca con il segnale IR dei nostri dispositivi, viene utilizzata una tecnica che prende il nome di modulazione.

Se prendiamo in considerazione il telecomando di un TV, quando premiamo uno dei pulsanti verrà emesso, tramite il LED IR, una sequenza di accensioni e spegnimenti del LED IR a frequenza fissata (tipica è la frequenza di 38 kHz) secondo uno schema specifico per ogni pulsante premuto.
Ad ogni pulsante è associato uno schema (detti pattern) specifico di 0 ed 1. Ad ogni stato logico è associata la frequenza di 0 Hz nel caso si voglia inviare uno 0 logico ed una frequenza di 38 kHz nel caso si voglia inviare un 1 logico. Gli schemi sono in genere costituiti da sequenze 12 o 32 bit.

Esistono diverse tecniche per ridurre la quantità di errori derivanti dal rumore esterno (soprattutto dalla luce solare), una di queste prevede che alla pressione di uno dei tasti del telecomando un oscillatore interno al trasmettitore fa “lampeggiare” il LED IR ad una frequenza f_a per il livello logico 0 e ad una frequenza f_b per un valore logico 1.

Il ricevitore prenderà in considerazione solo le sequenze di segnali alle frequenze f_a e f_b associate ai valori 1 e 0 e scarterà tutte le altre frequenze che potrebbero essere derivanti da rumore IR esterno.

Sintesi schema di trasmissione e ricezione

Il trasmettitore invierà la sequenza di o e 1 ad un decoder che riconoscerà la sequenza corretta.

La modalità in cui il segnale IR modulato viene convertito in binario è definito dal protocollo di trasmissione. Esistono diversi protocolli di trasmissione IR definiti dalle aziende produttrici: NEC, Sony, Matsushita, NEC, RC5 sono tra i protocolli più comuni.

Nel caso del protocollo NEC il ricevitore converte il segnale IR modulato in un segnale binario, usando la seguente regola:

il livello logico 0 viene trasmesso con un impulso IR a livello ALTO lungo 562.5 μs seguito da un impulso IR BASSO lungo 562.5 μs. Un livello logico 1 inizia con un impulso IR a livello ALTO lungo 562,5 μs ad una frequenza di 38 kHz seguito da un impulso IR a livello BASSO lungo 1.687,5 μs.

Ogni volta che si preme un pulsante sul telecomando, viene generato un codice esadecimale univoco, questo sarà il codice che viene modulato ed inviato tramite il segnale IR al ricevitore. Per decifrare quale pulsante è stato premuto sul telecomando bisognerà fare in modo che il microcontrollore sappia quale codice corrisponde a ciascun tasto sul telecomando.

Tenete in conto che ciascun telecomando, anche di stessa marca, invia codici esadecimali diversi anche per stessa funzionalità del pulsante, quindi per i vostri progetti dovrete determinare, prima di procedere nelle sperimentazioni, il codice generato per ciascun tasto sul vostro telecomando.

Le schede tecniche dei telecomandi forniscono i codici esadecimali corrispondenti ad ogni tasto, nel caso non riusciate a trovare la scheda tecnica, in questo tutorial mostro come, con un semplice sketch, è possibile trovare immediatamente i codici associati ad ogni pulsante.

Prima di partire con le sperimentazioni

Durante le attività di sperimentazioni potrete utilizzare il telecomando del vostro TV, nel caso desiderate utilizzare telecomandi IR provenienti da apparati che non possedete più probabilmente potrebbe essere il caso verificarne il funzionamento.

Premesso che abbiate controllato la carica delle batterie del telecomando, un modo pratico per verificare il funzionamento del telecomando consiste nell’utilizzare una qualsiasi macchina fotografica digitale, anche quella del vostro smartphone, dispositivi in grado di visualizzare le frequenze IR.

Passo 1: spegnete l’illuminazione della stanza (per ridurre il rumore IR)
Passo 2: puntata il telecomando verso l’obiettivo
Passo 3: premete un qualsiasi pulsante ed osservate lo schermo della fotocamera, dovreste notare una luce tendente al blu, ciò identifica il funzionamento della trasmissione del segnale

Connettere il ricevitore IR ad Arduino

I ricevitori IR più comuni sono: TSOP4838, PNA4602, TSOP2438, TSPO2236

Tutti questi dispositivi presentano gli stessi collegamenti ed il circuito di collegamento ad Arduino è il medesimo, tranne che per il TSOP2438 in cui i piedini +5V e GND sono invertiti rispetto agli altri componenti elencati.

Per questo esercizio utilizzerò un ricevitore IR TSOP2236 – con demodulazione a 36 KHz.

Per poter utilizzare un ricevitore IR è indispensabile includere all’interno degli sketch la libreria IRremote.h che permette la gestione della trasmissione e la ricezione di segnali infrarossi.

Per i dettagli sull’uso della libreria vi rimando:

Nel caso abbiate problemi di utilizzo della libreria IRremote.h vi consiglio la lettura dell’articolo pubblicato su questo sito:

Arduino: problemi con la libreria IRremote.h – come risolverli

Ricordo che per l’invio dei segnali la libreria IRremote.h utilizza la modulazione PWM ed un timer specifico che utilizzando il pin numero 3. Nel caso abbiate la necessità di variare il pin è indispensabile modificare la libreria. Parlerò di ciò in una prossima lezione.

La spiegazione del funzionamento dei metodi utilizzati fate riferimento ai commenti inclusi nel codice.

Per l’esatto orientamento del TSOP2236 mantenere la protuberanza di fronte a se, in tal modo partendo da sinistra verso destra, come indicato nell’immagine che segue si avrà:

segnale (a sinistra)
+Vcc (centrale)
GND (a destra)

Esercizio 1

Realizzare uno sketch che permetta di far accendere e spegnere il led di controllo (collegato al pin 13) di Arduino ogni volta che si preme un pulsante del telecomando.

// Prof. Michele Maffucci
// 28.04.2019

// Il LED sul pin 13 si accende o si spegne ogni volta che viene
// un pulsante del telecomando

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore
const int ledPin = 13;                     // LED connesso al pin 13

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

boolean lightState = false;                // ricorda se il LED e' acceso
unsigned long last = millis();             // ricorda quando e' stato ricevuto
                                           // l'ultima volta un segnale IR

void setup() {
    pinMode(ledPin, OUTPUT);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
  if (irrecv.decode(&risultato) == true) // vero se si e' ricevuto un messaggio
  {
    if (millis() - last > 250) {             // e' passato 1/4 di secondo dopo l'ultimo messaggio
      lightState = !lightState;              // se vero si cambia lo stato del LED
      digitalWrite(ledPin, lightState);
    }
    last = millis();
    irrecv.resume();                         // presta attenzione ad un altro messaggio
  }
}

// Prof. Michele Maffucci

// 28.04.2019

// Il LED sul pin 13 si accende o si spegne ogni volta che viene

// un pulsante del telecomando

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236

// pin 1 (sx): pin Arduino

// pin 2 (centrale): +Vcc

// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4; // pin a cui collegato il ricevitore

const int ledPin = 13; // LED connesso al pin 13

IRrecv irrecv(pinRicevitoreIR); // pin a cui collegato il ricevitore

decode_results risultato; // salva il risultato ricevuto dal rilevatore IR

boolean lightState = false; // ricorda se il LED e' acceso

unsigned long last = millis(); // ricorda quando e' stato ricevuto

// l'ultima volta un segnale IR

void setup() {

pinMode(ledPin, OUTPUT);

irrecv.enableIRIn(); // Attiva l'oggetto del ricevitore

}

void loop() {

if (irrecv.decode(&risultato) == true) // vero se si e' ricevuto un messaggio

{

if (millis() - last > 250) { // e' passato 1/4 di secondo dopo l'ultimo messaggio

lightState = !lightState; // se vero si cambia lo stato del LED

digitalWrite(ledPin, lightState);

}

last = millis();

irrecv.resume(); // presta attenzione ad un altro messaggio

}

Esercizio 2

Realizzare uno sketch che decodifica i segnali di un telecomando in modo che si possa realizzare un sistema di automazione comandato con i pulsanti del telecomando.
Per i collegamenti utilizzare lo schema dell’esercizio 01.

// Prof. Michele Maffucci
// 28.04.2019

// lettura codici esadecimali di un telecomando IR generico
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
    if (irrecv.decode(&risultato)) {           // vero se si riceve un risultato
        Serial.print("0x");                    // stampa 0x che identifica un codice esadecimale
        Serial.println(risultato.value, HEX);  // stampa il valore esadecimale
        delay(50);                             // attesa di 50 millisecondi
        irrecv.resume();                       // ricezione del successivo valore
    }
}

// Prof. Michele Maffucci

// 28.04.2019

// lettura codici esadecimali di un telecomando IR generico

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236

// pin 1 (sx): pin Arduino

// pin 2 (centrale): +Vcc

// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4; // pin a cui collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR); // pin a cui collegato il ricevitore

decode_results risultato; // salva il risultato ricevuto dal rilevatore IR

void setup() {

Serial.begin(9600);

irrecv.enableIRIn(); // Attiva l'oggetto del ricevitore

}

void loop() {

if (irrecv.decode(&risultato)) { // vero se si riceve un risultato

Serial.print("0x"); // stampa 0x che identifica un codice esadecimale

Serial.println(risultato.value, HEX); // stampa il valore esadecimale

delay(50); // attesa di 50 millisecondi

irrecv.resume(); // ricezione del successivo valore

}

Esercizio 3

Sfruttando lo sketch degli esercizi 1 e 2 identificare il codice di 5 pulsanti ed inviare sulla Serial Monitor i seguenti messaggi alla pressione dei pulsanti:

CODICE 1: Centrale
CODICE 2: Destro
CODICE 3: Sinistro
CODICE 4: Su
CODICE 5: Giù

Suggerimento
Utilizzare l’istruzione switch per discriminare tra la pressione dei diversi pulsanti

// Prof. Michele Maffucci
// 28.04.2019

// associazione codice invio messaggio sulla Serial Monitor
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

// N.B. nell'esempio sono stati inseriti nei rispettivi case i codici
// esadecimali utilizzati per il telecomando utilizzato
// sostituite questi valori a quelli che rilevate con lo sketch per la rilevazione
// dei codici esadecimali di qualsiasi telecomando  


#include <IRremote.h>

int pinRicevitoreIR = 4;                   // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
    if (irrecv.decode(&risultato)) {       // vero se si riceve un risultato
        
        switch (risultato.value) {         // in funzione di uno dei 4 pulsanti premuti invia messaggio sulla Serial Monitor
            case 0x77E1A086:
            Serial.println("Centrale");
            break;
            
            case 0x77E16086:
            Serial.println("Destro");
            break;
            
            case 0x77E19086:
            Serial.println("Sinistro");
            break;
            
            case 0x77E15086:
            Serial.println("Su'");
            break;
            
            case 0x77E13086:
            Serial.println("Giu'");
            break;
        } 
        irrecv.resume();                  // ricezione del successivo valore
    }
}

// Prof. Michele Maffucci

// 28.04.2019

// associazione codice invio messaggio sulla Serial Monitor

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236

// pin 1 (sx): pin Arduino

// pin 2 (centrale): +Vcc

// pin 3 (dx): GND

// N.B. nell'esempio sono stati inseriti nei rispettivi case i codici

// esadecimali utilizzati per il telecomando utilizzato

// sostituite questi valori a quelli che rilevate con lo sketch per la rilevazione

// dei codici esadecimali di qualsiasi telecomando

#include <IRremote.h>

int pinRicevitoreIR = 4; // pin a cui collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR); // pin a cui collegato il ricevitore

decode_results risultato; // salva il risultato ricevuto dal rilevatore IR

void setup() {

Serial.begin(9600);

irrecv.enableIRIn(); // Attiva l'oggetto del ricevitore

}

void loop() {

if (irrecv.decode(&risultato)) { // vero se si riceve un risultato

switch (risultato.value) { // in funzione di uno dei 4 pulsanti premuti invia messaggio sulla Serial Monitor

case 0x77E1A086:

Serial.println("Centrale");

break;

case 0x77E16086:

Serial.println("Destro");

break;

case 0x77E19086:

Serial.println("Sinistro");

break;

case 0x77E15086:

Serial.println("Su'");

break;

case 0x77E13086:

Serial.println("Giu'");

break;

}

irrecv.resume(); // ricezione del successivo valore

}

Esercizio 4

Accensione e spegnimento di un LED collegato al pin 8 con un solo pulsante di un telecomando. Visualizzare sulla Serial Monitor un messaggio che indica la pressione del pulsante.

Componenti

TSOP2236
LED
Resistenza da 220 Ohm

Nota
Tra pressione e successiva lettura della pressione di un pulsante lasciare trascorrere un tempo di 200 ms

// Prof. Michele Maffucci
// 28.04.2019

// accensione spegnimento di un LED con un telecomando IR generico
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

// N.B. nell'esempio è stato utilizzato come valore di controllo memorizzato in risultato.value
// il codice esadecimali del pulsante utilizzato per il telecomando usato come test
// sostituite questo valore con il pulsante del vostro telecomando

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

int ledPin = 8;                            // pin a cui  collegato il LED
int stato = 0;                             // se stato= 0 ledPin off - se stato = 1 ledPin on

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
    pinMode(ledPin, OUTPUT);
}
 
void loop() {
    if ((irrecv.decode(&risultato)) && (risultato.value==0x77E1A086)) {
        if (stato == 0) {
            stato = 1;
            digitalWrite(ledPin, HIGH); 
            Serial.println("Centro - HIGH");
            } else {
            stato = 0;
            digitalWrite(ledPin, LOW);
            Serial.println("Centro - LOW");
        }
        delay(200);
        irrecv.resume();
    }
}

// Prof. Michele Maffucci

// 28.04.2019

// accensione spegnimento di un LED con un telecomando IR generico

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236

// pin 1 (sx): pin Arduino

// pin 2 (centrale): +Vcc

// pin 3 (dx): GND

// N.B. nell'esempio è stato utilizzato come valore di controllo memorizzato in risultato.value

// il codice esadecimali del pulsante utilizzato per il telecomando usato come test

// sostituite questo valore con il pulsante del vostro telecomando

#include <IRremote.h>

const int pinRicevitoreIR = 4; // pin a cui collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR); // pin a cui collegato il ricevitore

decode_results risultato; // salva il risultato ricevuto dal rilevatore IR

int ledPin = 8; // pin a cui collegato il LED

int stato = 0; // se stato= 0 ledPin off - se stato = 1 ledPin on

void setup() {

Serial.begin(9600);

irrecv.enableIRIn(); // Attiva l'oggetto del ricevitore

pinMode(ledPin, OUTPUT);

}

void loop() {

if ((irrecv.decode(&risultato)) && (risultato.value==0x77E1A086)) {

if (stato == 0) {

stato = 1;

digitalWrite(ledPin, HIGH);

Serial.println("Centro - HIGH");

} else {

stato = 0;

digitalWrite(ledPin, LOW);

Serial.println("Centro - LOW");

}

delay(200);

irrecv.resume();

}

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato infrared, infrarosso, ir, IRremote.h, telecomando | 2 commenti

ROB-O-COD – Linguaggi di programmazione alternativi per LEGO MINDSTORMS EV3

Pubblicato il Aprile 26, 2019 da admin

Durante le attività di prove e registrazione della trasmissione ROB-O-COD negli studi televisivi di Rai Gulp ho portato con me la mio essere insegnante 🙂
Come sicuramente saprete il software di Lego di programmazione è un ottimo strumento, adatto per tutti gli studenti che incominciano a programmare, ma il confronto con gli allievi mi ha portato a consigliare la sperimentazione di altri linguaggi di programmazione da utilizzare con l’EV3. Ho ritenuto il caso di realizzare un post in cui segnalare alcune soluzioni, che vanno ad integrasi alle risorse già segnalate in un precedente articolo di qualche anno fa.

MakeCode
Microsoft MakeCode è una piattaforma di programmazione online in grado di programmare l’EV3 e altri dispositivi elettronici, come ad esempio BBC micro:bit. MakeCode utilizza i blocchi grafici simili a quelli utilizzati in Scratch oppure la programmazione JavaScript.

Scratch
Scratch è sicuramente tra i linguaggi di programmazione a livello didattico più conosciuti. Nell’ultima versione, Scratch 3, l’utilizzo dell’EV3 è pienamente integrato e supportato, trovate ulteriori informazione su questo sito. Per maggiori informazioni seguire anche il link: https://scratch.mit.edu/ev3. Poiché so che molti colleghi di scuola elementare utilizzano Lego WeDo e desiderano sperimentare attività di gara simili a quelle proposte in ROB-O-COD, vi rimando per maggiori informazioni alla pagina specifica di Scratch per l’uso di WeDo 2.0 https://scratch.mit.edu/wedo

Python for EV3 (segnalazione di Gianluca Cannalire)
Programmare in Python su EV3 non è stato mai così semplice! Dal sito ufficiale Lego sarà sufficiente prelevare ed installare l’immagine MicroPython per EV3 su qualsiasi scheda micro SD, al riavvio del vostro Brick EV3 potrete immediatamente incominciare a programmare. Sul sito Lego documentazione completa con esempi.

LeJOS
LeJOS (che si pronuncia come la parola spagnola “lejos” che tradotta in italiano è “lontano”) è una Java Virtual Machine che supporta Java. Con LeJOS potrete programmare EV3, NXT e RCX.

Bricx Command Center 3.3 (segnalazione di Maurizio Pelizzone)
Bricx Command Center (BricxCC) è un IDE di programmazione open source, che permette la scrittura del programma, la compilazione e il trasferimento sul robot. L’IDE è gratuito e funziona su sistemi operativi Windows. BricxCC consente la scrittura in diversi linguaggi di programmazione tra i più noti l’NXC molto simile al C.

OpenRoberta
Open Roberta è un linguaggio di programmazione gratuito, cloud-based (quindi non avrete necessità di installare nulla sul vostro computer), funziona trascinando in un’apposita area di programmazione dei blocchi funzionali (ricorda un po’ Scratch) e potrete programmare robot LEGO EV3 e NXT.

RobotC
RobotC è un linguaggio di programmazione basato su C con un debugger software completamente integrato che supporta una vasta gamma di piattaforme hardware, potete utilizzarlo per Lego EV3, NXT, RCX. Sul sito di riferimento trovate moltissima documentazione.

Swift Playground
Swift Playgrounds è un ambiente di sviluppo integrato solo per iPad progettato esclusivamente per imparare a programmare con il linguaggio di programmazione Swift. In Swift Playground, potrete programmare il vostro robot, raccogliere informazioni da sensori e azionare motori. Per gli insegnanti che volessero utilizzare questo linguaggio di programmazione ed avere delle sperimentazioni da far svolgere agli studenti vi consiglio il libro gratuito: LEGO MINDSTORMS EV3 Animal Rescue Teacher’s Guide

EV3Python
EV3Python per tutti gli utenti che hanno dimestichezza con la programmazione in Python questa è una validissima soluzione per controllare vostro robot Lego Mindstorms EV3. Avrete necessità di utilizzare Microsoft Visual Studio Code

EV3 Basic
EV3 Basic è un linguaggio di programmazione testuale gratuito che non richiede nessuna modifica del firmware Lego brick o dell’installazione di uno specifico sistema operativo da installare sul brick. Utilizza Microsoft Small Basic. EV3 Basic è compatibile con tutti i motori e sensori EV3 e NXT e dispositivi bluetooth e Wifi Lego compatibili. Small Basic è disponibile in 17 lingue e l’estensione EV3 è disponibile in inglese, tedesco, spagnolo e francese.

EV3dev
EV3dev non è un linguaggio di programmazione, ma un sistema operativo basato su Linux Debian in grado di eseguire programmi realizzati con moltissimi linguaggi di programmazione inclusi C ++, Node.js e Python. Sul sito di riferimento trovate moltissime guide.

CoderZ
CoderZ ambiente di simulazione 3D per robot EV3. La programmazione può essere fatta con Blockly o Java. CoderZ è un prodotto commerciale e viene offerta la possibilità di utilizzarlo in prova per 14 giorni.

LabVIEW
LabVIEW per LEGO MINDSTORMS (LVLM) e LabVIEW for Education (LV4E) sono ambienti di programmazione visuali. Il software di programmazione grafica standard di di Lego è stato realizzato usando LabVIEW, quindi LVLM rappresenta forse il passo successivo, soprattutto se state operando con studenti dei primi anni delle superiori. Troverete un’ambiente di sviluppo estremamente potente e versatile.

Per maggiori informazioni:

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in i miei allievi | Contrassegnato coding, ev3, game show, kids, lego, micro:bit, mindstorms, programmazione, rai, rai gul, rai gulp, rai ragazzi, rai tagazzi, rob-o-cod, ROBOCOD, robot, robotica, rob_o_cod, teens | Lascia un commento

ROB-O-COD un evento da replicare a scuola – lo racconterò a Fossano (Cn) il 6 giugno prossimo

Pubblicato il Aprile 25, 2019 da admin

Come ebbi modo di scrivere qualche tempo fa su Facebook, pur essendo docente di scuola superiore ho avuto la fortuna di insegnare a studenti e insegnanti di ogni ordine di scuola. Ogni nuova attività di formazione mi offre la possibilità di sperimentare tecnologie e modalità di comunicazione che poi se efficaci assemblo per costruire gli strumenti per le future lezioni.

Credo che uno dei momenti più ricchi per la mia formazione sia stata quella derivante dalle attività di laboratorio con gli studenti di scuola elementare, la loro creatività, il loro stupirsi ed il loro punto di vista richiede una progettazione completamente diversa da quella con allievi di scuola superiore.

In questi mesi sto dedicando alcune ore pomeridiane alla formazione di studenti di 4 elementare, gli obiettivi sono quelli che amo di più: Coding e Robotica.

Gli strumenti che utilizziamo sono molti: carta, matite, BBC micro:bit, Lego WeDo e anche Lego Mindstorms EV3 e proprio su quest’ultima tecnologia, anche se non ne era stato programmato l’utilizzo, ho avuto forte richiesta da parte degli studenti da quando, per aumentare il loro interesse nelle attività proposte, ho dato notizia della trasmissione ROB-O-COD:

“MICHELE anche noi vogliamo partecipare!
Costruiamo i campi, con il cartone e facciamo noi i mondi e ci insegni!”

Ora come rispondere a questa necessità?
Ai bambini bisogna rispondere! 🙂

La trasmissione ha un traget per ragazzi di scuola media con l’uso di tecnologie non proprio adatte ai più piccoli delle scuole elementari…

pensare pensare e ripensare…

Di seguito vi condivido una primissima bozza di attività da perfezionare, per velocità di scrittura inserisco direttamente quanto scritto nei miei appunti su Evernote spero che queste idee possano servire anche ad altri:

Bozza di progetto:

vediamo la prima puntata di ROB-O-COD in classe, al termine ne faccio nascere un confronto tra gli allievi per immaginare attività di gara e modalità di costruzione campi e robot.
I campi gara avranno una forma geometrica particolare (nota per il lettore: non ne posso parlare in questo post per non svelare troppe cose ma potreste intuire la forma dei tavoli dalla grafica della trasmissione 😉 ).
Spiego come costruire su carta questa specifica forma geometrica.
Con le dimensioni reali usate per realizzare i campi gara in trasmissione, replichiamo la forma con dello nastro di carta posto sul pavimento dell’aula, all’interno del perimetro dovranno gareggiare i robot programmati dai bambini.
Le dinamiche di gioco saranno molto simili a quelle della trasmissione: presenza di un pubblico, di tecno-disturbatori che dovranno creare difficoltà alla movimentazione dei robot, ecc…
Tecnologia dei robot: primo girone realizzazione di robot basati su BBC micro:bit la cui struttura sarà di cartone, secondo girone robot realizzati con Lego WeDo. I primi classificati potranno utilizzare il Lego Mindstorms EV3 messo a disposizione del Prof. (Io) per realizzare una gara su un singolo campo di gioco.
Scrivere le storie. Le storie potranno essere realizzate prendendo spunto da quanto proposto di giorno in giorno nella trasmissione oppure inventate dagli studenti (valutare attività da far svolgere durante le attività al mattino).
Come realizzare la scenografia? Scatole di cartone, bottiglie e bicchieri di plastica, mattoncini Lego.

Cercherò nelle prossime settimane condividere una versione aggiornata dell’attività. L’intero percorso sarà presentato ad un gruppo di insegnanti durante l’evento di Coding e Robotica per scuole medie organizzato dall’IIS Vallauri di Fossano il prossimo 6 giugno.

e ricordare: #ROB_O_COD è tutto un programma!

🙂

Articoli simili:

Pubblicato in programmazione, robotica | Contrassegnato coding, game show, kids, lego, micro:bit, mindstorms, programmazione, rai gulp, rai ragazzi, ROBOCOD, robot, robotica, rob_o_cod, teens, WeDo | Lascia un commento

Appunti di programmazione su Arduino: esercizi di approfondimento su istruzione switch..case, display a 7 segmenti, Serial.read

Pubblicato il Aprile 24, 2019 da admin

Durante le scorse settimane ho svolto una serie di esercitazioni di laboratorio che avevano l’obiettivo di insegnare l’uso dell’istruzione switch…case e la modalità di ricezione dati seriali in Arduino.

La prima lezione è introdotta nel post:

Appunti di programmazione su Arduino: controllo di flusso – istruzione switch..case

Nell’articolo trovate due link che fanno riferimento a due guide sul sito Arduino in cui viene mostrato come utilizzando l’istruzione switch…case:

per inviare un output specifico sulla Serial monitor in funzione del valore letto dal sensore;
usare la Serial input per accendere uno specifico LED.

La seconda lezione è basata sul tutorial:

Arduino – lezione 08: display a 7 segmenti e creazione di librerie

In cui viene mostrato come pilotare un display a 7 segmenti realizzando un contatore da 0 a 9, e cicli di visualizzazione di numeri pari e numeri dispari. Nella parte finale del tutorial viene mostrato come realizzare una libreria dedicata alla gestione del display a 7 segmenti.

La terza lezione mostra come ricevere dati dalla seriale in Arduino.

Per questa parte è indispensabile svolgere le esercitazioni che trovate nelle slide:

Alfabeto di Arduino – Lezione 3 da pagina 53 a pagina 62

Successivamente aggiungo gli esercizi che di seguito condivido, in cui riprendendo la gestione del display a 7 segmenti, però questa volta inviamo dati dal computer mediante la tastiera al display comandato da Arduino.

Per lo svolgimento di questa parte è necessario effettuare una piccola variazione rispetto al circuito mostrato in: Arduino – lezione 08: display a 7 segmenti e creazione di librerie in questa lezione volutamente utilizzo tra tutti i pin il piedino 1 di Arduino che viene utilizzato normalmente come pin TX e ciò provoca un comportamento anomalo di accensione del LED e del display, ciò mi permette di spiegare l’utilizzo dei pin 0 e 1 di Arduino.

Il circuito da realizzare per la terza lezione è il seguente (i pin di controllo di Arduino sono presi in maniera sequenziale dal pin 6 al pin 12)

Esercitazione 1

Realizzare un contasecondi da 0 a 9 utilizzando un display 7 segmenti a catodo comune

Soluzione

// Prof. Michele Maffucci
// 14.04.2019

// Conteggio 9 secondi con display 7 segmenti a catodo comune

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a=12;
const int b=11;
const int c=10;
const int d=9;
const int e=8;                           
const int f=7;
const int g=6;

// variabile che definisce la velocità con cui appaiono i numeri
const int pausa = 1000;

void setup()
{
  // inizializzazione dei pin ad OUTPUT
  for (int i=6; i<13; i++) {
    pinMode(i, OUTPUT); 
  }
}

void loop ()
{
  for (int i=0;i<10;i++) 
  {
    LedAcceso(i);
    delay (pausa);
  }
}

void LedAcceso(int n)
{
  switch(n)
  {
  case 0:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, LOW);
    break;

  case 1:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 2:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, LOW); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;
  case 3:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;

  case 4:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 5:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 6:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 7:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 8:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 9:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

// Prof. Michele Maffucci

// 14.04.2019

// Conteggio 9 secondi con display 7 segmenti a catodo comune

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a=12;

const int b=11;

const int c=10;

const int d=9;

const int e=8;

const int f=7;

const int g=6;

// variabile che definisce la velocità con cui appaiono i numeri

const int pausa = 1000;

void setup()

{

// inizializzazione dei pin ad OUTPUT

for (int i=6; i<13; i++) {

pinMode(i, OUTPUT);

}

void loop ()

{

for (int i=0;i<10;i++)

{

LedAcceso(i);

delay (pausa);

}

void LedAcceso(int n)

{

switch(n)

{

case 0:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case 1:

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case 2:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case 3:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case 4:

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 5:

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 6:

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 7:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case 8:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 9:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 2

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviene quando si preme invio.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;
      
    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviene quando si preme invio.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 3

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f 

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 4

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      digitalWrite(a, LOW);
      digitalWrite(b, LOW);
      digitalWrite(c, LOW);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

digitalWrite(a, LOW);

digitalWrite(b, LOW);

digitalWrite(c, LOW);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

roll();

}

Esercitazione 5

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display.
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  // spegnimento di tutti i led del display
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    digitalWrite(a, HIGH);
    delay(intervallo);
    digitalWrite(a, LOW);
    delay(intervallo);
    digitalWrite(b, HIGH);
    delay(intervallo);
    digitalWrite(b, LOW);
    delay(intervallo);
    digitalWrite(c, HIGH);
    delay(intervallo);
    digitalWrite(c, LOW);
    delay(intervallo);
    digitalWrite(d, HIGH);
    delay(intervallo);
    digitalWrite(d, LOW);
    delay(intervallo);
    digitalWrite(e, HIGH);
    delay(intervallo);
    digitalWrite(e, LOW);
    delay(intervallo);
    digitalWrite(f, HIGH);
    delay(intervallo);
    digitalWrite(f, LOW);
    delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

// spegnimento di tutti i led del display

digitalWrite(a, LOW);

digitalWrite(b, LOW);

digitalWrite(c, LOW);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

Esercitazione 6

Realizzare le stesse funzionalità dell’esercizio 5 ma ottimizzare la funzione roll() in modo che lo spegnimento iniziale dei LED sia costituito da un ciclo for e l’accensione e lo spegnimento sequenziale sia realizzato da due cicli for annidati.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione in cui la funzione roll() è stata ottimizzata
// Lo spegnimento iniziale dei LED è costituito da un ciclo for e l'accensione e lo spegnimento sequenziale
// è realizzato da due cicli for annidati.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int m = 0; m < 6; m++) {
    for (int p = 12; p > 6; p--) {
      digitalWrite(p, HIGH);
      delay(intervallo);
      digitalWrite(p, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione in cui la funzione roll() è stata ottimizzata

// Lo spegnimento iniziale dei LED è costituito da un ciclo for e l'accensione e lo spegnimento sequenziale

// è realizzato da due cicli for annidati.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

// funzione per gioco di luci

void roll() {

// spegnimento di tutti i led del display

for (int i = 6; i < 13; i++) {

digitalWrite(i, LOW);

}

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int m = 0; m < 6; m++) {

for (int p = 12; p > 6; p--) {

digitalWrite(p, HIGH);

delay(intervallo);

digitalWrite(p, LOW);

delay(intervallo);

}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display

// prima che venga stampato il numero viene eseguita la funzione roll()

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

Esercitazione 7

Realizzare le stesse funzionalità dell’esercizio 6 realizzando una libreria di gestione “LedAcceso.h” richiamata dallo sketch principale. Per l’esecuzione di questo esercizio seguire le indicazioni fornite al fondo del tutorial: Arduino – lezione 08: display a 7 segmenti e creazione di librerie

Soluzione

LedAcceso.cpp

/* display_sette_segmenti.cpp
libreria che consente il controllo di un display a 7 segmenti a catodo comune
del tipo HDSP 5503
*/

#include "Arduino.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    for (int j = 12; j > 6; j--) {
      digitalWrite(j, HIGH);
      delay(intervallo);
      digitalWrite(j, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

/* display_sette_segmenti.cpp

libreria che consente il controllo di un display a 7 segmenti a catodo comune

del tipo HDSP 5503

#include "Arduino.h"

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

// funzione per gioco di luci

void roll() {

// spegnimento di tutti i led del display

for (int i = 6; i < 13; i++) {

digitalWrite(i, LOW);

}

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int i = 0; i < 6; i++) {

for (int j = 12; j > 6; j--) {

digitalWrite(j, HIGH);

delay(intervallo);

digitalWrite(j, LOW);

delay(intervallo);

}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display

// prima che venga stampato il numero viene eseguita la funzione roll()

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

LedAcceso.h

/* LedAcceso.h
   header file della libreria LedAcceso
*/
 
#include "Arduino.h"
 
void LedAcceso(int n);  // prototipo della funzione
void roll();            // prototipo della funzione

/* LedAcceso.h

header file della libreria LedAcceso

#include "Arduino.h"

void LedAcceso(int n); // prototipo della funzione

void roll(); // prototipo della funzione

sketch

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione con inclusione della libreria di gestione dell'accensione del display

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

#include "LedAcceso.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

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

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  // verifica se sulla serial monitor è presente un carattere,
  // se la condizione è vera viene letto il carattere presente sulla serial monitor
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione con inclusione della libreria di gestione dell'accensione del display

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

#include "LedAcceso.h"

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

// verifica se sulla serial monitor è presente un carattere,

// se la condizione è vera viene letto il carattere presente sulla serial monitor

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato 7 segment, arduino, C, case, display, libraries, libreria, switch | Lascia un commento

ROB-O-COD… tanto tempo fa era un LegoDuino

Pubblicato il Aprile 23, 2019 da admin

Mi è stato chiesto qualche giorno fa quale piattaforma fosse stata scelta per la realizzazione dei Robot per le gara per la trasmissione ROB-O-COD.

La scelta è stata attentamente valutata, anche con sperimentazioni pratiche che mi hanno coinvolto in prima persona.

Nel “brodo primordiale delle idee” 🙂 circa 1 anno fa, erano state considerate diverse tecnologie: BBC micro:bit, robot basati su Arduino e dopo tanto sperimentare e progettare, si è giunti a Lego Mindstorms EV3, i motivi di questa scelta, condivisi tra tutte le persone che hanno partecipato alla realizzazione della trasmissione sono stati molti, i principali: rapidità di assemblaggio e modifica dei robot in un ambito di studio televisivo, personalizzazione delle strutture, interfaccia grafica di programmazione intuitiva… e molto altro.

Nelle prime fasi di progetto ho valutato e sperimentato soluzioni miste, interfacciando, motori Lego Mindstorms con Arduino.
In passato avevo realizzato LegoDuino (seguendo il link potrete vedere un video dimostrativo) l’obiettivo era quello di realizzare dei robot Sumo, su di essi avevo inserito sensori ad ultrasuoni ed infrarossi.

Per ROB-O-COD, ho variato la versione Sumo in una versione cingolato su cui ho svolto le primissime sperimentazioni:

Ma come realizzare una soluzione mista?

Poiché mi è stato chiesto espressamente da alcuni colleghi, di seguito propongo un breve tutorial per la realizzazione di una struttura mista (Lego+Arduino) in modo che possiate poi da soli replicare le modalità di gara così come le potrete vedere nella trasmissione ROB-O-COD.

Il motore Lego Mindstorms, sia nella versione NXT che EV3 funziona ad una tensione di 9V e possiede al suo interno un encoders rotativo con una risoluzione di 1 grado, il controllo avviene mediante i cavi gialli e blu, nel tutorial che mostro però non utilizzerò l’encoder, ma solamente i due cavi bianco e nero utilizzati per l’invio del segnale PWM questi pin vengono chiamati MA0 e MA1 (tabella pin indicata di seguito).

Per effettuare il collegamento tra motore ed Arduino potete utilizzare una piccola interfaccia che permette di collegare i cavi BrickLink (noto anche come RJ12) in dotazione ai kit Lego Mindstorms, con la breadboard, i connettori si chiamano:

Breadboard Connector Kit for NXT or EV3 (seguite il link)

Nel caso non riusciste a procuravi questo adattatore, tagliate il cavo BrickLink ed utilizzate solamente i cavi bianco e nero, saranno questi che verranno collegati direttamente ad Arduino.

Di seguito la mappatura del cavo, per la numerazione fate riferimento a quanto indicato nell’immagine in cui è rappresentato il motore:

PIN    Colore    Nome
 1     Bianco    MA0
 2     Nero      MA1
 3     Rosso     GND
 4     Verde     4.3V dal mattoncini Lego
 5     Giallo    Tach01 (Encoder rotativo)
 6     Blu       Tach02 (Encoder rotativo)

PIN Colore Nome

1 Bianco MA0

2 Nero MA1

3 Rosso GND

4 Verde 4.3V dal mattoncini Lego

5 Giallo Tach01 (Encoder rotativo)

6 Blu Tach02 (Encoder rotativo)

Per procedere nella sperimentazione dovete munirvi di:

Scheda Arduino UNO R3 o simili
Scheda motore L298N
Breadboard Connector Kit for NXT or EV3 (in alternativa tagliate i cavi)
Uno o due motori Lego NXT o EV3

Il principio di funzionamento, inclusi i collegamenti, la programmazione e il funzionamento della scheda motori L298N sono identici a quelli che trovate nella lezione:

EduRobot – ASL (Alternanza Scuola Lavoro) – Manuale di costruzione – 2/3

Seguendo la lezione sarete in grado di realizzare un robot costituito da elementi Lego, scheda Arduino e sensori, tutto facilmente reperibile on-line a costi contenuti.

Aggiungo a quanto già indicato nella lezione segnalata sopra, gli schemi di collegamenti con la presenza dei motori Lego alimentati mediante una batteria esterna a 9V.

E se poi siete “puristi Lego” 🙂 allora partendo dai tutorial che trovate nell’ambiente di programmazione della versione LEGO MINDSTORMS EV3 Home Edition potrete realizzare qualcosa di molto simile a quanto mostrato nell’immagine che segue…

e ricordare: #ROB_O_COD è tutto un programma!

🙂

Articoli simili:

Pubblicato in arduino, robotica | Contrassegnato coding, game show, kids, lego, micro:bit, mindstorms, programmazione, rai, rai gulp, rai ragazzi, ROBOCOD, robot, robotica, rob_o_cod, teens | Lascia un commento

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Mi piace:

Articoli simili:

Dove mi trovi?

Iscriviti al blog tramite email

Cerca

Categorie

Vuoi aiutare la mia attività di divulgazione?

Domande

Arduino che passione

WebApp Arduino

BBC micro:bit

Stampa 3D

DotBot

EduRobot

Raspberry Pi

Corso di Elettronica

Micro corso di elettronica per principianti

Saldare è semplice

Robot Pet Therapy

BiblioBox

Pillole di tecnologia didattica

Instagram

Seguimi su Twitter

Articoli recenti

Ultimi commenti

Tag

Foto Flickr

Pubblicità