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.

 

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.

 

 

 

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.

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.

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.

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.

 

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;
}

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”

 

 

 

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!