Module de conversion TTL / RS485

Le module de conversion TTL / RS485 fait le pont entre un microcontrôleur et un bus RS485 : il traduit le signal série d’un Arduino, d’un ESP ou d’un PIC en signaux différentiels capables de parcourir plusieurs centaines de mètres sur une simple paire torsadée. C’est la carte que l’on retrouve au bout des compteurs d’énergie, des variateurs de fréquence, des capteurs industriels et de tous les appareils qui communiquent en Modbus RTU.

Le module est prêt à l’emploi : transceiver RS485 semi-duplex en boîtier SOIC-8, alimentation en 5 V, bornier à vis pour le bus, peigne de broches des deux côtés, et résistance de terminaison de 120 Ω déjà soudée entre A et B. Quatre fils vers le microcontrôleur, deux fils vers le bus, et la liaison fonctionne.

À quoi sert un module TTL / RS485 ?

Le port série d’un Arduino transmet un signal référencé à sa masse : une seule broche oscille entre 0 V et 5 V, et la moindre perturbation électrique sur le câble peut faire basculer un bit. Le RS485 transmet la même information sous forme de différence entre deux fils, A et B : une perturbation qui atteint les deux fils à la fois s’annule à la réception. C’est ce qui permet d’aller loin sans perdre de données.

• Allonger une liaison série — quelques mètres deviennent plusieurs centaines de mètres.
• Relier plusieurs appareils sur un seul câble — jusqu’à 32 nœuds sur le même bus, en interrogeant chacun à son tour.
• Traverser un atelier électrique — le signal différentiel résiste bien mieux aux moteurs, aux relais et aux variateurs qu’un signal TTL.
• Dialogue avec du matériel industriel — compteurs, sondes, automates et capteurs qui exposent une sortie RS485 ou Modbus RTU.
• Remplacer un câble trop court — c’est la solution quand un capteur série fonctionne près de la carte mais plus du tout au fond du bâtiment.

Caractéristiques techniques

Brochage du module

Deux peignes de quatre broches, un de chaque côté. Tous les noms sont sérigraphiés sur la carte, il suffit de les lire : aucun brochage n’est à deviner.

Côté TTL, vers le microcontrôleur

Côté bus RS485

La règle du semi-duplex : RE et DE se relient ensemble et se pilotent avec une seule broche du microcontrôleur. État haut, le module émet ; état bas, il écoute. Deux appareils qui émettent en même temps se brouillent mutuellement, c’est pourquoi le dialogue RS485 est toujours mené par un maître qui interroge chacun à son tour.

Câblage avec un Arduino

Avec une carte en 3,3 V (ESP32, ESP8266, STM32), l’alimentation reste en 5 V, les entrées DI, RE et DE acceptent sans problème les niveaux 3,3 V, mais la sortie RO monte à 5 V : interposez une résistance de 1 kΩ en série avant l’entrée du microcontrôleur.

Mini-projet : un Arduino qui répond sur le bus RS485

Le montage complet tient sur une plaque d’essai et se termine en un quart d’heure. L’Arduino se met à l’écoute du bus, répond à trois commandes et renvoie la tension lue sur une entrée analogique.

Ce qu’il faut

Pourquoi des fils mâle-femelle ? Les deux peignes du module portent des broches mâles, et les connecteurs de l’Arduino sont des embases femelles : l’extrémité femelle du fil se clipse sur le module, l’extrémité mâle entre dans la carte. Rien à souder.

Le câblage

Le programme

À copier dans l’IDE Arduino, puis à téléverser sur la carte :

/*
 * Module de conversion TTL / RS485 - un Arduino qui repond sur le bus
 * Carte : Arduino Uno R3
 * Montage : module RS485, broche de direction sur D3
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "SoftwareSerial.h"

const byte PIN_RE_DE = 3;    // RE et DE du module, relies ensemble
const byte PIN_RO    = 10;   // RO du module, vers le RX logiciel
const byte PIN_DI    = 11;   // DI du module, depuis le TX logiciel
const byte PIN_LED   = 13;   // la LED deja presente sur la carte
const byte PIN_SONDE = A0;   // entree analogique utilisee comme mesure

SoftwareSerial busRS485(PIN_RO, PIN_DI);

char tampon[40];
byte position = 0;
char message[32];
char chiffres[8];

// Prend la parole, envoie une ligne complete, puis rend la ligne au bus.
void envoyer(const char * texte) {
  digitalWrite(PIN_RE_DE, HIGH);   // on passe en emission
  delay(2);
  busRS485.println(texte);         // println ajoute le retour a la ligne
  busRS485.flush();                // on attend la fin de l'emission
  delay(2);
  digitalWrite(PIN_RE_DE, LOW);    // on repasse en ecoute
}

void repondreMesure() {
  int mesure = analogRead(PIN_SONDE);
  itoa(mesure, chiffres, 10);      // 10 = base decimale
  strcpy(message, "MESURE ");
  strcat(message, chiffres);
  envoyer(message);
}

void traiter(char * commande) {
  if (strcmp(commande, "MESURE") == 0) {
    repondreMesure();
  } else if (strcmp(commande, "LED ON") == 0) {
    digitalWrite(PIN_LED, HIGH);
    envoyer("LED ALLUMEE");
  } else if (strcmp(commande, "LED OFF") == 0) {
    digitalWrite(PIN_LED, LOW);
    envoyer("LED ETEINTE");
  } else {
    envoyer("COMMANDE INCONNUE");
  }
}

void setup() {
  pinMode(PIN_RE_DE, OUTPUT);
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_RE_DE, LOW);    // on ecoute au demarrage
  Serial.begin(9600);
  busRS485.begin(9600);
  busRS485.listen();
  envoyer("ARDUINO PRET");
}

void loop() {
  while (busRS485.available() != 0) {
    char recu = busRS485.read();
    if (recu == 13 || recu == 10) {   // codes ASCII 13 et 10 : fin de ligne
      if (position != 0) {            // une ligne vide ne declenche rien
        tampon[position] = 0;         // on ferme la chaine
        traiter(tampon);
        position = 0;
      }
    } else if (position != 36) {
      tampon[position] = recu;
      position = position + 1;
    }
  }
}

L’essai depuis un PC

Pour parler au bus depuis un ordinateur, il faut un second nœud : un convertisseur USB RS485, dont les bornes A et B rejoignent celles du module. On ouvre ensuite le moniteur série de l’IDE Arduino sur ce port, à 9600 bauds, avec la fin de ligne « Nouvelle ligne ». Tapez MESURE ou LED ON : l’Arduino répond en clair.

Comment ça marche

• digitalWrite(PIN_RE_DE, HIGH) place DE à l’état haut : le transceiver prend la ligne. Il ne faut jamais oublier la ligne suivante, qui repasse à l’état bas — sans quoi le module garde le bus occupé et plus personne ne peut lui répondre.
• Le rôle de tampon[position] = 0 est de terminer la chaîne de caractères reçus : strcmp compare ensuite la commande reçue aux textes attendus.
• La vitesse doit être identique des deux côtés, 9600 bauds ici. Un écart de vitesse ne donne pas une erreur franche, mais des réponses tronquées.
• La résistance de 120 Ω du module est déjà entre A et B. Sur deux modules de part et d’autre d’un câble long, elles terminent correctement le bus ; sur un nœud intermédiaire, elle doit être dessoudée, sinon la charge augmente et le signal s’affaiblit.

Points d’attention

• A et B inversés : c’est de très loin la panne la plus fréquente. Aucun dégât possible, il suffit d’inverser les deux fils. Un module qui reste muet alors que tout le reste est correct a toutes les chances d’avoir ses deux lignes inversées.
• Paire torsadée obligatoire : deux fils séparés annulent l’intérêt du RS485. Deux conducteurs d’une même paire se tiennent par les torsades, c’est ce qui rend le signal insensible au bruit.
• Un seul émetteur à la fois : le RS485 ne tolère pas deux appareils qui parlent ensemble. Avec deux microcontrôleurs, prévoyez un maître et un esclave, ou une consigne d’alternance.
• Une masse commune dès que le câble s’allonge : relier les masses des deux extrémités par un fil ou un blindage évite que la tension de mode commun sorte de la plage admise, de −7 V à +12 V.
• Fin de ligne acceptée des deux façons : le programme découpe les commandes sur le retour chariot (code ASCII 13) comme sur le saut de ligne (code ASCII 10), et ignore les lignes vides. Le réglage de fin de ligne du moniteur série n’a donc pas d’importance, et une trame terminée par les deux caractères ne déclenche qu’une seule réponse.
• Pas d’isolation galvanique : ce module relie électriquement les deux côtés. Entre deux bâtiments ou deux installations sur des tableaux différents, la tension de masse peut être élevée : dans ce cas, il faut une version isolée, pas des précautions de câblage.
• Rien à programmer côté module : la carte ne fait que convertir des niveaux. C’est votre programme qui décide du protocole, du format des trames et de qui parle.

Questions fréquentes

Peut-on brancher plusieurs appareils sur le même câble ?

Oui, jusqu’à 32 emplacements sur un même segment, avec un module par appareil. Le bus ne fonctionne que si un seul appareil émet à la fois : le maître interroge l’un, puis l’autre. Chaque appareil doit avoir une adresse différente, en général fixée par cavalier ou par un petit interrupteur sur l’appareil lui-même.

Est-ce que ce module peut piloter une sortie RS485 d’appareil industriel ?

Oui. Le module est transparent : ce que votre programme envoie sur DI part tel quel sur le bus, et ce qui arrive sur le bus ressort sur RO. Charge à votre programme de respecter le format attendu par l’appareil, par exemple Modbus RTU avec son adresse d’esclave et sa vitesse.

Le module se branche-t-il sur un ESP32 ou une carte 3,3 V ?

Oui, avec deux précautions : alimentez le module en 5 V (la sortie 3V3 ne convient pas) et n’oubliez pas la résistance de 1 kΩ en série sur la sortie RO, qui monte à 5 V. Les entrées DI, DE et RE, elles, acceptent les niveaux 3,3 V.

Quelle vitesse choisir ?

La vitesse dépend de la longueur : 9600 bauds passent sur environ 1 200 m, 115200 bauds sur quelques dizaines de mètres, et les débits élevés ne tiennent que sur câble court. En cas de réponses tronquées ou de caractères parasites, c’est la première chose à baisser — avant de chercher une erreur de programme.

Faut-il retirer la résistance de 120 Ω ?

Sur un bus à deux appareils, on n’y touche pas. Sur une ligne où plusieurs modules sont répartis, seuls les deux modules situés aux extrémités gardent leur résistance ; les modules intermédiaires doivent être chargés avec R7 dessoudée, sous peine d’atténuer le signal.

À combiner avec

Pour câbler proprement un bus qui compte plusieurs départs, un bornier à vis au pas de 5,08 mm sert de réserve ou de point de reprise si le bornier d’origine est abîmé.

Pour un nœud qui doit fonctionner sans Arduino, un bloc d’alimentation 5 V alimente le module seul, à condition de garder les masses communes.

Enfin, pour un montage compact au bout d’une ligne, le Nano avec son câble tient à côté du module dans une petite boîte et joue exactement le même rôle que l’Uno du mini-projet.