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.

Commenti

Post più popolari