Systèmes séquentiels et commande numérique

Une partie commande a deux métiers. Elle enchaîne des opérations : ouvrir une porte, indexer une table, pousser un colis ; c'est le domaine des systèmes séquentiels, décrits par des diagrammes d'états. Elle asservit des grandeurs : un niveau, une température, une position ; c'est le domaine des systèmes asservis, dont le correcteur est aujourd'hui un programme. Les deux métiers sont exécutés par un calculateur qui ne voit le procédé qu'à des instants séparés et ne connaît que des nombres entiers : la scrutation d'un automate est un échantillonnage, la mesure d'un codeur est quantifiée, la commande d'un correcteur est bloquée entre deux calculs. Ce chapitre décrit d'abord le séquentiel, puis le calculateur qui l'exécute, puis ce que l'échantillonnage et la quantification coûtent à une boucle d'asservissement.

7.1 Diagramme d'états et chronogramme

Le diagramme d'états est la description graphique du comportement séquentiel employée en ingénierie système (langage SysML). Il permet de s'affranchir d'un langage de programmation particulier : le même diagramme se programme sur un automate, un microcontrôleur ou un variateur. La syntaxe SysML n'est pas exigible : la structure d'un diagramme est toujours fournie, à lire, à compléter ou à modifier.

Exemple 7.2Cycle d'une presse

Une presse attend l'ordre de départ dcy ; si le carter de protection est fermé, elle descend jusqu'au capteur bas, maintient la pression deux secondes, puis remonte jusqu'au capteur haut.

Si l'opérateur appuie sur dcy carter ouvert, la garde est fausse : l'événement est perdu, et il faudra appuyer de nouveau une fois le carter fermé. C'est voulu : un ordre ne doit pas rester en mémoire et déclencher la presse plus tard, par surprise.

Le chronogramme de la presse (descente et remontée de $1,5\mathrm{s}$) se lit colonne par colonne : dcy fait passer de « Repos » à « Descente », l'activité descendre dure jusqu'à ce que bas devienne vrai, le maintien dure exactement deux secondes, et le cycle complet $5\mathrm{s}$.

7.2 États composites, régions parallèles et modes de marche

Un diagramme d'états plat devient illisible dès que le système a plusieurs postes ou plusieurs modes. Trois structures suffisent à couvrir le reste.

Les modes de marche.

Un équipement industriel ne se contente pas de produire : il démarre, s'arrête proprement en fin de cycle, se met en sécurité sur un arrêt d'urgence, se laisse régler. On décrit ces modes par des états composites : « Arrêt », « Production », « Défaillance ». L'arrêt d'urgence part de la frontière de « Production » : il la quitte quel que soit l'état du cycle de production, sans qu'il faille l'écrire depuis chacun de ses sous-états.

7.3 Programmer un diagramme d'états : la scrutation

Un automate programmable exécute son programme dans une boucle sans fin, de période le temps de cycle $T_c$ (quelques millisecondes à quelques dizaines de millisecondes).

Coder un diagramme d'états.

On représente l'état actif par une variable, et l'on calcule l'état suivant par une structure conditionnelle portant sur l'état courant. Un front montant de l'entrée $p$ se détecte en comparant la lecture du cycle à celle du cycle précédent : p and not p_prec. Pour la presse : {

etat, dcy_prec = "REPOS", False
while True:
    dcy, carter, bas, haut = lire_entrees()      # image des entrees
    front = dcy and not dcy_prec
    if etat == "REPOS" and front and carter:
        suivant = "DESCENTE"
    elif etat == "DESCENTE" and bas:
        suivant = "MAINTIEN" ; t0 = horloge()
    elif etat == "MAINTIEN" and horloge() - t0 >= 2.0:
        suivant = "REMONTEE"
    elif etat == "REMONTEE" and haut:
        suivant = "REPOS"
    else:
        suivant = etat
    etat, dcy_prec = suivant, dcy
    ecrire_sorties(descendre = (etat == "DESCENTE"),
                   monter = (etat == "REMONTEE"))

La structure if … elif porte sur l'état courant : une seule branche est exécutée, donc une seule transition par cycle. Des if indépendants laisseraient la presse franchir deux transitions dans le même cycle si deux conditions étaient vraies ensemble.

7.4 Signaux à temps discret : échantillonnage et quantification

Mesurer une vitesse par comptage.

Un codeur de $N$ incréments par tour lu toutes les $T_e$ donne la vitesse par la différence de deux comptages (dérivation numérique par le schéma arrière) : ${\Omega }_k=\frac{N_k-N_{k-1}}{N{T}_e}$. Son quantum, $\frac{1}{N{T}_e}$ tour par seconde, est grossier : la dérivation dégrade la résolution. La différence sur $n$ périodes, $\frac{N_k-N_{k-n}}{nN{T}_e}$, est la moyenne glissante des $n$ dernières différences : elle divise le quantum par $n$ et retarde la mesure d'environ $n{T}_e/2$.

7.5 Commande numérique : bloqueur, retard et limites du modèle continu

Les équations aux différences des correcteurs.

Elles sont établies avec les correcteurs continus, en remplaçant la dérivée par le schéma arrière ; on les rappelle, pour une période $T_e$ et l'écart $e_k$ :

• proportionnel $C(p)=K_p$ : $u_k=K_p{e}_k$ ;
• proportionnel intégral $C(p)=K_p\left(1+\frac{1}{T_{i}p}\right)$ : $u_k=u_{k-1}+K_p\left[\left(1+\frac{T_e}{T_i}\right)e_k-e_{k-1}\right]$ ;
• avance de phase $C(p)=K_c\frac{1+aTp}{1+Tp}$ : $u_k=\frac{T{u}_{k-1}+K_c\left[(T_e+aT)e_k-aT{e}_{k-1}\right]}{T+T_e}$.

Le gain statique se lit au point fixe ($u_k=u_{k-1}$, $e_k=e_{k-1}$) : $u=K_{c}e$ pour l'avance de phase ; pour le proportionnel intégral, le point fixe impose $e=0$, c'est l'écart statique nul.

Les limites du modèle continu.

Quand $T_e$ augmente, le modèle continu (même corrigé du retard $T_e/2$) cesse de dire vrai. Sur une cuve de section $S$ réglée par un correcteur proportionnel ($\tau =S/K$ en continu), la récurrence exacte donne ${\epsilon }_{k+1}=\left(1-\frac{T_e}{\tau }\right){\epsilon }_k$ : la boucle oscille dès que $T_e>\tau$ et devient instable pour $T_e\ge 2\tau$, alors que le modèle continu est stable à tout gain, et que le modèle du retard ne prévoit l'instabilité que pour $T_e=\pi \tau$. Le modèle du retard $T_e/2$ n'est fiable que pour ${\omega }_c{T}_e$ petit (de l'ordre de $0,1$, soit une perte de $3^{\circ }$) ; au-delà, on vérifie sur la récurrence exacte, par simulation.

La quantification de la commande.

Une commande qui ne prend que des valeurs entières de pas (trains d'ondes, convertisseur numérique-analogique) ne peut pas, en général, produire exactement la valeur d'équilibre. Avec un correcteur intégral, l'écart s'accumule jusqu'à faire changer la commande d'un pas, puis dans l'autre sens : la grandeur réglée oscille en cycle limite, d'amplitude d'autant plus faible que le pas est fin. Le modèle linéaire ne le prévoit pas.

7.6 Complément (hors programme) : Grafcet, GEMMA et langages d'automates

Le programme décrit le séquentiel par des diagrammes d'états. L'industrie française emploie aussi le Grafcet (norme CEI 60848), qu'on rencontre dans la documentation des machines ; ce complément en donne les bases et la correspondance avec les diagrammes d'états. Il n'est pas exigible.

Figure : Séquence Grafcet linéaire avec boucle de retour.

Structures et modes de marche.

Le Grafcet a ses structures : le choix (divergence en OU, réceptivités exclusives), le parallélisme (divergence en ET, double barre ; la convergence en ET est un rendez-vous), le saut et la reprise. Le guide GEMMA organise les modes de marche en trois familles, procédures d'arrêt (A), de fonctionnement (F) et de défaillance (D) ; un Grafcet de conduite en découle et commande le Grafcet de production par forçage. Les états composites « Arrêt », « Production », « Défaillance » d'un diagramme d'états jouent le même rôle.

Figure : Parallélisme en ET dans un Grafcet, et structuration des modes de marche par le GEMMA.

Équations d'activation.

Pour programmer un Grafcet dans un automate, on écrit pour chaque étape $n$ une équation booléenne de mémoire :

$$X_n={\mathrm{CA}}_n+X_n\cdot \overline{{\mathrm{CD}}_n},{\mathrm{CA}}_n=\sum _{k\in \text{Preˊc}(n)}{X}_k\cdot r_{k\to n},$$

où $X_n$ (à droite) est la valeur au cycle précédent. La condition de désactivation ${\mathrm{CD}}_n$ s'écrit, selon la convention, ${\sum }_j{X}_n\cdot r_{n\to j}$ (franchissement d'une transition aval) ou, plus simplement, ${\sum }_j{X}_j$ (une étape suivante est active) ; les deux conventions ne se mélangent pas dans une même équation.

7.7 Synthèse du chapitre

• Un diagramme d'états décrit un comportement séquentiel par des états, des transitions (événement [garde] / action), des actions instantanées et des activités qui durent. Une transition est franchie quand son événement survient, son état source actif et sa garde vraie ; un événement sans transition est perdu ; after(d) se compte depuis la dernière entrée.
• Le chronogramme trace l'état actif et les variables : c'est sur lui que se vérifient les exigences temporelles.
• Les gardes d'un choix sont exclusives et complètes. Un état composite à régions parallèles s'achève sur un rendez-vous : sa durée est le maximum de celles de ses régions. Les modes de marche sont des états composites ; l'arrêt d'urgence part de la frontière.
• Un automate scrute : lire, calculer, écrire sur l'image des entrées. Une transition au plus par cycle, un temps de réponse entre $T_c$ et $2T_c$, et une condition $f\le 1/(2T_c)$ pour ne pas perdre d'impulsion.
• Un signal numérique est échantillonné (repliement au-delà de $f_e/2$, filtre anti-repliement) et quantifié (quantum $E/2^n$, résolution d'un codeur) ; une moyenne glissante divise le quantum et retarde de la moitié de sa fenêtre.
• En commande numérique, le correcteur est une récurrence ; le bloqueur retarde en moyenne de $T_e/2$ et retranche ${\omega }_c{T}_e/2$ à la marge, trois fois plus avec un retard de calcul d'une période. Le modèle continu n'est valable que pour ${\omega }_c{T}_e$ petit ; au-delà, on revient à la récurrence exacte. Une commande quantifiée et un intégrateur créent un cycle limite.

7.8 Travaux dirigés

Exercice 1 — La porte palière de métro : lire un diagramme d'états, puis le modifier

Sur le quai d'une ligne de métro automatique, une façade de verre sépare les voyageurs de la voie ; chaque porte de la façade s'ouvre en face d'une porte du train. Un vantail met $2,0\mathrm{s}$ à s'ouvrir entièrement et $3,0\mathrm{s}$ à se fermer entièrement, à vitesse constante. Deux fins de course donnent les conditions fc_ouvert et fc_fermé ; le variateur du moteur émet l'événement obstacle quand l'effort de fermeture dépasse un seuil (le vantail bute sur un voyageur ou un sac). La commande de la porte est décrite par le diagramme d'états fourni ; autorisation est émis par le pilotage automatique quand le train est arrêté en face de la porte.

L'action bip déclenche un signal sonore d'une seconde. Cahier des charges de l'exploitant :

Exigence	Niveau
stationnement, de `autorisation` à la porte fermée	$\le 25\mathrm{s}$, même avec un obstacle
vantail qui bute pendant la fermeture	réouverture automatique
nouvel obstacle après une réouverture	porte isolée, agent appelé

1) Tracer le chronogramme d'un stationnement sans obstacle : état actif, moteur ouvrir, moteur fermer, bip. Que vaut le temps de stationnement ?

2) Un voyageur retient le vantail $1,5\mathrm{s}$ après le début de la fermeture. Combien de temps dure la réouverture ? Tracer le chronogramme et calculer le temps de stationnement. Que fait la commande si le variateur émet obstacle pendant l'état Ouverture (un voyageur heurte le vantail qui s'ouvre) ? Est-ce souhaitable ?

3) Modifier la commande. On ajoute une variable entière $n$, deux états Réouverture (do/ moteur ouvrir) et Réouverte, où la porte reste ouverte $3\mathrm{s}$, et un état Défaut (entry/ appel agent ; porte isolée). Écrire les étiquettes des transitions nouvelles ou modifiées. Calculer le temps de stationnement avec un obstacle, puis avec deux obstacles si l'on autorisait deux réouvertures automatiques.

4) Dresser le tableau exigence / valeur / écart pour la commande d'origine et la commande modifiée, et conclure.

Démonstration (Corrigé)

La stratégie. Un diagramme d'états se lit en suivant l'état actif : à chaque instant, on cherche quel événement peut survenir, et si une transition issue de l'état actif l'attend. Le chronogramme est le résultat de cette lecture ; c'est lui qu'on compare au cahier des charges.

1) Le stationnement nominal. À $t=0$, autorisation survient avec la garde vraie : Ouverture devient actif et son activité moteur ouvrir dure jusqu'à fc_ouvert, soit $2,0\mathrm{s}$. À $t=2,0\mathrm{s}$, Ouverte devient actif ; l'événement after(12 s) survient $12\mathrm{s}$ après cette entrée, à $t=14,0\mathrm{s}$. L'entrée dans Fermeture exécute l'action bip (le signal sonne de $14$ à $15\mathrm{s}$) et lance l'activité moteur fermer, qui dure $3,0\mathrm{s}$. La porte est fermée à

$$t_{\text{stat}}=2,0+12+3,0=17,0\mathrm{s}\le 25\mathrm{s}.$$

On distingue ici les deux mots du programme : une action (bip, à l'entrée) est instantanée, même si elle déclenche un appareil qui sonne une seconde ; une activité (do/ moteur fermer) dure autant que l'état.

2) Un obstacle. Le vantail a parcouru $1,5/3,0$, soit la moitié de sa course de fermeture ; il la refait à la vitesse d'ouverture, en $0,5\times 2,0=1,0\mathrm{s}$. La transition obstacle ramène dans Ouverture : la porte est ouverte à $14+1,5+1,0=16,5\mathrm{s}$. Le point délicat est l'événement after(12 s) : il se compte depuis la dernière entrée dans Ouverte, et cette entrée vient d'avoir lieu. La porte reste donc encore $12\mathrm{s}$ ouverte, puis se ferme en $3,0\mathrm{s}$ :

$$t_{\text{stat}}=2,0+12+1,5+1,0+12+3,0=31,5\mathrm{s}>25\mathrm{s}.$$

Les deux chronogrammes : (a) sans obstacle, celui de la question 1 ; (b) avec l'obstacle ($\mathrm{Ou}$ : ouverture, $\mathrm{Fe}$ : fermeture).

Obstacle pendant l'ouverture. Aucune transition issue de Ouverture n'attend obstacle : l'événement est perdu, et le vantail continue de s'ouvrir. C'est le comportement voulu : s'ouvrir dégage le voyageur. Un diagramme d'états ne réagit qu'aux événements que l'état actif attend ; ce qui n'est pas écrit n'a pas lieu.

3) La commande modifiée. Les étiquettes (structure de la question) :

Transition	Étiquette
`Fermée` vers `Ouverture`	`autorisation [train à quai] / n := 0`
`Fermeture` vers `Réouverture`	`obstacle [n < 1] / n := n + 1`
`Réouverture` vers `Réouverte`	`when(fc_ouvert)`
`Réouverte` vers `Fermeture`	`after(3 s)`
`Fermeture` vers `Défaut`	`obstacle [n >= 1]`

L'ancienne transition obstacle de Fermeture vers Ouverture disparaît. Les deux gardes $[n<1]$ et $[n\ge 1]$ sont exclusives (jamais vraies ensemble : le comportement ne dépend pas de l'ordre d'évaluation) et complètes (l'une des deux est toujours vraie : aucun obstacle n'est perdu pendant la fermeture). La remise à zéro de $n$ se fait sur la transition d'entrée du stationnement, pas dans Fermée, pour qu'elle ait lieu une seule fois par train.

Avec un obstacle à $1,5\mathrm{s}$ de fermeture :

$$t_{\text{stat}}=2,0+12+1,5+1,0+3+3,0=22,5\mathrm{s}\le 25\mathrm{s}.$$

Si l'on autorisait deux réouvertures (garde $[n<2]$), un second obstacle dans les mêmes conditions ajouterait $1,5+1,0+3=5,5\mathrm{s}$ : $28,0\mathrm{s}>25\mathrm{s}$. Une seule réouverture automatique tient le temps de stationnement ; la seconde obstruction relève d'un agent, ce que demande aussi la troisième exigence.

4) Bilan.

Exigence	Commande d'origine	Commande modifiée
stationnement $\le 25\mathrm{s}$ sans obstacle	$17,0\mathrm{s}$ : tenue	$17,0\mathrm{s}$ : tenue
stationnement $\le 25\mathrm{s}$ avec un obstacle	$31,5\mathrm{s}$ : non tenue	$22,5\mathrm{s}$ : tenue
réouverture sur obstacle	oui	oui
obstruction répétée	réouvertures sans fin	`Défaut`, agent appelé

Le défaut d'origine n'était pas une durée mal choisie : c'était la sémantique de after(12 s), réarmé à chaque entrée dans l'état. On l'a corrigé en changeant la structure (un état de plus), pas une valeur.

Ce que l'exercice installe. Lire un diagramme d'états en suivant l'état actif ; distinguer l'événement (ce qui déclenche), la garde (ce qui autorise) et l'action (ce qui est fait, instantanément), et l'action de l'activité ; savoir qu'un after() repart de zéro à chaque entrée et qu'un événement sans transition est perdu ; écrire des gardes exclusives et complètes ; juger une commande sur son chronogramme, exigence par exigence.