Arduino et communication 433MHz: allumer des LEDs à distance

Cet article va présenter une solution pour allumer deux LEDs à partir de boutons poussoirs, mais via une communication radio à 433MHz. La communication radio étant un domaine un peu différent de l’électronique, je commence d’emblée par quelques conseils pour vous éviter mes erreurs de débutant:

Communication sans fil: ce qu’il faut savoir avant de démarrer

• Emetteur et récepteur: ne pas utiliser les composants estampillés FS1000A (émetteur) + MX-RM-5V (récepteur). La raison est simple: le circuit de réception ne dispose pas de protection à l’entrée: si l’émetteur est un peu trop près ou si la puissance de l’émetteur est trop forte, ou si vous jouez avec votre télécommande de garage d’un peu trop près, vous allez griller le circuit de réception et avoir du mal à identifier la panne. Pour quelques dizaines de centime de plus, il faut privilégier la paire STX882 et SRX 882, beaucoup plus robustes.
• 2 cartes Arduino sont vraiment à privilégier pour utiliser ces paires de modules. J’ai voulu essayer avec un Pi Pico et un Arduino, et ça c’est avéré beaucoup plus difficile, du fait du manque d’une librairie qui proposerai un protocole commun à ces deux plateformes. Ca oblige à redévelopper son propre protocole et on perd l’avantage d’une librairie qui définira par défaut débit de transmission, code correcteur d’erreur, répétition, en-tête de message, etc…

Fonctionnement

Côté émetteur, on va réaliser un circuit qui détectera l’appui de deux boutons. Chaque bouton est associé à un message, qui est constitué d’une seule lettre, R pour rouge, G pour vert/green. Ce message est envoyé avec la librairie RadioHead, qui est relativement commune et simple d’utilisation. On règle un débit faible et une répétition du message pour être robuste aux interférence ou à la distance.

Côté récepteur, on attend la réception d’un message connu (R ou G), et on allume la LED qui correspond en fonction. Tout autre message est rejeté.

Côté émetteur

On s’occupe du côté émetteur, qu’on va appeler Tx (pour Transmitter). Voici le montage des composants et le code associé à charger sur l’arduino.

// ============================================================
//  Émetteur — Arduino Uno + STX882 — Télécommande LED
// ============================================================
//
//  Câblage :
//    STX882  DATA → pin 12
//    STX882  VCC  → 5V
//    STX882  GND  → GND
//
//    Bouton VERT  : entre pin 2 et GND  (pull-up interne)
//    Bouton ROUGE : entre pin 3 et GND  (pull-up interne)
//
//  Optimisations longue distance :
//    · 1000 bps  : débit minimal de RH_ASK, meilleure immunité au bruit
//    · Répétition x3 du message avec 200 ms d'intervalle
//    · Attente de fin d'émission avant répétition (waitPacketSent)
//    · Messages courts (2 octets) = trames plus courtes = moins d'erreurs
// ============================================================

#include <RH_ASK.h>
#include <SPI.h>

// 1000 bps = débit le plus bas supporté par RH_ASK → portée maximale
RH_ASK driver(1000, 11, 12, 10);  // (baud, pin_rx, pin_tx, pin_ptt)

const uint8_t PIN_BTN_VERT  = 2;
const uint8_t PIN_BTN_ROUGE = 3;

// Messages courts : 'G' = green, 'R' = red
const char MSG_VERT[]  = "G";
const char MSG_ROUGE[] = "R";

// Nombre de répétitions par appui et délai entre elles
const uint8_t  NB_REPETITIONS  = 3;
const uint16_t DELAI_REPETITION = 200;  // ms

// Anti-rebond logiciel
const uint16_t DEBOUNCE_MS = 50;

bool dernierEtatVert  = HIGH;
bool dernierEtatRouge = HIGH;
unsigned long dernierTempsVert  = 0;
unsigned long dernierTempsRouge = 0;

void envoyerMessage(const char* msg) {
  for (uint8_t i = 0; i < NB_REPETITIONS; i++) {
    driver.send((const uint8_t*)msg, strlen(msg));
    driver.waitPacketSent();
    if (i < NB_REPETITIONS - 1) delay(DELAI_REPETITION);
  }
  Serial.print("Envoye x");
  Serial.print(NB_REPETITIONS);
  Serial.print(" : ");
  Serial.println(msg);
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_BTN_VERT,  INPUT_PULLUP);
  pinMode(PIN_BTN_ROUGE, INPUT_PULLUP);

  if (!driver.init()) {
    Serial.println("Erreur init RadioHead !");
    while (true);
  }
  Serial.println("Emetteur pret.");
}

void loop() {
  unsigned long maintenant = millis();
  bool etatVert  = digitalRead(PIN_BTN_VERT);
  bool etatRouge = digitalRead(PIN_BTN_ROUGE);

  // Détection front descendant (appui) avec anti-rebond
  if (etatVert == LOW && dernierEtatVert == HIGH
      && (maintenant - dernierTempsVert) > DEBOUNCE_MS) {
    dernierTempsVert = maintenant;
    envoyerMessage(MSG_VERT);
  }

  if (etatRouge == LOW && dernierEtatRouge == HIGH
      && (maintenant - dernierTempsRouge) > DEBOUNCE_MS) {
    dernierTempsRouge = maintenant;
    envoyerMessage(MSG_ROUGE);
  }

  dernierEtatVert  = etatVert;
  dernierEtatRouge = etatRouge;
}

Côté récepteur

On s’occupe du côté récepteur, qu’on va appeler Rx (pour Receiver). Voici le montage des composants et le code associé à charger sur l’arduino.

// ============================================================
//  Récepteur — Arduino Uno + SRX882 — Télécommande LED
// ============================================================
//
//  Câblage :
//    SRX882  DATA → pin 11
//    SRX882  CS   → 5V  (activation permanente du module)
//    SRX882  VCC  → 5V
//    SRX882  GND  → GND
//
//    LED VERTE : pin 6 → résistance 220Ω → anode LED → cathode → GND
//    LED ROUGE : pin 7 → résistance 220Ω → anode LED → cathode → GND
//
//  Même vitesse que l'émetteur (1000 bps) — obligatoire.
//
//  Logique :
//    Réception 'G' → allume LED verte, éteint LED rouge
//    Réception 'R' → allume LED rouge, éteint LED verte
//    Les répétitions émetteur sont ignorées (même état → pas de changement visible)
// ============================================================

#include <RH_ASK.h>
#include <SPI.h>

RH_ASK driver(1000, 11, 12, 10);  // même paramètres que l'émetteur

const uint8_t PIN_LED_VERTE = 6;
const uint8_t PIN_LED_ROUGE = 7;

void allumerVerte() {
  digitalWrite(PIN_LED_VERTE, HIGH);
  digitalWrite(PIN_LED_ROUGE, LOW);
  Serial.println("LED verte allumee");
}

void allumerRouge() {
  digitalWrite(PIN_LED_ROUGE, HIGH);
  digitalWrite(PIN_LED_VERTE, LOW);
  Serial.println("LED rouge allumee");
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED_VERTE, OUTPUT);
  pinMode(PIN_LED_ROUGE, OUTPUT);
  digitalWrite(PIN_LED_VERTE, LOW);
  digitalWrite(PIN_LED_ROUGE, LOW);

  if (!driver.init()) {
    Serial.println("Erreur init RadioHead !");
    while (true);
  }
  Serial.println("Recepteur pret.");
}

void loop() {
  uint8_t buf[RH_ASK_MAX_MESSAGE_LEN];
  uint8_t buflen = sizeof(buf);

  if (driver.recv(buf, &buflen)) {
    // CRC vérifié par RadioHead — on traite uniquement les trames valides
    if (buflen == 1) {
      switch (buf[0]) {
        case 'G': allumerVerte(); break;
        case 'R': allumerRouge(); break;
        default:
          Serial.print("Message inconnu : ");
          Serial.println((char)buf[0]);
          break;
      }
    }
  }
}