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.

Il servo meccanismo è un dispositivo capace di eseguire dei movimenti meccanici in funzione del segnale applicato al suo ingresso. Viene utilizzato spesso per eseguire lavori continui, ovvero per controllare meccanismi che non possono essere azionati continuamente da personale umano.  In campo hobbystico viene impegnato per azionamenti a distanza tipici del radio modellismo.

Le caratteristiche comuni tra i servo sono principalmente, l’angolo di rotazione, la velocità di rotazione e la coppia motrice.
Il modello SG-5010 che ho acquistato viene prodotto dalla TowerPro e le sue caratteristiche tecniche sono elencate nella tabella seguente:

Il suo funzionamento è veramente elementare, tutto si riduce nell’utilizzo del segnale PWM variando il valore di duty cycle tra 1% e 50% .
Per convenienza possiamo alimentare il servo tramite il pin 5Vdc del Netduino, anche se per applicazioni operative consiglio vivamente di alimentare il servo con una tensione esterna, evitando in questo modo di sovraccaricare il Netduino rendendolo instabile.
Il TowerPro Sg-5010 dispone di tre fili con colori che possono essere ambigui infatti il filo marrone deve essere collegato a massa, il filo rosso deve essere collegato alla +5Vdc e il filo arancione va collegato ad un pin PWM del Netduino (Pin 5-6-9-10).

In via generale il segnale PWM tipico deve avere una frequenza di 50Hz (Periodo di 20mS), mentre l’impulso positivo del segnale deve avere una larghezza compresa tra 1ms e 2ms, infatti per portare l’asse del servo nella posizione centrale la larghezza dovrà essere di 1.5ms (zero gradi) per portare l’asse a +90° l’impulso deve essere largo 2ms mentre per portare l’asse a -90° l’impulso dovrà essere largo 1ms.

L’illustrazione seguente aiuta a capire meglio il funzionamento

Il codice che andremmo a scrivere dovrà generare un segnale pwm con una frequenza di 50Hz e con un impulso la cui larghezza dovrà variare da 1ms sino a 2ms, questo è possibile utilizzando la classe PWM e il metodo SetPulse(), per maggiori informazioni riguardo questa classe vi consiglio di leggere questo articolo

// Istanzio un oggetto pwm
// Setto il pin 9 come uscita pwm
PWM servo = new PWM(Pins.GPIO_PIN_D9);

while (true)
{
  //imposto una frequenza di circa 50Hz
  //con un impulso di 1.5ms
  //l'asse del servo viene posizionato a 0°
  servo.SetPulse(20000, 1500);
  //attendo 2 secondi
  Thread.Sleep(2000);

  //imposto la frequenza sempre a 50Hz
  //con un impulso di 1ms
  //l'asse del servo si posiziona a -90°
  servo.SetPulse(20000, 1000);
  Thread.Sleep(2000);

  //imposto la frequenza sempre a 50Hz
  //con un impulso di 2ms
  //l'asse del servo si posiziona a +90°
  servo.SetPulse(20000, 2000);
  Thread.Sleep(2000);
}

Il codice esegue continuamente, ogni due secondi, la rotazione dell’asse del servo. Sicuramente i valori di larghezza generati non portano alla rotazione completa dell’asse del servo, questo perché anche se si ha una certa standardizzazione ci possono essere delle differenze tra i vari modelli.

Quindi sarà necessaria una calibrazione per capire quali sono i valori limite che portano alla rotazione di 180° dell’asse. Eseguendo il codice precedente potremo vedere se l’asse compie una manovra di 180° se per esempio non raggiunge i limiti di -90° e +90° possiamo aumentare e diminuire della stessa quantità la larghezza degli impulsi relativa a questi limiti ad esempio portando il valore di 1000 (1ms) a 800 (0.8ms) e il valore di 2000 (2ms) a 2200 (2.2ms).

Tabella riepilogativa

Col servo in mio possesso ho dovuto cambiare i valori della larghezza dell’impulso in questo modo

In questo modo abbiamo capito quali sono i valori limite per il nostro servo, questo è fondamentale per impostare la larghezza dell’impulso per spostare l’asse anche nei valori intermedi.

The post Servo SG-5010 come controllarlo con Netduino tramite segnale PWM appeared first on Esperimenti con logiche programmabili.

I pin digitali del Netduino, come sapiamo, possono svolgere anche delle funzioni aggiuntive, in particolare i pin 5, 6, 10 ed 11 sono in grado di generare un segnale pwm (Pulse Width Modulation). Utilizzando questa funzione possiamo generare un segnale con una frequenza minima di 15Hz ed una massima di 500KHz, con un Duty Cycle variabile da 0 a 100%. Per poter generarlo dobbiamo creare un’istanza di oggetto dalla classe PWM

PWM pwm = new PWM(pin del Netduino);

Il costruttore della classe richiede come parametro il pin del Netduino che vogliamo utilizzare per generare il pwm.
Le funzioni disponibili sono due:

pwm.SetPulse(frequenza, duty cycle);
pwm.SetDutyCycle(duty cycle);

SetPulse accetta due argomenti, il primo indica il valore della frequenza da generare ed il secondo il valore del duty cycle. Il valori validi da inserire nel parametro della frequenza vanno da 2 a 65535 mentre quelli validi da inserire nel parametro duty cycle vanno da 1 a 65534 ma dipendono dal parametro frequenza.
Il valore 2 corrisponde a una frequenza di 500Khz mentre il valore 65535 corrisponde a un frequenza di 15hz.
Il secondo parametro che definisce il duty cycle dipende strettamente dal valore numerico inserito nel parametro della frequenza. Chiarisco subito con un esempio, se voglio generare un segnale a 100Hz con duty cycle del 30% devo procedere in questo modo:

Calcolo il valore del parametro frequenza basandomi su questa proporzione

65535 : 2 = 500000 : 15

quindi per calcolare il numero intero che produrrà un segnale pwm con una frequenza di 100Hz devo eseguire questo calcolo

(65535*15) / 100 ~= 9830

Il risultato del calcolo va immesso nel campo frequenza della funzione SetPulse. Il valore di duty cycle da inserire nel secondo parametro dipende dal valore della frequenza, e per calcolarlo devo usare questa formula:

(Valore Frequenza / 100) * Valore Duty Cycle

che in pratica diviene:

(9830/100)*30 = 2949

di conseguenza la funzione SetPulse per generare un segnale a 100Hz con duty cycle al 30% è:

pwm.SetPulse(9830, 2949); //100Hz 30%

SetDutyCycle genera una frequenza fissa di 10KHz con un duty cycle variabile a seconda del valore inserito nel suo parametro. SetDutyCycle accetta valori da 0 a 100 rispettivamente per un duty cycle del 0% e del 100%. Se in questo parametro inseriamo il valore o otterremo un segnale basso all’uscita del pin del Netduino mentre se specifichiamo 100 otterremo sul pin in questione un valore fisso di 5Vdc, tutti gli altri valori da 1 a 99 produrranno il segnale pwm con duty cycle da 1% a 99%.

Il PWM solitamente è impiegato nel controllo della velocità di rotazione dei motori, la possibilità di variare il duty cycle permette di controllare direttamente la velocità di rotazione del motore, aumentandola o diminuendola in funzione del valore di duty cycle.

Il codice seguente mostra un esempio di utilizzo della funzione pwm del Netduino

public static void Main()
{
UInt32 DutyCycle = 0;
PWM pw1 = new PWM(Pins.GPIO_PIN_D5); //uscita pwm su pin5

while (true) //ciclo infinito
{
// incrementato per 100 iterazioni la variabile Intensita
// e la passo come parametro alla funzione SetDutyCycle
for (DutyCycle = 1; DutyCycle <= 100; DutyCycle++)
{
pw1.SetDutyCycle(DutyCycle);
Thread.Sleep(25);
}
}
}

Il diagramma seguente mostra l’andamento del segnale pwm che progressivamente va da un duty cycle dell’1% sino al 99%. La frequenza del segnale è sempre di 10KHz il circuito elettrico invece è il seguente;

Come sempre critiche e suggerimenti sono sempre ben accetti.

The post PWM gestione col Netduino appeared first on Esperimenti con logiche programmabili.

Uno dei primi esperimenti che feci quando iniziai a studiare elettronica, fu pilotare un piccolo motorino dc. Presto capii che abbassando la tensione di alimentazione, per far diminuire la velocità del motore, portava anche a una perdita di potenza del motore stesso, dovuta ad un conseguente calo di corrente.
Dopo vari studi imparai che, per tenere il motore sempre con una certa forza a diverse velocità, non bisognava abbassare il valore di tensione, ma pilotare il motore con un segnale ad onda quadra e variare il duty cycle dello stesso.
Il duty cycle è il rapporto che c’è tra il segnale positivo e il periodo totale del segnale ad onda quadra ed è espresso in percentuale. Un duty cycle del 100% equivale ad un segnale Alto continuo, uno del 0% equivale ad un segnale Basso continuo mentre un duty cycle del 50% significa che il segnale Alto dura quanto quello Basso.

per calcolarlo basta eseguire questa semplice formula

dove Livello Alto è il valore di tempo della durata del segnale positivo mentre Periodo è il tempo relativo al periodo del segnale ad onda quadra.
Possiamo fare un semplice esempio:

Supponendo che il livello alto duri 10ms e il periodo del segnale ad onda quadra sia di 20ms, potremmo calcolare che il duty cycle sia del 50%, infatti 10ms / 20ms = 0.5 che moltiplicato per 100 da 50(%).

Nel caso in cui invece il tempo del livello alto sia di 2ms e il periodo del segnale di 20ms otterremo un duty cycle del 10%

Mentre se il tempo del livello alto è di 18ms e il periodo del segnale di 20ms otterremo un duty cycle del 90%.

Questa caratteristica è stata implementata sia nel Netduino che nell’Arduino e la capacità di variare il duty cycle viene comunemente detta PWM (Pulse Width Modulation). Per generare un segnale ad onda quadra con duty cycle variabile bisogna configurare alcuni pin dedicati del Netduino/Arduino ed usare delle semplici funzioni.

The post Capire il duty cycle appeared first on Esperimenti con logiche programmabili.