COMMUNICATION SUR RS232 AVEC UN MICROCONTROLEUR

/**************************************************************************/
/*                            Fichier rs232_hc.c                          */
/**************************************************************************/
/*  Description :                                                         */
/*                programme de gestion de la liaison serie sur HC11       */
/*                                                                        */
/**************************************************************************/
/*        H I S T O R I Q U E   D E S   M O D I F I C A T I O N S         */
/**************************************************************************/
 
 
/**************************************************************************/
/*                           DEFINITION DES Variables globales            */
/**************************************************************************/  
unsigned char voie = 0 ;
unsigned char erreur_rs232 = 0;
unsigned char i =0;
unsigned char max_timeout = 3; 
unsigned char leng_trame = 4;/*4 caracteres*/
unsigned char demi_char = 51; 
unsigned char new_trame = 0; 
/************************** tableau ***********************************/

unsigned char tableau_trame_RX [10] = {0x00} ; /*tableau pour recuperation de la trame serie*/
unsigned char tableau_trame_TX [10] = {0x00} ; /*tableau pour emission de la trame serie*/
 
/**************************************************************************/
/*                           DEFINITION DES Header                        */
/**************************************************************************/
 

/* Header de définition constant, address, fonction ...*/

 #include "define.h"  
 #include "Fonction.h"
 
/* Declaration des "headers" system*/
 #include <io6811.h>                                                               
 #include <int6811.h>    
 #include <string.h> 
 #include <stdlib.h>
/****************************************************/
/* Fonction :    Main  Programme Principal          */
/*                                                  */
/* Description : Initialisation, Boucle while(1)    */
/*               Interruption IRQ & XRQ             */
/*                                                  */
/* para entrees : 0                                 */
/* para sorties : 0                                 */
/****************************************************/
void main(void) 
{
 
  /* autorise des interruption */
  enable_interrupt(); 
  Init_micro(); /* init des port du micro*/
  INIT_AFF();   /*init de l'afficheur*/
 
 /*************************debut du soft principal*******************************/
 
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/ 
/**!!!!!!!!!!!le while principal!!!!!!!!!!!!!!!!!!!!!!*/
 /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

  while (1) 
  {
   if (new_trame)
    {
     CLEAR();          /*nettoyage de l'ecran*/   
     gotoxy(1,1);       
     new_trame = 0;
     if (!erreur_rs232)
      {
       printf("%s",(int)"valeur char =");
       gotoxy(1,2);
       for(i=0 ;i<6;i++)
       {
        tableau_trame_TX[i] = tableau_trame_RX[i];
        printf("%d",(tableau_trame_RX[i]));
        printf("%s",(int)" ");
       }
       tx_rs232_hc();
      }
     else 
      {
       printf("%s",(int)"    erreur rs232    ");
      }
     }
    tempo(2,2);  
  } /* fin du while (go) */   

}/* fin du main */ 
/**********************************************************************************/
/********************************************/
/* Fonction : tx_rs232_hc                   */
/* Description : routine emission de trame  */
/*           par la liaison serie           */
/* para entrées : 0                         */
/* para sorties : 0                         */
/********************************************/
void tx_rs232_hc (void)
{
 unsigned char reg_SCSR = 0; /*registre d'etat*/
 unsigned char flag_TDRE = 0;/*flag registre transmission vide*/
 unsigned char j= 0;
 
 for (j=0;j<leng_trame;j++)
  {
   /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
   /*peut etre remplacé par while(!(SCSR & B7)); */
   /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
   do
   {
    reg_SCSR = SCSR ;/*lecture du registre d'etat*/
    flag_TDRE =(reg_SCSR & B7)? 1 :0;/*extraction du flag registre vide*/ 
   }
   while(!(flag_TDRE));
   /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
   SCDR = tableau_trame_TX[j];
  } 
}
/**********************************************************************************/
/********************************************/
/* Fonction : SCI_interrupt                 */
/* Description : interruption quand le      */
/*               le port communication est  */
/*               active                     */
/*                                          */
/* para entrées : 0                         */
/* para sorties : 0                         */
/********************************************/
interrupt[0] void SCI_interrupt(void)
{
 unsigned char reg_SCSR = 0;
 unsigned char reg_recep = 0;
 unsigned char overrun = 0;
 unsigned char reg_full = 0;
 unsigned char tour = 0;
 unsigned char cnt_time_out = 0;
 unsigned char j;
 /***********************************************************************************/
 /*on rentre dans la boucle de reception tant que pas time_out inter_caractere      */
 /*ce qui permet de remplir un tableau de reception de caracteres                   */ 
 /*puis apres time_out on verifie si le Nb de caratere correspond a une trame ou pas*/
 /*sinon on raz le tableau et on signale un erreur                                  */
 /*l'incrementation du compteur est gere ici car on est dans une routine interrupt  */
 /*la pause doit correspondre a la duree d'un demi caractere(9600baud environ 500µs)*/
 /***********************************************************************************/
 erreur_rs232 = 0;/*avant tout on raz l'erreur en cours*/
 while(cnt_time_out < max_timeout)
   { 
     /*attention ici le registre et les flag sont raz par la simple lecture */
    reg_SCSR = SCSR; /*recup de la valeur du registre d'etat*/
    reg_recep = SCDR;/*lecture du registre de reception_emission*/

    overrun = ( reg_SCSR & B3)? 1 : 0 ; /*extraction du bit over_run*/
    reg_full =( reg_SCSR & B5)? 1 : 0 ; /*extraction du bit registre full*/

    if (overrun==1)
     {
      erreur_rs232 =1;
     }
     else
     {
      if(reg_full)
       {
        tableau_trame_RX[tour] = reg_recep ;
        cnt_time_out = 0 ; /*on a reçu un char dinc on raz le timeout*/       
        tour++;
       }/*fin de if(reg_full)*/
     }/*fin de if (overrun==1)*/  
    /*ici pause de 1/2 caractere*/
    /*la boucle prend 28 cycles de clock_E au 1er tour puis 19 jusqu'a egalité */
    /*pour un quartz de 8 MHz => E = 2MHz donc demi_char doit etre egal a 50 */
      for(j=0;j<demi_char;j++)/*raz du tableau */
       {
        /*on fait rien */
       }/*fin de for(j=0;j<demi_char;j++)*/ 
     cnt_time_out++;/*on incremente le compteur du timeout*/ 
   }/*fin du while(cnt_time_out < max_timeout)*/
   
  new_trame = 1; /*ici pour afficher */

 /*gestion de l'erreur RS232 */
if ((erreur_rs232 == 1)||(tour !=leng_trame))
 {
  erreur_rs232 = 1; /*on signale une erreur*/
  /*ça on peut le faire ailleur si on veut*/
  for(j=0;j<10;j++)/*raz du tableau */
  {
   tableau_trame_RX[j] = 0x00;
  }/*fin de for(j=0;j<leng_trame;j++)*/ 
  return;
 }
else
 {
 /*si on est ici c'est que l'on a recu une nouvelle trame sans erreur*/
  /*new_trame = 1; */
  erreur_rs232 =0;
 }
}
/********************************************************************************************************/
/********************************************/
/* Fonction :    RTITimerEnable             */
/*                                          */
/* Description : Real Time Timer            */
/* paramètres entrées : void                */
/* paramètres sorties : void                */
/********************************************/     
void RTITimerEnable(void)      
{                       
  PACTL = 3 ; /* "00000011"  RTI timer 32.768 ms*/
/* Validation de l'interruption RTI et inhibition des autres interruptions TIMER */
  TMSK2 = 64;  /*"01000000" RTI enable */   
  TFLG2 = 64 ; /*"01000000"  clr du flag d'interrupt RTI pour demarrer comme il faut*/
}
/*********************************************************************************************************/  
/********************************************/
/* Fonction : RTI                           */
/* Description : interruption quand le      */
/*               Real Timer Time overflow   */
/*               relance le watchdog        */
/*                                          */
/* para entrées : 0                         */
/* para sorties : 0                         */
/********************************************/
interrupt[26] void RTI_interrupt(void)
{        
 /*cette routine est effectuée periodiquement en fonction de la valeur de PACTL*/
/*on interdit les interruption pour avoir un comptage sur*/
 disable_interrupt() ; 
 TFLG2 = 64 ;   /*clr flag interrupt*/
 /* Valide les demandes d'interruptions */     
 enable_interrupt() ;
}

/*************************************************************************************************************/ 
/********************************************/
/* Fonction : Init_micro                    */
/* Description : initialisation  des port   */
/*                       du micro           */
/*                                          */
/* para entrées : void                      */
/* para sorties : void                      */
/********************************************/
void Init_micro(void)
 {
  unsigned char i = 0 ; /* variable pour le clignotement des leds*/
 /* Initialisation des registres µC */
  SPCR = 0x00 ;  /*pas de SPI*/
 /* port A */
    /*est initialise dans la fonction RTITimerEnable */ 
 /*port D */
  DDRD_B2(0) ;   /*bit  positionnés en entree*/ 
  DDRD_B3(1) ;   /*bit  positionnés en sortie*/
  DDRD_B4(0) ;   /*bit  positionnés en entree*/ 
  DDRD_B5(1) ;   /*bit  positionnés en sortie*/ 
/*communication en liaison serie*/
  voie_rs232 = voie;
  BAUD = 0x30; /*9600 baud*/
  SCCR1 = 0x00; /*1 start 8bits 1 stop (et methode reveil :attente)*/
  SCCR2 = 0x2C; /*RX interrupt et tx rx enable*/
  } 
/************************************/
/*                  TEMPO           */
/************************************/
void tempo(unsigned char into_loop_limit,unsigned char over_loop_limit)
{
    unsigned char into_loop_char, over_loop_char;

    for(over_loop_char = 0; over_loop_char < over_loop_limit; over_loop_char++ )
    {                                            
         for(into_loop_char = 0; into_loop_char < into_loop_limit; into_loop_char++ ){}
    }
}