Programmation 2
SCL : Structured Control Language (programmation structurée en
texte).
Introduction
• Basé sur le cours Siemens : SIMOTION ST Structured Text, Manuel
de programmation et d'utilisation, 02/2012
Langage SCL
• Évolué
• Basé sur du PASCAL
• Norme EN-61131-3 (CEI 61131-3) -> langage de programmation
ST « Structured Text »
• Utilisation des I/O, fonction, mementos etc.
• Mélange de Ladder et SCL possible
• Vérifie la syntaxe directement
Déclaration de variables
• Commence par une balise (VAR, VAR_GLOBAL, …)
• Déclare les variables de différents types ainsi que les
déclarations d’instance.
• Fini par END_VAR.
• Nom de la variable : Lettres, Chiffres ou underscore.
• On peut assigner une valeur de départ à la variable ->
initialisation.
• Si déclaration de constante -> obligé de l’initialiser.
Déclaration de variables (suite)
• VAR : temporaire (Fct) ou statique (FB).
• VAR_GLOBAL : accès partout mais ….
• VAR_IN_OUT : modifiable dans la fonction FC ou FB (R/W).
• VAR_INPUT : non modifiable dans la fonction FC ou FB (que R).
• VAR_OUTPUT : envoyée vers l’extérieur. (return)
• VAR_TEMP : variable temporaire.
• VAR RETAIN : variable rémanente. (espace entre VAR et RETAIN)
• VAR CONSTANT : variable constante. (espace entre VAR et CONSTANT).
• Attention, les variables globales (VAR_GLOBAL) ne peuvent être que dans
un GVL !
Types de données
Plusieurs types de données sont possibles :
• Élémentaires : int, char, …
• Définies par l’utilisateur (UDT) : array, struct, enum, …
• Objets technologiques : sinapos, ...
• Systèmes : StructAlarmId et StructTaskId.
Types de variables élémentaires
• Binaires : Bool (true, false), Byte, Word, DWord.
• Numériques : SInt, USInt, Int, UInt, DInt, UDInt, Real, LReal
• Temps :
• Time : durée par pas d’1ms,
• Date : Date par pas d’1 jour,
• Time Of Day (TOD) : Heure par pas d’1ms (idem que Time sans le jour),
• Date and Time (DT) : comporte Date et Time
• Chaine de caractères : String[80] = ‘toto’;
• Types généraux (p115) : utilisé dans les I/O des FC ou FB. Permet
d’envoyer (ou de retourner) tous les types demandés :
• ex: tous les int si on utilise ANY_INT
Plage de valeurs
Plage de valeurs
Type de variables UDT (user defined data
types -> l’utilisateur crée un type de donné !
• Commence par la balise TYPE et fini par END_TYPE.
• Définir un nom pour le type.
• Suivit de :
• Le type
• Et finir par ;
Chaine de caractères (String)
• Chaque caractère dans la chaine est codé sur 1 octet.
• Le $ permet de stocker dans la chaine : ‘,CR(carriage return),LF (line
feed) :
• $’ -> stock le caractère ’
• $L -> saut de ligne
• $r -> retour chariot
• $$ -> stock le caractère $
• Le ‘’ permet de stocker des caractères dans la chaine :
• ‘Ma chaine’ -> chaine contient Ma chaine (longueur 9 octets)
• ‘ -> chaine de caractère vide (longueur 0 octet)
• ‘Hello$r’ -> chaine contenant le texte Hello suivi du retour chariot (longueur 6
octets)
Les énumérations (Enum)
• Remplace un int en texte. Permet une lecture du code plus lisible.
• Exemples :
• Retour d’erreurs dans une fonction : plutôt que de retourner un int, on
retourne du texte synthétique expliquant l’erreur.
• En GTC (gestion technique centralisée) ou GTB (gestion technique des
bâtiments) : permet de déterminer l’état d’alarme, sirène, etc. via du texte
(activé, désactivé, intrusion_cuisine, ..) plutôt que (0,1,2,..).
• Le premier texte d’une énumération à la valeur 0, le suivant 1 etc.
Sauf si le texte énuméré est affecté. La valeur est un int.
• Pas vraiment utile si on a un booléen.
• Utilisable pour le GEMMA
Les énumérations dans Codesys V3
On peut modifier le int par défaut de l’enum si on met le type à la
fin de l’enum. (encadré en rouge ci-contre).
Les structures (Struct)
• Une structure permet de regrouper des données de différents
types ou non. (Contrairement au tableau où les données doivent
être de même type.)
• Permet d’envoyer plus facilement des données de différents types
à une fonction. (arguments)
• La structure est presque un objet car il contient des variables de
différents types mais pas de fonctions (méthodes) à appliquer
sur cet objet.
Utilisation structure dans Twincat
Ajouter une Structure dans Twincat :
Utilisation structure dans Twincat
• Créer la structure :
• Je n’ai pas créé d’enum pour le modèle de la voiture.(Cela montre l’intérêt de Enum)
• Déclarer les variables de type structure (2 méthodes : avec ou
sans initialisation). Dans les variables globales (ou non).
Twincat :
Ctrl + espace = autocomplétion ou, comme
l’image ci-contre le montre, affiche les
différents champs possibles.
Utilisation structure dans Twincat
• Suite de la déclaration (autocomplétion) :
• Visualisation du commentaire.
• Visualisation des paramètres à initialiser ou pas.
• Modèle sans enum => bcp moins compréhensible.
• Aide sur les affectations :
Utilisation structure dans Twincat
• L’autre méthode d’affectation de la variable structure sans
initialisation :
• Dans les déclarations de variables :
• Dans le code :
Écrire : « ma1 » suivi de Ctrl + espace et ça m’a
écrit automatiquement GVL.Ma1Voiture.
L’affectation des variables de type structure dans le code est également possible avec
l’initialisation de celles-ci :
Affectation de variables
• Affectation de données élémentaires :
• Affectation binaire conseillé via true, false :
• Affectation ou lecture binaire via le bit d’un byte, word ou Dword :
• Modification des types de variable : int_to_bool etc.
Exemples d’instructions importantes
• Exemple affectation :
• a :=27;
• Exemple de commentaire :
• //a:=27;
• (* permet de réaliser
des commentaires sur
plusieurs lignes ! *)
• Exemple d’appel de fonction :
• Somme := add(10,25);
• Exemple de comparaison :
• IF i<10 then
i++;
END_IF;
Opérations (ordre)
Opération Modulo (MOD)
• Détermine le reste de la division euclidienne.
• Exemples :
• 9 Mod 4 = 1 car 4*2=8, il reste donc 1 (9-8=1).
• 9 Mod 3 = 0 car 3*3=9, il ne reste rien (9-9=0).
• 9 Mod 6 = 3 car 6*1=6, il reste 3 (9-6=3).
• 14 Mod 12 = 2 car 12*1=12, il reste 2 (14-12=2).
• 2 Mod 5 = 2 car 5*0=0, il reste 2 (2-0=2). (5 étant trop grand par rapport à 2, on fait 5*0).
• i=(i+1)Mod 5; //permet de remettre i à 0 dès qu’il arrive à 4 et de
recommencer. Varie de 0 à 4 indéfiniment.
• i Mod 2 : permet de déterminer les nombres pairs et impairs.
• 0Mod2=0 1Mod2=1 2Mod2=0 3Mod2=1 4Mod2=0
• Permet également de déposer une pièce à un endroit puis un autre avec le robot.
• Mod12 : 0 à 24h -> 0 à 12h (AM/PM).
Comparaison (condition) -> if
• Il est conseillé d’utiliser des instructions if elsif plutôt que des if.
• réduire le temps de cycle. Si une condition est vraie, alors on exécute le
code dans cette condition vraie pour ensuite allez directement à endif
sans même vérifier les conditions suivantes.
• Utilisation de then et de end_if (attention : end_if avec ; dans TIA et sans ;
dans twincat !)
Sélecteur -> Case (switch)
• Equivalent à un elsif mais compare si la valeur (Any_int) mise dans
le sélecteur est dans la liste.
• Utilisé pour réaliser le G7 (Attention Tempo !!)
• Type utilisé : tous les int ou enum
• Avec Enum, on ne peut pas utiliser directement l’énum, il faut
créer une variable de l’Enum. Ex : MarqueVoiture
Boucle : While, do while (repeat, until)
• While (true) -> est interdit !!
• Attention aux boucles -> temps de cycle…
• Repeat/until (Do/while) : exécute au moins une fois le code voire
plus si la condition est vraie.
• While : exécute le code que si la condition est vraie => booléen
Boucle : for
• Connaitre le nombre d’exécution de la boucle. => any int
• Pas de condition contrairement à While.
• Si compteur (cpt), une ligne en moins par rapport au While.
Instruction exit
• Permet de sortir d’une boucle while, repeat, for.
• Le programme reprend à la fin de la boucle (END_...)
Les fonctions
• Exécute des codes identiques qui se répèteraient.
• Structure le programme, le rend plus claire (ex : gestion des
sorties, grafcet, temporisations, gestion de l’alarme, régulation de
température, etc.)
• Permet un dépannage plus rapide
• Modification d’erreur plus rapide
• Code réduit
• Moins laborieux à écrire => pratique !
Différence entre FC, FB et Prog:
• FC : -> calcul, conversion, opération logique, … (retourne souvent des
valeurs)
• Pas de données statiques
• Les variables locales perdent leur valeur dès qu’on quitte la fonction
• Lorsqu’elles sont rappelées, les variables locales sont réinitialisées.
• FB : -> gestion de postes identiques,.. => G7, PID, compteur etc..
• Données statiques permettant de garder en mémoires des variables
• Si elles sont définies en statique, elles gardent leur valeur même si on quitte la
fonction
• Créé une DB d’instance à chaque appel
• Prog : -> main, gestion des sorties,… -> gestion (appelé une seule fois)
• Non paramétrable => on n’envoi et ne retourne rien à/de la fonction ! Pas de
var_in, var_out, return etc.
• Structure le programme
Les fonctions (FC ou FUN)
• Prototype (déclaration de la fonction, idem que la déclaration de
variables) : Non obligatoire en SCL !
Normalement : Mais pas en SCL !
• Fonction (programme) :
Les fonctions
Les entrées ne peuvent être que lues.
Les sorties ne peuvent être qu’écrites.
Les entrées/sorties peuvent être lues et
écrites.
Variables locales = mémoire interne à la
fonction.
Dans twincat, var_stat est utilisé pour les
variables statiques.
Les fonctions (FC ou FUN)
• Appel de la fonction (exécution de la fonction) :
Le premier appel utilise le return.
Le deuxième appel utilise la variable output.
Les blocs fonctionnels (FB)
• Garde en mémoire !
• Avant d'appeler une FB, il faut l’instancier dans les variables !
• Code de la FB
Les FB
• Appel de la FB
• On peut aller lire les variables locales de la FB en étant en dehors
de celle-ci : (par exemple dans gestion des sorties)
Les programmes Prog
• Similaires aux FB
• Mais : pas de paramètres formels (donc pas d’envoi de données à
la fonction via des paramètres).
• Pas de retour possible non plus.
• Possède également des variables locales statiques (var ou
var_stat) et des variables locales temporaires (var_temp)
• Le grafcet aurait pu être un programme plutôt qu’un FB vu qu’on
ne l’appelle qu’une fois et on n’envoie pas de paramètre et on ne
retourne rien.
Les tableaux Array (sans pointeur)
• Déclaration du tableau :
• Type Array
• De 0 à 10 (l’indice du tableau va de 0 à 10). On peut donc stocker
11 valeurs réelles.
• Le tableau stocke des variables de types réelles.(ou autre)
Les matrices
Les tableaux Array (avec pointeur)
• Permet d’envoyer l’adresse d’une cellule d’un tableau (une
donnée) à une fonction plutôt que d’envoyer tout le tableau
(beaucoup de données). L’adresse de la cellule envoyée est
souvent la première cellule du tableau.
• [Link]
3/tc3_plc_intro/[Link]&id=
Les tableaux Array (avec pointeur)
• Exemple : incrémente les valeurs de 1 dans le tableau à chaque
front montant
Les tableaux (avec pointeur)
• La fonction
