• 1
  • info@lungolagocapodimonte.it

    Creare gioco di luci ( Con Led ) attraverso una "Lampada in Rete" usando il Processing , Comunicare con la rete , - Arduino Uno o Duemilanove

    Creare gioco di luci ( Con Led ) attraverso una "Lampada in Rete" usando il Processing - Arduino Uno o Duemilanove

     

     

    Lampada in Rete

    Ripasso "Alfabeto di Arduino"

     

     


    Output Digitale

    L'abbiamo usato per controllare un LED ma, con un circuito appropriato, può essere usato per controllare motori, produrre suoni e molto altro ancora.

    Output Analogico

    Ci offre la possibilità di controllare la luminosità del LED, non solo di accenderlo e spegnerlo. Con questo possiamo addirittura controllare la velocità di un motore.

    Per maggiori informazioni cliccate QUI

    Input Digitale

    Questo ci permette di leggere lo stato di sensori semplici, come pulsanti o interruttori a mercurio.

    Input Analogico

    Possiani leggere i segnali continui inviati dai sensori che non si limitano a segnalare gli stati acceso/spento, come i potensiometri o i sensori di luce.

    Comunicazione Seriale

    Ci permette di comunicare con un computer e scambiare dati o semplicemente controllare cosa sta succedendo nello sketch che viene eseguito su Arduino.

    In questo articolo, vedremo come comporre un'applicazione funzionante usando quanto abbiamo imparato nei capitoli precedenti. Questo articolo dovrebbe mostrarvi come ciascun singolo esempio può fungere da blocco costitutivo di un progetto complesso. Qui viene fuori l'aspirante designer che è in noi. Creeremo la versione del ventunesimo secolo della classica lampada del mio designer preferito, Joe Colombo. L'oggetto che stiamo per costruire si ispira a una lampada di nome "Aton" 1964.

    La lampada è una semplice sfera collocata su una base con ampio buco che le impedisca di rotolare sul tavolo. Questo design permette di orientare la lampada in varie direzioni.

    In termini di funzionalità, vogliamo costruire un dispositivo che si colleghi a internet, ricavi l'elenco di articoli di un Blog o Sito e conti quante volte sono state citate le parole Es. "Arduino" , "Peace" , "Love". Con questi valori, genereremo un colore e lo mostreremo nella lampada. La lampada è dotata di un pulsante che possiamo usare per accenderla e spegnerla e di un sensore di luce per la sua attivazione automatica.


    Pianificazione


    Diamo un'occhiata a dove vogliamo arrivare e a cosa ci serve. Innanzitutto, ci serve che Arduino possa collegarsi a Internet. Dato che la scehda Arduino è dotata solo di una porta USB, non possiamo collegarla direttamente a una connessione a Internet, quindi dobbiamo scoprire come costruire un ponte tra le due cose. Di solito si esegue un applicazione su un computer che si colleghi a Internet, elabori i dati e mandi ad Arduino solo alcune informazioni selezionate.

    Arduino è un computer semplice con poca memoria; non è in grado di elaborare facilmente file molto grandi e quando ci colleghiamo a un feed RSS ricaviamo lunghi file XML che avrebbero bisogno di molta più RAM. Quindi implementeremo un proxy che semplifichi l' XML usando il linguaggio Processing.

    Processing

    Processing è l'origine di Arduino. Questo linguaggio ci piace moltissimo e veniva usato per insegnare la programmazione ai principianti oltre che per costruire dei codici bellissimi. Processing e Arduino sono una combinazione perfetta. Un altro vantaggio è che Processing è open source e gira su tutte le piattaforme principali ( Mac, Linux e Windows ). E' in grado di generare applicazioni indipendenti per queste stesse piattaforme. Inoltre, la comunità di Processing è attiva e generosa e permette di trovare molti programmi di esempio già pronti.


    Ecco cosa fa il proxy per noi: scarica il feed RSS da un Blog o Sito ed estrae tutte le parole dal file XML che ottiene. Quindi, analizzandolo, conta il numero di volte che nel tempo appaiono le parole "Peace", "Love" e "Arduino". Con questi tre numeri, calcoleremo il valore di un colore e lo invieremo ad Arduino. La scheda ci restituirà la quantità di luce misurata dal sensore e la mostrerà sullo schermo del computer.

    Dal lato hardware, combineremo l'esempio del pulsante, quello del sensore di luce, il controllo del LED via PWM ( Moltiplicato per 3! ) e la comunicazione seriale.

    Dato che Arduino è un dispositivo semplice, dovremo codificare il colore in un modo semplice. Useremo il modo standard in cui si rappresentano i colori in HTML: # seguito da sei cifre esadecimali. I numeri esadecimali sono pratici, perchè ciascun numero di 8 bit viene rappresentato esattamente da due caratteri; nel caso dei numeri decimali, variano da uno a tre caratteri. Prevedibilmente, anche il codice diventa quindi più semplice: aspettiamo di vedere un #, poi leggiamo i sei caratteri che seguono in un buffer ( una variabile usata come contenitore temporaneo per questi dati ). Infine, convertiamo ciascun gruppo di due caratteri in un byte che rappresenti la luminosità di uno di tre LED.


    Codice ( Sketch ) Processing

    {codecitation class="brush:cpp"}

    import processing.serial.*;

    String feed = "http://blog.makezine.com/index.xml";

    int interval = 10;  // Estrae il feed ogni 60 secondi;
    int lastTime;       // L'ultima volta che abbiamo estratto il contenuto

    int love    = 0;
    int peace   = 0;
    int arduino = 0;

    int light = 0;  // Livello della luce misurato dalla Lampada

    Serial port;
    color c;
    String cs;

    String buffer = ""; // Accumula i caratteri che provengono da Arduino

    PFont font;

    void setup()
    {
    size(640,480);
    frameRate(10);    // Non ci servono aggiornamenti troppo veloci

    font = loadFont("HelveticaNeue-Bold-32.vlw");  
    fill(255);  
    textFont(font, 32);
    // NOTA IMPORTANTE:
    // La prima porta seriale ricavata da Serial.list()
    // dovrebbe essere quella del vostro Arduino. Se no, togliete
    // le linee di comment // che precedono la riga che segue questo commento ed eseguite di nuovo
    // lo Sketch per vedere un elenco di porte seriali. Quindi, sostituite lo 0 tra [ e ]
    // con il numero di porta cui è collegato il vostro Arduino
    //println(Serial.list());
    String arduinoPort = Serial.list()[0];
    port = new Serial(this, arduinoPort, 9600); // Si collega ad Arduino

    lastTime = 0;
    fetchData();
    }

    void draw() {
    background( c );
    int n = (interval - ((millis()-lastTime)/1000));

    // Build a colour based on the 3 values
    c = color(peace, love, arduino);
    cs = "#" + hex(c,6); // Prepara una strinda da inviare ad Arduino

    text("Arduino Networked Lamp", 10,40);
    text("Reading feed:", 10, 100);
    text(feed, 10, 140);

    text("Next update in "+ n + " seconds",10,450);
    text("peace" ,10,200);
    text(" " + peace, 130, 200);
    rect(200,172, peace, 28);

    text("love ",10,240);
    text(" " + love, 130, 240);
    rect(200,212, love, 28);

    text("arduino ",10,280);
    text(" " + arduino, 130, 280);
    rect(200,252, arduino, 28);

    // Scrive la stringa del colore sullo schermo
    text("sending", 10, 340);
    text(cs, 200,340);

    text("light level", 10, 380);
    rect(200, 352,light/10.23,28); // this turns 1023 into 100

    if (n <= 0)
    {
    fetchData();
    lastTime = millis();
    }

    port.write(cs); // Invia i dati ad Arduino

    if (port.available() > 0)  // Controlla se ci sono dei dati in attesa
    {
    int inByte = port.read(); // Legge un byte
    if (inByte != 10) // Se il byte non è un LINE FEED
    {
    buffer = buffer + char(inByte); // Lo aggiunge del buffer
    }
    else
    {

    // Raggiunto il LINE FEED, elaboriamo i dati
    if (buffer.length() > 1) // Verifichiamo che ci siamo abbastanza dati
    {

    // Elimina l'ultimo carattere, che è un a capo
    // ( Un a capo è il carattere alla fine di una
    // linea di testo)
    buffer = buffer.substring(0,buffer.length() -1);

    // Converte il buffer da stringa a numero intero
    light = int(buffer);

    // Svuota il buffer da stringa a numero intero
    buffer = "";

    // Probabilmente nel leggere i dati che invia Arduino
    // steam rimanendo indietro. Quindi svuotiamo il Backlog
    // delle letture che provengono dal sensore in modo che
    // la prossima sia aggiornata.
    port.clear();
    }
    }
    }

    }

    void fetchData()
    {
    // Usiamo queste stringhe per fare il parsing del feed
    String data;
    String chunk;

    // Azzeriamo i contatori
    love    = 0;
    peace   = 0;
    arduino = 0;
    try
    {
    URL url = new URL(feed);  // Un oggetto per rappresentare l'URL
    // Prepariamo un collegamento   
    URLConnection conn = url.openConnection();
    conn.connect(); // Ora colleghiamoci al sito web

    // Si tratta di un'azione idraulica virtuale, dato che colleghiamo
    // i dati che provengono dalla connessione a un lettore dotato
    // di buffer che legge i dati una linea alla volta.
    BufferedReader in = new
    BufferedReader(new InputStreamReader(conn.getInputStream()));

    // Legge ciascuna linea del Feed
    while ((data = in.readLine()) != null)
    {

    StringTokenizer st =
    new StringTokenizer(data,"\"<>,.()[] "); // La subdivide
    while (st.hasMoreTokens())
    {
    // Ogni porzione di dati viene scritta tutta in minuscole
    chunk= st.nextToken().toLowerCase() ;

    if (chunk.indexOf("love") >= 0 ) // Trovato "love"?
    love++;    // Incrementa love di 1
    if (chunk.indexOf("peace") >= 0)   // Trovato "peace"?
    peace++;   // Incrementa peace di 1
    if (chunk.indexOf("arduino") >= 0) // Trovato "arduino"?
    arduino++; // Incrementa arduino di 1
    }
    }

    // Imposta 64 come numero massimo di occorrenze che ci interessano.
    if (peace > 64)   peace = 64;
    if (love > 64)    love = 64;
    if (arduino > 64) arduino = 64;

    peace = peace * 4;     // Moltiplica per 4 in modo che il massimo sia 255,
    love = love * 4;       // Che si rileva utile quango dobbiamo costruire
    arduino = arduino * 4; // Un colore composto da 4 byte (ARGB)
    }
    catch (Exception ex) // Se si verifica un errore, interrompe lo Sketch
    {
    ex.printStackTrace();
    System.out.println("ERROR: "+ex.getMessage());
    }

    }

    {/codecitation}


    Perchè lo Sketch di Processing venga eseguito correttamente, prima dovete fare due cose. Innanzitutto, dovete chiedere a Processing di generare il font utilizzato per lo Sketch. Per farlo, CREATE e salvate questo Sketch. Quindi, con lo Sketch ancora aperto, fare click sul menu Tools di Processing e scegliete CREATE Font.

    Selezionate il font di nome HelveticalNeue-Bold, assegnate al font una dimensione pari a 32 e fate click su OK.

    Secondo, dovete confermare che lo Sketch sta usando la porta seriale corretta per comunicare con Arduino. E per farlo dovete aspettare di aver assemblato il circuito di Arduino e caricato lo Sketch di Arduino. Nella maggior parte dei sistemi, questo Sketch di Processing non darà problemi. Ma se non vedete succedere niente su Arduino e sullo schermo non vi appare nessun dato proveniente dal sensore di luce, cercate il commento dal titolo " NOTA IMPORTANTE " nello Sketch di Processing e seguite le istruzioni che fornisce.


    Codice ( Sketch )Arduino, Lampada in Rete

    {codecitation class="brush:cpp"}

    #define SENSOR 0   
    #define R_LED 9
    #define G_LED 10
    #define B_LED 11
    #define BUTTON 12

    int val = 0; // Variabile per conservare il calore che proviene dal sensore

    int btn = LOW;
    int old_btn = LOW;
    int state = 0;
    char buffer[7] ;
    int pointer = 0;
    byte inByte = 0;

    byte r = 0;
    byte g = 0;
    byte b = 0;

    void setup()
    {
    Serial.begin(9600);  // Apre la porta seriale
    pinMode(BUTTON, INPUT);
    }

    void loop()
    {
    val = analogRead(SENSOR); // Legge il valore proveniente dal sensore
    Serial.println(val);      // Stampa il valore sulla porta seriale


    if (Serial.available() >0)
    {

    // Legge il byte che arriva:
    inByte = Serial.read();

    // Se trova il marcatore, i 6 caratteri seguenti sono il colore
    if (inByte == '#')
    {

    while (pointer < 6) // Accumula 6 caratteri
    {
    buffer[pointer] = Serial.read(); // Li inserisce nel Buffer
    pointer++; // Sposta il puntatore avanti di 1
    }

    // Ora disponiamo dei 3 numeri salvati come numeri esadecimali
    // dobbiamo decodificarli in 3 byte r , g e b
    r = hex2dec(buffer[1]) + hex2dec(buffer[0]) * 16;
    g = hex2dec(buffer[3]) + hex2dec(buffer[2]) * 16;
    b = hex2dec(buffer[5]) + hex2dec(buffer[4]) * 16;

    pointer = 0; // Resetta il puntatore per riutilizzare il buffer

    }
    }   

    btn = digitalRead(BUTTON); // Legge il valore dell'input e lo conserva

    // Controlla se è avvenuta una transizione
    if ((btn == HIGH) && (old_btn == LOW))
    {
    state = 1 - state;
    }

    old_btn = btn; // Memorizza il valore vecchio in btn

    if (state == 1) // Se la lampada è accesa
    {

    analogWrite(R_LED, r);  // I led si accendono
    analogWrite(G_LED, g);  // Con il colore
    analogWrite(B_LED, b);  // Inviato dal computer
    }
    else
    {

    analogWrite(R_LED, 0);  // Altrimenti si spengono
    analogWrite(G_LED, 0);
    analogWrite(B_LED, 0);
    }

    delay(100);                // Aspetta 100ms tra ogni invio
    }

    int hex2dec(byte c) // Converte un carattere esadecimale in un numero
    {
    if (c >= '0' && c <= '9')
    {
    return c - '0';
    }
    else if (c >= 'A' && c <= 'F')
    {
    return c - 'A' + 10;
    }
    }

    {/codecitation}

     

    Schema Collegamento su Arduino Uno o Duemilanove

     

     

    Assemblare il circuito


    Nello schema soprastante e' possibile vedere il collegamento. Per tutte le resistenze che appaiono nel diagramma, dovete usare una resistenza da 10K, anche se nel caso delle resistenze collegate ai LED potreste cavarvela con valori inferiori ( Per una spiegazione più approfondita cliccate QUI e QUI ).

    Ricordate che i LED sono polarizzati: in questo circuito, il Pin Lungo ( Positivo ) dovrebbe andare a destra e quello corto ( Negativo ) a sinistra ( la maggior parte dei LED nel lato negativo sono appiattiti ).

    Aggiungi commento


    Codice di sicurezza
    Aggiorna