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é.
int EnvoieOctet (unsigned char Valeur)
{
unsigned char Retour;
outportb(PORT,Valeur&0x0F);
while(((inport(PORT+1)&0xF8)&128)==0);
Retour1 =((inport(PORT+1)&0xF8)>>3)&0x0F;
outportb(PORT,(Valeur>>4)|0x10);
Retour2=while(((inport(PORT+1)&0xF8)&128)!=0);
Retour = Retour1|Retour2;
(Valeur==Retour);
}
ü 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'expliquer «Valeur&0x0F »,
on prend par exemple valeur = 0101 0110.
Or 0x0F=0000 1111.
Alors,
Valeur & 0x0F=
0101 0110
0000 1111
0000 0110
Cela a
permis de prendre en compte seulement le
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.
La valeur  est trouvée dans l'adresse de l'offset 1 (PORT+1).
Pour visualiser cette valeur, le procédé de
masquage est appliqué.
1 0 0 0
0 0 0 0 = (128)H
0 0 0
0 0 0 0
ü « Retour1
=((inport(PORT+1)&0xF8)>>3)&0x0F » :
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)
a
b
c
d
0
0
0
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 :
0
0
0
a
b
c
d
0
ü
«outportb(PORT,(Valeur>>4)|0x10)» :
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) :
A
B
C
D
0
0
0
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 :
B
C
D
0
0
0
0
A
ü «Retour= Retour1|Retour2» : Cela permet
de concaténer les deux valeurs du quartet.
Ceci se fait de la manière suivante :
0
0
0
0
a
b
c
d
Retour1 :
0
A
B
C
D
0
0
0
Retour2 :
B
C
D
a
b
c
d
A
= Retour :
ü «Return (Valeur= = Retour)» : C'est
l'étape de la vérification.
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:
void main(void)
unsigned char valeur;
clrscr();
do
{
valeur= getch(); // lire le caractère clavier
EnvoieOctet(valeur); // envoie du caractère
printf("%c",valeur); // affiche du caractère
même s'il est ESC
}while (valeur!=0x1b);//envoie de caractère si oui
sortir
}
Le programme complet est introduit dans l'annexe 2.
· 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
unsigned char RecOctet( void )
{
unsigned char LoNib, HiNib;
while((((inport(PORT+1)&0xF8)&128)==0));
LoNib =( (inport(PORT+1)&0xF8) >> 3) & 0x0F;
outportb(PORT,LoNib);
while((( (inport(PORT+1)&0xF8) & 128 ) != 0 ));
HiNib = ( (inport(PORT+1)&0xF8) << 1 ) & 0xF0;
outportb(PORT,((HiNib >> 4 ) | 0x10 ));
return( LoNib | HiNib );
}
ü 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)) » :
La valeur  est trouvée dans l'adresse de l'offset 1 (PORT+1).
Pour visualiser cette valeur, le procédé de
masquage est appliqué.
ü «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:
void main(void)
{
unsigned char valrecu;
clrscr();
do
{
valrecu=RecOctet();
printf("%c",valrecu);
} while(valrecu!=0x1b);
}
Le programme complet est introduit dans l'annexe 2.
CONCLUSION
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.
| 
