HC-06 Arduino : code Bluetooth esclave complet

Connecter un module HC‑06 à une carte Arduino ouvre rapidement la porte au pilotage sans fil depuis un smartphone ou un PC. Encore faut‑il maîtriser le rôle d’un module Bluetooth esclave, comprendre son câblage précis et écrire un code fiable pour recevoir des commandes série.

Entre les spécifications techniques du HC‑06, les subtilités des commandes AT et les différences avec un HC‑05, de nombreux points restent souvent flous. Les lignes qui suivent posent un cadre clair, avec un code Bluetooth HC‑06 Arduino complet, commenté et prêt à adapter à vos propres projets.

HC‑06 et Arduino : fonctionnement d’un module Bluetooth esclave

Le module HC‑06 est un petit adaptateur Bluetooth série (UART) conçu pour établir un lien sans fil simple entre un microcontrôleur, comme l’Arduino, et un périphérique maître : smartphone, tablette, ordinateur. Dans une architecture classique, le HC‑06 sert uniquement de périphérique esclave, ce qui signifie que le module attend qu’un appareil maître se connecte à lui.

Sur Arduino, le HC‑06 se comporte comme un simple pont série. Les données reçues en Bluetooth arrivent sur la liaison RX/TX du module, puis sont transmises à l’UART de l’Arduino. À l’inverse, tout ce que l’Arduino envoie vers le HC‑06 est diffusé en Bluetooth vers l’appareil connecté. Cette approche reste très efficace pour du pilotage de LED, de moteurs, de capteurs ou pour du retour de mesure en temps réel.

Caractéristiques techniques du HC‑06 utiles pour l’Arduino

Les spécifications du HC‑06 orientent directement les choix de câblage, de débit série et le périmètre d’utilisation. Une bonne compréhension de ces paramètres évite des comportements instables, des déconnexions ou une communication illisible.

Info pratique : aucune évolution officielle majeure du HC‑06 n’est documentée pour 2025. La plupart des modules présents sur le marché reprennent le même comportement, avec quelques variations de firmware sur les commandes AT.

Différences entre HC‑06 et HC‑05 : impact sur le code Arduino

HC‑05 et HC‑06 se ressemblent visuellement et partagent une base matérielle proche, mais leurs rôles dans un système Bluetooth se distinguent nettement. Cette nuance structure la logique de votre code Arduino et la manière d’aborder les commandes AT.

Dans un projet orienté Arduino ↔ smartphone, le HC‑06 remplit parfaitement son rôle : le téléphone agit comme maître, le module reste en esclave et passe tout en série vers l’Arduino. Pour un projet où l’Arduino devrait initier lui‑même la connexion, comme un Arduino maître Bluetooth qui rejoint un autre périphérique, un HC‑05 configuré en mode maître s’impose.

« Sur un projet pédagogique, nous utilisons le HC‑06 pour tout ce qui concerne la communication basique avec Arduino. Les étudiants passent ensuite au HC‑05 quand ils abordent les notions de rôle maître et d’appairage avancé. »

Conseil : pour la majorité des projets de contrôle à distance simples, HC‑06 et application smartphone dédiée suffisent largement. Le HC‑05 trouve davantage sa place dans les architectures plus élaborées, avec réseau de modules ou passerelles Bluetooth.

Câblage du module HC‑06 avec Arduino

La connexion matérielle conditionne la fiabilité de la liaison série. Une erreur de câblage peut bloquer la communication ou, pire, endommager le module. La liaison se réduit à quelques broches, mais chaque pin joue un rôle précis.

Brochage typique du HC‑06

Sur la plupart des cartes breakout HC‑06, on retrouve les broches suivantes :

• VCC : alimentation (3.3 – 6 V selon la carte)
• GND : masse
• TXD : sortie série du module (vers RX de l’Arduino)
• RXD : entrée série du module (depuis TX de l’Arduino)
• Parfois une broche STATE ou EN selon le modèle, pour indiquant l’état ou activer/désactiver le module

Sur certaines versions, une LED signale l’état de connexion : clignotement rapide en attente de connexion, clignotement plus lent ou fixe quand la liaison Bluetooth est établie.

Connexion sur Arduino Uno avec SoftwareSerial

Pour garder le port série matériel (Serial) libre pour le moniteur série, de nombreux montages exploitent la bibliothèque SoftwareSerial. Le HC‑06 se connecte alors sur deux broches numériques libres.

• HC‑06 VCC → Arduino 5 V
• HC‑06 GND → Arduino GND
• HC‑06 TXD → Arduino broche RX logicielle (par exemple D10)
• HC‑06 RXD → Arduino broche TX logicielle (par exemple D11, idéalement via diviseur de tension dans une logique 3,3 V réelle)

De nombreux breakout HC‑06 possèdent déjà un régulateur et un circuit d’adaptation de niveau, ce qui les rend compatibles avec le 5 V en entrée. Une vérification sur la fiche produit reste judicieuse avant de connecter directement le TX 5 V de l’Arduino au RX du module.

Astuce de câblage : en cas de doute sur la tolérance 5 V du RX du HC‑06, un simple pont diviseur avec deux résistances (par exemple 1 kΩ / 2 kΩ) sur la ligne TX de l’Arduino réduit la tension vers un niveau proche de 3,3 V.

Configuration du HC‑06 : commandes AT essentielles

Le HC‑06 propose un jeu de commandes AT plus restreint que le HC‑05, mais largement suffisant pour configurer le nom Bluetooth, le mot de passe PIN et la vitesse série. L’envoi de ces commandes s’effectue par la liaison série, soit via un adaptateur USB‑série, soit directement depuis l’Arduino avec un sketch de passerelle.

Mode AT du HC‑06

Selon les versions de HC‑06, le passage en mode AT se fait :

• soit en alimentant le module sans connexion Bluetooth active puis en envoyant les commandes AT à la vitesse par défaut (souvent 9600 bps ou 38400 bps),
• soit en maintenant un bouton ou une broche clé au moment de l’alimentation, selon le modèle.

En mode AT, le module ne transmet plus les données vers le Bluetooth, mais interprète les textes reçus comme des commandes de configuration. Les réponses reviennent sur la même liaison série.

Commandes AT fréquentes sur HC‑06

Voici un aperçu des commandes AT couramment utilisables avec un HC‑06 classique (les variantes exactes dépendent parfois du firmware) :

Le comportement exact dépend de la version de module. Un test via un convertisseur USB‑série permet de valider les réponses et d’ajuster les commandes.

Code Arduino complet : HC‑06 en Bluetooth esclave au format texte

Passons à un exemple de code complet pour Arduino qui gère un HC‑06 en mode esclave. Ce programme :

• utilise SoftwareSerial pour libérer Serial pour le moniteur série,
• reçoit des commandes en texte depuis le smartphone,
• interprète des mots‑clés pour piloter une LED et renvoyer des réponses.

#include <SoftwareSerial.h>

// Broches pour le HC-06
const byte BT_RX = 10; // Arduino reçoit sur 10 (branché au TX du HC-06)
const byte BT_TX = 11; // Arduino envoie sur 11 (branché au RX du HC-06)

SoftwareSerial BTSerial(BT_RX, BT_TX); // RX, TX

const byte LED_PIN = 13; // LED de contrôle

String inputBuffer = "";        // Buffer pour enregistrer les caractères reçus
bool commandReady = false;       // Indique qu'une commande complète est prête

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

  // Moniteur série pour le debug
  Serial.begin(9600);
  while (!Serial) {
    ; // Attente éventuelle sur certaines cartes
  }

  Serial.println("Initialisation...");

  // Liaison avec le HC-06 (par défaut 9600 bps)
  BTSerial.begin(9600);
  Serial.println("HC-06 prêt en esclave. En attente de connexion...");
}

void loop() {
  // 1) Lecture des données Bluetooth
  readBluetooth();

  // 2) Traitement des commandes complètes
  if (commandReady) {
    processCommand(inputBuffer);
    inputBuffer = "";      // Réinitialisation du buffer
    commandReady = false;   // Prêt pour la prochaine commande
  }
}

// Lecture des caractères issus du HC-06
void readBluetooth() {
  while (BTSerial.available() > 0) {
    char c = BTSerial.read();

    // Fin de commande sur retour chariot ou saut de ligne
    if (c == '\n' || c == '\r') {
      if (inputBuffer.length() > 0) {
        commandReady = true;
      }
    } else {
      inputBuffer += c; // Ajout du caractère au buffer
    }
  }
}

// Interprétation d'une commande texte
void processCommand(String cmd) {
  // Nettoyage des espaces superflus
  cmd.trim();

  // Pour une comparaison insensible à la casse
  String upperCmd = cmd;
  upperCmd.toUpperCase();

  Serial.print("Commande reçue : ");
  Serial.println(upperCmd);

  if (upperCmd == "LED_ON") {
    digitalWrite(LED_PIN, HIGH);
    sendResponse("LED allumee");
  }
  else if (upperCmd == "LED_OFF") {
    digitalWrite(LED_PIN, LOW);
    sendResponse("LED eteinte");
  }
  else if (upperCmd == "LED_TOGGLE") {
    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
    sendResponse("LED basculee");
  }
  else if (upperCmd == "STATUS") {
    String state = digitalRead(LED_PIN) ? "ON" : "OFF";
    sendResponse("Etat LED : " + state);
  }
  else {
    sendResponse("Commande inconnue : " + cmd);
  }
}

// Envoi d'un message vers le smartphone et le moniteur série
void sendResponse(const String &message) {
  BTSerial.println(message);
  Serial.print("> ");
  Serial.println(message);
}

Ce code gère des commandes terminées par un retour chariot ou un saut de ligne. Côté application Bluetooth (terminal série ou application maison), il suffit d’envoyer des commandes telles que LED_ON, LED_OFF, LED_TOGGLE ou STATUS suivies d’un appui sur Entrée.

Remarque : la gestion sous forme de lignes complètes simplifie considérablement le débogage et évite les interprétations partielles de commandes. L’Arduino réagit uniquement quand une ligne se termine, ce qui stabilise l’échange.

Gestion avancée : format binaire, trames structurées et accusés de réception

Pour des projets plus complexes, la simple commande texte ne suffit plus. Lorsqu’un Arduino pilote plusieurs actionneurs ou renvoie des mesures régulières, une structure de trame plus rigoureuse améliore la robustesse de la communication Bluetooth.

Trame simple avec préfixe et checksum

Une trame structurée inclut typiquement :

• un préfixe de début de trame (par exemple <),
• des octets de commande (identifiant, valeur, paramètre),
• un checksum ou somme de contrôle,
• un marqueur de fin de trame (par exemple >).

Ce schéma réduit les risques d’interprétation erronée en présence de perturbations et facilite la synchronisation si l’Arduino commence à écouter en milieu de flux.

Accusés de réception et fiabilité

Dans un environnement bruyant ou lorsque les commandes engagent un mouvement physique (robot, servo, relais de puissance), un accusé de réception confirmant l’exécution de la commande augmente la sécurité. Le principe : chaque commande se voit associer un identifiant, et l’Arduino renvoie un message contenant cet identifiant une fois l’action complétée.

« Sur un mini‑robot Bluetooth, nous avons mis en place un simple code d’accusé de réception basé sur un identifiant incrémental. Les pertes de trame se détectent immédiatement, et l’application smartphone relance uniquement la commande manquante. »

Intégration avec une application smartphone pour le HC‑06

Le module HC‑06 s’accorde particulièrement bien avec une application smartphone. L’appairage se fait via le Bluetooth classique du téléphone, puis l’application se connecte au port série virtuel du module. Selon le niveau d’exigence du projet, plusieurs approches existent.

Applications terminal série prêtes à l’emploi

De nombreuses applications Android de type « Bluetooth Terminal » permettent d’envoyer et de recevoir des données vers un HC‑06 sans développement spécifique. Elles se révèlent très utiles pour :

• tester rapidement le câblage du module,
• déboguer la logique série de l’Arduino,
• simuler des commandes avant de développer une interface graphique personnalisée.

Le principe reste simple : on sélectionne le HC‑06 dans la liste des périphériques appairés, on ouvre une console, puis on tape du texte qui part vers l’Arduino. Les réponses s’affichent en retour.

Applications dédiées et interface personnalisée

Pour un produit fini ou un projet pédagogique avancé, une application Android personnalisée permet de proposer des boutons, sliders, champs de texte adaptés aux commandes du HC‑06. Des bibliothèques facilitent l’accès au port série Bluetooth du téléphone.

Une vue d’ensemble sur la conception d’une telle interface figure dans la logique générale des projets Arduino pilotés par application mobile. Le module HC‑06 reste vu comme un port série distant, la logique métier se concentre dans l’Arduino.

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

Conseil UX : aligner strictement les libellés des boutons de l’application avec les commandes attendues par l’Arduino (LED_ON, LED_OFF, etc.) simplifie considérablement le débogage et la maintenance du projet.

Gestion de l’énergie et stabilité de la liaison HC‑06

La consommation du HC‑06 se situe autour de 40 à 50 mA en fonctionnement. Associé à une carte Arduino, un ensemble alimenté sur batterie doit tenir compte de ce courant pour estimer en amont l’autonomie.

Réduction de la consommation

Plusieurs pistes existent pour limiter l’impact du HC‑06 sur l’énergie :

• désactiver le module via une broche de contrôle (EN) lorsque la communication n’est pas nécessaire,
• mettre l’Arduino lui‑même en veille entre deux échanges,
• réduire la fréquence des transmissions de données périodiques.

La documentation du breakout utilisé précise parfois des modes « low power » intégrés au module. En leur absence, un simple transistor MOSFET commandé par l’Arduino peut couper complètement l’alimentation du HC‑06 en dehors des phases de communication.

Stabilité et environnement radio

La portée typique de 10 m mentionnée pour un HC‑06 découle de conditions dégagées en intérieur. Dans un environnement réel, des murs porteurs, des structures métalliques ou des interférences Wi‑Fi influencent fortement la qualité de la liaison. La position physique du module, la proximité d’alimentations à découpage ou de moteurs électriques jouent également un rôle.

Pour un robot ou un prototype embarqué, placer le HC‑06 à l’écart des moteurs, des régulateurs à découpage et des faisceaux de puissance augmente la fiabilité. Une alimentation propre, avec condensateurs de découplage près du module, limite les resets intempestifs liés aux chutes de tension.

Debug efficace : moniteur série, logs et tests croisés

Un projet Bluetooth entre HC‑06 et Arduino se débogue surtout au niveau série. Sans stratégie claire, le diagnostic devient vite confus. Une méthode structurée facilite la compréhension de chaque étape de l’échange de données.

Utilisation simultanée du moniteur série et du Bluetooth

Dans le code exemple, le moniteur série USB affiche toutes les commandes reçues et les réponses envoyées au HC‑06. Ce double affichage joue un rôle de traceur. Dès le moindre problème, une vérification se fait d’abord sur la console :

• la commande envoyée par le smartphone apparaît‑elle correctement dans le moniteur série ?
• la réponse générée par l’Arduino correspond‑elle à l’action attendue ?

Cette méthode permet de distinguer rapidement un problème côté application mobile d’un problème côté Arduino ou fichier source.

Tests croisés avec adaptateur USB‑série

Un adaptateur USB‑série externe relié directement au HC‑06 fournit un test indépendant de l’Arduino. On s’assure ainsi que les commandes AT sont bien acceptées, que le débit série correspond et que le module fonctionne correctement en amont de l’intégration au sketch.

« En atelier, nous vérifions systématiquement chaque HC‑06 avec un simple dongle USB‑série avant intégration. Cette étape sort le module du doute et évite d’accuser le code Arduino lorsqu’un module défectueux perturbe les essais. »

Limites du HC‑06 et pistes d’évolution

Le HC‑06 s’adresse en priorité aux projets de communication série basiques, stable dans ce rôle, mais limité par conception lorsqu’on vise des architectures Bluetooth plus avancées. Plusieurs points méritent une mise en perspective avant d’engager un projet long terme.

Limitations fonctionnelles du HC‑06

Les contraintes principales du HC‑06 en environnement Arduino :

• mode esclave uniquement : aucune capacité à initier une connexion vers un autre périphérique,
• jeu de commandes AT restreint : configuration plus limitée que sur un HC‑05,
• support de Bluetooth 2.0 uniquement : pas d’intégration native aux fonctionnalités avancées des versions récentes de Bluetooth Low Energy.

Pour une simple liaison console entre Arduino et smartphone, ces points restent sans conséquence. Pour un projet nécessitant réseau de capteurs, gestion de plusieurs esclaves ou intégration plus serrée avec des applications mobiles modernes, d’autres modules Bluetooth méritent un examen.

Alternatives et modules complémentaires

Outre le passage vers un HC‑05 configuré en maître ou esclave, d’autres familles de modules orientées BLE ou Wi‑Fi existent. Elles offrent généralement :

• des piles réseau plus riches (GATT, notifications, services personnalisés),
• une consommation réduite dans certains cas,
• une meilleure compatibilité avec les systèmes mobiles récents.

Le HC‑06 garde toutefois une place solide pour aborder la communication série sans fil avec Arduino, illustrer les notions de protocole, de trame et d’interface maître‑esclave, puis servir de base à des projets pédagogiques ou de prototypage rapide, avec un code Bluetooth esclave simple à lire et à maintenir.