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.

Un petit schéma de principe :

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 :

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.

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

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.

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

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.

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« .

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

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

Ce qui donne :

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

#! /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

:

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.

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 :

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.

Relancez le script et la vie est bleue !
Voila pour la partie pyhton -> 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.

On crée une base nommée psc.

mysql -p
create database psc;
quit;

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

Puis on copie les fichiers web pour apache2

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

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

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.