Memoire Online - Mise au point d'applications en temps réel: Communication entre deux ordinateurs

Mise au point d'applications temps réel : Communication entre deux ordinateurs

SOMMAIRE

INTRODUCTION GÉNÉRALE.............................................................1

I- INTRODUCTION...................................................................................3

II- LES CONCEPTS TEMPS RÉELS...............................................................3

II-1- Principales caractéristiques d'un système temps réel ......................................3

II-2- Validité et fonctionnalité d'un système temps réel.....................................4

II-3- Notion du temps et contraintes temporelles..................................................4

II-4- Expression des contraintes temps réels......................................................5

II-5- Conception et structure d'un système temps réel ...........................................5

III- L'ANLYSE DU CAHIER DES CHARGES...............................................6

III-1- Port série RS232...............................................................................6

III-1-1- Définition du port série RS232........................................................6

III-1-2- Le protocole RS232....................................................................7

III-1-3- L'interface d'E/S séries 8250......................................................8

III-1-4- Les registres de configuration........................................................9

III-1-5- Principe du transfert série asynchrone sur ligne RS232.......................12

III-2- Port parallèle ..............................................................................12

III-2-1- Les adresses des interfaces........................................................13

III-2-2- Les registres de l'interface ........................................................14

III-2-3- Élaboration d'un câble null-modem ...............................................15

III-2-4- Protocole de transmission utilisé ..................................................16

III-2-5- Transmission d'un octet ...........................................................16

III-3- L'environnement turbo C ..............................................................17

III-3-1- Définition du Outport .............................................................17

III-3-2- Définition du Inport ................................................................17

IV- CONCLUSION................................................................................18

I- INTRODUCTION..............................................................................19

II- SPÉCIFICATION...............................................................................19

II-1- Modèle de SA-RT..........................................................................19

II-1-1- Diagramme de contexte de données (DCD)........................................20

II-1-2- Diagramme de fonctionnalités........................................................21

II-1-2-1- Cas de la communication de deux PC avec le port série RS232...........21

II-1-2-2- Cas de la communication de deux PC avec le port parallèle...............24

III- PROGRAMMATION.......................................................................29

III-1- Conception...............................................................................29

III-1-1- Port Série............................................................................30

III-1-2- Port Parallèle........................................................................35

IV- CONCLUSION................................................................................41

CONCLUSION GÉNÉRALE...............................................................42

BIBLIOGRAPHIE..............................................................................43

Dédicaces

A mon père et ma mère qui m'ont présenté les sacrifices nécessaires durant toute ma scolarité.

A mon oncle, ma tante ainsi que ma grand-mère qui m'ont soutenu en m'encourageant durant ce projet.

Sans oublier mes amis (es) : Badr, Hazem, Hassen, Ahmed, Rchid, Manel et tous les autres.

INTRODUCTION GENERALE

Les applications industrielles informatisées sont de plus en plus développées et doivent traiter les informations et exécuter les instructions de plus en plus vite. Pour palier à ces contraintes, il faut donc mettre en oeuvre de nouveaux concepts intégrant des caractéristiques spécifiques au temps réel. Les applications temps réel font appel à un environnement de plus en plus complexe pour des raisons de coût et d'efficacité [1].

Les systèmes informatiques temps réel se différencient des autres systèmes informatiques par la prise en compte de contraintes temporelles dont le respect est aussi important que l'exactitude des résultats, autrement dit le système ne doit pas simplement délivrer des résultats exacts, il doit les délivrer dans des délais imposés.

L'objectif de notre projet de fin d'étude consiste à assurer des moyens permettant la communication entre deux ordinateurs : l'émission et la réception des données.

Afin d'atteindre notre objectif, on doit d'abord analyser notre cahier des charges tout en spécifiant les besoins demandés et les solutions envisageables. On doit aussi présenter les différents outils que ce soit matériel ou logiciel permettant la communication entre les deux ordinateurs.

Dans notre projet, on est amené à assurer la partie programmation permettant de communiquer entre deux ordinateurs à travers un port série RS232 ou un port parallèle.

Dans le contexte du temps réels, les programmes ont souvent à gérer des systèmes critiques. Notre but est alors de fournir un programme fiable tout en évitant les problèmes d'encombrement et en dépassant les contraintes temporelles.

Ainsi, on a recours à la programmation structurée se basant essentiellement sur des moyens de spécification dans le but de donner une représentation abstraite et simplifiée du fonctionnement de notre système. Parmi ces moyens, on cite les diagrammes de flots de données dans le modèle de SA-RT (diagramme de contexte de données (DCD) et diagramme de fonctionnalités).

Un exposé sur les systèmes temps réels: caractéristiques, fonctionnalité, contraintes temporelles... est tout d'abord mis en relief.

L'accent est mis ensuite sur la description des différents outils intervenant dans l'application envisagé : la communication entre deux ordinateurs.

Le deuxième chapitre est consacré aux différentes étapes de la programmation structurée. L'étape de la spécification, se basant sur des outils de modélisation, a permis de détecter, en premier lieu, les problèmes d'encombrement qui peuvent se poser dans notre application. Viens ensuite l'étape de conception permettant de fournir des sous fonctions spécifiques et importantes pour la réalisation de notre programme, la partie test et validation est alors mise en relief.

I- INTRODUCTION

Les systèmes temps réel proviennent des évolutions des systèmes informatiques et des contraintes temporelles en milieu industriel. Ces systèmes réduisent les temps de réponses pour assurer la compatibilité avec les temps d'exécution des processus. [1]

La communication entre deux ordinateurs nécessite l'utilisation d'un port (séries, parallèle...).

Dans ce chapitre, une analyse du cahier de charges précisant les besoins et présentant les solutions envisagées est effectuée. On donnera, en premier temps, une étude sur les systèmes temps réels. Puis, une description du matériel utilisé (type de port, environnement choisi...) permettant la communication entre deux ordinateurs, sera introduite.

II- LES CONCEPTS TEMPS REEL

· Systèmes transformationnels (calcul scientifique, gestion de base de données) : ils sont caractérisés par le fait que

· Systèmes interactifs (systèmes transactionnels ou outils bureautiques) qui ont les caractéristiques suivantes :

Un système informatique est dit « Temps réel » si il est connecté à un procédé qu'il doit piloter en fonction de l'évolution de celui-ci.

Un système temps réel doit posséder un temps de réaction adapté aux événements externes et le programme doit pouvoir traiter l'ensemble d'un flux de données d'entrée avant qu'ils n'en reçoivent d'autres. C'est pour cela qu'il est nécessaire de connaître les temps d'exécution d'un programme pour connaître les limites de réactivité. [1]

II-3- Notion du temps et contraintes temporelles

Le temps est le facteur déterminant des systèmes temps réel. On peut distinguer trois classes de système :

Ce système est moins exigeant quant au respect absolu de toutes les contraintes temporelles. Les systèmes de cette classe, dits temps réel souple, peuvent souffrir un taux acceptable de fautes temporelles de la part d'une partie des traitements et sans que cela ait des conséquences catastrophiques. La mesure du respect des contraintes temporelles prend la forme d'une donnée probabiliste : la qualité de service relative à un service particulier ou relative au comportement du système dans son ensemble ou les deux combinés. Une problématique de cette classe de systèmes est d'évaluer la qualité de service, avant ou pendant le fonctionnement, que le système offre ou va pouvoir offrir en cours de fonctionnement, en fonction des caractéristiques de l'environnement et du système.

(La performance est dégradée mais sans conséquences dramatiques si les contraintes temporelles ne sont pas rencontrées).

La majorité des systèmes temps réel sévère est exclusivement constituée de traitements qui ont des contraintes temporelles strictes : on parle de systèmes temps réel strict. C'est à dire qu'en condition nominale de fonctionnement du système, tous les traitements du système doivent impérativement respecter toutes leurs contraintes temporelles ; on parle alors de traitements temps réel strict ou sévère.

Système sévère mais une faible probabilité de manquer les contraintes temporelles est tolérée.

II-4- Expression des contraintes temps réels

Le fonctionnement d'un système temps réel impose des contraintes sur le matériel (machine et environnement logiciel). Pour palier à ces contraintes, les systèmes doivent disposer :

Les logiciels temps réel doivent disposer de langages adaptés et d'instructions spécialisées pour permettre une bonne gestion des relations entre processus. Les informations doivent être traitées rapidement pour palier aux problèmes de contraintes de temps tandis que les instructions résultantes doivent rester dans les limites de fonctionnement nominal de la machine. [2]

II-5- Conception et structure d'un système temps réel

Pour optimiser un système temps réel, on peut suivre la procédure d'analyse suivante :

· Représentation simultanée de l'évolution logique et temporelle du système,

Une partie du logicielle permet de réaliser une bonne gestion des ressources matérielles afin de remplir certaines tâches ou fonctions dans des limites temporelles bien précises. Cette partie est appelée système d'exploitation ou noyau temps réel. Elle fournit des services basées sur les ressources disponibles au niveau matériel.

III- L'ANALYSE DU CAHIER DES CHARGES

Afin d'assurer la communication entre deux ordinateurs, on a besoin de deux ordinateurs, d'un câble permettant d'assurer la communication entre ces deux PC tels que le câble série RS232 ou un câble parallèle et d'un environnement turbo C.

III-1-1- Définition du port série RS232

Chaque ordinateur possède deux ports série. Ils prennent la forme de deux connecteurs mâles à 9 broches (pour les PC un peu plus anciens, un des deux possède 25 broches), nommés en standard COM1 et COM2. A l'origine, le port série était destiné à être connecté à un modem, c'est de là que le nom des broches est tiré. En effet, seulement trois broches sont nécessaires pour communiquer avec un périphérique (TxD, RxD et la masse), les autres broches n'étant que des signaux de contrôle et d'état. Le port série est très bien protégé contre les courts-circuits (avec une intensité de 20mA) et les broches sont limitées en courant. Ainsi, il est tout à fait possible d'alimenter un petit montage électronique (par exemple les souris séries sont alimentées par la ligne RTS). Mais, il est quand même préférable d'avoir recours à une alimentation externe.

III-1-2- Le protocole RS232

C'est par cette norme qu'il est possible de relier deux ordinateurs (la connexion directe par câble sous Windows), ou encore de communiquer avec un modem ou imprimante. Ce protocole est dit full duplex car il peut transmettre des données et en recevoir en même temps, via les lignes RxD et TxD. Il est tout à fait possible de n'utiliser que ces deux bornes en plus de la masse (pour la référence), en veillant bien sûr à relier la borne TxD du premier ordinateur à la broche RxD du second et vice versa. Le contrôle du flux de données sera alors totalement logiciel car les bornes annexes du port ne sont pas utilisées. Le mode de communication dit Xon/Xoff est très répandu (avec les imprimantes séries par exemple) et permet de contrôler l'écoulement des données en fixant dans la mémoire deux limites, haute et basse.

III-1-3- L'interface d'E/S séries 8250

Le composant électronique chargé de la gestion des transmissions séries asynchrones dans les PC est appelé UART (Universal Asynchronous Receiver/Transmitter), qui a pour fonction de sérialiser les caractères partant sur la ligne et mettre dans un registre en lecture les caractères arrivant par cette ligne. Lorsqu'un caractère est transmis sur la ligne RS232 ou lorsqu'un nouveau caractère est reçu, le circuit UART est capable d'engendrer une interruption. Un pilote RS232 comprend une routine d'interruption capable de stoker un caractère arrivé sur la ligne dans un tampon circulaire, accessible par l'application. [3]

Le port série possède un certain nombre de registres. Ces registres sont situés dans un composant nommé UART (Universal Asynchronous Receiver/Transmitter), qui gère totalement le port série et se situe sur la carte mère. Le port série est une vieille technologie, et à l'époque, la mémoire était rare et le moindre petit gain était apprécié. Chaque port série possède une adresse de base qui est généralement 0x3F8 pour le COM1 et 0x2F8 pour le COM2. Les registres sont accessibles via un offset par rapport à cette adresse de base, ce qui est représenté dans le tableau I-1.

C'est le registre d'émission. Il est chargé par le MPU en exécutant l'instruction OUT THR, AL. (Où THR est une constant initialisée avec l'adresse du registre THR).

Le contenu de THR est automatiquement copié par l'interface dans le registre à décalage d'émission, qui permettra la sortie en série des bits sur la sortie SOUT.

C'est le registre de réception. Les bits qui arrivent en série sur la borne SIN du circuit entrent dans un registre à décalage. Lorsque ce dernier est complet, il est transféré dans RBR.

A noter que si un deuxième octet arrive avant que RBR n'ait été lu par le MPU, il remplace RBR : on perd le premier arrivé, c'est l'erreur d'écrasement 26.

Adresse				REGISTRES
DLAB	A2	A1	A0
0	0	0	0	RBR : Registre de reception
0	0	0	0	THR : Registre d'émission
1	0	0	0	DLL : Poids faible diviseur horloge
1	0	0	1	DLM : Poids fort diviseur horloge
0	0	0	1	IER : Interrupt Enable Register
X	0	1	0	IIR : Interrupt Identification Register
X	0	1	1	LCR : Line Control Register
X	1	0	0	MCR : Modem Control Register
X	1	1	1	LSR : Line Status Register
X	1	0	0	MSR : Modem Status Register
X	1	1	1	Non utilisé

Ce registre de commande permet de définir certains paramètres de la transmission, en fonction de sa configuration binaire.

Bits 0 et 1 : spécifient le nombre de bits de la donnée à transmettre (caractères de 5, 6, 7 ou 8 bits) :

Bit 1	Bit 0	Nb de bits/caractère
0	0	5 bits
0	1	6 bits
1	0	7 bits
1	1	8 bits

Bit 2 : spécifie le nombre de bits STOP (s'il vaut 0 on a 1 bit de stop et s'il vaut 1 on a 2 bit de stops).

Bit 3 : spécifie la présence (si 1) ou l'absence (si 0) d'un bit de contrôle d'erreur (type bit de parité).

Bit 4 : s'il y a un bit de contrôle d'erreur, le bit 4 spécifie s'il s'agit d'un bit de parité paire (si 1) ou impaire (si 0).

Bit 7 : bit DLAB, permettant l'accès aux registres DLL et DLM dans la phase d'initialisation de l'interface.

Bit 2 : interruption lorsque l'un des 4 bits de poids faible de LSR passe à 1.

Ce registre d'état rend compte du fonctionnement de la liaison en réception (bits 0 à 4) et en émission (bits 5 et 6).

Bit 1 : signale erreur d'écrasement. 1 si donnée reçue et chargée dans RBR alors que la précédente n'avait pas été lue. Remis automatiquement à 0 par la lecture du registre LSR.

Bit 2 : passe à 1 à la suite d'une erreur de parité. Remis à 0 par la lecture de LSR.

Bit 3 : passe à 1 lorsque le niveau du bit STOP n'est pas valide (erreur de format). Remis à 0 par la lecture de LSR.

Bit 4 : passe à 1 lorsque le niveau de la liaison est resté à 0 pendant la durée d'émission de la donnée (problème de l'émetteur). Remis à 0 par la lecture de LSR.

Bit 5 : passe à 1 lorsqu'une donnée est transférée de THR vers le registre à décalage d'émission (THR est alors libre pour le caractère suivant).

IIR est utilisé pour les E/S par interruption. Son contenu permet d'identifier la cause de l'interruption émise par l'interface 8250.

Bit 0 : commande le niveau de la borne DTR qui informe le modem que le MPU est prêt à communiquer.

III-1-5- Principe du transfert série asynchrone sur ligne RS232

Pour transférer de manière asynchrone des caractères sur une ligne série, il est nécessaire de choisir une vitesse de transfert de bits (bits par seconde ou baud rate) convenue entre l'émetteur et le récepteur. Le caractère comprend un bit de départ (start bit) qui permet au récepteur de se synchroniser au premier flanc reçu et d'échantillonner les bits successifs au milieu de leur période. [3]

Le Port Parallèle associé à l' Interface parallèle Centronics (à l'origine : LPT pour Line Printing Terminal) est un connecteur situé à l'arrière des ordinateurs compatibles PC reposant sur la communication parallèle. Elle a été conçue pour une imprimante texte employant un jeu de caractères de 8 bits : l'ASCII. Le nom vient des limitations de l'imprimante qui ne peut imprimer que du texte, une ligne après l'autre.

La transmission de données en parallèle consiste à envoyer des données simultanément sur plusieurs canaux (fils). Les ports parallèles présents sur les ordinateurs personnels permettent d'envoyer simultanément 8 bits (un octet) par l'intermédiaire de 8 fils. [4]

Il est possible de brancher à un PC jusqu'à trois interfaces parallèles. Les espaces d'adressage réservé à chaque interface sont :

N° Ordre	Nom	Adresse du Port	Type d'interface
1	LPT1*	3BCh-3BFh	Interface parallèle sur la carte graphique MDA
2	LPT2*	378h-37Fh	1^er Interface
3	LPT3*	278h-27Fh	2^eme Interface

· La première interface occupée sera appelée LPT1, la suivante occupée sera alors LPT2 et ainsi de suite (cette appellation est faite au démarrage de l'ordinateur). Par exemple, s'il n'y a pas une carte graphique de type MDA (et par conséquent l'adresse 3BCh-3BFh n'est occupée) et la première interface parallèle est occupée, elle sera appelée LPT1 (c'est le cas général, puisque les cartes graphiques MDA sont anciennes). Il faut signaler que cette appellation est gérée par le DOS.

· Pour connaître avec un programme quel port est connecté, on peut consulter le segment variables du BIOS à l'offset 0008h. Cette adresse contient une table de quatre mots qui mémorisent des interfaces parallèles.

*Adresse du mot*	*Contenu*
0040h à 008h	Port de base du port parallèle n°1 : LPT1.
0008h à000Ah	Port de base du port parallèle n°2 : LPT2.
000Ah à000Ch	Port de base du port parallèle n°3 : LPT3.
000Ch à000Eh	Port de base du port parallèle n°4 : LPT4.

Indépendamment de leur adressage, toutes les interfaces parallèles présentent trois registres situés au début de leur zones mémoire : par exemple, pour la première interface parallèle, les registres sont à l'adresse 378h, 379h et 37Ah. La description de ces registres se trouve ci-dessous. Il est à remarquer que tous les bits des registres d'interfaces sont directement reliés aux lignes de transmission du câble.

Si on change la valeur de l'un des bits à 1, la ligne associée est aussitôt mise à 1. Inversement, si le bit est mis à 0, la ligne est placée à un niveau bas.

Les huit bits du premier registre représentent les données qui doivent être transférées sur les lignes D0 - D7. Il est à noter que ce registre n'est pas destiné à réceptionner des données. Le deuxième est en lecture seulement, il reflète l'état des lignes d'état de l'imprimante.

Le troisième registre sert à envoyer des commandes à travers l'interface. Le bit 4 aide au déclenchement d'une interruption matérielle dès que le signal

passe à 0 et ainsi l'autre bout du câble parallèle signal la réception du dernier caractère. De plus l'imprimante peut communiquer son état avec les trois signaux SLCT (correspond à l'état de sélecteur On-line de l'imprimante), PE (Paper Error manque ou défaut de papier) et ERROR (autres erreurs).

L'ordinateur dispose de diverses lignes qui lui permettent de commander l'imprimante. Elles sont AUTOFEED (pour signaler à l'imprimante la nécessité d'ajouter un caractère LF à chaque caractère CR), SLCT IN (mise hors ligne de l'imprimante) et INIT (permet de réinitialiser l'imprimante). [4]

III-2-3- Élaboration d'un câble null-modem

D'après le schéma usuel, la transmission ne peut se faire que dans un seul sens (l'interface parallèle est utilisée principalement pour communiquer avec l'imprimante). L'émetteur ne peut pas recevoir des données sur les lignes D0 - D7. Il faut alors établir une liaison bidirectionnelle pour que les données circulent dans les deux sens librement.

On utilise à cette fin les différentes lignes d'état qui véhiculent habituellement des informations d'état en provenance de l'imprimante.

III-2-4-Protocole de transmission utilisé

Le câble null-modem présenté dans la figure I-7 permet d'envoyer simultanément (dans les deux sens) cinq bits par lignes de données D0 - D4 dans chaque direction. Cependant il faut réserver une ligne qui sert pour rythmer la communication. L'un des cinq lignes va être sacrifié à cette fin (le bit

). Nous présentons à la suite le protocole que nous allons utiliser pour le transfert d'un octet.

III-2-5-Transmission d'un octet

Du coté émetteur, l'octet doit être divisé en deux quartets pour être transféré. Donc, le récepteur charge les bits de faible poids (de 0 à 3) dans les bits 0 à 3 du premier registre et met le cinquième (D4) à 0 pour que le récepteur reçoive la valeur 1 sur la ligne BUSY.

Du coté récepteur, le programme doit interroger en permanence la ligne

jusqu'à ce qu'elle monte à 1 pour transformer le contenu de deuxième registre dans une variable. Ce contenu, ainsi lu, est renvoyé à l'émetteur par les lignes de données. Le bit de la ligne D4 est ensuite mis à 0 pour que l'émetteur trouve sa ligne

à 1. Ce dernier va lire alors le quartet et peut le comparer au quartet envoyé. C'est une vérification au plus bas niveau.

Le même principe est répété pour la transmission du second quartet de poids fort. Et il ne reste que la concaténation de deux quartets pour obtenir l'octet. L'émetteur relie le deuxième quartet renvoyé pour contrôle, le concatène au second et teste s'il y a conformité avec l'original. En cas d'erreur, Une erreur est transmise au programme appelant pour décider ce qui est de mieux.

III-3- l'environnement turbo C

Les applications temps réel font appel à un environnement de plus en plus complexe pour des raisons de coût et d'efficacité. Durant cette étude, nous utilisons l'environnement Turbo C.

Turbo C est un langage de programmation très utilisé en milieu industriel mais peu convivial dans l'ingénierie industrielle.

Les deux instructions assembleur permettant au processeur de communiquer avec les interfaces d'E/S sont IN et OUT.

Il est possible d'accéder simplement à ces instructions en langage C, grâce aux fonctions inportb (adr) et outportb (adr).

· Unsigned char inportb (int address) : lit un octet à l'adresse (de l'espace d'E/S) indiquée et la retourne.

· Void outportb (int address, unsigned char *data) : écrit l'octet (argument data) à l'adresse (E/S) indiquée.

III-3-1-Définition de Outportb

C'est pour envoyer un octet dans un port. Les périphériques ont généralement une plage de ports qui lui sont adressés. Ces ports permettent de « communiquer » avec ces périphériques.
C'est généralement utilisé pour le port (série pour envoyer des données du PC vers la machine connectée).

C'est pour recevoir un octet dans un port. Les périphériques ont généralement une plage de ports qui lui sont adressés. Ces ports permettent de « communiquer » avec ces périphériques.
C'est généralement utilisé pour le port (série pour recevoir des données de PC).

L'analyse de cahier de charges est une étape préliminaire, voire importante, afin de permettre la conception et la commande d'un système temps réel tout en satisfaisant les contraintes exigées. Cette étape nous a permis, en premier temps, de mieux connaître et choisir le matériel utilisé dans notre application. Elle nous a encore aidé à réaliser les autres étapes de la programmation structurée qui seront élaborées dans le chapitre suivant.

I- INTRODUCTION

Afin de donner une représentation abstraite et simplifiée du fonctionnement de communication entre deux ordinateurs, on est amené d'introduire la notion de programmation modulaire.

Un programme structuré doit avoir une composition modulaire, il faut faire une analyse descendante de l'application conduisant à une décomposition fonctionnelle de l'application ; « plusieurs fonctions élémentaires indépendantes qui sont regroupés pour réaliser l'application ».

Dans l'objectif d'arriver à la composition modulaire, il y a certaines étapes indispensables par lesquelles on doit passer tels que l'analyse du cahier de charges déjà élaborée dans le premier chapitre, la spécification, la conception, le codage et la validation fonctionnelle du projet. Ce chapitre sera consacré à l'étude des différentes étapes tout en l'appliquant sur l'application de la communication entre deux ordinateurs.

II- SPECIFICATION

L'étape de spécification fonctionnelle, liée à l'établissement du cahier des charges du système à commander, doit être basée sur un outil formel. La spécification d'un système est l'expression technique du besoin auquel il doit répondre, c'est la traduction de celui-ci en une représentation (formalisme), qui permet de décrire le comportement et l'environnement du système sans faire appel à des considérations informatiques. Une spécification rigoureuse sera ensuite le point de départ de la conception du programme. On s'applique alors à réaliser un programme le plus fidèle à la spécification. Il existe de nombreux modèles permettant de traiter les problèmes du temps réel.

II-1- Modèle de SA-RT

C'est une méthodologie de développement qui est rendue indispensable pour répondre à la complexité des systèmes modernes, associée à un besoin croissant de qualité dans l'accomplissement d'un projet temps réel. Dans ce cadre, la méthodologie SA-RT (System Analysis - Real Time) apporte une réponse : elle dissocie le modèle des besoins de celui d'architecture, tout en prenant en compte les aspects temporels sur différents processus.

En effet, SA-RT est une méthode de spécification des systèmes temps réel. Elle permet de construire deux modèles d'une machine :

Le modèle des besoins est composé de diagrammes de flots de données (DFD), des diagrammes de flots de contrôle (DFC), des machines à états finis pour l'aspect temporel, des spécifications de contrôle, des spécifications de traitements et un dictionnaire des données.

Le modèle d'architecture a pour but d'attribuer les différents éléments du modèle des besoins (processus, spécifications de contrôles, données et contrôles) à des unités matérielles et logicielles qui composeront le système. Il intègre les éventuelles contraintes technologiques. Il est constitué de diagrammes de flots d'architecture, de spécifications de modules d'architecture, de diagrammes d'interconnexion d'architecture et d'un dictionnaire d'architecture. [5]

II-1-1- Diagramme de contexte de données (DCD)

Ce diagramme est la représentation de la fonction principale à laquelle on veut aboutir : la communication entre deux ordinateurs.

Le DCD délimite le sujet de l'étude, et se compose de bords, d'un processus, de flots de données. L'objectif du DCD est d'exposer le but principal du système et identifier les entités extérieures avec lesquelles il doit communiquer.

· Toutes les entités externes communiquant avec le système (peuvent être de niveau élevé).

Dans notre application assurant la communication entre deux ordinateurs, le diagramme de contexte de données est représenté dans la figure II.1.

II-1-2- Diagramme de fonctionnalités

C'est un diagramme décrivant les fonctionnalités qui doivent être implantées par le système pour satisfaire les besoins du client. Une fonctionnalité est immatérielle et décrit une action prise par le système pour produire un résultat. La sortie d'une fonctionnalité peut être utilisée comme entrée par une ou plusieurs autres fonctionnalités.

· Les fonctionnalités du système représentées sous forme de verbe d'action suivi d'un nom.

II-1-2-1- Cas de la communication de deux PC avec le port série RS232

D'abord, on doit effectuer la configuration du port RS232 afin d'assurer la bonne transmission des données entre les deux ordinateurs. Le port série peut effectuer l'envoi et encore la réception des données. Pour cela, et afin de ne pas tomber dans des problèmes d'encombrement, des tests vérifiant le mode de fonctionnement du port (envoi ou réception) doivent être pris en compte. Si le port série est prêt à la réception, l'adresse sera lue et le caractère sera affiché. Si le port série est prêt à l'envoi, le caractère sera transporté à travers le port RS232.

II-1-2-2- Cas de la communication de deux PC avec le port parallèle

Le port parallèle peut effectuer la transmission et encore la réception des données.

Du coté émetteur, l'octet doit être divisé en deux quartets pour être transféré. Donc le récepteur charge les bits de faible poids (de 0 à 3) dans les bits 0 à 3 du premier registre et met le cinquième (D4) à 0 pour que le récepteur reçoive la valeur 1 sur la ligne BUSY.

Du coté récepteur, le programme doit interroger en permanence la ligne

à 1. Ce dernier lit alors le quartet et peut la compare au quartet envoyé. C'est une vérification au plus bas niveau.

Le même principe est répété pour la transmission du second quartet de poids fort. Et il ne reste que la concaténation de deux quartets pour obtenir l'octet. L'émetteur relie le deuxième quartet renvoyé pour contrôle, le concatène au second et teste s'il y a conformité avec l'original. En cas d'erreur, une erreur est transmise au programme appelant afin de décider ce qui est de mieux.

Il est clair d'après le mode de fonctionnement du port parallèle effectuant la transmission d'un octet que il est préférable de composer notre application en deux grandes parties : la première se chargeant de l'émission et l'autre pour la réception.

· L'organigramme assurant l'émission d'un octet à travers le port parallèle est donné dans la figure II-3

Figure-II-3: Organigramme du mode de fonctionnement du port parallèle (émission)

· L'organigramme assurant la réception d'un octet à travers le port parallèle est donné dans la figure II-4

III- Programmation

En informatique, la programmation modulaire repose sur l'utilisation de modules, qui sont des structures permettant de définir des espaces regroupant des éléments définis par le programmeur : fonctions, structures de donnée, types, objets, etc.

Cette méthode de regroupement permet de réaliser une encapsulation comparable par certains aspects à celle de la programmation objet, et permet l'organisation du code source en unités de travail logiques. Les modules définissent également des espaces de noms utiles lors de leur utilisation.

La programmation modulaire n'induit pas obligatoirement un style de programmation (ou paradigme) plutôt qu'un autre dans les éléments qu'elle structure qui peuvent être de style objet, impératif ou fonctionnel.

Ce style de programmation facilite principalement la réutilisation, le partage du code et est particulièrement utile pour la réalisation de bibliothèques. De plus, suivant les langages de programmation, les modules peuvent être paramétrés et/ou polymorphes, ce qui apporte une modularité dont la souplesse amène alors à parler de généricité.

La programmation générique est un sur ensemble qui peut tirer avantageusement partie de la modularité apportée par la programmation modulaire.

Afin d'assurer la communication entre deux ordinateurs, on est amené à effectuer un programme par l'environnement Turbo C.

III- 1- Conception

L'étape de spécification a permis de détecter les problèmes qui peuvent se poser lors de la programmation. Le problème le plus important c'est de pouvoir suivre l'état d'émission ou de réception d'un bit ou même d'un octet suivant le type de port utilisé.

Après l'étape de spécification, on doit décomposer notre programme en sous-programmes plus simples à résoudre. Chaque sous-programme devient donc plus élémentaire. Ce processus de «raffinement» se poursuit jusqu'à arriver au niveau d'abstraction du langage de programmation que l'on va utiliser (Turbo C). A ce niveau, on peut utiliser les éléments du langage pour représenter le programme. [6]

III-1-1- Port série

· On doit tout d'abord effectuer la configuration du port RS232 pour assurer la transmission des données entre les deux ordinateurs. Cette étape est réalisée à l'aide d'une fonction configurer décrite par son prototype void configurer (void).

ü L'instruction « outport(adr_base+1,0x00 )» effectue la réglage de la vitesse de transmission.

· Pour assurer l'envoi et la réception des informations à travers ces deux ordinateurs dans des bonnes conditions, on peut intervenir des fonctions test permettant de tester la présence et le fonctionnement des matériels :

Tout d'abord, on peut tester la présence du clavier à l'aide d'une fonction Unsigned char test_clavier(void).

Cette fonction a recours à une fonction kbhit déjà existante en Turbo C et qui permet de lire un caractère tapé par le clavier.

On peut encore vérifier si le port est prêt à la réception : on teste la présence du caractère dans le port série. Cette étape est réalisée à l'aide d'une fonction décrite par son prototype int test_ prêt _reception (void).

Cette fonction a recours à une fonction spécifique : inportb déjà existante dans la bibliothèque de Turbo C. Elle permet de recevoir un octet dans un port. Les périphériques ont généralement une plage de ports qui lui sont adressés. Ces ports permettent de « communiquer » avec ces périphériques.

ü L'instruction « lu=inportb(adr_base+5) » permet la lecture du caractère dans le port série.

ü «if(lu!=0) return(1)» : Cette instruction permet de tester si le caractère lu à travers l'instruction précédente est différent de 0. Ceci signifie que le port RS232 est prêt à la réception.

On peut aussi vérifier si le port est prêt à envoyer dans le but d'éviter l'encombrement entre l'émission et la réception. Cette étape est réalisée à l'aide d'une fonction test_prêt_envoyer décrite par son prototype: unsigned char test_prêt_envoyer(void)

ü L'instruction « lu=inportb(adr_base+5) », la même utilisée dans la fonction précédente et permet la lecture du caractère dans le port série.

ü «if(lu=!0) return(1)» : Cette instruction est la même utilisée dans la fonction précédente permet de tester si le caractère lu à l'aide de l'instruction précédente est différent à 0, Ceci signifie que le port RS232 est prêt à l'envoi.

· Afin de visualiser le caractère qu'on vise à envoyer, on peut utiliser une fonction qui permet la lecture d'un caractère du clavier et, en cas de présence, l'affiche sur l'écran du coté récepteur. Son prototype est de la manière suivante : Unsigned char lecture (void). Cette fonction a recours à la fonction test_clavier déjà expliqué auparavant.

ü Cette fonction a recours à des fonctions getch et return déjà existantes dans la bibliothèque de Turbo C. « char getch (void) » est une fonction permettant de lire un caractère tapé par le clavier et l'afficher sur l'écran.

· Du coté émetteur, un caractère doit être affiché sur l'écran utilisant la fonction précédente et encore mis dans le port RS232 afin d'être envoyé à l'autre ordinateur. Cela est assuré grâce à une fonction envoyer, décrite par son prototype: void envoyer(void).

Cette fonction a recours à la fonction test_prêt_envoyer déjà expliquée auparavant. Cela permet de n'effectuer l'envoi d'un caractére que si le port est prét à l'émission.

Cette fonction a recours à une fonction spécifique : outportb déjà existante dans la bibliothèque de Turbo C. Elle permet d'envoyer un octet dans un port. Les périphériques ont généralement une plage de ports qui lui sont adressés. Ces ports permettent de « communiquer » avec ces périphériques.

ü L'instruction « outportb(adr_base,lu) est utilisée pour le port série pour envoyer des données du PC vers l'autre machine connectée.

· On peut assurer la réception et l'affichage du caractère présent dans le port RS232, par une fonction recevoir. Son prototype est de la manière suivante : void recevoir(void) .

Cette fonction a recours à la fonction test_prêt_reception déjà expliquée auparavant.

Cela permet de n'effectuer la réception d'un caractére que si le port est pêt à la reception.

III-1-2- port parallèle

D'après le diagramme de fonctionnalité précédent du port parallèle, notre programme est décomposé en deux grandes parties: la première se chargeant de l'émission et l'autre pour la réception.

· L'envoie est assuré grâce à une fonction EnvoieOctet, décrite par son prototype: int EnvoieOctet (unsigned char Valeur).

Du coté émetteur, on doit diviser l'octet en deux quartets pour être transféré.

ü Cette fonction a recours à une fonction spécifique, la même utilisée dans le port série. C'est la fonction outport déjà existante dans la bibliothèque de Turbo C. Elle permet d'envoyer un octet dans un port. Les périphériques ont généralement une plage de ports qui lui sont adressés. Ces ports permettent de « communiquer » avec ces périphériques.

ü On déclare une constante PORT qui égale à la valeur en hexadécimale 0x378.

ü L'instruction « outportb(PORT,Valeur&0x0F)» permet l'envoi du quartet le plus faible.

ü Afin d'atteindre la mise à zéro de BUSY, on a recours à une boucle répétitive while permettant ainsi de ne sortir de la boucle que si la condition sur BUSY est vérifiée.

L'instruction «while(((inport(PORT+1)&0xF8)&128)==0)»permet ainsi de tester la condition sur BUSY.

Afin de vérifier la bonne transmission, l'acquisition du quartet de retour à partir du récepteur est effectuée.

Ce quartet de retour est initialement mis de la manière suivante dans l'offset 1 du port parallèle (on désigne ce quartet par la valeur abcd)

Cela mène à conclure qu'on doit effectuer un décalage de 3 (>> 3) pour que le quartet de retour sera mis dans les quatre premier bits de l'offset 1 tout en multipliant par la valeur hexadécimale 0x0F pour le remplissage des autres valeurs, donc la valeur retour 1 est donnée par :

Afin d'envoyer le quartet le plus fort, on doit tout d'abord le mettre dans les quatre premier bits en effectuant un décalage de quatre et en écrasant ainsi le quartet le quartet faible( il est déjà envoyé).

Cette valeur est additionnée par une valeur hexadécimale (0x10) afin de remplir les autres quartets vides ( le but de 1 est de positionner le quartet décalé).

ü Afin d'attendre la mise à 1 de BUSY, on a utilisé la boucle répétitive while se basant sur le même principe déjà expliqué auparavant.

ü «Retour2=while(((inport(PORT+1)&0xF8)&128)!=0)» : Le deuxième quartet de retour est initialement posé de la manière suivante( on désigne ce quartet par la valeur ABCD) :

Cela mène à conclure qu'on doit effectuer un décalage à gauche de 1(<<1) tout en multipliant par 0xF0 afin de forcer les autres valeurs en 0, ainsi la valeur de Retour2 est donnée par :

ü «Retour= Retour1|Retour2» : Cela permet de concaténer les deux valeurs du quartet.

Si Valeur est égale à Retour, on retour en 1 à la fonction EnvoieOctet, Sinon un message d'erreur doit être affiché.

Le programme principal assurant l'émission est ainsi décrit de la manière suivante:

· La réception est assurée grâce à une fonction RecOctet, décrite par son prototype: unsigned char RecOctet( void ) définie de la manière suivante

ü On doit tout d'abord attendre la ligne

jusqu'à atteindre la valeur 1. Cela est assuré grâce à la boucle répétitive while : while((((inport(PORT+1)&0xF8)&128)==0)) » :

ü «LoNib = ((inport(PORT+1)&0xF8) >> 3) & 0x0F»: Comme décrit dans la fonction précédente, on doit décaler le quartet reçu à droite par trois (>>3 ) afin de le placer dans les quatre premiers quartets de l'offset du port parallèle.

ü Après la réception du quartet supérieur, le port doit le renvoyer à l'émetteur qui le compare au quartet envoyé. De cette façon, on a effectué la vérification au plus bas niveau. Cela est assuré grâce à la fonction : « outportb(PORT,LoNib ».

ü Afin d'attendre la mise à 1 de busy, on a utilisé la boucle répétitive while par le même principe déjà utilisé auparavant : «while((( (inport(PORT+1)&0xF8) & 128 ) != 0 ))».

ü On répète le même principe pour la transmission du second quartet de poids fort.

« outportb(PORT,((HiNib >> 4 )|0x10 ))» : Afin d'envoyer le quartet le plus fort, on doit tout d'abord le mettre dans les quatre premiers bits en effectuant un décalage de quatre et en écrasant ainsi le quartet le quartet faible.

ü «return( LoNib|HiNib» :Après la réception des deux quartets, on va retourner tout l'octet en effectuant la concaténation de LoNib et HiNib.

Le programme principal assurant la réception est ainsi décrit de la manière suivante:

Grâce à cette méthode de spécification et de programmation structurée, on a pu suivre l'état d'émission et de réception d'un bit suivant le port série RS232 et d'un octet suivant le port parallèle. Cette méthode nous a permis d'éviter le problème d'encombrement dans le port et le problème de blocage devant les contraintes temporelles.

La dernière étape dans la programmation structurée est le test et la validation. Cette étape a été réalisé et a donnée des résultats satisfaisants. Ceci montre la fiabilité et l'efficacité de notre programme que ces soit pour le port série ou le port parallèle.

CONCLUSION GENERALE

L'élaboration de ce projet de fin d'études a permis d'avoir une idée claire sur l'élaboration d'un programme permettant d'effectuer la communication entre deux ordinateurs à travers le port série ou le port parallèle.

Pour atteindre cet objectif, nous avons tout d'abord présenté les différents outils de point de vue matériel ou logiciel intervenant dans notre application.

On a ensuite recours à la programmation structurée. Celle-ci est basée essentiellement sur des moyens de spécification tels que le diagramme de flots de données dans le modèle de SA-RT (diagramme de contexte de données (DCD) ou encore le diagramme de fonctionnalités). Cette étape de spécification nous a donné une représentation abstraite et simplifiée du fonctionnement de notre système.

Cela nous a facilité l'étape de l'élaboration d'un programme fiable assurant la communication entre les deux ordinateurs dans des bonnes conditions que ce soit à travers le port série ou même le port parallèle. Un tel programme est jugé fiable lorsqu'il permet d'éviter les problèmes d'encombrement et de dépasser les contraintes temporelles.

Nos perspectives rentrent dans le cadre de l'élaboration d'un nouveau programme permettant l'émission et la réception de fichiers à travers le port parallèle. Ceci sera encore basé sur la méthode de la programmation structurée et on aura certainement recours à nos programmes dèja élaborés dans ce mémoire.

Enfin, on est amené à confirmer que ce projet nous a permis de nous investir totalement pendant quatre mois et d'approfondir nos connaissances dans différents domaines tels que les méthodes de spécification, les méthodes de conception et l'utilisation du langage de programmation Turbo C.

BIBLIOGRAPHIE

[1] : « Mr Khaled JELASSI » Fascicule de travaux pratiques : Bureau d'étude Conception des systèmes temps réel et informatique industrielle. Laboratoire d'informatique industrielle, ENIT, Edition 2004.

[2] : « » Fascicule de travaux pratiques: Communication entre deux ordinateurs

[3] : « Roger D.HERSCH » Informatique Industrielle, Microprocesseurs et interfaces temps réel, collection INFORMATIQUE, Presses polytechniques et universitaires Romandes, 1997.

[4] : « » Fascicule de travaux pratiques: Communication entre deux ordinateurs

[5] : « Samir BEN AHMED » Approche multi-modéles pour la spécification, la validation et la conception de la commande des systèmes flexibles de production manufacturière, Thèse de doctorat d'état en informatique. Faculté de Sciences de Tunis.

[6] : «BIBERSTEIN Olivier, QUELOZ Pierre-Antoine et BRULHART Dominique» cours Langage C, Janvier 1993.

ANNEXE 1

/******************* Lecture d'un caractère du clavier *********************/

/******************** Test réception du caractère ***********************/

/********************Tester l'envoi du caractère***************************/

/*************** Envoyer le caractère au port RS 232 ***********************/

Mise au point d'applications en temps réel: Communication entre deux ordinateurs

REBAÏ Rami & TURKI Ladhem

Le Diplôme Universitaire Technologique

SOMMAIRE

Dédicaces

INTRODUCTION GENERALE

I- INTRODUCTION

II- LES CONCEPTS TEMPS REEL

II-3- Notion du temps et contraintes temporelles

II-4- Expression des contraintes temps réels

II-5- Conception et structure d'un système temps réel

III- L'ANALYSE DU CAHIER DES CHARGES

III-1-1- Définition du port série RS232

III-1-2- Le protocole RS232

III-1-3- L'interface d'E/S séries 8250

III-1-5- Principe du transfert série asynchrone sur ligne RS232

III-2-3- Élaboration d'un câble null-modem

III-2-4-Protocole de transmission utilisé

III-2-5-Transmission d'un octet

III-3- l'environnement turbo C

III-3-1-Définition de Outportb

I- INTRODUCTION

II- SPECIFICATION

II-1- Modèle de SA-RT

II-1-1- Diagramme de contexte de données (DCD)

II-1-2- Diagramme de fonctionnalités

II-1-2-1- Cas de la communication de deux PC avec le port série RS232

II-1-2-2- Cas de la communication de deux PC avec le port parallèle

III- Programmation

III- 1- Conception

III-1-1- Port série

III-1-2- port parallèle

CONCLUSION GENERALE

BIBLIOGRAPHIE

ANNEXE 1

ANNEXE 2