Étiquette : cajon

Commande lumière pour percussion (DMX/Raspberry pi)

J’ai un petit groupe de musique dans lequel je fais de la percussion avec petit set Cajon + accessoires, pour faire une mini batterie transportable à vélo… Nous sommes amateurs ; j’ai rejoint le groupe en cours de route, et ils avaient collectivement acheté la table de mixage et la sono pour les concerts. De mon côté, je me suis dit que j’allais mettre au pot en achetant les lumières.

Un jour, à la déchetterie, j’ai trouvé 2 petits projecteurs LED RVB pilotables par DMX : « Algam Lighting SLIMPAR 710 HEX« . Ils étaient hors d’usage, mais après le passage entre les mains d’un ami magicien de l’électronique, ils ont ressuscités 🙂

Je me suis tout de même procuré une interface USB>DMX (Enttec Open DMX USB Interface Bundle) afin de pouvoir piloter mes jouets.

Les projecteurs LED RVB connectés en DMX via USB

Point consommation électrique

Consommation de la sono sur une répète

La consommation électrique est un point important. Nous avons une petite sono qui consomme ~60W de moyenne, avec des pics à 120W. Il nous arrive de jouer en « autonomie » (dans les bois par exemple) sur ma batterie de vélo 48V, avec un convertisseur 48V-350W de chez Victron. Celle-ci nous permet de tenir ~4h de concert sans problème (on a un set de ~1h alors on est large). Les 2 projecteurs LED consomment ~10W chacun, ce qui fait qu’on devrait pouvoir largement jouer notre concert, même avec les 2 projecteurs, même avec 3 rappels 🙂

Console DMX pour Cajon

Je me suis lancé dans la création d’une commande DMX pour mon Cajon. Afin de pouvoir jouer + commander les lumières par le protocole DMX.

Démonstration vidéo

Préparation lumière sur logiciel

Je suis parti sur le logiciel QLC+, qui est open source, plutôt complet (pour ce que j’ai à faire) et léger. J’ai l’ambition de faire tourner ma mini console sur un Raspberry pi. Dans QLC+, je peux préparer des séquences / ambiances par morceau, et passer d’une ambiance à une autre.

Par exemple, sur la capture ci-après – qui correspond au morceau « Tu veux ou tu veux pas », il y a plusieurs ambiances selon si c’est le moment de l’intro, du refrain, d’un solo…. J’utilise les cadres avec pagination pour « passer au morceau suivant ».

Je vous partage mon fichier qxf, qui permet au logiciel QLC+ de « comprendre » ces projecteurs. Je l’ai créé à partir de l’Éditeur d’appareil QLC+ (qlcplus-fixtureeditor) :

Algam-Slimpar-710-LED.qxf_ (à déposer dans .qlcplus/fixtures après décompression)Télécharger

Je vous partage aussi mon fichier avec l’enchaînement des ambiances (un morceau par page) dans la console virtuel. Pour une meilleure compréhension…

Ambiance 2par MadameDe.qxw_Télécharger

Les commandes sur Cajon

Je décide qu’il me faut donc 4 boutons :

  • Pour passer à l’ambiance lumière suivante
  • Revenir à l’ambiance lumière précédente (en cas de pépin)
  • Passer à la page/morceau/séquence suivant
  • Taper la pulsation (s’il y a des ambiances qui « clignotent », je veux que celles-ci soient en rythme…). 2 tapes à intervalle suffisent à donner la pulsation, il ne reste qu’à la suivre…. A noter que la pulsation peut être détectée via un micro USB sur le Raspberry Pi avec le Audio Trigger dans QLC+. C’est ce que j’ai finalement privilégié…

Rapidement, je me rends compte qu’il me faudra doubler ces 4 commandes :

  1. 4 boutons accessibles aux mains (si j’ai les pieds occupés)
  2. 4 mêmes boutons accessibles aux pieds (si j’ai les mains occupées)…

Et oui, parce que ça dépend des morceaux… Parfois je fais du cabassa, parfois du cajon…

Voilà le schéma de câblage / branchement sur le Raspberry pi des boutons :

Schéma de câblage / branchement sur le Raspberry

Si vous suivez, vous voyez 3 boutons sur le schéma alors qu’il y en a 4… J’ai changé d’avis en cours de route, et j’ai pas changé mon schéma. Mais vous avez l’idée générale…

Une fois soudé, j’ai tout rangé dans des petites boîtes en chutes de contre plaqué ou autres qui traînaient :

Façade pédale
L’intérieur de la pédale est dédié à l’électronique
Connexion des boutons d’arcade pour la commande manuelle

Une fois que mes ambiances sont « calées », et que les connexions sont faites, je peux installer un linux (avec interface) sur un Raspberry pi. Désormais, il me faut faire en sorte que les boutons que j’ai connectés sur le GPIO du Raspberry interagissent avec QLC+.

Option 1 : websockets

Option très propre, puisque QLC+ intègre un websockets (moyennant le lancement avec un « -w » de QLC+) qui permet d’interagir avec le logiciel lancé en tâche de fond par script :

import asyncio
import websockets

async def test():
    async with websockets.connect('ws://127.0.0.1:9999/qlcplusWS') as websocket:
        # Play
        await websocket.send("2|PLAY")
        response = await websocket.recv()
        print(response)
 
asyncio.get_event_loop().run_until_complete(test())

Seulement, toutes les fonctionnalités des consoles virtuelles ne sont pas implémentées… Par exemple, je ne pouvais pas ajuster le tempo (Widget durée).

Option 2 : simuler un clavier

C’est l’option retenue, je simule l’appui sur une touche de clavier quand un bouton est pressé (signal GPIO d’un bouton poussoir). Je m’explique :

QLC+ peut facilement être piloté par clavier, les raccourcis sont facilement paramétrables. Ainsi, j’ai paramétré plusieurs raccourcis :

  • d : démarrer le séquenceur du morceau
    • f : stopper le séquenceur du morceau
    • q : ambiance suivante
    • s : ambiance précédente
  • z : page suivante (morceau suivant)
  • x : allumer le micro pour détecter le tempo
  • w : déterminer la durée (taper le tempo)

Ensuite, pour simuler mes touches de clavier en fonction des boutons pressés (GPIO activé), j’ai fait un petit script en python avec la librairie pyautogui qui simule un clavier, voici les dépendances : 

sudo apt install python3-rpi.gpio
pip install pyautogui

Et voici le script 

#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import RPi.GPIO as GPIO                 #bibliothèque RPi.GPIO
import time                             #bibliothèque time
from pyautogui import press, typewrite, hotkey 	#clavier virtuel
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
# Configuration
#-------------------------------------------------------------------------------
pin1 = 17                                #broche utilisé en entrée
pin2 = 18                                #broche utilisé en entrée
pin3 = 27                                #broche utilisé en entrée
pin4 = 22                                #broche utilisé en entrée
pinLed = 23                              # Broche de la led
ledUpTime = 500                         # Temps d'allumage de la LED
# Temp de rebond : 
temps = 100                              #valeur attente en msec

#-------------------------------------------------------------------------------
# Préparation
#-------------------------------------------------------------------------------
GPIO.setwarnings(False)                 #désactive le mode warning
GPIO.setmode(GPIO.BCM)                  #utilisation des numéros de ports du
                                        #processeur
GPIO.setup(pin1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(pin2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(pin3, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(pin4, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(pinLed, GPIO.OUT, initial=GPIO.LOW) 
                                        #mise en entrée du port GPIO 22
                                        #et activation résistance soutirage
                                        #au ground
# Passer sur Qlight+ si ce n'est pas le cas
print("alt tab")
hotkey('alt', 'tab')
time.sleep(3)                       

#-------------------------------------------------------------------------------
# Lancement
#-------------------------------------------------------------------------------
ledup=False
if __name__ == '__main__':
     GPIO.output(pinLed, GPIO.HIGH) # Turn on
     time.sleep(2)
     GPIO.output(pinLed, GPIO.LOW) # Turn off
     print("Début du programme")        #IHM
     print("Sortie par ctrl-c\n")       #IHM
     try:
         while True:                    #boucle infinie
             # Gestion de l'extinciton de la led
             if (ledup != False) :
                 now = time.time()
                 if (now < ledup+ledUpTime):
                     GPIO.output(pinLed, GPIO.LOW) # Turn off
                     ledup = False
             # Gestion des boutons
             entree1 = GPIO.input(pin1)   #lecture entrée
             entree2 = GPIO.input(pin2)   #lecture entrée
             entree3 = GPIO.input(pin3)   #lecture entrée
             entree4 = GPIO.input(pin4)   #lecture entrée
             if (entree1 == False):       #si touche appuyée
                 GPIO.output(pinLed, GPIO.HIGH) # Turn on
                 print("Press f (Stop séquence)")
                 press('f')
                 time.sleep(0.5)
                 print("BP 1 appuyé")     #IHM
                 print("Press z (Page suivant) - N")
                 press('z')
                 time.sleep(0.5)
                 print("Press d (Start séquence)")
                 press('d')
                 time.sleep(0.5)
                 print("Press x (Allumer le micro)")
                 press('x')
                 ledup = time.time()
             if (entree2 == False):       #si touche appuyée
                 GPIO.output(pinLed, GPIO.HIGH) # Turn on
                 ledup = time.time()
                 print("BP 4 appuyé - T")     #IHM
                 print("w (tape)")
                 press('w')
             if (entree3 == False):       #si touche appuyée
                 GPIO.output(pinLed, GPIO.HIGH) # Turn on
                 ledup = time.time()
                 print("BP 2 appuyé - P")     #IHM
                 print("Press q (Pas prédent)")
                 press('q')
                 time.sleep(0.5)
             if (entree4 == False):       #si touche appuyée
                 GPIO.output(pinLed, GPIO.HIGH) # Turn on
                 ledup = time.time()
                 print("BP 3 appuyé - S")     #IHM
                 print("s (Pas suivant)")
                 press('s') 
                 time.sleep(0.5)
             time.sleep(temps / 1000)   #attente en msec 
     except KeyboardInterrupt:          #sortie boucle par ctrl-c
         GPIO.cleanup()                 #libère toutes les ressources
         print("\nFin du programme\n")  #IHM

Pour le lancement, au démarrage du Raspberry, je place des fichiers « .desktop » dans le répertoire .config/autostart/ de l’utilisateur « pi » que j’utilise pour lancer l’interface graphique.

Le script qui simule le clavier est lancé avec .config/autostart/button-qlcplus-controle.desktop

[Desktop Entry]
Type=Application
Name=button-qlcplus-controle
GenericName=button
Exec=/usr/bin/python /home/pi/DMX/button-qlcplus-controle.py  > /tmp/button-qlcplus-controle.log
Terminal=true
StartupNotify=true

Pour le lancement de QLC+, c’est le fichier .config/autostart/qlcplus.desktop : 

[Desktop Entry]
Type=Link
Name=Q Light Controller Plus Web
Icon=qlcplus
Exec=qlcplus -f -k -w -o DMX/fichierQLC.qxw
StartupNotify=false

Retour visuel

Même si c’est pas indispensable, pour savoir où on en c’est pratique d’avoir un retour visuel sur la console virtuelle de QLC+. Ce que j’ai fait, c’est que j’ai mis le Raspberry Pi en mode « Hotspot Wifi » (en gros, comme votre box – des tuto plein le web pour faire ça…), et je m’y connecte avec mon téléphone portable. De là, je peux :

  • Voir la console en mode web (lancer QLC+ avec un « -w »)
  • Voir l’écran avec VNC (sur un téléphone linux, j’utilise AVNC).

Voilà ce que ça donne :

Le téléphone posé sur le pupitre, pour suivre « là ou j’en suis »
Ma console « pour jouer »
Console paginée par morceau avec, ici, différentes ambiances pour 1 morceau

En situation

Des photos en situation :

Vue quand je suis assis sur le Cajon
Vue de face