domenica 17 aprile 2011

Wireless Pixels


English version below.

Questa applicazione per la quale abbiamo usato i JeeNode (già usati in questo post) e il Ranbowduino (già usato in questo post) è stata presentata in occasione dell'Arduino Day insieme al MIDIRainbow.
La giornata è stata densa di scambi con gli altri espositori e con i visitatori, un'ottima occasione per conoscersi tra appassionati e professionisti, tutti coinvolti con grande entusiasmo, compresi i ragazzi dell'organizzazione DiScienza. Molto interessanti anche gli interventi della conferenza.



Parti Hardware utilizzate:
- Un PC con Processing
- Due JeeNode
- Un Rainbowduino
- Una matrice di LED RGB 8x8

Software/Firmware utilizzato:
- Un'applicazione scritta in Processing (neorainbowduino_plasma.zip)
- La libreria neorainbow-0.82 che è composta di tre parti:
+ Un firmware per il Rainbowduino
+ Un firmware per Arduino
+ Una libreria per Processing
- Il firmware per i due JeeNode (neoLed_tx.zip) (neoLed_rx.zip)



Sul PC gira l'applicazione processing, ottenuta integrando l'esempio della libreria neorainbow-0.82 "neorainbowduino_simple" con l'algoritmo "Plasma" (preso dagli esempi di Processing: File -> Examples -> Topics -> Effects -> Plasma), che genera un immagine 8x8.



Questa matrice di pixel viene inviata via seriale al primo dei due JeeNode sul quale gira una versione modificata del firmware per Arduino della libreria neorainbow-0.82.
La modifica effettuata consente al JeeNode di ricevere i byte relativi alle componenti RGB dei pixels che compongono l'immagine e di inviarli via radio al secondo dei JeeNode (con l'uso della libreria RF12 sviluppata da JeeLabs per utilizzare facilmente il modulo radio RFM12B).
Il firmware sul secondo JeeNode gli permette di ricevere l'immagine dal primo usanda la libreria RF12 e di inviarla al Rainbowduino via I2C con la libreria Wire (inclusa nel sistema di sviluppo di Arduino).
Sul Rainbowduino gira il firmware preso dalla neorainbow-0.82 che si occupa di ricevere il flusso di byte che compongono l'immagine dalla porta I2C e di accendere i LED della matrice RGB in maniera opportuna.


Wireless Pixels from SuLuLab on Vimeo.



This application, for which we have used the JeeNode (already used in this post) and the Rainbowduino (already used in this post), was presented at the Arduino Day, as well as the MIDIRainbow.

Hardware components:
- A PC with Processing
- Two JeeNode
- A Rainbowduino
- An 8x8 RGB LED Matrix

Software/Firmware components:
- An application written in Processing (neorainbowduino_plasma.zip)
- The library neorainbow-0.82 which is composed of three parts:
+ A Rainbowduino firmware
+ An Arduino firmware
+ A Processing library
- The firmware for the two JeeNode's (neoLed_tx.zip) (neoLed_rx.zip)

On the PC is running the processing application, obtained by integrating the "neorainbowduino_simple" example of the neorainbow-0.82 library, with the "Plasma" algorithm (taken from the examples of Processing: File -> Examples -> Topics -> Effects -> Plasma), which creates a 8x8 image.
This matrix of pixels is sent via serial port to the first of the two JeeNode's on which runs a modified version of the Arduino firmware from the neorainbow-0.82 library.
This firmware variation allows the JeeNode ​​to receive the bytes for the pixels' RGB components in the image and send it via radio to the second JeeNode (using the RF12 library developed by JeeLabs, to easily use the RFM12B radio module).
The firmware on the second JeeNode allows it to receive the image from the first one, using the RF12 library, and send it to the Rainbowduino via I2C by the Wire library (included in the Arduino IDE).
The Rainbowduino runs the firmware, taken from neorainbow-0.82 library, that is responsible for receiving the stream of bytes that makes up the image from the I2C port and turns on the proper LED on the RGB Matrix with the right colour.

lunedì 11 aprile 2011

Arduino Day

Saremo presenti all'Arduino Day con il MIDI Rainbow.
Ci vediamo lì!!!

venerdì 8 aprile 2011

Moving BlinkyBug

English version below.

Un piccolo oggetto da costruire senza utilizzo di elettronica.
Le istruzioni seguite sono quelle del BlinkyBug di Ken Murphy, al quale abbiamo apportato una modifica per farlo muovere.
Il materiale che serve a costruirlo, nella nostra versione, è il seguente:
  • 2 LED
  • 30 cm di una corda da chitarra molto sottile
  • 2 batterie a bottone: una da 3V e una da 1.5V
  • degli scovolini da pipa
  • un tubicino di rame
  • colla tipo Attak
  • un motorino pager
Nel seguire le istruzioni abbiamo incollato con l'Attak la parte superiore, quella con le antenne, alla pila da 3V, per tenerla ferma, quindi abbiamo saldato il tubicino alla pila. Mentre, per la parte inferiore, abbiamo saldato la parte con i LED alla pila e poi incollato, con della colla a caldo (ma dovrebbe andare bene anche l'Attak), le zampe sotto. La pila va prima un po' carteggiata con una limetta da ambo i lati per migliorare la presa della saldatura.

Una volta che il BlinkyBug è completo ed i suoi occhietti si illuminano al muoversi delle antenne, si può procedere con la modifica per farlo camminare.
L'idea ci è venuta dal Bristlebot di Evil Mad Scientist Laboratories.
Prima di tutto bisogna procurarsi un motorino pager. Per questo basta aprire un vecchio telefono cellulare, infatti il pager è il motore che ne permette la vibrazione.
Infatti il peso del cilindretto che fuoriesce dal motore è sbilanciato su un lato per cui, quando il motore gira, si ha una vibrazione continua.
Il nostro pager aveva anche un rivestimento in plastica che lo ha fatto entrare perfettamente all'interno del tubicino di rame, che lo tiene fermo.

Per il pager ci vuole una pila apposita perché quella da 3V non basta ad alimentare anche i LED.
La pila da 1.5V quindi va collegata al pager e poi sistemata sotto le zampe dell'insetto, con della colla.
Per interrompere la vibrazione abbiamo predisposto un piccolo uncino sul collegamento ad una delle zampette del pager.



A little object built without any elctronics.

Instructions are the same as the ones for the Ken Murphy's BlinkyBugs. We modified it to make it move too.

What you need to build it:
  • 2 LEDs
  • 30 cm of a thin music wire
  • 2 batteries: 3V and 1.5V
  • some pipe cleaners
  • a copper tube
  • a pager motor
  • some strong glue
We used the glue to attach the upper and lower parts of the bug, to keep them stable, and then we solder them to the battery. It is usefull to scratch the battery with a rasp before you solder.

When the BlinkyBug was finished, we went ahead with our variation to make it move.

We took the idea from the Evil Mad Scientist Laboratories' Bristlebot.

We have used an old cell phone, opened it, and took the pager motor, the one that makes it vibrate.

The pager motor needs a battery of his own, so, we used another one (1.5V), which was glued to the bottom of the bug's legs.

To stop the vibration, we provided a little hook at one leg of the pager motor.

domenica 3 aprile 2011

MIDI Rainbow

English version below.

Un'altra applicazione del MIDI Shield. Questa volta, invece di generare messaggi MIDI come nell'applicazione "MIDI Sequencer", i messaggi in ingresso alla porta MIDI IN vengono interpretati per visualizzare pattern luminosi su una striscia di LED RGB indirizzabile.

Componenti principali del sistema:
  • Arduino
  • MIDI Shield qui e qui
  • Striscia di LED RGB basata sul chip HL1606
  • Alimentatore 5VDC 1.5A per alimentare la striscia (la corrente in uscita dalla porta USB non è sufficiente)
  • Libreria FastSPI_LED  

Collegamenti tra la striscia e Arduino:
Striscia
Pin di Arduino
GND<--->GND
SI<--->12
DI<--->11
CI<--->13
LI<--->10

I messaggi MIDI provenienti dalla tastiera (vera o simulata da PC) entrano nella porta MIDI IN del MIDI Shield e vengono presentati ad Arduino sulla porta seriale. Il firmware in Arduino interpreta i messaggi MIDI NoteOn e NoteOff, associa ogni tasto sulla tastiera a cinque ottave (60 tasti) ad un LED della striscia e lo accende del colore associato alla nota. Nel Firmware per controllare la striscia abbiamo usato la libreria FastSPI_LED che permette di indirizzare ogni singolo LED ed accenderlo del colore desiderato (R, G, B).




Una cosa interessante da notare nel firmware è l'utilizzo della funzione millis() per implementare una sorta di multitasking elementare. L'idea è stata presa da questo post dell'utente "westfw" sul forum di Arduino.


unsigned long now, nextMIDI, nextNote, nextPot, nextBTN, nextDemo;

void setup() {
  ...
  ...
  nextMIDI = millis();
  nextNote = millis();
  nextPot = millis();
  nextBTN = millis();
  nextDemo = millis();

  ...
  ...
}

void loop()
{
  now = millis();
  if (demo) {
    if (now >= nextDemo) {
      nextDemo = now + bvel * 2;
      playDemo();
    }
  }
  else {
    if (now >= nextMIDI) {
      nextMIDI = now + 2;
      readMIDI();
    }
  }
  if (now >= nextNote) {
    nextNote = now + 2;
    playNote();
  }
  if (now >= nextPot) {
    nextPot = now + 100;
    readPot();
  }
  if (now >= nextBTN) {
    nextBTN = now + 100;
    readButton();
  }
}



Premendo il tasto in alto sul MIDI Shield si accede alla modalità demo. Nella modalità demo i LED vengono accesi in sequenza con un effetto tipo rinbalzo, il potenziometro in alto controlla la velocità del movimento e il potenziometro in basso il fading.

Link per scaricare il firmware:





Another Arduino MIDI Shield application. This time, instead of generating MIDI messages as in the "MIDI Sequencer", incoming messages to the MIDI IN port are interpreted to display light patterns on a strip of addressable RGB LED.

Main components:

Connections from strip to Arduino:
Strip
Arduino Pin
ND <---> GND
SI <---> 12
DI <---> 11
CI <---> 13
LI <---> 10

MIDI messages from the keyboard (real or simulated on PC) enter the MIDI Shield's MIDI IN and are presented to the Arduino serial port. The Arduino firmware interprets the MIDI messages NoteOn NoteOff, associates each key on the five octaves (60 keys) keyboard to a strip LED and lights it with color associated with the note. In the firmware to control the strip we used the FastSPI_LED library that allows you to address every single LED and turn the desired color (R, G, B).


One interesting thing to note is the use of the firmaware function millis() to implement a sort of elementary multitasking. The idea was taken from this post after user "westfw" on the Arduino forum.


For the code look the italian section.


Pressing the first button of the MIDI Shield demo mode is entered. In demo mode, the LEDs are turned on sequentially with a bouncing effect, the first potentiometer controls the speed of movement and the second potentiometer controls the fading.

Link for firmware downloading:
MIDI_Rainbow.zip