Arduino come sappiamo è una piattaforma molto versatile che permette di realizzare diverse tipologie di progetti. La parte che preferisco maggiormente riguarda la realizzazione di progetti che in qualche modo risolvano o migliorino una attività pratica.
Nonostante ciò molti esperimenti vengono realizzati ai soli fini didattici o ludici. Il cubo led 3x3x3 è sicuramente uno di quei progetti che vengono realizzati per stupire gli amici!

Di tutorial per realizzare cubi led 3x3x3 ne esistono centinaia, ma nonostante ciò ho voluto realizzare anche io l’ennesimo cercando di spiegare la sua realizzazione in modo molto semplice, questo perché molti utenti,  che sono alle prime esperienze, hanno bisogno di spiegazioni passo passo molto elementari.

I materiali necessari per realizzare il cubo led sono elencati di seguito:

• 27 led da 3mm, nel mio cubo di colore rosso
• 3 Transistors NPN, io ho usato il 2n2222 ma va bene anche il BC547
• 9 resistenze da 150 ohm 1/4w
• 3 resistenze da 1Kohm 1/4w
• 1 scheda Arduino, nel mio caso una Micro ma va bene anche la UNO
• basetta millefori per montare i componenti
• filo elettrico q.b.

Realizzazione del cubo

il cubo led è formato da tre livelli, o strati, ognuno composto da 9 led. Questi nove led vendono collegati unendo tutti i catodi tramite delle saldature a stagno. Per primo bisogna procedere piegando il catodo di 9 led a 90°

procedendo poi a saldare tra loro i catodi dei 9 led, cercando di formare un quadrato:

dovrete otterrete questa struttura composta da 9 led:

Nella realtà otterremo qualcosa del genere:

come potete osservare dalla figura precedente ho utilizzato un pezzo di cartone ondulato per posizionare in maniera uniforme i led. Il cartone si presta ad essere forato utilizzando il led stesso.
Una volta realizato il primo livello continuiamo con gli altri due livelli. Una volta finito il lavoro dovremmo avere qualcosa del genere:

Ora dobbiamo unire i tre strati di led tra loro formando appunto un cubo. Sovrapponiamo il primo strato con il secondo e con delle saldature collegheremo gli anodi dei led tra loro, una volta saldato il secondo strato si continua posizionando e saldando il terzo strato. La figura seguente da un’idea di come posizionare e saldare gli anodi

per posizionare i tre strati di led uno su l’altro, potete usare delle pinzette a coccodrillo o alcuni supporti per tenere ferma la struttura. Notate che ho utilizzato lo stesso cartone per tenere fermo il primo strato di led per poi andare a saldare il secondo ed il terzo, inoltre per semplificare le saldature i led sono rivolti verso il basso.

A lavoro finito otterremo questo:

la struttura è formata da 9 colonne verticali che collegano gli anodi dei led e da tre righe orizzontali separate che collegano i catodi dei 9 led per strato.

Il circuito elettrico

La struttura dispone quindi di 9 anodi e 3 catodi, dovremmo collegare tutti questi file ai pin dell’Arduino Micro. I 9 anodi sono collegati ai pin di Arduino tramite una resistenza di limitazione da 150 ohm. I catodi invece verranno collegati a massa tramite l’utilizzo dei transistors.

Nella figura seguente potete notare i dettagli del cubo led 3x3x3 ed i relativi collegamenti:

Principio di funzionamento

La parte di realizzazione è sicuramente quella più impegnativa, mentre per la parte software non ci resta che scrivere alcune semplici istruzioni IO. Naturalmente è necessario conoscere il modo in cui si accendono i led, in modo da poter scrivere correttamente un programma.
In pratica per poter accendere i led dobbiamo mettere a livello logico alto uno o piu pin collegati ai 9 anodi (da pin2 a pin9) e successivamente attivare uno o più transistor mettendo a livello logico alto una delle uscite 11, 12 o 13.
Se ad esempio voglio accendere il led numero 1, dovrò mettere alta l’uscita al pin 2 ed attivare il transistor collegato al pin 11. Oppure mettendo alto il pin 11, 12 e 13 otterrò l’accensione contemporanea del led del primo, secondo e terzo strato.

The post Tutorial come costruire un cubo led 3x3x3 appeared first on Esperimenti con logiche programmabili.

La tecnologia di illuminazione a led si è ormai evoluta ed inizia ad essere presente in modo pronunciato in molti ambienti, dalla casa agli uffici fino ad arrivare all’illuminazione pubblica (vedi progetto di lampada di cortesia a led).

I vantaggi in termini di risparmio energetico sono enormi e la qualità della luce emessa sta raggiungendo un comfort visivo soddisfacente.

Anche nell’arredamento troviamo soluzioni molto interessanti che vanno dalla lampada da salotto multicolore alle luci di cortesia nei piani cottura oppure alle barre led impermeabili poste nel box doccia.

Vista la nostra passione per l’auto-costruzione possiamo realizzare un dispositivo basato su Arduino per pilotare una barra led RGB. Per questo tutorial ho usato una Arduino Leonardo e uno spezzone di 10 cm di una strip led RGB da un metro. Questo modello viene alimentato a 12Vdc e un modulo assorbe, con tutti i led accesi circa 55mA (quindi un metro assorbe circa 550mA).

Un elemento RGB è composto da 3 LED distinti (LED Rosso, LED Verde, LED Blu) disposti in modo da poter interagire tra loro per formare diversi colori complementari.

Il modo più semplice per accendere i led è di collegare uno dei pin (B,R,G) verso massa; non è necessario utilizzare delle resistenze per limitare la corrente perché sono già integrate nel circuito.

Vediamo ora come usare Arduino per accendere e spegnere singolarmente i vari led. Il circuito da realizzare è il seguente e si basa su tre transistor PNP tipo BC337.

Le basi dei tre transistors sono collegate ai pin 3, 5 e 6 non a caso poiché su questi pin è disponibile anche il segnale PWM che utilizzeremo per andare a pilotare i led RGB in modo migliore.

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop() 
{
 //se arrivano dati...
 if (Serial.available())
 {
  //leggi il carattere in arrivo
  byte data = Serial.read();
  if(data == 'q') //accende il led blu
   digitalWrite(3, HIGH);
  else if (data == 'w') //spegne il led blu
   digitalWrite(3, LOW);
 
  if(data == 'a') //accende il led verde
   digitalWrite(5, HIGH);
  else if (data == 's') //spegne il led verde
   digitalWrite(5, LOW);
  if(data == 'z') //accende il led rosso
   digitalWrite(6, HIGH);
  else if (data == 'x') //spegne il led rosso
   digitalWrite(6, LOW);
 }
}

Il codice precedente permette di accendere o spegnere i led inviando tramite serial monitor dei caratteri di comando. L’effetto che otteniamo è una miscelazione dei colori.

Un maggior controllo dei led RGB possiamo ottenerlo utilizzando il segnale PWM generato da Arduino. In questo modo abbiamo la possibilità di creare dissolvenze per creare combinazioni di colori visivamente più interessanti.
Il codice seguente permette di accendere e spegnere il led BLU in modo graduale tramite una dissolvenza:

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop()
{
 //Aumenta il duty cycle da 100% a 0%
 for(byte sfuma = 0; sfuma < 255; sfuma++)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
 //diminuisci il duty cycle da 100% a 0%
 for(byte sfuma = 255; sfuma > 0; sfuma--)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
}

Se volessi miscelare i colori potrei scrivere qualcosa del genere

void setup()
{
 //led Rosso
 pinMode(5, OUTPUT);
 //led verde
 pinMode(6, OUTPUT);
 //led blu
 pinMode(3, OUTPUT);
 //init seriale
 Serial.begin(9600);
}

void loop()
{
 //accendo il led rosso
 digitalWrite(6, HIGH);
 //Aumenta il duty cycle da 100% a 0%
 for(byte sfuma = 0; sfuma < 255; sfuma++)
 {
  analogWrite(3, sfuma);
  delay(40);
 }

 //spengo il rosso
 digitalWrite(6, LOW);
 //accendo il verde
 digitalWrite(5, HIGH);
 //diminuisci il duty cycle da 100% a 0%
 for(byte sfuma = 255; sfuma > 0; sfuma--)
 {
  analogWrite(3, sfuma);
  delay(40);
 }
}

Le combinazioni che possiamo creare sono innumerevoli, potete provare a sperimentare creando effetti luminosi che possono abbellire i vostri ambienti.

The post Pilotare striscia LED RGB appeared first on Esperimenti con logiche programmabili.

Un progetto che ha sempre attirato molta attenzione è il circuito VU meter sincronizzato con il ritmo della musica (il mitico luci psichedeliche ). Anche io quando ero alle superiori mi sono cimentato costruendone uno. Il circuito era formato da tre filtri analogici, uno passa basso uno passa banda e uno passa alto, che lavoravano rispettivamente alle frequenze 0-500Hz, 500Hz 4000Hz e 4000Hz-16000Hz. All’uscita dei filtri c’era un rilevatore di picco costruito con un operazionale che andava a pilotare dei driver che accendevano delle lampadine colorate.

Oggi la tecnologia offre prodotti integrati a basso costo, specializzati in una vasta gamma di compiti che rendono più semplice la realizzazione dei nostri circuiti. Per quanto riguarda le nostre luci psichedeliche possiamo fa affidamento allo Spectrum shield per Arduino. Lo shield è molto semplice ed è composto principalmente da due integrati MSGEQ7 (Equalizzatore grafico a 7 bande). Lo schema a blocchi dell’integrato è il seguente:

si osserva che in effetti il principio di funzionamento è molto simile a quello che si usava nei primi circuiti a luci psichedeliche, ma i filtri a disposizione sono ben 7 e le uscite dei filtri vengono multiplexate, in questo modo invece di avere 7 pin di output ne abbiamo solamente uno.
Inviando un primo impulso positivo al pin strobe avremmo in uscita il valore analogico proveniente dal filtro a 63Hz, inviandone un altro impulso avremmo in uscita il valore analogico del filtro a 160Hz e così via fino a tornare dopo 8 impulsi al filtro a 63Hz.

I due integrati MSGEQ7 presenti nello spectrum shield analizzano il segnale audio proveniente dal canale destro e dal canale sinistro. Per brevità utilizzerò un solo integrato (canale) visto che il codice è interscambiabile.
Le uscite analogiche dei due integrati sono collegate ai pin A0 e A1 mentre i pin Strobe e Reset sono collegati ai pin digitali D4 e D5.

Questo è il codice:

[c]
//Specifica i pin Reset, Strobe
int spectrumReset=5;
int spectrumStrobe=4;

//Specifico il canale di ingresso
//pin A0 per canale destro
//pin A1 per canale sinistro
int spectrumAnalog = 1; //canale sinistro

//creo un vettore per contenere i valori analogici
//delle 7 bande
int Spectrum[7];

void setup()
{
//pin reset e strobe in output
pinMode(spectrumReset, OUTPUT);
pinMode(spectrumStrobe, OUTPUT);

//inizializzo lo spectrum shield
//Strobe
digitalWrite(spectrumStrobe,HIGH);
delay(1);
digitalWrite(spectrumStrobe,LOW);
delay(1)

//Reset dei due chip
digitalWrite(spectrumReset,HIGH);
delay(1);
digitalWrite(spectrumReset,LOW);
delay(5);

//definisco 7 uscite digitali per pilotare altrettanti led
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);

}

void loop()
{
//esegui la lettura ogni 10mS
readSpectrum();
delay(10);
}

void readSpectrum()
{
//Questa funzione legge il valore analogico per ogni banda
//e ne rappresenta il valore tramite dei led

byte Band;
//questo ciclo for viene eseguito 7 volte
for(Band = 0; Band < 7; Band++)
{
//eseguo due letture per poi dividerle per due tramite
//spostamento di bit. Il valore ottenuto viene memorizzato
//nel vettore
Spectrum[Band] = (analogRead(spectrumAnalog) + analogRead(spectrumAnalog) ) >>1;

//invio un impulso al pin strobe per passare al filtro successivo
digitalWrite(spectrumStrobe,HIGH);
digitalWrite(spectrumStrobe,LOW);
}

//una volta effettuata la memorizzazione dei dati
//nel vettore, creo un altro ciclo for
//per rappresentare gli stessi tramite led
for (byte Ciclo = 0; Ciclo < 7; Ciclo++)
{
//recupero il valore memorizzato nel vettore
//traslo il valore intero in un byte
byte x = map(Spectrum[Ciclo], 0, 1023, 1, 254);

//se il valore supera una soglia accendi il led
//altrimenti spegnilo
if( x > 120)
digitalWrite(Ciclo + 6 , HIGH);
else
digitalWrite(Ciclo + 6, LOW);
}
}
[/c]

Mentre questo è il circuito elettrico

Per poter collegare delle lampade a 220Vac è necessario usare dei triac con relativo stadio pilota fotoisolato.

The post Utilizzare lo Spectrum Shield con Arduino appeared first on Esperimenti con logiche programmabili.

Il primo programma che possiamo creare, per iniziare a sperimentare con Netduino, è il classico esempio che permette di far lampeggiare il led di sistema, posto sulla scheda del dispositivo.
Questo programma è ormai un classico che si può trovare un po da per tutto in internet, ma nonostante ciò, anche io volevo proporvelo.

Dopo aver avviato Visual C# e creato un nuovo progetto, apriamo il file Program.cs e all’interno del blocco Main() inseriamo le seguenti righe di codice.

OutputPort ledOnBoard = new OutputPort(Pins.ONBOARD_LED, false);

while(true) //Ciclo infinito
{
//accende il led
ledOnBoard.Write(true);
//attende 500 millisecondi
Thread.Sleep(500);
//Spegne il led
ledOnBoard.Write(false);
//attende 500 millisecondi
Thread.Sleep(500);
}

queste istruzioni accendono e spengono il led ad una frequenza di mezzo secondo.
l’istruzione :

OutputPort ledOnBoard = new OutputPort(Pins.ONBOARD_LED, false);

crea un oggetto che viene usato per controllare il led onboard; il costruttore della classe OutputPort richiede l’identificativo del pin e il relativo stato iniziale. Pins.ONBOARD_LED appunto, è il led fisico posto sul dispositivo e false indica lo stato iniziale, ovvero spento.

Il cico while è infinito ed esegue ciclicamente queste istruzioni:

//accende il led
 ledOnBoard.Write(true);
//attende 500 millisecondi
Thread.Sleep(500);
//Spegne il led
ledOnBoard.Write(false);
//attende 500 millisecondi
 Thread.Sleep(500);

la funzione write() dell’oggetto non fa altro che accendere o spegnere il led a seconda del valore booleano passato come parametro.
Thread.Sleep() serve per creare un ritardo tra le istruzioni Write() per creare l’effetto intermittente, il valore passato è espresso in millisecondi.

Non ci resta che avviare il debug per eseguire la compilazione e il caricamento dell’eseguibile nel Netduino.
Il dispositivo deve essere collegato al pc tramite porta usb e Visual c# deve essere configurato per interaggire con il Netduino piuttosto che con l’emulatore.

The post Netduino far lampeggiare un led appeared first on Esperimenti con logiche programmabili.

Ora che abbiamo il nostro mini laboratorio per creare i prototipi e il software sul pc è installato correttamente possiamo avviare il primo progetto per verificare se tutto funziona e se il .net micro framework è correttamente attivo e funzionante sul Netduino.

Per prima cosa colleghiamo il Netduino al pc e verifichiamo che il led pwr sulla scheda sia acceso.
Ora avviamo Visual C# 2010 Express e creiamo un nuovo progetto:

la finestra Nuovo Progetto mostra tutti i tipi di soluzioni che possiamo generare con la nostra copia di Visual C# 2010 Express. Cliccando sulla voce Visual C# potremmo vedere la sottovoce Micro Framework, clicchiamo su di essa per visualizzare i vari tipi di progetto che possiamo creare. Se l’installazione dell’ sdk di Netduino è stata eseguita correttamente, in questo box ci sarà una voce dal nome Netduino Application

Selezioniamo la voce come mostrato in figura, diamo un nome alla nostra soluzione compilando la casella di testo Nome e clicchiamo sul pulsante OK per dar modo a Visual C# di impostare l’ambiente per lo sviluppo con Netduino e con il .Net micro framework.

Di tutte le voci elencate nella finestra Esplora Soluzione quella che ci interessa maggiormente è Program.cs che conterrà il codice della nostra applicazione. Avviamo l’editor cliccando due volte su questo file.

Il nostro codice può essere inserito nel blocco Main(), ma per il momento lasciamo tutto così com’è e proviamo subito a caricare il sorgente nel nostro Netduino.

Per prima cosa dobbiamo configurare Visual C# per comunicare con la scheda. Dalla finestra Esplora Soluzione clicchiamo due volte sulla voce Propierties per aprire la finestra delle proprietà della soluzione.

Selezioniamo la voce .Net Micro Framework; come si può vedere dalla figura nel box Deployment per default è selezionato l’emulatore. Per caricare il programma sul Netduino dobbiamo scegliere nella combobox Transport la voce USB. In questo modo Visual C# controllerà i dispositivi collegati alla porta usb e gli elencherà nella combobox Device. Selezioniamo la voce Netduino_Netduino disponibile nella lista dei device per poter comunicare con il Netduino.
Ora chiudiamo la finestra delle proprietà.

Tutto è pronto per programmare il  Netduino basta cliccare sull’icona Avvia Debug(F5) e Visual C# compilerà il sorgente e caricherà l’eseguibile sul dispositivo

Nella finestra Output di Visual Studio (Menu Visualizza -> Output) potremmo vedere tutti i passaggi della compilazione e del caricamento del sorgente sul Netduino.

Il .net micro framework contenuto nel Netduino inizierà a gestire ed eseguire il programma.

The post Netduino, .Net micro Framework e Visual C# appeared first on Esperimenti con logiche programmabili.