Vaso tecnologico con Arduino che indica quando la tua pianta ha sete

Un vaso con sottovaso tecnologico che quando si avvicina una persona produce una luce rotante di colore che varia in base all’umidità della terra e quindi alla necessità che la pianta ha di nuova acqua.

Quante cose si possono fare con Arduino? Da quando è apparso sulle riviste e sul web, si direbbe praticamente tutto, visto che ogni giorno, grazie alla fervente attività dei maker, la board veste nuovi panni e recita parti sempre originali.

Nel calderone dei maker a volte ci mettiamo anche noi, che di Arduino non solo abbiamo fatto un alleato, ma anche il seme, la matrice su cui crescere e sviluppare nuove schede di prototipazione come le prestanti e irrinunciabili Fishino, ma anche la Business Card (biglietto da visita elettronico) proposta in questo post, che è il punto di partenza del progetto descritto in queste pagine.

Si tratta di uno speciale vaso con sottovaso, il tutto stampato in 3D con del PLA trasparente (utile a far passare la luce prodotta all’interno) ma non tradizionale, perché il sottovaso è “intelligente” e grazie a un sensore di umidità su breakout board verifica quanto è umida la terra della pianta contenuta nel vaso e quando rileva l’avvicinamento di una persona fa accendere un anello di LED Neopixel per generare una luce rotante la cui tonalità dipende da quanto la pianta ha bisogno di acqua.

Più esattamente, la luce prodotta è rossa quando la terra è secca, rossa intercalata a verde quando è un po’ umida, verde quando l’umidità è ottimale, blu-verde se c’è molta acqua e blu quando l’acqua è sin troppa (azzurro è, d’altra parte, il colore che associamo all’acqua).

Tutto questo viene ottenuto utilizzando come cervello una board Arduino, ma non una qualsiasi bensì la più sottile, che è l’hardware del biglietto da visita, il quale sostanzialmente è una Arduino Leonardo priva di header e dotata di cinque pulsanti, oltre che della connessione USB, utile ad alimentarla o a fornire alimentazione al resto dell’elettronica coinvolta.

Caratteristiche tecniche

  • Tensione di alimentazione: 5 Vcc
  • Assorbimento max: 500 mA
  • Rilevamento di presenza con P.I.R.
  • Igrometro con uscita analogica
  • Segnalazione con 60 LED Neopixel

Arduino Business Card: di cosa si tratta

Il circuito in questione è una scheda Arduino Leonardo con formato compatibile Arduino e connettori laterali (può quindi ospitare i connettori strip per supportare gli shield) più quello per l’ICSP, ma le manca sezione alimentazione Vin, quindi riceve 5V (sugli header non c’è quindi la Vin); la vedete nella Fig. 1. I 3,3 volt necessari alla logica degli eventuali shield e riportati sul contatto laterale 3V3, sono ricavati dai 5V dell’USB mediante un regolatore di tensione a bordo scheda.

Per ragioni di spazio non stiamo a riportare lo schema elettrico della scheda, che potete trovare, insieme alla descrizione completa, del post di presentazione.

Il cuore del circuito è il microcontrollore Atmel 32u4, lo stesso della Arduino Leonardo, che dispone internamente dell’interfaccia USB di tipo Device; questo micro è alimentato con i 5 volt dell’USB e ricava internamente 3 volt per la propria logica. Le linee per la programmazione in-circuit sono riportate sul connettore ICSP standard delle schede Arduino (2 file da 3 contatti, a passo 2,54 mm).

Come di consueto, la linea di reset (RST) viene utilizzata per avviare il caricamento dello sketch attraverso il bootloader e nello schema è collegata all’immancabile resistore di pull up e al pulsante che la porta a massa quando serve resettare il microcontrollore manualmente (il reset automatico viene gestito dal PC tramite la connessione USB).

Gli altri cinque pulsanti, collegati alle linee PD7, PC6, PD4, PD0 e PD1 (rispettivamente P1, P2, P3, P4, P5) permettono, se premuti, di attivare le funzioni loro assegnate dallo sketch, che potete personalizzare a piacimento.

I due LED presenti nel circuito vengono gestiti dal microcontrollore per segnalare l’avvio dello sketch, il caricamento e l’attività sull’USB; in quest’ultimo caso LD2 è il TX LED e LD1 l’RX LED di Arduino.

Inoltre LD1 (rosso) lampeggia quando, dopo il collegamento e il riconoscimento da parte del PC, la scheda avvia lo sketch ed è pronta all’uso. LD2 (giallo) lampeggia invece ogni volta che si preme uno dei tasti P1÷P5 per accedere alle rispettive funzioni. Il clock del micro è ottenuto dall’oscillatore interno, che si affida a un quarzo per ottenere la necessaria precisione.

Nel progetto, oltre alla scheda Arduino biglietto da visita vengono impiegati (trovare qui a fianco tutti i prodotti):
• un anello di LED Neopixel a 60 LED RGB comandato da Arduino tramite l’apposito bus di comunicazione;
• un sensore P.I.R. miniatura con uscita digitale dedicato al rilevamento delle persone e ad avvisare con un livello logico la nostra Arduino;
• un sensore (igrometro) su breakout board dotato di sonda a forchetta per rilevare l’umidità della terra attraverso la resistenza elettrica che essa assume a seconda che sia secca, umida o molto bagnata; sostanzialmente sfruttiamo la conducibilità dell’acqua comune, la quale contenendo dei sali in soluzione conduce elettricità.

Fig. 1 – Il biglietto da visita basato su Arduino.

Igrometro per il terreno

Il sensore di umidità è una breakout board con uscita sia a scatto, sia analogica, che interfacciato ad Arduino o altro microcontrollore permette di rilevare la percentuale di umidità del terreno, ad esempio per controllare un dispositivo di innaffiatura automatica; nel nostro caso è impiegato per influire sull’accensione dei LED Neopixel.

L’insieme è in realtà composto da una sonda realizzata su PCB e dalla breakout board basata sull’integrato LM393 (Fig. 2) che permette di rilevare la percentuale di umidità del terreno; quando questa è inferiore a un valore di soglia impostato, sull’uscita DO sarà presente un livello logico alto, mentre quando la percentuale supererà il valore di soglia, sull’uscita DO sarà presente un livello logico basso.

 

Fig. 2 – Il sensore a forchetta da conficcare nella terra da solo (sopra) e collegato alla relativa breakout board.

 

Il circuito sostanzialmente è composto da un comparatore di tensione (uno dei due contenuti nell’integrato LM393) e permette di svolgere due diverse funzioni quando rileva lo stesso evento; l’evento è l’abbassamento di resistenza tra i piedini + e – (ovvero A0 e GND), che in pratica corrisponde al contatto del sensore (a elettrodi a forchetta) con l’acqua contenuta nella terra, quando questa è continua e diffusa a sufficienza da unire i due elettrodi del sensore stesso.

Il comparatore funziona in modalità non-invertente, nel senso che riceve la tensione di riferimento sull’ingresso invertente (piedino 6) e quella da comparare sul non-invertente; inoltre non è retroazionato, perciò non ha isteresi, quindi la commutazione dell’uscita dal livello di tensione alto a quello basso avviene per lo spesso potenziale sull’ingresso non-invertente che determina il passaggio dal livello basso a quello alto.

Siccome la tensione di riferimento applicata al piedino 6 (ingresso invertente del comparatore) è ricavata da un trimmer montato a potenziometro, possiamo variare a piacimento, da 0 volt fino ad arrivare al potenziale di alimentazione, il riferimento e quindi giocare sulla sensibilità del circuito nel massimo campo ammesso.

L’uscita del comparatore può compiere la massima escursione possibile, sebbene, quando è a livello basso, non scende esattamente a zero volt (peculiarità, questa, degli operazionali rail-to-rail) ma si mantiene su poche centinaia di millivolt. L’uscita è inoltre di tipo open-collector, perciò per raggiungere il livello alto richiede una resistenza di pull-up, che nello specifico è integrata nel circuito.

Comunque nel nostro caso l’uscita digitale (a scatto) che fa capo al contatto DO non viene utilizzata, perché con Arduino andiamo a leggere la A0, che sostanzialmente fa capo ai contatti della sonda conficcata nella terra del vaso.Le caratteristiche del nostro igrometro sono le seguenti:
• sensibilità regolabile tramite trimmer;
• tensione di alimentazione: da 3,3V a 5V;
• uscite digitale e analogica;
• dimensioni modulo: 30×16 mm;

La piedinatura del modulo è la seguente:
1) VCC: da 3,3V a 5V
2) GND
3) DO: uscita digitale (0 e 1)
4) AO: uscita analogica.

Notate che per l’uscita digitale, collegata al comparatore, è possibile, con il trimmer, adattare la segnalazione al tipo di terra e di pianta che vogliamo monitorare, ricordando che più avviciniamo il cursore all’estremo di massa, più umido dev’essere il terreno per far accendere il LED e viceversa (il LED si spegne già prima che la terra sia un po’ secca).

Comunque nella nostra applicazione non utilizziamo tale funzione.

 

 

Il sensore a forchetta conficcato nella terra (foto in basso) deve rimanere fuori almeno per un centimetro prima del connettore di collegamento alla breakout board igrometro (che vedete nella foto sopra) altrimenti i contatti si bagnano e restano inumiditi, falsando la rilevazione.

 

Il sensore di movimento PIR

Passiamo adesso al sensore a infrarossi passivi che vedete nella Fig. 3 e che abbina un P.I.R. in miniatura a un’elettronica di controllo e con uscita da interfacciare ad un microcontrollore, come ad esempio Arduino.

Le specifiche tecniche del nostro radar a infrarossi passivi sono:
• tensione di alimentazione: da 3,3V a 15V;
• assorbimento a riposo: <50 µA;
• uscita: livello alto 3,3V/basso 0V;
• distanza di rilevamento: da 3 a 5 metri;
• angolo di rilevamento: circa 110° a meno di 4 metri;
• dimensioni (mm): 28×13 (lunghezza x diametro);
• Temperatura di funzionamento: da -20°C a +40°C

Fig. 3 – Il mini radar a infrarossi passivi (P.I.R.) impiegato per rilevare l’avvicinamento delle persone.

 

 

Quanto alla piedinatura del PCB del sensore, il contatto 1 è l’alimentazione positiva (Vcc) il 2 è l’uscita, mentre la massa e localizzata al 3; in pratica l’alimentazione si applica ai due estremi.
Inoltre il P.I.R. ha un ritardo di attivazione di 10 secondi da quando viene alimentato.

L’anello Neopixel

Passiamo adesso al visualizzatore che produce la luce rotante colorata, composto da un anello a tecnologia Neopixel con 60 diodi LED RGB che possono essere gestiti individualmente, ognuno dei quali può produrre 256 tonalità del proprio colore, determinando un totale di 16.777.216 colori.

Il canale dati per la comunicazione è seriale di tipo One-Wire e può essere controllato con microcontrollori come Arduino, PIC, mbed, ecc.

È possibile impostare a piacimento la frequenza di refresh, in modo da rendere impercettibili determinati giochi di luce.

Più anelli possono essere collegati in cascata per realizzare vari effetti. Per la gestione dell’anello la nostra Arduino in formato biglietto da visita si basa sull’apposita libreria NeoPixel.

Una particolarità dei LED Neopixel è che possono essere collegati in cascata in modo che la linea dati da uno passi al successivo, però il prezzo da pagare è che oltre un certo numero di LED, la velocità di gestione deve ridursi sensibilmente; a causa di ciò, se si devono realizzare matrici per mostrare della grafica veloce occorre impiegare molte linee con pochi LED ciascuna.

Neopixel è praticamente una soluzione che prevede l’integrazione di un driver e del rispettivo LED RGB in un case SMD, consentendo il comando diretto LED per LED. L’alimentazione prevista per i LED Neopixel è a 5 volt; la comunicazione avviene a un massimo di 800 kbps.

Il protocollo di controllo del sistema Neopixel prevede l’invio di gruppi di tre byte in una stringa di 24 bit, ognuna delle quali contiene lo stato di illuminazione di ciascun colore base (prima gli otto bit del verde, poi quelli del rosso e infine quelli del verde).

Le caratteristiche tecniche dell’anello Neopixel qui utilizzato sono:
• numero di LED: 60;
• tipo di LED: 5050;
• chip: WS2812B;
• alimentazione: 5 Vcc;
• diametro esterno: 158 mm;
• spessore: 3 mm.

Schema di cablaggio

 

Come funziona

Detto ciò, vediamo come funziona il nostro circuito: se tra i contatti + e – (ovvero tra A0 e GND) connettiamo il sensore a forchetta, composto da un circuito stampato di tale forma che ha due elettrodi incisi che arrivano fin quasi alle punte, che poi infiliamo nel terreno, l’umidità dello stesso determinerà tra i contatti predetti una certa resistenza che andrà a fare partitore con quella interna alla breakout board.

Il rapporto di partizione determinerà il potenziale applicato all’ingresso del comparatore, quindi a parità di tensione di riferimento fornita dal trimmer, più sarà umida la terra, minore sarà la tensione alla quale si verificherà la commutazione dell’uscita del comparatore.

Quest’ultima è a livello basso (il che fa illuminare il LED LD1) quando la terra è molto umida e la resistenza derivante è tale da tenere la tensione sul piedino 5 dell’U1b a un valore minore di quello applicato al pin 6 dal trimmer; nella stessa condizione si trova il contatto DO.

Invece quando la terra inizia a seccarsi, la percentuale d’acqua si riduce sensibilmente e la tensione tra A0 e GND cresce, fino a superare quella di riferimento del comparatore, provocando la commutazione dell’uscita dal livello basso a quello alto; ora il LED si spegne, il che ci indica che dobbiamo aggiungere acqua.

Il Firmware

Vediamo dunque il funzionamento del sistema, che è molto semplice, essendo tutto affidato ad Arduino: il firmware gira in loop attendendo che la linea digital I/O 2 rilevi il livello logico fornito dal mini P.I.R. quando esso rileva l’avvicinamento di una persona; in tale evenienza il tutto si attiva e il microcontrollore di Arduino va a leggere la tensione presente sull’input analogico A5, dedicato al sensore di umidità, la quale è direttamente proporzionale alla resistenza elettrica rilevata tra i contatti del sensore a forchetta piantato nella terra e quindi inversamente proporzionale alla quantità d’acqua presente nella terra stessa.

Il valore viene confrontato con le soglie impostate da firmware e a seconda dell’esito del confronto comanda l’accensione sequenziale dei LED Neopixel in modo da ottenere, giacché si tratta di diodi montati su un anello da 60 LED RGB, la luce rotante; il colore dipende appunto dall’esito del confronto, ovvero qual è il rapporto tra la tensione fornita dal sensore di umidità e le soglie impostate nello sketch.

Per l’esattezza, se la tensione corrisponde a molta umidità (bassa resistenza) la luce composta sui LED Neopixel è blu, mentre qualora coincida con la soglia di umidità intermedia (media resistenza) viene combinata la luce verde; infine, se la tensione corrisponde a scarsa umidità (terra secca o quasi) viene prodotta la luce rossa, che dovremo interpretare come un segnale d’allarme lanciato dalla nostra pianta “assetata”.

In realtà sono previste colorazioni intermedie ottenute alternando, nel cerchio luminoso di LED, quattro segmenti colorati, quindi abbiamo le seguenti combinazioni:
• terra secca = cerchio rotante di luce rossa;
• terra appena umida = cerchio rotante con rosso alternato al verde;
• terra con umidità ottimale = cerchio rotante a sola luce verde;
• terra con umidità più che ottimale = cerchio rotante diviso in luce verde e blu;
• terra troppo umida = cerchio rotante a sola luce blu.

Descriviamo lo sketch, che trovate per intero nel Listato 1; qui vedete che per prima cosa includiamo la libreria che provvede alla gestione dei LED Neopixel e all’implementazione del relativo protocollo di comunicazione seriale.

Poi si passa alla definizione dei pin di Arduino utilizzati, che sono:

#define PIXEL_PIN 9

che imposta il pin I/O digitale 9 come canale dati per inviare i comandi all’anello di LED Neopixel, sulla linea DI.
Poi abbiamo la definizione dell’ingresso analogico per leggere il sensore di umidità:

#define HUM_PIN A5
come vedete, è assegnato all’ingresso 5 dell’ADC di Arduino.

Infine abbiamo la definizione dell’input riservato alla lettura dello stato d’uscita del sensore di movimento a infrarossi passivi:

#define PIR_PIN 2

Altro dettaglio rilevante dello sketch è la definizione del numero di LED Neopixel presenti e da pilotare, che viene effettuata con l’istruzione seguente:

#define PIXEL_COUNT 60

Questo numero è importante perché su di esso Arduino imposta la velocità di trasmissione dei dati sul pin D9 per ottenere un refresh compatibile con la persistenza del nostro occhio, quindi sufficientemente veloce.

La comunicazione con l’anello di LED viene impostata inizialmente spegnendo tutti i LED e poi comandandoli in base alla lettura di A9.
Nel setup, per prima cosa si imposta la modalità del pin D9 che funzionerà da input:

pinMode(PIR_PIN, INPUT);

Viene anche inizializzata la seriale a 9.600 baud per stampare, se apriamo Serial Monitor, le condizioni di funzionamento.

Nel loop vediamo quindi l’assegnazione dell’input analogico A5 e la relativa lettura del sensore di umidità:

int humRAW=analogRead(HUM_PIN);

cui poi verrà correlata l’azione dopo il confronto con le soglie impostate.

La velocità di scorrimento dei LED Neopixel si imposta con l’istruzione:

rainbowCycle(5);
dove rainbowCycle è la funzione arcobaleno del Neopixel e 5 è il parametro che le viene passato per definire la velocità: variandolo, cambia la temporizzazione, ovvero diminuendo il numero la rotazione rallenta e viceversa.

Concludiamo con la porzione di codice che riguarda le soglie di umidità e le corrispondenti azioni sui LED Neopixel:

switch(hum){
case 1: strip.setPixelColor(i, Wheel1(((i * 256 / strip.numPixels()) + j) & 255));
break;
case 2: strip.setPixelColor(i, Wheel2(((i * 256 / strip.numPixels()) + j) & 255));
break;
case 3: strip.setPixelColor(i, Wheel3(((i * 256 / strip.numPixels()) + j) & 255));
break;
case 4: strip.setPixelColor(i, Wheel4(((i * 256 / strip.numPixels()) + j) & 255));
break;
case 5: strip.setPixelColor(i, Wheel5(((i * 256 / strip.numPixels()) + j) & 255));
break;
}

Listato1

#include <Adafruit_NeoPixel.h>

#define PIXEL_PIN 9 // Digital IO pin connected to the NeoPixels.
#define HUM_PIN A5
#define PIR_PIN 2
#define PIXEL_COUNT 60

// Parameter 1 = number of pixels in strip, neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
// NEO_RGB Pixels are wired for RGB bitstream
// NEO_GRB Pixels are wired for GRB bitstream, correct for neopixel stick
// NEO_KHZ400 400 KHz bitstream (e.g. FLORA pixels)
// NEO_KHZ800 800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 8;
int hum = 1;

void setup() {
  pinMode(PIR_PIN, INPUT);

  strip.begin();
  strip.show(); // Initialize all pixels to ‘off’
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  delay(2000);

  // prints title with ending line break
  Serial.println(“RGB vase by Boris”);
}

void loop() {
  int humRAW = analogRead(HUM_PIN);
  hum = map(humRAW, 390, 1000, 1, 5);
  Serial.print(“ValueRAW = “);
  Serial.print(humRAW);
  Serial.print(“Value = “);
  Serial.println(hum);
  int pirvalue = digitalRead(PIR_PIN);
  Serial.print(“PIR = “);
  Serial.println(pirvalue);
  if (pirvalue == 1) {
    rainbowCycle(5);
  } else {
    colorWipe(strip.Color(0, 0, 0), 50);
  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for (uint16_t i = 0; i & lt; strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for (j = 0; j & lt; 256 * 50; j++) { // 50 cycles of all colors on wheel
    for (i = 0; i & lt; strip.numPixels(); i++) {
      switch (hum) {
        //case 0: strip.setPixelColor(i, Wheel0(((i * 256 / strip.numPixels()) + j) & 255));
        // break;
      case 1:
        strip.setPixelColor(i, Wheel1(((i * 256 / strip.numPixels()) + j) & amp; 255));
        break;
      case 2:
        strip.setPixelColor(i, Wheel2(((i * 256 / strip.numPixels()) + j) & amp; 255));
        break;
      case 3:
        strip.setPixelColor(i, Wheel3(((i * 256 / strip.numPixels()) + j) & amp; 255));
        break;
      case 4:
        strip.setPixelColor(i, Wheel4(((i * 256 / strip.numPixels()) + j) & amp; 255));
        break;
      case 5:
        strip.setPixelColor(i, Wheel5(((i * 256 / strip.numPixels()) + j) & amp; 255));
        break;
      }
    }
    strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel1(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(0, 0, WheelPos * 3);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(0, 0, WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(0, 0, WheelPos * 3);
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
/*uint32_t Wheel1(byte WheelPos) {
WheelPos = 255 - WheelPos;
if(WheelPos < 85) {
return strip.Color(0, WheelPos * 3, WheelPos * 3);
}
if(WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(0, WheelPos * 3, WheelPos * 3);
}*/

uint32_t Wheel2(byte WheelPos) {
  //WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(0, 255 - WheelPos * 3, WheelPos * 3);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(0, 255 - WheelPos * 3, WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(0, 255 - WheelPos * 3, WheelPos * 3);
}

uint32_t Wheel3(byte WheelPos) {
  //WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(0, 255 - WheelPos * 3, 0);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(0, 255 - WheelPos * 3, 0);
  }
  WheelPos -= 170;
  return strip.Color(0, 255 - WheelPos * 3, 0);
}

uint32_t Wheel4(byte WheelPos) {
  //WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(255 - WheelPos * 3, WheelPos * 3, 0);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(255 - WheelPos * 3, WheelPos * 3, 0);
  }
  WheelPos -= 170;
  return strip.Color(255 - WheelPos * 3, WheelPos * 3, 0);
}

uint32_t Wheel5(byte WheelPos) {
  //WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    return strip.Color(255 - WheelPos * 3, 0, 0);
  }
  if (WheelPos & lt; 170) {
    WheelPos -= 85;
    return strip.Color(255 - WheelPos * 3, 0, 0);
  }
  WheelPos -= 170;
  return strip.Color(255 - WheelPos * 3, 0, 0);
}

Realizzazione pratica

Tutti i componenti e le board richiesti per la realizzazione del sistema sono reperibili già montati e collaudati presso la Futura Elettronica (qui a destra trovate tutti i componenti). Le parti devono essere interconnesse come mostrato nello schema di cablaggio visibile sopra, ricordando che il tutto potrà prendere posto nel sottovaso.

L’anello richiede un’alimentazione di soli 5 volt e quindi possiamo alimentarlo connettendolo tra i pin 5V e GND di Arduino. Notate che la confezione comprende 4 archi da 15 LED, che devono essere saldati tra loro per creare il cerchio da 60 LED.

Completato il montaggio e verificato che sia tutto a posto potete connettere il circuito al programmatore e caricare il bootloader, quindi effettuare la connessione al PC via USB e caricare lo sketch.

Se acquistate la scheda in versione già montata, trovate già il bootloader nel microcontrollore e dovete solo caricare lo sketch dal PC, mediante l’IDE Arduino, indicando come scheda Arduino Leonardo.

Ora Arduino B-card è pronta per l’uso e dovete solo caricarvi lo sketch. Per quanto riguarda il vaso, quello da noi utilizzato nel prototipo e che vedete nelle foto in queste pagine è stato stampato in 3D con del PLA trasparente, utilizzando la nostra stampante 3D4040, l’unica capace di effettuare una stampa delle dimensioni richieste: infatti può produrre oggetti delle dimensioni massima di 40x40x40 centimetri!

Per il vaso (che è forato alla base come tutti quelli per giardinaggio) abbiamo previsto un sottovaso specifico fatto per accogliere la base del vaso e contenere l’elettronica del caso, in un vano separato da quello dove stazionerà l’acqua in eccesso drenata dalla terra ma raggiungibile dall’esterno per inserire nella presa microUSB della Arduino B-Card lo spinotto di un alimentatore da rete con uscita a 5V formato micro USB.

L’anello Neopixel va posto nel sottovaso incastrandolo nell’apposita sede: quindi è il sottovaso che fa il gioco di luci e la luce si propaga attraverso il vaso in PLA trasparente; il sensore P.I.R. va collocato preferibilmente sul bordo del vaso o anche del sottovaso, montato in un piccolo involucro a forcella che ne facilita il posizionamento e il fissaggio.

Bene, con questo è tutto; non ci resta che augurarvi buon divertimento con il vostro nuovo vaso smart!

 

Download File STL

 

La colorazione della luce alla base del vaso cambia da rossa a verde, fino al blu, quando si annaffia la terra.

2 Commenti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Menu