Utilizziamo lo shield DMX per Arduino e Vixen per creare animazioni Natalizie

Comandiamo i dispositivi ad interfaccia DMX512 da PC, utilizzando un Arduino equipaggiato con l’apposito shield ed un software di libero utilizzo con cui possiamo costruire sequenze di attivazione, anche sincronizzate alla musica.

Da parecchi anni, ormai, il controllo delle luci e delle apparecchiature per lo spettacolo avviene utilizzando la tecnica digitale ed il protocollo DMX512; ciò perché, se cablare una centralina per luci psichedeliche da casa comporta già qualche problema di trasporto della tensione di rete alle lampade, figuratevi cosa può essere cablare il palco per un concerto, dove ci sono centinaia di proiettori ognuno dei quali deve avere un proprio cavo che porta alla centralina di controllo.

Con il protocollo DMX tutto è stato semplificato: la console di comando genera delle stringhe di dati facilmente trasportabili con cavi di segnale, che raggiungono i controller, posti vicino alle lampade, alle sfere motorizzate o alle macchine del fumo; sono poi i controller a decodificare i dati e a commutare di conseguenza l’alimentazione di rete, con evidenti vantaggi sia in termini di riduzione delle perdite di potenza nei cavi, sia in fatto di sicurezza, dato che l’alta tensione rimane confinata nei controller.

Per comandare dispositivi a standard DMX512 si usano apposite console, ma è anche possibile, come in questo caso, usare una scheda come Arduino; siccome nel protocollo DMX512 le comunicazioni avvengono con livelli RS485, Arduino da solo non può farcela, ed è per questo che dobbiamo dotarlo di uno shield che a bordo abbia un’interfaccia RS485.

Visto che c’eravamo, abbiamo deciso di aggiungere altro hardware allo shield, così da permettere ai più intraprendenti di implementare ulteriori funzioni; ecco quindi un lettore di SD-Card nel quale potrete memorizzare sequenze di comando per i dispositivi DMX, da riprodurre dietro comando, ad esempio di un pulsante.

Poi abbiamo predisposto una connessione per un display LCD seriale, con il quale possiamo visualizzare informazioni di servizio come l’indirizzo DMX512 generato dal sistema, il nome della sequenza riprodotta al momento ecc.

Schema elettrico della shield DMX

Vediamo ora l’hardware del sistema di controllo, prendendo in considerazione solo il nostro shield dato che Arduino è un dispositivo a sé e che ormai conoscerete (i relativi schemi si trovano in Internet); il circuito consta di un transceiver RS485 di Maxim, siglato MAX485 e incapsulato in contenitore plastico DIP a 4+4 piedini.

Il componente è sostanzialmente un ricetrasmettitore simplex per linea differenziale, capace di raggiungere velocità di comunicazione di 2,5 Mbps; è composto da un trasmettitore ed un ricevitore ciascuno dotato di un proprio ingresso ed una propria uscita; il trasmettitore ha ingresso singolo riferito a massa, TTL-compatibile, collegato al piedino DI (Data Input) ed uscita differenziale (5 V) mentre il ricevitore ha l’ingresso differenziale, connesso in parallelo all’output del TX, ed uscita singola (RO-Receiver Output) riferita a massa.

La linea dati RS485 fa capo ai piedini A (6) e B (7) ed è bidirezionale, quindi può essere impegnata ora per trasmettere, ora per ricevere; chi decide la direzione dei dati sono i piedini /RE e OE, i quali attivano rispettivamente il ricevitore ed il trasmettitore (per l’esattezza, il primo si attiva ponendo a massa /RE ed il secondo portando ad 1 logico OE).

Nel nostro circuito abbiamo collegato insieme questi piedini, in modo da comandare simultaneamente l’attivazione del ricevitore e la disattivazione del trasmettitore e viceversa, semplicemente usando una linea di Arduino, che può essere D2 o D5 a seconda di come posizioniamo il jumper JRDE; tale ponticello ci è utile per scegliere la linea libera quando l’altra è occupata, ad esempio perché su Arduino è montato un secondo shield che ne fa uso. In ogni caso, quando la linea è a livello alto l’U2 trasmette, mentre con il livello basso si ottiene la ricezione.

L’uscita dei dati dal canale DMX512 viene letta dal pin RO (1) del MAX485 usando la linea di Arduino D0 o la D4, a seconda di come è impostato il ponticello JRO per il quale valgono le considerazioni appena fatte per JRDE: permette di scegliere fra più linee in modo da trovarne una libera.

L’ingresso dei dati che Arduino invia sulla linea DMX512 per comandare i vari dispositivi è localizzato al piedino 4 dell’U2; anche qui possiamo scegliere tra due linee digitali, ossia D1 e D3, grazie al jumper JDI.

Resta inteso che una volta scelte le linee di Arduino con cui comandare la ricetrasmissione, trasmettere i dati e riceverli, queste vanno definite nello sketch.

Quanto detto riguarda la sezione di controllo RS485 destinata a interfacciarsi con la linea DMX512 mediante l’apposito connettore XLR a 3 contatti.

Ora vediamo gli altri due blocchi circuitali, ossia quelli riguardanti la SD-Card e l’interfaccia seriale per il display esterno: il primo consta del connettore SD1, fatto per ospitare una microSD, i cui contatti di clock, CMD e CD sono interfacciati con Arduino mediante un traslatore di livelli logici 74HC4050D, il quale contiene sei buffer capaci di adattare i livelli TTL con cui lavora Arduino a quelli 0/3,3V richiesti dalle microSD.

Il traslatore è unidirezionale, quindi i contatti 2, 3 e 5 del connettore SD1 sono dati in ingresso; quando al canale dati in lettura, cioè quello usato da Arduino per leggere i dati nella card, viene collegato direttamente alla linea D10 (che nel firmware sarà impostata come ingresso), in quanto non è richiesto alcun adattamento perché gli ingressi digitali di Arduino riescono a leggere correttamente i livelli logici anche quando l’intervallo è fra 0 e 3,3 V.

Come accennato, il lettore di SD-Card può essere gestito da Arduino allo scopo di realizzare molteplici funzioni correlate al controllo di dispositivi DMX512: ad esempio può memorizzare sequenze di attivazione di lampade e dispositivi per lo spettacolo, da riprodurre dietro comando impartito da computer o semplicemente dal pulsante P1 di cui lo shield è provvisto.

Passiamo ora all’interfaccia LCD, che è semplicemente il collegamento ad un connettore che prende i dati dalla linea A0 o A2 (a seconda di come è impostato il jumper JLCD) e con essi invia ad un display seriale delle informazioni da visualizzare, riguardanti ad esempio la sequenza in fase di esecuzione, l’indirizzo assegnato al dispositivo DMX512 che si sta controllando, l’eventuale nome della sequenza memorizzata in microSD ecc.

Oltre a quanto descritto, nello shield abbiamo inserito il pulsante RST, che serve a resettare Arduino (agisce infatti cortocircuitando verso massa la linea RST) e P1, che viene letto dalla linea A1 di Arduino e può essere associato alla gestione della microSD, al controllo DMX512 o all’LCD.

Altri due elementi “per futuri sviluppi” sono i LED LD1 e LD2, che facciamo gestire ad Arduino tramite le sue linee digitali D7 e D8; anche con questi potete fare ciò che preferite, abbinandoli a funzioni del controllo DMX512 ecc. Nel nostro caso il diodo rosso si illumina quando Arduino trasmette una stringa di comando DMX512 sull’interfaccia RS485.

Piano di montaggio della shield DMX

Elenco componenti:

R1: 10 kohm
R2: 1 kohm
R3: 1 kohm
C1: 100 nF 
multistrato
P1: Microswitch
RST: Microswitch
LD1: LED 5 mm rosso
LD2: LED 5 mm giallo
U1: 74HC4050D
U2: MAX485
SD1: Connettore microSD (MICROSDSOCK2)

Varie:
- Strip Maschio/Femmina 3 poli (2 pz.)
- Strip Maschio/Femmina 6 poli (1 pz.)
- Strip Maschio/Femmina 8 poli (2 pz.)
- Strip Maschio/Femmina 10 poli (1 pz.)
- Zoccolo 4+4
- Strip Maschio 3 poli (5 pz.)
- Jumper (4 pz.)
- Connettore XLR 3 poli Femmina da CS
- Circuito stampato

Realizzazione pratica

Costruire lo shield è abbastanza semplice, dato che i pochi componenti utilizzati, ad eccezione del lettore di SD-Card e del 74HC5050, sono a montaggio tradizionale.

Per prima cosa saldate l’integrato 74HC5050, che va montato usando un saldatore da non più di 20 watt, a punta fine, e filo di lega saldante del diametro massimo di 0,5 mm; per il corretto montaggio, posizionate l’integrato ben centrato nelle rispettive piazzole, poi stagnate un pin su un angolo e aggiustate eventualmente l’allineamento, così da fermarlo nella posizione corretta.

Procedete con i restanti pin prestando attenzione a non cortocircuitare quelli vicini con eccesso di stagno.

Ora tocca al montaggio del lettore di microSD: per fare ciò posizionatelo in modo che i suoi contatti siano ben centrati nelle rispettive piazzole, quindi stagnate per prime le linguette di ancoraggio al circuito stampato e poi via-via i contatti. Fatto ciò, inserite e saldate le resistenze e i pulsanti per c.s., quindi i condensatori e lo zoccolo per il MAX485; concludete con i LED (da orientare come indicato nello schema di montaggio visibile in queste pagine) i jumper e il connettore XLR da circuito stampato. I jumper si ottengono semplicemente montando per ciascuno, nelle rispettive piazzole, un pin-strip da 3 punte, che per le impostazioni chiuderete con un jumper (cap) a passo 2,54 mm.

Per montare lo shield su Arduino dovete anche inserire e saldare in corrispondenza dei contatti sui lati lunghi dello stampato dei connettori SIL femmina a passo 2,54 mm con piedini lunghi almeno 20 mm: ne occorrono due pezzi da 8, uno da 6 ed uno da 10 contatti. Queste connessioni rendono lo shield adatto ad Arduino, Mega, UNO e compatibili.

Il firmware per la shield DMX

Con l’hardware ultimato, possiamo passare all’analisi del firmware che permette ad Arduino di creare ed inviare stringhe di comando a standard DMX512; prima di scendere nel dettaglio occorre ricordare che i comandi secondo tale protocollo vengono trasmessi come stringhe formate da un massimo di 512 byte, ognuno dei quali esprime 256 livelli di luminosità, oppure di movimento di un rotore sul quale vengono montati corpi illuminanti o altro, a seconda del dispositivo controllato.

Ciascuna stringa inizia con un impulso header (vedi l’apposito riquadro) a cui seguono in sequenza tutti i bit; ogni decoder/controller monocanale è impostato in modo da interpretare solo il proprio byte, mentre i decoder con controller pluricanale interpretano un intervallo di byte.

Perché ciò avvenga, ciascun decoder conta il numero di byte a partire dall’header.

Ne deriva che per raggiungere il decoder/controller contraddistinto da un certo indirizzo, Arduino deve generare una stringa che contenga tanti byte quanti sono i canali fino a quell’indirizzo: per esempio, volendo comandare la periferica che ha per address 128, il nostro sistema deve generare una stringa che contenga almeno i primi 128 byte (quelli dal 129 al 512 può anche non generarli, perché irrilevanti, contribuendo a mantenere una buona velocità di aggiornamento dei dispositivi DMX512).

Alla generazione delle stringhe provvede una libreria chiamata DMXSimple (ma ne esistono altre…).

All’interno della libreria vengono già forniti due sketch (vi accedete con il comando di menu Esempi): il primo permette di effettuare il fading (la dissolvenza…) di un canale DMX (vedi FadeUp, Listato 1) mentre il secondo consente di impostare il valore e il canale DMX tramite seriale (vedi SerialToDmx).

Nell’impostare gli indirizzi delle periferiche da controllare ricordate quanto detto poco fa, quindi se dovete intervenire su un decoder/controller DMX512, possibilmente impostate per esso un indirizzo basso; ciò vi permetterà di ridurre il lavoro di Arduino e velocizzare la scansione, così da poter agevolmente eseguire giochi di luce molto rapidi.

Oltre ai due sketch di esempio contenuti nella libreria, dal nostro sito potete scaricarne altri due chiamati FadeUpHSV, che esegue la dissolvenza tra i vari colori RGB, e DMX_LightSequencing, che permette di utilizzare il software Vixen, che gira su PC in ambiente Windows e vi consente di costruire sequenze di controllo luci definendo i canali da attivare ed eventualmente abbinando l’accensione e lo spegnimento di luci o l’attivazione di altri apparati DMX512, in determinati momenti della riproduzione di un brano musicale, che potete caricare dallo stesso programma.

Listato 1

/* Welcome to DmxSimple. This library allows you to control DMX stage and
** architectural lighting and visual effects easily from Arduino. DmxSimple
** is compatible with the Tinker.it! DMX shield and all known DIY Arduino
** DMX control circuits.
**
** DmxSimple is available from: http://code.google.com/p/tinkerit/
** Help and support: http://groups.google.com/group/dmxsimple */

/* To use DmxSimple, you will need the following line. Arduino will
** auto-insert it if you select Sketch > Import Library > DmxSimple. */

#include <DmxSimple.h>

void setup() {
/* The most common pin for DMX output is pin 3, which DmxSimple
** uses by default. If you need to change that, do it here. */
DmxSimple.usePin(3);

/* DMX devices typically need to receive a complete set of channels
** even if you only need to adjust the first channel. You can
** easily change the number of channels sent here. If you don’t
** do this, DmxSimple will set the maximum channel number to the
** highest channel you DmxSimple.write() to. */
DmxSimple.maxChannel(4);
}

void loop() {
int brightness;
/* Simple loop to ramp up brightness */
for (brightness = 0; brightness <= 255; brightness++) {

/* Update DMX channel 1 to new brightness */
DmxSimple.write(1, brightness);

/* Small delay to slow down the ramping */
delay(10);
}

I due sketch d’esempio contenuti nella libreria e FadeUpHSV sono stati da noi modificati per essere compatibili con lampade RGB controllabili in DMX (per esempio la lampada Velleman VDPLP64SB); dunque, in essi è sufficiente indicare l’indirizzo di partenza del DMX, poi Arduino fa il resto.

Soffermiamoci ora sul quarto esempio di sketch (Listato 2), chiamato DMX_LightSequencing, perché è quello che ci permette di interagire con Arduino mediante un PC e di fare quindi le cose più interessanti; in questo sketch, oltre all’indirizzo DMX512 di partenza, va specificato anche il numero di canali da gestire, nel senso che bisogna dire ad Arduino qual è l’address del primo canale e quanti canali seguono.

In questo modo Arduino potrà costruire la stringa necessaria, riempiendo con tanti byte a zero le posizioni corrispondenti agli indirizzi precedenti quello di partenza e terminando la stringa con il byte dell’indirizzo dell’ultimo canale. Ciò, come accennato, evita di sprecare risorse nella ricostruzione di quella parte di stringa che non serve.

Listato 2

/*
The purpose of this code is to allow the Arduino to use the 
generic serial output of vixen lights to control 5 channels of LEDs. 
*/

#include <DmxSimple.h>

const int jrde = 2;
const int jdi = 3;
const int jro = 4;
const int lr = 7;
const int ly = 8;

#define DELAY 10

int i = 0; // Loop counter
int incomingByte[25]; // array to store the 25 values from the serial port
int address=1;
int ch=16;
int k;

//setup the pins/ inputs & outputs
void setup()
{
Serial.begin(9600); // set up Serial at 9600 bps

pinMode(jrde, OUTPUT);
pinMode(jdi, OUTPUT);
pinMode(jro, INPUT);
pinMode(lr, OUTPUT);
pinMode(ly, OUTPUT);

digitalWrite(jrde, HIGH);

/* The most common pin for DMX output is pin 3, which DmxSimple
** uses by default. If you need to change that, do it here. */
DmxSimple.usePin(jdi);

/* DMX devices typically need to receive a complete set of channels
** even if you only need to adjust the first channel. You can
** easily change the number of channels sent here. If you don’t
** do this, DmxSimple will set the maximum channel number to the
** highest channel you DmxSimple.write() to. */
DmxSimple.maxChannel(ch);

for (k=0; k<ch+1; k++) {
DmxSimple.write(k+address,0); 
}

}

void loop()
{ // 25 channels are coming in to the Arduino
if (Serial.available() >= ch) {
// read the oldest byte in the serial buffer:
for (k=0; k<ch+1; k++) { 
incomingByte[k] = Serial.read();
}
//for (k=0; k<ch+1; k++) {
//Serial.print (“ch “); Serial.print (k); Serial.print (“ - value “); Serial.println (incomingByte[k]); 
//}

digitalWrite(lr, HIGH);

for (k=0; k<ch+1; k++) { // for all three colours
DmxSimple.write(k+address, incomingByte[k]);
}
} 

//delay(DELAY);
digitalWrite(lr, LOW);
}

Lo sketch va utilizzato in abbinamento al programma Vixen; questo software è in grado di funzionare praticamente su qualsiasi computer.

Con questo software è possibile creare delle sequenze luminose (ma non solo) eventualmente legate alla musica; una delle applicazioni più suggestive è l’abbinamento alle illuminazioni natalizie, di cui vedete una piccola demo in questo filmato.

Vixen ha diversi formati di output tra cui anche quello seriale (purtroppo è possibile selezionare solo le COM 1, 2, 3 o 4) che possiamo usare per una connessione USB da COM virtuale; selezionando la porta COM cui è collegato Arduino (Fig. 1), il software invia il valore che deve assumere ogni canale.

Arduino interpreta questi dati e gestisce di conseguenza i propri I/O digitali.

Normalmente, infatti, i progetti disponibili in “rete” prevedono che Arduino comandi le lampade, ovvero i loro controller, mediante le proprie uscite digitali, ma ciò limita di molto il numero di canali utilizzabili (anche utilizzando un Arduino MEGA le porte disponili sono 54).

Nella nostra applicazione, invece, utilizziamo la libreria DMX, la quale tramite lo shield DMX permette di gestire 512 canali (tra l’altro anche analogici).

In questo modo è possibile gestire svariate periferiche anche diverse dalle classiche luci, come ad esempio macchine del fumo e per la neve, strobo, teste rotanti ecc. Molti prodotti DMX li trovate nella categoria Sound and Light di Futuranet

Sul web si trovano tantissime sequenze già pronte; l’unica cosa da fare è impostare l’uscita della sequenza (ovvero la porta seriale) e programmare Arduino indicando il numero di canali utilizzati nella sequenza.