Programmer un automate ouvert avec OpenPLC : texte structuré et Modbus

Jusqu’ici, nos « automates » étaient simulés en Python. Il est temps d’en faire tourner un vrai — au sens industriel du terme : un programme qui exécute une logique en boucle, à intervalle garanti, dans les langages normalisés des automaticiens. OpenPLC transforme un simple PC ou un nano-ordinateur en automate programmable, gratuitement et de façon transparente. Dans ce tutoriel, vous allez l’installer, écrire une logique en texte structuré, la déployer, puis lire ses sorties par Modbus — bouclant ainsi avec ce que vous avez appris précédemment.

🎯 Ce que vous allez apprendre

• Installer l’environnement d’exécution OpenPLC et accéder à son interface.
• Comprendre le cycle d’un automate et l’adressage des entrées/sorties.
• Écrire une logique en texte structuré conforme à la norme IEC 61131-3.
• Téléverser, compiler et lancer le programme.
• Lire les sorties de l’automate depuis un client Modbus.

🛠️ Ce que vous allez construire

Un automate qui fait clignoter une sortie toutes les secondes et compte ses propres cycles dans un registre. Une sortie tout-ou-rien qui bascule, un compteur qui s’incrémente : modeste en apparence, mais c’est exactement le genre de logique cyclique temps réel qui pilote convoyeurs, feux et séquences partout dans l’industrie. Et comme OpenPLC expose tout en Modbus, votre superviseur Python du tutoriel précédent pourra lire ces valeurs.

Prérequis

• Une machine Linux (Ubuntu/Debian) ou un Raspberry Pi, avec accès administrateur et Internet.
• Git installé (sudo apt install git).
• Idéalement, avoir suivi le tutoriel Modbus de la série pour lire les sorties à la fin. Test express : si vous savez lancer un script et ouvrir un navigateur, vous êtes prêt.
• ⏱️ Temps estimé : 50 minutes, dont la compilation initiale.

Une note sur les versions

OpenPLC existe en deux générations. La lignée éprouvée, la version 3, embarque une interface web intégrée où l’on téléverse et pilote ses programmes : c’est la plus simple pour apprendre, et celle que nous utilisons ici. Une refonte, la version 4 (2026), réarchitecture l’exécution autour d’une interface applicative distincte. Pour découvrir la programmation d’automate sans friction, la version 3 reste le meilleur point d’entrée ; les concepts (cycle, langages, adressage) sont identiques d’une génération à l’autre.

Étape 1 — Installer OpenPLC

On récupère le code de l’environnement d’exécution et on lance son script d’installation, qui s’occupe de toutes les dépendances. La compilation prend quelques minutes.

git clone https://github.com/thiagoralves/OpenPLC_v3.git
cd OpenPLC_v3
./install.sh linux

Le paramètre linux indique la plateforme cible ; sur un Raspberry Pi, on utilise rpi à la place pour activer la gestion des broches physiques. Le script télécharge les dépendances, compile le cœur de l’automate et met en place un service web. À la fin, sans erreur, l’automate est prêt. Il démarre un serveur web : ouvrez un navigateur sur http://localhost:8080 (ou l’adresse IP de la machine, port 8080, depuis un autre poste).

La première page demande des identifiants : par défaut, l’utilisateur est openplc et le mot de passe openplc. Changez-les dès que possible dans les réglages — un automate aux identifiants par défaut est une porte ouverte.

✅ Point d’étape — Si l’interface web s’affiche et accepte la connexion, l’automate tourne. Le menu de gauche donne accès aux programmes, à la surveillance et aux réglages.

Étape 2 — Comprendre le cycle et l’adressage

Un automate ne s’exécute pas comme un script ordinaire. Il répète, indéfiniment et à intervalle fixe, un cycle en trois temps : lire toutes les entrées, exécuter la logique, écrire toutes les sorties. Ce déterminisme — un tour de boucle toutes les quelques millisecondes, sans dérive — est ce qui rend un automate fiable pour commander une machine.

Les entrées et sorties portent des adresses normalisées. Une sortie tout-ou-rien s’écrit %QX0.0 (Q pour sortie, X pour bit) ; une entrée tout-ou-rien %IX0.0 ; un registre de sortie sur 16 bits %QW0 (W pour mot). Ce qui compte pour la suite : OpenPLC relie ces adresses au monde Modbus. %QX0.0 devient le coil 0, %QW0 devient le holding register 0. C’est ainsi que votre superviseur Python pourra lire ce que fait l’automate.

Étape 3 — Écrire la logique en texte structuré

Le texte structuré (ST) est l’un des cinq langages de la norme IEC 61131-3, proche du Pascal et idéal pour exprimer une logique claire. On va écrire un programme qui fait clignoter une sortie toutes les secondes à l’aide d’un temporisateur, et compte les cycles. Créez un fichier clignotant.st :

PROGRAM principal
  VAR
    t_off : TON;            (* temporisateur pour la phase éteinte *)
    t_on : TON;             (* temporisateur pour la phase allumée *)
    sortie AT %QX0.0 : BOOL;   (* le voyant -> coil Modbus 0 *)
    compteur : INT;
    nb_cycles AT %QW0 : INT;   (* compteur -> holding register 0 *)
  END_VAR

  (* Oscillateur : 1 s éteint, 1 s allumé *)
  t_off(IN := NOT sortie, PT := T#1s);
  t_on(IN := sortie, PT := T#1s);

  IF t_off.Q THEN
    sortie := TRUE;
    compteur := compteur + 1;
    nb_cycles := compteur;
  END_IF;
  IF t_on.Q THEN
    sortie := FALSE;
  END_IF;
END_PROGRAM

CONFIGURATION Config0
  RESOURCE Res0 ON PLC
    TASK Tache0(INTERVAL := T#20ms, PRIORITY := 0);
    PROGRAM Instance0 WITH Tache0 : principal;
  END_RESOURCE
END_CONFIGURATION

Lisons ce programme. On déclare deux temporisateurs TON (temporisateur à l’enclenchement, un bloc standard de la norme), la sortie liée à %QX0.0, et un compteur lié à %QW0. L’astuce de l’oscillateur : t_off compte le temps tant que la sortie est éteinte et la rallume au bout d’une seconde ; t_on fait l’inverse. À chaque rallumage, on incrémente le compteur. Le bloc CONFIGURATION en fin de fichier est obligatoire : il déclare une tâche cyclique de 20 millisecondes qui exécute le programme — c’est lui qui matérialise le fameux cycle de l’automate.

Étape 4 — Téléverser et lancer le programme

Retournez dans l’interface web. Dans le menu Programs, choisissez d’ajouter un programme et téléversez votre fichier clignotant.st. Donnez-lui un nom et une description, puis validez. OpenPLC compile alors le texte structuré en code exécutable — une étape qui peut prendre quelques secondes et dont le journal s’affiche à l’écran. Une compilation réussie se termine par un message de succès, sans ligne d’erreur rouge.

Une fois le programme compilé, allez dans Run et démarrez l’automate. À partir de cet instant, le cycle tourne : la sortie %QX0.0 bascule toutes les secondes et le compteur grimpe. La page Monitoring vous montre l’état des entrées et sorties en direct — vous devez y voir le voyant clignoter et le compteur s’incrémenter.

✅ Point d’étape — Si la page de surveillance montre la sortie qui bascule et le compteur qui monte, votre automate exécute bien sa logique en temps réel. C’est un vrai automate, pas une simulation.

Étape 5 — Activer le serveur Modbus

Pour qu’un client extérieur lise l’automate, son serveur Modbus doit être actif. Dans les réglages (Settings), vérifiez que l’option Modbus Server est activée ; OpenPLC écoute alors les requêtes Modbus TCP sur le port standard 502. Notez l’adresse IP de la machine qui héberge OpenPLC : c’est elle que le client interrogera.

Le serveur Modbus d’OpenPLC expose automatiquement la correspondance vue plus haut : la sortie %QX0.0 est le coil 0, le compteur %QW0 est le holding register 0. Aucune configuration supplémentaire n’est nécessaire — c’est tout l’intérêt d’un automate qui parle nativement un protocole standard.

Étape 6 — Lire l’automate depuis Python

On réutilise pymodbus pour interroger l’automate réel, exactement comme on interrogeait l’automate simulé du tutoriel Modbus. Adaptez l’adresse IP et le port (502 ici). Créez lecture_plc.py :

from pymodbus.client import ModbusTcpClient
import time

client = ModbusTcpClient("127.0.0.1", port=502)  # IP de la machine OpenPLC
client.connect()

for _ in range(10):
    coil = client.read_coils(0, count=1, device_id=1)
    registre = client.read_holding_registers(0, count=1, device_id=1)
    if not coil.isError() and not registre.isError():
        print("Voyant :", coil.bits[0], "| Cycles :", registre.registers[0])
    time.sleep(1)

client.close()

Ce programme lit dix fois, à une seconde d’intervalle, le coil 0 (le voyant) et le holding register 0 (le compteur). Comme l’automate bascule la sortie chaque seconde, vous verrez True et False alterner, tandis que le compteur progresse. Si le port 502 est refusé faute de droits, lancez le script avec les privilèges nécessaires ou configurez OpenPLC sur un port accessible. Vous venez de relier un automate réel à un superviseur logiciel : la boucle de la série se referme.

✅ Point d’étape final — Voir le voyant alterner et le compteur grimper côté Python confirme que l’automate exécute sa logique et la publie en Modbus. Vous tenez la chaîne complète : logique d’automate → Modbus → supervision.

Les cinq langages et le temps de cycle

La norme IEC 61131-3 ne définit pas un mais cinq langages, et OpenPLC les accepte tous. Les connaître aide à choisir le bon outil selon la tâche et l’équipe. Le Ladder (LD) dessine des schémas à contacts qui imitent les circuits électriques à relais : intuitif pour les électrotechniciens, parfait pour la logique tout-ou-rien. Le texte structuré (ST), que nous avons utilisé, ressemble à un langage de programmation classique et brille pour les calculs et les logiques complexes. Le diagramme de blocs fonctionnels (FBD) relie des boîtes par des fils, idéal pour la régulation et le traitement de signal. La liste d’instructions (IL), proche de l’assembleur, est aujourd’hui en déclin. Enfin, le diagramme fonctionnel en séquence (SFC) décrit les procédés par étapes et transitions, excellent pour les séquences de machine. Les cinq compilent vers la même logique d’exécution : le choix est affaire de lisibilité et d’habitude, pas de capacité.

Un paramètre mérite une attention particulière : le temps de cycle, que nous avons fixé à 20 millisecondes dans le bloc de configuration. C’est l’intervalle auquel l’automate répète sa boucle lire-calculer-écrire. Le régler correctement est crucial. Trop long, et l’automate risque de manquer un signal bref — une impulsion d’un capteur qui apparaît et disparaît entre deux cycles passera inaperçue. Trop court, et le processeur peine à terminer la logique avant le cycle suivant, ce qui provoque des dépassements et un comportement erratique. La règle : le temps de cycle doit être nettement plus court que la durée du phénomène le plus rapide à surveiller, tout en laissant à la logique le temps de s’exécuter confortablement. Pour notre clignotant à la seconde, 20 millisecondes offrent une marge très large. Sur une machine réelle qui surveille des fins de course rapides, on descend parfois à quelques millisecondes — et l’on vérifie alors, dans la page de surveillance, que le temps réel d’exécution reste sous la limite fixée.

🐞 Pièges fréquents

✅ Récapitulatif

Vous avez installé un automate logiciel, compris son cycle déterministe et l’adressage de ses entrées/sorties, écrit une logique en texte structuré conforme à la norme, l’avez compilée et lancée, puis lue par Modbus depuis Python. Vous savez maintenant programmer un automate ouvert et l’intégrer à une supervision — la pièce qui manquait entre la théorie des protocoles et un système qui agit vraiment. La passerelle finale reliera cet automate au robot ROS 2.

🧾 Aide-mémoire

💪 À vous de jouer

Remplacez le clignotant par une logique d’arrêt/marche moteur : une entrée %IX0.0 « marche », une entrée %IX0.1 « arrêt », et une sortie %QX0.0 qui reste enclenchée une fois lancée jusqu’à l’arrêt. C’est le circuit d’auto-maintien, fondamental en automatisme. Utilisez la page de surveillance pour forcer les entrées et tester.

Tutoriels frères

• Lire et écrire des registres en Modbus TCP avec Python — la lecture côté client, indispensable ici.
• La passerelle ROS 2 ↔ automate — faire coopérer cet automate avec un robot.

Pour aller plus loin

• 🔝 Retour au guide principal : Robotique industrielle open source
• Documentation du projet OpenPLC et référence des langages IEC 61131-3.

FAQ

OpenPLC convient-il à de la vraie production ?
Pour du prototypage, de l’éducation et des applications non critiques, oui. Pour des fonctions de sécurité des personnes, il faut un automate certifié selon les normes applicables. OpenPLC reste un formidable outil d’apprentissage et un automate logiciel honnête pour les cas non critiques.

Quelle différence entre le texte structuré et le Ladder ?
Ce sont deux des cinq langages de la même norme. Le Ladder imite les schémas électriques à contacts, intuitif pour les électrotechniciens ; le texte structuré ressemble à un langage de programmation classique, plus à l’aise pour les développeurs. Les deux compilent vers la même logique.

Puis-je faire tourner OpenPLC sur un Raspberry Pi ?
Oui, c’est même un usage très courant : un Raspberry Pi avec OpenPLC devient un petit automate à faible coût, capable de piloter des entrées/sorties physiques via ses broches. On utilise alors le paramètre d’installation dédié.

Comment commander l’automate depuis Modbus plutôt que seulement le lire ?
En écrivant dans les coils ou les holding registers mappés sur des variables que votre programme lit. Un client Modbus peut ainsi fournir des consignes que la logique d’automate prend en compte à chaque cycle.