Archivi categoria: arduino

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.

Arduino – misurare tensioni superiori a 5V dc utilizzando un partitore di tensione

Nella precedente lezione abbiamo visto come misurare una tensione non superiore ai 5V dc, vedremo ora come realizzare un semplice circuito che permette mediante un partitore di tensione la misurazione di tensioni fino a 9 Volt. Dimensionando opportunamente le resistenze di partizione potremo effettuare misure per tensioni elettriche superiori.

Precisazione importante

Gli esempi riportati in questa e nella precedente lezione ed inoltre la gran parte degli esempio classici che trovate online, sono pensati per far comprendere il funzionamento del convertitore A/D, ma è opportuno fare alcune considerazioni sulla precisione di lettura, ovvero degli errori commessi dal convertitore A/D e sull’imprecisione delle tensioni di riferimento usate dal microcontrollore per fornirvi la misura. Questo sarà argomento di una prossima lezione e vedremo come ridurre l’errore di misura.

Per rendere semplice la realizzazione utilizzeremo la batteria da 9V, ma se intendete avere dei limiti di misura diversi e superiori a 9V dovrete apportare modifiche ai valori dei componenti, ma le formule esposte restano le medesime.

Prima di procedere con la realizzazione pratica è essenziale comprendere come dimensionare le resistenze del partitore, inoltre è essenziale che la tensione sul pin analogico A0 non superi il valore di 5V. Per effettuare il dimensionamento del circuito fissiamo la massima tensione misurabile Vmis_max  a 9V e imponiamo il valore di uno dei due resistori, ad esempio R1 in modo da poter ricavare il valore di R2.

Vi ricordo inoltre che sarebbe opportuno, una volta fissate le resistenze, fare qualche considerazione sulla corrente massima entrante in A0 in modo che non venga superato il valore di 40 mA corrente massima di I/O sui pin analogici e digitali di Arduino Uno R3, ma come le resistenze che sono state scelte non correremo alcun rischio, però esporrò ugualmente il calcolo.

Nello schema che segue Vmis rappresenta la tensione da misurare, Vadc la tensione sul pin A0. I è la corrente totale che circola nel circuito.

Sappiamo che la tensione Vadc ai capi di R2 non dovrà superare i 5V. Le tensioni su R1 ed R2 saranno:

(a) VR1 = R1*I
(b) VR2 = R2*I

Pertanto la tensione Vmis sarà

(c) Vmis = VR1 + VR2 = R1*I+R2*I = (R1+R2)*I

da cui ricaviamo:

(d) I = Vmis /(R1+R2)

Sostituendo I in (a) e (b) avremo:

(e) VR1 = R1*I = R1 * Vmis /(R1+R2)
(f) VR2 = R2*I = R2 * Vmis /(R1+R2)

Per il calcolo di R2 consideriamo la formula (f) sostituendo i valori fissati, Vmis_max e R1, ricordando che VR2 è la tensioni in A0, cioè Vadc:

⇒ VR2 =  R2 * Vmis /(R1+R2)

⇒ R2 /(R1+R2)  = VR2/Vmis_max

⇒ R2 /(R1+R2)  = 5/9

⇒ R2 /(R1+R2)  = 0,56

⇒ R2  = 0,56*R1 + 0,56*R2

⇒ R2*(1-0,56) = 0,56*R1

⇒ R2 = 0,56 *R1/0,44

⇒ R2 = 0,56 * 27 * 103/0,44 = 34,363 * 103 = 34,363 Kohm

Scelgo come valore commerciale prossimo (e che dispongo nel mie scorte) il valore di 33 Kohm, quindi:

  • R1 = 27 Kohm
  • R2 = 33 Kohm

Per quanto riguarda la corrente entrante in A0, utilizziamo la formula (b):

VR2 = R2*I

I = VR2/R2

I = 5V/33000 Ω = 0,00015 A = 0,15 mA

ben al di sotto del valore massimo del valore accettabile su un pin I/O di Arduino che è di 40mA.

Schema di collegamento

Programmazione

Sviluppiamo il codice necessario per la lettura della tensione e partendo dal primo sketch della lezione precedente modifichiamone alcune parti, nei commenti la spiegazione delle varie parti.

Nel codice bisognerà tenere in conto che la tensione su A0 è data dal calcolo della partizione di tensione, pertanto sapendo che Vmis = Vadc, dalla forma (f) abbiamo:

⇒ VR2 = R2*I = R2 * Vmis /(R1+R2)

⇒ VR2 = Vadc = R2 * Vmis /(R1+R2)

⇒ Vmis = Vadc * (R1+R2)/R2

Che sarà la formula che ci consentirà di rilevare la misura.

// Prof. Maffucci Michele
// Esempio 01: Misura una tensione di 9V con Arduino
// utilizzando variabili di tipo float
// Data: 03.10.2021

// tensione di riferimento massima misurabile
const float tensioneDiRiferimento = 5.0;

float R1 = 27000.0; // 27 Kohm
float R2 = 33000.0; // 33 Kohm

float volt_adc = 0.0;
float volt_mis = 0.0;

void setup() {
  Serial.begin(9600);
  //analogReference(DEFAULT);
}
void loop() {
  // legge il valore su A0 (su R2), cioè la tensione Vadc e lo trasforma
  // in un valore numerico tra 0 e 1023
  
  int valoreLetto = analogRead(A0);

  // Tensione in ingresso ad A0, cioè la tensione Vadc
  // calcolo della proporzione
  // volt:tensioneDiRiferimento = valoreLetto:1023.0
  // da cui si ricava la formula che segue
  
  volt_adc = (valoreLetto/1023.0) * tensioneDiRiferimento;

  //Stampa del valore letto dall'ADC
  Serial.print("Valore ADC = ");
  Serial.println(valoreLetto);
  
  // calcolo della tensione di ingresso Vmis

  volt_mis = volt_adc*(R1+R2)/R2;

  // stampa sulla Serial Monitor la tensione misurata
  Serial.print("Tensione di ingresso = ");
  Serial.println(volt_mis);
  Serial.println(" ");

  delay(1000);
}

Esercizi per i miei studenti

Esercizio 1
Dimensionare il Circuito per misurare una tensione massima di 12V

Esercizio 2
Realizzare uno sketch Arduino che permette di dimensionare il circuito prendendo in  input, attraverso la Serial Monitor il valore massimo misurabile ed il valore di R1 e restituisce il valore di R2 calcolato.

Esercizio 3
Realizzare le medesime funzionalità dell’esercizio 2, ma il valore restituito di R2 deve essere sia quello calcolato che quello commerciale immediatamente superiore o inferiore al valore calcolato.

Buon Coding a tutti 🙂

Arduino – misurare tensioni continue fino a 5V

La misurazione di una tensione con Arduino è un esercizio standard utilizzato per spiegare come funziona il convertitore Analogico Digitale sulla scheda. Nell’esempio che segue verrà mostrato come visualizzare sulla Serial Monitor la tensione di una batterie da 1,5V ma in generale di una tensione non superiore ai 5V, seguono poi una serie di esercizi per i miei studenti.
Nella prossima lezione mostreremo come misurare una tensione superiore ai 5V.

ATTENZIONE
E’ essenziale ricordare che non bisogna in alcun modo inserire tensioni superiori a 5V sui pin di Arduino, in quanto potreste distruggere irrimediabilmente la scheda.

Per la rilevazione di una tensione elettrica su un pin analogico viene utilizzata la funzione analogRead, che come più volte indicato su questo sito, è in grado di convertire una tensione tra 0V e 5V continui in un valore numerico intero con risoluzione di 10 bit tra 0 e 1023, operazione svolta dal convertitore A/D.

Ricordo che l’analogRead(pin) 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 il valore unitario corrisponde a:

Vu = 5V/1023 = 4,89 mV

Per conoscere il valore di tensione rilevato sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), quello che chiamiamo valore quantizzato Vq compreso tra 0 e 1024, il valore misurato Vm sarà:

Vm = Vu x Vq

e sapendo che Vu corrisponde a 4,89 mV possiamo scrivere:

Vm = 4,89 x Vq

Nota per i miei allievi: riprenderemo questo semplice calcolo qundo utilizzeremo ad esempio i sensori di temperatura.

Il semplice schema di collegamento è riportato nell’immagine che segue:

Per stampare sulla Serial Monitor la tensione ai capi della batteria, useremo valori di tipo float (in virgola mobile), che come indicato nel mio post: “Arduino: tipi di dati – ripasso” possiamo esprime valori compresi tra –3.4028235E+38 e 3.4028235E+38.
La stampa di numeri in virgola mobile sula Serial Monitor verrà rappresentata con numeri che hanno al massimo con due cifre decimali, riprenderemo questo aspetto nel secondo esempio di questa lezione.

// Prof. Maffucci Michele
// Esempio 01: Misura di tensioni continue non superiori a 5V
// utilizzando variabili di tipo float
// Data: 01.10.2021

// tensione di riferimento predefinita sulla scheda
const float tensioneDiRiferimento = 5.0;

// batteria connessa al pin analogico 0
const byte pinBatteria = A0;

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

void loop() {
  // legge il valore della batteria e lo trasforma
  // in un valore numerico tra 0 e 1023
  int valoreLetto = analogRead(pinBatteria);

  // calcolo della proporzione
  // volt:tensioneDiRiferimento = valoreLetto:1023.0
  // da cui si ricava la formula che segue
  float volt = (valoreLetto/1023.0) * tensioneDiRiferimento;

  // stampa sulla Serial Monitor la tensione misurata
  Serial.println(volt);
}

Per evitare spreco di memoria dovuto ai calcoli che utilizzano i tipi di dati float che occupano maggiore memoria, è possibile utilizzare al posto del tipo float il tipo long, ovvero un int lungo rappresentato da 4 byte in grado di rappresentare numeri interi tra –2147483648 a 2147483647.

Vediamo come modificare lo sketch precedente per rilevare tensioni espresse in millivolt in cui però si utilizzano variabili intere di tipo long:

// Prof. Maffucci Michele
// Esempio 02: Misura di tensioni continue non superiori a 5V
// utilizzando variabili di tipo float
// Data: 01.10.2021

// batteria connessa al pin analogico 0
const byte pinBatteria = A0;

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

void loop() {
  // legge il valore della batteria e lo trasforma
  // in un valore numerico tra 0 e 1023
  // valoreLetto è di tipo long
  long valoreLetto = analogRead(pinBatteria);

  // stampa sulla Serial Monitor la tensione misurata
  // in millivolt
  
  Serial.println((valoreLetto*(500000/1023L))/100);
}

Quindi per evitare di effettuare calcoli con numeri di tipo float (in virgola mobile) senza perdere precisione, il trucco consiste nell’operare sui valori in millivolt invece che  sui valori in volt. Ricordo che 1 volt corrisponde a 1000 millivolt.

Come detto all’inizio di questa lezione sappiamo che un valore numerico di 1023 restituito dall’analogRead, corrisponde al valore massimo di 5000 millivolt, allora ogni unità rappresenta 5000/1023 millivolt, che corrisponde a 4,89 millivolt. Come detto nell’esempio precedente, la stampa su Serial Monitor di un numero in virgola mobile mostrerà al massimo due decimali, pertanto l’eliminazione dei decimali nel secondo esempio possiamo farlo moltiplicando per 100, nel codice: 5000×100=500000, questo valore verrà poi moltiplicato per il rapporto tra il valore letto e 1023 ed il tutto ancora diviso per 100, così facendo otterremo il valore in millivolt. Questo calcolo permette di far effettuare al compilatore solamente calcoli tra interi e non tra float, rendendo quindi la computazione più veloce e riducendo la quantità di memoria utilizzata.

Si noti che al fondo del numero 1023 è stata aggiuta una L, cioè 1023L, che indicare al compilatore che il numero rappresentato è di tipo long (4 byte).

Esercizi per i miei studenti

Esercizio 1
Utilizzare un Trimmer per regolare la tensione in ingresso ad A0 tra 0 e 5V, in questo caso si prenda la tensione di 5V dal pin di Arduino.

Esercizio 2
Nel primo sketch proposto utilizzare la funzione map per convertire il valore restituito dall’ analogRead in un valore di tensione. In questo caso nascono dei problemi sulla precisione della misura, sapresti indicarmi quali?

Esercizio 3
Visualizzare il valore di tensione regolato dal Trimmer sul Plotter Seriale.

Esercizio 4
Utilizzando uno qualsiasi dei due sketch indicati sopra e visualizzare la tensione misurate sul un display 16×2

Esercizio 5
Aggiungere all’esercizio precedente l’indicazione di carica data da un grafico costituito da 5 quadrati che ne indicano il livello di carica, non appena il livello di carica raggiunge 1 volt il quadrettino inizia a lampeggiare.

Buon Making a tutti 🙂

Arduino: stampare più funzioni sulla serial plotter

L’attività di progetto di questa mattina: progettazione di dispositivi elettronici che rispondono a diverse necessità per la salute umana: cura della persona, disabilità, sicurezza sul lavoro, strumenti medici/laboratorio, accessibilità dei luoghi pubblici, ecc…

Con mio piacere ne è nata un’intensa attività di ricerca che ha coinvolto l’intero gruppo classe. Molte le necessità e tra queste ne evidenzio uno, semplice, che riguarda la programmazione, che in più occasioni gli studenti affrontano durante le sperimentazioni e di cui mi sono reso conto di non avere documentato adeguatamente, ovvero: il plot di più funzioni su uno stesso piano cartesiano con Arduino.

Avevo mostrato in più occasioni come effettuare il plot di grandezze variabili nel tempo utilizzando la Serial Plotter dell’IDE di Arduino, uno degli ultimi articoli si riferisce alla realizzazione di uno strumento per la rilevazione di vibrazioni, un semplice sismografo realizzato con un sensore piezoelettrico.

Alcuni studenti questa mattina, si stavano cimentando nella progettazione di un guanto da utilizzare per la movimentazione di un braccio robot industriale della hyundai con l’obiettivo di simulare la movimentazione a distanza di sostanze chimiche pericolose. Nelle prime attività di ricerca si è manifestata la necessità di visualizzare su tre grafici diversi le componenti X, Y, Z dell’accelerazione fornite da un accelerometro connesso ad Arduino.

Come sicuramente saprete l’avvio della Serial Plotter avviene, così come per la Serial Monitor dal menù Tools. Ricordo che Serial Monitor e Serial Plotter non possono essere avviate contemporaneamente.

La Serial Plotter prende i valori che giungono dalla seriale (connessione USB) e li grafica su un piano cartesiano. I dati numerici vengono anche visualizzati nella parte in alto a sinistra della finestra della Serial Plotter.

I valori massimi e minimi rappresentati sull’asse Y vengono regolati automaticamente, mentre la dimensione dell’asse X è fissato a 500 punti e l’aggiornamento del grafico avviene ogni qual volta nel vostro sketch viene eseguita una Serial.println().

Ricordate inoltre di fissare il Baud Rate del Serial Plotter in modo che corrisponda a quello che avete indicato nel codice.

Per tracciare contemporaneamente forme d’onda è possibile agire in due modi:

inserendo uno spazio tra due istruzioni di stampa

Serial.print(temperatura);
Serial.print(" ");
Serial.println(umidita);

oppure inserendo una tabulazione tra due istruzioni di stampa

Serial.print(temperatura);
Serial.print("\t");
Serial.println(umidita);

In questo caso le due grandezze, temperatura e umidità, saranno rappresentate da due funzioni separate e tracciate contemporaneamente sullo stesso piano cartesiano.

A titolo di esempio consideriamo il mio post in cui mostravo come utilizzare un DHT11 e visualizzeremo sulla Serial Plotter le due grandezze fisiche temperatura ed umidità. Di seguito schema di collegamento, sketch e grafici.

// Prof. Maffucci Michele
// Visualizzazione della pressione e dell'umidità rilevata da un DHT11
// sulla Serial Plotter
// 16.09.2021

// Libreria DHT
#include "DHT.h"

// Pin digitale di arduino connesso al DHT
#define DHTPIN 2

// tipo del sensore: DHT 11
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  // Attesa di 1 millisecondo prima di fornire la misura.
  delay(1);

  // Lettura dell'umidità
  float h = dht.readHumidity();
  // Lettura della temperatura in gradi Celsius
  float t = dht.readTemperature();

  // Verifica se le si presenta un errore di lettura (e riprova nuovamente)
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Impossibile leggere dal sensore DHT!"));
    return;
  }

  // Stampa del valore dell'umidità
  Serial.print(h);
  Serial.print(' ');
  // Stampa del valore della temperatura
  Serial.println(t);
}

Il plot delle due grandezze è:

Per completezza realizziamo un semplice sketch che permette di rappresentare 3 funzioni sinusoidali sfasate di 90 gradi una rispetto all’altra con ampiezze diverse:

// Prof. Maffucci Michele
// Visualizzazione di tre funzioni siusoidali
// di ampiezza diversa e sfasate di 90 gradi
// 16.09.2021

void setup() {
  Serial.begin(9600);
}

void loop() {

  // M_PI è la macro definita nell'header math.h
  // che definisce il pi greco che ha il valore di:
  // 3.14159265358979323846
  for(int i = 0; i < 360; i += 2) {
    float ValoreY1 = 1 * sin(i * M_PI / 180);
    float ValoreY2 = 2 * sin((i + 90)* M_PI / 180);
    float ValoreY3 = 4 * sin((i + 180)* M_PI / 180);

    Serial.print(ValoreY1);
    Serial.print(' ');         // deve essere stampato spazio ' ' o  tab '\t' tra due valori.
    Serial.print(ValoreY2);
    Serial.print(' ');         // deve essere stampato spazio ' ' o  tab '\t' tra due valori.
    Serial.println(ValoreY3);  // l'ultimo valore deve avere un ritorno a capo

    delay(1);
  }
}

Buon Coding a tutti 🙂

Arduino: misuratore di distrazione dovute all’uso di uno smartphone

Uno dei progetti che ho assegnato ai miei studenti in questo anno scolastico che volge al termine, è stato quello di progettare e realizzare un sistema di automazione in grado di valutare il comportamento sedentario di una persona quando lavora a computer. Al sistema sono stati aggiunti  appositi segnali di allarme che hanno l’obiettivo di invogliare la persona ad effettuare esercizio fisico.
Gli allievi hanno progettare il dispositivo non solo da un punto di vista elettronico, ma anche dal punto di vista dell’usabilità e del design.
I progetti realizzati hanno avuto sviluppi molto interessanti, nelle foto in allegato trovare una versione addirittura dotata di caricatore per smartphone dotato inoltre di un doppio controllo: presenza persona (mediante sensore PIR) e rilevazione prelievo smartphone mediante sensore LDR. Come accade spesso i migliori progetti sviluppati durante il PCTO vengono utilizzati per sviluppare le future attività di laboratorio per l’anno scolastico successivo.

Una variante all’attività sopra segnalata è un misuratore di distrazione, l’idea nasce da una serie di necessità:

1. far percepire fisicamente la quantità di interruzioni e quindi distrazioni durante un’attività di studio dovute alle continue notifiche ricevute sugli smartphone;
2. usare concetti elettronici ed informatici non estremamente complessi ed adatti a chi inizia ad utilizzare un microcontrollore;
3. far si che nell’attività di laboratorio sia presente una componente di educazione civica.

Da ciò è nato il “misuratore di distrazioni” che proporrò per la realizzazione ad un gruppo di colleghi che stanno seguendo il mio corso: Le buone pratiche del Making e dell’Internet delle Cose (IOT avanzato) organizzato dal Liceo da Vinci – Floridia (SR), sarà il progetto della settimana.

Il sistema sarà dotato di pochi componenti:

  • Arduino
  • Ldr
  • Display 16×2
  • Pulsante

Il tutto si presenta come una semplice scatola su cui può essere poggiato il telefono, un LDR posto sulla base di appoggio rileverà la variazione di luce quando si solleva lo smartphone. Il display indicherà il numero di volte che il telefono è stato preso e quindi il numero di volte che la persona ha interrotto il suo lavoro o studio. Le distrazioni potranno essere ridotte inserendo un coperchio che nasconde il display dello smartphone.

Ovviamente si potrà migliorare il sistema, ad esempio mostrando la quantità di minuti trascorsi dall’ultima distrazione, o ancora il numero di minuti totali si distrazione, il progetto potrà essere migliorata a piacimento. Poiché durante il corso dovrò parlare anche di IoT si aggiungerà la possibilità di invio messaggi di avvertimento via Telegram nel caso si raggiunga un limite fissato di distrazioni.

Per rendere la costruzione del dispositivo semplice e veloce ho utilizzato del foam core in modo che non ci sia l’obbligo di utilizzo di una stampante 3D o di una macchina a taglio laser per la realizzazione dell’oggetto.

Rendo quindi disponibile i sorgenti grafici in formato svg per stampare su foglio di carta adesiva le parti della scatola. I fogli adesivi verranno poi incollati sui pannelli foam ed ogni parte sarà tagliata a mano con un cutter e successivamente incollati con colla vinilica.

Buon making a tutti 🙂