DEV Community: Remy Jacquand

Mise en place d Outline et Authentik

Remy Jacquand — Thu, 12 Feb 2026 17:56:49 +0000

Dans ce tutoriel, nous allons montrer comment déployer Outline, le wiki collaboratif, avec Authentik comme fournisseur d’authentification OpenID Connect (OIDC), le tout orchestré via Docker Compose. L’objectif est d’avoir Outline accessible sur https://outline.multiplaie.work et sécurisé avec un login centralisé via Authentik.

1. Prérequis

Serveur Linux avec Docker et Docker Compose
Nom de domaine géré via Cloudflare (multiplaie.work)
Certificat SSL (optionnel si HTTPS est géré par un reverse proxy)
Connaissance de base de Docker et Authentik

2. Structure des services Docker

2.1 Outline

docker-compose.yml pour Outline :

services:
  outline:
    image: docker.getoutline.com/outlinewiki/outline:latest
    container_name: outline
    env_file: ./docker.env
    networks:
      - appflowy-proxy
    volumes:
      - storage-data:/var/lib/outline/data
    depends_on:
      - postgres
      - redis

  redis:
    image: redis:7
    container_name: outline-redis
    networks:
      - appflowy-proxy

  postgres:
    image: postgres:16
    container_name: outline-postgres
    networks:
      - appflowy-proxy
    environment:
      POSTGRES_USER: outline
      POSTGRES_PASSWORD: outline
      POSTGRES_DB: outline
    volumes:
      - database-data:/var/lib/postgresql/data

volumes:
  storage-data:
  database-data:

networks:
  appflowy-proxy:
    external: true

2.2 Authentik

docker-compose.yml pour Authentik :

version: "3.8"

services:
  postgresql:
    image: postgres:16-alpine
    container_name: authentik-postgres
    env_file:
      - .env
    environment:
      POSTGRES_DB: ${PG_DB:-authentik}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      interval: 30s
      retries: 5
      start_period: 20s
      timeout: 5s
    restart: unless-stopped
    volumes:
      - database:/var/lib/postgresql/data
    networks:
      - authentik-proxy

  server:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.12.3}
    container_name: authentik-server
    env_file:
      - .env
    depends_on:
      postgresql:
        condition: service_healthy
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
    ports:
      - ${COMPOSE_PORT_HTTP:-9000}:9000
      - ${COMPOSE_PORT_HTTPS:-9443}:9443
    restart: unless-stopped
    volumes:
      - ./data:/data
      - ./custom-templates:/templates
    networks:
      - authentik-proxy

  worker:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.12.3}
    container_name: authentik-worker
    env_file:
      - .env
    command: worker
    user: root
    depends_on:
      postgresql:
        condition: service_healthy
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/data
      - ./certs:/certs
      - ./custom-templates:/templates
    networks:
      - authentik-proxy

volumes:
  database:
    driver: local

networks:
  authentik-proxy:
    external: true

3. Configuration des fichiers `.env`

3.1 Outline

NODE_ENV=production
URL=<URL EXTERNE>
PORT=3000
WEB_CONCURRENCY=1
SECRET_KEY=<clé aléatoire>
UTILS_SECRET=<clé aléatoire>

DATABASE_URL=postgres://outline:outline@postgres:5432/outline
PGSSLMODE=disable

REDIS_URL=redis://outline-redis:6379

FILE_STORAGE=local
FILE_STORAGE_LOCAL_ROOT_DIR=/var/lib/outline/data

OIDC_CLIENT_ID=<Client ID Authentik>
OIDC_CLIENT_SECRET=<Client Secret Authentik>
OIDC_AUTH_URI=https://<URL vers Authentik>/application/o/authorize/
OIDC_TOKEN_URI=https://<URL vers Authentik>/application/o/token/
OIDC_USERINFO_URI=https://<URL vers Authentik>/application/o/userinfo/
OIDC_LOGOUT_URI=https://<URL vers Authentik>/application/o/outline/end-session/
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=Authentik
OIDC_SCOPES=openid email profile

3.2 Authentik

PG_PASS=<mot de passe PostgreSQL>
AUTHENTIK_SECRET_KEY=<clé aléatoire>

AUTHENTIK_EMAIL__HOST=smtp.gmail.com
AUTHENTIK_EMAIL__PORT=465
AUTHENTIK_EMAIL__USERNAME=<USERNAME>
AUTHENTIK_EMAIL__PASSWORD=<mot de passe Gmail>
AUTHENTIK_EMAIL__USE_SSL=true
AUTHENTIK_EMAIL__FROM="auth@URL"

AUTHENTIK_ERROR_REPORTING__ENABLED=true

4. Configuration d’Authentik pour Outline

Créer un Provider OIDC
- Name : Outline
- Client ID et Client Secret générés
- Endpoints :
  - Authorization : /if/authorize/
  - Token : /if/token/
  - Userinfo : /if/userinfo/
- Scopes : openid email profile
Créer l’application OIDC
- Redirect URI : https://<URL OUTLINE>/auth/oidc/callback
- Post Logout Redirect URI : <URL OUTLINE>
- Associer au Provider Outline créé précédemment
Copier le Client ID et le Client Secret dans le .env de Outline.

5. Démarrage des services

# Démarrer Authentik
docker compose -f docker-compose.authentik.yml up -d

# Démarrer Outline
docker compose -f docker-compose.outline.yml up -d

Vérifier les logs si besoin :

docker compose logs -f outline
docker compose logs -f authentik-server

6. Connexion à Outline

Ouvrir https://<URL OUTLINE>
Choisir Authentik comme fournisseur de login
Se connecter avec les identifiants configurés dans Authentik
L’accès est maintenant sécurisé via OpenID Connect

7. Conclusion

Cette configuration permet d’avoir :

Un Outline fonctionnel et accessible sur un domaine public
Authentification centralisée via Authentik (OIDC)
Gestion des utilisateurs et des permissions via Authentik
Stockage sécurisé des données via PostgreSQL et Redis

Tout est orchestré avec Docker Compose, ce qui facilite la maintenance et les mises à jour.

Pourquoi mon serveur est devenu lent : le cas du disque SMR

Remy Jacquand — Thu, 12 Feb 2026 17:52:35 +0000

Récemment, mon serveur Lenovo Linux Mint est devenu très lent, même pour se connecter en SSH. Après quelques minutes d’attente, j’ai commencé à diagnostiquer le problème. Voici ce que j’ai découvert et ce que cela signifie.

Symptômes

SSH extrêmement lent.
apt update et autres commandes système qui mettent beaucoup de temps.
Serveur globalement réactif mais “ramé” sur tout ce qui touche le disque.

Diagnostic initial

J’ai commencé par vérifier :

RAM / CPU : usage normal, pas de saturation.
Disque : utilisé à 798 Go / 915 Go (~87% de remplissage).
Docker / conteneurs : beaucoup d’applications média (Jellyfin, qbittorrent, Sonarr, Radarr, AppFlowy…).

Le disque semblait être le principal coupable.

Vérification SMART

J’ai lancé :

sudo smartctl -a /dev/sda

Résultats clés :

Modèle : Western Digital Blue Mobile (SMR)
Capacité : 1 To
SMART overall-health : PASSED
Secteurs réalloués : 0
Pending / erreurs : 0
Heures de fonctionnement : 12 667 h
Température : 47°C

Interprétation : le disque est en parfait état matériel, rien ne justifie une lenteur mécanique.

Le problème réel : la technologie SMR

SMR = Shingled Magnetic Recording, conçu pour stockage froid, peu d’écritures.
Quand le disque est presque plein (>80%) et qu’il reçoit des écritures continues (Docker, torrents, scans), il doit réécrire de grandes bandes de données pour chaque petite écriture.
Conséquence : latence énorme, même pour SSH ou des lectures simples.

Actions effectuées

Libération d’espace disque (~100 Go).
Redémarrage du serveur.
Lancement d’un **fstrim -av** pour indiquer au SMR quelles zones sont libres :

/boot/efi: 504,8 MiB trimmed
/: 426,8 GiB trimmed

Résultat : le disque a reconnu 426 Go comme libres et peut désormais optimiser ses écritures.
Après quelques minutes, le SSH et les mises à jour système sont redevenus plus fluides.

Analyse I/O

Pendant le problème, avec iostat :

%util disque : ~96%
await lectures : ~50 ms
CPU libre : 73%

Conclusion : le goulot d’étranglement était le disque, pas le CPU ni la RAM.

Conclusion et recommandations

Les disques SMR ne sont pas adaptés pour :
- Docker intensif
- Torrents
- Bases de données
- Applications média avec scans fréquents
Même après libération d’espace et fstrim, le disque reste lent si le remplissage et l’écriture continue reprennent.
Pour un serveur Docker média, préférer un SSD ou un HDD CMR classique.
- SSD : rapide et fiable pour écritures continues
- HDD CMR : meilleur pour gros volumes mais encore limité pour Docker très actif
En cas d’achat futur, vérifier technologie SMR vs CMR pour éviter ce type de goulot d’étranglement.

TL;DR

Mon serveur est lent non pas parce que le disque est mort, mais parce qu’un disque SMR plein et actif ne peut pas suivre un usage Docker intensif. Libérer de l’espace et faire un fstrim aide, mais la solution définitive est de passer sur SSD ou HDD CMR.

Héberger Paheko chez soit derière Cloudflare

Remy Jacquand — Thu, 12 Feb 2026 17:48:31 +0000

Héberger Paheko chez soit derière Cloudflare

Paheko

Paheko aide a la gestion d'association, il se dit "simple, complet et efficace" Le logiciel est accentué par sont ethique (pas de pistage, logiciel libre, sans IA). Elle assiste sur la gestion des memebres de l'association, la comptabilité, la gestion de document et création d'un site web.

La version en ligne est 100% gratuit avec toutes les fonctionnaliés, 10mo de stockage pour les documents Mais un seul exercice comptable et pas d'envoie d'email.

Dans le cadre de l'auto-hébergement, la limite des exercices comptable et l'envoi d'email n'existe plus.

Cloudflare

Cloudflare est un prestataire offrant une solution gratuit pour sécurisé pour créer un tunnel appelé "zero trust" vers votre serveur.

Son interface d'aministration est simple et propose beaucoup d'option et d'outils de mesure du trafic

Pour communiquer jusqu'au serveur, cloudflare passe par l'intermédiaire d'un container dont la plateforme propose la commande pour le créer: cloudflared

Cloudflared

Cloudflared est une image Docker permettant la connexion, via tunnel, entre le serveur et Cloudlfare. Sa mise en place est expliqué lors de la déclaration d'un nouveau tunnel depuis l'interface administrateur.

Architecture

Une fois la stack mise en place, chaque demande de connexion vers l'hébergement Paheko passera par le DNS de cloudflare.

Utilisateur => DNS Cloudflare => Cloudflared => Paheko

Le nom de domaine utilisé pour la connexion depuis l'exterieur doit être configuré, au préalable, pour utiliser les DNS de Cloudflare. Il sera donc nécessaire de déclarer le nom de domaine dans l'interface utilisateur Cloudflare.com

Sur le serveur, l’entièreté des projet docker seront contenu dans

~/Docker

et s'organisera de la façon suivante:

Docker/
├─ paheko/
│ ├─ config/
│ ├─ data/
| ├─ docker-compose.yaml
|
├─ cloudflared/
| ├─ docker-compose.yaml

Intallation

Partons du principe que docker est déjà installé sur le serveur.

Préparons les dossiers:

# Dossier de base
mkdir -p ~/Docker

# Paheko
mkdir -p ~/Docker/paheko ~/Docker/paheko/config ~/docker/paheko/data

# Cloudflare
mkdir -p ~/Docker/cloudflared

Mise en place de Paheko

L'image docker de Paheko est disponible sur hub.docker.com

https://hub.docker.com/r/libretic/paheko

services:
  paheko:
    image: paheko/paheko
    restart: always
    volumes:
      - ./config.local.php:/var/www/paheko/config.local.php
      - ./php.ini:/usr/local/etc/php/php.ini
      - pahekodata:/var/www/paheko/data
      - /var/www/paheko/data/plugins
    ports:
      - 8080:80

Pour adapter le fichier aux besoin actuel, la mise à jour ce présente ainsi:

# ~/Docker/paheko/docker-compose.yaml

services:
  paheko:
    image: paheko/paheko
    container_name: paheko 
    restart: always
    volumes:
      - ./config/php.ini:/usr/local/etc/php/php.ini
      - ./data:/var/www/paheko/data
    networks:
      - paheko-proxy
    ports: 
      - "8080:80"

networks:
  paheko-proxy:
    external: true

Un "container_name" a été ajouté

container_name: paheko

Et un network "paheko-proxy" a été créer

docker network create paheko-proxy

Pour finir, le dossier data doit être editable par www-data du container

sudo chown 33:33 ~/Docker/paheko/data

Mise en place de Cloudflared

# ~/Docker/cloudflared/docker-compose.yaml

services:
  cloudflared:
    image: cloudflare/cloudflared:latest
    container_name: cloudflared
    restart: unless-stopped
    command: tunnel --no-autoupdate run --token [SECRET_TOKEN]
    networks:
      - paheko-proxy
networks:
  paheko-proxy:
    external: true

le SECRET_TOKEN est fourni durant le déclarion du tunnel dans l'interface utilisateur de Cloudflare

Enfin, les containers peuvent être lancé:

# Cloudflared
cd ~/Docker/cloudflared
docker compose up -d

# Paheko
cd ~/Docker/paheko
docker compose up -d

et vérifier leur connexion réseau:

docker network inspect paheko-proxy

Accès Exterieur

Dans l'interface utilisateur de Cloudflare, déclarez un nouvel hôte publique en spécifiant:

Type: HTTP
URL: paheko:80

Une fois validé, le site sera accéssible depuis le nom de domaine déclaré dans Cloudflare

Streamer des fichiers audio avec homeassistant et mopidy

Remy Jacquand — Thu, 21 Apr 2022 13:23:08 +0000

Dans ce billet, je vais expliquer la mise en place d'un système permettant la diffusion de fichier audio vers différents périphériques connectés.
Je prendrai comme contexte les éléments suivants : je suis dans un lieu possédant 3 pièces.
Dans les pièces 1 et 2 y est disposé un Raspberry pi (3 ou 4) raccordé a des enceintes.
Dans la pièce 3 se trouve le serveur permettant de diffuser les fichiers audio vers les Raspberry pi des autres pièces.
Les Raspberry pi sont sous la distribution raspbian lite et le serveur principal est sous ubuntu 20.04 (LTS).

Préparation périphérique Mopidy

Afin de pouvoir lire de la musique depuis un Raspberry pi, je vais installer l'application Mopidy.
Mopidy est un lecteur de fichier audio avec plusieurs plugin intéressant tel qu'un plugin spotify, soundcloud, TuneIn et avec plusieurs thèmes ect...

Via son plugin mopidy-mdp, je vais pouvoir contrôler la lecture depuis d'autres applications. Home Assistant dans notre cas.

Je me connecte donc à un des deux Raspberry pi en gardant en tête que je devrai refaire la même oopération sur l'autre.

Installation Mopidy

Ajout de l'archive GPG

sudo mkdir -p /usr/local/share/keyrings
sudo wget -q -O /usr/local/share/keyrings/mopidy-archive-keyring.gpg \ 
    https://apt.mopidy.com/mopidy.gpg

Ajout de la nouvelle source de paquet

sudo wget -q -O /etc/apt/sources.list.d/mopidy.list https://apt.mopidy.com/buster.list

Installation de Mopidy

sudo apt update
sudo apt install mopidy

source

Installation des extensions

Parmis les extensions, seulement 2 sont intéressantes pour le projet : mopidy-mpd et mopidy-iris

Modipy-MPD permettra de contrôler la lecture depuis Home Assistant et Mopidy Iris est une interface graphique pour simplifier son utilisation direct

La liste des extensions disponibles sont accessible au lien suivant : liste des extensions

Mopidy-MDP

pour installer l'extension:

sudo python3 -m pip install Mopidy-MPD

Ensuite, je passe à la configuration:

sudo nano /etc/mopidy/mopidy.conf

et j'y ajoute les lignes suivante

[mpd]
enabled = true
hostname = 192.168.0.48
port = 6600

"enabled" correspond a l'activation de l'extension.
"hostname" est l'adresse IP de la machine sur laquelle je suis.
"port" est à 6600, ce qui est le port par défaut de mpd.

source

Mopidy-Iris

Voici la commande pour l'installation de l'interface graphique Iris

sudo python3 -m pip install Mopidy-Iris

Rien n'oblige à utiliser spécifiquement cette interface. Elle est installé juste par soucis esthétique.

Aucune configuration est requise.

source

configuration HTTP

Afin d'accéder pour navigateur web a Mopidy, il faut configurer son accès. Pour cela, il faut ajouter les lignes suivantes dans le fichier "/etc/mopidy/mopidy.conf"

[http]
enabled = true
hostname = 192.168.0.48

"enabled" active l'extension
"hostname" est l'adresse de notre Raspberry pi

Maintenant, mopidy est accessible par le navigateur à l'adresse du Raspberry pi et au port 6680 (pour ma part http://192.168.0.48:6680)

Il faut maintenant effectué la même installation sur l'autre Raspberry pi en prenant soin de changer l'adresse IP.

Préparation du serveur HomeAssistant

Ce serveur Permettra de diffuser et de controller la lecture d'un ou plusieurs fichiers audio vers les lecteur Mopidy installer précédement.

Pour commencer, il faut se rendre sur le serveur et y faire les mise à jour

sudo apt-get update
sudo apt-get upgrade -y

Ensuite, installer les dependances

sudo apt-get install -y python3 python3-dev python3-venv python3-pip libffi-dev libssl-dev libjpeg-dev zlib1g-dev autoconf build-essential libopenjp2-7 libtiff5 libturbojpeg0-dev tzdata

Créer un compte utilisateur sur le serveur

sudo useradd -rm homeassistant

Ainsi qu'un environement virtuel

sudo mkdir /srv/homeassistant
sudo chown homeassistant:homeassistant /srv/homeassistant
sudo -u homeassistant -H -s
cd /srv/homeassistant
python3 -m venv .
source bin/activate

Une fois l'environement activé, il est necessaire d'installer le paquet python suivant

python3 -m pip install wheel

Il est maintenant temps d'installer homeassistant

pip3 install homeassistant

Pour démarrer homeassistant

hass

Et l'interface de Home Assistant est maintenant accessible depuis le navigateur à l'adresse IP du serveur et au port 8123 (http://192.168.0.79:8123)

source

Configuration de Home Assistant

Configuration des contrôles des Raspberry pi par MPD

Afin de pouvoir faire lire aux Raspberry pi des fichiers audio depuis Home Assistant, il faut déclarer les adresses d'accès des Raspberry pi dans la configuration de Home Assistante.

sudo vim /home/homeassistant/.homeassistant/configuration.yaml

et ajouter les lignes suivantes

media_player:
        - platform: mpd
          host: 192.168.0.48
          port: 6600
          name: rpi48
        - platform: mpd
          host: 192.168.0.35
          port: 6600
          name: rpi35

"platform": correspond à l'entité utilisé
"host": c'est l'adresse IP de la machine à contrôler
"port": le port d'accès
"name": le nom qui apparaitra dans l'interface de Home Assistant afin de le repérer plus facilement

Ici, j'ai déclaré les 2 Raspberry pi que j'ai configuré précédement

source

Mise en place de l'espace media

Il existe un espace par defaut où Home Assistant va chercher les fichiers audio. Ce dossier "media" se trouvant à "/home/homeassistant/.homeassistant/"

sudo mkdir /home/homeassistant/.homeassistant/media

C'est dans ce dossier que vous pouvez disposer vos fichiers audio à diffuser

Test

Une fois Home Assistant configuré et démarré, il faut placer les fichiers audio dans le dossier "/home/homeassistant/.homeassistant/" du serveur Home Assistant et ajouter les cartes de contrôle de chaque Raspberry pi sur le reseau.

Ajout des cartes de contrôle de média

Pour cela il faut cliquer sur l'icone "menu" en haut à droite de la page puis sur modifier le tableau de bord.

Clic sur le bouton "Ajouter une carte"

Dans la nouvelle fenêtre, il faut chercher le terme "media" et cliquer sur la carte "Contrôle des medias"

Selectionner une des entités proposé que nous avons déclaré dans le fichier de configuration "/home/homeassistant/.homeassistant/configuration.yaml"
Pour mon exemple, ça sera les entités rpi48 et rpi35.

Une fois les cartes ajoutées, il est maitenant possible de diffuser un fichier audio vers le périphéque souhaité.

Diffusion du fichier audio

Pour diffuser un fichier audio que nous avons stocké au préalable sur le serveur Home Assistant, il faut repérer la carte du raspberry pi souhaité et cliquer sur le logo "media" en bas à droite de la carte.

Selectioner "Local Media" et sélectionner le fichier audio souhaité.

le fichier est maintenant lu sur le périphérique souhaité

lien supplémentaire

video explicative

Streamer une capture vidéo de sa webcam avec VLC

Remy Jacquand — Wed, 06 Apr 2022 11:36:08 +0000

Dans cette note, je vais énumérer les étapes afin de streamer une webcam depuis VLC. Dans un premier temps, je détaillerai comment capturer la vidéo de la webcam avec VLC et ensuite comment l'envoyer dans un flux HTTP par l'interface graphique et, finalement, en ligne de commande dans le but de l'intégrer dans un projet annexe.

note à moi même :
Toute l'opération se passe dans un environnement Linux. Pour Windows, c'est sensiblement la même chose. Cependant, mes essais sous Windows 11 n'ont pas pu aboutir à cause du problème suivant :
dshow:// non accéssible

Depuis l'interface graphique de VLC

La capture vidéo

Pour capturer le flux vidéo de la webcam, ouvrir VLC et rendez-vous sur Média > Ouvrir un périphérique de capture (Ctrl+C)

Dans cette fenêtre, l'onglet "Périphérique de capture" est sélectionné.

Puis, configure les options suivantes:

Sélectionner "Video Camera" dans "Capture mode"
Nom du périphérique vidéo > /dev/video0
Nom du périphérique audio > hw:0,0
Standard vidéo > Tous

Ces options correspondent à mon système actuel est peuvent être différente en fonction des versions du soft.

Terminer la configuration en cliquant sur le bouton "Lire" en bas de la fenêtre.

Stream vidéo

Afin de Streamer sa webcam depuis VLC
Media > Stream (ou Ctrl+s)

Sélectionner l'onglet "Périphérique de capture"

La configuration à adopté est la même que la capture de vidéo.

Puis cliquer sur "Stream"

Valider la fenêtre suivante "Source", valider sans changer les options.

Ensuite, dans la fenêtre "Destination setup", sélectionner la destination "HTTP" et cliquer sur "Ajouter". Un onglet HTTP va s'ajouter avec le paramétrage du port souhaité (par defaut 8080) ainsi que le chemin d'accès (par défaut /)

Dans la fenêtre correspondant à l'encodage, sélectionner le profil MP4.

Pour finir, dans la fenêtre des options, appuyer simplement sur le bouton stream.

Votre stream est en cours et accessible à l'adresse IP de la machine sur le port sélectionné précédemment.

En ligne de commande

Voici de manière brève la commande correspondant à mon besoin et à la configuration effectué précédemment.

vlc -vvv v4l2:///dev/video0 --sout '#transcode{vcodec=h264,acodec=mpga,vb=800,ab=128}:standard{access=http,mux=flv,dst=:8080}'

En quelques mots:

vvv : verbose
v4l2:///dev/video0 : la capture de ma webcam
--sout : paramètre de sortie de video
#transcode{vcodec=h264,acodec=mpga,vb=800,ab=128} : encodage
:standard{access=http,mux=flv,dst=:8080} : ouverture http + format de la vidéos + adresse d'accès

Fonctionnalités optionnelles

Ajouter un filigrane

Certaines options sont persistante et peuvent être configuré via l'interface graphique en amont.

Pour ajouter un logo en filigrane des vidéos, il faut ouvrir VLC et faire "clic droit"> outils > effets et filtres (Ctrl+e)

Sélectionner Effets vidéos dans le premier menu d'onglet et Incrustation dans le second.

Cocher la case Ajouter un logo puis parcourir vos dossiers pour sélectionner le logo souhaité.

Voila, le logo sera posé sur votre vidéo chaque fois que VLC sera utilisé.

Limiter la durée de la diffusion

Afin de déterminer un temps de diffusion, il est nécessaire d'utiliser la commande timeout:

timeout 10 vlc -vvv v4l2:///dev/video0 --sout '#transcode{vcodec=h264,acodec=mpga,vb=800,ab=128}:duplicate{dst=http{mux=flv,dst=:8080}, dst=file{dst=/home/remy/Vidéos/video.mp4, no-overwrite}, dst=display{delay=6000}}'

Dans cette exemple, je diffuse dans un flux http en local, j'enregistre dans un fichier et j'affiche le retour de la webcam durant 10 secondes.

Source:

Déclancher un signal midi avec NodeJs sur Windows

Remy Jacquand — Thu, 17 Feb 2022 16:53:58 +0000

Je vais présenter ici un script simpliste pour générer un signal midi depuis une application NodeJs.

Installation

Pour cet exemple, nous avons besoin de :

NodeJs
Express
EasyMidi

mkdir Project
cd Project
npm init
npm install express
npm install easymidi

En complément, il nous faut installer 2 logiciels tiers :

LoopMidi qui nous permet de créer un périphérique midi virtuel
et
Midi-OX qui permet de visualiser les logs.

Configuration

LoopMidi

Démarre LoopMidi et créé un nouveau périphérique en lui assignant un nom et en appuyant sur le bouton "+"

Midi-OX

Démarre Midi-OX et affiche le moniteur si il n'apparait pas

Ensuite, plug LoopMidi avec midi-ox en allant dans Options->Midi Devices

Pour finir, sélectionne le périphérique que vous avez créé avec LoopMidi dans la partie "MIDI Inputs" (1) et "Microsoft GS Wavetable Synth" dans "MIDI Outputs" (3). Si tout est ok, ils apparaîtront respectivement dans "Port Map Objects" (2) et "Port Mapping" (3).

Main.js

Dans le dossier du projet, ajoute le fichier main.js

let easymidi = require("easymidi")
let express = require('express')
let output = new easymidi.Output("NAME OF VIRTUAL DEVICE")
const app = express()
let is_on = false;
app.get('/', function (req, res) {
    res.sendFile(__dirname + '/index.html');
})

app.post('/click', (req, res)=>{
    console.log('received')

    output.send("cc", {
        controller: 37,
        value: (is_on) ? 0:127,
        channel: 0
    })

    is_on = !is_on;
    res.sendStatus(201);
})

app.listen(3000)

Ce script génère un serveur http affichant simplement un bouton.
Le but du script est de déclancher un signal midi chaque fois que le bouton "ON/OFF" est cliqué

Pour lier le script au périphérique midi virtuel, il faut indiquer le nom du périphérique à la ligne suivant :

let output = new easymidi.Output("NAME OF VIRTUAL DEVICE")

Ensuite, création du fichier index.html suivant :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <button id="button">ON/OFF</button>
    <script>
        document.getElementById('button').onclick = ()=>{

            fetch('/click', {method: 'POST'})
        }
    </script>
</body>
</html>

Start

Execute le script main.js

node main.js

Et ouvre la page http://localhost:3000 pour afficher le bouton d'envoi de signal midi. Chaque fois que le bouton est cliqué, un signal midi est envoyé au périphérique LoopMidi et intercepté par Midi-OX.

Bravo, tu sais envoyer un signal midi avec NodeJs :)

Sources

Pour cette présentation, je me suis beaucoup aidé de cette vidéo

Pour en savoir plus sur les signaux possible à envoyer, je conseille de lire la section "Message Reference" sur le github de easymidi

Tous les codes pour cet exemple sont disponible sur mon github

Systeme de communication entre NodeJS, Madmapper et arduino

Remy Jacquand — Thu, 17 Feb 2022 11:16:26 +0000

Dans le cadre de création d'une pièce d'escape game, nous expérimentons le logiciel Madmapper pour gérer toute la partie audio visuelle. La projection vidéo, le son et la lumière sont au centre de l'univers du jeu.

Concernant les interactions avec les joueurs et les énigmes, nous souhaitons contrôler ces instruments par Arduino.

Dans les prévisions, nous souhaitons contrôler la salle via une application web afin d'y accéder depuis n'importe quel périphérique (mobile, desktop...)

Les énigmes sont gérés sur arduino, madmapper récupère l'information et une application Web nous informe du status de la room et éventuellement nous permet de déclancher .

Bonne surprise, Madmapper intègre Firmata. C'est un outil de contrôle Arduino facilitant la communication entre ce dernier et un logiciel tier. Ce qui permet de nouvelles possibilités d'interaction.

Concernant l'application Web, pour mon confort, elle est en NodeJS.

Problématique

Intuitivement, aillant Firmata sur le Arduino, je pensais pouvoir contrôler ce dernier avec un montage parallèle entre Madmapper et NodeJS.

Malheureusement, si le Arduino est en communication avec Madmapper, NodeJS ne peut interagir avec le Arduino car le port et occupé. Je pars donc sur un montage en série des applications pour simplifier le flux d'information.

Dans cet exemple, nous allons préparer un interrupteur pour allumer et éteindre une LED.

Note : Pour ce développement, je suis sous un environnement Windows, ce qui affect la création de périphérique virtuel par NodeJs. C'est pour cela que nous installerons des applications tier pour palier à certain problème.

Hardware et Software

Arduino Uno
Petit montage électrique avec une LED et une résistance
MadMapper
Midi-OX
LoopMidi
IDE Arduino
VSCode
NodeJs
EasyMidi
Express

Preparation de l'environnement de travail

LoopMidi

Le logiciel permet de créer un périphérique midi virtuel. Il nous permet de communiquer entre l'app NodeJs et Madmapper.
Une fois l'installation effectuée, déclare un nouveau périphérique en lui indiquant un nom (1) en cliquant sur le "+" en bas à gauche de la fenêtre. (2)

Personnellement, j'ai laissé le nom par défaut

Midi-OX

Midi-OX est un logiciel de consultation de log Midi. Une fois le périphérique sélectionné, nous pouvons consulter les communications IN et OUT avec ce dernier.

Ouvrez Midi-OX et le moniteur si ce dernier ne s'ouvre pas automatiquement

Allez dans Options->Midi Devices pour lier Midi-OX à LoopMidi

Sélectionne le périphérique que vous avez créé avec LoopMidi dans la partie "MIDI Inputs" (1) et "Microsoft GS Wavetable Synth" dans "MIDI Outputs" (3). Si tout est ok, ils apparaîtront respectivement dans "Port Map Objects" (2) et "Port Mapping" (3).

Validez la sélection avec le bouton "OK".

Un message "Opened MIDI INPUT" et "Opened MIDI OUTPUT" apparaîtront dans le moniteur

Lors des tests, nous pourrons observer les logs dans ce moniteur.

Installation de Firmata dans le Arduino Uno et communication avec MadMapper

Une très bonne vidéo explique tout cela ici :)

Communication NodeJs et MadMapper

Pour communiquer avec MadMapper depuis NodeJs, nous allons envoyer un signal MIDI depuis NodeJs et l'interpréter dans MadMapper

EasyMidi

Afin de déclencher un signal midi, nous allons utiliser le périphérique virtuel LoopMidi avec NodeJs.
Dans votre dossier de projet :

Initialisez le projet :

npm init

Installez easymidi :

npm intall easymidi

Et créé le script main.js :

let easymidi = require("easymidi") //on déclare easymidi
let output = new easymidi.Output("loopMIDI Port") //On connecte easymidi au periphérique midi virtuel loopMIDI grâce à son nom
// on envoi le signal midi
output.send("cc", {
    controller: 37, // numéro de la commande
    value: 127, // valeur de la commande [0-127]
    channel: 0 // channel midi
})

Dans le cadre de notre interrupteur, nous allons utiliser l'opérateur "change control" qui change d'état quand on l'active et reste dans ce même état jusqu'à ce qu'on le déclenche de nouveau (un interrupteur en somme).

Le numéro contrôleur 37 est reconnue comme une commande "change control". En fonction de cette valeur, il peut être reconnu comme un changement de pitch ou de modulation ou beaucoup d'autre commande.
Entre 30 et 40 (à vérifier) sont reconnues les commandes de type Gate.

Note : il est possible de créer un périphérique midi virtuel à la volée avec easymidi. Cependant, Windows bloque sa création :

MidiOutWinMM::openVirtualPort: cannot be implemented in Windows MM MIDI API!

Je n'ai pas essayé avec d'autres OS mais la plupart des tutos trouvé sur YouTube sont iOS et semble fonctionner sans trop de difficultés.

source

En lançant le script, une ligne apparaît dans la console de log de Midi-OX.

Nous pourrons donc par la suite configurer un déclencheur avec MadMappeur avec cette commande.

Création page web express

À présent, nous allons modifier le script pour créer une page web et y afficher un bouton pour déclencher plus facilement la commande midi avec express.

Installation de express

npm install express

Ajoutez le fichier index.html pour le front

<!-- ./index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Panel Control</title>
</head>
<body>
    <button id="button">ON/OFF</button>
    <script>
        document.getElementById('button').onclick = () => {
            fetch('/click', {method: 'POST'})
        }
    </script>
</body>
</html>

Et le back

let easymidi = require("easymidi")
let express = require('express')
let output = new easymidi.Output("loopMIDI Port")
const app = express()
let is_on = false;
app.get('/', function (req, res) {
    res.sendFile(__dirname + '/index.html');
})

app.post('/click', (req, res)=>{
    console.log('received')

    output.send("cc", {
        controller: 37,
        value: (is_on) ? 0:127,
        channel: 0
    })

    is_on = !is_on;
    res.sendStatus(201);
})

app.listen(3000)

Coté front, le but est simple: lorsqu'on clique sur le bouton, on envoie une requête POST au endpoint "/click" pour allumer ou éteindre la LED.

Coté back, nous mettons en place l'API:

Implémentation de express

let express = require('express') 
const app = express()

Création de l'index

app.get('/', function (req, res) {
    res.sendFile(__dirname + '/index.html');
})

Création de l'endpoint

let is_on = false;
app.post('/click', (req, res)=>{
    console.log('received')
    output.send("cc", {
        controller: 37,
        value: (is_on) ? 0:127,
        channel: 0
    })

    is_on = !is_on;
    res.sendStatus(201);
})

À présent, nous pouvons tester le script et voir le resultat dans la console de log de Midi-OX.

Le script est prêt

Parametrage d'action midi sur MadMapper

Rendez-vous sur MadMapper et connectez l'application au Arduino avec le module Firmata. Ensuite, choisissez un pin (je préconise le Pin3 pour le test) et cliquez sur le bouton "OUTPUT" pour activer la sortie.

La LED s'illumine. Dans le cas contraire, il faut sélectioner de nouveau le model du Arduino et le port pour forcer la connexion.

Continuons avec click droit sur le bouton "OUTPUT" -> Add Control -> MIDI

Dans le nouveau panneau qui apparaît, clique sur le bouton "Learn"

execute l'application NodeJs

node main.js

et clique sur le bouton ON/OFF de votre page. MadMapper va alors capturer l'information et l'assigner au bouton "OUTPUT"

Désormais, chaque fois que vous cliquerez sur ce bouton "ON/OFF" vous commanderez la LED :D

Félicitations !

Installation mongoDB sur raspberry pi 3

Remy Jacquand — Tue, 26 Oct 2021 10:38:30 +0000

Après de nombreuses tentatives, j'ai compris pourquoi le RPI3/Raspbian ne permet pas d'installer la dernière version de MongoDB:
L'architecture n'est pas adaptée... Et ça ! Personne n'en parle.

Nous allons donc voir comment contourner toutes ces problématiques.

Step 1 : installation d'Ubuntu sur le RPI3

Téléchargez et installez Raspberry Pi Imager.
Choisir l'OS suivant : Other general purpose OS > Ubuntu > Ubuntu Server 20.04.3 LTS (64bits)
Et installer tout ça sur la carte micro SD

Step 2 : Upgrade

$ sudo apt-get update
$ sudo apt-get upgrade

Tu connais les bails.

Step 3 : installation MongoDB

La meilleure succession de commande que j'ai trouvée, c'est celle-là :

$ wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -
$ echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
$ sudo apt-get update
$ sudo apt-get install mongodb-org=4.4.8 mongodb-org-server=4.4.8 mongodb-org-shell=4.4.8 mongodb-org-mongos=4.4.8 mongodb-org-tools=4.4.8

Vérifiez la version. (elle doit être au moins superieur a la versioin 3)

mongod --version

Créez les dossiers pour le stockage des data.

$ sudo mkdir /data
$ cd /data
$ sudo mkdir db
$ sudo pkill -f mongod

Step 4 : Use as service

$ sudo systemctl enable mongod.service

petite note: la commande "mongod" permet de lancer un serveur mongodb et la commande "mongo" permet d'accéder a la console mongoDB. Il faut donc penser a lancer le service "mongod" avant d'accéder a la console :)

Step 5 : accéder au serveur depuis l'exterieur

Pour ma part, j'utilise l'application compass. Pour connecter compass depuis un autre PC, il faut ouvrir le serveur MongoDB (sur le RPI) vers l'exterieur.

Récupérez l'adresse IP du RPI

$ ifconfig

Ouvre le fichier de configuration de MongoDB

$ sudo nano /etc/mongod.conf

Ajoutez l'adresse IP au fichier de configuration de MongoDB

...
# network interfaces
net:
port: 27017
bindIp: 127.0.0.1,192.168.0.XX
...

Redmarrez le service mongod

$ sudo systemctl restart mongod.service

Aaaaaand it's done :)

Gestion du son dans une salle d'escape game

Remy Jacquand — Mon, 25 Oct 2021 13:16:57 +0000

Le projet

La disposition

Le projet principal s'articule de la façon suivante :

Dans une salle, 5 joueurs et un maître du jeu prennent place. Cette salle accueillera un jeu de rôle sur table durant 1 h et plongera les joueurs dans une ambiance en lien avec les événements du jeu.
Le maître du jeu sera le seul lien avec l'histoire. Il mettra en scène les situations et sera garant de l'interaction des joueurs dans le scénario.

Le Maitre du jeu est éloigné des joueurs afin de gérer la mise en place des ambiances derrière son pupitre. Les joueurs, quant à eux, seront placés face au MJ derrière une table. Cette table est la seule interaction physique qu'il y aura entre les joueurs et l'histoire.

L'ambiance

Pour générer une ambiance dans laquelle les joueurs seront plongés, il est nécessaire de d'utiliser les éléments suivants :

Les lumières
Le son
La décoration
Les objets d'interactions

Ce document se concentrera uniquement sur la diffusion du/des sons dans la salle.

Pour créer une ambiance sonore, nous avons besoin des éléments suivants :

Un système son (stéréo pour le moment)
Des sons d'ambiances bouclé et permanant par scène
Des sons d'objet ou d'animaux pouvant intervenir par-dessus la musique d'ambiance sur décision du MJ

Le materiel

Principalement, tout sera géré par un Raspberry pi 3. Il jouera le rôle de serveur d'application. Sur ce dernier, seront installées VLC ainsi que les musiques à jouer.

Les requêtes seront envoyées depuis une PC sous Windows depuis la console Powershell.

Petite astuce

Pour télécharger des musiques depuis YouTube vers le RPI, la lib youtube-dl fais complètement le café.

Execution

Installation du RPI

Le RPI sera le serveur principal de toutes les musiques d'ambiance. C'est par lui que passeront toutes les requêtes de lecture des musiques ou des sons additionnel.

Connexion SSH

La connexion SSH entre le pc windows et le rpi sous linux permettra aux deux periphérique de communiquer.

Sur le RPI

Activons le service sur le RPI


$ sudo raspi-config

Sélectionnez les éléments suivants :


3 Interface Options > P2 SSH > YES

Le service est maintenant actif. Récupérez l'adresse IP.

$ ifconfig

Et passez sur le PC Windows.

Sur Windows

Testons la connexion ssh avec Powershell:

$ ssh pi@XXX.XXX.X.XX

Le Mot de passe par défaut est :

raspberry

Si la connexion n'aboutit pas, vérifiez vos connexions et RTFM

Afin d'éviter de rentrer le mot de passe à chaque connexion, nous allons créer une clé publique.

Dans Powershell:

ssh-keygen.exe

Puis validez. Validez également sans modification tous les points qui vous seront présentés.

Puis, envoyez votre clé publique au RPI:

$ ssh pi@XXX.XXX.X.XX mkdir -p .ssh
$ pi@XXX.XXX.X.XX's password:

$ cat .ssh/id_rsa.pub | ssh pi@XXX.XXX.X.XX 'cat >> .ssh/authorized_keys'
$ pi@XXX.XXX.X.XX's password:

Vous pouvez maintenant vous connecter sans rentrer de mot de passe.

$ ssh pi@XXX.XXX.X.XX

Si un problème persiste -> RTFM

VLC

Procèdons à l'installation de VLC sur le RPI

RPI


$ sudo apt-get install vlc

... Classique

VLC sera utilisé entierement par la console. En voici là doc des commandes avancées

Téléchargement des musiques d'exemple

La Lib youtube-dl permet de télécharger facilement des vidéos ou des audios à partir d'un lien YouTube.
La lib dans les dépôts Ubuntu ne sont pas stable. Il faut donc télécharger le package depuis le site officiel.

$ sudo wget https://yt-dl.org/latest/youtube-dl -O /usr/local/bin/youtube-dl
$ sudo chmod a+x /usr/local/bin/youtube-dl
$ hash -r

Pour les essais, nous allons travailler avec les musiques et sons suivants :

Pour les télécharger

$ cd ~
$ youtube-dl -x --audio-format mp3 https://www.youtube.com/watch?v=O1wtKpdgk9c
$ mv Megan McDuffee - Don't Go In There _ Scary Dark Ambient Music-O1wtKpdgk9c.mp3 ambiance.mp3
$ youtube-dl -x --audio-format mp3 https://www.youtube.com/watch?v=-4_CIMDuoLM
$ mv BATS SOUND EFFECT IN HIGH QUALITY--4_CIMDuoLM.mp3 bats.mp3

NB: Lors de l'application de ce tuto sur une version LTS d'ubuntu, il a fallut que j'effectue des opération supplémentaire:

youtube-dl utilise python et par defaut, uniquement python3 est installé. j'ai donc utilisé la commande suivante:

$ sudo apt install python-is-python3

source

Il me manquait également une librairie ffmpeg

$ sudo apt-get install ffmpeg

source

Notez que les sons ont été téléchargés dans votre home :

/home/pi/

Tests des sorties son

Pour tester les sons téléchargés :

$ vlc ambiance.mp3

Normalement, le son devrait sortir par la sortie audio.

Serveur web VLC

Afin de pouvoir jouer plusieurs sons en même temps, nous devons clarifier les besoins :

Une musique ambiante tourne en continue durant toute une scène. Elle ne s'arrêtera que lorsque le besoin de changer de scène se fera ressentir. Néanmoins, la musique doit pouvoir être contrôlable pour être changé, baisser ou augmenter le volume, simplement stopper.
Des sons court d'ambiance vont être joué de façon impromptu suivant les besoins du MJ. Le son ne sera joué qu'une seule fois juste le temps nécessaire.

Dans ces conditions, la solution s'offrant à nous est le suivant :
Mettre la musique principale sur un serveur web audio VLC et les autres sons seront lancé par ligne de commande en fonction des besoins.

Pourquoi un serveur WEB

Le Serveur, web VLC, contrairement à son utilisation par ligne de commande, permet de garder la main sur la lecture de la musique en cours par le biais de requeté web.
La liste des requêtes disponible est énuméré dans cette documentation

Pour lancer l'interface web de VLC, il faut exécuter la ligne de commande suivante :

$ cvlc -I http --http-password xxx -L -R

Legende
-I:	Sélection de l'interface. Ici, c'est http
--http-password:	Mise en place d'un mot de passe d'accès (ici, c'est xxx, mais c'est à vous de le changer.)
-L:	activation de la loop
-R:	activation du repeat

Rendez-vous sur sur le PC Windows et sur votre navigateur preferé pour voir cette interface. Par défaut :

192.168.X.XX:8080

Un mot de passe vous sera demandé pour accéder à l'interface. Laissez le Username vide et le mot de passe est celui rentré dans la ligne de commande précédente. (ici xxx si vous ne l'avez pas changé)

Si vous souhaitez jouer une musique directement au lancement de l'interface, vous pouvez ajouter la piste souhaitée dans la ligne de commande :

$ cvlc -I http --http-password xxx -L -R /home/pi/ambiance.mp3

Mise en place du service

Afin de ne pas avoir la console hors d'usage durant la mise en service du serveur web VLC, il est nécessaire de transformer la commande en service daemon au démarrage du RPI.

documentation

STEP 1 : Écrire le service

$ sudo nano /etc/systemd/system/vlc-web.service

[Unit]
After=network.service

[Service]
ExecStart=/usr/local/bin/vlc-web-startup.sh

[Install]
WantedBy=default.target

STEP 2 : Écrire le script

$ sudo nano /usr/local/bin/vlc-web-startup.sh

#!/bin/bash

cvlc -I http --http-password pwd -q -L -R

STEP 3 : Gérer les droits de lecture

$ sudo chmod 744 /usr/local/bin/vlc-web-startup.sh
$ sudo chmod 664 /etc/systemd/system/disk-space-check.service

STEP 4 : Permettre le lancement de VLC par root

sudo sed -i 's/geteuid/getppid/' /usr/bin/vlc

Vous pouvez maintenant redémarrer votre RPI et le serveur se lancera automatiquement au démarrage à la même adresse que noter plus haut.

Test des requêtes avec Postman

Pour tester notre serveur, nous allons utiliser l'application Postaman depuis notre PC Windows

Durant les tests, n'oubliez pas de remplir les identifiants de connexion dans l'onglet "Authorization" et de sélection "Basic Auth". Laissez Username vide et saisissez votre mot de passe.

Ajouter une musique dans la playlist et jouez la :

http://192.168.X.XX:8080/requests/status.xml?command=in_play∈put=/home/pi/ambiance.mp3

Votre musique sera jouée maintenant en fond sonore et vous pouvez aussi profiter pleinement de votre shell :)

Toutes les commandes par requête http sont disponible dans cette documentation

Lancement des sons additionnel

Nous y voici enfin : lancer des sons additionnels au-dessus de la musique d'ambiance.

Maintenant, que tout est optimisé, une simple requête permet de réaliser votre rêve.

$ cvlc --no-one-instance --play-and-exit -q /home/pi/bats.mp3 &

Legende
cvlc:	C'est le client console
--no-one-instance:	Permet de lancer plusieurs instance VLC en meme temps
--play-and-exit:	Joue le son et quitte le processus VLC automatiquement
-q:	N'affiche aucune sortie.
/home/pi/bats.mp3:	Le lien vers le son
&:	Permet a la commande de ne pas bloquer la console durant l'exécution du processus.

ENJOY

Construction des données de contrôle de luminosité d'une lampe Neewer 660

Remy Jacquand — Fri, 10 Sep 2021 15:58:18 +0000

Construction des données de controle de luminosité d'une lampe Neewer 660

Dans le cadre des recherches sur le développement d'une application Windows pour contrôler un panneau LED Neewer 660, je réunis dans ce document les informations concernant la construction des données permettant de changer la luminosité de la lampe.

La lampe Neewer 660

La lampe Neewer est une lampe à LED RGB contrôlable par Bluetooth via l'application smartphone Android ou iPhone.

Voici le lien officiel

Les données

Après des manipulations de reverse engineering et focalisé sur les données de la luminosité de la lampe, il est apparue un code hexadécimal de 16 caractères:
xxxxxx xx xx xx xx xx

La constante: Les 6 premiers caractères sont fixes tout le long des tests et ont la valeur suivante : 788604

La couleur: Les 2 caractères suivants représentent la valeur hexadécimale de la position, en degrés, du curseur dans le cercle chromatique.

Le flag: S'en suis 2 caractères variants de 01 à 00 (en hexa). Ce flag change d'état lorsque la couleur dépasse la valeur FF pour retourner à 00

La luminosité: S'ajoute 2 caractères représentant la valeur hexadécimale du pourcentage de luminosité souhaité. Par exemple pour 100% => 64, 50% => 32, 25% => 19 et 0% => 0

La saturation: Ensuite 2 caractères dont la valeur hexadécimale représente le pourcentage de saturation de la couleur sélectionnée.

Le checksum: Concernant les 2 derniers caractères rien n'est sûr. Il semble représenter un genre de checksum allant de 0 à 255 avec un modificateur:

Checksum (base 10) = 2 (base 10)+ flag (base 10) + couleur (base 10) + luminosité (base 10) + saturation (base 10)

Puis convertie en hexadécimal.

Resultat: Une fois cet ensemble de caractère concaténé, nous obtenons les données permettant de contrôler la couleur, la saturation et la luminosité de la lampe.

Voici toutes les données recueillient:

Data light control for Neewer 660 RGB LED Lamp

Les tests

Les tests ont été effectués à l'aide d'un raspberry pi 4 avce Bluez installé.

Pour me connecter, il a été nécessaire de procéder à quelque configuration préalable.

Il semble important de modifier le fichier suivant :

sudo nano /etc/bluetooth/main.conf

d'y ajouter cette ligne en fin de document

DisablePlugins=pnat

et de redémarrer votre systeme

sudo reboot now

Une fois le système réveillé, vous pouvez vous connecter à la lampe avec la commande suivante :

gatttool -t random -b XX:XX:XX:XX:XX:XX -I

Notez que le parametre "-t" s'est vu affecter la valeur "random"

gatttool --help
Usage:
  gatttool [OPTION?]
...
-t, --addr-type=[public | random]         Set LE address type. Default: public
...

Une fois l'interface affichée, vous pouvez vous connecter et envoyer les données de controle.

pi@raspberrypi:~ $ gatttool -t random -b XX:XX:XX:XX:XX:XX -I
[XX:XX:XX:XX:XX:XX][LE]> connect
Attempting to connect to XX:XX:XX:XX:XX:XX
Connection successful
[XX:XX:XX:XX:XX:XX][LE]> char-write-cmd 0x000e 788604d100640037

Controlez vos lumières Triones Bluetooth Low Energy (BLE) avec votre Streamdeck (Partie 2)

Remy Jacquand — Sun, 02 May 2021 19:30:59 +0000

Avant d'aller plus loin, je tiens à apporter quelque précision sur ma démarche:

Ce post n'est pas à objectif pédagogique. Je ne suis pas un professionnel et je me suis adapté en fonction de mes connaissances, du matériel à ma disposition et du temps qui m'étais imparti.
Ce post, donc, est une explication de ma mise en place pour le sujet qui m'a été donné. Il sera plein de fautes, incomplet certainement voir même offrera des solutions plus compliqué que ce qu'il devrai être.

J'espère tout de même que ma démarche aidera d'autres personnes à imaginer de meilleur solution et dégrossira les difficultés qui peuvent être rencontré.

Merci à vous <3

Ps: C'est la 2e partie de mes recherhes. La partie 1 se trouve ici

Comment j'ai controlé les lumieres BLE Triones avec un Streamdeck (Partie 2)

Mise en place d'un Raspberry pi pour le controle Bluetooth des lumières

Après plusieurs essaie, j'ai décidé de me servir d'un systeme Linux pour communiqué avec les lumières à l'aide de la librairie intégrée Bluez. Cette librairie m'a permis en quelques lignes de commandes de découvrir mon réseau, me connecter et communiquer.

TODO : Détailler les opérations liés a l'installation, le scan, la connexion et les data

TODO : parler de la connection ssh + test coté windows avec streamdeck

Création du plugin Streamdeck en C

Préparation

Pour cette partie, j'ai simplement suivi le tuto de Claudio Bernasconi pour créer un plugin pour Streamdeck en C# avec Toolkit.

Pour ce faire :

Installez les pré-requis pour le "Streamdeck Toolkit", A savoir le Dotnet Core SDK et l'application "Streamdeck Software".
Installez également Visual studio 2019 Community edition pour gérer le projet et pouvoir le compiler.
Ouvre votre console préférée, rendez vous dans votre dossier de projet et tapez la ligne suivante:

dotnet new -i StreamDeckPluginTemplate::0.5.2040

- Créez le dossier de votre projet. (pour moi ça sera BtTrionesBLELightStreamdeckPlugin)

mkdir BtTrionesBLELightStreamdeckPlugin

Entrez dedans

cd BtTrionesBLELightStreamdeckPlugin
Saisissez la ligne suivante pour télécharger le template de création

dotnet new streamdeck-plugin --plugin-name StreamdeckPluginTrionesBleLights --uuid com.khundar.streamdecktrionesblelights --skipRestore false

. Attention à adapter le "plugin-name" et l'uuid.

L'uuid est important pour que l'application streamdeck reconnaisse votre plugin.
Ouvrez le projet avec Visual Studio 2019 avec "Ouvrir un projet ou une solution" et sélectionnez le fichier BtTrionesBLELightStreamdeckPlugin.csproj
Vous voici dans le projet Template. Il "ne reste plus qu'à..."

Objectif 1: envoyer une commande

Mon but à ce moment-ci est d'effectuer la connexion ssh et lancer gatttool.
Pour exécuter une commande shell, j'ai trouvé cette façon de faire :

ProcessStartInfo processInfo;
Process process;

processInfo = new ProcessStartInfo("cmd.exe", "/c " + bashCmd);
processInfo.CreateNoWindow = true;
processInfo.UseShellExecute = false;
processInfo.RedirectStandardError = true;
processInfo.RedirectStandardOutput = true;

process = Process.Start(processInfo);
process.WaitForExit();
process.Close();

Ensuite, pour effectuer ma commande de manipulation de la lumière, je remplace la variable bashCmd


string lightMacAddr = "ff:ff:11:11:bb:9b"; //adresse de la lumiere
string switch = "cc2333"; //commande d'allumage
string color = "ff0000";
string sshconnect = "ssh pi@192.168.0.32"; //Connexion ssh
string stophci = "sudo hciconfig hci0 down"; //fermeture de la connexion bluetooth
string starthci = "sudo hciconfig hci0 up"; //fermeture de la connexion bluetooth
string gatttoolpwr = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=" + switch;
string gatttoolcolor = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=56" + color + "00f0aa";
string bashCmd = "\"" + stophci + " && " + starthci + " && " + gatttoolpwr + " && " + gatttoolcolor + " && " + stophci + "\"";

Pour finir, je souhaite effectuer la commande sur un "keyup". Celle déjà en place suffira:


// ./StreamdeckPluginTrionesBleLightsAction.cs

public override async Task OnKeyUp(StreamDeckEventPayload args)
{

    string lightMacAddr = "ff:ff:11:11:bb:9b"; //adresse de la lumiere
    string switch = "cc2333"; //commande d'allumage
    string color = "ff0000";
    string sshconnect = "ssh pi@192.168.0.32"; //Connexion ssh
    string stophci = "sudo hciconfig hci0 down"; //fermeture de la connexion bluetooth
    string starthci = "sudo hciconfig hci0 up"; //fermeture de la connexion bluetooth
    string gatttoolpwr = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=" + switch;
    string gatttoolcolor = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=56" + color + "00f0aa";
    string bashCmd = "\"" + stophci + " && " + starthci + " && " + gatttoolpwr + " && " + gatttoolcolor + " && " + stophci + "\"";
    processInfo = new ProcessStartInfo("cmd.exe", "/c " + sshconnect + " " + bashCmd);
    processInfo.CreateNoWindow = true;
    processInfo.UseShellExecute = false;
    processInfo.RedirectStandardError = true;
    processInfo.RedirectStandardOutput = true;

    process = Process.Start(processInfo);
    process.WaitForExit();
    process.Close();


    //update settings
    await Manager.SetSettingsAsync(args.context, SettingsModel);
}

Très bien, mon action est prête.

Objectif 2: Dynamiser cette commande

À présent, isolons les variables nécessaires à la configuration d'une lumière :

l'adresse MAC de la lumière => lightMacAddr
l'état de la lumière => switch
la couleur => color

Commençons par modifier le model


// ./models/TrionesBLESettingsModel.cs

namespace StreamdeckPluginTrionesBleLights.Models
{
    public class TrionesBLESettingsModel
    {
        public string Switch { get; set; } = "000000";
        public string Color { get; set; } = "000000";
        public string LightMacAddr { get; set; } = "xx:xx:xx:xx:xx:xx";

    }
}

Ensuite, on ajoute les attributs du model dans le controleur.


// ./StreamdeckPluginTrionesBleLightsAction.cs

public override async Task OnKeyUp(StreamDeckEventPayload args)
{

    string lightMacAddr = SettingsModel.LightMacAddr; //adresse de la lumiere
    string switch = SettingsModel.LightMacAddr; //commande d'allumage
    string color = SettingsModel.Color;
    string sshconnect = "ssh pi@192.168.0.32"; //Connexion ssh
    string stophci = "sudo hciconfig hci0 down"; //fermeture de la connexion bluetooth
    string starthci = "sudo hciconfig hci0 up"; //fermeture de la connexion bluetooth
    string gatttoolpwr = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=" + switch;
    string gatttoolcolor = "sudo gatttool -b " + lightMacAddr + " --char-write-req --handle=0x0007 --value=56" + color + "00f0aa";
    string bashCmd = "\"" + stophci + " && " + starthci + " && " + gatttoolpwr + " && " + gatttoolcolor + " && " + stophci + "\"";
    processInfo = new ProcessStartInfo("cmd.exe", "/c " + sshconnect + " " + bashCmd);
    processInfo.CreateNoWindow = true;
    processInfo.UseShellExecute = false;
    processInfo.RedirectStandardError = true;
    processInfo.RedirectStandardOutput = true;

    process = Process.Start(processInfo);
    process.WaitForExit();
    process.Close();


    //update settings
    await Manager.SetSettingsAsync(args.context, SettingsModel);
}

Et on fini avec la vue.


<!-- ./property_inspector/property_inspector.html -->

<body>
    <div class="sdpi-wrapper">
        <!-- select light -->
        <div class="sdpi-item" id="select_light">
            <div class="sdpi-item-label">Lights</div>
            <select class="sdpi-item-value select" id="light" onchange="setSettings(event.target.value, 'LightMacAddr');">
                <option value="xx:xx:xx:xx:xx:xx">--Select a light--</option>
                <option value="ff:ff:11:11:bb:9b" data-name="Light 1">Light 1</option>
                <option value="ff:ff:50:03:10:3c" data-name="Light 2">Light 2</option>
                <option value="ff:ff:66:60:cf:58" data-name="Light 3">Light 3</option>
                <option value="ff:ff:77:70:b1:a4" data-name="Light 4">Light 4</option>
                <option value="ff:ff:33:30:fe:ee" data-name="Light 5">Light 5</option>
                <option value="ff:ff:44:42:77:82" data-name="Light 6">Light 6</option>

            </select>
        </div>
        <!-- switch on/off -->
        <div class="sdpi-item" id="select_switch"> 
            <div class="sdpi-item-label">Switch</div>
            <select class="sdpi-item-value select" id="switch" onchange="setSettings(event.target.value, 'Switch')">
                <option value="cc2333">ON</option>
                <option value="cc2433">OFF</option>
                <option value="000000">--Select a Power--</option>
            </select>
        </div>
        <!-- color -->
        <div type="range" class="sdpi-item" id="colorslider" onchange="setSettings(event.target.value, 'Color')">
            <div class="sdpi-item-label">Color</div>
            <div class="sdpi-item-value">
                <input type="color" id="color" value="#000000">
            </div>
        </div>
    </div>
    <script src="js/property-inspector.js"></script>
</body>

et le js

// global websocket, used to communicate from/to Stream Deck software
// as well as some info about our plugin, as sent by Stream Deck software 
var websocket = null,
    uuid = null,
    inInfo = null,
    actionInfo = {},
    settingsModel = {
        LightMacAddr: 'xx:xx:xx:xx:xx:xx',
        Switch: '000000',
        Color: '000000'
    };

function connectElgatoStreamDeckSocket(inPort, inUUID, inRegisterEvent, inInfo, inActionInfo) {
    uuid = inUUID;
    actionInfo = JSON.parse(inActionInfo);
    inInfo = JSON.parse(inInfo);
    websocket = new WebSocket('ws://localhost:' + inPort);

    //initialize values
    if (actionInfo.payload.settings.settingsModel) {
        settingsModel.LightMacAddr = actionInfo.payload.settings.settingsModel.LightMacAddr;
        settingsModel.Switch = actionInfo.payload.settings.settingsModel.Switch;
        settingsModel.Color = actionInfo.payload.settings.settingsModel.Color;
        settingsModel.Name = actionInfo.payload.settings.settingsModel.Name;

    }
    websocket.onopen = function () {
        console.log(settingsModel);
        setSelectField('light', settingsModel.LightMacAddr);
        setSelectField('switch', settingsModel.Switch);
        document.getElementById("color").value = '#' + settingsModel.Color;


        var json = { event: inRegisterEvent, uuid: inUUID };
        // register property inspector to Stream Deck
        websocket.send(JSON.stringify(json));

    };

    websocket.onmessage = function (evt) {
        // Received message from Stream Deck
        var jsonObj = JSON.parse(evt.data);
        var sdEvent = jsonObj['event'];
        switch (sdEvent) {
            case "didReceiveSettings":

                break;
            default:
                break;
        }
    };
    function setSelectField(id, value) {
        var allInputs = document.getElementById(id);
        for (var x = 0; x < allInputs.length; x++)
            if (allInputs[x].value == value) {
                allInputs[x].setAttribute('selected', 'selected');
                console.log(allInputs[x]);
            }

    }
}

const setSettings = (value, param) => {
    console.log(param + "=" + value);
    if (websocket) {

        if (param == 'Color')
            value = value.substring(1);

        settingsModel[param] = value;
        var json = {
            "event": "setSettings",
            "context": uuid,
            "payload": {
                "settingsModel": settingsModel
            }
        };

        websocket.send(JSON.stringify(json));
    }

};

A présent, mon plugin est prêt à être utiliser

Controlez vos lumières Triones Bluetooth Low Energy (BLE) avec votre Streamdeck (Partie 1)

Remy Jacquand — Sun, 02 May 2021 19:02:51 +0000

Avant d'aller plus loin, je tiens à apporter quelque précision sur ma démarche:

J'espère tout de même que ma démarche aidera d'autres personnes à imaginer de meilleur solution et dégrossira les difficultés qui peuvent être rencontré.

Merci à vous <3

Comment j'ai contrôle les lumières BLE Triones avec un Streamdeck (Partie 1)

Voici la demande

Mon Client est un Youtubeur qui souhaite créer un nouveau studio d'enregistrement et gérer son éclairage "facilement".
Dans son idée, il souhaite pré-configurer un éclairage et une vidéo spécifique en fonction des tournages et des scènes :

tournage 1/ scène 1 => ambiance plage
- lumière chaude + vidéo d'une plage
tournage 1/ scène 2 => ambiance Spatial
- lumières tamisées + vidéo de la terre
tournage 2/ scène 1 => ambiance volcan
- lumière rouge + vidéo lave
.... (vous avez saisi l'idée.)

Pour composer ces ambiances, le studio est équipé de 6 projecteurs lumineux et d'une énorme télévision afin de remplacer le fond vert.

Pour finir, le tout doit être contrôlé par un périphérique appelé le Streamdeck. Ainsi, il sera possible d'organiser les configurations en fonction des tournages et suffira d'appuyer sur un seul bouton pour automatiser les commandes aux lumières et à l’écran. Pour fonctionner, le Streamdek doit être connecté en permanence sur un pc (ici, un pc Windows) car le profil d'utilisation est enregistré sur le pc et non sur le périphérique.

Comment tester ces périphériques facilement pour comprendre leur fonctionnement

Après quelques recherches, j'ai rapidement compris que ces lumières BLE portait le nom Triones (et aussi parce qu'une fois branchait, ce nom apparaissais dans la liste des périphériques disponibles).

Le seul moyen proposé pour les manipuler était de télécharger l'application HappyLighting sur mon mobile Android. Effectivement, l'application fonctionne très bien et propose quelque fonctionnalité intéressante.

Coté PC, j'ai eu la bonne surprise de découvrir une application nodeJs permettant d'effectuer 90% des fonctionnalité proposé par l'appli. vinceroti s'est penché sur le problème et propose une interface très fonctionnel et simple d'utilisation.

TODO : Upload des images de l'appli bt-triones

Malheureusement pour moi c'est encore insuffisant car je n'ai pas trouvé le moyen de le faire communiquer avec le Streamdeck.

Puis, c'est en lisant le post détaillé de Uri Shaked que j'ai commencer à comprendre comment cette technologie est plutôt avare en information (l'article en question)

en Bref, l'article explique comment les différentes entité composants le Bluetooth Low Energy (BLE) sont sensé communiqué et comment l'auteur s'est débrouillé dans ce petit dédale. On y apprend l’existence d'une application mobile android appelé nRF Connect for Mobile et qui permet de communiqué à l'aide du Bluetooth avec les appareils qui nous entours et voir leurs entrées et sorties d'information a notre disposition.

En ce qui concerne ces données devant commander nos lumières Triones, madhead à laissé une petite note récapitulative détaillant les données dont on connait leurs effets :

Cette documentation ici.

Ici aussi, on y voit encore une documentation incomplète avec des données "Magic" mais l'essentiel y est :

allumer ou éteindre les lumières
choisir la couleur
choisir la luminosité
... et d'autre truc ne nous interagissant pas

A présent, les travaux Pratique !

Une fois la lumière trouvé sur l'application "nRF Connect Mobile", cliquez sur le bouton noir "connect"
Vous allez basculer sur l’onglet de communication avec le périphérique
Dans l'onglet "CLIENT", déployez le service dont l'UUID est "0xFFD5" en cliquant dessus
En appuyant sur le flèche pointant vers le haut, tout à droite, vous allez ouvrir la fenêtre d’envoi de data.
Pour tester, saisissez la valeur cc2333 pour allumer ou cc2433 pour éteindre. Puis validez avec le bouton "SEND"

DEV Community: Remy Jacquand

Mise en place d Outline et Authentik

1. Prérequis

2. Structure des services Docker

2.1 Outline

2.2 Authentik

3. Configuration des fichiers .env

3.1 Outline

3.2 Authentik

4. Configuration d’Authentik pour Outline

5. Démarrage des services

6. Connexion à Outline

7. Conclusion

Pourquoi mon serveur est devenu lent : le cas du disque SMR

Symptômes

Diagnostic initial

Vérification SMART

Le problème réel : la technologie SMR

Actions effectuées

Analyse I/O

Conclusion et recommandations

TL;DR

Héberger Paheko chez soit derière Cloudflare

Héberger Paheko chez soit derière Cloudflare

Paheko

Cloudflare

Cloudflared

Architecture

Intallation

Mise en place de Paheko

Mise en place de Cloudflared

Accès Exterieur

Streamer des fichiers audio avec homeassistant et mopidy

Préparation périphérique Mopidy

Installation Mopidy

Installation des extensions

Mopidy-MDP

Mopidy-Iris

configuration HTTP

Préparation du serveur HomeAssistant

Configuration de Home Assistant

Configuration des contrôles des Raspberry pi par MPD

Mise en place de l'espace media

Test

Ajout des cartes de contrôle de média

Diffusion du fichier audio

lien supplémentaire

Streamer une capture vidéo de sa webcam avec VLC

Depuis l'interface graphique de VLC

La capture vidéo

Stream vidéo

En ligne de commande

Fonctionnalités optionnelles

Ajouter un filigrane

Limiter la durée de la diffusion

Déclancher un signal midi avec NodeJs sur Windows

Installation

Configuration

LoopMidi

Midi-OX

Main.js

Start

Sources

Systeme de communication entre NodeJS, Madmapper et arduino

Problématique

Hardware et Software

​Preparation de l'environnement de travail

​LoopMidi

​Midi-OX

​Installation de Firmata dans le Arduino Uno et communication avec MadMapper

​Communication NodeJs et MadMapper

EasyMidi

Création page web express

​Parametrage d'action midi sur MadMapper

Installation mongoDB sur raspberry pi 3

Step 1 : installation d'Ubuntu sur le RPI3

Step 2 : Upgrade

Step 3 : installation MongoDB

Step 4 : Use as service

Step 5 : accéder au serveur depuis l'exterieur

3. Configuration des fichiers `.env`

Preparation de l'environnement de travail

LoopMidi

Midi-OX

Installation de Firmata dans le Arduino Uno et communication avec MadMapper

Communication NodeJs et MadMapper

Parametrage d'action midi sur MadMapper