Contrôle d'un variateur AC depuis Raspberry Pi via DimmerLink

En bref : La découpe de phase TRIAC directe depuis les GPIO de Raspberry Pi n'est pas réalisable — la gigue de l'OS Linux est de 1–10 ms alors que la synchronisation TRIAC exige < 100 µs. Utilisez DimmerLink comme contrôleur matériel : le RPi écrit une valeur de luminosité (0–100) à l'adresse I2C 0x50, registre 0x10. Une seule ligne en Python : bus.write_byte_data(0x50, 0x10, level).

Pourquoi Raspberry Pi ne peut pas piloter un TRIAC directement

La variation par découpe de phase déclenche la gâchette du TRIAC avec un délai précis après chaque passage par zéro du courant AC (toutes les 10 ms à 50 Hz). L'erreur de synchronisation admissible est inférieure à 100 µs pour éviter un scintillement visible.

Raspberry Pi fonctionne sous Linux — un OS généraliste avec un ordonnanceur préemptif, du swap, des pilotes réseau et de l'activité GPU, tous en compétition pour le temps CPU. La latence d'interruption GPIO sous cet OS :

Une gigue de 2 ms à 10 % de luminosité (fenêtre de déclenchement de 9 ms) correspond à 22 % de variation de luminosité — un scintillement clairement visible. Même avec le démon pigpio (GPIO basé sur DMA, meilleure option disponible) la gigue est typiquement de 200–500 µs — toujours au-dessus du seuil requis sous charge réelle.

Ce n'est pas une limitation propre au Raspberry Pi. Tout SBC sous Linux (Orange Pi, Rock Pi, Jetson Nano, Banana Pi) a la même contrainte. Le contrôle TRIAC en temps réel sous Linux nécessite soit un patch noyau RT (impraticable pour un usage amateur) soit de déléguer la synchronisation à un microcontrôleur dédié.

DimmerLink est ce contrôleur dédié. Il gère la détection de passage par zéro et le déclenchement du TRIAC sur un Cortex-M0+ (famille STM32), atteignant < 50 µs de gigue quelle que soit la charge CPU de l'hôte. Raspberry Pi lui indique simplement la luminosité souhaitée — aucune exigence de synchronisation.

Matériel nécessaire

• Raspberry Pi 3, 4, 5 ou Zero 2W (tout modèle avec I2C)
• Module DimmerLink
• Module variateur AC rbdimmer (tout calibre de courant)
• 2 × résistances 4,7 kΩ (rappels I2C — souvent inutiles sur RPi 3/4)

Étape 1 — Basculer DimmerLink en mode I2C

DimmerLink est livré en mode UART par défaut. Basculez-le en mode I2C avant de le connecter au Raspberry Pi.

Connectez DimmerLink à un adaptateur USB-UART (TX → RX, RX → TX, GND, VCC 3.3V). Sur n'importe quel ordinateur, ouvrez le port à 115200 baud, 8N1, et envoyez :

Raw bytes: 02 5B

Réponse attendue : 00 (OK). L'appareil démarre désormais en mode I2C après chaque mise sous tension. (Le mode est sauvegardé en EEPROM.)

Étape 2 — Câblage

Raspberry Pi → DimmerLink (I2C)

Résistances de rappel : Raspberry Pi 3/4/5 dispose de rappels intégrés de 1,8 kΩ sur GPIO2 et GPIO3. Ils sont généralement suffisants pour des câbles de moins de 30 cm. Pour des câbles plus longs ou une communication instable, ajoutez des résistances externes de 4,7 kΩ entre SDA/SCL et 3.3V.

DimmerLink → Module variateur AC

Connect the dimmer module to mains AC and the load per the Hardware Connection Guide.

Étape 3 — Activer I2C sur Raspberry Pi

sudo raspi-config
# Interface Options → I2C → Enable → OK → Finish
sudo reboot

Après redémarrage, installez i2c-tools et vérifiez la connexion :

sudo apt install i2c-tools
i2cdetect -y 1

Sortie attendue — l'adresse 50 visible dans le tableau :

0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
...
50: 50 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

If the device does not appear, see DimmerLink Not Detected.

Étape 4 — Contrôle en Python (smbus2)

Installez la bibliothèque :

pip install smbus2

Exemple minimal

from smbus2 import SMBus
DIMMER_ADDR = 0x50
REG_LEVEL   = 0x10  # DIM0_LEVEL — luminosité 0–100%
bus = SMBus(1)  # Bus I2C 1 du Raspberry Pi
bus.write_byte_data(DIMMER_ADDR, REG_LEVEL, 50)  # régler à 50%
bus.close()

Classe complète avec gestion d'erreurs

from smbus2 import SMBus
import time
class DimmerLink:
    ADDR = 0x50
    REG_STATUS = 0x00
    REG_LEVEL  = 0x10  # luminosité 0-100%
    REG_CURVE  = 0x11  # 0=LINEAR, 1=RMS, 2=LOG
    REG_FREQ   = 0x20  # fréquence secteur (50 ou 60 Hz)
    def __init__(self, bus_number=1):
        self.bus = SMBus(bus_number)
    def is_ready(self):
        status = self.bus.read_byte_data(self.ADDR, self.REG_STATUS)
        return bool(status & 0x01)
    def set_level(self, level: int):
        """Régler la luminosité 0–100%."""
        level = max(0, min(100, level))
        self.bus.write_byte_data(self.ADDR, self.REG_LEVEL, level)
    def get_level(self) -> int:
        """Lire la luminosité actuelle."""
        return self.bus.read_byte_data(self.ADDR, self.REG_LEVEL)
    def set_curve(self, curve: int):
        """Définir la courbe de variation : 0=LINEAR, 1=RMS, 2=LOG."""
        if curve not in (0, 1, 2):
            raise ValueError("curve must be 0, 1, or 2")
        self.bus.write_byte_data(self.ADDR, self.REG_CURVE, curve)
    def get_frequency(self) -> int:
        """Lire la fréquence secteur (50 ou 60 Hz)."""
        return self.bus.read_byte_data(self.ADDR, self.REG_FREQ)
    def close(self):
        self.bus.close()
if __name__ == "__main__":
    dimmer = DimmerLink()
    if dimmer.is_ready():
        print(f"Fréquence secteur : {dimmer.get_frequency()} Hz")
        # Montée progressive
        for level in range(0, 101, 5):
            dimmer.set_level(level)
            print(f"Luminosité : {level}%")
            time.sleep(0.1)
        # Courbe RMS pour lampes à incandescence
        dimmer.set_curve(1)  # 1 = RMS
        print("Courbe : RMS (incandescence)")
    else:
        print("DimmerLink non prêt — vérifiez le câblage et le mode I2C")
    dimmer.close()

Contrôle rapide en CLI (sans Python)

# Régler la luminosité à 50%  (0x32 hex = 50 décimal)
i2cset -y 1 0x50 0x10 50
# Lire la luminosité actuelle
i2cget -y 1 0x50 0x10
# Lire la fréquence secteur
i2cget -y 1 0x50 0x20

Étape 5 — Intégration Node-RED

Via le nœud exec avec la commande i2cset

Dans un flux simple, utilisez exec pour exécuter i2cset :

[inject: level=50] → [function: construire la commande] → [exec] → [debug]

Nœud Function :

var level = msg.payload;  // 0-100
msg.payload = "i2cset -y 1 0x50 0x10 " + level;
return msg;

Via node-red-contrib-i2c

Installez le nœud :

cd ~/.node-red
npm install node-red-contrib-i2c

Configurez un nœud i2c out :

• Address : 0x50
• Command : 0x10 (registre)
• Payload : la valeur de luminosité (0–100) depuis msg.payload

Un curseur UI mappé sur 0–100 contrôle alors directement le variateur.

Étape 6 — Home Assistant OS sur Raspberry Pi

Si Raspberry Pi exécute Home Assistant OS (et non Home Assistant sur Raspberry Pi OS), l'accès matériel I2C depuis les add-ons est restreint par le modèle conteneurisé de HA OS.

Approche recommandée :

1. Conservez le Raspberry Pi comme serveur HA.
2. Ajoutez un ESP32 avec DimmerLink séparé comme contrôleur matériel.
3. Utilisez l'add-on ESPHome dans Home Assistant pour flasher et gérer l'ESP32.
4. HA contrôle la luminosité via l'intégration ESPHome — pas d'I2C direct depuis l'hôte RPi.

See: AC Dimmer with Home Assistant and ESPHome

Si vous exécutez Home Assistant supervised sur Raspberry Pi OS (pas HA OS), l'accès I2C depuis les scripts Python est libre et l'approche smbus2 ci-dessus fonctionne directement.

Étape 7 — Lancer comme service systemd

Pour démarrer automatiquement le script de contrôle du variateur :

Créez /etc/systemd/system/dimmer.service :

[Unit]
Description=DimmerLink Controller
After=multi-user.target
[Service]
Type=simple
ExecStart=/usr/bin/python3 /home/pi/dimmer_control.py
Restart=on-failure
User=pi
[Install]
WantedBy=multi-user.target

Activez et démarrez :

sudo systemctl daemon-reload
sudo systemctl enable dimmer.service
sudo systemctl start dimmer.service

Autres SBC Linux

La même approche fonctionne sur tout SBC Linux avec I2C :

Pour trouver les bus I2C disponibles sur toute carte Linux :

ls /dev/i2c-*

Pour Orange Pi et Banana Pi, activez I2C via armbian-config :

sudo armbian-config
# System → Hardware → enable i2c

En Python, passez le bon numéro de bus à SMBus() :

bus = SMBus(3)  # pour /dev/i2c-3 sur Orange Pi Zero 2

Erreurs fréquentes

Checklist rapide

Articles connexes

• DimmerLink I2C not detected → DimmerLink Not Detected: I2C vs UART Mode
• Tasmota integration → Tasmota AC Dimmer via DimmerLink
• Home Assistant guide → AC Dimmer with Home Assistant and ESPHome
• ESPHome YAML → ESPHome YAML for AC Dimmer and DimmerLink
• Safety and wiring → AC Dimmer Safety: Mains Voltage, Isolation, and Wiring

Encore des questions ?

Ask on forum.rbdimmer.com or open a GitHub Issue.