Communication sur rs232 avec un microcontroleur

Soyez le premier à donner votre avis sur cette source.

Snippet vu 25 791 fois - Téléchargée 31 fois

Contenu du snippet

Ici pour microcontroleur HC11. Mais peut etre utiliser pour la communiaction serie standard

Source / Exemple :


/**************************************************************************/
/*                            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++ ){}
    }
}

A voir également

Ajouter un commentaire

Commentaires

nidou113
Messages postés
3
Date d'inscription
mercredi 2 avril 2008
Statut
Membre
Dernière intervention
7 août 2011
-
azerty merci
Rou25
Messages postés
16
Date d'inscription
lundi 30 octobre 2006
Statut
Membre
Dernière intervention
10 juin 2009
-
salut,

j'avais une petite question étant donné que ton programme comporte des fonctions que j'aurais besoin pour ma programmation. Voila, je suis nouveau a la programmation et j'ai un projet de stage a faire sur un module Bluetooth. En fait, je dois faire un reset du module en envoyant un 0 sur le RX pendant un temps assez long. Mais j'arrive pas a le faire. Pourrait tu maider stp.

Merci a bientot!
cs_Maxaks
Messages postés
4
Date d'inscription
dimanche 28 mars 2004
Statut
Membre
Dernière intervention
5 décembre 2004
-
Tu pourrais donner quelques explications ? : >
Par exemple sur ce qu'il y a dans define.h et Fonctions.h, et les headers spécifiques au µc

merci

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.