Arduino HC-06 code : Bluetooth esclave

Connecter un module Bluetooth HC‑06 à une carte Arduino ouvre la voie au pilotage sans fil, au contrôle à distance et à la télémétrie. Le HC‑06 fonctionne en mode esclave, ce qui impose une architecture de communication bien précise et une configuration matérielle soignée.

Une fois les bases comprises, la mise en place d’un code Arduino HC‑06 reste méthodique : choix des pins, gestion de l’UART, adaptation des niveaux logiques, structure du protocole de trame, sécurisation du lien, tout se joue sur quelques détails techniques.

Fonctionnement du module HC‑06 en Bluetooth esclave avec Arduino

Le module HC‑06 est un module Bluetooth série conçu pour ajouter une liaison sans fil à une carte Arduino. Il se comporte comme un pont UART / Bluetooth, en mode esclave uniquement. Il accepte une alimentation de 3,3 V à 6 V en entrée (PIN VCC) mais son interface logique (TX/RX) fonctionne en 3,3 V TTL.

ArduinoArduino et domotique : automatiser sa maison pour pas cher

Le HC‑06 utilise la norme Bluetooth 2.0 ou 2.1 + EDR, sur la bande ISM de 2,4 GHz, avec une modulation GFSK. Il supporte exclusivement le profil SPP (Serial Port Profile), ce qui le fait apparaître comme un port série virtuel côté smartphone, PC ou Raspberry Pi. La portée typique se situe autour de 10 m en intérieur et 20 à 30 m en extérieur en ligne de vue, avec une antenna intégrée directement sur le module.

Le principe d’utilisation avec Arduino reste simple : l’Arduino envoie et reçoit des octets sur son port série (matériel ou logiciel), le HC‑06 se charge de convertir ce flux UART en trame Bluetooth à destination de l’appareil maître (téléphone, ordinateur, autre contrôleur). Le débit série par défaut est 9600 bauds avec un code PIN d’appairage 1234 et un nom d’appareil « HC-06 ».

« Le HC‑06 est un module Bluetooth esclave, compact et robuste, parfaitement adapté aux liaisons série simples entre Arduino et un smartphone ou un PC, sur des distances courtes. »

Spécifications techniques du HC‑06 à connaître avant le code Arduino

Pour écrire un code Arduino propre et fiable, il reste utile de maîtriser quelques caractéristiques techniques du HC‑06. Ces paramètres influencent directement le schéma de câblage, la configuration de la liaison série et la stratégie énergétique.

Différences HC‑06 / HC‑05 : impact sur le code Arduino Bluetooth

Le HC‑06 est souvent comparé au HC‑05, autre module Bluetooth très répandu. Les deux partagent un format et une interface UART assez proches, mais le comportement Bluetooth diffère. Le HC‑05 peut être maître ou esclave et gère une communication bidirectionnelle full duplex entre deux modules, alors que le HC‑06 reste cantonné au rôle d’esclave.

Sur Arduino, cette distinction change la manière de structurer les projets. Avec un HC‑06, la carte se contente d’attendre une connexion depuis un maître (smartphone, PC). Avec un HC‑05 configuré en maître, l’Arduino peut initier lui‑même une liaison Bluetooth vers un autre HC‑05 ou HC‑06. La gestion de la découverte, de l’appairage et du maintien de la connexion suit alors une logique différente.

• HC‑06 : rôle esclave fixe, configuration AT restreinte, usage centré sur les liaisons simples Arduino ↔ téléphone.
• HC‑05 : rôle maître / esclave, commandes AT étendues, débit série ajustable (38400, 57600, 115200 bps, etc.).
• Liaison entre modules : deux HC‑06 ne gèrent pas de communication directe maître ↔ esclave entre eux. Un HC‑05 en maître reste nécessaire si l’objectif est de relier deux modules Bluetooth ensemble.

« Dans un projet Arduino orienté contrôle par smartphone, le HC‑06 couvre la majorité des besoins. Pour des réseaux plus complexes ou des ponts entre microcontrôleurs, le HC‑05 offre davantage de flexibilité. »

Câblage Arduino HC‑06 : schéma, alimentation et adaptation des niveaux

Un câblage soigné garantit une communication fiable et un module préservé. Le HC‑06 se connecte en quelques fils seulement : alimentation, masse, TX, RX. L’Arduino agit comme contrôleur applicatif, en envoyant des commandes ou en réceptionnant des données de capteurs via le lien Bluetooth.

Connexion électrique HC‑06 vers Arduino UNO / Nano

Sur une carte Arduino UNO / Nano en 5 V, le HC‑06 impose une adaptation sur la ligne RX du module. Son entrée RX n’accepte pas directement le 5 V logique. Un simple diviseur de tension réalisé avec deux résistances limite la tension à un niveau sûr.

Schéma type :

• HC‑06 VCC → 5 V de l’Arduino (ou 3,3 V selon le module, vérifier la sérigraphie).
• HC‑06 GND → GND Arduino.
• HC‑06 TXD → entrée RX de l’Arduino (RX matériel ou pin SoftwareSerial) sans adaptation, car le signal sort en 3,3 V et reste lisible par l’Arduino.
• HC‑06 RXD → sortie TX de l’Arduino via un diviseur de tension 5 V → 3,3 V.

Diviseur de tension recommandé pour la ligne vers RXD :

• R1 = 2 kΩ entre TX Arduino (5 V) et RX HC‑06.
• R2 = 1 kΩ entre RX HC‑06 et GND.

Cette combinaison ramène le signal autour de 3,3 V sur RX du module, ce qui respecte ses spécifications de tension logique et évite une dégradation à long terme.

Utilisation du port série matériel vs SoftwareSerial

Sur Arduino UNO, les broches 0 (RX) et 1 (TX) correspondent au port série matériel utilisé également pour la programmation USB. Pour un projet durable, il reste préférable de séparer la liaison Bluetooth de ce port dédié au debug et à l’upload du code.

La bibliothèque SoftwareSerial reste souvent employée :

• Choix de deux pins numériques libres (par exemple 10 pour RX et 11 pour TX).
• Création d’un port série virtuel dédié au HC‑06.
• Conservation de Serial pour le moniteur série via USB (debug, logs, traces).

#include <SoftwareSerial.h>

// RX Arduino <- TX HC-06
// TX Arduino -> RX HC-06 (via diviseur de tension)
SoftwareSerial btSerial(10, 11); // RX, TX

void setup() {
  Serial.begin(9600);      // Moniteur série USB
  btSerial.begin(9600);    // HC-06 à 9600 bauds

  Serial.println("Initialisation HC-06 en mode esclave...");
}

void loop() {
  // Relayage des données PC -> Bluetooth
  if (Serial.available()) {
    char c = Serial.read();
    btSerial.write(c);
  }

  // Relayage des données Bluetooth -> PC
  if (btSerial.available()) {
    char c = btSerial.read();
    Serial.write(c);
  }
}

Ce code met en place un pont transparent entre le moniteur série de l’IDE Arduino et le module HC‑06. Il permet de tester la communication, d’observer les caractères reçus et de valider la configuration physique avant de passer à une logique applicative plus avancée.

Paramétrage du HC‑06 en mode esclave : nom, PIN, débit

Le HC‑06 arrive en général préconfiguré avec :

• Nom : « HC-06 »
• PIN : 1234
• Débit série : 9600 bauds

Ces paramètres suffisent pour une liaison de base, mais un renommage et un code PIN différent apportent une meilleure lisibilité et un niveau de contrôle plus serré lorsque plusieurs modules Bluetooth cohabitent.

Commandes AT du HC‑06 : configuration via Arduino

Le HC‑06 possède un jeu de commandes AT limité par rapport au HC‑05, mais suffisant pour les usages courants. Pour accéder au mode AT, le module doit rester non appairé (aucune connexion active) et accepter des commandes depuis l’Arduino à un débit généralement fixé à 9600 bps (ou un autre débit si le module a déjà été modifié).

ArduinoPiloter un relais 230 V avec Arduino en sécurité : 5 erreurs à éviter

Exemple minimal pour envoyer une commande AT :

#include <SoftwareSerial.h>

SoftwareSerial btSerial(10, 11);

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);

  Serial.println("Mode configuration HC-06...");

  delay(2000);

  btSerial.print("AT"); // Test simple
}

void loop() {
  if (btSerial.available()) {
    Serial.write(btSerial.read());
  }
}

Commandes AT courantes du HC‑06 (syntaxe indicative, selon firmware) :

• AT : test de communication, le module répond en général par « OK ».
• AT+NAME=MonModule : change le nom Bluetooth visible lors de la recherche d’appareils.
• AT+PIN=5678 : modifie le code PIN d’appairage (4 chiffres en général).
• AT+BAUD4 : change le débit série (par exemple code 4 pour 9600 bauds, d’autres codes pour 38400, 57600, etc. selon la documentation du module).

Écriture du code Arduino HC‑06 : réception de commandes Bluetooth

Une fois la liaison série validée et le module paramétré, le cœur du projet réside dans la gestion des commandes reçues depuis l’application maître (smartphone, PC). Le HC‑06 transporte un flux d’octets, à l’Arduino ensuite d’interpréter ces données selon un protocole clair.

Structure d’un protocole simple par caractères ou mots‑clés

Pour un contrôle basique (LED, relais, moteurs), une architecture par caractères reste efficace. Chaque caractère reçu correspond à une action précise.

#include <SoftwareSerial.h>

SoftwareSerial btSerial(10, 11);
const int LED_PIN = 13;

void setup() {
  pinMode(LED_PIN, OUTPUT);

  Serial.begin(9600);
  btSerial.begin(9600);

  Serial.println("Arduino prêt pour les commandes Bluetooth HC-06.");
}

void loop() {
  if (btSerial.available()) {
    char cmd = btSerial.read();

    switch (cmd) {
      case '1':
        digitalWrite(LED_PIN, HIGH);
        Serial.println("LED ON");
        btSerial.println("ACK:LED_ON");
        break;
      case '0':
        digitalWrite(LED_PIN, LOW);
        Serial.println("LED OFF");
        btSerial.println("ACK:LED_OFF");
        break;
      default:
        Serial.print("Commande inconnue : ");
        Serial.println(cmd);
        btSerial.println("ERR:UNKNOWN_CMD");
        break;
    }
  }
}

Ce code montre une boucle simple : l’Arduino lit un caractère, applique une action et renvoie une réponse sur le lien Bluetooth. L’application côté maître (par exemple une interface Android) envoie « 1 » pour allumer la LED et « 0 » pour l’éteindre, puis lit les réponses « ACK » ou « ERR » pour synchroniser son état.

Gestion de trames textuelles plus structurées

Pour des projets un peu plus évolués, un protocole textuel structuré offre une meilleure extensibilité. Par exemple : CMD:LED=ON, CMD:MOTOR=STOP, CMD:SERVO=90. L’Arduino accumule les caractères jusqu’à un séparateur (saut de ligne, point‑virgule) puis parse la commande complète.

#include <SoftwareSerial.h>

SoftwareSerial btSerial(10, 11);
String bufferCmd = "";

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
}

void traiterCommande(String cmd) {
  cmd.trim();

  if (cmd == "LED=ON") {
    digitalWrite(13, HIGH);
    btSerial.println("OK:LED=ON");
  } else if (cmd == "LED=OFF") {
    digitalWrite(13, LOW);
    btSerial.println("OK:LED=OFF");
  } else {
    btSerial.print("ERR:CMD=");
    btSerial.println(cmd);
  }
}

void loop() {
  while (btSerial.available()) {
    char c = btSerial.read();

    if (c == '\n') {
      if (bufferCmd.length() > 0) {
        traiterCommande(bufferCmd);
        bufferCmd = "";
      }
    } else {
      bufferCmd += c;
    }
  }
}

Cette approche simplifie l’ajout de nouvelles commandes dans le temps. Elle se combine facilement avec des applications mobiles construites avec des outils comme MIT App Inventor, AppSheet ou une application native Android.

Arduino HC‑06 : envoi de données, télémétrie et retour d’état

Le mode esclave n’interdit pas à l’Arduino d’initier l’envoi d’informations vers le maître, une fois la connexion établie. Le HC‑06 transmet tout ce que l’Arduino lui envoie, que ce soit des mesures analogiques, des états logiques ou des messages de log.

Quelques scénarios fréquents :

• Récupération de données de capteurs (température, humidité, luminosité) affichées sur un tableau de bord mobile.
• Retour d’état d’un robot : batterie, distance passée, vitesse actuelle.
• Monitoring de mesures électriques, en lien par exemple avec une installation gérée par un disjoncteur de protection électrique pour surveiller la consommation.

#include <SoftwareSerial.h>

SoftwareSerial btSerial(10, 11);
const int CAPTEUR_TEMP = A0;

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
}

void loop() {
  int valBrute = analogRead(CAPTEUR_TEMP);
  float tension = (valBrute / 1023.0) * 5.0;
  float temperature = (tension - 0.5) * 100.0; // Exemple pour un LM35-like

  btSerial.print("TEMP=");
  btSerial.print(temperature);
  btSerial.println("C");

  delay(1000); // Envoi toutes les secondes
}

Côté application maître, il suffit de parser les lignes reçues pour alimenter des graphiques, des jauges ou des enregistrements de données pour un suivi à moyen terme.

Limites du HC‑06 en mode esclave et bonnes pratiques de conception

Le HC‑06 rend les liaisons Bluetooth accessibles, mais présente quelques contraintes à prendre en compte dès la phase de conception. Une architecture claire évite les mauvaises surprises en phase de test ou en déploiement sur le terrain.

Restrictions Bluetooth et profil SPP

Le HC‑06 ne supporte que le profil SPP. Cette réalité impose de l’utiliser comme un lien série virtuel, sans fonctionnalités avancées de type Bluetooth Low Energy, beacons ou communication multipoint.

• Pas de mode maître : l’Arduino ne peut pas rechercher ni initier une connexion vers un autre module, il attend simplement qu’un maître se connecte à lui.
• Aucune mesure RSSI fournie : absence de retour direct sur la qualité du signal dans la couche série.
• Portée limitée : ≈ 10 m en intérieur, avec une perte de performance notable en présence d’obstacles métalliques ou de murs épais.

Pour un réseau d’objets, un maillage complexe ou un besoin de faible consommation énergétique, des solutions Bluetooth 4.x / 5.x ou d’autres technos radio (LoRa, Wi‑Fi, Zigbee) offrent des options plus adaptées.

Consommation énergétique et gestion d’alimentation

Une consommation de 40 à 50 mA en fonctionnement continu impacte rapidement une alimentation sur batterie. L’Arduino peut cependant gérer la durée d’activation du module :

• Placer le HC‑06 derrière un transistor ou un MOSFET piloté par une sortie Arduino.
• Désactiver l’alimentation Bluetooth en phase de sommeil ou de veille profonde.
• Limiter la fréquence d’envoi de données, en envoyant des batchs plutôt qu’un flux continu.

Interopérabilité et cas d’usage typiques

Le HC‑06 reste adapté à des scénarios concrets bien ciblés :

• Contrôle à distance d’appareils domestiques : éclairage, ventilateur, petite motorisation.
• Pilotage de robots éducatifs : différentiel de vitesse, direction, consignes de trajectoire.
• Acquisition de données capteurs : température, mouvement, lumière, tension batterie.
• Surveillance d’armoires électriques : en association avec un disjoncteur différentiel, l’Arduino transmet des alertes de déclenchement ou des mesures de courant par Bluetooth.

Pour des montages plus spécifiques, le recours à un module type F en protection des circuits alimentant l’ensemble Arduino + HC‑06 apporte une couche de sécurité matérielle adaptée aux environnements perturbés (charges électroniques, variateurs, etc.).

« L’association Arduino + HC‑06 offre une base solide pour explorer la communication série sans fil, à condition de rester dans le cadre du profil SPP et d’ajuster l’architecture aux limites de portée et d’énergie. »

Qualité du lien radio et stabilité entre l’Arduino et l’appareil maître

En fonctionnement normal, les performances du HC‑06 se rapprochent de celles d’un HC‑05 en mode esclave, avec une stabilité correcte sur de courtes distances. La robustesse du lien dépend surtout de l’environnement radio et de la gestion des erreurs côté Arduino.

Quelques bonnes pratiques :

• Éviter de placer le module à proximité immédiate de moteurs à balais, relais ou transformateurs de puissance.
• Ajouter une capacité de découplage (100 nF + 10 µF) près du VCC du HC‑06 pour filtrer les variations d’alimentation.
• Prévoir des timeouts et des mécanismes de reconnexion côté application maître lorsque le lien se coupe.
• Mettre en place un format de trame avec sommes de contrôle simples (checksum) lorsqu’une intégrité stricte des données est nécessaire.

Exemple complet : projet Arduino + HC‑06 pour pilotage et retour d’état

Pour rassembler les éléments abordés, voici un squelette de projet qui combine contrôle de sorties et retour de mesures sur un même lien Bluetooth. L’Arduino gère :

• Une LED contrôlée par commande.
• Un capteur analogique, envoyé périodiquement au maître.
• Un protocole texte simple avec préfixes CMD: et DATA:.

#include <SoftwareSerial.h>

SoftwareSerial btSerial(10, 11); // RX, TX

const int LED_PIN = 13;
const int CAPTEUR = A0;

String cmdBuffer = "";
unsigned long dernierEnvoi = 0;
const unsigned long periodeEnvoi = 1000; // 1 s

void setup() {
  pinMode(LED_PIN, OUTPUT);

  Serial.begin(9600);
  btSerial.begin(9600);

  Serial.println("Systeme Arduino + HC-06 pret.");
}

void traiterCommande(const String &cmd) {
  if (cmd == "CMD:LED=ON") {
    digitalWrite(LED_PIN, HIGH);
    btSerial.println("ACK:LED=ON");
  } else if (cmd == "CMD:LED=OFF") {
    digitalWrite(LED_PIN, LOW);
    btSerial.println("ACK:LED=OFF");
  } else {
    btSerial.print("ERR:");
    btSerial.println(cmd);
  }
}

void gererReceptionBluetooth() {
  while (btSerial.available()) {
    char c = btSerial.read();

    if (c == '\n') {
      if (cmdBuffer.length() > 0) {
        traiterCommande(cmdBuffer);
        cmdBuffer = "";
      }
    } else {
      cmdBuffer += c;
    }
  }
}

void envoyerDonnees() {
  unsigned long maintenant = millis();
  if (maintenant - dernierEnvoi >= periodeEnvoi) {
    dernierEnvoi = maintenant;

    int brut = analogRead(CAPTEUR);
    btSerial.print("DATA:SENSOR=");
    btSerial.println(brut);
  }
}

void loop() {
  gererReceptionBluetooth();
  envoyerDonnees();
}

Ce canevas sert de base pour de nombreux projets : domotique, robotique, surveillance de paramètres physiques, intégration dans un environnement électrique protégé par des dispositifs de coupure, etc. Chaque brique (protocole, rythme d’envoi, traitement des commandes) se spécialise ensuite selon le besoin.