Il 5 Luglio 2013, Campus Camilla organizza una giornata di formazione gratuita dedicata alla programmazione con Arduino e alle stampanti 3D.

Di seguito il programma della open day:

Ore 9:30

Presentazione della giornata

Ore 10:00

Logo 3DItaly

Introduzione alla Filosofia Makers

• la nuova rivoluzione industriale
• fabbricazione digitale fra bit e atomi
• accesso alle tecnologie
• i Fablab per le comunità
• l’esperienza dell’artigianato
• condivisione open
• dal prototipo al prodotto finito
• una nuova forma per il mondo industriale

3D printing: Introduzione alla stampa, alle risorse ed alle applicazioni

• una guida pratica per la prima stampa 3D
• open source software e hardware
• i modelli open e le risorse disponibili online
• i vari modelli di stampanti ed i materiali di stampa
• le applicazioni ed i vari campi d’impiego
• la stampa 3D per l’educazione e per il futuro del pianeta

Ore 11:30

Elettronica In: La nostra filosofia sulle stampanti 3D

Ore 12:30

Scaldiamo i motori!
Stampanti 3D in azione!

Buffet gratuito

Ore 14:30 – Corso gratuito su Arduino

Obiettivi del corso, cosa avrai imparato al termine del corso:

• conoscere e aver installato l’IDE Arduino
• conoscere le differenze tra Arduino Uno, Mini, Mega, Due;
• conoscere le differenze tra segnale analogico e digitale
• riconoscere un pin di aduino se analogico o digitale
• conoscere l’ADC e i livelli di segnali convertiti
• saper usare le principali librerie
• riconoscere un motore, un led, un relé
• riconoscere i sensori compatibili Arduino
• conoscere le principali shield disponibili e la loro funzione
• aver già realizzato almeno un proprio progetto
• aver chiaro come si affronta un progetto con Arduino

Nello specifico, il corso tratterà i seguenti argomenti tecnici:

• riconoscere e provare i pin di arduino
• differenza tra pin digitali, analogici e PWM
• basi di elettronica: led, motori cc, motori passo-passo
• collegare attuatori ( led, motori, relè )
• collegare sensori (pulsanti, potenziometri, ecc..)
• leggere i sensori per interagire con l’ambiente
• controllare velocità e verso dei motori
alcune shield disponibili con Arduino

Tutte le info per poter partecipare al corso le trovate sulla pagina http://www.internetdeglioggetti.it/openday/ un evento interessante che vi consiglio di non perdere.

L’utilizzo dei pin digitali rientra tra le nozioni basilari da comprendere per poter iniziare ad interagire con  i dispositivi ed i componenti esterni che permettono al modulo Flyport Ethernet di far parte di un sistema complesso.
Il modulo Flyport Ethernet è composto da due connettori, J1 e J2; essi sono collegati direttamente ai pin del microcontrollore Pic24F ed al controller Ethernet ENC424J600.

Tramite questi connettori possiamo collegarlo al modulo NEST Proto o ad un nostro circuito host dedicato.
Nel mio caso utilizzerò il Nest Proto per motivi di semplicità e di uniformità dei tutorial.

Nel Nest Proto è presente un connettore femmina collegato direttamente al connettore J1 del Flyport Ethernet, che permette di utilizzare dei fili elettrici pint-to-pin per realizzare velocemente prototipi ed esperimenti. Tralasciamo, per ora, il connettore J2 che viene impiegato per la comunicazione ethernet (tramite una porta RJ45 da saldare sul NEST Proto), e per offrire altri 8 pin IO.

Il connettore J1 è composto da 26 pin, ad ognuno è associata una funzione specifica. La tabella seguente mostra la pin-function del connettore:

Configurare pin GPIO come uscita

I pin contrassegnati come GPIO possono funzionare sia come ingressi sia come uscite digitali. La colonna Remappable indica invece se al pin può essere associata una funzione speciale, ad esempio i pin p1 e p3 NON sono rimappabili e quindi possono essere configurati o come GPIO o come bus I2C. Un pin rimappabile può funzionare sia come GPIO ed è possibile associarli anche una funzionalità aggiuntiva come PWM, UART o SPI. Questa peculiarità permette di avere un sistema molto flessibile, configurabile per ogni esigenza progettuale.
La colonna, 5V Tollerant, indica se il pin può sopportare tensioni di 5 Volt (Logica TTL), ad esempio il pin p17 non è 5V tollerant e quindi dobbiamo stare molto attenti a non collegare tensioni superiori ai 3.3V, causa possibile danneggiamento del microcontrollore.

Utilizziamo il circuito in figura per scrivere un piccolo programma che utilizzerà le istruzioni per definire il pin p2 come uscita digitale:

al pin p2, ho collegato una resistenza da 330 ohm ed un diodo led. Da notare che i numeri dei pin sono disposti utilizzando la prima riga, del connettore J1, per i numeri dispari e la seconda riga per i numeri pari.

Il codice seguente accende e spegne il led ogni 500ms:

#include "taskFlyport.h"

void FlyportTask()
{
  //il pin p2 viene configurato
  //come uscita digitale
  IOInit(p2, out);

  //ciclo infinito
  while(1)
  {
    //commuto il pin p2 a livello
    //logico alto
    IOPut(p2, on);
    //creo un ritardo di 500ms
    DelayMs(500);
    //commuto il pin p2 a livello
    //logico basso
    IOPut(p2, off);
    //creo un ritardo di 500ms
    DelayMs(500);
  }
}

L’istruzione che permette di definire un pin come uscita o come ingresso è la IOInit(). I parametri da passare sono il numero del pin, espresso nella forma px (dove x è il numero del pin) ed il flag per specificare un uscita out o un ingresso in.
In questo caso il pin p2 viene usato come uscita (out). Per poter commutare il suo stato logico utilizziamo la funzione IOPut(). Questa funzione accetta due parametri, il primo è il numero del pin, definito nella IOInit, e il secondo specifica se metterlo a livello logico alto (on) o al livello basso(off).

Configurare pin GPIO come ingresso

Il pin p2 viene ora impiegato come ingresso digitale. Lo schema elettrico è il seguente:

la resistenza R1 serve per avere un livello logico basso sul pin p2 quando il pulsante è aperto. Sul pin p4 ho collegato un diodo led in modo da poterlo accendere quando premo sul pulsante.
Questo è il codice del firmware da caricare sul Flyport:

#include "taskFlyport.h"

void FlyportTask()
{
  //il pin p2 viene configurato
  //come Ingresso digitale
  IOInit(p2, in);

  //il pin p4 viene configurato
  //come Uscita digitale
  IOInit(p4, out);

  //ciclo infinito
  while(1)
  {
    //verifico lo stato del pin p2
    //Alto o basso
    if(IOGet(p2) == 1)
      //sel il pin è a livello
      //logico alto, accendo il led
      IOPut(p4, on);
    else
      //altrimenti
      //spegni il led
      IOPut(p4, off);

    DelayMs(20);
  }
}

Ho usato due istruzioni IOInit per definire il pin p2 come ingresso e il pin p4 come uscita. Nel blocco while, controllo, con l’istruzione IOGet, se il livello logico sul pin p2 è alto. In caso affermativo, utilizzo il pin p4, per accendere o spegnere il diodo led.

Nei prossimi tutorial vedremo come attivare la resistenza interna di pull-up e di pull-down per gli ingressi digitali del Flyport Ethernet.

Con i precedenti tutorial abbiamo visto tutti i passaggi per configurare l’ambiente di sviluppo e come caricare il nostro primo programma sul modulo Flyport ethernet senza però conoscere il modulo stesso. In questo articolo verrei analizzare le potenzialità di questo dispositivo, informazioni utili per poter sceglierlo nei nostri progetti.

Le sue dimensioni sono di 5 cm x 3.5 cm, caratteristica sempre apprezzata nelle installazioni dove le dimensioni contenute sono un fattore richiesto.

Il microprocessore che governa il modulo è il modello della serie PIC24F (PIC24FJ256) prodotto dalla Microchip, troviamo inoltre il controller ethernet ENC424j600, sempre prodotto da Microchip. Il processore opera a 16bit capace di eseguire, con i suoi 32MHz di clock, 16 milioni di istruzioni al secondo, possiede 256 KByte di Flash e 16KB di RAM. L’interfaccia di rete è una 10/100 Base-T.
Troviamo collegato sul pcb anche un quarzo da 32.768Mhz necessario al modulo RTCC (Real Time Clock and Calendar) implementato nel microprocessore PIC24F.

Le porte digitali sono 18, di cui 14 rimappabili (possibilità di configurarle come ingressi o come uscite), le porte analogiche sono 4 con una risoluzione di 10bit (valori da 0 a 1023). Inoltre possiamo configurare 4 porte UART, 9 canali PWM, una porta SPI e una porta I2C.

Il modulo ospita una memoria flash seriale da ben 16Mbit (SST25VF016Bb), utile per memorizzare le pagine html che poi verranno impiegate ad esempio dal webserver interno.

Il Flyport Ethernet può essere alimentato sia a 5Vdc sia a 3.3Vdc.

L’intervallo di temperature in cui il modulo può operare va da -20°C a +85°C. Questi valori sono veramente interessanti permettendo l’installazione in ambienti anche estremi.

Flyport framework

All’interno del microprocessore troviamo, il bootloader, un sistema operativo real-time (freeRTOS), lo stack TCP/IP e l’Openpicus Framework.
Il bootloader è un piccolo software che risiede nella flash del microcontrollore PIC24F. Questo software permette di caricare il programma scritto con l’Openpicus IDE dentro la flash del microcontrollore, tramite la porta seriale UART. Inoltre permette di avviare il programma o di resettarlo. Questa scelta permette di usare solamente il convertitore usb seriale piuttosto che impiegare un programmatore esterno più complesso per tutte le fasi di programmazione e di debug.
Il sistema operativo real time è basato su FreeRTOS, realizzato per girare su diversi dispositivi embedded. L’Openpicus framework integra lo stack TCP/IP tramite questo sistema operativo e permette così di facilitare la gestione di TCP/IP. Nonostante questa semplificazione è comunque richiesta una minima esperienza nell’uso delle reti e della loro configurazione.

Il modulo, o per meglio dire il sistema Openpicus, si dimostra utile in moltissime applicazioni, da quelle puramente hobbistiche a quelle industriali. Credo che conoscerne il funzionamento e la sua programmazione si davvero utile per arricchire le nostre competenze e per avere dalla nostra un utile strumento da utilizzare anche in campo lavorativo.

E poi è made in Italy!

Dopo aver visto come installare il software necessario alla scrittura dei programmi e dopo aver installato i driver del programmatore miniUSB Prog, passiamo alla pratica creando un piccolo progetto che ci permetterà di far lampeggiare il led onboard del Flyport ethernet.

Avviamo l’OpenPicus Flyport IDE.
L’interfaccia grafica è ben organizzata, molto intuitiva e snella.

Creiamo il nostro progetto cliccando sull’icona New Project -> Ethernet ->Ethernet 2.3 Basic no webserver, come rappresentato nella figura seguente:

Nella finestra andremmo ad inserire il nome del progetto e la cartella dove verrà salvato, confermiamo cliccando sul pulsante Create>>:

La configurazione dell’IDE è immediata. L’interfaccia grafica viene suddivisa in tre blocchi principali, il pannello progetto mostra i file sorgente e le eventuali librerie che utilizzeremmo durante lo sviluppo, il pannello editor codice è la parte dove andremmo a scrivere le istruzioni che saranno poi compilate e caricate sul Flyport Ethernet, infine il pannello output mostra tutte le informazioni di compilazione e gli eventuali messaggi di errore.

Sul pannello Editor Codice viene caricato un template standard. Andremo a modificarlo per poter far lampeggiare il led onboard del nostro Flyport Ethernet scrivendo le seguenti istruzioni:

#include "taskFlyport.h"

void FlyportTask()
{
  //blink onboard led D1
  while(1)
  {
    //comuto l'uscita p21 alta
    IOPut(p21,on);
    //attendo 1/2 secondo
    DelayMs(500);
    //commuto l'uscita p21 bassa
    IOPut(p21,off);
    //attendo 1/2 secondo
    DelayMs(500);
  }
}

L’azione successiva è quella di “trasformare”, tramite la compilazione, le nostre istruzioni in un linguaggio comprensibile per il microcontrollore.
Clicchiamo sul pulsante Compile Project -> Compile, per avviarla.

I vari passaggi sono rappresentati nel pannello Output. Dopo poco tempo la compilazione termina con successo:

Ci siamo quasi, ora che abbiamo il file compilato possiamo caricarlo sul modulo Flyport utilizzando il tool Download firmware:

se non l’abbiamo fatto colleghiamo il Flyport Ethernet e il programmatore miniUSB Prog sul modulo NEST Proto. Colleghiamo il cavo usb al PC e nella finestra Openpicus – Flyport Bootloader clicchiamo il pulsante Refresh ports per aggiornare la lista dei dispositivi COM collegati al PC.
Selezioniamo la porta COM dove è collegato il miniUSB Prog (nel mio caso la porta COM21, vedi precedente articolo) e avviamo il download del firmware cliccando sul relativo pulsante Download:

la barra di avanzamento e la finestra di log mostreranno le fasi di scrittura:

Un popup di conferma ci indicherà che l’operazione è avvenuta con successo clicchiamo sul pulsante OK per chiudere la finestra:

osserviamo il led D1 posto sul pcb del Flyport Ethernet che inizierà a lampeggiare con una cadenza di 1/2 secondo.

Questo tutorial conclude una serie di articoli che permettono, a chi ha poca esperienza, di poter iniziare a smanettare con i moduli Flyport. Abbiamo visto infatti come installare l’ambiente di sviluppo, come installare i driver del programmatore ed infine come eseguire la compilazione e la scrittura del firmware sul modulo Flyport ethernet.

Nel precedente articolo abbiamo visto come installare l’ambiente di sviluppo che ci permetterà di scrivere i programmi per la piattaforma Openpicus. Ora passeremmo alla pratica utilizzando il Flyport Ethernet Makerkit. Questo starter kit comprende un modulo Flyport Ethernet, il miniUSB Prog ed il Proto Nest.

Il Proto Nest permette di ospitare il modulo Flyport e il modulo miniUSB Prog. Il modulo Flyport deve essere inserito nel giusto verso, vi consiglio di inserire prima il modulo miniUSB Prog (anche questo da inserire correttamente confrontando il simbolo > serigrafato nel PCB) poichè la sua posizione verticale va ad interferire con il connettore RJ45, rendendo difficoltoso il posizionamento del modulo Flyport.
L’immagine seguente mostra il corretto posizionamento:

Il modulo miniUSB Prog è un convertitore USB seriale basato sul chip FTDI FT232. Le istruzioni seguenti mostrano come installare il dispositivo su Windows 7.

La prima operazione da eseguire è il download dei driver dal sito FTDIchip. Personalmente ho scaricato la versione eseguibile:

Colleghiamo il miniUSB Prog al computer, dopo qualche istante Windows avvierà la procedura automatica di installazione dei driver:

annulliamo la procedura automatica cliccando sul link “Ignora download di driver da Windows Update“, confermiamo la nostra scelta cliccando il pulsante Si nella seguente finestra:

l’installazione viene annullata:

Nella finestra Gestione Dispositivi (Pannello di controllo -> Sistema e sicurezza) potremmo osservare la presenza del dispositivo USB Serial Port:

Avviamo l’installazione dei driver tramite il pacchetto CDM20828_Setup.exe:

Clicchiamo sul pulsante Extract della seguente finestra:

Il programma di installazione estrarrà i file necessari ed avvierà automaticamente la procedura guidata:

Clicchiamo sul pulsante Avanti nella prima finestra della procedura guidata:

i driver saranno copiati sul sistema, questa operazione può durare anche diversi minuti, non interrompiamo la procedura e lasciamo collegato il miniUSB Prog alla porta usb del PC:

dopo un po di pazienza l’installazione termina correttamente, clicchiamo sul pulsante Fine:

Verifichiamo la corretta installazione del convertitore USB seriale anche tramite il pannello Gestione Dispositivi:

Annottiamo il numero di porta seriale assegnato dal sistema, nel mio caso la COM21, questo ci permetterà di selezionare la giusta COM in fase di caricamento del firmware sul modulo Flyport.

Openpicus è un progetto tutto italiano nato nel 2010, basato sulla filosofia open hardware che permette di realizzare applicazioni dove la connettività è il fattore chiave. Attualmente esistono tre moduli programmabili, il Flyport Ethernet, il Flyport Wi-Fi e il Flyport Gprs. I moduli Flyport sono gestiti dal microcontrollore Microchip Pic 24FJ256(16 bit) operante a 32MHz.

Analizzeremmo meglio le caratteristiche dei moduli Flyport nei seguenti tutorial.
Vediamo nel dettaglio come installare l’ambiente di sviluppo che ci permetterà di scrivere i programmi, di compilarli e caricarli nel modulo Flyport.

La prima operazione è quella di scaricare il file di setup relativo all’IDE e al compilatore Microchip C30 seguendo questo link http://wiki.openpicus.com/index.php?title=Getting_Started.

Partiamo con l’installazione dell’IDE (attualmente giunto alla versione 2.3).

Eseguiamo il file FlyPort IDE-2.3-Setup.exe e accettiamo di eseguire l’installazione (Controllo account utente). Selezioniamo la lingua dell’ide che preferiamo, nel mio caso Italian:

Clicchiamo sul pulsante ok. Il prossimo popup ci avvisa che l’IDE sarà installato sul sistema, proseguiamo cliccando sul pulsante ‘Si’.

La prossima schermata mostra il Contratto di Licenza. Dopo averlo letto Accettiamo e clicchiamo sul pulsante Avanti:

Continuiamo l’installazione cliccando nuovamente sul pulsante Avanti:

La finestra seguente indica in quale percorso desideriamo installare l’IDE, nel mio caso ho lasciato il percorso di default sotto la cartella Programmi nell’unita C:, continuamo cliccando sul pulsante Avanti:

la schermata seguente riepiloga le scelte effettuate. Avviamo l’installazione dei file cliccando sul pulsante Avanti:

la barra di avanzamento indica lo stato della copia dei file:

dopo qualche istante l’installazione viene completata. Lasciamo i tre simboli di spunta selezionati e clicchiamo sul pulsante Fine:

A questo punto verrà avviato il FlyPort IDE. La finestra popup avvisa che non è stato trovato il compilatore GCC. Clicchiamo sul pulsante NO:

Il programma ci avviserà che non è stato possibile trovare il compilatore. Clicchiamo sul pulsante OK:

A questo punto il FlyPort IDE viene avviato ma non è possibile utilizzarlo. Chiudiamo il programma.

Per risolvere il problema avviamo l’installazione del compilatore Microchip C30 tramite il file MPLABC30Combo_v3_24Lite.exe:

dopo avver confermato, nella finestra account utente, l’intenzione di installare il programma, verrà avviata la finestra di benvenuto, clicchiamo sul pulsante Avanti:

accettiamo il contratto e clicchiamo sul pulsante Avanti:

il popup seguente ci permette di scegliere se l’installazione del programma deve avvenire per tutti gli utenti o solo per l’utente corrente, clicchiamo sul pulsante SI:

selezioniamo l’installazione Completa:

scegliamo la cartella di installazione. Se non avete particolari esigenze, consiglio di tenere il percorso prestabilito:

La finestra popup successiva vi indicherà che verrà aggiunta una voce alla sezione PATH Enviroment del sistema operativo, accettiamo cliccando sul pulsante Si:

la successiva finestra popup, vi chiederà se volete modificare il registro in modo che l’MPLAB IDE possa usare il compilatore GCC. Nel mio caso ho scelto cliccando il pulsante SI, se voi non avete installato l’MPlAB IDE potete anche cliccare sul pulsante NO:

La finestra successiva riepiloga le varie opzioni scelte, avviamo l’installazione cliccando sul pulsante Avanti:

una barra di avanzamento mostrerà lo stato dell’installazione:

dopo un po di attesa l’installazione si concluderà con una finestra di conferma. Clicchiamo sul pulsante Finish.

L’installazione dell’IDE  e del compilatore sono concluse.
Avviamo nuovamente il FlyPort IDE per assicurarci che il compilatore GCC sia stato riconosciuto.

se non ci sono problemi, le finestre popup di errore visualizzate precedentemente, non verranno visualizzate e l’ide sarà avviato senza nessun messaggio.
Clicchiamo sulla scheda View e poi sul pulsante Compiler Settings:

la finestra che verrà avviata mostra l’indirizzo di installazione del compilatore Microchip GCC come definito nella sezione PATH enviroment:

Nei prossimi tutorial vedremmo come installare il modulo FlyPort Ethernet  e come caricare il primo programma.

Per maggiori dettagli visitate il sito http://www.openpicus.com/
Altre info su http://wiki.openpicus.com/index.php/Main_Page

La libreria Webduino implementa una semplice autenticazione basata sul protocollo http. Certamente non offre un livello di sicurezza impenetrabile ma può comunque essere utile utilizzare questa funzione per le nostre applicazioni.

Nell’esempio, viene caricata la pagina index.htm dove è presente un link che punta a una pagina protetta. per poter visualizzarne il contenuto è necessario inserire nome utente e password.

La based authentication si basa sulla codifica Base64. Il nume utente e la password, nella forma numeutente:password, vengono convertiti in un unica stringa  di caratteri.  Per la conversione, potete utilizzare diversi servizi online oppure scaricare la mia app ConvertBase64.

Il codice seguente è pronto all’uso, dovete cambiare solamente l’indirizzo ip, adattando lo alla vostra rete locale.

#include "SPI.h"
#include "Ethernet.h"
#include "WebServer.h"

//definisco mac address e indirizzo ip
static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
static uint8_t ip[] = { 192, 168, 1, 10};

//creo un oggetto webduino
WebServer webserver("", 80);

//funzione che crea la pagina principale del sito
void defaultCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
  server.httpSuccess();
  if (type != WebServer::HEAD)
  {
    //invio al browser la pagina principale
    P(helloMsg) = "<h4>Accedi:</h4><a href=\"private.html\">Pagina Privata</a>";
    server.printP(helloMsg);
  }
}

//questa funzione permette di verificare il nome utente e la password
//e in caso di successo di visualizzare la pagina privata
void privateCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
  //user= admin
  //password= admin

  //verifico nome utente e password
  if (server.checkCredentials("YWRtaW46YWRtaW4="))
  {
    //in caso affermativo...
    server.httpSuccess();
    if (type != WebServer::HEAD)
    {
      //invio al browser la pagina privata
      P(helloMsg) = "<h3>Buongiorno Admin!</h3>";
      server.printP(helloMsg);
    }
  }
  else
  {
    //creo una risposta http
    //nel caso in cui si tenta un accesso
    //no autorizzato
    server.httpUnauthorized();
  }
}

void setup()
{
  //inizializzo la ethernet shield
  Ethernet.begin(mac, ip);
  //definisco funzione che gestisce
  //la pagina principale del sito
  webserver.setDefaultCommand(&defaultCmd);
  webserver.addCommand("index.html", &defaultCmd);
  //definisco la funzione che gestisce la pagina privata
  webserver.addCommand("private.html", &privateCmd);

  //inizializzo la libreria webduino
  webserver.begin();
}

void loop()
{
  char buff[64];
  int len = 64;

  webserver.processConnection(buff, &len);
}

La libreria Webduino è molto flessibile e permette di realizzare applicazioni interessanti in modo molto veloce.

La tecnologia 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. 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 carine 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 (Rosso, Verde, 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.

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 i caratteri corrispondenti.

Per un maggior controllo dei led RGB possiamo utilizzare il segnale PWM. In questo modo abbiamo la possibilità di creare dissolvenze per creare combinazioni di colori visivamente più interessanti.
Ad esempio 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.

Molte applicazioni richiedono la variazione continua di alcuni parametri, come ad esempio un alimentatore, un amplificatore audio, un termostato o un varilight che solitamente impiegano un potenziometro analogico e l’intervento manuale di una persona per effettuare queste variazioni.
Possiamo digitalizzare questi sistemi impiegando lo stesso principio di regolazione basato su potenziometro ma invece di agire fisicamente sulla manopola di regolazione possiamo utilizzare dei comandi software per incrementare decrementare il valore resistivo del potenziometro.

Il componente che andremmo ad usare è l’integrato MCP4131-103 prodotto dalla Microchip. E’ un integrato a 8 pin che possiamo comandare tramite il protocollo seriale SPI.
Al suo interno troviamo un potenziometro da 10Kohm.

Il potenziometro è composto da una rete resistiva composta da 128 elementi  il cui valore totale è, nel nostro modello, di 10Kohm. Tramite software possiamo spostare la posizione dello Wiper, che corrisponde al contatto strisciante di un potenziometro meccanico. Gli spostamenti dello Wiper vengono definiti steps e vanno dalla posizione 00H (Wiper collegato al pin P0A) alla posizione 80H(Wiper collegato al pin P0B).
Il potenziometro digitale MCP4131 permette un massimo di 129 steps.

Il datasheet è comune a diversi potenziometri digitali quindi per poter capire quale siano i comandi corretti per pilotare il nostro modello dobbiamo esaminare le parti che ci interessano. La prima sezione riguarda le Caratteristiche del dispositivo (Device Features)

Da questa tabella deduciamo che il dispositivo ha un singolo potenziometro, che i valori della posizione dello Wiper sono memorizzati in RAM (piuttosto che sulla EEPROM). L’interfaccia di comunicazione è SPI, i numeri di Steps sono 129 e il range con cui possiamo alimentare l’integrato va da 1.8Vdc a 5.5Vdc.

L’MCP4131 supporta comandi a 8 bit e a 16 bit. Il comando a 8 bit permette di incrementare o decrementare il valore dello Wiper di uno steps per volta mentre il comando a 16 bit permette di scrivere direttamente sulla RAM il valore della posizione dello Wiper.

Nella figura il comando a 8 bit è composto da 2 bit di dati (che non vengono utilizzati), 2 bit di comando (incremento – decremento)  e 4 bit che definiscono l’indirizzo di memoria che vogliamo usare (indirizzo dello Wiper 00h).
Nella figura del comando a 16 bit la prima parte è identica a quella a 8 bit con la differenza che nei 2 bit di comando possiamo specificare se scrivere o leggere dall’area di memoria del dispositivo, i restanti 8 bit compongono il Data Byte che ci permette di indicare direttamente il valore dello Wiper.

Gli indirizzi di memoria disponibili sono i seguenti:

nel nostro caso utilizzeremmo l’indirizzo 00h, che corrisponde all’unico Wiper disponibile all’interno del nostro chip.

I bit di commando invece sono i seguenti:

Passando alla pratica, se volessi inviare un comando di incremento al Wiper dell’MCP4131, usando la modalità a 8bit, invierei tramite SPI il valore decimale 4

Per decrementare il valore corrente dello Wiper bisogna spedire via SPI il valore decimale 8:

Se volessi spostare il Wiper al centro della sua corsa, utilizzerei la modalità a 16 bit, inviando per primo il dato contenente l’indirizzo di memoria che vogliamo usare e il comando di scrittura

Seguito dal valore della posizione dove vogliamo spostare lo Wiper, in questo esempio il valore 64 decimale (128/2) corrisponde a metà corsa.

Ora che conosciamo come utilizzare il chip possiamo passare alla pratica collegando la porta SPI dell’Arduino all’MCP4131. Nel mio caso ho utilizzato un Arduino Leonardo (la porta SPI è disponibile sui pin dell’header ICSP). Lo schema è il seguente:

L’uscita W è collegata all’ingresso analogico A0 della Leonardo, in questo modo posso misurare il valore di tensione disponibile su tale piedino.
Il Pin B dell’MCP4131, corrispondente alla posizione 00H è collegato a massa mentre il pin A corrispondente alla posizione 80H è collegato alla 5Vdc.
Il codice seguente posiziona lo Wiper nella posizione 00H, ottenendo cosi una tensione pressochè nulla sul pin W (poiche internamente il pin W è collegato con il pin B).

#include <SPI.h>

void setup()
{
  //Definisco il pin come uscita
  //il pin 2 viene usato per selezionare il
  //chip all'interno di un collegamento SPI
  pinMode (2, OUTPUT);

  //Inizializzo la libreria SPI
  SPI.begin();

  //Inizializzo la porta seriale
  Serial.begin(9600);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

}

void loop()
{
  //Inizializzo la posizione dello Wiper
  byte Posizione = 0;

  //Per selezionare l'MCP4131
  //metto basso la linea CS del
  //potenziometro digitale
  digitalWrite(2, LOW);

  //Invio il primo byte per eseguire una scrittura
  //sul registro Wiper
  SPI.transfer(0);
  //Invio il valore della posizione dello Wiper
  //valori da 00H a 80H (0-128 in decimale)
  SPI.transfer(Posizione);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

  //eseguo la lettura sul pin analogico A0
  //in questo pin è collegato il pin Wiper
  //del potenziometro digitale
  int Data = analogRead(0);

  //spedisco il dato letto al serial Monitor
  //Valori da 0 a 1023
  Serial.println(Data);

  //ritardo di mezzo secondo
  delay(500);
}

Aprendo il serial monitor otterremmo dei valori prossimi allo zero poichè la tensione in ingresso del pin A0 sarà nulla. Questo è ciò che avviene all’interno dell’MCP4131:

Per posizionare lo Wiper verso il pin A, collegato alla 5Vdc, dobbiamo scrivere sull’indirizzo 00H il valore 80H, come descritto nel codice seguente:

#include <SPI.h>

void setup()
{
  //Definisco il pin come uscita
  //il pin 2 viene usato per selezionare il
  //chip all'interno di un collegamento SPI
  pinMode (2, OUTPUT);

  //Inizializzo la libreria SPI
  SPI.begin();

  //Inizializzo la porta seriale
  Serial.begin(9600);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

}

void loop()
{
  //Inizializzo la posizione dello Wiper
  byte Posizione = 128;

  //Per selezionare l'MCP4131
  //metto basso la linea CS del
  //potenziometro digitale
  digitalWrite(2, LOW);

  //Invio il primo byte per eseguire una scrittura
  //sul registro Wiper
  SPI.transfer(0);
  //Invio il valore della posizione dello Wiper
  //valori da 00H a 80H (0-128 in decimale)
  SPI.transfer(Posizione);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

  //eseguo la lettura sul pin analogico A0
  //in questo pin è collegato il pin Wiper
  //del potenziometro digitale
  int Data = analogRead(0);

  //spedisco il dato letto al serial Monitor
  //Valori da 0 a 1023
  Serial.println(Data);

  //ritardo di mezzo secondo
  delay(500);
}

In questo caso aprendo il serial monitor leggeremmo dei valori prossimi a 1023 in quanto sul pin analogico A0 sarà presente la tensione di 5Vdc.
Internamente otterremo questo risultato:

Di conseguenza per avere tutti gli altri valori intermedi potremmo cambiare il valore della variabile Posizione assegnandole valori tra 0 e 128.

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:

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

Mentre questo è il circuito elettrico

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