Archivi tag: arduino

CoolTerm – Alternative alla Serial Monitor di Arduino

La comunicazione seriale viene usata in moltissimi dispositivi elettronici che utilizziamo ogni giorno. Rispetto alla comunicazione parallela (4, 8 o 64-bit), la comunicazione seriale è utilizzata spesso nei sistemi embedded a causa del basso costo e della trasmissione efficace nelle lunghe distanze.
Per chi opera con Arduino, sa che l’uso della Serial Monitor è necessario per la lettura di dati inviati serialemente tra Arduino ed il computer con altri dispositivi elettronici, ad esempio l’invio sulla Serial Monitor dei valori di temperatura rilevata da un sensore di temperatura connesso ad Arduino.

La comunicazione seriale è inoltre uno strumento utilissimo per effettuare il debug, ovvero inviare dei messaggi sulla seriale per l’utente al fine di rilevare errori o mettere in evidenza i passi di esecuzione di un programma o lo stato di un sistema.

I dati inviati da Arduino al Computer o viceversa possono essere visualizzati sul monitor del computer (attraverso la finestra della Serial Monitor) o su altri dispositivi come ad esempio un display LCD connesso ad Arduino.

Ho mostrato più volte in precedenti lezioni l’uso dei comandi seriali: Serial.begin(), Serial.print(), Serial.read() e l’utilizzo della Serial Plotter che permette di visualizzare il grafico su piano cartesiano dei dati seriali trasmessi da Arduino.

Sicuramente anche voi, nell’uso costante della Serial Monitor, avrete notato i limiti dello strumento, come esempio l’impossibilità del salvataggio dei dati inviati ad un file di log.
E’ utile quindi considerare l’uso di un terminale alternativo che offra maggiori funzionalità rispetto alla Serial Monitor, come ad esempio visualizzare:

  • i caratteri di controllo;
  • i dati in formato testo o binario o entrambi;
  • salvare i dati rilevati in un file di log.

Tra i molti software disponibili il mio consiglio va a CoolTerM, un terminale user-friendly estremamente utile.
CoolTerM viene distribuito con licenza freeware / donationware sviluppato da Roger Meier ed è disponibile per dispositivi Windows, Mac, Linux.

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

A titolo di esempio sfruttiamo quanto già svolto in passato, visualizzimo su CoolTerM la distanza di un ostacolo rilevato da un sensore ad ultrasuoni.
Prendiamo come riferimento lo sketch che segue, tratto da una mia lezione sull’uso del sensore ad ultrasuoni per un kit robotico, nello stesso post trovate la teoria di funzionamento del sensore HC-SR04.

/* Prof. Maffucci Michele

   Utilizzo del sensore ultrasuoni HC-SR04
   Misura della distanza di un ostacolo

*/

long durata;          // durata dell'impulso
long distanza;        // distanza dell'oggetto
int pin_echo = 7;     // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 9;     // pin Arduino a cui è collegato il sensore SR04

void setup()
{
    Serial.begin(9600);
	pinMode(pin_trig, OUTPUT);
  	pinMode(pin_echo, INPUT);
  	Serial.println("Sensore ad ultrasuini");
}

void loop()
{
  Serial.print("Distanza ostacolo: ");
  Serial.println(distanzaOstacolo());
  delay(100);
}

// rilevazione distanza ostacolo

// misura la distanza dell'ostacolo
long distanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_echo, HIGH);
  distanza = (durata / 2.0) / 29.1;
  delay(100);
  return distanza;
}

Con Arduino connesso al computer aprire CoolTerM e selezionare “Options”, da quì impostare la porta a cui è connessa la scheda e la velocità di connessione a 9600, una velocità diversa non permetterà una lettura corretta dei dati.

Torna alla schermata principale fate clic su “Connect”, ciò permetterà di avviare la trasmissione dei dati tra Arduino e il computer e i dati inizieranno ad apparire.
Quando desiderate interrompere la trasmissione ovviamente farete clic su “Disconnetti”.

E’ spesso utile analizzare i dati raccolti, in tal caso selezionate: Connection > Capture to Text/Binary File > Start ciò permetterà di salvare i vostri dati in un file TXT che potrà poi essere analizzato ad esempio con un foglio di calcolo.

CoolTerM offre ulteriori funzionalità molto utili:

  • se disponibile è possibile connettere più porte seriali concorrenti;
  • visualizzazione dei dati in formato semplice o esadecimale (HEX);
  • salvataggio e caricamento delle opzioni di connessione;
  • gestione dei caratteri speciali;
  • scripting;
  • eco locale di dati trasmessi / ricevuti;

Buon Making a tutti 🙂

Esercitazioni di base di Arduino – visualizzazione luminosità LED mediante una barra di avanzamento su display 16×2


Continuo nell’aggiornamento delle esercitazioni di base per gli studenti di 3′ dell’ITIS (Elettronica ed Automazione) e per gli utenti che iniziano con Arduino.
Utilizzeremo un display LCD 16×2 di tipo I2C su cui visualizzeremo mediante una barra di avanzamento, la quantità di luminosità impostata per il LED, mediante un potenziometro.

Per la gestione di un display LCD di tipo I2C rimando alla mia lezione: Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T.

Per la creazione di caratteri personalizzati rimando alla mia lezione: Disegnare caratteri personalizzati con Arduino per un LCD 16×2.

Lista componenti

  • N.1 Arduino UNO
  • N.1 Breadboard
  • N.1 LCD 16×2 I2C
  • N.1 Potenziometri da 10 KOhm
  • N.1 LED da 5 mm
  • N.1 Resistore da 220 Ohm
  • jumper

Schema di collegamento

Scketch

Di seguito viene indicato il codice i base, all’interno i commenti che ne dettagliano il funzionamento di ogni parte:

/*
   Prof. Maffucci Michele
   https://www.maffucci.it
   Ver.1 - 27.12.21
   Controllo di luminosità LED con
   visualizzazione intensità mediante una
   barra di avanzamento su display 16x2
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
byte pinLed = 3;            // pin PWM a cui connettere il LED
int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
int  luminosita = 0;        // variabile in cui memorizzare la luminosità
byte barraAvanzamento = 0;  // indice barra avanzamento

// Per maggiori informazioni sulla realizzazione di caratteri speciali:
// https://www.maffucci.it/2020/01/18/disegnare-caratteri-personalizzati-con-arduino-per-un-lcd-16x2/

// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
byte iconaBarra[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
// impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
LiquidCrystal_I2C lcd(0x27, 16, 2);
//-----------------------------

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
  pinMode(pinLed, OUTPUT);

  // Cancella il display
  lcd.clear();

  // Stampa il messaggio sulla prima riga del display
  lcd.print("Luminosita' LED");

  //Creazione del carattere per la barra di avanzamento
  lcd.createChar(0, iconaBarra);
}

// Per maggiori informazioni sull'uso del display 16x2 I2C:
// https://www.maffucci.it/2019/01/25/utilizzo-delllcd-16x2-hitachi-hd44780-1602-con-modulo-i2c-pcf8574t/
//-----------------------------

void loop() {
  // Cancella il display
  lcd.clear();

  // Stampa il messsaggio sulla prima riga
  lcd.print("Luminosita' LED");

  //Posiziona il cursore nella seconda riga, prima colonna
  lcd.setCursor(0,1);

  // Lettura del valore impostato dal potenziometro
  analogVal = analogRead(pinPot);

  // Conversione del valore analogico impostato con il potenziometro
  // in Duty Cicle per impostare la luminosità del LED
  luminosita=map(analogVal, 0, 1024, 0, 255);

  // Impostazione della luminosità del LED
  analogWrite(pinLed, luminosita);

  // Conversione della luminosità in quantità di caratteri della barra da stampare
  barraAvanzamento=map(luminosita, 0, 255, 0, 15);

  // Stampa la barra di avanzamento
  for (byte i = 0; i < barraAvanzamento; i++)
  {
    lcd.setCursor(i, 1);
    lcd.write(byte(0));
  }
  // leggero ritardo di 500 ms per visualizzare la barra
  delay(500);
}

Proposta esercizi

Esercizio 1
Nell’esempio proposto viene utilizzato un delay() finale per permettere la visualizzazione dei caratteri sul display. Sostituire il delay() ed utilizzare l’istruzione millis() per valutare il tempo trascorso e controllare la stampa dei caratteri sul display.

Esercizio 2
Modificare il programma precedente raddoppiando il numero di caratteri che rappresenta la barra di avanzamento.

Esercizio 3
Modificare l’esercizio proposto variando la barra di avanzamento in funzione dell’approssimarsi al valore massimo o minimo della luminosità.

Esercizio 4
Modificare l’esercizio proposte inserendo un buzzer che emette un suono la cui frequenza varia in funzione dell’intensità luminosa del LED.

Buon Making a tutti 🙂

Esercitazione di Sistemi Elettronici – Arduino – impianto semaforico ad 1 via

Questa esercitazione è dedicata ai miei studenti di 3′ (Automazione ed Elettronica Biomedicale) che come compito per le vacanze natalizie dovranno, partendo dall’esempio svolto, realizzare le 4 varianti richieste al fondo di questa lezione.

Introduzione

  • In questo progetto bisognerà realizzare l’impianto semaforico per automobili e modificarlo secondo le specifiche indicate al fondo di questo post
  • vengono utilizzati 3 LED: verde, giallo e rosso per simulare un semaforo reale
  • vengono utilizzati 2 LED : verde e rosso per simulare il semaforo per i pedoni
  • è presente un pulsante di richiesta attraversamento per i pedoni

Lista componenti

  • 1 Breadboard
  • 1 Arduino UNO
  • 3 LED da 5mm (rosso, giallo, verde)
  • 2 LEd da 5mm LED (rosso, verde)
  • 5 resistori da 220 Ohm
  • 1 resistore da 10 kOhm
  • 1 pulsante normalmente aperto
  • jumper

Collegamenti

Sketch

Per la realizzazione di questo progetto non avrete necessità di nessuna libreria da aggiungere all’IDE di Arduino.

L’automazione del semaforo sarà la seguente:

  • Il semaforo per le automobili è sempre verde e la luce pedonale risulta sempre rossa a meno che qualcuno preme il pulsante.
  • Quando viene premuto il pulsante dal pedone:
    • il semaforo auto cambia da giallo e successivamente si spegne il giallo e si accende il rosso;
    • sul semaforo pedonale si spegne il rosso e si accende il verde;
    • le luci del semaforo pedonale rimangono in questo stato per un tempo pari a tempoAttraversamento
    • successivamente il verde del semaforo pedonale lampeggia, terminata la sequenza di lampeggio si spegne e si accende il rosso;
  • il semaforo delle auto passa da rosso a verde

Tutte queste funzioni sono svolte dalla funzione cambiabentoLuci().

/*
   Prof. Maffucci Michele
   Ver.1 - 22.12.21
   Impianto semaforico con attraversamento
   pedonale a richiesta
*/

// pin a cui sono connessi i LED
byte rossoAuto = 13;
byte gialloAuto = 12;
byte verdeAuto = 11;
byte rossoPedone = 10;
byte verdePedone = 9;

// pin a cui è connesso il pulsante di richiesta
byte pulsante = 8;

// tempo massimo di attraversamento del pedone
int tempoAttraversamento = 10000;

// definizione della variabile per l'impostazione
// del cambio stato del semaforo auto
unsigned long tempoCambio;

void setup() {
  // inizializzazione timer
  tempoCambio = millis();

  // inizializzazione dei pin come OUTPUT

  pinMode(rossoAuto, OUTPUT);
  pinMode(gialloAuto, OUTPUT);
  pinMode(verdeAuto, OUTPUT);
  pinMode(rossoPedone, OUTPUT);
  pinMode(verdePedone, OUTPUT);

  // inizializzazione pin come INPUT
  pinMode(pulsante, INPUT);

  // accensione luci verdi
  // all'avvio le auto hanno il verde e i pedoni il rosso
  digitalWrite(verdeAuto, HIGH);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(gialloAuto, LOW);
  digitalWrite(verdePedone, LOW);

  // inizializzazione della Serial Monitor
  Serial.begin(9600);
}

void loop() {
  // la variabile state viene utilizzata per sapere se il
  // pulsante di attraversamento viene premuto
  int stato = digitalRead(pulsante);

  // lo stato del pulsante viene visualizzato sulla Serial Monitor
  Serial.println(stato);

  // Se viene premuto il pulsante e se sono
  // passati 5 secondi dall'ultima pressione del pulsante

  if (stato == HIGH && (millis() - tempoCambio) > 5000) {
    // chiama la funzione per il cambio luci
    cambioLuci();
  }
}

void cambioLuci() {
  digitalWrite(verdeAuto, LOW);      // il LED verde viene spento
  digitalWrite(gialloAuto, HIGH);    // il LED giallo viene acceso per 2 secondi
  delay(2000);

  digitalWrite(gialloAuto, LOW);    // il LED giallo viene spento
  digitalWrite(rossoAuto, HIGH);    // il LED rosso viene acceso per 5 secondi

  digitalWrite(rossoPedone, LOW);   // il LED rosso del pedone viene spento
  digitalWrite(verdePedone, HIGH);  // il LED verde del pedone viene acceso
  delay(tempoAttraversamento);

  // lampeggio del LED verde dei pedoni
  for (int x = 0; x < 10; x++) {
    digitalWrite(verdePedone, LOW);
    delay(100);
    digitalWrite(verdePedone, HIGH);
    delay(100);
  }
  digitalWrite(verdePedone, LOW);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(verdeAuto, HIGH);

  tempoCambio = millis();
}

Esercizio 1
Aggiungere un sensore ad ultrasuoni che rileva la presenza del pedone in fase di attraversamento, fino a quando viene rilevato il pedone viene mantenuto il verde per il pedone ed il rosso per le auto. E’ presente sempre il pulsante di richiesta attraversamento.

Esercizio 2
Ampliare l’esercizio 1 aggiungendo un display a 7 segmenti utilizzato come conto alla rovescia (da 9 a 0) per i pedoni quando attraversano.

Esercizio 3
Ampliare l’esercizio 1 aggiungendo un buzzer che con un segnale pulsante variabile, indica l’approssimarsi del rosso.

Esercizio 4
Ampliare l’esercizio proposto in questa lezione trasformando l’impianto semaforico da 1 via a 4 vie con rispettivi attraversamenti pedonali sulle 4 strade.

Per coloro che non sono miei studenti, sul mio Patreon nei prossimi giorni verrà proposta:

  • La soluzione a tutti gli esercizi proposti con schemi di collegamento e codice
  • Video di spiegazione
  • Sorgenti STL per la stampa 3D di un semaforo da poter essere inseriti all’interno di un plastico
  • Proposta progettuale per la realizzazione di un kit didattico per lo sviluppo di questa tipologia di esercizi.

Buon Making a tutti.

Creare un kit robotico educativo a basso costo – 2′ edizione


Dopo il successo della prima edizione sono felice di annunciarvi che questa settimana proporrò la seconda edizione del corso: Creare un kit robotico educativo a basso costo. Mostrerò nuovi robot realizzati in cartone controllati da BBC micro:bit. Darò inoltre indicazione su effettuare il controllo con Arduino e Raspberry Pi.

Come in ogni corso che svolgo verranno forniti sorgenti grafici per la realizzazione dei robot e schede didattiche di programmazione che potranno essere utilizzate in classe con gli studenti.

Presentazione del corso:

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

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

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

  • Venerdì 19 novembre 2021 – Dalle 17.00 alle 19.00
  • Lunedì 29 novembre 2021 – Dalle 17.00 alle 19.00
  • Martedì 30 novembre 2021 – Dalle 17.00 alle 19.00

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

Open PLC – Lezione 3: Slave Arduino – configurare gli I/O

E’ possibile utilizzare una scheda Arduino come slave per espandere gli I/O di un dispositivo hardware su cui funziona OpenPLC. Questa operazione è particolarmente utile se state lavorando con OpenPLC in esecuzione su un computer Windows o Linux, in questo modo collegando una scheda Arduino potremo aggiungere un’interfaccia fisica di gestione degli I/O del nostro PLC.

La scheda Arduino può essere utilizzata solo come dispositivo slave, pertanto è essenziale impostare un host, ovvero avere un OpenPLC Runtime installato su un computer con sistema operativo Windows o Linux, così come visto nelle lezioni precedenti. Vedremo inoltre nella successiva lezione come installare OpenPLC su un computer Raspberry Pi e su un Raspberry Pi 400 ed utilizzare la GPIO come I/O del nostro PLC.

Effettuare l’upload del Firmware su Arduino

Selezionate la versione corretta del firmware (si tratta di uno sketch Arduino che deve essere eseguito) per la scheda che possedete, scompattate e caricatela sulla scheda Arduino:

Aggiungere lo slave ad OpenPLC

Installato il firmware sulla scheda e mantenendo la scheda connessa al computer con cavo USB, avviare il OpenPLC Runtime sul vostro computer, effettuate il login con le vostre credenziali. Accedere al menù “Slave Devices” e clic su “Add new device”:

Compilare tutti i campi, evitare caratteri accentati come ad esempio: ç, é, ó, ñ, selezionare la scheda Arduino utilizzata, la porta COM viene identificata automaticamente, in ogni caso se doveste avere dei problemi vi ricordo che la porta COM a cui è connessa la scheda può essere desunta dall’IDE di Arduino oppure verificando dal vostro sistema operativo, quali sono le periferiche connesse.

Avviate il PLC facendo clic su “Start PLC”. Se all’interno della dashboard di OpnePLC vengono visualizzati messaggi di timeout, non preoccupatevi è una situazione normale, tutte le schede Arduino hanno una funzione di ripristino automatico che riavvia la scheda ogni volta che viene effettuata una nuova connessione USB, quindi una volta che OpenPLC avvia una comunicazione, il primo tentativo di inviare un messaggio alla scheda fallisce perché la scheda Arduino si sta ancora avviando dopo un ripristino. Dopo pochi millisecondi la scheda è completamente operativa, dovreste vedete i LED Tx ed Rx lampeggiare, ciò identifica il funzionamento del sistema.

Mappa dei Pin

Nelle tabelle che seguono è indicata la mappatura dei pin per le schede Arduino Uno e Arduino Mega. La mappatura si riferisce all’ultima versione di OpenPLC, la v3.
Ricordate che, per quanto riguarda le schede Arduino, gli I/O hanno una numerazione che differisce da altri hardware.

Mappatura pin Arduino UNO

input digitali Arduino Pin OpenPLC I/O
2 %IX100.0
3 %IX100.1
4 %IX100.2
5 %IX100.3
6 %IX100.4
output digitali 7 %QX100.0
8 %QX100.1
12 %QX100.2
13 %QX100.3
input analogici A0 %IW100
A1 %IW101
A2 %IW102
A3 %IW103
A4 %IW104
A5 %IW105
output analogici 9 %QW100
10 %QW101
11 %QW102

Mappatura pin Arduino MEGA

input digitali Arduino Pin OpenPLC I/O
22 %IX100.0
24 %IX100.1
26 %IX100.2
28 %IX100.3
30 %IX100.4
32 %IX100.5
34 %IX100.6
36 %IX100.7
38 %IX101.0
40 %IX101.1
42 %IX101.2
44 %IX101.3
46 %IX101.4
48 %IX101.5
50 %IX101.6
52 %IX101.7
14 %IX102.0
15 %IX102.1
16 %IX102.2
17 %IX102.3
18 %IX102.4
19 %IX102.5
20 %IX102.6
21 %IX102.7
output digitali 23 %QX100.0
25 %QX100.1
27 %QX100.2
29 %QX100.3
31 %QX100.4
33 %QX100.5
35 %QX100.6
37 %QX100.7
39 %QX101.0
41 %QX101.1
43 %QX101.2
45 %QX101.3
47 %QX101.4
49 %QX101.5
51 %QX101.6
53 %QX101.7
input analogici A0 %IW100
A1 %IW101
A2 %IW102
A3 %IW103
A4 %IW104
A5 %IW105
A6 %IW106
A7 %IW107
A8 %IW109
A9 %IW109
A10 %IW110
A11 %IW111
A12 %IW112
A13 %IW113
A14 %IW114
A15 %IW115
output analogici 2 %QW100
3 %QW101
4 %QW102
5 %QW103
6 %QW104
7 %QW105
8 %QW106
9 %QW107
10 %QW108
11 %QW109
12 %QW110
13 %QW111

Buon Making (di automazione) a tutti 🙂