Albero di Natale “Camaleonte”

Due differenti approcci per realizzare un gadget natalizio che prende il colore del piano cui si appoggia. รˆ lโ€™occasione per vedere la differenza tra lo sviluppo di un progetto โ€œamatorialeโ€ e di un prodotto โ€œcommercialeโ€.

Spesso, in redazione nascono discussioni โ€œspontaneeโ€ sul modo di affrontare i progetti che vengono poi presentati sulla rivista; uno dei temi principali รจ quale approccio utilizzare in un progetto: orientarsi verso un circuito a componenti discreti, o usare uno o piรน integrati, oppure affidarsi a un microcontrollore e, nel caso, quale.

Chiaramente le soluzioni possono essere piรน di una e sono spesso legate alla formazione e allโ€™esperienza dei singoli progettisti. E questi sono anche i motivi per i quali le discussioni diventano โ€œacceseโ€.

La situazione descritta si รจ puntualmente presentata durante la decisione su cosa presentare come โ€œprogetto di Nataleโ€: alla fine si รจ concordato di proporre una lampada a LED in grado di assumere il colore della superficie sulla quale viene appoggiata e da inserire in un albero di Natale cavo. A questo punto si รจ posta lโ€™inevitabile serie di domande: quale lampada, come riconoscere i colori, come riprodurli?

Abbiamo perciรฒ deciso di valutare due differenti approcci e descriverli in questo articolo per farvi vedere come si puรฒ sviluppare un progetto partendo dalla concezione iniziale, passando dalla progettazione e realizzazione in forma prototipale, per giungere poi alla definizione di un prodotto finale da produrre in serie.

Nello specifico, per lโ€™elettronica abbiamo contrapposto una realizzazione basata su Arduino ad una realizzata da zero con una scheda e un microcontrollore specifico; la prima รจ lโ€™ideale per sviluppare un prototipo, ma per costo e ingombri รจ inadatta a una produzione di serie, dove invece scegliere lโ€™hardware fornisce la soluzione migliore.

Lโ€™approccio al progetto

Lo schema di massima del processo di progettazione e ingegnerizzazione di un prodotto รจ mostrato in Fig. 1: si parte dallโ€™ipotesi iniziale, nel nostro caso la volontร  di realizzare la nostra lampada di Natale in grado di emettere luce dello stesso colore della superficie sulla quale viene appoggiata. Il primo passo che porta da una semplice idea ad unโ€™ipotesi di progetto รจ la definizione delle funzionalitร , la scelta dei componenti e, in questo caso, anche unโ€™ipotesi di design.

Fig. 1

 

Il processo prevede una prima fase dedicata alla scelta dei componenti, per quanto riguarda la realizzazione elettronica, e alla definizione dellโ€™aspetto estetico, per quel che concerne il corpo esterno della lampada. Sulla base delle prime scelte si realizza un primo prototipo da valutare e migliorare fino a giungere ad una versione adatta ad essere replicata in produzione.

La decisione (o, meglio, lโ€™obbligo, detto anche โ€œvincolo di progettoโ€) รจ stata di realizzare la lampada con il processo di stampa 3D, in modo da ottenere un oggetto molto simile per aspetto e consistenza a quello che sarebbe risultato il prodotto definitivo. La forma iniziale sarร  quella di un albero a tre dimensioni che ricordi quello di Natale.

Ora pensiamo alla funzionalitร  della lampada, che consiste nel rilevare il colore della superficie sottostante la base e la sua riproduzione come tonalitร  di luce.

Giร  questo introduce un ulteriore vincolo: il corpo della lampada deve essere di materiale traslucido e di un colore che non interferisca con la tonalitร  di luce emessa, in modo da non falsare i colori. In pratica il bianco รจ dโ€™obbligo.

Per semplificare lo sviluppo del progetto ci conviene suddividere lโ€™intero problema in parti piรน piccole e, per cosรฌ dire, monofunzione, quelli che comunemente vengono chiamati โ€œmoduliโ€: un โ€œmodulo sensoreโ€ in grado di riconoscere il colore della superficie di appoggio della lampada, un โ€œmodulo di elaborazioneโ€ in grado di comprendere il segnale in uscita dal โ€œsensoreโ€ ed elaborarlo per produrre in uscita un โ€œqualcosaโ€ in grado di pilotare una sorgente luminosa โ€œprogrammabileโ€ e, infine, un โ€œmodulo luceโ€ in grado di riprodurre una tonalitร  luminosa a fronte di un input predefinito.

Definite le funzionalitร  dei singoli โ€œmoduliโ€ o โ€œstadiโ€ come si diceva una volta, per ciascuno รจ necessario decidere quale tecnologia adottare e la conseguente โ€œingegnerizzazioneโ€.

Per il modulo di riconoscimento del colore si presentano diverse alternative: possiamo utilizzare una telecamera e poi elaborare le immagini acquisite per estrapolare il colore predominante, ma tale soluzione richiede un hardware con una potenza di elaborazione abbastanza significativa. Ma sarebbe come utilizzare un cannone per andare a caccia di zanzare.

Potremmo allora ipotizzare la costruzione di un sensore utilizzando componenti discreti, sensori di luce, e diodi multicolori da interfacciare ad una logica di elaborazione e controllo: una soluzione giร  piรน adatta, ma ancora troppo complicata da realizzare e mettere a punto.

Una terza scelta รจ di adottare un criterio che sta avendo sempre piรน seguito: andare alla ricerca, sul mercato, di moduli preconfezionati che svolgano le funzioni di cui abbiamo bisogno.

Lo stesso criterio che adottiamo quando realizziamo i nostri progetti in GNU/Linux: ricerca della maggior quantitร  di โ€œmattoniโ€ disponibili nel โ€œmondoโ€ e la realizzazione delle sole integrazioni tra le diverse parti. Questa ricerca sarร  maggiormente fruttuosa quanto piรน siamo stati accurati nella scomposizione del problema in moduli.

Cerca che ti cerca, abbiamo trovato il TCS230, un modulo con sensore di riconoscimento dei colori prodotto da LC Technology.

Per riprodurre la tonalitร  di luce rilevata con il sensore, la scelta รจ molto semplice: un LED RGB andrร  benissimo in fase di prototipo e ci apre la strada a diverse scelte in fase di prodotto finale, in quanto il pilotaggio RGB si applica ad una vasta gamma di prodotti di produzione di luce, reperibili sul mercato in una varietร  di forme, dimensioni, potenze e prezzi.

Ne consegue la definizione della funzione principale del โ€œmodulo di elaborazioneโ€: applicare ai piedini che pilotano ciascun colore un segnale PWM proporzionale alla intensitร  della corrispondente componente di colore rilevata dal sensore.

Ci resta da scegliere cosa usare come โ€œmodulo di elaborazioneโ€: per un oggetto monofunzione, con molta probabilitร  la scelta giusta รจ utilizzare un microcontrollore con unโ€™adeguata dotazione di pin di ingresso/uscita sia analogici che digitali.

Le prestazioni non sono molto importanti, in quanto una lampada รจ un oggetto statico: una volta appoggiata su una superficie se ne sta lรฌ fino a quando qualcuno non la sposta, giusto per vedere se cambia colore.

Per intenderci, la nostra applicazione non richiede una soluzione real time basata su FPGA con tempi di campionamento dellโ€™ordine dei nanosecondi: un microcontrollore economico รจ piรน che sufficiente per le esigenze di questo progetto.

Per un primo prototipo la scelta รจ facile: basta allungare la mano sulla scrivania e utilizzare lโ€™onnipresente Arduino Uno. La sua vocazione รจ proprio quella di rendere semplice e veloce la realizzazione di prototipi โ€ฆ funzionanti.

Lโ€™IDE e il linguaggio di sviluppo sono stati messi a punto con il preciso obiettivo di essere accessibili a tutti. Abbiamo tutto per realizzare il nostro prototipo.

Per il prodotto finale dovremo sostituire Arduino Uno con una soluzione piรน adatta ad una produzione in serie, cosรฌ come probabilmente per il LED RGB, ma ce ne preoccuperemo a tempo debito.

Arduino Uno รจ giร  stato oggetto di numerosi libri e articoli sulla rivista, quindi rimandiamo a questi per chi giร  non ne conosce a sufficienza lโ€™utilizzo. Ci concentriamo invece sulle caratteristiche del modulo TCS230 e sullโ€™utilizzo dei LED RGB.

Il modulo TCS230

Il modulo TCS230 non รจ altro che una breakout board con a bordo il sensore TCS230, un convertitore programmabile che permette di trasformare la luce in ingresso in una frequenza proporzionale allโ€™intensitร  della luce percepita.

Il circuito integrato in tecnologia CMOS comprende una matrice di 8×8 fotodiodi ed un convertitore corrente-frequenza secondo lo schema a blocchi visibile in Fig. 2.

Nel sensore sono presenti tre filtri di colore R, G e B (guarda caso) e la misura delle componenti di colore consiste in una prima misura dellโ€™intensitร  della luce composta (senza filtri) e nel misurare successivamente le intensitร  relative a ciascun colore applicando i filtri uno alla volta.

In Fig. 3 รจ visibile la pin-out dellโ€™integrato, mentre nella Tabella 1 sono descritti i significati dei singoli pin. I pin del modulo TCS230 trovano corrispondenza uno a uno con i pin dellโ€™integrato, come visibile nella Fig. 4.

Fig. 2

Fig. 3

 

Tabella 1

 

Fig. 4

 

I diodi presenti sul modulo sono alimentati in parallelo e servono ad โ€œilluminareโ€ il campo di โ€œvisioneโ€ del sensore.

Il modulo puรฒ essere alimentato con tensioni da 2,7V a 5,5V ed รจ quindi compatibile con i livelli dei microcontrollori alimentati sia a 3,3V che a 5V.

Il convertitore TCS230 legge i fotodiodi che compongono la matrice. In base alla configurazione dei pin di controllo S2 ed S3 (vedi Tabella 2) la matrice di diodi filtra la luce rossa, verde, blu o bianca ed emette in uscita sul pin OUT un segnale ad onda quadra con duty-cycle del 50% e frequenza direttamente proporzionale allโ€™intensitร  della luce percepita (irradianza).

Il funzionamento del sensore sfrutta il fatto che le differenti sfumature di colore possono essere ricondotte ad una combinazione dei tre colori fondamentali, rosso, verde e blu, in proporzioni appropriate (Fig. 5).

Quando viene impostato il filtro per un determinato colore predominate, ad esempio il blu, lโ€™integrato TCS230 misura la sola intensitร  del colore esaminato, escludendo gli altri; in questo modo รจ possibile determinare la componente blu del colore in esame. Stesso procedimento per determinare lโ€™intensitร  delle componenti rossa e verde.

Lโ€™ampiezza dello spettro di frequenza emessa puรฒ essere scalata dei fattori espressi in Tabella 3 configurando opportunamente i livelli dei pin S0 ed S1, in modo da potersi adattare alle capacitร  di elaborazione del microcontrollore utilizzato.

Gli ingressi e le uscite possono essere interfacciati ad un microcontrollore per la configurazione e la lettura dei valori di frequenza, cosa che noi faremo con il nostro Arduino Uno.

Tabella 2

Fig. 5

Tabella 3

Il LED RGB

Per riprodurre la tonalitร  di colore recepite dal sensore, utilizziamo un LED RGB, almeno nel nostro prototipo, ovvero un dispositivo optoelettronico composto da tre LED che emettono rispettivamente luce Rossa, Blu e Verde (Fig. 6).

Esistono due tipologie di questi componenti: ad anodo comune e a catodo comune. Nel primo, tutti i LED hanno lโ€˜anodo, ovvero il terminale positivo in comune, mentre i tre LED vengono comandati singolarmente pilotando il catodo di ciascuno.

Nei componenti a catodo comune, i tre LED condividono il terminale negativo, mentre il pilotaggio di ciascun singolo LED avviene utilizzando lโ€™anodo, ovvero il terminale positivo. Una configurazione, questa, piรน adatta ad essere utilizzata con Arduino Uno.

Infatti per pilotare i LED utilizzeremo tre uscite analogiche (DAC) di Arduino Uno, in grado di convertire le grandezze digitali tra 0 e 255 in valori di tensione proporzionali tra 0 e +5V.

Ciascuna sfumatura di colore, nella rappresentazione RGB ad otto bit di precisione, รจ rappresentata da una terna di valori nellโ€™intervallo 0-255 che rispecchia lโ€™intensitร  di ciascuna componente di colore. Per esempio, il rosso intenso รจ rappresentato dalla configurazione (255, 0, 0).
Sul web, allโ€™indirizzo di RapidTables potete trovare una tabella interattiva nella quale, inserendo i valori delle tre tonalitร  di colore base, vedrete a cosa corrispondono in RGB.

Vale la pena sottolineare una particolaritร  relativa ai toni di grigio: chi si รจ occupato di elaborazione di immagini, sa che i toni di grigio sono espressi da terne di valori RGB uguali, per esempio (150, 150, 150). Non essendo possibile riprodurre, con il nostro LED, le tonalitร  di grigio, faremo in modo che in queste condizioni il LED emetta luce bianca. Il LED RGB scelto per il nostro prototipo รจ siglato 540R2GBC-CC.

Fig. 6

Strategia di elaborazione

La strategia di elaborazione per il microcontrollore del progetto รจ visibile nel diagramma a blocchi di Fig. 7: dopo le definizioni iniziali dellโ€™ambiente di elaborazione, allโ€™accensione del microcontrollore viene innescato il ciclo di elaborazione principale, che esegue allโ€™infinito le operazioni descritte qui di seguito.

Come prima operazione, tentiamo di verificare se la lampada รจ effettivamente appoggiata ad una superficie, oppure la stiamo tenendo sollevata, eventualmente per spostarla da un luogo ad un altro; in questo caso sospendiamo la funzione di โ€œmimetismoโ€ saltando tutto il processo di elaborazione successivo.

Se verifichiamo che la lampada รจ appoggiata ad una superficie, dobbiamo operare sul sensore in modo da riconoscere la tonalitร  di colore della superficie di appoggio.

Per ottenere questo risultato, eseguiamo una serie di letture della frequenza di uscita, la quale, come abbiamo giร  visto, รจ proporzionale allโ€™intensitร  della componente luminosa, modificando di volta in volta la configurazione dei filtri.

La prima lettura viene eseguita in assenza di filtri, in modo da ottenere la luminositร  totale riflessa dalla superficie. Eseguiamo le successive letture inserendo ogni volta un filtro diverso, rispettivamente il filtro per il colore rosso, il verde e il blu.

Dopo ogni lettura siamo in grado di determinare quanto la componente del colore selezionato รจ presente nella tonalitร  complessiva, in termini percentuali.

Al termine delle letture prendiamo il valore maggiore tra quelli letti e gli assegniamo il livello 255 per poi rapportare gli altri due in modo proporzionale, con alcuni aggiustamenti che abbiamo trovato sperimentalmente sulla base del comportamento del sensore, come descritto nel datasheet.

La terna di valori ottenuti รจ utilizzata per configurare le tre uscite PWM che pilotano i terminali positivi del LED RGB.

Fig. 7

Schema elettrico del prototipo con sensore di colore

Fig. 8

Nello schema in Fig. 8 possiamo vedere i collegamenti tra il sensore TCS230, la scheda Arduino Uno e il LED RGB.

Fig. 9

 

Lโ€™assemblaggio, in puro stile โ€œprototipoโ€, รจ visibile in Fig. 9.

I terminali S0 ed S1, che servono a configurare il range di frequenza della tensione emessa dallโ€™uscita del sensore TCS230, sono collegati ai pin 2 e 3 di Arduino.

Le uscite S2 ed S3 che permettono di definire se e/o quale filtro utilizzare nella lettura delle intensitร  luminose, sono collegati rispettivamente alle uscite digitali 6 e 5.

Il terminale di uscita del sensore TCS230 รจ collegato allโ€™ingresso 4 di Arduino.

Infine, i tre terminali del LED RGB sono collegati alle uscite PWM di Arduino 9 (R), 10 (G) e 11 (B). Le uscite PWM sono quelle identificate con un โ€œ-โ€œ sulla serigrafia della scheda.

Abbiamo usato le tre uscite citate, in quanto sono caratterizzare dallo stesso intervallo di frequenza del segnale PWM; se avessimo scelto altri pin, avremmo potuto riscontrare un funzionamento anomalo in quanto i pin 5 e 6 hanno frequenza di uscita di 976 Hz mentre gli altri pin (3, 9, 10 e 11) hanno frequenza di uscita di 488 Hz.

Per evitare sorprese e anomalie di funzionamento difficilmente individuabili, quando si affronta un progetto รจ sempre opportuno leggere i data-sheet e la documentazione dei componenti coinvolti.

Nel nostro caso, abbiamo collegato i terminali del LED RGB a tre uscite PWM caratterizzate dalla stessa frequenza.

Le tre resistente da 470 ohm limitano la corrente in ingresso ai terminali di uscita a circa 20 mA.

Sketch per Arduino Uno per la lampada cambiacolore

Lo sketch nel Listato 1 permette di gestire la logica della nostra lampada, ovvero il processo di riconoscimento del colore della base di appoggio e la sua riproduzione come tonalitร  luminosa del LED RGB.

Lavorando a livello di prototipo con uno strumento semplice come Arduino, possiamo introdurre nel codice una serie di istruzioni utili ai fini del debug che poi elimineremo in fase di realizzazione del prodotto finale.

Nel nostro caso utilizzeremo il Monitor Seriale per evidenziare i valori letti ed i risultati dei calcoli eseguiti.

La costante isPresentTolerance permette di impostare un valore di soglia per verificare se la lampada รจ appoggiata o meno su una superficie.

Abbiamo usato lโ€™accorgimento di eseguire una lettura con i LED di illuminazione accesi ed una con i LED spenti; per accendere e spegnere i LED, si configurano opportunamente i pin S0 ed S1.

Nel caso di lampada appoggiata su una superficie, avremo due valori molto diversi, mentre nel caso di lampada โ€œsospesaโ€ la luce ambiente raggiungerร  comunque il sensore, fornendo due letture con valori piรน vicini.

Se la lampada รจ appoggiata ad una superficie, si misura lโ€™intensitร  totale della luce riflessa e le intensitร  relative delle singole componenti di colore, applicando a ciascuna lettura i filtri opportuni mediante la configurazione dei pin S2 ed S3 del sensore TCS230.

Lโ€™intensitร  relativa di ciascuna componente viene calcolata in rapporto allโ€™intensitร  del colore complessivo, letto senza la presenza di alcun filtro.

Per leggere la frequenza emessa in corrispondenza dellโ€™applicazione di ciascun filtro viene utilizzata lโ€™istruzione โ€œpulseInโ€, che legge la lunghezza di un impulso su uno specifico pin.

Lโ€™istruzione puรฒ essere configurata per leggere la durata dellโ€™impulso nel livello LOW o nel livello HIGH: nel nostro caso, LOW.

In questa evenienza lโ€™istruzione attende che il livello del pin assuma il valore LOW, poi inizia la misurazione del tempo fino a quando il livello torna HIGH, interrompendo la misurazione. Il risultato della lettura รจ in microsecondi. Il formato dellโ€™istruzione รจ:

pulseIn(pin, value, timeout)

dove pin รจ il riferimento del pin per il quale si vuole leggere lโ€™impulso (int), value il livello dellโ€™impulso da leggere HIGH o LOW.

(int) e timeout (opzionale) corrisponde al numero di microsecondi entro i quali deve essere rilevato un impulso. Il valore predefinito รจ di un secondo (unsigned long).

Se entro il timeout non viene rilevato alcun impulso, viene prodotto come risultato il valore 0.

Lโ€™istruzione โ€œpulseinโ€ funziona per impulsi della durata tra 10 microsecondi e tre minuti, anche se per impulsi particolarmente lunghi possono verificarsi errori nelle letture.

La logica di riconoscimento del colore richiede una prima lettura in assenza di filtri, condizione che si ottiene impostando i pin S2 ed S3 rispettivamente a livello alto e basso, come specificato in Tabella 3.

Viene letto il valore presente sul pin OUT e, in sequenza, vengono impostati i filtri corrispondenti ai tre colori base e letti i valori delle relative intensitร , rapportati al valore dellโ€™intensitร  complessiva (Valore Intensitร  Totale/Valore Intensitร  Colore).

Per confronto e selezione dellโ€™intensitร  relativa piรน alta, viene poi calcolato il colore predominante al quale viene assegnato il valore di pilotaggio del PWM uguale a 255.

I valori di pilotaggio dei PWM per gli altri colori vengono calcolati in proporzione tra il valore letto per il colore in esame ed il valore del colore predominante rapportato a 255.

Come ultima operazione, i valori PWM calcolati vengono utilizzati per pilotare i rispettivi pin collegati ai terminali del LED RGB.

Lo sketch del Listato 1 puรฒ essere scaricato dal sito www.elettronicain.it.

Per eseguirlo, aprite lโ€™IDE di Arduino e copiate lo sketch nellโ€™editor dellโ€™IDE. Collegate Arduino Uno al PC con lโ€™apposito cavo USB, impostate la porta COM e la scheda come indicato in precedenza, compilate ed eseguite lโ€™upload dello sketch nel microcontrollore.

Aprite il Monitor Seriale: posizionate il sensore su oggetti o su fogli di carta di colore diversi e divertitevi a verificarne il funzionamento (Fig. 10).

Ora andiamo a vedere se la nostra stampante 3D ha terminato di realizzare lโ€™alberello che rappresenta lโ€™involucro della lampada.

Assembliamo il tutto e andiamo in giro a raccogliere i commenti sul nostro prototipo: nel mondo professionale, questa attivitร  si chiama test di mercato.

Listato 1

/*
Sketch lampada di Natale
*/
int S0 = 2; // pin controllo frequenza di output
int S1 = 3; // pin controllo frequenza di output
int S2 = 6; // pin controllo filtri colore
int S3 = 5; // pin controllo filtri colore
int taosOutPin = 4; // pin uscita frequenza
int LED = 13; // pinD
int R = 9; // PWM colore rosso
int G = 10; // PWM colore verde
int B = 11; // PWM colore Blu
double Coeff = 0;
int Ro = 0; // p inE
int Go = 0; // pinE
int Bo = 0; // pinE

void setup() {
TCS230setup();
Serial.begin(115200);
Serial.print(โ€œ\n\n\nready\n\n\nโ€);
pinMode(R,OUTPUT); //S2 pinE
pinMode(G,OUTPUT); //S2 pinE 
pinMode(B,OUTPUT); //S2 pinE 
delay(100);
}
void loop() {
Serial.print(detectColor(taosOutPin)); // impostazione seriale per debug
Serial.print(โ€œ\n\n\nโ€);
delay(1000);
}
int detectColor(int taosOutPin){
// controllo presenza superficie
double isPresentTolerance = 5;
double isPresent = colorRead(taosOutPin,0,0)/colorRead(taosOutPin,0,1);
Serial.print(โ€œisPresent:โ€);
Serial.println(isPresent,2);
Serial.print(โ€œvalore isPresentTolerance:โ€);
Serial.println(isPresentTolerance,2);
if(isPresent < isPresentTolerance){
Serial.println(โ€œnessuna superficie rilevataโ€);
return 0;
}
double red,blue,green;
// lettura intensita della luce (senza filtri) 
double white = colorRead(taosOutPin,0,1);
// lettura intensita componente rossa
red = white/colorRead(taosOutPin,1,1);
// lettura intensita componente blu
blue = white/colorRead(taosOutPin,2,1);
// lettura intensita componente verde
green = white/colorRead(taosOutPin,3,1);
Serial.print(โ€œredโ€);
Serial.println(red);
Serial.print(โ€œblueโ€);
Serial.println(blue);
Serial.print(โ€œgreenโ€);
Serial.println(green);

if(red > blue && red > green){
Coeff = 255 / red;
Ro = 255;
Go = green * Coeff;
Bo = blue * Coeff;
LED_RGB(Ro, Go, Bo);
return 1;
}
if(blue > green && blue > red){
Coeff = 255 / blue;
Bo = 255;
Go = green * Coeff;
Ro = red * Coeff;
LED_RGB(Ro, Go, Bo);
return 2;
}
if(green > blue && green > red){
Coeff = 255 / green;
Go = 255;
Ro = red * Coeff;
Bo = blue * Coeff;
LED_RGB(Ro, Go, Bo);
return 3;
}
}

double colorRead(int taosOutPin, int color, boolean LEDstate){
//make sure that the pin is set to input

pinMode(taosOutPin, INPUT);

taosMode(1);
int sensorDelay = 3;
//imposta i pin per selezionare i filtri
if(color == 0){// bianco (no filtri)
digitalWrite(S3, LOW); //S3
digitalWrite(S2, HIGH); //S2
// Serial.print(โ€œ wโ€);
}else if(color == 1){// attiva filtro rosso
digitalWrite(S3, LOW); //S3
digitalWrite(S2, LOW); //S2
// Serial.print(โ€œ rโ€);
}else if(color == 2){// attiva filtro blu
digitalWrite(S3, HIGH); //S3
digitalWrite(S2, LOW); //S2
// Serial.print(โ€œ bโ€);
}else if(color == 3){// attiva filtro verde
digitalWrite(S3, HIGH); //S3
digitalWrite(S2, HIGH); //S2
// Serial.print(โ€œ gโ€);
}
double readPulse;
if(LEDstate == 0){
taosMode(0); 
// digitalWrite(LED, LOW);
}
if(LEDstate == 1){
taosMode(1);
// digitalWrite(LED, HIGH);
}
delay(sensorDelay);
readPulse = pulseIn(taosOutPin, LOW, 80000);
// gestione timeout della lettura impulso
if(readPulse < .1){
readPulse = 80000;
}
// spegne i LED del sensore
taosMode(0);
return readPulse;
}
// gestione modalita emissione frequenza. TaosMode(0);
// zero sensore in quiete

void taosMode(int mode){
if(mode == 0){
//power OFF
digitalWrite(LED, LOW);
digitalWrite(S0, LOW); //S0
digitalWrite(S1, LOW); //S1
// Serial.println(โ€œmOFFmโ€);
}else if(mode == 1){
// frequenza 1:1
digitalWrite(S0, HIGH); //S0
digitalWrite(S1, HIGH); //S1
// Serial.println(โ€œm1:1mโ€);
}else if(mode == 2){
// frequenza 1:5
digitalWrite(S0, HIGH); //S0
digitalWrite(S1, LOW); //S1
//Serial.println(โ€œm1:5mโ€);
}else if(mode == 3){
// frequenza 1:50
digitalWrite(S0, LOW); //S0
digitalWrite(S1, HIGH); //S1
//Serial.println(โ€œm1:50mโ€);
}
return;
}

void LED_RGB(int Rx, int Gx, int Bx){
analogWrite(R, Rx);
analogWrite(G, Gx);
analogWrite(B, Bx);
return;
}

void TCS230setup(){
// inizializza pin gestione frequenza
pinMode(LED,OUTPUT); 
// pin di selezione dei filtri colore
pinMode(S2,OUTPUT); //S2 
pinMode(S3,OUTPUT); //s3 
// pin di uscita conversione luce-frequenza
pinMode(taosOutPin, INPUT); 
// pin selezione modo frequenza di uscita
pinMode(S0,OUTPUT); //S0 pinB
pinMode(S1,OUTPUT); //S1 pinA
return;
}

Fig. 10

Schema elettrico dell’albero di Natale con sensore colore

Piano di montaggio

Elenco componenti

R1: 1 kohm
R2: 1 kohm
R3: 1 kohm
R4: 100 ohm
R5: 100 ohm
R6: 100 ohm
C1: 100 nF multistrato
C2: 100 ยตF 25 VL elettrolitico
C3: 100 nF multistrato
C4: 100 ยตF 25 VL elettrolitico
U1: PIC16F1827-I/P (MF1170)
U2: 7805
U3: Brackout Board TCS230
D1: 1N4007
Q1: BS170
Q2: BS170
Q3: BS170
LD1: LEDRGB1W

Varie:
- Plug alimentazione
- Zoccolo 9+9
- Strip femmina 4 poli (2 pz.)
- Vite 3MA 6mm (4 pz.)
- Torretta F/F 23mm (4 PZ.)
- Circuito stampato

Ingegnerizzazione del prodotto

Una volta che il prototipo รจ stato โ€œapprovatoโ€, il che, come รจ capitato anche a noi, puรฒ richiedere diverse modifiche delle specifiche e rivisitazioni di soluzioni soprattutto estetiche, dobbiamo iniziare a pensare a produrne una versione โ€œcommercialeโ€.

Non possiamo certo mantenere lo schema a fili volanti ed Arduino Uno รจ decisamente troppo ingombrante e costoso per un prodotto di questo tipo. Dunque dobbiamo operare delle scelte con lโ€™obiettivo di:
โ€ข sostituire Arduino con un microcontrollore piรน economico e di ridotte dimensioni; la scheda Arduino Uno รจ sovrabbondante per un utilizzo in produzione e richiederebbe comunque la realizzazione di uno shield collegato con dei pin-strip, con ingombri e costi che posizionerebbero il nostro prodotto fuori mercato ancor prima di produrlo;
โ€ข realizzare un circuito stampato che si adatti alla disposizione dei componenti, ovvero il sensore verso il basso e il o i LED RGB verso il centro della lampada, e che si adatti ad essere alloggiato allโ€™interno della lampada stessa;
โ€ข proteggere il codice in modo che non sia facilmente replicabile da chi volesse copiare il progetto per un uso commerciale;
โ€ข realizzare il tutto in modo che sia facilmente gestibile a chi dovrร  occuparsi di assemblaggi, montaggio, gestione a magazzino e spedizione.

Per la lampada, anche qui dipende dal numero di pezzi da ottenere: con la stampante 3D possono essere realizzati prototipi e piccole serie, mentre per la produzione di massa รจ probabilmente meglio rivolgersi a stampatori con impianti a iniezione; in questo caso la produzione deve prevedere volumi veramente grandi, per ammortizzare il costo di allestimento degli stampi e dellโ€™attrezzaggio delle macchine di produzione.

Quanto al microcontrollore, avremmo potuto scegliere un micro Atmel compatibile con il codice scritto per il prototipo, per poi compilarlo e caricarlo sul micro stesso con una tecnica che non richieda il bootloader, come ampiamente descritto nel libro โ€œArduino e le Tecniche di programmazione dei microcontrollori Atmelโ€.

Invece abbiamo preferito una soluzione โ€œscomodaโ€ ma che viene adottata molto spesso in questo tipo di realizzazioni: siamo โ€œandati a cadereโ€ su un microcontrollore ultraeconomico della Microchip, e precisamente il PIC16F1827.

Definiamo la scelta โ€œscomodaโ€ perchรฉ dobbiamo riscrivere o meglio โ€œportareโ€ il codice scritto per Arduino UNO in una forma utilizzabile per il micro PIC16F1827.

I motivi per cui abbiamo scelto un prodotto Microchip e in special modo questo micro, sono i seguenti:
โ€ข ha un costo contenuto;
โ€ข รจ disponibile sia in contenitore PDIP che SMD;
โ€ข รจ dotato di clock interno, il che ci evita il ricorso a quarzi e componenti aggiuntivi, con il conseguente ulteriore contenimento dei costi;
โ€ข presenta consumi ridotti;
โ€ข dispone di 15 pin di I/O, ciascuno in grado di pilotare un LED;
โ€ข ha un numero di pin PWM (4) sufficienti per i nostri scopi;
โ€ข presenta compatibilitร  pin to pin con micro della stessa famiglia con piรน funzionalitร .

Come ulteriore โ€œingegnerizzazioneโ€ di prodotto, abbiamo sostituito il LED RGB con uno piรน potente e con una gestione migliore della luce prodotta, anche se questo ha comportato la necessitร  di pilotare ciascun โ€œcoloreโ€ con un circuito di potenza basato su un transistor MOSFET.

Il risultato finale รจ visibile nello schema elettrico qui sotto (notate che il LED RGB รจ composto dai diodi LD1r, LD1g, Ld1b). Possiamo vedere, con riferimento anche al Listato 2, le assegnazioni dei pin del microcontrollore Microchip PIC16F1827.

Nello schema elettrico รจ indicato sia il nome โ€œfunzionaleโ€ del pin che il suo numero di riferimento. Come si vede nel Listato 2, i pin RB1, RB2, RB4 ed RB5 sono pin digitali di output, che pilotano gli ingressi del sensore TCS230.

Su RB7 viene letta la durata dellโ€™impulso risultato della misurazione dellโ€™intensitร  di luce. Come pin di uscita PWM abbiamo utilizzato CCP2, CCP3 e CCP4, ai quali fanno capo i terminali del LED di potenza B, G ed R.

Lโ€™alimentazione per il microcontrollore e per il resto del circuito รจ fornita dallo stadio di alimentazione costruito attorno allโ€™integrato U2, un regolatore di tensione lineare di tipo 7805, con un diodo di protezione dallโ€™inversione di corrente e le celle di livellamento e stabilizzazione della tensione realizzate con i condensatori C1, C2, C3 e C4.

Dato lโ€™alto consumo del circuito, dovuto principalmente al LED di potenza, raccomandiamo di utilizzare un alimentatore esterno in CC stabilizzato che eroghi una tensione non superiore a 7,5 V.

Questo, per evitare un eccessivo surriscaldamento dellโ€™integrato 7805.

Listato 2

โ€˜**************************************************************
โ€˜* Name : LampadaCamaleonte.pbp *
โ€˜* PIC : 16F1827 * 
โ€˜* Notes : Firmware Lampada Camaleonte *
โ€˜* Riproduce i colori della superficie di appoggio * 
โ€˜**************************************************************

INCLUDE โ€œmodedefs.basโ€ 
โ€˜@ DEVICE INTRC_OSC_NOCLKOUT
โ€˜@ DEVICE MCLR_OFF
DEFINE OSC 16
โ€˜DEFINE PULSIN_MAX 1350
โ€˜DEFINE PULSIN_MAX 1750

ADCON0 = %00000000
OPTION_REG.7=0
โ€˜CMCON0 =%00000111
ANSELA=%00000000 
ANSELB=%00000000
โ€˜OSCCON=%01101010
OSCCON=%01111010
APFCON0.3=0 โ€˜CCP2 su pin Rb6
โ€˜MDSRC=%00000011
โ€˜WPU=%00010000

โ€˜********************** Definizione porte del PIC *****************************

SYMBOL TX = PORTB.3 โ€˜Pin 9 - Dati Seriali in uscita

SYMBOL S0 = PORTB.2 โ€˜ Pin 8
SYMBOL S1 = PORTB.1 โ€˜ Pin 7
SYMBOL S2 = PORTB.5 โ€˜ Pin 11
SYMBOL S3 = PORTB.4 โ€˜ Pin 10
SYMBOL OUTC = PORTB.7 โ€˜ Pin 13

Coeff VAR WORD

Ro VAR word
Go VAR word
Bo VAR word

white VAR WORD
white_off VAR WORD
red VAR WORD
blu VAR WORD
green VAR WORD

Tolerance VAR WORD
mode VAR BYTE

DEFINE CCP3_REG PORTA โ€˜Hpwm 1 pin port
DEFINE CCP3_BIT 3 โ€˜Hpwm 1 pin bit
DEFINE CCP4_REG PORTA โ€˜Hpwm 1 pin port
DEFINE CCP4_BIT 4 โ€˜Hpwm 1 pin bit
DEFINE CCP2_REG PORTB โ€˜Hpwm 1 pin port
DEFINE CCP2_BIT 6 โ€˜Hpwm 1 pin bit

INPUT OUTC
OUTPUT S0
OUTPUT S1
OUTPUT S2
OUTPUT S3

โ€˜********************* Dichiarazione variabili ******************************
CONTA VAR WORD โ€˜Contiene la lunghezza dellโ€™impulso
ERRORE VAR BYTE โ€˜0:Nessun errore nel segnale - 1:Segnale non valido

Ro = 0
Go = 0
Bo = 0

CONTA=0
ERRORE=0

โ€˜************************ Inizializzazione programma **************************
INIZIO:
CLEAR
SEROUT tx,T9600,[13,10,โ€SYSTEM STARTUP v1.0โ€,13,10]

โ€˜โ€™********************************** M A I N ***********************************
โ€˜Lettura lunghezza impulso โ€œ0โ€ e successivamente lettura treno di bit ricevuti
MAIN: 
mode = 3
GOSUB TAOS_MODE 
CONTINUA:
โ€˜ Legge il bianco 
LOW S3
HIGH S2 
GOSUB LEGGI_COLORE
SEROUT tx,T9600,[13,10,โ€W:โ€,#CONTA,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]
white = CONTA * 100
SEROUT tx,T9600,[13,10,โ€Wx:โ€,#white,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10] 

โ€˜ Legge il rosso
LOW S3
LOW S2 
GOSUB LEGGI_COLORE
SEROUT tx,T9600,[13,10,โ€R:โ€,#CONTA,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]
red = white / CONTA 
SEROUT tx,T9600,[13,10,โ€Rx:โ€,#red,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10] 

โ€˜ Legge il verde 
HIGH S3
HIGH S2 
GOSUB LEGGI_COLORE
SEROUT tx,T9600,[13,10,โ€G:โ€,#CONTA,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]
green = white / CONTA 
SEROUT tx,T9600,[13,10,โ€Gx:โ€,#green,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]

โ€˜ Legge il blu
HIGH S3
LOW S2 
GOSUB LEGGI_COLORE
SEROUT tx,T9600,[13,10,โ€B:โ€,#CONTA,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]
blu = white / CONTA 
SEROUT tx,T9600,[13,10,โ€Bx:โ€,#blu,โ€ (โ€œ,#S2,โ€-โ€,#S3,โ€)โ€,13,10]

IF red >= blu AND red >= green THEN
Coeff = 25500 / red
Ro = 255
Go = green * Coeff / 100
Bo = blu * Coeff / 100
Bo=Bo * 3 / 4
Go=Go * 3 / 4
ENDIF

IF blu >= red AND blu >= green THEN
Coeff = 25500 / blu
Bo = 255
Go = green * Coeff / 100
Ro = red * Coeff / 100
Ro=Ro * 3 / 4
Go=Go * 3 / 4
ENDIF

IF green >= blu AND green >= red THEN
Coeff = 25500 / green
Go = 255
Ro = red * Coeff / 100
Bo = blu * Coeff / 100
Bo=Bo * 3 / 4
Ro=Ro * 3 / 4
ENDIF

HPWM 2,bO,100 
HPWM 3,gO,100 
HPWM 4,rO,100 

SEROUT tx,T9600,[13,10,โ€RGB:โ€,#Ro,โ€-โ€,#Go,โ€-โ€,#Bo,13,10]

pause 500 
GOTO CONTINUA

TAOS_MODE:
SELECT CASE mode
CASE 0 
LOW S0
LOW S1
CASE 1
HIGH S0
HIGH S1 
CASE 2
HIGH S0 
LOW S1 
CASE 3
LOW S0 
HIGH S1 
END SELECT
pause 50
RETURN

LEGGI_COLORE:
pause 50
PULSIN OUTC,0,CONTA 
RETURN

 

Per quanto riguarda la breakout board TCS230, alimentazione a parte, lโ€™unica nota da aggiungere, come nel caso del prototipo, รจ il collegamento a massa del terminale OE, in modo da mantenere sempre in funzione il sensore.

Per pilotare correttamente il LED di potenza, per ciascun terminale โ€œcoloreโ€ del LED รจ inserito un circuito di potenza costituito da un MOSFET BS170, con relativa resistenza di limitazione.

Le resistenze R4, R5 ed R6 limitano la corrente assorbita da ciascun terminale del LED di potenza.

Se date unโ€™occhiata al circuito stampato potete notare lโ€™adattamento della realizzazione per lโ€™utilizzo con la lampada.

Abbiamo previsto di montare il sensore al di sotto dello stampato, rivolto verso la superficie della quale si vuole rilevare il colore, mentre gli altri componenti, sono montati superiormente, in particolare il LED di potenza in posizione โ€œcentraleโ€, in modo da diffondere la luce nel modo migliore.

La disposizione dei componenti รจ visibile nel โ€œPiano di montaggioโ€.

Abbiamo montato sullโ€™alloggiamento della breakout board TCS230 due strip di connettori femmina, cosรฌ come abbiamo adottato uno zoccolo per lโ€™integrato PIC16F1827.

Chiaramente, in caso di montaggio di produzione questi ultimi componenti verrebbero saldati direttamente sullo stampato. Ma tantโ€™รจ, alla fine ha prevalso lo spirito del โ€œkitโ€.

Quattro โ€œcolonnineโ€, dalla parte della breakout board, costituiscono una solida base sulla quale poggiare il tutto. Portiamo lโ€™attenzione sul software di gestione della lampada, da installare sul microcontrollore PIC16F1827.

Per il โ€œporting del software abbiamo scelto il linguaggio di sviluppo Pic Basic Pro, una versione di BASIC appositamente destinato allo sviluppo sui microcontrollori Microchip. Per la programmazione dobbiamo utilizzare un programmatore Pic.

Nel Listato 2 vediamo il risultato del โ€œportingโ€, che rispetta la logica di elaborazione vista nel diagramma a blocchi di Fig. 7.

I commenti nel listato e la sua โ€œsomiglianzaโ€ con lo sketch di Arduino non dovrebbero lasciare dubbi di interpretazione.

 

Download del codice dell’Albero di Natale โ€œCamaleonteโ€

 

Fig. 11

 

 

Per rendere โ€œmodulareโ€ lโ€™utilizzo della lampada, ovvero per offrire la possibilitร  di sostituire lโ€™albero con contenitori di altre forme, abbiamo separato la base della lampada dal โ€œlumeโ€.

Come base abbiamo stampato un cilindro di 70 mm di diametro e 40 mm di altezza, in modo da contenere tutto il circuito della lampada e fornire supporto alla parte superiore (vedere la Fig. 11).

Abbiamo quindi praticato un foro laterale da 10 mm di diametro in corrispondenza del plug di alimentazione per fare passare il jack dellโ€™alimentatore.

Finalmente (lo vedete nella Fig. 12) abbiamo raggiunto il risultato finale del nostro processo: la lampada di โ€œNataleโ€ che si adatta al colore dellโ€™oggetto dove viene appoggiata.

Provate ad appoggiarla sulle confezioni dei regali o sulla tovaglia della tavola di Natale e vedrete che prenderร  il loro colore.

Ora non ci resta che salutarvi, augurarvi buon divertimento e …Buone Feste!

 

Lascia un commento

Il tuo indirizzo email non sarร  pubblicato. I campi obbligatori sono contrassegnati *

Menu