Introduction au langage ST
Le langage ST fait partie des cinq langages standardisés par la norme IEC 61131-3.
Il combine la puissance d’un langage de programmation textuel avec une grande simplicité en terme de syntaxe. Cette approche te permet de créer des programmes complexes tout en gardant un code clair et maintenable. La programmation ST t’offre une flexibilité que tu ne trouveras pas dans les langages graphiques comme le Ladder ou le FBD.
De mon point de vue la programmation en langage ST est la meilleure manière de programmer un automate industriel, la courbe d’apprentissage est certes un peu plus raide que sur des langages graphiques mais les fonctionnalité sont beaucoup moins restrictive.
Syntaxe de base et structure du code
La structure de base de ton programme ST commence par PROGRAM et se termine par END_PROGRAM. Chaque instruction se termine par un point-virgule (;). Tu peux ajouter des commentaires entre (* et *) pour documenter ton code.
- La déclaration de ton programme :
PROGRAM : Nom_programme ; - La déclaration de tes variables :
Nom_variable : TYPE_VARIABLE ; - L’écriture de tes commentaires :
(* mon commentaire *) OU //mon commentaire
Exemple réalisé sur codesys :
Les Types de variable en langages ST
Ces fameuse variable que l’on doit déclarer en amont de notre programme il en existe une multitude, on te présente donc cette diversité de types de variables dans les tableaux ci-dessous :
Types de données booléennes
| Type | Description | Exemple |
|---|---|---|
| BOOL | Booléen (valeur logique) | TRUE/FALSE |
Types de données numériques entiers
| Type | Description | Exemple |
|---|---|---|
| SINT | Entier signé sur 8 bits | -128 à 127 |
| INT | Entier signé sur 16 bits | -32768 à 32767 |
| DINT | Entier signé sur 32 bits | -2 147 483 648 à 2 147 483 647 |
| LINT | Entier signé sur 64 bits | Très grand nombre |
| USINT | Entier non signé sur 8 bits | 0 à 255 |
| UINT | Entier non signé sur 16 bits | 0 à 65535 |
| UDINT | Entier non signé sur 32 bits | 0 à 4 294 967 295 |
| ULINT | Entier non signé sur 64 bits | Très grand nombre |
Types de données numériques en virgule flottante
| Type | Description | Exemple |
|---|---|---|
| REAL | Nombre décimal en simple précision (32 bits) | -3.402e38 à 3.402e38 |
| LREAL | Nombre décimal en double précision (64 bits) | Très grande plage de valeurs |
Types de données temporelles
| Type | Description | Exemple |
|---|---|---|
| TIME | Durée ou intervalle | T#5s, T#1h30m |
| DATE | Date | DATE#2024-12-06 |
| TIME_OF_DAY / TOD | Heure du jour | TOD#12:30:15 |
| DATE_AND_TIME / DT | Date et heure | DT#2024-12-06-12:30:15 |
Types de données bit et mot
| Type | Description | Exemple |
|---|---|---|
| BYTE | Octet de 8 bits | 0x00 à 0xFF |
| WORD | Mot de 16 bits | 0x0000 à 0xFFFF |
| DWORD | Double mot de 32 bits | 0x00000000 à 0xFFFFFFFF |
| LWORD | Long mot de 64 bits | Très grand nombre |
Choisis les types de données appropriés pour économiser la mémoire. Par exemple, utilise SINT au lieu de DINT pour les petites valeurs.
Structures d’un code en langages ST
Les structures de contrôle te permettent de créer des programmes ST plus sophistiqués. Voici comment les maîtriser efficacement.
Opérateurs et expressions
| Catégorie | Opérateurs | Exemple en ST |
|---|---|---|
| Opérateurs arithmétiques | +, -, *, /, :=, MOD |
Result := A + B;
Remainder := A MOD B; |
| Opérateurs logiques | AND, OR, NOT, XOR |
IF (A > 5) AND (B < 10) THEN
Output := TRUE; END_IF; |
| Opérateurs de comparaison | =, <>, <, >, <=, >= |
IF A = B THEN
Equal := TRUE; ELSE Equal := FALSE; END_IF; |
Boucles et conditions
| Structure | Description | Exemple de code en ST |
|---|---|---|
| IF | Exécution conditionnelle. |
IF x > 5 THEN
y := y + 1; ELSE y := 0; END_IF; |
| FOR | Nombre d’itérations connu à l’avance. |
FOR i := 1 TO 10 DO
Sum := Sum + i; END_FOR; |
| WHILE | Répétition tant qu’une condition est vraie. |
WHILE x < 10 DO
x := x + 2; END_WHILE; |
| REPEAT | Exécution au moins une fois. |
REPEAT
x := x – 1; UNTIL x = 0 END_REPEAT; |
La fonction que j’utilise très souvent est la fonction CASE avec ca tu peux créer un code avec des étapes et transition comme dans un grafcet. Ca se présente comme ça :
0: (* Étape 0 *)
Output := FALSE; (* Action : désactiver la sortie *)
IF Condition1 THEN
Step := 1; (* Transition vers l’étape 1 *)
END_IF;
1: (* Étape 1 *)
Output := TRUE; (* Action : activer la sortie *)
IF Condition2 THEN
Step := 2; (* Transition vers l’étape 2 *)
END_IF;
2: (* Étape 2 *)
Output := FALSE; (* Action : désactiver la sortie *)
IF Condition3 THEN
Step := 0; (* Transition vers l’étape 0 *)
END_IF;
END_CASE;
Optimisation et bonnes pratiques du langages ST
L’optimisation de tes programmes ST peut faire une grande différence dans leurs performances. Voici comment maximiser l’efficacité de ton code.
Standards de codage
Adopter de bonnes pratiques permet de rendre ton code plus lisible et maintenable :
- Commente ton code pour faciliter sa reprise par d’autres développeurs.
- Structure tes programmes en blocs logiques bien définis.
- Utilise des noms de variables explicites pour éviter les ambiguïtés.
Gestion de la mémoire
Une gestion efficace de la mémoire est essentielle en langage ST. Voici quelques principes à appliquer
Allocation de mémoire
- Réutilise les variables temporaires quand c’est possible.
- Libère les ressources après leur utilisation.
- Évite les variables globales inutiles, qui peuvent consommer de la mémoire inutilement.
Optimisation des données
- Surveille la zone mémoire utilisée et ajuste le paramétrage du processeur en fonction des besoins.
Calculs complexes
Pour les calculs complexes :
- Divise les opérations en étapes distinctes.
Cette approche facilite le débogage et améliore la performance globale du programme.
Notre avis sur la programmation en langage ST
Le langage Structured Text (ST) se démarque par sa flexibilité, qui en fait le plus polyvalent des langages d’automates. Grâce à sa syntaxe inspirée des langages de programmation traditionnels, il permet une grande liberté dans l’écriture des programmes, notamment pour gérer des algorithmes complexes, des calculs précis ou encore des structures conditionnelles avancées.
Comparé à des langages plus graphiques comme Ladder ou FBD (Function Block Diagram), ST offre un contrôle bien plus fin et une facilité de maintenance pour des projets de grande envergure.
Contenu
