ISA Informatique et systèmes automatisés - cours, examenscours-examens.org/images/Etudes_superieures/Ingenieur_en... · 2017. 7. 6. · Département TIN Technologies Industrielles

Département TIN Technologies Industrielles

Haute École d'Ingénierie et de Gestion du Canton de Vaud

Systèmes IndustrielsSIC - SIG

ISAInformatiqueet systèmes automatisés

Support de cours

Alain Beuret

10 avril 2011 Version 1.164

ISAISA IntroductionIntroduction heig-vdheig-vd

Historique des modifications

Version Date Auteur Modifications

1.164 10.04.11 Alain Beuret Création document

Convention typographiqueExemples DescriptionsTexte Texte du cours, sans serif normal taille 12

Important Termes importants, sans serif gras taille 12English / Deutsch Termes dans un langue étrangère, sans serif italique taille 12

Exemple, note Exemple et note, sans serif taille 10

i, x, ω, φI, X, Ω

Variables mathématiques, serif italique minusculesConstantes mathématiques, sérif italique majuscules

sin, tg, lim Fonctions mathématiques, serif grasa := b + c; Code programme, chasse fixe normal if … then … else Mots réservés programme, chasse fixe gras' Commentaire Commentaires programme, chasse fixe italique

ii

Copyright © Alain Beuret, 2011

La copie de tout ou partie de ce document, quelle qu’en soit la forme et le support, n’est pas autorisée sans l’accord formel de l'auteur. En particulier, la publication et la diffusion de ce document sur des sites internet de partage est interdite.

Ce document est disponible au téléchargement sur le site de l'Institut d'Automatisation Industrielle de la heig-vd : iai.heig-vd.ch

Par ailleurs, l'auteur ne prend aucune responsabilité relative à des erreurs éventuelles du contenu, ni aux droits de reproduction de certaines des images utilisées.

Toutes propositions d’améliorations et de corrections seront les bienvenus.

[email protected]

http://iai.heig-vd.ch/mailto:[email protected]

heig-vdheig-vd IntroductionIntroduction ISAISA

Table des matières

1 Matériel et architectures 1-21.1 Bref historique.......................................................................................................................1-21.2 Systèmes informatiques........................................................................................................1-51.2.1 Bureautique...........................................................................................................................1-51.2.2 Industriels..............................................................................................................................1-51.3 Matériel..................................................................................................................................1-51.3.1 Ordinateurs et calculateurs...................................................................................................1-51.3.1.1 Architecture matérielle.................................................................................................................. 1-51.3.1.2 Fonctionnement............................................................................................................................ 1-51.3.1.3 Systèmes d'exploitation................................................................................................................ 1-5

1.3.2 Automates programmables et commandes numériques......................................................1-71.3.2.1 Architecture matérielle.................................................................................................................. 1-71.3.2.2 Fonctionnement............................................................................................................................ 1-71.3.2.3 Ressources................................................................................................................................... 1-71.3.2.4 Langages de programmation normalisés..................................................................................... 1-7

1.3.3 Microcontrôleurs....................................................................................................................1-71.3.4 Réseaux et bus de terrain.....................................................................................................1-7

2 Binaire et logique combinatoire 2-22.1 Les nombres binaires............................................................................................................2-22.2 Algèbre de Boole...................................................................................................................2-22.2.1 Les opérateurs......................................................................................................................2-22.2.1.1 NON logique................................................................................................................................. 2-32.2.1.2 ET logique..................................................................................................................................... 2-32.2.1.3 OU logique.................................................................................................................................... 2-3

2.2.2 Règles et théorèmes.............................................................................................................2-42.2.2.1 Axiomes........................................................................................................................................ 2-42.2.2.2 Théorèmes.................................................................................................................................... 2-42.2.2.3 Théorèmes de De Morgan............................................................................................................ 2-52.2.2.4 Principe de dualité........................................................................................................................ 2-5

2.2.3 Synthèse d'une fonction logique...........................................................................................2-62.2.4 Réduction des équations, tables de Karnaugh.....................................................................2-72.3 Langages de programmation graphique.............................................................................2-102.3.1 Les variables.......................................................................................................................2-102.3.1.1 Déclaration des variables............................................................................................................ 2-11

2.3.2 Opérateurs logiques............................................................................................................2-112.3.2.1 Affectation................................................................................................................................... 2-122.3.2.2 Négation (NOT)........................................................................................................................... 2-122.3.2.3 ET logique (AND)........................................................................................................................ 2-132.3.2.4 OU logique (OR)......................................................................................................................... 2-13

iii

En cours de rédaction


2.3.2.5 OU exclusif (XOR)...................................................................................................................... 2-132.3.2.6 Sélection binaire (SEL)............................................................................................................... 2-142.3.2.7 Opérateurs SET (S) et RESET (R)............................................................................................. 2-14

2.3.3 Blocs fonctionnels...............................................................................................................2-152.3.3.1 Bascules RS et SR..................................................................................................................... 2-162.3.3.2 Détection de flancs R_TRIG et F_TRIG..................................................................................... 2-172.3.3.3 Temporisation TON et TOF......................................................................................................... 2-182.3.3.4 Générateur d'impulsion TP......................................................................................................... 2-192.3.3.5 Clignoteur BLINK........................................................................................................................ 2-19

3 Éléments de programmation 3-23.1 Représentation des nombres................................................................................................3-23.1.1 Binaires.................................................................................................................................3-33.1.2 Entiers...................................................................................................................................3-43.1.2.1 Entiers non signés........................................................................................................................ 3-43.1.2.2 Entiers signés............................................................................................................................... 3-4

3.1.3 Flottants.................................................................................................................................3-73.1.4 Autres codages.....................................................................................................................3-83.1.4.1 BCD.............................................................................................................................................. 3-83.1.4.2 Hexadécimal................................................................................................................................. 3-93.1.4.3 ASCII............................................................................................................................................. 3-93.1.4.4 Code de Grey.............................................................................................................................. 3-11

3.2 Variables et types................................................................................................................3-123.2.1 Déclaration des variables et constantes.............................................................................3-123.2.1.1 Codage des valeurs de constantes............................................................................................ 3-13

3.2.2 Les types standards............................................................................................................3-143.2.2.1 Numériques................................................................................................................................. 3-143.2.2.2 Date et heure.............................................................................................................................. 3-153.2.2.3 Chaînes de caractères................................................................................................................ 3-163.2.2.4 Énumération................................................................................................................................ 3-17

3.2.3 Tableaux ou matrices..........................................................................................................3-183.2.4 Composition des identifiants de variables..........................................................................3-193.3 Les opérateurs....................................................................................................................3-203.3.1 Ordre d'évaluation...............................................................................................................3-203.3.2 Affectation...........................................................................................................................3-213.3.3 Arithmétiques......................................................................................................................3-213.3.4 Numériques.........................................................................................................................3-223.3.5 Logiques..............................................................................................................................3-233.3.5.1 Sélection binaire......................................................................................................................... 3-23

3.3.6 De comparaison..................................................................................................................3-243.4 Les structures de contrôle...................................................................................................3-253.4.1 Le test de base IF ... THEN ... ELSE ... END_IF................................................................3-25

iv

heig-vdheig-vd IntroductionIntroduction ISAISA

3.4.2 Le test multiple CASE ... OF...............................................................................................3-273.4.3 La boucle FOR ... TO ... DO...............................................................................................3-283.4.4 La boucle WHILE ... DO......................................................................................................3-293.4.5 La boucle REPEAT ... UNTIL..............................................................................................3-303.5 Autres opérateurs................................................................................................................3-313.5.1 Changement de types.........................................................................................................3-313.5.1.1 Booléen autres types............................................................................................................ 3-313.5.1.2 Entiers vers types numériques................................................................................................... 3-313.5.1.3 REAL vers entiers....................................................................................................................... 3-323.5.1.4 Temps et dates vers types numériques...................................................................................... 3-323.5.1.5 Conversion des chaînes de caractères...................................................................................... 3-33

3.6 Les fonctions et procédures standards...............................................................................3-343.6.1 Conversion BCD.................................................................................................................3-343.6.2 Compteurs...........................................................................................................................3-343.6.2.1 Compteur CTU............................................................................................................................ 3-343.6.2.2 Compteur CTD............................................................................................................................ 3-363.6.2.3 Compteur CTUD......................................................................................................................... 3-37

3.6.3 Manipulation de chaînes de caractères..............................................................................3-383.6.3.1 Longueur d'une chaîne de caractères LEN................................................................................ 3-383.6.3.2 Caractères à gauche d'une chaîne LEFT................................................................................... 3-383.6.3.3 Caractères à gauche d'une chaîne RIGHT................................................................................. 3-383.6.3.4 Caractères au milieu d'une chaîne MID...................................................................................... 3-393.6.3.5 Concaténation de chaînes CONCAT.......................................................................................... 3-393.6.3.6 Insertion d'une chaîne dans une autre INSERT......................................................................... 3-393.6.3.7 Suppression d'une partie de chaîne DELETE............................................................................ 3-393.6.3.8 Recherche d'une chaîne dans une autre FIND........................................................................... 3-40

4 Programmation structurée 4-2

5 Annexes 5-25.1 Glossaire...............................................................................................................................5-25.2 Bibliographie.........................................................................................................................5-35.3 Webographie.........................................................................................................................5-3

v


IntroductionCe document est le support du cours d'informatique et d'automatisation industrielle ( ISA) pour les étudiants ingénieurs en systèmes industriels de la heig-vd. Ce cours vise à donner à l'étudiant des notions élémentaires d'informatique industrielle et les bases de programmation en langages normalisés IEC 61131-3 pour automates programmables. Le but et de lui fournir les éléments lui permettant pour comprendre et décrire le fonctionnement des systèmes de commandes automatiques simples.Le premier chapitre donne un bref historique de l'informatique et présente les notions élémentaires d'architectures des systèmes.Le deuxième chapitre décrit l'algèbre de Boole et introduit les notions élémentaires de programmation avec un langage graphique.Le troisième chapitre traite la représentation binaire des nombres entiers et en virgule flottante. Il aborde également les éléments de programmation en langage textuel structuré.Le quatrième chapitre introduit la programmation structurée et des notions d'analyse.

vi

heig-vdheig-vd ISAISA

Chapitre 2

Binaire etlogique combinatoire

2-1

ISAISA Binaire et logique combinatoireBinaire et logique combinatoire heig-vdheig-vd

22 Binaire et logique combinatoireBinaire et logique combinatoire

2.1 Les nombres binairesLes systèmes de traitement de l'information fonctionnent sur le principe de la commutation de signaux électriques : le circuit est ouvert ou fermé. L'informatique qui se base sur ces systèmes utilise des nombres représentés par des ensembles de chiffres binaires, appelés bits, qui ne peuvent prendre que deux valeurs 0 ou 1. L'analogie avec un circuit électrique est donnée dans le tableau ci-dessous :

État Alias Signification Exemple

0FauxFALSE

L (low)

Le circuit est ouvert:- la tension est nulle,- le courant ne passe pas

1VraiTRUE

H (high)

Le circuit est fermé:- la tension n'est pas nulle- le courant passe

2.2 Algèbre de BooleL'algèbre de Boole7 ou calcul booléen est utilisée pour traiter les expressions binaires. Cette algèbre défini un espace de donnée non vide B qui ne contient que deux valeurs :

B={0 ,1} (2.2.1)

Cet ensemble comporte deux lois de composition interne ou opérateurs (ET, OU) et une transformation (négation) qui satisfont à certaines propriétés.

2.2.1 Les opérateursLes différentes combinaisons des variables sont représentées par des tables de vérité qui définissent la valeur de la variable de sortie en fonction de la valeur des variables d'entrée. L’algèbre booléenne défini des opérateurs pour transcrire ces tables en expressions algébriques et les règles qui permettent de simplifier ces expressions.

7 George Boole [1815-1864]: logicien, mathématicien et philosophe britannique, créateur de la logique moderne.

2-2

U

I=0

U

I≠0

heig-vdheig-vd Binaire et logique combinatoireBinaire et logique combinatoire ISAISA

2.2.1.1 NON logique

La négation logique ou complément8 est un opérateur unaire, c'est-à-dire qu'il ne comporte qu'un seul opérande, qui donne pour résultat la valeur inverse de celle de l'opérande. L'opération S égale NON a se note :

S=a

Table de vérité

a S0 11 0

(2.2.2)

2.2.1.2 ET logique

Le ET logique ou produit logique ou conjonction est une opération binaire, à deux opérandes, qui donne pour résultat la valeur 1 si et seulement si les deux opérandes ont la valeur 1.L'opération S égale a ET b se note :

S=a⋅b

Table de vérité

b a S0 0 00 1 01 0 01 1 1

(2.2.3)

2.2.1.3 OU logique

Le OU logique ou somme logique ou disjonction est une opération binaire, à deux opérandes, qui donne pour résultat la valeur 1 si au moins l'un des deux opérandes a la valeur 1.L'opération S égale a OU b se note :

S=ab

Table de vérité

b a S0 0 00 1 11 0 11 1 1

(2.2.4)

Par convention il est défini que l'opération ET est prioritaire par rapport à l'opération OU, ainsi a⋅bc signifie a⋅b c , il n'est donc pas nécessaire de mettre des parenthèses s'il n'y a pas

d'ambiguïtés dans l'expression.

8 Les termes d'inversion ou de contraire sont également employés.

2-3


2.2.2 Règles et théorèmes2.2.2.1 Axiomes

Les 5 axiomes ou règles fondamentales de l'algèbre de Boole sont9 :i. La commutativité

- pour l'opérateur ET a⋅b=b⋅a - pour l'opérateur OU ab=ba

(2.2.5)

ii. L'associativité- pour l'opérateur ET a⋅b⋅c=a⋅b ⋅c=a⋅b⋅c - pour l'opérateur OU abc=ab c=abc

(2.2.6)

iii. Les éléments neutres- pour l'opérateur ET a⋅1=a - pour l'opérateur OU a0=a

(2.2.7)

iv. La distributivité- de l'opérateur ET par rapport à l'opérateur OU a⋅bc =a⋅b a⋅c mais également- de l'opérateur OU par rapport à l'opérateur OU ab⋅c =ab ⋅ac

(2.2.8)

v. La complémentarité- pour l'opérateur NON a=a - pour l'opérateur ET a⋅a=0 - pour l'opérateur OU aa=1

(2.2.9)

2.2.2.2 Théorèmes

1. Unicitéa est l'unique élément de B vérifiant a⋅a=0 et aa=1 (2.2.10)

2. L'idempotence- pour l'opérateur ET a⋅a=a - pour l'opérateur OU aa=a

(2.2.11)

3. Les éléments absorbants- pour l'opérateur ET a⋅0=0 - pour l'opérateur OU a1=1

(2.2.12)

4. L'absorption- pour l'opérateur ET a⋅ab =a - pour l'opérateur OU aa⋅b =a

(2.2.13)

5. La redondancea⋅ba⋅c=a⋅ba⋅cb⋅c et ab ⋅ ac =ab ⋅ac ⋅bc (2.2.14)

9 Une définition complète de ces règles ainsi que la démonstration des théorèmes peut être consultée sur http://www.sciences.ch/htmlfr/infotheorique/infosyslogiques01.php

2-4

http://www.sciences.ch/htmlfr/infotheorique/infosyslogiques01.php


2.2.2.3 Théorèmes de De Morgan

Les théorèmes de De Morgan10 ou lois de la dualité sont utilisés pour simplifier les expressions de la logique booléenne. Ils s'expriment comme suit :

Le complément d’une opération ET entre 2 opérandes est égal à

une opération OU du complément de chacun des opérandes :a⋅b=ab

et

Le complément d’une opération OU entre 2 opérandes est égal à

une opération ET du complément de chacun des opérandes :ab=a⋅b

Exemplesa) L'expression ab⋅c se transforme en a⋅b⋅c en appliquant le 2ème théorème de De Morgan, puis par

l'axiome de complémentarité a⋅b⋅c .

b) Réaliser la fonction Q=abc uniquement avec des opérateurs ET et NON :

Q=abc=abc=a⋅bc=a⋅bc=a⋅b⋅c=a⋅b⋅c

2.2.2.4 Principe de dualité

En algèbre de Boole tout résultat se présente sous 2 formes duales qui s'obtiennent en permutant systématiquement les opérateurs ET et OU ainsi que les valeurs 0 et 1.Si un résultat P est vrai, il en est de même pour son dual P*.

Exemples1. Soit P :∀a∈B , aa=a (règle d'idempotence) alors P * :∀ a∈B , a⋅a=a

2. Soit P :∀a ,b∈B , a⋅b=ab (théorème de De Morgan) alors P * :∀ a ,b∈B , ab=a⋅b

10 Augustus De Morgan [1806-1871]: mathématicien et logicien britannique, né en Inde. Il est le fondateur avec Boole de la logique moderne.

2-5


2.2.3 Synthèse d'une fonction logiqueUne fonction logique S(a, b, c, ..., k) peut être décrite par une table de vérité qui explicite la valeur de la fonction pour chacune des combinaisons de ses variables d'entrée. Pour une fonction logique à n entrées le nombre de combinaisons possibles est de 2n. Dans une table de vérité chaque ligne représente l'état de la (ou des) variable(s) de sortie correspondant à une et une seule combinaison des variables d'entrée.La synthèse d'une fonction logique, c'est à dire l'établissement de son équation caractéristique, peut être effectuée à partir de sa table de vérité:

• Chaque ligne de la table où la combinaison des variables d'entrées produit la valeur 1 pour la fonction S peut s'exprimer par un minterme Pn .Celui-ci est la fonction ET logique de toutes les variables d'entrée valant 1 et du complément des variables d'entrée valant 0.

• La forme canonique, c'est-à-dire non simplifiée, de l'équation de la fonction S est le OU logique de tous les mintermes: S=P1P2...P n

L’expression canonique de l’équation ainsi obtenue n’est pas forcément optimale car elle ne fait pas nécessairement intervenir un nombre minimal d’opérations logiques. Cette équation doit être simplifiée en appliquant les règles et théorèmes de la l’algèbre booléenne. La simplification est importante pour toute réalisation technique car du nombre d’opérations logiques dépend la complexité du système.

ExempleLa fonction majorité à 3 entrées S(a, b, c) est vraie si au moins deux des variables d'entrées sont vraies. Sa table de vérité est la suivante :c b a S Mintermes

0 0 0 0

0 0 1 0

0 1 0 0

0 1 1 1 P1=c⋅b⋅a

1 0 0 0

1 0 1 1 P2=c⋅b⋅a

1 1 0 1 P3=c⋅b⋅a

1 1 1 1 P4=c⋅b⋅a

L'équation canonique de cette fonction est : S=P1P2P3P4=c⋅b⋅a c⋅b⋅a c⋅b⋅a c⋅b⋅a La simplification par l'algèbre booléenne se fait comme suit :S=c⋅b⋅a c⋅b⋅a c⋅b⋅a c⋅b⋅a =[ c⋅b⋅a c⋅b⋅a ][ c⋅b⋅a c⋅b⋅a ][c⋅b⋅a c⋅b⋅a ]=[c⋅b⋅a c⋅b⋅a ][b⋅ c⋅a b⋅ c⋅a ][a⋅ c⋅b a⋅c⋅b ]=[ cc⋅ b⋅a ][bb ⋅c⋅a ][aa ⋅c⋅b ]

S=b⋅a c⋅a c⋅b

2-6


2.2.4 Réduction des équations, tables de KarnaughLa réduction des équations logiques par l’algèbre booléenne nécessite intuition et savoir-faire. Pour des équations comptant six variables ou moins, la méthode des tables de Karnaugh11 donne une approche visuelle et pratique de la simplification.La table de Karnaugh est une représentation matricielle de la table de vérité. Lignes et colonnes correspondent aux variables d’entrées, la valeur de la sortie est reportée dans les cases de la matrice. Pour 2, 3 et 4 variables la matrice est bidimensionnelle. Pour 5 et 6 variables d’entrée, la méthode peut également être appliquée mais elle nécessite une matrice tridimensionnelle ce qui fait qu'elle est beaucoup moins utilisée.Lorsqu’un système comporte plusieurs variables de sortie (S1, S2, etc.), il convient d’établir une table de Karnaugh pour chacune d’elles.

2 variables d'entrée (a, b) 3 variables d'entrée (a, b, c) 4 variables d'entrée (a, b, c, d)

Sa

0 1

b0

1

a, b

00 01 11 10

c0

1

Sa, b

00 01 11 10

c, d

00

01

11

10

5 variables d'entrée (a, b, c, d, e) 6 variables d'entrée (a, b, c, d, e, f)

Sa, b, c

000 001 011 010 110 111 101 100

d, e

00

01

11

10

Sa, b, c

000 001 011 010 110 111 101 100

d, e, f

000

001

011

010

110

111

101

100

Figure 2.2.1: Structure des tables de Karnaugh pour 2 à 6 variables d'entrée

Dans une table de Karnaugh, seule une variable change d'état lorsqu'on passe, horizontalement ou verticalement, d'une case à n'importe quelle autre case voisine. La numérotation des lignes et colonnes se fait selon le code de Gray ou binaire réfléchi, qui a comme propriété principale de ne faire varier qu'un seul bit entre deux mots successifs.

11 Maurice Karnaugh [1924- ]: physicien américain. A travaillé comme chercheur chez Bell Labs, auteur de la méthode de simplification des expression logiques.

2-7


Deux cases adjacentes dans une table de Karnaugh correspondent à des combinaisons qui diffèrent d'un seul bit du type x⋅y et x⋅y , ceci étant dû à l'utilisation du code de Grey. Ceci est valable non seulement à l'intérieur de la matrice mais également sur ses bords; en passant du bord droit au bord gauche ou du bas au haut il y a également adjacence. Cette table est à considérer comme la surface d'une sphère.Les figures ci-dessous illustrent le concept d'adjacence, les cases ombrées sont adjacentes à celle marquée d'une croix.Pour les tables à 4 variables, chaque case à toujours 4 cases adjacentes

Sa, b

00 01 11 10

c, d

00

01 X

11

10

Sa, b

00 01 11 10

c, d

00

01

11 X

10

Sa, b

00 01 11 10

c, d

00

01

11

10 X

Pour les tables à 5 variables, 5 cases adjacentes et pour 6 variables 6 cases adjacentes

Sa, b, c

000 001 011 010 110 111 101 100

d, e

00

01 X

11

10

Les cases adjacentes sont dans la symétrie par rapport à la ligne médiane entre les colonnes 010 et 110.

Sa, b, c

000 001 011 010 110 111 101 100

d, e, f

000

001

011 X

010

110

111

101

100

Les cases adjacentes sont dans les symétries par rapport à la ligne médiane- entre les colonnes 010 et 110 et - entre les lignes 010 et 110

Figure 2.2.2: Exemple de cases adjacentes dans les tables de Karnaugh

La méthode de simplification consiste à regrouper, par 2, 4, 8, 16 ou 32, les cases adjacentes contenant la valeur 1. L'expression logique x⋅y x⋅y définit deux cases adjacente et peut se simplifier en éliminant la variable qui change d'état :

x⋅y x⋅y=x⋅ y y =x (2.2.15)

2-8


Règles de regroupement1. Les rectangles de regroupement devront être les plus grand possibles. Un regroupement de

2 cases permet d'éliminer 1 variable, de 4 cases 2 variables, 8 case 3 variables et ainsi de suite.

2. Toutes les cases du tableau contenant la valeur 1 doivent être englobées dans au moins un groupe. Un groupe peut n'englober qu'une seule case isolée.

3. Une case peut appartenir à plusieurs blocs.4. Il est inutile de faire des groupes appartenant déjà à d'autres groupes, l'expression sera

alors redondante.5. Pour créer le terme définissant le groupe, seules les variables qui ne changent pas sont

conservées. Quand une variable a la valeur 1 on la note x et si elle a la valeur 0 on la note x .

6. L'expression logique de la fonction S est le OU de tous les termes des blocs effectués.

Exemples1. Simplifions la fonction majorité vue plus haut par la méthode des tables de Karnaugh

Sa, b

00 01 11 10

c0 0 0 1 0

1 0 1 1 1

Il y a 3 groupes de 2 cases à faire

G1=a⋅b

G2=a⋅c

G3=b⋅c

Ce qui donne finalement S=G 1G2G 3=a⋅ba⋅cb⋅c

2. Considérons la fonction de 4 variables donnée ci-dessousQ=a⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅da⋅b⋅c⋅d

Qa, b

00 01 11 10

c, d

00 1 0 1 1

01 0 0 1 0

11 0 1 1 0

10 1 1 1 0

Il y a 2 groupes de 4 cases à faire

G1=a⋅b

G2=b⋅c

et 2 groupes de 2 cases

G3=a⋅c⋅d ( est aussi possible G3 '=b⋅c⋅d )

G4=a⋅b⋅d ( est aussi possible G 4 '=a⋅c⋅d )

Ce qui donne finalement Q=G1G 2G3G 4=a⋅bb⋅ca⋅c⋅da⋅b⋅d

2-9


2.3 Langages de programmation graphiqueLes langages de programmation graphiques permettent d'écrire des programmes en assemblant des éléments fonctionnels représentés par des symboles avec des entrées et des sorties. Les liaisons ordonnées sont tracées par des lignes qui joignent la sortie d'un symbole à une ou plusieurs entrée d'autres symboles.La norme IEC 61131-3 défini 3 langages graphiques pour la programmation des automates :

• FBD (Function Block Diagram), schémas en blocs fonctionnels : représentation des expressions logiques ou arithmétiques sous forme de schémas de blocs de fonctions structurés en réseau. Les notions élémentaires de ce langage seront décrites dans ce chapitre, il sera utilisé pour réaliser quelques logigrammes utilisant la logique booléenne.◦ CFC (Continous Function Chart) est une implémentation des blocs fonctionnels

complémentaire à la norme. Les expression logiques et arithmétiques sont également décrites par des schémas de blocs de fonction mais ceux-ci peuvent être disposées librement. La représentation est de ce fait plus visuelle et plus claire. L'ordre d'exécution des instructions doit par contre être contrôlé pour éviter des aléas de fonctionnement des programmes.

• LD (Ladder Diagram), schémas à contacts : basé sur le principe des schémas électriques. Les expressions logiques sont traduites en réseaux de "contacts" qui commandent des "bobines". Des éléments de type bloc de fonction peuvent également être utilisés dans ces réseaux.

☞ Ce langage est obsolète et son utilisation n'est pas recommandée.• SFC (Sequential Function Chart), diagramme fonctionnel en séquence : implémentation

du langage GRAFCET pour la description de séquences. L'utilisation de ce langage sera détaillée dans le cours SEQ – Automatisme de séquences.

Les langages graphiques conviennent pour programmer des applications simples et linéaires, ils ne sont cependant pas adapté à la réalisation de programmes traitant des algorithmes complexes. Mais ils peuvent en revanche être utilisés pour structurer une application complexe en faisant appel à des blocs de fonction écrits dans d'autres langages.

2.3.1 Les variablesEn informatique les informations sont stockées en mémoire sous forme de séquences de bits plus ou moins longues. Pour accéder à ces informations les langages de programmation utilisent des variables qui attribuent un identificateur à une adresse ou position dans la mémoire de la machine. Les principales caractéristiques d'une variable informatique sont :

• Son identificateur est un nom unique qui désigne la variable,

• Son type indique ce que contient la variable,• Son adresse est l'endroit de la mémoire où elle

est rangée,• Sa valeur est le contenu de la zone de mémoire

correspondante,Dans ce chapitre seules les variables de type booléen (BOOL) seront abordées, la manière de déclarer les variables et la présentation des autres types est traitée au chapitre 3.2.

2-10

Adresses Identificateur Mémoire

%MW1763 ...

%MW1764 ReponseUltime 42

%MW1765

...

Figure 2.3.1: Adressage d'une variable en mémoire


2.3.1.1 Déclaration des variables

Les langages informatiques structurés imposent que les variables d'un programme soient être déclarées à priori, c'est-à-dire avant de les utiliser dans l'écriture du programme. Dans l'environnement de développement CoDeSys la déclaration des variables locales se fait dans la partie supérieure de la fenêtre d'édition des programmes. Les variables utilisées dans le module peuvent être déclarées dans un tableau à 7 colonnes :

Figure 2.3.2: Tableau de déclaration de variables

Les colonnes contiennent les informations suivantes :1. Un numéro d'ordre,2. Le genre de la variable,3. Le nom de la variable ou de l'instance,4. L'adresse mémoire ou de la ressource si elle doit être fixée,5. Le type de la variable ou de l'instance,6. Une valeur initiale si elle doit être imposée,7. Un commentaire.

2.3.2 Opérateurs logiquesEn langage FBD les opérateurs logiques et autres fonctions sont symbolisés par des blocs ayant une ou plusieurs entrées et une ou plusieurs sorties. Ces éléments sont combinés et interconnectés par des liaisons pour créer un diagramme réalisant une fonction.Les diagrammes fonctionnels sont structurés en réseaux, unité de base du programme, qui contiennent une structure représentant une expression logique ou arithmétique, un appel à un module de programmation (fonction, bloc fonctionnel, programme), une instruction de saut ou de retour.Le programme est constitué d'une liste de réseaux qui se suivent. L'interprétation de ces réseaux se fait naturellement de gauche à droite puis de haut en bas. Chaque réseau est numéroté sur sa partie gauche. Chaque réseau peut être documenté à l'aide d'un commentaire et, en option, identifié par une étiquette qui sera donnée comme adresse de destination pour une instruction de saut.

2-11


Les opérateurs, qu'ils soient logiques, arithmétiques, de comparaison, de contrôle ou autres, sont les codes de base du programme définis par la norme. Chaque opérateur est défini par un mot clé réservé ou par un symbole selon le langage de programmation, par exemple le mot clé AND correspond à l'opérateur ET logique.

2.3.2.1 Affectation

L'opération d'affectation consiste à attribuer une valeur à une variable. Cette valeur peut être une constante ou le contenu d'une autre variable. En langage FBD chaque liaison entre blocs fonctionnels ou avec une variable est une affectation.

ExempleLa valeur de la variable xA est copiée dans la variable xS.

2.3.2.2 Négation (NOT)

L'opérateur de négation donne la valeur inverse de la variable. En langage FBD l'opérateur de négation peut se présenter soit sous forme d'un bloc avec une entrée et une sortie soit, et c'est la forme la plus utilisée, par un cercle au début ou à la fin d'une liaison.

ExempleL'inverse de la valeur de la variable xA est copiée dans la variable xS.

xS=xA

Deux formes d'écriture sont possibles :• En haut comme bloc de fonction,• En bas le cercle du côté de xS indique la négation.

2-12

Figure 2.3.3: Exemple de schéma en blocs fonctionnels


2.3.2.3 ET logique (AND)

L'opérateur ET logique donne la valeur TRUE si et seulement si toutes ses entrées sont à la valeur TRUE.L'opérateur AND se présente sous la forme d'un bloc marqué du symbole "&" avec au moins deux entrées et une sortie. Si nécessaire le nombre d'entrées peut être augmenté pour réaliser une fonction ET de plusieurs variables.

ExempleLa variable xS. reçoit le résultat de l'opération xA AND xB.

xS=xA⋅xB

2.3.2.4 OU logique (OR)

L'opérateur OU logique donne la valeur TRUE si au moins l'une ses entrées est à la valeur TRUE.L'opérateur OR se présente sous la forme d'un bloc marqué du symbole "≥1" avec au moins deux entrées et une sortie. Si nécessaire le nombre d'entrées peut être augmenté pour réaliser une fonction OU de plusieurs variables.

ExempleLa variable xS. reçoit le résultat de l'opération xA OR xB.

xS=xAxB

2.3.2.5 OU exclusif (XOR)

L'opérateur OU exclusif donne la valeur TRUE si une et une seule de ses entrées est à la valeur TRUE. Cet opérateur n'est pas un opérateur de base de l'algèbre booléenne c'est une fonction de deux variables définie par :

S=a⋅ba⋅b=a⊕ b (2.3.1)

L'opérateur XOR se présente sous la forme d'un bloc marqué du symbole =1 avec deux entrées et une sortie.

ExempleLa variable xS. reçoit le résultat de l'opération xA XOR xB.

xS=xA⊕ xB

2-13


2.3.2.6 Sélection binaire (SEL)

L'opérateur de sélection binaire SEL est une fonction logique de trois variables qui simule un commutateur :

• lorsque l'entrée G est à la valeur FALSE la sortie reçoit la valeur de l'entrée IN0, • dans le cas contraire lorsque G est à TRUE la sortie reçoit la valeur de l'entrée IN1.

L'opérateur SEL se présente sous la forme d'un bloc avec trois entrées et une sortie.

ExempleLa variable xS. reçoit la valeur de xA quand xE est FALSE,elle reçoit la valeur de xB quand xE est TRUE.

2.3.2.7 Opérateurs SET (S) et RESET (R)

Ces deux opérateurs sont complémentaires :• S (SET) attribue la valeur TRUE à la variable lorsque sa valeur d'entrée est TRUE,• R (RESET ) attribue la valeur FALSE à la variable lorsque sa valeur d'entrée est TRUE,• Ils ne modifient pas la variable si leur entrée est FALSE.☞ Attention ☜

Ces opérateurs ne doivent pas être utilisés sur des variables dont l'affectation de valeur est le résultat de calculs d'autres opérateurs. Réciproquement les variables qui sont modifiées par les opérateurs S et R ne doivent pas être utilisées pour stocker le résultat d'autres opérateurs, le fonctionnement du programme serait imprévisible.L'utilisation de ces opérateurs est délicate et il est préférable d'employer les blocs fonctionnels SR et RS décrits au paragraphe 2.3.3.1.

ExempleLa variable xS. reçoit la valeur TRUE quand xA est TRUE,elle ne change pas de valeur quand xA est FALSE.

La variable xS. reçoit la valeur FALSE quand xA est TRUE,elle ne change pas de valeur quand xA est FALSE.

2-14


2.3.3 Blocs fonctionnelsLes fonctions et blocs fonctionnels sont des éléments complémentaires au langage de programmation, ils sont définis dans des bibliothèques. Un opérateur est reconnu implicitement par le système de programmation alors qu'une fonction ou un bloc fonctionnel est une partie de programme prédéfini qui devra être chargé à partir d'une bibliothèque (standard.lib, util.lib, etc.).Les blocs fonctionnels sont appelés au moyen d'une instance qui est un alias du bloc fonctionnel. Chaque instance est identifiée de manière unique par une étiquette. Chaque sorte de bloc fonctionnel défini une structure de données qui contient ses variables d'entrée et de sortie ainsi que ses variables internes.Comme une variable, une instance de bloc fonctionnel doit être déclarée pour être utilisée. Chaque instance a un nom unique d'identification, son type est indiqué par le nom du bloc fonctionnel.

2-15


2.3.3.1 Bascules RS et SR

Les blocs fonctionnels SR (SET-RESET) et RS (RESET-SET) sont des bascules utilisées pour mémoriser une information. Le fonctionnement de ces bascules est décrit par les tables de vérité ci-dessous :

S R Q Q+

0 0 0 0

0 0 1 1

0 1 0 0

0 1 1 0

1 0 0 1

1 0 1 1

1 1 0 1

1 1 1 1

Figure 2.3.4: Table de vérité d'une bascule SR

S R Q Q+

0 0 0 0

0 0 1 1

0 1 0 0

0 1 1 0

1 0 0 1

1 0 1 1

1 1 0 0

1 1 1 0

Figure 2.3.5: Table de vérité d'une bascule RS

• Les entrées S (SET) et R (RESET) sont à 0 la sortie Q ne change pas d'état,• L'entrée R est à 1 et l'entrée S à 0 la sortie Q passe à 0,• L'entrée R est à 0 et l'entrée S à 1 la sortie Q passe à 0,• Lorsque les 2 entrées R et S sont à 1 le comportement diffère selon le type de bascule

◦ RS, RESET prédominant, la sortie Q passe à 0,◦ SR, SET prédominant, la sortie Q passe à 1.

Les blocs fonctionnels RS et SR font partie de la bibliothèque standard.lib, l'instance chargée dans le programme doit être déclarée avec le type RS, respectivement SR.

ExempleLa variable xS ne change pas d'état quand xA et xB sont FALSE,La variable xS reçoit la valeur TRUE quand xA est TRUE et xB est FALSE,elle reçoit la valeur FALSE quand xB est TRUE.

ExempleLa variable xS ne change pas d'état quand xA et xB sont FALSE,La variable xS reçoit la valeur TRUE quand xA est TRUE,elle reçoit la valeur FALSE quand xB est TRUE et xA est FALSE,

2-16


2.3.3.2 Détection de flancs R_TRIG et F_TRIG

Les blocs fonctionnels R_TRIG et F_TRIG détectent le changement d'état d'une variable booléenne. Lorsque la variable connectée à l'entrée CLK passe de l'état FALSE à l'état TRUE, le bloc fonctionnel R_TRIG détecte le flanc montant et positionne sa sortie Q à l'état TRUE pendant un cycle de l'automate. Le bloc fonctionnel F_TRIG effectue une opération identique pour le passage de l'état TRUE à l'état FALSE.Les blocs fonctionnels R_TRIG et F_TRIG font partie de la bibliothèque standard.lib, l'instance chargée dans le programme doit être déclarée avec le type R_TRIG, respectivement F_TRIG.

Exemples

La détection de flancs montant ou descendant peut être ajoutée directement à l'entrée des opérateurs ou des blocs fonctionnels en utilisant des entrées dynamisées.

Le symbole placé devant une entrée indique une détection de flanc montant et le symbole une détection de flanc descendant.

ExempleOpérateur OU avec détection du flanc montant de la variable xA et du flanc descendant de la variable xB.

2-17

t1 cycle

automate

xA

xS

TRUE

TRUE

FALSE

FALSE

t1 cycle

automate

xA

xS

TRUE

TRUE

FALSE

FALSE


2.3.3.3 Temporisation TON et TOF

Le bloc fonctionnel TON est un temporisateur à l'enclenchement. Lorsque l'entrée IN devient TRUE, une durée définie par l'entrée PT s'écoule avant que la sortie Q passe à TRUE. La sortie Q passe immédiatement à FALSE quand l'entrée IN devient FALSE.Le bloc fonctionnel TOF est un temporisateur au déclenchement. Lorsque l'entrée IN devient FALSE, une durée définie par l'entrée PT s'écoule avant que la sortie Q passe à FALSE. La sortie Q passe immédiatement à TRUE quand l'entrée IN devient TRUE.La sortie ET donne la valeur instantanée de la temporisation.L'entrée IN et la sortie Q sont de type booléen (BOOL) alors que l'entrée PT et la sortie ET sont associées à une variables de temps, elles sont de type TIME, type utilisé pour les variables ou les constantes contenant une valeur de temps. La valeur d'un temps s'écrit avec le symbole T# placé devant la valeur exprimée en millisecondes (ms), secondes (s), minutes (m), heures (h) ou jours (d).Les blocs fonctionnels TON et TOF font partie de la bibliothèque standard.lib, l'instance chargée dans le programme doit être déclarée avec le type TON, respectivement TOF.

Exemples

L'enclenchement est retardé de 3 minutes.

Le déclenchement est retardé de 25 secondes.

2-18

xA

xS

t

ET

PT PT

xA

xS

t

ET

PT PT


2.3.3.4 Générateur d'impulsion TP

Le bloc fonctionnel TP (Time Pulse) est un générateur d'impulsion. Lorsque l'entrée IN passe à TRUE, une impulsion d'une durée définie par l'entrée PT est générée sur la sortie Q.L'entrée IN et la sortie Q sont de type booléen (BOOL) alors que l'entrée PT et la sortie ET sont de type TIME.Le bloc fonctionnel TP fait partie de la bibliothèque standard.lib, l'instance chargée dans le programme doit être déclarée avec le type TP.

Exemple

L'impulsion dure 1.2 s

2.3.3.5 Clignoteur BLINK

Le bloc fonctionnel BLINK (clignoteur) génère un signal périodique quand l'entrée ENABLE est à TRUE. La sortie OUT est à TRUE pendant un temps défini par l'entrée TIMEHIGH puis passe à FALSE pendant une durée définie par l'entrée TIMELOW, et le cycle continue tant que l'entrée ENABLE est à TRUE.L'entrée ENABLE et la sortie OUT sont de type booléen (BOOL) alors que les entrées TIMELOW et TIMEHIGH sont de type TIME.Le bloc fonctionnel BLINK fait partie de la bibliothèque util.lib, l'instance chargée dans le programme doit être déclarée avec le type BLINK.

Exemple

2-19

xA

xS

t

ET

PT PT PT

xA

xS

t

TL

TH

TL TL TL

TH THTH TH


2-20

heig-vdheig-vd ISAISA

Chapitre 3

Éléments deprogrammation

3-1

ISAISA Éléments de programmationÉléments de programmation heig-vdheig-vd

33 Éléments de programmationÉléments de programmation

3.1 Représentation des nombresLes systèmes numériques de traitement de l'information fonctionnent avec des circuits logiques et arithmétiques binaires. Ces circuits ne connaissent 2 états 'faux' ou 'vrai'. En associant l'état 'faux' au chiffre '0' et 'vrai' au chiffre '1' il est possible de représenter les nombres en base 2. Le chiffre binaire, appelé bit, est l'objet de donnée élémentaire en informatique.Le bit qui représente la plus grande valeur, c'est à dire le bit situé le plus à gauche d'un nombre binaire est le bit de poids fort (MSB: Most Significant Bit), respectivement le bit le plus à droite est le bit de poids faible (LSB: Least Significant Bit).

Exemple8910= 1

MSB

0 1 1 0 0 1LSB

2

La taille des nombres est fixée par des contraintes matérielles liées aux caractéristiques du processeur et de la mémoire. Cette taille varie entre 4 et 64 bits pour les microprocesseurs, elle peut même être de 128 voir 256 bits pour dans les grands ordinateurs scientifiques.Les microcontrôleurs destinés à être embarqués dans des appareils portatifs travaillent avec des nombre comptant entre 4 et 32 bits pour des raisons de limitation de consommation d'énergie.Un processeur travaille avec des registres. Ces éléments servent au stockage des informations qui seront utilisées par le processeurs. La taille des nombres est définie par le nombre de bits des registres du processeur. C'est une des caractéristiques du processeur.

ExemplesLe premier microprocesseur Intel 4004 était un processeur de 4 bits (2300 transistors),Le microcontrôleur PIC12Fxxx est un processeur de 8 bits,La famille des Pentium 4 qui équipe les PC est à 32 bits,Les ordinateurs actuels de haute performances sont basés sur des processeurs 64 bits (Intel Core 2, 600 million de transistors !).

Une terminologie est associée à l'ensemble de bits d'un registre de processeur ou de mémoire:4 bits : quartet (nibble)8 bits : octet (byte)16 bits: mot (word)32 bits: double mot (dword : double word)64 bits: mot long (lword : long word)

3-2

heig-vdheig-vd Éléments de programmationÉléments de programmation ISAISA

3.1.1 BinairesDans un ordinateur les variables binaires peuvent être stockée de différentes manières.La première consiste à utiliser un bit d'un registre pour enregistrer une variable binaire, cette solution utilise judicieusement la mémoire.Notation : le bit X du mot W est noté W:X

ExempleNuméro du bit k 15 14 13 12 11 10 9 8 7 6 5 5 3 2 1 0

Adresse 479 . . . . . . . . . X . . . . . .

Le bit 6 du mot d'adresse 479 se note⇧479:6

Un autre solution consiste à utiliser un registre entier pour représenter une valeur binaire, par convention tous les bits du registre à '0' représentent la valeur FALSE, la valeur TRUE est donnée si au moins un des bit du registre est à '1'. Cette solution accélère les opérations arithmétiques effectuées par le processeur qui n'a pas besoin d'adresser individuellement chaque bit, bien évidemment l'utilisation de la mémoire n'est pas optimale.

ExemplesXA = 0000 0000 0000 0000 = FALSE (Faux)XB = 1000 0000 = TRUE (Vrai)XC = 0000 0000 0000 0000 0000 0000 0000 0001 = TRUE (Vrai)XD = 1111 1111 1111 1111 = TRUE (Vrai)

Les systèmes destinés aux commandes industrielles doivent traiter une grande quantité de variables binaires. Pour optimiser le temps de traitement et l'utilisation de la mémoire une solution retenue par certains constructeurs consiste à coder les variables binaires sur 4 bits.Un bit contient la valeur de la variable, un autre indique si la variable est forcée (sa valeur est fixée par l'opérateur et ne peut pas être modifiée par le programme), les deux derniers sont utilisés pour indiquer un flanc montant ou descendant.

3-3


3.1.2 EntiersLes nombres entiers peuvent être représentés sous forme binaire. En informatique deux représentations sont utilisées : les entiers non signés et les entiers signés.3.1.2.1 Entiers non signés

Le binaire pur permet de représenter simplement les nombres entiers naturels ℕ qui sont les nombres entiers positifs ou nuls. Avec n bits il est ainsi possible de représenter les 2n valeurs comprises entre 0 et 2n – 1. Le nombre entier positif N est représenté par:

N= xn−1⋅2n−1xn−2⋅2

n−2...x1⋅21x0⋅2

0=∑k=0

n−1

xk⋅2k ∣ N ∈[0 ; 2n−1]⊂ℕ (3.1.1)

avec x∈[0 ,1 ] et n = nombre de bits.

Figure 3.1.1: Plage de valeurs entiers non signés

ExempleReprésentation binaire du nombre décimal 8910 dans un mot (16 bits):

Numéro du bit k 15 14 13 12 11 10 9 8 7 6 5 5 3 2 1 0

Valeur binaire xk 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 1

3.1.2.2 Entiers signés

La représentation des nombres entiers relatifs ℤ (nombres entiers positifs, nuls ou négatifs) peut se faire de la même manière en utilisant un bit pour le signe.Signe et valeur absolueUne relation possible consiste à prendre par convention le bit le plus significatif comme bit de signe en lui attribuant la valeur '0' pour les nombres positifs et la valeur '1' pour les nombres négatifs. Les autres bits sont utilisés pour représenter la valeur absolue du nombre. Les nombre entiers peuvent être ainsi représentés par:

N=−1xn−1signe

⋅∑k=0

n−2

xk⋅2k

(3.1.2)

Cette relation permet de coder avec n bits les nombres entiers compris dans l'intervalle:

N ∈[−2n−1−1 ;2n−1−1]Mais cette relation présente plusieurs inconvénients. D'une part elle n'est pas univoque, en effet le nombre '0' possède 2 représentations : +0 et -0. D'autre part le résultat de l'addition binaire d'un nombre positif N ≥ 0 et d'un nombre négatif M < 0 ne donne pas un résultat correct.

3-4

ℕ0 2

n-1


ExempleCodage sur 8 bits des nombre N = 89 et M = -26 selon la relation "signe et valeur absolue" décrite ci-dessus:

N=8910=−10

signe

⋅[1⋅260⋅251⋅241⋅230⋅220⋅211⋅20] = 0101 10012

M =−2610=−11

signe

⋅[0⋅260⋅251⋅241⋅230⋅221⋅210⋅20] = 1001 10102

Addition binaire de N et M

reports → 1 1N → 0101 1001M → 1001 1010 +

Résultat → 1111 0011

Décodage du résultatR=1111 0011 2=−1

1signe

⋅[1⋅261⋅251⋅240⋅230⋅221⋅211⋅20] =−[64321621] =−11510 ≠89−26 =6310

Complément à unLe complément à un N ou complément restreint d'un nombre binaire N est le nombre obtenu en inversant la valeur de chaque bit.

ExempleEffectuons l'addition binaire du nombre N = 89 et du complément à un du nombre M = 26.Complément à un du nombre M = 26 codé sur 8 bits:

M = 0001 1010M = 1110 0101

Nous constatons que le bit le plus significatif du nombre complémenté à un prend la valeur ' 1', ce qui selon la définition de notre précédente relation indique un nombre négatif.Addition binaire de N et M

reports → 1 1 1N → 0101 1001

M → 1110 0101 +Résultat → (1) 0111 1110

Décodage du résultat, le 9ème bit résultant des reports n'est pas pris en considérationR=0111 11102=1

0signe

⋅[1⋅261⋅251⋅241⋅231⋅221⋅210⋅20] =[643216842 ] =6210 = 89−26−1

En utilisant le complément à un pour représenter un nombre négatif nous constatons que le résultat de l'addition est inférieur d'une unité au résultat correct.

3-5


Complément à deuxLe complément à deux N − ou complément vrai d'un nombre binaire N est défini par:

N −=N1 (3.1.3)

Le complément à deux d'un nombre entier peut être assimilé à son opposé et vérifie la relation:

NN−= 0 (3.1.4)

ExempleComplément à un du nombre 0 codé sur 8 bits:

0 = 0000 00000 = 1111 1111

Complément à deux du nombre 0 codé sur 8 bits:0−=01= 1111 1111 0000 0001

reports → 1 1 1 1 1 1 1 10 → 1111 11111 → 0000 0001 +

Résultat → (1) 0000 0000

Nous constations que 0 = 0− ce qui lève l'ambiguïté de la représentation du nombre '0'.

La forme générale de la représentation en complément à deux d'un nombre binaire codé sur n bits permet de représenter les 2n valeurs comprises entre -2n-1 et 2n-1 – 1.Le nombre entier relatif N est représenté par:

N=−xn−1⋅2n−1[ xn−2⋅2

n−2...x1⋅21x0⋅2

0]=−xn−1⋅2n−1

signe

∑k=0

n−2

xk⋅2k

∣ N ∈[−2n−1 ;2n−1−1]⊂ℤ(3.1.5)

avec x∈[0 ,1 ] et n = nombre de bits.

Figure 3.1.2: Plage de valeurs entiers signésExempleCodage sur 8 bits des nombre N = 89 et M = -26 selon la relation "complément à deux" décrite ci-dessus:

N =8910=−0⋅27

signe

[1⋅260⋅251⋅241⋅230⋅220⋅211⋅20] = 0101 10012

M−=−2610=−1⋅27

signe

[1⋅261⋅250⋅240⋅231⋅221⋅210⋅20] = 1110 01102

Addition binaire de N et M

reports → 1 1 N → 0101 1001M- → 1110 0110 +

Résultat → (1) 0011 1111

Décodage du résultat, le 9ème bit résultant des reports n'est pas pris en considération. R=0011 11112=−0⋅2

7signe

[0⋅261⋅251⋅241⋅231⋅221⋅211⋅20] = [32168421 ] =6310

Le résultat de l'addition est correct.

3-6

ℤ0 2

n-1-1-2

n-1


3.1.3 FlottantsPour effectuer les calculs scientifiques et techniques il nécessaire de pouvoir représenter des nombres Y qui ne sont pas entiers. Les nombres en virgule flottante représentent une partie des nombres rationnels ℚ , seuls ceux dont la forme irréductible est N⋅2− z ont une représentation exacte, les autres ont une représentation approchée. Cela signifie que le nombre de valeurs représentables est fini, les résultats des calculs sont nécessairement arrondis.

Exemples

Le nombre 58= 0.62510 = 2

−12−3 = 0.1012 a une représentation exacte,

par contre 25= 0.410 = 2

−22−32−62−72−102−11...= 0.0110 0110 0110 ...2 = 0.0110 2 ne peux pas être

représenté exactement avec un nombre fini de bits car la séquence surlignée se répète indéfiniment.

La notation en flottant permet de représenter ces nombres. Les nombres en virgule flottante F sont représentés par la relation:

F=−1S⋅M⋅2E (3.1.6)

Un nombre flottant est caractérisé par 3 groupes de bits: S le signe, M la mantisse et E l'exposant. La précision de la représentation dépend du nombre de bits alloués à la mantisse.

Signe Exposant Mantisse

La norme IEEE 754 standardise plusieurs formats de représentation des nombres en virgule flottante dont la simple précision codée sur 32 bits et la double précision codée sur 64 bits. Au nombre de bits utilisés près le schéma de codage est identique pour tous les formats.

Simple précision Double précision

Taille Bits Intervalle Taille Bits Intervalle

Registre 32 64

Signe S 1 x31 [0;1] 1 x63 [0;1]

Exposant E 8 x30..x23 [-126;+127] 11 x62...x52 [-1022;+1023]

Mantisse M 23 x22..x0 [0.0;1.0[ 52 x51..x0 [0.0;1.0[

Le bit de signe S à '0' indique un nombre positif, inversement à '1' il indique un nombre négatif.Afin de pouvoir comparer entre eux les nombre en virgule flottante, l'exposant E est représenté sous forme d'un nombre entier positif décalé. Ce décalage permet l'utilisation d'exposants négatifs et positifs.A l'exclusion du nombre zéro, la valeur de l'exposant peut être choisie de manière à ce que la mantisse M soit comprise entre 1.0 et 2.0 , cela implique que le bit de poids fort de la mantisse a toujours la valeur '1'. Dans ce cas la mantisse est dite normalisée. Le bit de poids fort peut alors être omis et la résolution gagne un bit.Pour représenter les très petits nombres compris entre 2-149 et 2-126 (simple précision) la norme autorise de ne pas normaliser la mantisse, l'exposant est égal à '0' dans ce cas.

3-7


La norme prévoit également quelques cas particuliers:• Lorsque tous les bits de l'exposant sont à '1' et tous les bits de la mantisse à '0' cela indique

une valeur ±∞ .• Lorsque tous les bits de l'exposant sont à '1' et tous les bits de la mantisse ne sont pas à '0'

cela indique une valeur impossible ou indéterminée (NaN : Not a Number) : division par zéro, racine d'un nombre négatif.

Le tableau ci-dessous résume les différentes représentations en virgule flottante selon la norme IEEE 754:

Exposant Mantisse Nombre représenté Cas

E0 =0 ±0 Zéro

E0 ≠0 F=−1S⋅[0M ]⋅2E MIN Dénormalisé (petites valeurs)

E0≠E≠E1 ≠0 F=−1S⋅[1M ]⋅2E−EMAX Normalisé

E1 =0 ±∞ Infini

E1 ≠0 NaN Indéterminé

Avec:– E0 : tous les bits de l'exposant à '0',– E1 : tous les bits de l'exposant à '1',– EMIN : -126 en simple précision, -1022 en double précision,– EMAX : 127 en simple précision, 1023 en double précision.

3.1.4 Autres codagesLes données traitées par un ordinateur ne sont pas toujours des nombres, d'autre part la représentation des nombres en binaire n'est pas très pratique à manipuler pour l'humain. Pour ces raisons un certain nombres de codes basés sur des suites de bits sont utilisés.3.1.4.1 BCD

Le code BCD (Binary Coded Decimal) conserve la représentation décimale d'un nombre (centaines, dizaines, unités...), mais chaque chiffre de ce nombre est reproduit en binaire.Comme chaque rang d'un nombre décimal (unités, dizaines, centaines...) peut contenir un chiffre de 0 à 9, chaque rang du code BCD sera représenté par quatre chiffres binaires (de 0000 à 1001), donc quatre bits.Ce codage est utilisé pour des entrées-sorties de données numériques (clavier et afficheur), chaque chiffre étant représenté par un groupe de signaux la manipulation des données est simplifiée.

ExempleCodage du nombre entier N = 143910 En binaire naturel sur 16 bits N = 0000 0101 1001 11112En BCD sur 4x4 bits : N = 0001 0100 0011 1001BCD

3-8


3.1.4.2 Hexadécimal

La notation hexadécimale permet une représentation plus compacte et plus lisible des nombres. La numération hexadécimale utilise les 10 chiffres de 0 à 9 et les 6 premières lettres de l'alphabet pour représenter les 16 chiffres. Ce format est largement utilisé en informatique car la conversion avec le système binaire est très simple.

Décimal Binaire Hexadécimal0 0000 01 0001 12 0010 23 0011 34 0100 45 0101 56 0110 67 0111 78 1000 89 1001 910 1010 A11 1011 B12 1100 C13 1101 D14 1110 E15 1111 F

3.1.4.3 ASCII

Le code ASCII (American Standard Code for Information Interchange) a été défini pour représenter les caractères alphanumériques, les signes de ponctuation ainsi que des caractères de contrôle. Le code ASCII de base est codé sur 7 bits, il permet de représenter 128 codes:

– 00H à 1FH : caractères de contrôle correspondent à des directives de terminal,– 30H à 39H : les chiffres 0 à 9,– 41H à 5AH : lettres majuscules A...Z,– 61H à 7AH : lettres minuscules a...z (Il suffit de modifier le 6ème bit pour passer de

majuscules à minuscules).Le code ASCII a été mis au point pour la langue anglaise, il ne contient donc pas de caractères accentués, ni de caractères spécifiques à une langue.

_0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F

0_ NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI1_ DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US2_ SP ! " # $ % & ' ( ) * + , - . /

3_ 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

4_ @ A B C D E F G H I J K L M N O

5_ P Q R S T U V W X Y Z [ \ ] ^ _

6_ ` a b c d e f g h i j k l m n o

7_ p q r s t u v w x y z { | } ~ DEL

3-9


Caractères de contrôle00 NUL : Null, nul01 SOH : Start Of Header, début d'entête02 STX : Start of Text, début du texte03 ETX : End of Text, fin de texte04 EOT : End Of Transmission, fin de transmission05 ENQ : Enquiry, demande06 ACK : Acknowledge, accusé de réception07 BEL : Bell, caractère d'appel, sonnerie08 BS : Backspace, espacement arrière09 HT : Horizontal Tab, tabulation horizontale0A LF : Line Feed, saut de ligne0B VT : Vertical Tab, tabulation verticale0C FF : Form Feed, saut de pageOD CR : Carriage Return, retour début de ligne (retour de chariot)0E SO : Shift Out, fin d'extension0F SI : Shift In, début d'extension10 DLE : Data Link Escape, libération de communication11 DC1 : Device Control 1, contrôle d'équipement12 DC2 : Device Control 2,13 DC3 : Device Control 3,14 DC4 : Device Control 4,15 NAK : Negative Acknowledge, accusé de réception négatif16 SYN : Synchronous Idle, attente de synchronisation17 ETB : End of Transmission Block, fin du bloc de transmission18 CAN : Cancel, annulation19 EM : End of Medium, fin de support1A SUB : Substitute, substitution1B ESC : Escape, échappement1C FS : File Separator, séparateur de fichier1D GS : Group Separator, séparateur de groupe1E RS : Record Separator, séparateur d'enregistrement1F US : Unit Separator, séparateur d'unité20 SP : Space, espace (caractère blanc)7F DEL : Delete, effacement

ExtensionsDe nombreuses normes de codage de caractère ont repris ASCII pour base, et défini d'autres caractères pour les codes supérieurs à 127. En particulier, beaucoup de pages de codes étendent l'ASCII en utilisant le 8ème bit pour définir des caractères numérotés de 128 à 255. La norme ISO/CEI 8859 fournit des extensions pour diverses langues.ISO-8859-1 ou Latin1En première approximation, ISO 8859-1, aussi appelée Latin-1, étend US-ASCII en ajoutant les caractères accentués et recouvre les principaux caractères utilisés par les langues européennes comme le français ou l'allemand.Le nom Latin1 est une appellation informelle non reconnue par l'organisation ISO ou IANA, mais utilisée par certains logiciels.Note: La norme finale ISO-8859-1 est disponible sur http://anubis.dkuug.dk/JTC1/SC2/WG3/docs/n411.pdf .

3-10

http://anubis.dkuug.dk/JTC1/SC2/WG3/docs/n411.pdf


Unicode et ISO/CEI 10646La norme informatique Unicode (Universal Character Set) standardise la représentation de tous les caractères de tous les systèmes d'écriture et de langue. Cette norme est principalement destinée aux logiciels de traitement de texte pour permettre l'interopérabilité de la représentation des textes sur des systèmes hétérogènes. Le codage de l'extension des caractères se fait sur 16 bits.Note: Pour des informations plus détaillée voir http://fr.wikipedia.org/wiki/Unicode.

3.1.4.4 Code de Grey

Le code de Gray, ou code binaire réfléchi, est un code binaire qui a la propriété de ne changer qu'un seul bit lorsque le nombre est augmenté ou diminué d'une unité.Ce code est utilisé principalement pour les codeurs de position. Si on utilise le code binaire standard pour ces appareils il y a risque d'apparition de valeurs erronées lors des transitions puisqu'il n'est pas possible de garantir la transition simultanée de 2 bits.

Binaire Gray 23 22 21 20

0 0000 0000

1 0001 0001

2 0010 0011

3 0011 0010

4 0100 0110

5 0101 0111

6 0110 0101

7 0111 0100

8 1000 1100

9 1001 1101

10 1010 1111

11 1011 1110

12 1100 1010

13 1101 1011

14 1110 1001

15 1111 1000

3-11

http://fr.wikipedia.org/wiki/Unicode


3.2 Variables et typesUne variable est un symbole qui identifie une position mémoire dans laquelle le programme stocke ou va chercher des informations. Le type d'une variable spécifie la nature de l'information représentée par une variable, c'est-à-dire la façon de coder cette information pour la représenter par une suite de bits de longueur variable.

3.2.1 Déclaration des variables et constantesUne variable doit être déclarée avant d'être utilisée. En général cette déclaration se fait dans une zone réservée à cet effet, l'entête du programme, elle consiste à :

• Donner un identifiant, un nom, à la variable. Cet identifiant peut être de longueur quelconque et doit respecter les règles de syntaxe suivantes12 :◦ être unique dans un module,◦ ne pas être un mot-clé du langage,◦ être constitué que de lettres ('A'..'Z'), de chiffres ('0'..'9') ou du souligné ('_'),

▪ les lettres majuscules et minuscules ne sont pas différentiées,◦ commencer par une lettre ou un souligné.

• Attribuer un type de données.Dans la déclaration des variables il est également possible :

• De donner une valeur initiale à la variable,• D'associer la variable à une ressource de l'équipement (mappage): adresse mémoire fixe,

entrée ou sortie physique.La déclaration des variables se fait entre les deux-mots clés13 VAR et END_VAR selon la syntaxe suivante :VAR {}

{AT } : {:= } ;

END_VAR

Note : les parties entre accolades {...} sont facultatives.

La déclaration permet également de définir la nature des variables au moyen d'attributs :• CONSTANT : les variables avec cet attribut sont des constantes en lecture seule,• RETAIN : ces variables sont rémanentes, elles gardent leur valeur quand le programme est

arrêté puis redémarré,• PERSISTANT : ces variables sont persistantes, elles gardent leur valeur même quand un

autre programme est chargé dans l'appareil.

Des commentaires explicatifs peuvent être ajoutés aux déclarations de variables.

12 Ces règles de déclaration sont celles de la norme IEC 61131, elles peuvent être différentes pour d'autre langages de programmation.

13 Par convention dans ce polycopié le mots clés du langage sont écrit en MAJUSCULES gras

3-12


Un commentaire d'une seule ligne commence avec le symbole "//". Un commentaire d'une ou plusieurs ligne est placé entre les symboles "(*" et "*)".

ExemplesVAR

(* Déclaration de variables *)xA : BOOL ; // Variable booléennexB : BOOL ; // Autre variable booléennexC : BOOL := TRUE; // Variable initialisée avec la valeur TRUExD : BOOL ;Boom AT %IX13,2 : BOOL ; (* Variable mappée à l'entrée physique %IX13,2

de l'appareil *)ReponseUltime AT %MW1764 : INT := 42 ; (* Variable de type entier mappée

à l'adresse mémoire %MW1764 et initialisée à la valeur 42 *)

(* Déclaration d'instances *)FctA : FONCTION_A ; // Instance de bloc fonctionnelBLK1 : BLINK ; // Instance d'un autre bloc fonctionnel

END_VAR

VAR CONSTANT(* Déclaration de constantes *)crPI : REAL := 3.141592654 ; // Nombre Pi

END_VAR

3.2.1.1 Codage des valeurs de constantes

Les valeurs des constantes peuvent être données sous différente formes :• Booléenne : xA := TRUE;• Entière : iK := 27;• Binaire : iK := 2#00011011;• Hexadécimale : iK := 16#1B;• En virgule flottante :

rY := 3.14159; rZ := 5.0; // Le point décimal est nécessaire • De temps : tHeure := t#2h30m16s;• De date : dtJour := d#2011-02-25;• Chaîne de caractères : sTG := 'Ceci est une chaîne de caractères';

3-13


3.2.2 Les types standardsLes types de données standards décrits dans la norme se divisent en quatre groupes:

• Booléen (BOOL), vu au chapitre précédent,• Numériques, entiers et virgule flottante,• Datation, temps et date,• Chaines de caractères.

Pour améliorer la structure et la compréhension du code des programmes il est possible de créer des variables

• Définies dans un domaine de validité partiel,• Énumérées,• Structurées, présentées au chapitre 4.

3.2.2.1 Numériques

Les types de variables numériques distinguent les types entiers signés ou non et les types en virgule flottante. Les tableaux ci-dessous présentent ces différents types et les limites de la plage numérique.Types entiers non signés

Type Taille Minimum Maximum Remarque

BYTE

USINT8 0 255 Octet

WORD

UINT16 0 65'535 Mot

DWORD

UDINT32 0 4'294'967'295 Double mot

LWORD

ULINT64 0 264 – 1 Mot long

Types entiers signésType Taille Minimum Maximum Remarque

SINT 8 -128 127 Entier court

INT 16 -32'768 32'767 Entier

DINT 32 -2'147'483'648 2'147'483'647 Entier double

LINT 64 -263 263 – 1 Entier long

Les constantes entières peuvent être données sous forme décimale, binaires ou hexadécimales. Une constante binaire commence par le code "2#" suivi de 0 et de 1. Une constante hexadécimale commence par le code "16#" suivi de chiffres de 0 à 9 et de lettres de a à f.

ExemplesbA : BYTE := 156; // en décimaliB : INT := 2#10011100; // en binairewC : WORD := 16#9c; // en hexadécimal

3-14


Types virgule flottanteType Taille Négatifs Positifs Remarque

REAL 32-3.402823466 10+38

-1.175494351 10-381.175494351 10-38

3.402823466 10+38Simple précision

LREAL 16-1.7976931348623158 10+308

-2.2250738585072014 10 -3082.2250738585072014 10 -308

1.7976931348623158 10+308Double précision

Les constantes en virgule flottante s'écrivent avec un point décimal "."

ExemplescrPI : REAL := 3.141592654; // en décimalclrRU : LREAL := 42.0; // Le point décimal "." est nécessaire

3.2.2.2 Date et heure

Les dates et heures ont un codage particulier sur 32 ou 64 bits, le type doit être choisi en fonction de l'utilisation de la variable.

Type Taille Spécifications

TIME 32 Temps relatif exprimé en millisecondes.

DATE 32

Date absolue spécifiée en secondes, comptabilisé en secondes depuis le 1er janvier 1970.

La spécification de date se fait selon le format D#

DATE_AND_TIME

DT32

Date et heure absolue spécifiée en secondes, comptabilisé en secondes depuis le 1er janvier 1970.

La spécification de date se fait selon le format DT#

TIME_OF_DAY

TOD32

Heure absolue spécifiée en millisecondes, comptabilisé en millisecondes depuis 00:00:00.000 heures.

La spécification de l'heure se fait sous le formatTOD#

LTIME 64 Temps relatif exprimé en nanosecondes.

Les constantes exprimant un temps commencent par le symbole "T#" ou "t#" suivi d'une valeur de temps exprimée en utilisant les symboles :

• "d" pour les jours,• "h" pour les heures,• "m" pour les minutes,• "s" pour les secondes,• "ms" pour les millisecondes,• "us" pour les microsecondes (utilisable seulement avec le type LTIME),• "ns" pour les nanosecondes (idem).

3-15


ExemplestTemps1 : TIME := T#2d16h7m45s741ms; // Déclaration complètetTemps2 : TIME := t#4h26s; // Il n'est pas obligatoire de spécifier tous

// les champstTemps3 : TIME := T#123m35s; // Dépassement sur le rang supérieur autorisédD_debut : DATE := D#1993-09-15; // Date sans les heuresdDelai : DATE_AND_TIME := DT#2011-06-30-23:59:59; // Date et heuredDelaiRecours : DT := DT#2011-07-20-12:00; // - forme également reconnuetHeureCourante : TIME_OF_DAY := TOD#17:32:48; // HeuretHeure_Fin : TOD := TOD#21:36:15.520; // forme également reconnueltTempoRapide : LTIME := T#1258ns; // Temps exprimé en nano ou microsecondes

3.2.2.3 Chaînes de caractères

Les chaînes de caractères ASCII, étendu codé sur 8 bits, sont stockées dans des variables de type STRING. Le type WSTRING est une extension qui permet de stocker des chaînes de caractère au formant Unicode codé sur 16 bits.La longueur de la chaîne de caractères peut être spécifiée entre parenthèses lors de la déclaration de la variable, par défaut cette longueur est de 80 caractères. La longueur d'une chaîne de caractères est comprise entre 1 et 255.Les constantes définissant une chaîne de caractères sont délimitées par des guillemets simples. Le signe dollar "$" suivi de deux chiffres hexadécimaux ou de certains caractères est utilisé pour coder les caractères spéciaux :

Combinaison Interprétation

$ Représentation hexadécimale du code d'un caractère

Exemple : $04 – ␄ : End Of Transmission

$A9 – © : signe copyright$$ Signe dollar $

$' Guillemet simple

$L " : Saut à la ligne$N : Nouvelle ligne

$P # : Saut de page$R $ : Retour automatique à la ligne$T ! : Tabulation

ExemplessCdC1 : STRING := 'Chaîne de caractères'; // Chaîne de 80 caractères par défautsChCar : STRING(35):= 'Déclaration d$'un guillemet simple' //Chaîne de 35 caractèressDollar : STRING := 'Le signe $$ dollar doit être doublé pour être défini'sUnicode : WSTRING :='Utilisation de la palette Unicode : ≋⇒Ω☺♣ '

3-16


3.2.2.4 Énumération

Les énumérations sont des types de données correspondant à des ensembles restreints de valeurs. Les énumérations sont définies pour l'ensemble d'un projet et sont déclarées globalement comme objet DUT (Data Type Unit).Une énumération est constituée par une liste de chaines de caractères associées à une valeur ordinale.La déclaration des énumérations se fait dans l'éditeur de types entre les deux-mots clés TYPE et END_TYPE selon la syntaxe suivante :TYPE

: (, {:=


3.2.3 Tableaux ou matricesLes variables d'un même type peuvent être regroupées en tableaux (ou matrices) à une, deux ou trois dimensions. L'accès aux données se fait au moyen d'index qui pointent sur la case souhaitée.La déclaration d'un tableau de variables se fait entre les deux-mots clés VAR et END_VAR selon la syntaxe suivante :VAR

: ARRAY [..{,..{,..}}] OF {:= [,, ... } ;

END_VAR

Note : les parties entre accolades {...} sont facultatives.

Les valeurs b1, t1, b2, t2 et b3, t3 sont des nombres entiers qui fixent les bornes du tableau. La numérotation des cases commence à la valeur de b1, b2 et b3 et se termine à la valeur de t1, t2 et t3.Les valeurs initiales des éléments d'un tableau peuvent être attribuées lors de sa déclaration. Ces valeurs sont données dans une liste; si plusieurs éléments consécutif ont la même valeur une notation abrégée permet de simplifier l'écriture (voir exemple).

ExemplesVAR

axV : ARRAY[0..63] OF BOOL; // tableau à 1 dimension de 64 valeurs BOOLaiT1 : ARRAY[1..5] OF INT := [10,11,12,13,14]; // 1 dimension et initialisationaiT2 : ARRAY[0..1, 5..6] OF INT := [4,3(7)]; // écriture abrégée de // l'initialisation [4,7,7,7]aiT3 : ARRAY[1..2,1..2,1..2] OF INT := [2(0),4(5),2,3]; // écriture abrégée de [0,0,5,5,5,5,3,4]// équivalent à faire :// aiT[1,1,1]=0; aiT[1,1,2]=0; aiT[1,2,1]=5; aiT[1,2,2]=5;// aiT[2,1,1]=5; aiT[2,1,2]=5; aiT[1,2,1]=3; aiT[1,2,2]=4;arZ : ARRAY [1..3, 25..29] OF REAL;

END_VAR;

25 26 27 28 29

1 2.35 7.20 8.39 4.39 8.42

2 6.94 4.15 5.24 1.20 7.18

3 1.45 9.12 2.01 2.57 2.91

arZ // Tableau de valeurs REAL

La lecture de la valeur contenue dans la case marquée (ligne 2, colonne 27) du tableau arZ se fait par l'instruction suivante :il := 2; // Index ligneic := 27; // Index colonnerX := arZ[ii,ij];

3-18

[il,ij];[il, ic];


3.2.4 Composition des identifiants de variablesL'identifiant d'une variable est une suite de caractères (lettres, chiffres et souligné) qui doit respecter les règles syntaxiques décrites au paragraphe 3.2.1.La "notation hongroise" est une recommandation qui décrit les règles de nommage des variables. Dans son principe cette recommandation propose de composer le nom des variables comme suit:

• un préfixe standardisé indique la ressource attribuée et le type de la variable. Ce préfixe est composé de lettres minuscules, la première indique la ressource et les suivantes le type.

• le nom de base donne une brève description correspondant au contenu. Chaque première lettre des mots composant le nom de base commence par une majuscule.

Le nom des instances est composé en utilisant comme préfixe le nom du bloc suivi d'un numéro ou d'un nom de base en minuscules.Les noms des types définis par l'utilisateur sont écrits entièrement en majuscules.Le tableau ci-dessous indique les préfixes usuels :Préfixe Ressource,

type de donnéesCommentaire

i entrée physique Variable associée à une entrée physique de l'automatem mémoire Variable associée à une adresse fixe de la mémoire automateq sortie physique Variable associée à une sortie physique de l'automateg globale Variable globalec constante Valeur constantea tableau (ARRAY) Tableau de variablesx BOOL Variable booléenne, 1 bitb BYTE ou USINT Variable de 8 bits non signéw WORD ou UINT Variable de 16 bits non signédw DWORD ou UDINT Variable de 32 bits non signélw LWORD ou ULINT Variable de 64 bits non signési SINT Entier de 8 bits signéi INT Entier de 16 bits signédi DINT Entier de 32 bits signéli LINT Entier de 64 bits signér REAL Variable en virgule flottante sur 32 bitslr LREAL Variable en virgule flottante sur 64 bitss STRING Chaîne de caractèrest TIME

TIME_OF_DAY, TODVariable contenant un temps, attention les types TIME et TOD ne sont pas compatibles

lt LTIME Variable contenant un temps codé sur 64 bitsdt DATE

DATE_AND_TIMEVariable contenant une date

e Type énuméré

Lorsqu'une variable correspond à plusieurs critères définis dans cette liste, le préfixe sera composé de plusieurs lettres qui se suivent selon l'ordre de la liste ci-dessus: par exemple un tableau d'entiers à une adresse fixe de la mémoire sera nommé maiNomTableau.

3-19


3.3 Les opérateursUn programme est la séquence des actions que doit exécuter un processeur. Cette séquence est définie par une suite d'instructions écrite en un langage informatique répondant à une syntaxe stricte. Chaque instruction est composée d'expressions qui comprennent au moins un opérateur défini par un symbole (+, –, *, =) ou un mot clé du langage (SIN, SQRT, AND, ...). Cet opérateur agit sur des opérandes qui sont soit une constante, une variable, un appel de fonction ou une autre expression.Dans le langage IEC 61131-3 ST, chaque instruction se termine par un point-virgule ";". La syntaxe générale d'une instruction est :

{} {} ;

Il est possible d'écrire plusieurs instructions sur une seule ligne.

3.3.1 Ordre d'évaluationL'ordre d'évaluation des expressions suit des règles de priorité déterminées similaires à celles de l'arithmétique. L'opérateur qui a la priorité la plus élevée est évalué en premier, puis le suivant en respectant l'ordre jusqu'à ce que tous les opérateurs aient étés évalués. Si des opérateurs sont de même rang, ils sont évalués de gauche à droite selon le sens de l'écriture.L'ordre des priorités est :

1. Mise entre parenthèses : (), priorité la plus élevée2. Appel de fonction : ()3. Exponentiation : EXPT(,)4. Négation : – 5. Complément logique : NOT6. Multiplication : *7. Division : /8. Reste entier de la division : MOD9. Addition : +10.Soustraction : –11. Inférieur à : <12.Supérieur à : >13. Inférieur ou égal à : =15.Égal à : =16.Différent de : 17.ET logique : AND18.OU exclusif : XOR19.OU logique : OR , priorité la moins élevée

3-20


3.3.2 AffectationL'opérateur d'affectation attribue la valeur d'une expression à une variable. Cet opérateur est symbolisé par ":=" et la syntaxe d'une instruction d'affectation est :

:= ;

L'opérateur d'affectation peut

Documents

ISA Informatique et systèmes automatisés - cours, examenscours-examens.org/images/Etudes_superieures/Ingenieur_en... · 2017. 7. 6. · Département TIN Technologies Industrielles