Python - Bibliotheques

Bibliothèques Python indispensables : calcul, données, API, fichiers, automatisation

Liste des bibliothèques Python essentielles à installer avec pip

INSTALLATION

pip install --upgrade pip        # MAJ de l'installateur pip
pip install nom_bibliotheque
pip install nom1 nom2 nom3        # plusieurs a la fois
pip install nom==1.2.3            # version precise
pip install --upgrade nom         # mettre a jour
pip uninstall nom                 # desinstaller
pip list                          # lister les bibliotheques installees

📊

CALCUL & DONNEES

numpy — Bibliothèque Python pour le calcul numérique, tableaux multidimensionnels et opérations vectorisées. Base du data science.
pandas — Analyse et manipulation de données tabulaires : DataFrame, import CSV/Excel, filtrage, nettoyage et transformation.
matplotlib — Création de graphiques, courbes, histogrammes et visualisations scientifiques en Python.

🔌

COMMUNICATION INDUSTRIELLE

pyserial — Communication série RS232/RS485 en Python. Idéal pour l’industrie et les microcontrôleurs.
pymodbus — Implémentation du protocole Modbus RTU/TCP pour communiquer avec des automates industriels.
asyncua — Client et serveur OPC-UA en Python pour SCADA, automates modernes et IoT industriel.

🖼️

INTERFACES GRAPHIQUES

tkinter — Bibliothèque graphique native Python pour créer des interfaces simples et rapides.
PyQt5 / PySide6 — Frameworks professionnels pour interfaces graphiques avancées, widgets complexes et applications desktop.

🌐

WEB & API

requests — Bibliothèque HTTP simple et puissante pour consommer des API REST.
flask — Micro-framework Python pour créer des API, serveurs web et applications légères.

📁

FICHIERS & FORMATS

openpyxl — Lecture et écriture de fichiers Excel (.xlsx) en Python. Manipulation de feuilles, cellules et formules.
PyPDF2 — Manipulation de fichiers PDF : lecture, extraction, fusion, rotation et écriture.

⚙️

SYSTEME & AUTOMATISATION

schedule — Planification de tâches récurrentes en Python : exécuter des scripts à intervalles réguliers.
pywin32 — Interaction avancée avec Windows : registre, COM, Excel, services, automatisation système.

✅

QUALITE / TESTS

pytest — Framework de tests unitaires Python : assertions, fixtures, tests paramétrés et rapports.

Python - Syntaxe

Syntaxe Python : Guide complet pour débutants (conditions, boucles, fonctions, listes, dictionnaires)

Apprendre la syntaxe Python : bases essentielles, exemples simples et rappels rapides

🔀

CONDITIONS

Conditions — Syntaxe des conditions Python : if, elif, else, et structure match-case pour gérer plusieurs scénarios. Idéal pour contrôler le flux d’exécution.

if condition:
    ...
elif autre:
    ...
else:
    ...

match valeur:
    case 1: ...
    case _: ... # équivalent du else

🔁

BOUCLES

Boucles — Boucles Python avec for et while, utilisation de range(), contrôle du flux avec break et continue. Indispensable pour l’itération.

for i in range(5):   # range(debut, fin, pas) -> 'fin' exclu
    print(i)

while condition:
    ...
    break
    continue

🧩

FONCTIONS

Fonctions — Définition de fonctions Python, paramètres par défaut, *args, **kwargs, et lambdas. Base de la programmation modulaire.

def ma_fonction(a, b=10):
    return a + b

resultat = ma_fonction(3)

carre = lambda x: x**2

📋

LISTES

Listes — Manipulation des listes Python : append, slicing, indexation, et list comprehension pour créer des listes en une ligne.

liste = [1, 2, 3]
liste.append(4)
liste[0]      # 1er element
liste[-1]     # dernier
liste[1:3]    # slicing

carres = [x**2 for x in range(5)]

🗃️

DICTIONNAIRES

Dictionnaires — Utilisation des dictionnaires Python : accès aux clés, ajout de valeurs, parcours avec items(), keys(), values(). Structure clé-valeur essentielle.

d = {"cle": "valeur", "age": 25}
d["cle"]
d["nouvelle_cle"] = 1

for cle, valeur in d.items():
    print(cle, valeur)

🔤

CHAINES DE CARACTERES

Chaines de caracteres — Manipulation des chaînes Python : f-strings, strip, split, upper, lower. Idéal pour le traitement de texte.

nom = "Alice"
msg = f"Bonjour {nom} !"

texte.strip()
texte.split(",")
texte.upper()
texte.lower()

💬

ENTREES / SORTIES

Entrees / sorties — Entrées et sorties Python : print(), input(), conversion de types. Interaction utilisateur simple.

print("Resultat :", valeur)

age = input("Ton age : ")
age = int(age)

print(f"Tu as {age} ans")

🛡️

GESTION D'ERREURS

Gestion d'erreurs — Gestion des erreurs Python avec try, except, else, finally. Capture des exceptions courantes et sécurisation du code.

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Erreur !")
else:
    print("OK")
finally:
    print("Fin")

📁

FICHIERS

Fichiers — Lecture et écriture de fichiers en Python avec open() et le mot-clé with. Manipulation de fichiers texte.

with open("data.txt", "r") as f:
    contenu = f.read()

with open("out.txt", "w") as f:
    f.write("Bonjour")

    # 'with' ferme le fichier automatiquement

🏛️

CLASSES (POO)

Classes (poo) — Bases de la programmation orientée objet en Python : classes, méthodes, constructeur __init__, attributs et instanciation.

class Chien:
    def __init__(self, nom):
        self.nom = nom    # self = reference a l'objet courant

    def aboyer(self):
        print(f"{self.nom} : Wouf")

rex = Chien("Rex")

➗

OPERATEURS & COMPARAISONS

Operateurs & comparaisons — Opérateurs Python : comparaisons, logique booléenne, appartenance, identité, et opérateurs d’affectation.

==   !=   <   >   <=   >=
and   or   not
in    is

x += 1      # x = x + 1
x -= 1      # x = x - 1

# '==' compare les valeurs, 'is' compare l'identite

📦

IMPORT / MODULES

Import / modules — Importation de modules Python : import, from import, alias avec as. Organisation du code et utilisation de bibliothèques.

import math
from math import sqrt
import numpy as np  # 'as' -> renomme le module importe

math.sqrt(16)
sqrt(16)

Linux - Commandes SSH

Commandes SSH & Linux essentielles : guide complet pour debutant sur Raspberry Pi

Connexion SSH, fichiers, paquets, reseau, services et outils specifiques Raspberry Pi

🔑

CONNEXION SSH

Se connecter au Raspberry Pi — Premiere connexion a distance depuis un PC : par adresse IP ou par nom reseau (mDNS). Necessite que le SSH soit active sur le Raspberry Pi.

ssh pi@192.168.1.50          # connexion (utilisateur@IP)
ssh pi@raspberrypi.local     # connexion via le nom reseau (mDNS)
passwd                       # changer le mot de passe de l'utilisateur courant
exit                         # fermer la session SSH

Premiers reflexes apres connexion — L'outil officiel raspi-config regroupe la quasi-totalite des reglages utiles (wifi, SSH, camera, langue, nom de la machine...).

sudo raspi-config                     # outil de configuration officiel du Raspberry Pi
sudo hostnamectl set-hostname mapi    # changer le nom de la machine sur le reseau
sudo reboot                           # redemarrer pour appliquer certains changements

📁

NAVIGATION & FICHIERS

Se deplacer et lister — Les commandes de base pour explorer l'arborescence des fichiers, indispensables des les premieres minutes.

pwd            # afficher le dossier courant
ls -la         # lister (y compris fichiers caches, avec details)
cd /home/pi    # se deplacer dans un dossier
cd ..          # remonter d'un niveau
cd ~           # revenir au dossier personnel

Manipuler fichiers et dossiers — Creer, copier, deplacer ou supprimer : les memes actions qu'un explorateur de fichiers graphique, en ligne de commande.

mkdir mon_dossier          # creer un dossier
touch fichier.txt          # creer un fichier vide
cp source.txt copie.txt    # copier un fichier
mv ancien.txt nouveau.txt  # renommer / deplacer
rm fichier.txt             # supprimer un fichier
rm -r mon_dossier          # supprimer un dossier (recursif)

📦

GESTION DES PAQUETS (APT)

Installer et mettre a jour des logiciels — APT est le gestionnaire de paquets de Raspberry Pi OS (base Debian). 'update' rafraichit la liste, 'upgrade' installe les mises a jour.

sudo apt update                     # rafraichir la liste des paquets disponibles
sudo apt upgrade -y                 # mettre a jour tous les paquets installes
sudo apt install nom_du_logiciel    # installer un logiciel
sudo apt remove nom_du_logiciel     # desinstaller un logiciel
sudo apt autoremove                 # nettoyer les paquets devenus inutiles

🔒

DROITS & PERMISSIONS

Comprendre et modifier les droits — Chaque fichier a un proprietaire, un groupe et des droits (lecture/ecriture/execution). 'sudo' execute une commande avec les droits administrateur.

ls -l                # afficher les droits (rwxrwxrwx)
chmod +x script.sh   # rendre un fichier executable
chmod 755 fichier    # droits precis (proprietaire/groupe/autres)
chown pi:pi fichier  # changer le proprietaire et le groupe
sudo commande        # executer une commande avec les droits administrateur

📝

EDITER DES FICHIERS

Editeurs en ligne de commande — nano est l'editeur le plus simple pour debuter (les raccourcis sont affiches en bas de l'ecran). cat et less servent juste a lire un fichier.

nano fichier.txt        # editeur simple (Ctrl+O sauver, Ctrl+X quitter)
cat fichier.txt         # afficher tout le contenu d'un fichier
less fichier.txt        # lire un fichier long page par page (q pour quitter)
sudo nano /etc/hostname # exemple : editer un fichier systeme

🌐

RESEAU

Diagnostiquer et configurer le reseau — Verifier son adresse IP et sa connexion internet, ou configurer le wifi via raspi-config.

hostname -I       # afficher l'adresse IP du Raspberry Pi
ip a              # detail complet des interfaces reseau
ping google.com   # tester la connexion internet (Ctrl+C pour arreter)
sudo raspi-config # menu 'System Options > Wireless LAN' pour le wifi

⚙️

SERVICES & PROCESSUS

Gerer les services (systemd) — Un service est un programme qui tourne en arriere-plan (ex: serveur web). 'enable' le fait demarrer automatiquement a chaque boot.

sudo systemctl status nom_service  # voir l'etat d'un service
sudo systemctl start nom_service   # demarrer un service
sudo systemctl stop nom_service    # arreter un service
sudo systemctl enable nom_service  # demarrer automatiquement au demarrage

Voir et arreter des processus — Utile quand un programme est bloque ou consomme trop de ressources.

ps aux      # lister tous les processus en cours
top         # suivre l'activite en temps reel (q pour quitter)
kill 1234   # arreter le processus d'identifiant (PID) 1234

🍓

RASPBERRY PI SPECIFIQUE

Outils propres au Raspberry Pi — vcgencmd donne des infos materielles (temperature, alimentation). raspi-config active les interfaces (camera, I2C, SPI, SSH...).

vcgencmd measure_temp    # afficher la temperature du processeur
vcgencmd get_throttled   # detecter les soucis d'alimentation / surchauffe
sudo raspi-config        # activer camera, GPIO, I2C, SPI, SSH...
sudo shutdown -h now     # eteindre proprement le Raspberry Pi
sudo reboot              # redemarrer le Raspberry Pi

📤

TRANSFERT DE FICHIERS

Copier des fichiers vers/depuis le Raspberry Pi (scp) — scp fonctionne comme cp, mais a travers le reseau via SSH. A executer depuis le PC (pas depuis le Raspberry Pi) dans la plupart des cas.

scp fichier.txt pi@192.168.1.50:/home/pi/    # envoyer un fichier vers le Pi
scp pi@192.168.1.50:/home/pi/fichier.txt .   # recuperer un fichier depuis le Pi
scp -r mon_dossier pi@192.168.1.50:/home/pi/ # copier un dossier entier

🗄️

PARTAGE DE FICHIERS (NFS)

Configurer le Raspberry Pi comme serveur NFS — Le Raspberry Pi expose un dossier sur le reseau. /etc/exports definit qui a le droit d'y acceder et avec quels droits.

sudo apt install nfs-kernel-server -y      # installer le serveur NFS
sudo mkdir -p /srv/nfs/partage             # creer le dossier a partager
sudo chown nobody:nogroup /srv/nfs/partage # droits d'acces pour les clients distants

sudo nano /etc/exports                     # ouvrir le fichier de configuration des partages
# ajouter une ligne, par exemple :
# /srv/nfs/partage  192.168.1.0/24(rw,sync,no_subtree_check)

sudo exportfs -ra                          # appliquer la configuration sans redemarrer
sudo systemctl restart nfs-kernel-server   # redemarrer le service NFS

Monter le partage depuis un autre appareil (client) — A executer sur la machine Linux qui doit acceder au dossier partage par le Raspberry Pi (un PC, un autre Pi...).

sudo apt install nfs-common -y                          # installer le client NFS
sudo mkdir -p /mnt/partage_pi                          # creer le point de montage local
sudo mount 192.168.1.50:/srv/nfs/partage /mnt/partage_pi  # monter le partage (IP du Pi)

ls /mnt/partage_pi                                     # verifier que les fichiers sont visibles

Verifier, rendre permanent et demonter — Le montage manuel disparait au redemarrage : ajouter une ligne dans /etc/fstab pour le rendre automatique.

showmount -e 192.168.1.50     # lister les partages disponibles sur le Raspberry Pi
df -h                          # verifier que le partage est bien monte
sudo umount /mnt/partage_pi    # demonter le partage

sudo nano /etc/fstab           # pour un montage automatique au demarrage, ajouter :
# 192.168.1.50:/srv/nfs/partage  /mnt/partage_pi  nfs  defaults  0  0

📊

SURVEILLANCE SYSTEME

Verifier l'etat du systeme — A verifier regulierement sur une carte SD : l'espace disque et la memoire disponible sont souvent limites sur un Raspberry Pi.

df -h              # espace disque disponible par partition
du -sh mon_dossier # taille d'un dossier
free -h            # memoire RAM utilisee / disponible
uptime             # depuis combien de temps le systeme tourne

Codesys - Syntaxe

Syntaxe Codesys Structured Text : guide complet IEC 61131‑3 (conditions, boucles, fonctions, types)

IEC 61131‑3 – Structured Text (ST) : syntaxe essentielle pour automates industriels

🔀

CONDITIONS

Conditions — Syntaxe des conditions en Structured Text : IF, ELSIF, ELSE et structure CASE pour gérer plusieurs scénarios. Chaque instruction se termine par un point‑virgule, conformément à IEC 61131‑3.

IF condition THEN
    ...;
ELSIF autre_condition THEN
    ...;
ELSE
    ...;
END_IF
 
CASE valeur OF
    1: ...;
    2, 3: ...;
    4..10: ...;
END_CASE
 
// ELSIF (un seul mot) ; chaque instruction se termine par ;

🔁

BOUCLES

Boucles — Boucles en Structured Text : FOR, WHILE et REPEAT…UNTIL. Utilisation de EXIT pour quitter la boucle et CONTINUE pour passer à l’itération suivante. Indispensable pour l’itération en automate.

FOR i := 0 TO 9 DO
    ...;
END_FOR

WHILE condition DO
    ...;
END_WHILE

REPEAT
    ...;
UNTIL condition
END_REPEAT

// EXIT; sort de la boucle ; CONTINUE; passe a l'iteration suivante

🧩

FONCTIONS & FUNCTION_BLOCK

Fonctions & function_block — Les FUNCTION retournent une valeur sans mémoire interne. Les FUNCTION_BLOCK possèdent un état conservé entre les cycles, idéal pour modéliser des objets (moteur, vanne, capteur).

FUNCTION Addition : INT  // FUNCTION renvoie une valeur
VAR_INPUT a, b : INT; END_VAR
    Addition := a + b;
END_FUNCTION

FUNCTION_BLOCK FB_Moteur  //FUNCTION_BLOCK garde un etat entre les cycles
VAR_INPUT Marche : BOOL; END_VAR
VAR_OUTPUT EnMarche : BOOL; END_VAR

📦

VARIABLES & TYPES

Variables & types — Déclaration des variables IEC 61131‑3 : VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT, VAR_GLOBAL, CONSTANT. Gestion des types de base (BOOL, INT, REAL, STRING) et initialisation des valeurs.

VAR
    temperature : REAL := 20.0;
    compteur    : INT := 0;
    actif       : BOOL := FALSE;
    nom         : STRING := 'Moteur1';
END_VAR

Types de variables (VAR) — Résumé des différents types de déclarations VAR en IEC 61131‑3 / Codesys : VAR, VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT, VAR_GLOBAL, VAR_TEMP, VAR_INST, CONSTANT, RETAIN et PERSISTENT.

// VAR : variables locales du POU, conservées entre les cycles
VAR
    xLocal : BOOL := FALSE;
END_VAR

// VAR_INPUT : paramètres d'entrée (lecture seule dans le FB)
VAR_INPUT
    rSetPoint : REAL;
END_VAR

// VAR_OUTPUT : paramètres de sortie (écriture dans le FB)
VAR_OUTPUT
    xReady : BOOL;
END_VAR

// VAR_IN_OUT : passage par référence (alias vers une variable externe)
VAR_IN_OUT
    stStatus : ST_Status;
END_VAR

// VAR_GLOBAL : variables globales (définies dans un GVL)
VAR_GLOBAL
    g_xEmergencyStop : BOOL;
END_VAR

// VAR_TEMP : variables temporaires (stack), non conservées entre les cycles
VAR_TEMP
    iCounterTemp : INT;
END_VAR

// CONSTANT : valeur fixe non modifiable
VAR CONSTANT
    c_rPi : REAL := 3.14159;
END_VAR

// RETAIN : variable conservée après redémarrage de l'automate
VAR RETAIN
    rTotalProduction : REAL;
END_VAR

// PERSISTENT : conservée même après téléchargement du programme
VAR PERSISTENT
    uiBootCounter : UINT;
END_VAR

// VAR_GENERIC : variable typée dynamiquement (polymorphisme de type)
// Permet d@@STR0@@importe quel type compatible
VAR_GENERIC
    AnyValue : ANY;
END_VAR

// Disponible uniquement dans la déclaration des Méthodes
METHOD MyMethod
    // VAR_STAT : variable statique dans une méthode
    // Conserve sa valeur entre les appels de la méthode
    VAR_STAT
        iStaticCounter : INT := 0;
    END_VAR

    // VAR_INST : variables d@@STR0@@un FB (mémoire interne)
    // (Déclarées implicitement dans un FUNCTION_BLOCK)
    VAR_INST
        iStaticCounter2 : INT := 0;
    END_VAR

        iStaticCounter := iStaticCounter + 1;
END_METHOD

🗂️

TABLEAUX (ARRAY)

Tableaux (array) — Déclaration de tableaux en IEC 61131‑3 : les bornes sont fixées à la création. Accès par index et parcours avec une boucle FOR pour manipuler des collections de données.

VAR
    valeurs : ARRAY[0..9] OF INT;
END_VAR

valeurs[0] := 100;
FOR i := 0 TO 9 DO
    valeurs[i] := i * 2;
END_FOR

🏗️

STRUCTURES (STRUCT)

Structures (struct) — Définition de structures utilisateur (STRUCT) pour regrouper plusieurs champs. Accès aux éléments via la notation point : variable.champ. Idéal pour organiser des données complexes.

TYPE ST_Moteur :
STRUCT
    Vitesse : REAL;
    Marche  : BOOL;
END_STRUCT
END_TYPE

moteur1.Vitesse := 50.0;

🔤

CHAINES DE CARACTERES

Chaines de caracteres — Manipulation des chaînes en Codesys : nécessite la bibliothèque standard String. Fonctions courantes : CONCAT, LEN, FIND, MID pour concaténer, mesurer, rechercher et extraire des sous‑chaînes.

txt : STRING := 'Bonjour';

CONCAT(txt, ' Monde');
LEN(txt);            // longueur
FIND(txt, 'jour');   // position
MID(txt, 3, 2);      // sous-chaine

⏱️

TEMPORISATEURS / COMPTEURS

Temporisateurs / compteurs — Temporisateurs IEC : TON (retard à l’enclenchement), TOF (retard au déclenchement), TP (impulsion). Compteurs CTU, CTD, CTUD pour incrémenter, décrémenter ou combiner les deux.

VAR
    Tempo : TON;
    Cpt   : CTU;
END_VAR

Tempo(IN := Marche, PT := T#5s);
IF Tempo.Q THEN
    ...;
END_IF

🛡️

GESTION DES ERREURS

Gestion des erreurs — Gestion des erreurs avec l’extension CODESYS __TRY / __CATCH / __FINALLY. Non standard IEC 61131‑3, mais utile pour capturer des exceptions et sécuriser l’exécution.

__TRY
    resultat := 10 / diviseur;
__CATCH(exc)
    Erreur := TRUE;
__FINALLY
    Termine := TRUE;
__ENDTRY

⚙️

PROGRAMMATION ORIENTEE OBJET (POO)

Programmation orientee objet (poo) — POO en Codesys : EXTENDS pour l’héritage, INTERFACE pour définir un contrat, méthodes pour encapsuler le comportement. Les FB jouent le rôle de classes avec état interne.

FUNCTION_BLOCK FB_Vehicule
VAR PUBLIC vitesse : REAL; END_VAR
METHOD Accelerer
    vitesse := vitesse + 10;
END_METHOD

FUNCTION_BLOCK FB_Voiture EXTENDS FB_Vehicule

➗

OPERATEURS & COMPARAISONS

Operateurs & comparaisons — Opérateurs en Structured Text : := pour l’assignation, = pour la comparaison, opérateurs logiques (AND, OR, NOT, XOR) et MOD pour le modulo. Syntaxe essentielle pour la logique automate.

:=    assignation      =   comparaison
<>   <   >   <=   >=
AND   OR   NOT   XOR
MOD   (modulo)

compteur := compteur + 1;

🏛️

STRUCTURE D'UN PROGRAMME (POUs)

Structure d'un programme (pous) — Structure d’un programme IEC : PROGRAM, FUNCTION, FUNCTION_BLOCK. Un FB s’utilise via une instance déclarée en VAR. Le PROGRAM PLC_PRG est exécuté par une tâche et pilote la logique principale.

PROGRAM PLC_PRG
VAR
    moteur : FB_Moteur;
END_VAR

moteur(Marche := TRUE);
IF moteur.EnMarche THEN
    ...;
END_IF

Codesys - Tips & Astuces

Astuces Codesys : raccourcis, édition ST, débogage, outils IDE et productivité

Optimiser votre développement dans Codesys : Structured Text, débogage, monitoring et outils intégrés

⌨️

Raccourcis clavier essentiels

Alt + Sélection — Sélection rectangulaire pour éditer plusieurs lignes simultanément.
Ctrl + F2 — Basculer entre la déclaration et l’implémentation d’une variable ou d’un FB.
Ctrl + Shift + F — Formatage automatique du code Structured Text.
Ctrl + Space — Auto‑complétion intelligente des mots‑clés, variables et fonctions.
Ctrl + Shift + C — Commenter / décommenter rapidement une sélection.
F7 — Compilation rapide du projet

✏️

Astuces d’édition ST

Duplication de ligne — Ctrl + D pour dupliquer la ligne courante.
Déplacement de ligne — Alt + ↑ / ↓ pour déplacer une ligne ou un bloc.
Alignement automatique — Utiliser le formatage ST pour aligner les := et les blocs IF.
Insertion rapide de blocs — Taper IF + Enter, FOR + Enter, CASE + Enter pour générer automatiquement le squelette.

🖥️

Astuces IDE Codesys

Watch List — Surveiller des variables en temps réel avec possibilité de modifier les valeurs.
Trace — Enregistrer l’évolution de variables dans le temps (oscilloscope intégré).
Task Monitoring — Analyser les temps d’exécution des tâches et détecter les surcharges.
Device Tree — Afficher les ressources de l’automate : tâches, IO, communication.
Cross Reference — Voir où chaque variable est utilisée dans le projet.

🐞

Débogage avancé

Forçage de variables — Forcer une valeur pour tester un comportement sans modifier le code.
Breakpoints ST — Mettre des points d’arrêt dans le code ST pour exécuter pas à pas.
Monitoring en ligne — Visualiser l’état des blocs IF, CASE, FOR en temps réel.
Simulation Codesys — Tester le programme sans automate physique.

🛠️

Manipulations utiles

Renommer une variable partout — Utiliser Refactor → Rename pour éviter les erreurs.
Recherche avancée — Ctrl + Shift + F pour rechercher dans tout le projet.
Export XML — Exporter une partie du projet pour la réimporter ailleurs.

🧰

Outils intégrés

PLC Logger — Journal système de l’automate (erreurs, warnings, reboot).
Online Change — Télécharger uniquement les modifications sans arrêter l’automate.
Symbol Configuration — Configurer les variables exposées pour OPC-UA, Modbus, MQTT.
I/O Mapping — Associer les variables aux entrées/sorties physiques.

Codesys - IEC & POO

IEC 61131-3 & POO Codesys : types, POU, classes, héritage, interfaces, pointeurs

Comprendre la programmation orientée objet dans Codesys : FB, méthodes, propriétés, héritage, interfaces et architecture IEC

📘

Types de Données IEC 61131-3

Types Elémentaires & Conventions — Chaque type de variable IEC possède un préfixe recommandatif (PLCopen) pour une lisibilité immédiate.

VAR
    xEnable     : BOOL := FALSE;    // x : Boolean (1 bit)
    bByteVal    : BYTE := 16#FF;    // b : Byte (8 bits, masques)
    iCounter    : INT := -120;      // i : Integer signatif (16 bits)
    uiCount     : UINT := 40000;    // ui : Unsigned Int (16 bits)
    diEncoder   : DINT := 100000;   // di : Double Int (32 bits)
    rTemp       : REAL := 23.5;     // r : Float simple précision (32 bits)
    lrPrecision : LREAL := 3.14159; // lr : Float double précision (64 bits)
    tDelay      : TIME := T#2s500ms;// t : Durée (TIME)
    sDevName    : STRING[30] := 'Pump_1'; // s : Chaîne ASCII
END_VAR

Structures, Énumérations & Alias — Les types utilisateur (DUT) permettent d'encapsuler la donnée. Préfixes : st (Struct), e (Enum), a (Array).

// TYPE ENUM (eState)
TYPE eAxisState : (INIT, STOPPED, MOVING, ERROR); END_TYPE

// TYPE STRUCT (stConfig)
TYPE stAxisConfig :
STRUCT
    rMaxSpeed : REAL := 1000.0;
    rAccel    : REAL := 100.0;
    xReversed : BOOL := FALSE;
END_STRUCT
END_TYPE

// Declaration
VAR
    eState : eAxisState := eAxisState.INIT;
    stCfg  : stAxisConfig;
    aSpeed : ARRAY[1..5] OF REAL := [10.0, 20.0, 30.0, 40.0, 50.0];
END_VAR

🧩

Unités d'Organisation de Programme (POU)

PROGRAM (PRG) vs FUNCTION (FUN) — Un PRG a une mémoire permanente et est exécuté par une Tâche. Une FUN est sans mémoire (pure) et retourne une valeur unique.

// FUNCTION (Sans état interne)
FUNCTION F_CelsiusToFahrenheit : REAL
VAR_INPUT
    rCelsius : REAL;
END_VAR
    F_CelsiusToFahrenheit := (rCelsius * 9.0 / 5.0) + 32.0;
END_FUNCTION

// Utilisation dans un PRG
PROGRAM PLC_PRG
VAR
    rAmbTempC : REAL := 21.5;
    rAmbTempF : REAL;
END_VAR
    rAmbTempF := F_CelsiusToFahrenheit(rAmbTempC);
END_PROGRAM

FUNCTION_BLOCK (FB) - L'Instance et la Mémoire — Un FB possède un état interne conservé entre chaque cycle. En POO, il sert de classe d'objet.

FUNCTION_BLOCK FB_Blinker
VAR_INPUT
    tToggleTime : TIME := T#1s;
END_VAR
VAR_OUTPUT
    xOut : BOOL;
END_VAR
VAR
    tonTimer : TON; // Bloc temporisateur standard IEC
END_VAR

tonTimer(IN := NOT tonTimer.Q, PT := tToggleTime);
IF tonTimer.Q THEN
    xOut := NOT xOut;
END_IF

⚙️

POO CODESYS - Classes, Méthodes & Propriétés

Encapsulation & Spécificateurs d'Accès — Un FB joue le rôle de Classe. Les Méthodes et Propriétés permettent de séparer l'interface de l'implémentation (PUBLIC, PRIVATE, PROTECTED, INTERNAL).

FUNCTION_BLOCK FB_Valve
VAR_OUTPUT
    xIsOpen : BOOL; // Visible depuis l'extérieur
END_VAR
VAR PRIVATE
    iErrorID : INT := 0; // Masqué pour les accès externes direct
END_VAR

// METHOD PUBLIC : Action exécutable sur l'objet
METHOD PUBLIC Open : BOOL
    xIsOpen := TRUE;
    Open := TRUE;
END_METHOD

Propriétés (PROPERTY) - Getters & Setters — Permettent de lire ou modifier de manière contrôlée des variables internes sans passer par des entrées directes.

// PROPERTY Speed : REAL (Contrôle d'accès à rInternalSpeed)
PROPERTY PUBLIC Speed : REAL

// Getter (Lecture)
GET
    Speed := rInternalSpeed;

// Setter (Écriture avec validation)
SET
    IF Speed > 100.0 THEN
        rInternalSpeed := 100.0;
    ELSE
        rInternalSpeed := Speed;
    END_IF

🏗️

POO CODESYS - Héritage & Interfaces

Héritage (EXTENDS) — Un FB enfant hérite des variables, propriétés et méthodes de son parent, et peut surcharger (override) son comportement.

// FB Parent
FUNCTION_BLOCK FB_Sensor
VAR
    rRawValue : REAL;
END_VAR
METHOD PUBLIC Read : REAL
    Read := rRawValue;
END_METHOD

// FB Enfant (Extension)
FUNCTION_BLOCK FB_CalibratedSensor EXTENDS FB_Sensor
VAR
    rOffset : REAL := 1.5;
END_VAR
// Surcharge de la méthode Read
METHOD PUBLIC OVERRIDE Read : REAL
    Read := SUPER^.Read() + rOffset; // Appel du parent via SUPER^
END_METHOD

Interfaces (INTERFACE & IMPLEMENTS) — Définit un contrat standardisé. Permet le polymorphisme et le découplage fort (Ex: I_Drive, I_Logger).

// INTERFACE I_Actuator
INTERFACE I_Actuator
METHOD Run : BOOL
END_METHOD
METHOD Stop : BOOL
END_METHOD
END_INTERFACE

// FB Implémentant l'Interface
FUNCTION_BLOCK FB_Conveyor IMPLEMENTS I_Actuator
METHOD Run : BOOL
    // Implémentation spécifique au convoyeur
    Run := TRUE;
END_METHOD
METHOD Stop : BOOL
    Stop := TRUE;
END_METHOD

🔗

Pointeurs, Références & Gestion Mémoire

Pointeurs (POINTER TO) vs Références (REFERENCE TO) — Utilisés pour passer des objets légers sans copie mémoire. Les Références gèrent le déférencement automatiquement.

VAR
    stData : stAxisConfig;
    pData  : POINTER TO stAxisConfig; // Adresse mémoire explicit (ADR)
    refData: REFERENCE TO stAxisConfig; // Alias sécurisé (REF=)
END_VAR

// Pointeur
pData := ADR(stData);
IF pData <> 0 THEN
    pData^.rMaxSpeed := 500.0; // Déférencement obligatoire (^)
END_IF

// Référence
refData REF= stData;
IF __ISVALIDREF(refData) THEN
    refData.rMaxSpeed := 500.0; // Accès direct transparent
END_IF

Pointeur Spécial THIS^ — Accès explicite à l'instance courante du Function Block dans ses propres méthodes.

METHOD PUBLIC SetSelfParam : BOOL
VAR_INPUT
    rMaxSpeed : REAL;
END_VAR
    // Ambiguïté levée grâce à THIS^
    THIS^.rMaxSpeed := rMaxSpeed;
END_METHOD

📐

Conventions de Nommage & Architecture IEC/POO

Tableau Synthetique des Préfixes Standardisés — Conventions d'écriture unifiées pour l'ensemble du projet CODESYS (PLCopen / Guidelines).

// PREFIXES D'OBJETS ET TYPES
PRG_   : Program (ex: PRG_MotionControl)
FB_    : Function Block (ex: FB_AxisServo)
F_     : Function (ex: F_MathCalc)
I_     : Interface (ex: I_MotorControl)
ST_    : Structure (ex: ST_AlarmData)
E_     : Enumeration (ex: E_MachineMode)
GVL_   : Global Variable List (ex: GVL_IO)

// PREFIXES DE VARIABLES & SCOPE
g_     : Variable Globale (ex: g_xEmergencyStop)
i_     : Entrée de FB/FUN (ex: i_rSetPoint)
q_     : Sortie de FB/FUN (ex: q_xDriveReady)
iq_    : InOut de FB/FUN (ex: iq_stStatus)

Règles d'Or d'Architecture en Automatisme — Principes de conception pour une application modulaire, maintenable et testable.

1. ZÉRO VARIABLE GLOBALE EN ÉCRITURE : Les GVL doivent être en lecture seule.
   Utiliser des méthodes / interfaces pour échanger des données.
2. UN FB = UNE RESPONSABILITÉ : Ne pas créer un FB monolithique 'Tout-en-un'.
3. DÉCOUPAGE PAR TÂCHES :
   - Task_Fast (1-2ms) : Régulation, Fast IO, Safety
   - Task_Main (10ms)  : Sequencier, Logique Métier, POO
   - Task_HMI (50-100ms) : Traitement IHM, Alarmes, Gateway
4. VÉRIFICATION DES RÉFÉRENCES : Toujours valider les pointeurs (ADR != 0)
   et références (__ISVALIDREF) avant toute lecture/écriture.

TIA Portal - Tips & Aides

TIA Portal : raccourcis, SCL, temporisateurs, organisation projet et bonnes pratiques

Guide Siemens STEP 7 / SCL pour S7‑1200 et S7‑1500 : programmation, diagnostic et optimisation

⌨️

Raccourcis clavier essentiels

Ctrl + B — Compiler / verifier la coherence du projet (project verification).
Ctrl + F8 — Charger le programme dans l'automate (Download vers la CPU).
Ctrl + M — Activer / desactiver la visualisation en ligne (monitoring) d'un bloc.
Ctrl + Z / Ctrl + Y — Annuler / retablir la derniere action.
F1 — Ouvrir l'aide contextuelle Siemens sur l'element selectionne.

🧮

Fonctions SCL courantes (Move, Calcul, Comparaison)

Affectation (equivalent du bloc MOVE en LAD) — En SCL, MOVE n'est qu'une simple affectation, pas besoin de bloc dedie.

Sortie := Entree;
TagDB.Vitesse := 50.0;

Operations arithmetiques (ADD / SUB / MUL / DIV) — Les operateurs standards remplacent les blocs LAD/FBD.

Total := A + B;
Reste := A MOD B;   // modulo
Resultat := (A - B) * C / D;

Comparaisons — Utilisables directement dans un IF, comme en ST/CODESYS.

IF Niveau >= SeuilHaut THEN
    AlarmeHaute := TRUE;
END_IF;

Conversion de types (CONVERT) — Convention Siemens : NomTypeSource_TO_NomTypeCible.

ValeurReelle := INT_TO_REAL(ValeurEntiere);
Texte := REAL_TO_STRING(ValeurReelle);

Mise a l'echelle (NORM_X / SCALE_X) — Le duo standard pour convertir un signal brut (ex: 4-20mA) en valeur physique, puis inversement.

NORM_X(MIN := 0, MAX := 27648, VALUE := ValeurBrute, OUT => ValeurNormee);
SCALE_X(MIN := 0.0, MAX := 100.0, VALUE := ValeurNormee, OUT => ValeurPhysique);

⏱️

Temporisateurs & Compteurs

TON / TOF / TP — Temporisateurs IEC standards, identiques dans leur logique a Codesys.

"MonTON"(IN := Marche, PT := T#5s);
IF "MonTON".Q THEN
    ...;
END_IF;

CTU / CTD / CTUD — Compteurs standards (comptage, decomptage, ou les deux).

"MonCTU"(CU := Impulsion, R := Reset, PV := 10);
NombreActuel := "MonCTU".CV;

🗂️

Organisation du projet

OB (Organization Block) — Point d'entree du programme, appele par le systeme d'exploitation de la CPU (ex: OB1 = cycle principal).
FB (Function Block) — Bloc avec memoire (instance / DB associe), utilise pour les objets avec etat (moteur, vanne...).
FC (Function) — Bloc sans memoire propre, pour du calcul ou de la logique reutilisable sans etat.
DB (Data Block) — Zone de donnees : DB d'instance (associe a un FB) ou DB global partage.
Table des variables API (PLC tags) — Centralise les adresses physiques (%I, %Q, %M) associees a des noms symboliques.
Commentaires de reseau (network) — Documenter chaque reseau LAD/FBD facilite la maintenance et le depannage futur.

🐞

Mise en service & diagnostic

PLCSIM — Simuler le programme sans automate physique avant la mise en service.
Table de visualisation (Watch Table) — Suivre et forcer des variables en temps reel pendant les tests.
Table de forcage (Force Table) — Forcer une valeur d'entree/sortie physique pour tester un cablage ou un capteur.
Fonction Trace — Enregistrer l'evolution de variables dans le temps, utile pour analyser un defaut intermittent.
Cross-reference (Reference croisee) — Localiser tous les endroits ou une variable est lue ou ecrite dans le projet.
Comparaison en ligne/hors ligne — Comparer le programme charge dans l'automate avec le projet local avant un telechargement.

💡

Bonnes pratiques

Nommer symboliquement chaque E/S — Eviter de manipuler des adresses brutes (%I0.0) directement dans la logique : passer par des tags nommes.
Un FB = une responsabilite — Comme en POO, garder chaque bloc focalise sur une seule fonction machine.
Sauvegarder avant tout changement en ligne — Toujours archiver le projet avant une modification 'online' pour pouvoir revenir en arriere.
Verifier la coherence avant chargement — Un Ctrl+B systematique avant Ctrl+F8 evite de charger un projet incoherent sur l'automate.