COMMANDE
EN TEMPS RÉEL
COMMAN DE EN TEMPS RÉEL
Daniel TSCHIRHART
Agrégé de génie électrique Professeur de Chaire supérieure
Collection dirigée Christian PANETTO par
Dunod
INFORMATIQUE
INDUSTRIELLE
© BORDAS, Paris, 1990 ISBN 2-04-018983-1
" Toute représentation ou reproduction, intégrale ou partielle, faite sans le consentement de l'auteur, ou de ses ayants-droit, ou ayants-cause, est illicite (loi du 11 mars 1957, alinéa 1 de l'article 40). Cette représentation ou reproduction, par quelque procédé que ce soit, constituerait une contrefaçon sanctionnée par les articles 425 et suivants du Code pénal. La loi du 11 mars 1957 n'autorise, aux termes des alinéas 2 et 3 de l'article 41, que les copies ou reproductions strictement réservées à l'usage privé du copiste et non destinées à une utilisation collective d'une part, et, d'autre part, que les analyses et les courtes citations dans un but d'exemple et d'illustration "
PREFACE
Les exécutifs ou noyaux multitâches temps réel sont depuis longtemps utilisés dans le domaine de l'informatique industrielle. Si les applications employant ces noyaux sont longtemps restées l'apanage des mini-ordinateurs, il n'en est rien aujourd'hui grâce à l'augmentation de la puissance des microprocesseurs 16 et 32 bits. Pourtant l'utilisation de ces techniques sur microprocesseurs n'est pas récente, un des premiers exécutif à être commercialisé pour ce type de composants a été le noyau iRMX80 pour le processeur 8080 (Intel 1975). L'élégance et la fiabilité des solutions apportées par l'incorporation de ces logiciels dans les applications industrielles permettent un abaissement du coût de développement et une maintenance plus aisée. Les noyaux multitâches temps réel, associés ou non à un système complet de gestion de fichiers sont actuellement les moteurs d'applications dans des domaines aussi variés que l'automatisation, la robotique, l'électronique médicale, le contrôle de processus, l'instrumentation, la télécommunication, la vidéo...
Ces outils logiciels ont la réputation, quelquefois justifiée, d'être d'une première approche difficile. Les procédés très techniques de mise en oeuvre, ainsi qu'un environnement de développement rébarbatif en sont souvent la cause. Cette situation ne permet pas l'apprentissage aisé de ces techniques, et masque les mécanismes fondamentaux utilisés. Une étude limitée à la théorie des noyaux temps réel (ordonnancement, communication, synchronisation) ne peut suffire. Elle fournit une vue incomplète en présentant un système abstrait dont le fonctionnement réel est difficile à imaginer.
Cet ouvrage a pour but de présenter les algorithmes programmés dans un ordonnanceur et dans les primitives de communication et de synchronisation d'un noyau temps réel. Ces algorithmes sont ensuite mis en oeuvre afin de constituer l'exécutif temps réel MTR86 dont le code source est entièrement décrit et commenté. Je me suis appliqué à rendre ce noyau modulaire afin qu'il puisse être facilement modifié et complété. MTR86 peut également être utilisé pour développer des applications sur micro-ordinateurs de façon simple et rapide.
Pour des questions de portabilité, MTR86 est entièrement écrit en langage C. Il utilise exclusivement l'approche structurée. Les procédures sont toujours courtes et abondamment documentées.
L'écriture du programme en langage C facilite la compréhension, mais rend les performances de MTR86 très liées à la qualité du code fourni par le compilateur employé pour la traduction. Le noyau présenté dans ce volume est compilé par TurboC version 2.0 pour les processeurs de la famille Intel 80x86. MTR86 peut être compilé pour d'autres cibles moyennant des modifications mineures, en particulier les processeurs de la famille Motorola 680x0.
Les applications utilisant MTR86 ne sont pas exclusivement développées en langage C. Elles peuvent utiliser la plupart des langages informatiques courants. Pour éviter une saisie toujours hasardeuse, l'ensemble du code de MTR86 et ses primitives représentant environ 3200 lignes sont disponibles sur une disquette au format standard MsDos. Cette disquette comporte également tous les programmes sources et binaires présentés dans cet ouvrage.
Daniel Tschirhart
Chapitre 1
PROBLEMES POSES PAR LA COMMANDE EN TEMPS REEL
1. Structure fonctionnelle des automatismes
Un système automatisé peut se décomposer en 2 parties qui coopèrent : - la partie opérative appelée également processus,
- la partie commande ou automatisme.
La communication avec l'opérateur fait partie intégrante de cette structure.
Par exemple, dans un tour à commande numérique, la partie opérative est le tour, et la partie commande, le calculateur (fig. 1.1).
Fig. 1.1. Schéma fonctionnel d'un automatisme.
L'automatisme peut se décomposer en un ensemble de fonctions à réaliser appelées tâches, et une partie contrôle réalisant le séquencement et l'enchaînement des tâches en fonctions d'événements internes ou externes (fig 1.2).
Fig. 1.2. Décomposition structurelle simplifiée d'un automatisme.
L'analyse fonctionnelle d'un système comprendra une description de la partie commande sous forme graphique (diagrammes de flux de données, diagrammes S.A.D.T., réseaux de Pétri, Grafcet) et devra mettre en évidence les informations traitées par les tâches.
2. Contraintes de temps dans un système
Chaque tâche de l'automatisme (figure 1.2) est exécutée en réponse à des sollicitations externes ou internes avec des contraintes de temps fixées par l'évolution du processus, par les dialogues avec l'opérateur, ou par l'écoulement du temps.
Pour chaque événement (modification de l'état d'un capteur ou toute information liée au processus...), il est nécessaire de calculer un ensemble de fonctions Fj dépendant de l'état Q de la commande. La durée t du calcul est fonction des algorithmes utilisés et de la puissance du processeur.
Le processus fixe une échéance de temps Te pour chaque calcul. La présence de cette échéance caractérise un système temps réel.
Pour des processus industriels, Te est compris entre quelques dizaines de microsecondes et quelques centaines de millisecondes.
Suivant la nature des contraintes de temps et la complexité des traitements, diverses solutions peuvent être retenues.
On distingue :
- les contraintes de temps faible (t très inférieur à Te),
- les contraintes de temps faible avec quelques événements contraignants, - les fortes contraintes de temps (t voisin de Te).
2.1. Contraintes de temps faibles
Ce type de contrainte autorise une programmation en mode bouclé appelée également gestion des entrées sorties par scrutation. Les rebouclages en arrière en attente d'événements sont interdits, car ils allongent la durée du cycle (ty) de façon indéterminée. Le programme doit pouvoir scruter en permanence les entrées avec un temps ty < Te (fig. 1.3.).
Ce mode de programmation est simple à mettre en oeuvre, mais difficile à maintenir. Lors de modifications ou d'ajouts de fonctions, les contraintes de temps peuvent ne plus être respectées. Pour éviter alors la réécriture complète du logiciel la seule solution consiste à remplacer le calculateur par un autre plus performant.
Fig. 1.3. Gestion des entrées/sorties par scrutation.
Exemple : programme terminal simplifié.
Un programme terminal consiste à afficher sur l'écran chaque caractère arrivant sur l'entrée série, et à envoyer le caractère frappé au clavier sur la sortie série.
Le matériel utilisé dans cet exemple possède les caractéristiques suivantes : - vitesse de frappe garantie : 10 caractères / secondes ;
- vitesse d'affichage sur l'écran : 1000 caractères / secondes ;
- vitesse de réception ou d'émission des caractères sur la ligne: 50.. 19200 Bauds, format 8 bits, 1 bit de start, 1 bit de stop.
La vitesse choisie est 600 Bauds.
Le programme terminal comporte deux tâches :
- une tâche déclenchée par la frappe d'un caractère avec = 0,1s,
- une tâche déclenchée par la réception d'un caractère avec Te = (1 + 8 + 1)/600s.
L'algorithme du programme terminal simplifié est donné à la figure 1.4 :
Fig. 1.4. Terminal fonctionnant par scrutation.
Vérification de la validité de l'algorithme
Le temps scrutation (ty) est essentiellement liée à la vitesse d'affichage. Nous la supposons égale à :
ty = 1 0 s dans le cas le plus défavorable.
La contrainte de temps la plus forte est :
Te = (1 + 8 + 1) / 600 = 16,7 1 0 s.
Ce qui vérifie ty très inférieur à Te.
Si la vitesse de réception des caractères est 19200 Bauds, la contrainte sera de : Te = 10 / 19200 = 0,52 1 0 s < ty et ne sera pas satisfaite.
2.2. Contraintes de temps faibles avec quelques événements contraignants Si le temps de cycle ne permet pas de satisfaire quelques contraintes, on associe les fonctions concernées à des interruptions. Chaque interruption est liée à un ou plusieurs événements. Le calculateur sera ainsi synchronisé sur ces événements et exécutera les traitements liés aux interruptions en suspendant le programme en exécution (fig. 1.5.).
Fig. 1.5. Gestion des entrées/sorties avec quelques événements contraignants.
Ecriture des programmes
Le traitement d'une interruption allonge le temps de cycle du programme interrompu. Les contraintes temporelles devront donc être analysées avec soin.
Soient Te, Te, Te les contraintes de temps liées aux durées t y , t y , t y . - Cas d'une seule interruption (IT) de fréquence constante
Pour satisfaire les contraintes de temps : t y < Te ;
t y + f x t y < Te
- Cas de plusieurs interruptions non emboîtées
Soient f et f les fréquences des interruptions IT et IT : (1)
- Cas de plusieurs interruptions emboîtées En supposant l'interruption 2 prioritaire
L'inégalité (1) est inchangée ;
si fl < f2 => t y + f2 x t y < ; si fl > f2 => t y + (fl - f2) x t y < Te ; ty2 < Te pour les événements liés à l'interruption IT.
Exemple : Terminal avec réception des caractères à vitesse élevée (fig. 1.5.).
Le programme comporte trois tâches :
- une tâche liée à une interruption (tâche réception). Celle-ci place le caractère reçu dans un tampon (FIFO). Le débordement du tampon n'est pas envisagé.
- une tâche, dont l'exécution dépend d'une condition interne (taux de remplissage du tampon) : tâche affichage.
- une tâche dont l'exécution dépend de conditions externes non liées à une interruption (caractère frappé) : tâche clavier.
Hypothèses
temps de cycle cumulé des taches affichage et clavier : t y = 2 10 s ; échéance de temps fixée par la tâche clavier : Te = 0,1 s ; temps de cycle du programme d'interruption : ty = 0,06 1 0 s.
Pour une réception à 9600 bauds :
fl = 9600 / 10 bits = 9 60 interruptions / secondes.
Les contraintes de temps sont :
Te = 10 / 9600 = 1,04 1 0 s ;
t y vérifie la contrainte (0,06 1 0 s < 1,04 1 0 s) ; t y + fl x t y = 2 1 0 s + 960 x 0,06 1 0 s
= 59,6 1 0 s < 0,1 s
Fig 1.5. Terminal fonctionnant par interruption (réception des caractères).
Contraintes de temps pour une réception à 19200 bauds : Te = 10 / 19200 = 0,52 1 0 s ;
t y vérifie la contrainte Te (0,06 1 0 s < 0,52 1 0 s) ; t y + fl x t y = 2 1 0 s + 19200/10 x 0,06 1 0 s
= 117 10-3 s > 0,1 s.
La contrainte Te n'est pas satisfaite. Il faudra alors lier la frappe d'un caractère à une interruption (de faible priorité).
2.3. Fortes contraintes de temps
Dans un système monoprocesseur les tâches sont exécutées séquentiellement. Si les contraintes de temps sont fortes, il est possible qu'elles ne puissent être satisfaites par un seul processeur.
Exemple :
Trois tâches T , T , T , dont l'exécution dans le temps est représentée par la figure 1.7 , ne peuvent satisfaire la contrainte Te. Le problème peut être résolu en attribuant un processeur à et T , et un autre à T .
Si les contraintes de temps portent toujours sur les même tâches, les processeurs pourront être spécialisés (processeur graphique, d'entrées/sorties ...). Ces processeurs sont appelés processeurs esclaves.
Si par contre les contraintes portent sur des tâches variables les processeurs devront être banalisés. Un programme de supervision se chargera alors d'attribuer aux tâches les processeurs libres.
Fig. 1.7. Exemple de système à contrainte insatisfaite.
Chapitre 2
SYSTEMES TEMPS REEL
1. Définitions
Il n'existe pas de définition précise pour désigner un système temps réel !
Le temps réel est lié à la notion de pilotage d'un système soumis à des contraintes de temps. On ne peut pas désigner de système temps réel, un calculateur utilisé pour des applications de gestion ou des applications scientifiques ; les contraintes de temps auquels sont soumis ces systèmes sont généralement liées à la productivité souhaitée.
Un système ne peut être classé temps réel que si les contraintes de temps sont d'origines matérielles (technologiques) et non humaines (de type confort). Ces contraintes peuvent être très sévères lorsqu'elles sont inférieures à la milliseconde, ou très larges lorsqu'elles sont de plusieurs minutes voire de plusieurs heures (pour un processus chimique). En réalité, lorsque les processus à contrôler sont lents, les contraintes de temps sont liées non pas au processus principal, mais aux dispositifs auxiliaires tels que les systèmes de mesures, les sécurités ...
Un système temps réel remplit son rôle lorsqu'il est en mesure de satisfaire toutes les contraintes de temps auxquels il est soumis.
Dans l'exemple (terminal) étudié précédemment, il n'existait qu'une seule contrainte de temps, la réception sans perte de caractère sur une ligne série. Ce système peut être qualifié de système temps réel. En fait ce terme n'est jamais utilisé pour désigner un terminal, car la notion de complexité et de multiplicité des contraintes est attachée à la notion de temps réel.
En conclusion la définition suivante peut être retenue :
un système temps réel pilote un processus comportant des contraintes de temps aléatoires et variées. Ce système doit être déterministe puisqu'il doit savoir avec précision, l'instant de début et de fin d'un traitement.
Un système temps réel comporte en général des tâches soumises à de fortes contraintes de temps, et des tâches pouvant être différées, tout en étant exécutées dans l'intervalle de temps voulu.
Les tâches soumises à de fortes contraintes de temps sont liées à des interruptions, et sont appelées tâches matérielles. Les tâches différées ou tâches logicielles sont programmées soit dans une boucle de scrutation (voir figure 1.5.), soit de façon indépendante. Elles sont alors exécutées de façon pseudo-simultanée. Lorsque la programmation est effectuée par un boucle de scrutation, on parlera d'un système temps réel monotâche, dans le cas contraire, de système temps réel multitâche. Dans tous les cas, un programme temps réel doit gérer l'occupation du processeur en fonction des échéances de temps liées au processus, des ressources disponibles, des synchronisations et des échanges de données.
L'aspect déterministe étant le critère le plus important dans un système temps réel, il n'importe de savoir que ce critère est rempli par une programmation monotâche ou multitâche. Cependant, dès que l'application devient complexe, les systèmes temps réel sont programmés suivant le mode multitâche, en raison d'une plus grande facilité de conception. Par contre pour des applications simples ou à très forte contrainte de temps, la programmation est généralement de type monotâche.
La programmation multitâche est grandement facilitée par des outils logiciels appelés : - systèmes d'exploitation temps réel (SETR),
- noyaux ou exécutifs ou moniteurs multitâches temps réel (NTR).
Ces outils ne sont pas équivalents. Un système d'exploitation temps réel multitâche fournit un support logiciel complet, tandis qu'un exécutif temps réel est destiné à être utilisé soit sans système d'exploitation, soit en complément d'un système exploitation. Les tâches sont dans un SETR, généralement des programmes complets et portent le nom de processus, tandis que pour un NTR, les tâches sont plutôt des procédures d'un même programme. On rencontre en général, les systèmes d'exploitation temps réel dans les calculateurs devant gérer d'importants volumes de données, et les exécutifs temps réel dans les calculateurs embarqués.
Un calculateur multitâche temps réel doit comporter au minimum les éléments matériels suivants :
- un dispositif d'horlogerie électronique appelé horloge temps réel, - un système d'interruption à priorités,
- des interfaces entrées/sorties adaptées aux processus à contrôler.
Ces composants matériels sont gérés par un SETR ou par un NTR.
Pour un SETR, les outils disponibles comportent des langages spécialisés (exemple : langage LTR) ou généraux, généralement C parfois Pascal voire Basic. Ces langages comprennent alors des instructions particulières permettant de mettre en oeuvre les possibilités temps réel.
Pour un NTR le logiciel peut être fourni sous la forme d'une mémoire morte à placer sur la carte processeur, ou sous la forme d'une bibliothèque de fonctions au format utilisé par la machine de développement. Si ces logiciels sont indépendants du matériel, un module de configuration doit être partiellement écrit par le développeur. L'utilisation de ces noyaux se fait à l'aide de primitives appelées à travers des interruptions logicielles. Du coté
COMMANDE ENTEMPS REEL
Du vidéodisque interactif aux calculateurs de vol, les exécutifs temps réel sont présents dans de très nombreuses applications.
Ce livre explique progressivement les concepts de développement de ces logiciels en construisant un noyau multitâche d'abord simplifié, puis complet et puissant, très proche des caractéristiques des logiciels commerciaux.
Sont abordés en particulier les points suivants :
— systèmes avec ou sans réquisition du processeur ;
— mécanisme de commutation des tâches ;
— ordonnancement ;
— exclusion mutuelle ;
— communication interprocessus ;
— synchronisations.
Le noyau temps réel entièrement écrit en langage C (aux normes ANSI) est utilisable avec des modifications mineures sur les microprocesseurs standards actuels (Intel 80x86 et Motorola 680x0). Le système présenté ici fonctionne sur un calculateur de type PC-XT-AT mais peut être adapté à d'autres machines.
Dans un souci pédagogique, de nombreux exercices sont proposés et leurs solutions peuvent être vérifiées et mises en œuvre à l'aide des outils proposés.
Ce livre qui s'adresse aux étudiants en informatique et électronique, intéressera également les professionnels amenés à utiliser ces techniques.
Participant d’une démarche de transmission de fictions ou de savoirs rendus difficiles d’accès par le temps, cette édition numérique redonne vie à une œuvre existant jusqu’alors uniquement
sur un support imprimé, conformément à la loi n° 2012-287 du 1er mars 2012 relative à l’exploitation des Livres Indisponibles du XXe siècle.
Cette édition numérique a été réalisée à partir d’un support physique parfois ancien conservé au sein des collections de la Bibliothèque nationale de France, notamment au titre du dépôt légal.
Elle peut donc reproduire, au-delà du texte lui-même, des éléments propres à l’exemplaire qui a servi à la numérisation.
Cette édition numérique a été fabriquée par la société FeniXX au format PDF.
La couverture reproduit celle du livre original conservé au sein des collections de la Bibliothèque nationale de France, notamment au titre du dépôt légal.
*
La société FeniXX diffuse cette édition numérique en accord avec l’éditeur du livre original, qui dispose d’une licence exclusive confiée par la Sofia
‒ Société Française des Intérêts des Auteurs de l’Écrit ‒ dans le cadre de la loi n° 2012-287 du 1er mars 2012.
