Category Archives: dmx

Communication entre le bus KNX et un serveur Linux

Jusqu’à présent, j’ai découvert comment envoyer des ordres ou obtenir une valeur avec mon bus KNX.
Que ce soit en PHP ou par ligne de commande.

Mon souhait est de pouvoir faire l’inverse : depuis le bus KNX, de donner un autre à mon serveur.
Plusieurs applications possibles, en voici deux concrètes :

  • Allumer/couper les lumières d’ambiance DMX, changer les couleurs.
  • Allumer/couper le wifi.

C’est sans limite en fait.
Du moment où j’envois une commande (boutton poussoir) au serveur celui-ci peut être interprété comme bon me semble.
Je passe de l’électrique de puissance à l’informatique classique.

Comment ça marche ?

J’ai essayé de faire un schéma :

Schéma de principe de l'écoute du bus  KNX

Schéma de principe de l'écoute du bus KNX

Coté programmation, j’ai crée un groupe d’adresses 0/0/10 qui ne contient aucune action, le groupe est lié à l’interrupteur bouton poussoir.

Configuration ETS4 avec un groupe vite pour le DMX

Configuration ETS4 avec un groupe vite pour le DMX

Notre serveur, équipé d’eibnetmux (lien vers son installation) utilise grouplisten pour écouter ce qu’il se passe sur le bus KNX pour un Groupe d’Adresse spécifié, ici le GA 0/0/10.

La fonction grouplisten est exécutée en même temps que le démarrage d’eibnetmux, j’ai rajouté quelques lignes à partir de mon script initial.
La sortie de cette commande est redirigée vers un fichier.

#
# Function that starts the daemon/service
#
do_start()
{
echo -n "Starting eibdnetmux"
/usr/local/bin/eibnetmux $DAEMON_ARGS
echo " done"
sleep 2
echo -n "Starting group listen"
/usr/local/bin/grouplisten ip:127.0.0.1 0/0/10 > /tmp/knx_0-0-10 &
echo " done"
}

Je vais me servir de ce fichier pour surveiller les changements d’état.
J’utilise l’outil logtail pour vérifier les nouveaux évènements.

Pour cet exemple, je souhaite que l’utilisation du bouton poussoir allume mon bandeau RGB, dont j’ai récemment effectué l’installation.

# touch /usr/local/bin/knx2dmx
# chmod +x /usr/local/bin/knx2dmx
# vi /usr/local/bin/knx2dmx
#!/bin/bash

lockfile=/tmp/knx2dmx.run
if [[ -f $lockfile ]] ; then
    echo "knx2dmx déjà en cours d'exécution ou supprimer le fichier $lockfile"
    exit
fi
touch $lockfile

groupaddress=$1
file=/tmp/knx_$groupaddress

bouclette="yes"
# Boucle sans fin
while [ $bouclette = "yes" ]
 do
 {
  # Mais on est pas à 1 seconde près
  sleep 1
   value=`/usr/sbin/logtail -f -o $file | grep "Write" | cut -d" " -f4`
  if [ "$value" == 01 ]
  then
        # Ici j'allume mon bandeau RGB, mais toute autre action est envisageable
        /usr/local/bin/dmxchangecolorfader.py 255 25 100
  elif [ "$value" == 00 ]
  then
        # Je l'éteinds
        /usr/local/bin/dmxchangecolor.py 0 0 0
 fi
 }
done

Et celui là, je le lance dans le cron.

*/10 *          * * *   root    /usr/local/bin/knx2dmx 0-0-10

Donc si mon script, via logtail, détecte que l’adresse de groupe 0/0/10 KNX passe à 1, il allume le strip RGB DMX.
A l’inverse, s’il détecte un 0, il l’éteint.

A titre de supplément, le script dmxchangecolor.py est celui abordé dans l’installation d’OLA.

#!/usr/bin/python
import sys, array
from ola.ClientWrapper import ClientWrapper

def DmxSent(state):
  wrapper.Stop()

universe = 1
data = array.array('B')
data.append(int(sys.argv[1]))
data.append(int(sys.argv[2]))
data.append(int(sys.argv[3]))
wrapper = ClientWrapper()
client = wrapper.Client()
client.SendDmx(universe, data, DmxSent)
wrapper.Run()

Et le script dmxchangecolorfader.py provient aussi de la page wiki d’OLA.
Que j’ai beaucoup bidouillé car je ne sais pas codé en python :
Je n’en suis pas fier, surtout qu’il ne faut pas mettre de valeur à 0.

#!/usr/bin/python
import sys, array
from ola.ClientWrapper import ClientWrapper

red_arg = int(sys.argv[1])
green_arg = int(sys.argv[2])
blue_arg = int(sys.argv[3])

red = 0
green = 0
blue = 0

wrapper = None
loop_count = 0
TICK_INTERVAL = 10  # in ms

def DmxSent(state):
  if not state.Succeeded():
    wrapper.Stop()

def SendDMXFrame():
  # schdule a function call in 100ms
  # we do this first in case the frame computation takes a long time.
  wrapper.AddEvent(TICK_INTERVAL, SendDMXFrame)

  # compute frame here
  data = array.array('B')
  global loop_count
  global red
  global green
  global blue

  if red == (red_arg-1):
    data.append(red_arg)
  else:
    red = loop_count % red_arg
    data.append(red)

  if green == (green_arg-1):
    data.append(green_arg)
  else:
    green = loop_count % green_arg
    data.append(green)

  if blue == (blue_arg-1):
    data.append(blue_arg)
  else:
    blue = loop_count % blue_arg
    data.append(blue)

  loop_count += 1

  if (red == (red_arg-1)) and (green == (green_arg-1)) and (blue == (blue_arg-1)):
    exit()

  # send
  wrapper.Client().SendDmx(1, data, DmxSent)

wrapper = ClientWrapper()
wrapper.AddEvent(TICK_INTERVAL, SendDMXFrame)
wrapper.Run()

Résultat

Pour aller plus loin avec un frontend php

Et voila ! Une bonne base pour faire interagir le serveur depuis le bus KNX.
Je pourrai rajouter autant de grouplisten que necessaire, mais dans une certaine mesure, il sera certainement préférable d’écouter tout ce qu’il se passe sur le bus via groupsocketlisten.

Avec un principe un petit peu différent :

Utilisation de groupsocketlisten pour une interface web

Utilisation de groupsocketlisten pour une interface web

Dans ce cas, groupsocketlisten écoute tout ce qu’il se passe sur le bus.
Un script PHP est à l’écoute des informations, certainement sur le même principe du logtail.
Il filtre et remplit des informations dans la base de données MySQL.

Cette partie là est intéressante, si par exemple, j’allume une lumière derrière un variateur TXA213, groupsocketlisten y voit défiler deux informations :

Write from 0.2.189 to 0/0/1: 01
Write from 1.1.2 to 0/0/7: 01
Write from 1.1.2 to 0/0/8: AF

Ici, j’ai allumé ma lumière grâce à un « groupswrite ip:127.0.0.1 0/0/1 1 », je le vois sur mon bus (0.2.189).
Et deux autres informations utiles y circulent :
– 0/0/7 correspond à l’indicateur d’état, à 01 donc ma lampe est allumée.
– 0/0/8 correspond à l’indicateur de la valeure d’éclairement en hexadécimale sur FF (255).
Ici la valeur hexa AF (FF étant le max) correspond à 175 en décimale (255 étant le max).
Ainsi, avec un base de données bien pensée, il est possible de faire un filtre intelligent : un type d’objet c’est tant et tant d’information à récolter avec tels et tels groupes d’adresses.
On peut pousser le bouchon plus loin, c’est ce « frontend » PHP qui pourrait exécuter des actions sur le système tel que l’allumage DMX.

Une fois la BDD avec des informations actualisées, il ne reste plus qu’à les exploiter à travers une page web.

Une solution qui me semble bonne pour les fondations d’une bonne usine à gaz.
Je vais commencer quelque chose dans ce principe pour un prochain article.

Posté dans Debian, dmx, KNX, led, Sysadmin | 2 Commentaires

Installation d’OLA et prise en main du DMX à travers python & php

Maintenant que notre contrôleur compatible Open DMX, nous allons pouvoir l’exploiter logicielement.
Mon but étant de pouvoir changer la couleur (ce qui reviens à allumer/éteindre) en quelques clics ; ainsi que de voir ce qu’il est possible de faire en ligne de commande et idéalement de changer la couleur depuis une page web.

La platine de test DMX

Mon installation est composée de :

  • DMX USB PC V3 (Contrôleur USB / DMX) → 36,50 €.
  • Câble XLR de récup → 0 €.
  • Décodeur DMX RGB → 23,08 €.
  • Alim 12V de récup → 0 €.
  • Câble pour connecter les bandeaux RGB → 1,50 €.
  • 2x Bandeau RGB 12V 5050 30cm → 1,35 € / pièce.
  • Bouchon DMX , livré avec le DMX USB PC → 0 €.

Soit  environ 67 € le tout, frais de ports inclus.

Platine de tests DMX

Platine de tests DMX

Un petit schéma de principe :

Schéma de principe de la phase de tests

Schéma de principe de la phase de tests

En phase final, je compte remplacer le XLR par de l’Ethernet et le strip RGB par des spots encastrables LED RGB de ce style :

Spot encastrable LED RGB 10mm

Spot encastrable LED RGB 10mm

Le revendeur est l’ancien Eurolite.de, devenu Steinigke Showtechnic : la fiche produit du spot encastable LED RGB 10mm.

Installation de Open Lighting Architecture (OLA)

Toujours depuis une Debian Wheezy, on commence par installer différents paquets qui seront nécessaire pour la compilation.

# apt-get install flex libmicrohttpd5 bison libprotobuf-dev protobuf-compiler uuid uuid-dev libcppunit-dev python python-protobuf build-essential
# ldconfig

Et on récupère l’archive d’OLA.

# cd /usr/src/
# wget http://linux-lighting.googlecode.com/files/ola-0.8.18.tar.gz
# tar zxvf ola-0.8.18.tar.gz
# cd ola-0.8.18
# ./configure --enable-python-libs --enable-http

Le « enable-python-libs » permettra d’envoyer des commandes DMX à partir d’un script python.
Le « enable-http » permettra d’utiliser de tester ola à travers une page http.

# make
# make install
# ldconfig

Et voila ! C’est installé.
Ola exige d’être démarré avec un utilisateur non root.

# adduser --disabled-password ola
# su ola

Avant cette première exécution, il est important de veiller à ce que le contrôleur USB/DMX soit reconnu en tant que /dev/dmx0.

# olad -l 3

Le 3 (/4) correspond au niveau de verbosity.

Vous devriez voir au moins ces lignes apparaîtrent :

PluginManager.cpp:74: Trying to start Enttec Open DMX
DeviceManager.cpp:111: Installed device: OpenDmx USB Device:6-0
PluginManager.cpp:78: Started Enttec Open DMX

Si vous avez installez libmicrohttpd5, vous devriez pouvoir accéder à la page http://ip_du_serveur_ola:9090 .
Et configurer votre fixture aka « universe« .

Page de configuration des univers

Page de configuration des univers

J’ai attribué au contrôleur RGB l’adressage DMX 1.
Dont la notice a été scannée.

adressage DMX du contrôleur RGB

adressage DMX du contrôleur RGB

Dans l’onglet Console, je peux modifier la valeur de mes trois canaux RGB et donc chacune des trois couleurs.

Console ola pour contrôleur RGB

Console ola pour contrôleur RGB

Ce qui donne :

Rendu instantané entre OLA et le strip RGB

Rendu instantané entre OLA et le strip RGB

Youpi !
De quoi être tranquille au démarrage de la machine, j’ai pondu ce petit init.d script pour ola à partir du skeleton.

# vi /etc/init.d/olad
#! /bin/sh
### BEGIN INIT INFO
# Provides:          olad
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: olad initscript
# Description:       Open Lighting Architecture init script
### END INIT INFO

# Author: Lionel / domolio.fr
#

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/bin/
DESC="Open Lighting Architecture Daemon"
NAME=olad
DAEMON=/usr/local/bin/$NAME
DAEMON_ARGS="-f"
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME
USER=olad

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started
        start-stop-daemon --start --chuid $USER --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
                || return 1
        start-stop-daemon --start --chuid $USER --quiet --pidfile $PIDFILE --exec $DAEMON -- \
                $DAEMON_ARGS \
                || return 2
        # Add code here, if necessary, that waits for the process to be ready
        # to handle requests from services started subsequently which depend
        # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
        # Return
        #   0 if daemon has been stopped
        #   1 if daemon was already stopped
        #   2 if daemon could not be stopped
        #   other if a failure occurred
        start-stop-daemon --chuid $USER --stop --quiet --retry=TERM/10/KILL/5 --pidfile $PIDFILE --name $NAME
        RETVAL="$?"
        [ "$RETVAL" = 2 ] && return 2
        # Wait for children to finish too if this is a daemon that forks
        # and if the daemon is only ever run from this initscript.
        # If the above conditions are not satisfied then add some other code
        # that waits for the process to drop all resources that could be
        # needed by services started subsequently.  A last resort is to
        # sleep for some time.
        start-stop-daemon --chuid $USER --stop --quiet --oknodo --retry=0/10/KILL/5 --exec $DAEMON
        [ "$?" = 2 ] && return 2
        # Many daemons don't delete their pidfiles when they exit.
        rm -f $PIDFILE
        return "$RETVAL"
}

#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
        #
        # If the daemon can reload its configuration without
        # restarting (for example, when it is sent a SIGHUP),
        # then implement that here.
        #
        start-stop-daemon --chuid $USER --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
        return 0
}

case "$1" in
  start)
        [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
        do_start
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  stop)
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
        do_stop
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  status)
        status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
        ;;
  #reload|force-reload)
        #
        # If do_reload() is not implemented then leave this commented out
        # and leave 'force-reload' as an alias for 'restart'.
        #
        #log_daemon_msg "Reloading $DESC" "$NAME"
        #do_reload
        #log_end_msg $?
        #;;
  restart|force-reload)
        #
        # If the "reload" option is implemented then remove the
        # 'force-reload' alias
        #
        log_daemon_msg "Restarting $DESC" "$NAME"
        do_stop
        case "$?" in
          0|1)
                do_start
                case "$?" in
                        0) log_end_msg 0 ;;
                        1) log_end_msg 1 ;; # Old process is still running
                        *) log_end_msg 1 ;; # Failed to start
                esac
                ;;
          *)
                # Failed to stop
                log_end_msg 1
                ;;
        esac
        ;;
  *)
        #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
        echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
        exit 3
        ;;
esac

:
# chmod +x /etc/init.d/olad
# insserv olad

Ainsi Open Lighting Architecture sera lancé à chaque démarrage.

Conclusion d’OLA

Cool, ça prend forme !
Il manque un gros détail : ça ne me semble pas viable de contrôler les couleurs à travers l’interface d’administration d’OLA, j’ai besoin de le faire en dehors de cette interface.
D’où l’intérêt d’avoir installé les libraires python d’Open Lighting Architecture.

Prise de contrôle du DMX par PHP & Python

Mon idée est de pouvoir disposer d’une roue chromatique depuis mon smartphone et pouvoir changer les couleurs de mon escalier, par exemple, pour la frime par challenge.
OLA a été installé avec des librairies python, servons-nous en.
Le wiki d’OLA fait part de scripts simple en pyhton.

# vi testcolor.py
import array
from ola.ClientWrapper import ClientWrapper

def DmxSent(state):
  wrapper.Stop()

universe = 1
data = array.array('B')
data.append(10)
data.append(50)
data.append(255)
wrapper = ClientWrapper()
client = wrapper.Client()
client.SendDmx(universe, data, DmxSent)
wrapper.Run()

En ayant olad d’exécuté, on lance :

# python testcolor.py

Si le script ne vous retourne rien et vous éclaire d’un joli bleu, tant mieux !

A l’inverse, si le script python retourne ceci :

Traceback (most recent call last):
  File "testor.py", line 2, in 
    from ola.ClientWrapper import ClientWrapper
ImportError: No module named ola.ClientWrapper

C’est que libraires d’OLA ne sont pas importables par le script.
L’une des solutions consiste à copier les libraires dans le script de travail de python.

# cp -r /usr/local/lib/python2.7/site-packages/ola /usr/lib/python2.7/

Relancez le script et la vie est bleue !
Voila pour la partie pyhton -> DMX.

Color Picker pour DMX

Color Picker pour DMX


Place maintenant à la partie PHP Python.
Dans mon délire d’avoir une roue chromatique ou quelque chose qui y ressemble, j’ai utilisé un script jQuery.

J’ai modifié le script pyhton pour lui passer les couleurs RGB en argument :

#!/usr/bin/python
import sys, array
from ola.ClientWrapper import ClientWrapper

def DmxSent(state):
  wrapper.Stop()

universe = 1
data = array.array('B')
data.append(int(sys.argv[1]))
data.append(int(sys.argv[2]))
data.append(int(sys.argv[3]))
wrapper = ClientWrapper()
client = wrapper.Client()
client.SendDmx(universe, data, DmxSent)
wrapper.Run()

Script nommé dmxchangecolor.py placé dans /usr/local/bin/ avec droit en éxecution.

Ma page php :

<?php
function html2rgb($color) {
    if ($color[0] == '#')
        $color = substr($color, 1);
    if (strlen($color) == 6)
        list($r, $g, $b) = array($color[0].$color[1],
                                 $color[2].$color[3],
                                 $color[4].$color[5]);
    elseif (strlen($color) == 3)
        list($r, $g, $b) = array($color[0].$color[0], $color[1].$color[1], $color[2].$color[2]);
    else
        return false;
    $r = hexdec($r); $g = hexdec($g); $b = hexdec($b);
    return array($r, $g, $b);
}

if(isset($_POST['envoyer'])) {
        $htmlcolor = $_POST['htmlcolor'];
        $rgb = html2rgb($htmlcolor);
        exec("dmxchangecolor.py $rgb[0] $rgb[1] $rgb[2]");
}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <link rel="stylesheet" href="css/colorpicker.css" type="text/css" />
    <link rel="stylesheet" media="screen" type="text/css" href="css/layout.css" />
    <title>ColorPicker DMX - jQuery plugin</title>
    <script type="text/javascript" src="js/jquery.js"></script>
    <script type="text/javascript" src="js/colorpicker.js"></script>
    <script type="text/javascript" src="js/eye.js"></script>
    <script type="text/javascript" src="js/utils.js"></script>
    <script type="text/javascript" src="js/layout.js?ver=1.0.2"></script>
</head>
<body>
<form action="" method="post" >
        <input type="text" maxlength="6" size="6" id="colorpickerField" name="htmlcolor" value="<?php echo $htmlcolor ?>" /><br />
        <input type="submit" value="Envoyer" name="envoyer" />
</form>
</body>
</html>

Simple et efficace, je choisis ma couleur, valide le formulaire, la fonction php convertit la couleur HTML en RGB qui la soumet au script python.

Télécharger le script PHP/jQuery/DMX.

Et voila ! J’aurais préféré une libraire PHP comme pour le KNX et le 1-wire, mais je n’en ai pas trouvé malheureusement.
Passer les couleurs à un script python lui même appelé commande php, ça fera l’affaire pour ma future machine à gaz.

Php Show Controller

Autrement, j’ai découvert Php Show Controller (PSC) et son sympathique créateur Laurent.
https://github.com/RenZ0/php-show-controller

L’outil est très intéressant si l’on souhaite scénariser ses lumières.
Le principe est résumé dans le README :

With php interface you change sql data.
Python engine reads sql data, and send it to OLA.
OLA use your hardware to send DMX signal.

Le paquet a un petit défaut, il n’est pas encore compatible PHP 5.4 car il exige les register_globals (qui ont disparus depuis php 5.4)
Mais d’après l’auteur, les modifications sont pour très bientôt, pour les impatients, en modifiant les quelques GET et POST vous pourrez vite vous faire une idée de la puissance de PSC.

Voici comment l’installer :
Il faut dans un premier temps python-mysqldb et bien sûr un serveur MySQL.

# apt-get install python-mysqldb mysql-server
# wget "http://www.imaginux.com/ccount/click.php?id=148" -O php-show-controller_1.1.1.tar.gz
# tar zxvf php-show-controller_1.1.1.tar.gz
# cd php-show-controller

On crée une base nommée psc.

mysql -p
create database psc;
quit;

On importe la structure et les paramètres de base :

# gzip -d sql/psc_base.sql.gz
# mysql -p psc < sql/psc_base.sql

Puis on copie les fichiers web pour apache2

# cp -r psc/ /var/www/
# cd /var/www/
# chown -R www-data:www-data psc

On modifie le fichier des paramètres MySQL pour que PHP s’en serve :

# vi psc/config.php

Et les paramètres MySQL pour que pyton utilise également MySQL :

# cd /usr/src/php-show-controller/engine/
# vi config.py

Et rendez-vous sur la page web de votre installation pour découvrir PSC.
N’oubliez pas de vous aider de README pour le paramétrage de votre scénario.

Conclusion

Après avoir installé les drivers Open DMX USB, après avoir installé Open Lighting Architecture et ses libraires, après avoir testé un scripts python et php.
Je suis sûr et certain de pouvoir introduire des lumières d’ambiances dans mon projet domotique.
Escalier, pièces à vivre, informations lumineuses, les idées sont nombreuses, mais je sais que je pourrais le faire et introduire les interactions dans mon usine à gaz par l’intermédiaire de pages php.

Posté dans Debian, dmx, led, Open DMX | 9 Commentaires

Installation du contrôleur USB DMX (OpenDMX) sur Debian Wheezy

DMX USB PC v3

DMX USB PC v3

Ça y’est ! J’ai acquis tout le matériel me permettant d’effectuer des tests de DMX pour mon projet de lumières d’ambiances dans notre future maison.
J’ai opté pour un « DMX USB PC V3 » sur eBay, 36,50 € en enchère classique.
Après utilisation avec FreeStyler sous Windows, je peux être très content de mon achat, il répond à tous mes besoins, entre autres financiers.
Je n’anime pas de soirées, je souhaite simplement entre autre éclairer mes escaliers.

Il ne reste plus qu’à l’exploiter sur ma VirtualBox.
Le petit bémol est lié à la domination du produit d’Enttec Open DMX USB qui rend les recherches difficiles, mais au final, rien ne change, c’est effectivement 100% Open DMX compatible.

Installation du driver Open DMX

Si ce n’est pas encore fait, il faut installer le nécessaire pour récupérer et compiler les sources du driver.

# apt-get install git curl build-essential

Ensuite, il nous faudrait les headers et les sources du kernel pour la compilation.

# apt-get install linux-headers-$(uname -r) linux-source

Enfin, nous récupérons les sources du driver dmx usb module.

# cd /usr/src/
# git clone git://github.com/lowlander/dmx_usb_module.git
# cd dmx_usb_module/

MISE A JOUR 26/07/2012 :
la partie ci-dessous n’est plus utile depuis que l’auteur a adapté ses sources pour les kernels en 3.x ; cependant, je ne retirer pas le détail pour les lecteurs qui utilisent – à tord – des sources non actuelles.
Avec des sources à jour, passez directement au make.

Etant sous Debian Wheezy avec un kernel 3.2.0, il est nécessaire de modifier les sources :
(vu sur le tutoriel d’Open DMX).
Sans quoi, il est possible de rencontrer cette erreur :

/usr/src/dmx_usb_module/dmx_usb.c:21:28: fatal error: linux/smp_lock.h: Aucun fichier ou dossier de ce type
compilation terminated.

Ou bien, celle-ci :

/usr/src/dmx_usb_module/dmx_usb.c:95:8: warning: type defaults to 'int' in declaration of 'DECLARE_MUTEX' [-Wimplicit-int]
/usr/src/dmx_usb_module/dmx_usb.c:95:1: warning: parameter names (without types) in function declaration [enabled by default]
/usr/src/dmx_usb_module/dmx_usb.c:123:2: error: unknown field 'ioctl' specified in initializer
/usr/src/dmx_usb_module/dmx_usb.c:123:2: warning: initialization from incompatible pointer type [enabled by default]
/usr/src/dmx_usb_module/dmx_usb.c:123:2: warning: (near initialization for 'dmx_usb_fops.aio_read') [enabled by default]
/usr/src/dmx_usb_module/dmx_usb.c: In function 'dmx_usb_open':
/usr/src/dmx_usb_module/dmx_usb.c:298:9: error: 'disconnect_sem' undeclared (first use in this function)
/usr/src/dmx_usb_module/dmx_usb.c:298:9: note: each undeclared identifier is reported only once for each function it appears in
/usr/src/dmx_usb_module/dmx_usb.c: In function 'dmx_usb_probe':
/usr/src/dmx_usb_module/dmx_usb.c:620:2: error: implicit declaration of function 'init_MUTEX' [-Werror=implicit-function-declaration]
/usr/src/dmx_usb_module/dmx_usb.c: In function 'dmx_usb_disconnect':
/usr/src/dmx_usb_module/dmx_usb.c:731:9: error: 'disconnect_sem' undeclared (first use in this function)
/usr/src/dmx_usb_module/dmx_usb.c: At top level:
/usr/src/dmx_usb_module/dmx_usb.c:95:8: warning: 'DECLARE_MUTEX' declared 'static' but never defined [-Wunused-function]

Donc c’est parti pour la chasse aux modifs…

# vi dmx_usb.c

Supprimer la ligne 21, ce qui donne :

#include <linux/module.h>
#include <linux/completion.h>

Au lieu de :

#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>

D’autres modifications :

/* prevent races between open() and disconnect() */
static DECLARE_MUTEX (disconnect_sem);

Devient :

/* prevent races between open() and disconnect() */
static DEFINE_SEMAPHORE(disconnect_sem);

Une autre modif,

.write =        dmx_usb_write,
.ioctl =        dmx_usb_ioctl,
.open =         dmx_usb_open,

Devient :

.write =        dmx_usb_write,
.unlocked_ioctl =	dmx_usb_ioctl,
.open =         dmx_usb_open,

Pour terminer,

init_MUTEX (&dev->sem);
dev->udev = udev;

Devient :

sema_init(&dev->sem, 1);
dev->udev = udev;

J’ai crée un patch, mais le git est régulièrement soumis à des modifications, d’où la présence du détail ci-dessus.
Voici le patch à enregistrer sous dmx_usb_patch.txt

--- dmx_usb_original.c  2012-04-20 17:13:47.508349903 +0200
+++ dmx_usb.c   2012-04-20 17:17:41.894998153 +0200
@@ -18,7 +18,6 @@
 #include
 #include
 #include
-#include
 #include
 #include
 #include
@@ -93,7 +92,7 @@

 /* prevent races between open() and disconnect() */
-static DECLARE_MUTEX (disconnect_sem);
+static DEFINE_SEMAPHORE(disconnect_sem);

 /* local function prototypes */
 //static ssize_t dmx_usb_read  (struct file *file, char *buffer, size_t count, loff_t *ppos);
@@ -121,7 +120,7 @@

        /* .read =              dmx_usb_read, */
        .write =        dmx_usb_write,
-       .ioctl =        dmx_usb_ioctl,
+       .unlocked_ioctl =   dmx_usb_ioctl,
        .open =         dmx_usb_open,
        .release =      dmx_usb_release,
 };
@@ -618,7 +617,7 @@
        }
        memset (dev, 0x00, sizeof (*dev));

-       init_MUTEX (&dev->sem);
+       sema_init(&dev->sem, 1);
        dev->udev = udev;
        dev->interface = interface;

Il s’applique ainsi :

# patch &gt; dmx_usb_patch.txt

S’il retourne autre chose que « patching file dmx_usb.c » c’est que le git a été modifié entre la rédaction de cet article et votre installation ; il ne reste plus qu’à remonter les erreurs les unes après les autres.

MISE A JOUR 26/07/2012 :
Ici prenne fin les modifications pour les kernels inférieur à 3.x

Installer le driver OpenDMX sous Ubuntu

Sous Ubuntu, vous devrez modifier le fichier dmx_usb.c pour remplacer chaque occurence de err( en pr_err( .Sans quoi, vous obtiendrez le message d’erreur suivant :

/home/quentin/Bureau/dmx_usb_module/dmx_usb.c: In function ‘dmx_usb_setup’:
/home/quentin/Bureau/dmx_usb_module/dmx_usb.c:256:3: erreur: implicit declaration of function ‘err’ [-Werror=implicit-function-declaration]
cc1: some warnings being treated as errors
make[2]: *** [/home/quentin/Bureau/dmx_usb_module/dmx_usb.o] Erreur 1
make[1]: *** [_module_/home/quentin/Bureau/dmx_usb_module] Erreur 2
make[1]: quittant le répertoire « /usr/src/linux-headers-3.5.0-27-generic »
make: *** [default] Erreur 2

Merci à Quentin (cf commentaires).

Compilation

Place à la compilation et l’installation du driver :

# make
# cp dmx_usb.ko /lib/modules/$(uname -r)/kernel/drivers/usb/serial/
# depmod

Et un petit reboot pour être sûr.

Après insertion du contrôleur DMX USB PC V3 sur une prise USB, dmesg doit absolument vous retourner ceci :

/usr/src/dmx_usb_module/dmx_usb.c: DMX USB device now attached to dmx0

S’il vous est retourné ttyUSB0 au lieu de dmx0, c’est en raison de l’utilisation ftdi_sio au lieu de dmx_usb que nous venons de compiler.

La solution consisterait à décharger ftdi_sio et usbserial (rmmod ftdi_sio) mais ça serait très embêtant pour l’utilisation d’un éventuel autre adaptateur USB/serial.

Je me suis inspiré d’un article intitulé Gérer un pilote USB avec UDEV pour créer un fichier rules:

# vi /etc/udev/rules.d/99-dmx-usb.rules

Fichier rules qui contient ceci :

ATTRS{idVendor}=="0403",
ATTRS{idProduct}=="6001",
PROGRAM="/bin/sh -c 'echo -n $id:1.0 > /sys/bus/usb/drivers/ftdi_sio/unbind;  echo -n $id:1.0 > /sys/bus/usb/drivers/dmx_usb/bind'",
MODE="0666"

A noter que le contrôleur USB ce présente comme ceci :

# lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 002: ID 80ee:0021 VirtualBox USB Tablet
Bus 002 Device 003: ID 04fa:2490 Dallas Semiconductor DS1490F 2-in-1 Fob, 1-Wire adapter
Bus 002 Device 004: ID 0403:6001 Future Technology Devices International, Ltd FT232 USB-Serial (UART) IC

La présence du contrôleur USB/DMX n’entraîne pas de changement pour le DS9404 USB/1-Wire.

Lors de la connexion au port USB (ou au rattachement via VirtualBox dans mon cas), dmesg donne ceci :

[   43.643958] usb 2-3: new full-speed USB device number 4 using ohci_hcd
[   44.184274] usb 2-3: New USB device found, idVendor=0403, idProduct=6001
[   44.184278] usb 2-3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[   44.184281] usb 2-3: Product: FT232R USB UART
[   44.184283] usb 2-3: Manufacturer: FTDI
[   44.184285] usb 2-3: SerialNumber: AH014RWJ
[   44.247045] usbcore: registered new interface driver usbserial
[   44.247061] USB Serial support registered for generic
[   44.247885] usbcore: registered new interface driver usbserial_generic
[   44.248222] usbserial: USB Serial Driver core
[   44.264304] USB Serial support registered for FTDI USB Serial Device
[   44.264682] ftdi_sio 2-3:1.0: FTDI USB Serial Device converter detected
[   44.264794] usb 2-3: Detected FT232RL
[   44.264796] usb 2-3: Number of endpoints 2
[   44.264799] usb 2-3: Endpoint 1 MaxPacketSize 64
[   44.264801] usb 2-3: Endpoint 2 MaxPacketSize 64
[   44.264803] usb 2-3: Setting MaxPacketSize 64
[   44.288179] usb 2-3: FTDI USB Serial Device converter now attached to ttyUSB0
[   44.288218] usbcore: registered new interface driver ftdi_sio
[   44.288222] ftdi_sio: v1.6.0:USB FTDI Serial Converters Driver
[   44.300042] usbcore: registered new interface driver dmx_usb
[   44.300044] /usr/src/dmx_usb_module/dmx_usb.c: DMX USB Driver v0.1.20101106
[   44.320269] ftdi_sio ttyUSB0: FTDI USB Serial Device converter now disconnected from ttyUSB0
[   44.320311] ftdi_sio 2-3:1.0: device disconnected
[   44.363993] /usr/src/dmx_usb_module/dmx_usb.c: DMX USB device now attached to dmx0

Pour terminer cette première partie, il est nécessaire que le contrôleur Open DMX USB soit lié à /dev/dmx0 avec des droits élargis en lecture et écriture aux utilisateurs du système :

# ls -lh /dev/dmx0
crw-rw-rwT 1 root root 180, 0 avril 20 19:43 /dev/dmx0

Si ce n’est pas le cas, pas la peine d’aller plus loin, il y’a un couac quelque part, retour à la case départ.

Coté matériel, c’est maintenant terminé. Le matériel est reconnu, les modules sont chargés.

Place à l’exploitation logiciel du DMX avec l’installation de Open Lighting Architecture pour Debian Wheezy afin de contrôleur des spots RGB.

Posté dans dmx, Open DMX | 7 Commentaires

Bientôt la découverte du DMX en domotique

Escalier éclairé par LED. source : dmx74.com

Escalier éclairé par LED. source : dmx74.com

L’escalier éclairé en rouge pour un mail important non lu, voila une idée qui fait sourire.

J’ai l’intention d’exploiter le DMX pour certains points d’éclairages de mon projet maison.
De la simple veilleuse, à la maison communiquante, il est possible de faire de multiples choses très sympas…
Éclairage de l’escalier avec spots encastrées.
– Lumière d’ambiance.
Spot encastré à l’extérieur (telle une piste d’atterrissage).
Ambilight DIY.
Constellation dans le plafond en fibre optique.
– Spot encastrés dans le parquet ou dans le faux plafond pour délimiter des espaces.
– Etc … Le créatif n’a pas de limite !

Ce projet va me rappeler mon bac STI Electronique, à l’époque orienté sur une console DMX et son scanner.

L’utilisation du DMX dans la maison intelligente est tutorialisée dans un article très complet de Christophe Nowicki :
Gestion de la lumière d’ambiance avec le protocole DMX sous Debian GNU/Linux

Y ‘a tout ce qu’il faut !
Sauf que je trouve l’utilisation du XLR sur l’Ethernet un peu onéreux pour une phase de tests, mais bien pratique en prod, je le conçois.
L’alim à 21 $ … J’ai un vieux boitier externe SATA, son alim 12V ferra parfaitement l’affaire.
Le contrôleur RGB à 32.80 $, y’ a un peu moins cher.

Au final, j’ai acheté sur un site d’enchère, frais de ports inclus :

  • Cordon d’alimentation RGB Strip : 1.99 $
  • Bandeau 30cm RGB 5050 : 3.38 $
  • DMX-512 Decodeur RGB (qui fait XLR et Ethernet) : 30.38 $
Enttec Open DMX USB

Enttec Open DMX USB

J’ai récupéré des câbles XLR.
Il me manque le contrôleur USB / DMX, le plus important ! *snif*
Il coûte assez cher.
Je me pose régulièrement la question de l’utilisation d’un autre contrôleur que la référence du marché : Open DMX USB d’Enttec.
J’ai du mal à comprendre comment Enttec fait pour produire un contrôleur dans une boîte de 5 cm, tandis que les concurrents le font dans le profilé de la prise XLR.

DMX_USB_PC par DMX FH

DMX_USB_PC par DMX FH

Après lecture de certains forums, il semblerait qu’il y’ ait une différence de qualité entre le produit Enttec et ses acolytes, ainsi qu’une différence de protection électrique entre le modèle Enttec simple et l’Enttec Pro, je ne suis pas un pro et je ne compte pas animer des soirées, mais au vu de la faible différence de prix entre le produit de marque Enttec et les produits semblables, j’ai tendance à m’engager sur le Enttec.
Sauf que … j’attends une bonne occasion pour l’acheter, je guette eBay et leboncoin à l’affût de la bonne affaire.
Malgré que … les autres contrôleurs se disent 100% Open DMX compatible, donc compatible logiciellement.
Pour l’instant …
Je fais de la lumière avec mon contrôleur LED et mes Strips RGB.
Vivement le contrôleur USB DMX

Vivement le contrôleur USB DMX !!!

Posté dans dmx, led | Laisser un commentaire