You are on page 1of 5

[TITRE DU DOCUMENT]

[Sous-titre du document]

[DATE]

[Adresse de la société]
CHEBIHI Youness 441
DUCOURNAU Ugo
M1 E3A
GR 02
20/12/2017

TP4 INFORMATIQUE INDUSTRIELLE


Introduction:

L’objectif de ce tp est de travailler et de comprendre les techniques de fonctionnement des


communications série.

Exercice 1

Compteur logic de temps: logic_count


Compteur nombre de bits : nb_bit
Automate émetteur
Tx : donnée du bit
Transmit: commande de l'émission
émission
Var_Tx: registre d'émission

! Transmi
t
S0 Set
Tx
0
Transmi
t

Clear Tx
S1 Raz nb_bit
Raz logic_count

logic_count != 12

logic_count == 12
& nb_bit == 9
Inc logic_count S2

logic_count ==12 S4
& nb_bit != 9
Transmit =
/*
0; indiquant la fin
l'émission
de */
Raz
if (nb_bit<8)
S3
logic_count
{ Tx lsb de Var_T
} else = x
{ Tx= /*bit de stop
*/ 1
Inc
} nb_bit
;
Nous avons décidé d’utiliser le type de condition « Switch Case » pour coder cet automate. Nous
déclarons d’abord toutes les variables nécessaires à sa réalisation.
/*****************************************/
/* declaration des variables et tableaux */
/*****************************************/

bit transmit;
sbit broche_Tx=0x97; // pin de connexion de l’émission
sbit broche_Rx=0x96; // pin de connexion de la réception
bit Tx,Rx = 0; // initialisation de Tx et Rx
int nb_bit, logic_count;
char etat=0;
int i;
bit FLAG_Timer;
char var_tx = 0xF3; //valeur de la donnée a transmettre
char var_loc; // définit en tant que char car sur 8 bits
char var_rx; // définit sur 8 bits
bit received;

On effectue par ailleurs une procédure de mise en route de l’interruption Timer0.

void init_timer0() {
TMOD= TMOD|2; // Mode 2 pour Timer0//
TH0=0; //tampon pour periode max ~192us car quartz uC à 16MHz//
TL0=0; //Compteur mis à 0
ET0=1; //validation de l'interruption Timer0 bit 1 du registre E
EA=1; //autorisation globale des interruptions bit 7 du registre E
TR0=1; //mise en route du Timer0

Ensuite, il est question d’écrire le code de l’automate émetteur et vérifier la trame série émise sur un
oscilloscope.

void Automate_emission (){


switch (etat)
{
case 0:
Tx=0;
if (transmit == 1){etat = 1;}
break;
case 1:
nb_bit=0;
logic_count=0;
Tx=0;
etat = 2;
break;
case 2:
if(logic_count!=12){
logic_count++;}
if (logic_count==12 && nb_bit!=9){
etat =3;
}
if (logic_count==12 && nb_bit==9){
etat=4;}
break;
case 3:
logic_count=0;
if (nb_bit<8){
Tx = var_tx & 0x01;
var_tx = var_tx >> 1;
}//multiplication logic et récupération du lsb de var_tx
else {
Tx=1; // bit de stop
}
nb_bit ++;
etat =2;
break;
case 4 :
transmit=0;
etat = 0;
break;
}}

L’automate de l’émetteur ci-dessus est implanté dans la routine d’interruption du Timer0. De plus,
l’échantillonnage des broches en entrée de l’interruption permet de garantir la stabilité de la largeur de chaque
bit émis.
Un signal Transmit (de type bit) est utilisé comme signal de synchronisation entre le programme principal qui
place les caractères à émettre mais aussi l’automate qui se charge du transfert effectif.

On code à présent l’automate récepteur, et pareillement, on prévoit un bit Received de synchronisation entre
l’automate récepteur et la partie du programme principal qui récupère et affiche le caractère reçu.

void Automate_reception (char etat){


switch(etat)
{
case 0:
logic_count=0;
if(Rx=0){
etat = 1;}
break;
case 1:
logic_count++;
if (logic_count==5){
etat=2;}
break;
case 2:
logic_count=0;
nb_bit=0;
etat =3;
break;
case 3:
if(logic_count!=12){
logic_count++;}
if(logic_count==12&&nb_bit!=8){
etat=4;}
if(logic_count==12&&nb_bit==8){
etat=5;}
break;
case 4:
nb_bit++;
logic_count=0;
var_loc = var_loc >> 1;
if(Rx == 1)
var_loc |= 0x80;
break;
case 5:
if (received==0){
var_rx=var_loc;
received=1;}
etat=0;
break;
}}

La fonction timer(0) interrupt va permettre d’automatiser l’interruption du timer au sein de la fonction émission et
réception.

timer0() interrupt 1{
broche_Tx=Tx;
printf("%u \n",var_tx);
Rx=broche_Rx;
Automate_emission();
Automate_reception();
}