1: 

     2:  

     3: #include <pic.h>

     4: #include "biosdem.h"

     5: /*mot de configuration pour 

     6: rendre le programme autonome*/

     7: __CONFIG (0x3D39);              

     8: 

     9: 

    10: void serial_puts (const char s[]);

    11: void serial_putchar (char c);

    12: void serial_init (void);

    13:  int a=0;

    14: char x=0;

    15: 

    16: /*commande est le mot qui va etre recu du PIC de la carte des capteurs,

    17: ce mot de 8bits va permettre de donner les informations sur les capteurs,

    18: c'est-à-dire de savoir quel capteur(s) capte la piste. Ce mot sera traité

    19: par la suite pour donner l'ordre aux moteurs de ralentir ou d'accélerer*/

    20: char commande=0x00;  

    21:                                          

    22: void main (void)

    23: {

    24: DelayMs(10);

    25:  serial_init();    //initialisation de la liaison série

    26:         ADCON1=0x06;            

    27: PR2=239;                   /*réglage de la période du signal de commande moteur

    28:                                           à 240us*/

    29: TRISC1=0;

    30: TRISC2=0;

    31: CCP2CON=0x0C;

    32: CCP1CON=0x0C;

    33: TRISE2=0;

    34: TRISD1=0;

    35: TRISD2=0;

    36: TRISD3=0;

    37: TRISE0=0;

    38: TRISE1=0;

    39: TRISA4=0;

    40: TRISA5=0;

    41: TRISA2=0;

    42: TRISE1=0;

    43: TMR2ON=1;

    44: TRISB4=0;

    45: RD1=0;

    46: RD2=0;

    47: RD3=1;

    48: RB4=1;

    49: /*configuration des interruptions*/

    50: PEIE=0;

    51: RCIE=0;

    52: GIE=0;

    53: 

    54: for(;;)

    55: {

    56: 

    57: RE2=1;

    58: RA2=1;

    59: 

    60: 

    61: if(OERR)                   //erreur

    62: {

    63: 

    64: CREN=0;

    65: RE0=1;

    66: CREN=1;

    67: }

    68: else

    69: {

    70: RE0=0;

    71: }

    72: 

    73: /*      RE1=0;

    74:         RE0=0;

    75:         RA5=0;

    76:         RA4=0;*/

    77: /* la partie qui suit traite la réception du 

    78:    mot commande venant du PIC situé sur la 

    79:    carte des capteurs.*/

    80:         if (RCIF==1)

    81:                 {

    82:           if ( !FERR )                                  //erreur

    83:          {

    84:                         RE1=1;

    85:            commande=RCREG;

    86:          }  

    87: 

    88:                 else

    89:                 { x = RCSTA ;

    90:                 x = RCREG ;

    91:                         RE1=0;

    92:                 }

    93:             }

    94: /*ce switch/case va permettre de traiter le mot commande 

    95:   qui a été recu précédemment,en fonction du mot recu,

    96:   la vitesse des moteurs*/

    97: switch (commande)

    98: {

    99:         case 0x00:                              //perte de la piste

   100:                 CCPR2L=0;

   101:                 CCPR1L=0;

   102:         break;

   103:         case 0x18:                              //piste au milieu

   104:                 CCPR2L=170;                             

   105:                 CCPR1L=165;

   106:         break;

   107:         

   108:         /*suit la partie au cas ou le robot part vers la 

   109:           gauche et donc les moteurs doivent

   110:           etre corrigés de telle façon à ce que le robot 

   111:           repart plus ou moins vers la droite*/

   112: 

   113:         case 0x10:                              //robot part léger gauche

   114:                 CCPR1L=0;

   115:                 CCPR2L=100;

   116:         break;

   117:         case 0x20:                              //robot part moyen gauche

   118:                 CCPR1L=100;

   119:                 CCPR2L=0;

   120:         break;

   121:         case 0x40:                              //robot part beaucoup gauche

   122:                 CCPR1L=0;

   123:                 CCPR2L=100;

   124:         break;

   125:         case 0x80:                              //robot part extrême gauche

   126:                 CCPR1L=100;     // 20

   127:                 CCPR2L=0;          //100

   128:         break;

   129: 

   130:          /*suit la partie au cas ou le robot part vers 

   131:        la droite et donc les moteurs doivent

   132:            etre corrigés de telle façon à ce que le robot 

   133:        repart plus ou moins vers la gauche*/

   134: 

   135:         case 0x08:                              //robot part léger droite

   136:                 RE1=1;

   137:                 CCPR2L=100;

   138:                 CCPR1L=0;

   139:         break;

   140:         case 0x04:                              //robot part moyen droite

   141:                 RE0=1;

   142:                 CCPR2L=0;

   143:                 CCPR1L=100;

   144:         break;

   145:         case 0x02:                              //robot part beaucoup droite

   146:                 RA5=1;

   147:                 CCPR2L=100;

   148:                 CCPR1L=0;

   149:         break;

   150:         case 0x01:                              //robot part extrême droite

   151:                 RA4=1;

   152:                 CCPR2L=0;

   153:                 CCPR1L=100;

   154:         break;

   155: }

   156: 

   157: RB4=!RB4;       /*cette broche nous a servi à sa voir si 

   158:               le programme tournait bien,

   159:                           car lors d'une panne nous avions émis 

   160:                           l'hypothèse que le programme ne

   161:                           tournait pas*/

   162: if(a==1)

   163: {

   164:         a=0;

   165: }

   166: }       

   167: }

   168: 

   169: 

   170: /*cette fonction permet d'initialiser

   171: la liaison série entre les deux PIC*/

   172: void serial_init (void)

   173:         {

   174:         BRGH=1;

   175:         SPBRG=25;

   176:         SYNC=0;

   177:         SPEN=1;

   178:         TXEN=1;

   179:         CREN=1; 

   180:         }

   181: 

   182: /*cette fonction permet d'emettre un caractère

   183: à l'aide de la liaison série*/

   184: void serial_putchar (char c)

   185:         {

   186:         while (TRMT==0)

   187:                 ;

   188:         TXREG=c;        

   189:         }

   190: 

   191: /*cette fonction permet d'emettre une suite 

   192: de caractère à l'aide de la liaison série*/

   193: void serial_puts (const char s[])

   194:         {

   195:         char i=0;

   196:         while (s[i]!='\0')

   197:                 {

   198:                         serial_putchar(s[i]);

   199:                         i++;

   200:                 }       

   201:         }

   202: 

   203: //cette partie du programme sert à traiter l'interruption

   204: interrupt void isr (void)

   205:         {

   206:         if (RCIF==1)

   207:                 {

   208:                 commande=RCREG;

   209:                 a=1;

   210:                 }       

   211:         }