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

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).

Cette fonction est donnée par :

void configurer (void)

{

outport(adr_base+3,0x80);

outport(adr_base,0x0c);

outport(adr_base+1,0x00);

outport(adr_base+3,0x03);

outport(adr_base+4,0x03);
}

ü L'instruction « outport(adr_base+3,0x80) » effectue la mise à 1.

ü 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 permet de tester la présence du clavier.

Unsigned char test_clavier (void )

{

if(kbhit()) return(1);

else return(0);

}

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 est donnée par :

int test_ prêt _reception (void)

{

unsigned char lu;

lu=inportb(adr_base+5);

lu=lu&1;

if(lu!=0) return(1);

else return(0);

}

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)

Cette fonction est donnée par :

unsigned char test_prêt_envoyer(void)

{

unsigned char lu;

lu=inportb(adr_base+5);

lu=lu&0x20;

if(lu=!0) return(1);

else

{

return(0);

}

}

ü 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.

Notre fonction est donnée par :

unsigned char lecture (void)

{

unsigned char lu;

lu=test_clavier();

if(lu==1)

{

lu=getch();

return(lu);

}

else return(0);

}

ü 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 est donnée par :

void envoyer(void)

{

unsigned char lu,lu1;

lu=lect_clavier();

if(lu!=0)

lu1=test_ prêt _envoyer();

if(lu1=lu)

{

{

outportb(adr_base,lu);

if(lu==0x1b) sortie=1;

}

}

}

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.

Cette fonction est donnée par :

void recevoir(void)

{

unsigned char lu;

lu= test_prêt_reception();

if(lu!=0)

{

lu=inportb(adr_base);

if(lu==0x1b) sortie=1;

printf("%c",lu);

}

}

ü L'instruction « lu=inportb(adr_base) » permet la lecture du caractère.

ü L'instruction « printf("%c",lu) »permet l'affichage du caractère reçu.

Le programme complet est introduit dans l'annexe1.