[Jérémy]

Re,

Je valide le changement de nom de la fonction à fonctionné !

Merci à Satinas

Je retourne donc à mes tests initiaux pour faire fonctionner ces deux UART

[Jérémy]

Ok le code avec les deux UART focntionnent sans les Interruptions . Ca avance tranquilement :

Code : Tout sélectionner

// PROGRAMME pour la télécommande-radio du robot

// DS du PIC 18F47K740 : http://ww1.microchip.com/downloads/en/DeviceDoc/40001844D.pdf

/*
Fosc = 64Mhz
*/
#define LED_R      LATC.B2      // Sortie led rouge
#define LED_V      LATC.B1      // Sortie led verte
#define BP         PORTE.B0     // Entree pour BP

//##################################     Variables    ##############################################
 unsigned char i;
//----- UART
 unsigned char Reception_UART1, Reception_UART2 ;
 unsigned char F_Test;

//##################################     PROTOTYPE    ##############################################
void Init_Uart1( unsigned long);
void Init_Uart2( unsigned long);
char Read_Uart1();
char Read_Uart2();
void Write_Uart1(char);
void Write_Uart2(char);

//##############################################################################
//------------------------     INTERRUPTION        -----------------------------
void interrupt(){
/*
//-----------------------          UART 1        -----------------------------
  if((RC1IF_bit==1) && (RC1IE_bit==1)) {

     Reception_UART1 = Uart1_Read(); // On récupere la donnée
     Uart1_Write( Reception_UART1);
     LED_R = ~LED_R;
   }
*/
}

//#################################################################################################
//#########################################      MAIN      ########################################
//#################################################################################################
void main() {

 // Disable comparator
  CM1CON0 = 0;
  CM2CON0 = 0;
  
  LATB.B1 = LATB.B2 = 0;
  TRISC.B1 = TRISC.B2 = 0;       // Sortie pour led verte et rouge
  
  ANSELB = ANSELC = 0b00000000;

  LED_R = LED_V = 0;
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
  PPSLOCK = 0x55;                 // unlock PPS
  PPSLOCK = 0xAA;
  PPSLOCKED_bit = 0;
  RC6PPS  = 0x09;                 // TX1 -> RC6
  RX1PPS  = 0x17;                 // RX1 <- RC7
  RB5PPS  = 0x0B;                 // TX2 -> RB5
  RX2PPS  = 0x0F;                 // RX2 <- RB7
  PPSLOCK = 0x55;                 // lock PPS
  PPSLOCK = 0xAA;
  PPSLOCKED_bit = 1;

  Init_Uart1(9600);
  Init_Uart2(9600);
  delay_ms(10);

//#################################################################################################
//###############################      BOUCLE PRINCIPALE      #####################################
//#################################################################################################
 while(1){
    if (RC1IF_bit) Write_Uart1(Read_Uart1()+1);
    if (RC2IF_bit) Write_Uart2(Read_Uart2()+2);
 }
}

//#################################################################################################
//###############################      PROGRAMME SECONDAIRE     ###################################
//#################################################################################################

void Init_Uart1( unsigned long baudrate)
{
  BAUD1CON = 0b00001000;            // ABDOVF=0; RCIDL=0; bit5=vide; SCKP=0; BRG16=1; bit2=vide; WUE=0; ABDEN=0
  SP1BRG   = 64000000/4/baudrate-1; // SP1BRG = SPBRGH + SPBRGL = (Fosc/4/Baudrate)-1
  TX1STA   = 0b00100100;            // CSRC=0; TX9=0; TXEN=1; SYNC=0; SENDB=0; BRGH=1; TRMT=0; TX9D=0
  RC1STA   = 0b10010000;            // SPEN=1; RX9=0; SREN=0; CREN=1; ADDEN=0; FERR=0; OERR=0; RX9D=0
}

char Read_Uart1(void)
{
  return RC1REG;
}

void Write_Uart1(char Data)
{
   while (!TX1IF_bit) ;
   TX1REG = Data;
}

//----------------------------------------------------------------------------------------------------
void Init_Uart2( unsigned long baudrate)
{
  BAUD2CON = 0b00001000;            // ABDOVF=0; RCIDL=0; bit5=vide; SCKP=0; BRG16=1; bit2=vide; WUE=0; ABDEN=0
  SP2BRG   = 64000000/4/baudrate-1; // SP1BRG = SPBRGH + SPBRGL = (Fosc/4/Baudrate)-1
  TX2STA   = 0b00100100;            // CSRC=0; TX9=0; TXEN=1; SYNC=0; SENDB=0; BRGH=1; TRMT=0; TX9D=0
  RC2STA   = 0b10010000;            // SPEN=1; RX9=0; SREN=0; CREN=1; ADDEN=0; FERR=0; OERR=0; RX9D=0
}

char Read_Uart2(void)
{
  return RC2REG;
}

void Write_Uart2(char Data)
{
   while (!TX2IF_bit) ;
   TX2REG = Data;
} 

Allez Zou je me lance dans le traitement sur interruption

[Jérémy]

Je maintiens un suspense fou sur FantasPic car ca continue de fonctionner avec les deux interruptions !

Ca sent bon ! Je continue mes recherche et je psoterais le code final si je ne rencontre pas d'OS ( ce qui m'étonnerais)

[Jérémy]

Un grand MERCI à Satinas pour sa patience et ses solutions !

Le piège était très vicieux, c'était donc la déclaration de la fonction qui avait le même nom que celle dans une librairie ( même si la librairie n'était pas activée).

A l'avenir je ne me risquera pas a créer une fonction avec le même nom !

Je vous post le programme qui pour le moment tourne parfaitement.
C'est à dire que je pilote mon robot avec l'UART1(qui communique avec mon module radiuo) et que dans le même temps je reçois des infos sur l'UART2 !

Du coup MikroC perds encore un point avec sa librairie en carton, qui nous dit qu'il faut activer tel ou tel UART avant utilisation ce qui est faux comme on le prouve avec satinas .

Code : Tout sélectionner

// PROGRAMME pour la télécommande-radio du robot

// DS du PIC 18F47K740 : http://ww1.microchip.com/downloads/en/DeviceDoc/40001844D.pdf

/*
Fosc = 64Mhz
UART1 = 57600 bauds
UART2 = 9600 bauds
*/

/*  Position initale des Joysticks quand ils sont au point milieu brut
Joystick_G_HB = 127
Joystick_G_DG = 130-131
Joystick_D_HB = 126-127
Joystick_D_DG = 129
*/

#define RESET      LATC.B3      // Sortie
#define CONFIG     LATD.B0      // Sortie
#define CTS        LATC.B4      // Sortie
#define RTS        PORTC.B5     // Entrée
#define DATA_REQ   LATD.B2      // Sortie
#define DATA_IND   PORTD.B3     // Entrée
#define TRX_DIS    LATD.B1      // Sortie

#define LED_R      LATC.B2      // Sortie led rouge
#define LED_V      LATC.B1      // Sortie led verte
#define BP         PORTE.B0     // Entree pour BP

#define ADC_RD5    0b00011101   // Defini le ADPCH = RD5
#define ADC_RD7    0b00011111   // Defini le ADPCH = RD7
#define ADC_RC0    0b00010000   // Defini le ADPCH = RC0
#define ADC_RA7    0b0000111    // Defini le ADPCH = RA7

#define BP_Trim_G_H   PORTA.B2  // Entrée avec pull-up interne
#define BP_Trim_G_B   PORTA.B3  // Entrée avec pull-up interne
#define BP_Trim_G_D   PORTA.B1  // Entrée avec pull-up interne
#define BP_Trim_G_G   PORTA.B0  // Entrée avec pull-up interne
#define BP_Trim_D_H   PORTB.B0  // Entrée avec pull-up interne
#define BP_Trim_D_B   PORTB.B1  // Entrée avec pull-up interne
#define BP_Trim_D_D   PORTB.B3  // Entrée avec pull-up interne
#define BP_Trim_D_G   PORTB.B2  // Entrée avec pull-up interne

//##################################     Variables    ##############################################

 //----- TRIMS
 bit Ancien_etat1,Ancien_etat2,Ancien_etat3,Ancien_etat4 ;
 bit Ancien_etat5,Ancien_etat6,Ancien_etat7,Ancien_etat8 ;

 unsigned char i,Cpt_Point_milieu=0 ;
 unsigned char Joystick_D_HB, Joystick_D_DG, Joystick_G_HB, Joystick_G_DG;
 unsigned char Mem_Joystick_D_HB, Mem_Joystick_D_DG, Mem_Joystick_G_HB, Mem_Joystick_G_DG;
 signed char  V_Trim_D_HB, V_Trim_D_DG, V_Trim_G_HB, V_Trim_G_DG;

//----- UART
 unsigned char Reception_UART1, Reception_UART2, Valeur, Valeur2,Reseau ;
 unsigned char Commande_Mode_OK, Parametre_OK, RESET_OK, F_Message_OK;
 unsigned char Index_Buff1, Long_Buff1;
 unsigned int XOR;
 char Buffer_UART1[50];

//##################################     PROTOTYPE    ##############################################
void Lecture_Potar();
void Envoi_Cde_Moteur();
void Lecture_Trim();

void Init_Uart1( unsigned long);
void Init_Uart2( unsigned long);
char Read_Uart1();
char Read_Uart2();
void Write_Uart1(char);
void Write_Uart2(char);

//##############################################################################
//------------------------     INTERRUPTION        -----------------------------
void interrupt(){

//-----------------------          UART 1        -----------------------------
  if((RC1IF_bit==1) && (RC1IE_bit==1)) {

     Reception_UART1 = Read_Uart1(); // On récupere la donnée

     CTS = 0 ;       // je mets à 0 CTS pour signaler au module que la reception est occupée

     switch (Valeur){
        case 0:     if (Reception_UART1 == 0x02){     // reception du Start signal
                       Valeur = 1 ;
                     }
                     else
                       Valeur = 0;
                    break;

                    // Numéro de la  commande recue
        case 1:     if (Reception_UART1 == 0x49)        // Parametre OK
                       Valeur = 2;
                    else if (Reception_UART1 == 0x81){  // Reception d'un message
                        Valeur = 10;
                        Index_Buff1 = 0;
                        XOR = 0x83;                     // Calcul du XOR : 0x02^0x81
                      }
                    else if (Reception_UART1 == 0x44)   // Command_MODE OK
                       Valeur = 20;
                    else
                       Valeur = 0;
                    break;

       //-------------------------------------------------- Parametre OK
       case 2:     if (Reception_UART1 == 0x01) Valeur = 3; // Nombre bytes
                   else                         Valeur = 0;
                   break;

        case 3:    if (Reception_UART1 == 0x00) Valeur = 4;//data
                   else                         Valeur = 0;
                   break;

        case 4:    if (Reception_UART1 == 0x4A){     // checksum 0x02 0x49 0x01 0x00 0x4A
                       Parametre_OK = 1;              // Je léve le FLAG
                     }
                   Valeur = 0;
                   break;

        //------------------------------------------------ Reception d'un message
        case 10:    if (Reception_UART1 <= 20){           // Verifie que la longueur ne dépasse pas 20
                       XOR = XOR^Reception_UART1;         // Calcul du XOR
                       Long_Buff1 = (Reception_UART1-1) ; // Enregistrement  de la longueur des donnés
                       Valeur = 11;
                     }
                     else
                       Valeur = 0;
                    break;
                                                        // J'enregistre le message dans le buffer tant que je n'ai pas atteint la longueur calculée
        case 11:    if (Index_Buff1 < Long_Buff1){      // Verifie que la longueur ne dépasse pas 20
                       XOR = XOR^Reception_UART1;       // Calcul du XOR
                       Buffer_UART1[Index_Buff1] = Reception_UART1;
                       Index_Buff1++;
                     }
                     else{
                       Reseau = Reception_UART1;       // Une fois la fin du corps du message j'enregistre le réseau
                       XOR = XOR^Reception_UART1;      // Calcul du XOR
                       Valeur = 12;
                     }
                    break;

        case 12:    if (Reception_UART1 == XOR){      // (0x02) (0x81) (Nbe data+1) (Data) (CS)
                       F_Message_OK = 1;
                     }
                     Valeur = 0;
                    break;

        //---------------------------------------------  Command_MODE OK
        case 20:    if (Reception_UART1 == 0x01) Valeur = 21;
                    else                         Valeur = 0;
                    break;

        case 21:    if (Reception_UART1 == 0x10) Valeur = 22;      // Command_MODE OK
                    else                         Valeur = 0;
                    break;

        case 22:    if (Reception_UART1 == 0x57){     //Command_MODE OK : 0x02 0x44 0x01 0x10 0x57
                       Commande_Mode_OK = 1;
                     }
                    Valeur = 0;
                    break;

        //---------------------------------------------  Command_MODE OK
        case 50:    if (Reception_UART1 == 0xFF) LED_V = ~LED_V;
                    Valeur = 0;
                    break;

        //--------------------------------------------- DEFAUT
        default:    Valeur = 0;
      }

      CTS = 1;      // Je libére CTS pour signaler que le PIC est dispo
   }
   
//-----------------------          UART 2        -----------------------------
  if((RC2IF_bit==1) && (RC2IE_bit==1)) {

     Reception_UART2 = Read_Uart2(); // On récupere la donnée
    
     LED_R = ~LED_R;

     switch (Valeur2){
        case 0:     if (Reception_UART2 == 0x02) Valeur2 = 1;
                    else                         Valeur2 = 0;
                    break;

        case 1:     if (Reception_UART2 == 0x99) Valeur2 = 2;
                    else                         Valeur2 = 0;
                    break;

        case 2:     if (Reception_UART2 == 0xFF)
                    F_Message_OK = 1;
                    Valeur2 = 0;
                    break;
      }
   }
}

#include "Initialisation_AMB8626.h"

//#################################################################################################
//#########################################      MAIN      ########################################
//#################################################################################################
void main() {

   // Disable comparator
    CM1CON0 = 0;
    CM2CON0 = 0;

    // registre des LATx à 0
    LATA = LATB = LATC = LATD = LATE = 0;

    // registre analogiques
    ANSELA = 0b10000000;     // RA7 en analogique
    ANSELB = 0;              // Tout en numérique
    ANSELC = 0b00000001;     // RC0 en analogique
    ANSELD = 0b10100000;     // RD5 et RD7 en analogique
    ANSELE = 0;              // Tout en numérique

    // registres des I/O
    TRISA = 0b11101111;      // RA4 en sortie pour liaison
    TRISB = 0b11011111;      // RB5 en sortie Pour UART-TX2
    TRISC = 0b10100001;      // En sortie RC1 et RC2 pour led test, RC3 et RC4 pour liaison AMB et RC6 pour Tx1
    TRISD = 0b11111000;      // En sortie RC0, RC1 et RC2 pour liaison AMB
    TRISE = 0b11111111;      // Tout en entrée

    // Registre des Pull-UP
    WPUA = 0x0F;             // RA0, RA1, RA2 et RA3 en Pull UP
    WPUB = 0x0F;             // RB0, RB1, RB2 et RB3 en Pull UP
    WPUC = 0 ;
    WPUD = 0;
    WPUE = 0x01;             // RE0 en pull up pour BP

    // -----------------     Initialisation de la lecture analogique/numérique  ----------------------------------
    ADC_Init();
    delay_ms(10);
    ADFM_bit = 0;               // Justification à gauche. ainsi je transforme la lecture sur 10 bits en 8 bits et j'ignore les petits chiffres
    TRISD.B5 = TRISD.B7 = TRISA.B7 = TRISC.B0 = 1;    // met RA7, RC0,RD5 et RD7 en entrée
    ADPCH = 0b011101;           // Lecture de RD5 par défaut


    // -----------------     Initialisation AMB8626   ----------------------------------
    Initialisation_AMB8626();  // Se trouve dans un Header a dé-commenter pour un changement de la config
    delay_ms(10);

    //----- Lecture des valeurs des trim sauvegarder en EEPROM
    V_Trim_G_HB = EEPROM_Read(0x01);
    delay_ms(20);
    V_Trim_G_DG = EEPROM_Read(0x02);
    delay_ms(20);
    V_Trim_D_HB = EEPROM_Read(0x03);
    delay_ms(20);
    V_Trim_D_DG = EEPROM_Read(0x04);

    //----- Enregistrement du point milieu au demarrage,
    // cela implique qu'il faut mettre les joysticks au milieu a l'allumage
    Lecture_Potar();                    // Je vais lire mes potars qui sont au PM
    Mem_Joystick_G_HB = Joystick_G_HB;
    Mem_Joystick_G_DG = Joystick_G_DG;
    Mem_Joystick_D_HB = Joystick_D_HB;
    Mem_Joystick_D_DG = Joystick_D_DG;
    
//******************************************************************************************************
//******************************************************************************************************
//******************************************************************************************************
  PPSLOCK = 0x55;                 // unlock PPS
  PPSLOCK = 0xAA;
  PPSLOCKED_bit = 0;
  RC6PPS  = 0x09;                 // TX1 -> RC6
  RX1PPS  = 0x17;                 // RX1 <- RC7
  RB5PPS  = 0x0B;                 // TX2 -> RB5
  RX2PPS  = 0x0F;                 // RX2 <- RB7
  PPSLOCK = 0x55;                 // lock PPS
  PPSLOCK = 0xAA;
  PPSLOCKED_bit = 1;

  Init_Uart1(57600);
  Init_Uart2(9600);
  delay_ms(10);

  //------------------------------   INTERRUPTION    -------------------------------------
  RC1IE_bit   = 1 ;      // Active les Interruptions sur Rx UART 1
  RC2IE_bit   = 1 ;      // Active les Interruptions sur Rx UART 2
  INTCON.PEIE = 1 ;      // On active les INT périphériques
  INTCON.GIE  = 1 ;      // On active toutes les INT
  
  // séquence de clignotement au demarrage (3 fois)
  for (i=0;i<=5;i++){
     LED_R = ~LED_R ;
     delay_ms(100);
   }

//#################################################################################################
//###############################      BOUCLE PRINCIPALE      #####################################
//#################################################################################################
 while(1){
  
   Lecture_Trim();       // Je vais lire si il y a un appui à traiter
   Lecture_Potar();      // Je récupere mes valeurs de potars

   // Je test si les joysticks sont bougés (127-131-126-129)
   if ( ((Joystick_G_HB<(Mem_Joystick_G_HB-3)) || (Joystick_G_HB>(Mem_Joystick_G_HB+3))) ||  ((Joystick_G_DG<(Mem_Joystick_G_DG-3)) || (Joystick_G_DG>(Mem_Joystick_G_DG+3))) || ((Joystick_D_HB<(Mem_Joystick_D_HB-3)) || (Joystick_D_HB>(Mem_Joystick_D_HB+3))) ||((Joystick_D_DG<(Mem_Joystick_D_DG-3)) || (Joystick_D_DG>(Mem_Joystick_D_DG+3))) ){
      Cpt_Point_milieu = 0; // Je RAZ la varaible
      Envoi_Cde_Moteur();   // J'envoie les commandes moteurs par radio
    }
   else if (Cpt_Point_milieu<2){   // Si le point milieu est detecté j'envoie deux fois les commandes pour mettre les moteurs à 0.
             Cpt_Point_milieu++;
             Envoi_Cde_Moteur();
    }
   delay_ms(100);         // A modifier suivant le temps du programme
 }
}

//#################################################################################################
//###############################      PROGRAMME SECONDAIRE     ###################################
//#################################################################################################

//-------------------------------------------------------------------------------------------------
// Cette fonction envoie au module radio les valeurs des potars pour les moteurs
void Envoi_Cde_Moteur(){

   while ( RTS != 0);  // J'attends que RTS soit a l'état 0 alors le module est libre, je peux lui envoyer

   //Envoi   d'un message
   Write_Uart1(0x02);             // Start
   Write_Uart1(0x00);             // Commande
   Write_Uart1(0x04);             // Nbe de DATA
   Write_Uart1(Joystick_G_HB);    // DATA
   Write_Uart1(Joystick_G_DG);    // DATA
   Write_Uart1(Joystick_D_HB);    // DATA
   Write_Uart1(Joystick_D_DG);    // DATA
   Write_Uart1(0x02^0x00^0x04^Joystick_G_DG^Joystick_G_HB^Joystick_D_DG^Joystick_D_HB );   //CS
 }

//-------------------------------------------------------------------------------------------------
// Cette fonction lit les valeurs analogiques présentes sur chaque entrées reliées aux potars
// Elle enregistre les valeurs analogiques, les converties et rajoute l'offset des trims
// Elle les envoies eb brut car decodées sur le VHL
void Lecture_Potar(){

     ADPCH = ADC_RD5;               // On change de broche pour lire la suivante ici RD5
     delay_us(50);                  // Stabilisation du changement de channel
     ADCON0.ADGO = 1;               // lancement de la conversion
     asm NOP;                       // Préconisation de microchip, ne pas checker le bit tout de suite
     asm NOP;                       // donc petite pause de rien du tout
     while (ADCON0.ADGO);           // On attend la fin de la conversion
     Joystick_D_HB = ADRESH;
     Joystick_D_HB += V_Trim_D_HB;

     delay_us(50);                  // On marque une pause, je sais pas pourquoi mais sans elle ca bug

     ADPCH = ADC_RD7;               // On change de broche pour lire la suivante ici RD7
     delay_us(50);
     ADCON0.ADGO = 1;
     asm NOP;
     asm NOP;
     while (ADCON0.ADGO);
     Joystick_D_DG = ADRESH;        // On enregistre le résultat
     Joystick_D_DG += V_Trim_D_DG;

     delay_us(50);

     ADPCH = ADC_RC0;                // On change de broche pour lire la suivante ici RC0
     delay_us(50);
     ADCON0.ADGO = 1;
     asm NOP;
     asm NOP;
     while (ADCON0.ADGO);
     Joystick_G_HB = ADRESH;
     Joystick_G_HB += V_Trim_G_HB;

     delay_us(50);

     ADPCH = ADC_RA7;              // On change de broche pour lire la suivante ici RA7
     delay_us(50);
     ADCON0.ADGO = 1;
     asm NOP;
     asm NOP;
     while (ADCON0.ADGO);
     Joystick_G_DG = ADRESH;
     Joystick_G_DG += V_Trim_G_DG;
 }

//-------------------------------------------------------------------------------------------------
// Cette fonction check la pression sur un BP des trims
// Sil'appui est validé elle incrémente ou décremente et l'enregistre en EEPROM
// Avec le systéme d'ancien état on ne reste pas bloqué dans la
void Lecture_Trim(){

   if ( (BP_Trim_G_H == 0) && (Ancien_etat1==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                   // debounce
      if (BP_Trim_G_H == 0) {
          Ancien_etat1 = 1;                          // Je signale un état bas validé
       }
    }
   if ( (BP_Trim_G_H == 1) && (Ancien_etat1==1) ) {  // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_HB += 1;                              // L'ordre est validé
      Ancien_etat1 = 0;                              // RAZ du flag
      EEPROM_Write(0x01, V_Trim_G_HB);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_G_B == 0) && (Ancien_etat2==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_B == 0) {
          Ancien_etat2 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat2 && (BP_Trim_G_B == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_HB -= 1;                              // L'ordre est validé
      Ancien_etat2 = 0;                              // RAZ du flag
      EEPROM_Write(0x01, V_Trim_G_HB);
      delay_ms(1);
    }
 //---
    if ((BP_Trim_G_D == 0) && (Ancien_etat3==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_D == 0) {
          Ancien_etat3 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat3 && (BP_Trim_G_D == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_DG += 1;                              // L'ordre est validé
      Ancien_etat3 = 0;
      EEPROM_Write(0x02, V_Trim_G_DG);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_G_G == 0) && (Ancien_etat4==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_G == 0) {
          Ancien_etat4 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat4 && (BP_Trim_G_G == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_DG -= 1;                              // L'ordre est validé
      Ancien_etat4 = 0;                              // RAZ du flag
      EEPROM_Write(0x02, V_Trim_G_DG);
      delay_ms(1);
    }
    //---
   if ( (BP_Trim_D_H == 0) && (Ancien_etat5==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_H == 0) {
          Ancien_etat5 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat5 && (BP_Trim_D_H == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_HB += 1;                              // L'ordre est validé
      Ancien_etat5 = 0;                              // RAZ du flag
      EEPROM_Write(0x03, V_Trim_D_HB);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_D_B == 0) && (Ancien_etat6==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_B == 0) {
          Ancien_etat6 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat6 && (BP_Trim_D_B == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_HB -= 1;                              // L'ordre est validé
      Ancien_etat6 = 0;                              // RAZ du flag
      EEPROM_Write(0x03, V_Trim_D_HB);
      delay_ms(1);
    }
//---
   if ( (BP_Trim_D_D == 0) && (Ancien_etat7==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_D == 0) {
          Ancien_etat7 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat7 && (BP_Trim_D_D == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_DG += 1;                              // L'ordre est validé
      Ancien_etat7 = 0;                              // RAZ du flag
      EEPROM_Write(0x04, V_Trim_D_DG);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_D_G == 0) && (Ancien_etat8==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_G == 0) {
          Ancien_etat8 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat8 && (BP_Trim_D_G == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_DG -= 1;                              // L'ordre est validé
      Ancien_etat8 = 0;                              // RAZ du flag
      EEPROM_Write(0x04, V_Trim_D_DG);
      delay_ms(1);
    }
}

//---------------------------------------------------------------------------------------------------------------
void Init_Uart1( unsigned long baudrate)
{
  BAUD1CON = 0b00001000;            // ABDOVF=0; RCIDL=0; bit5=vide; SCKP=0; BRG16=1; bit2=vide; WUE=0; ABDEN=0
  SP1BRG   = 64000000/4/baudrate-1; // SP1BRG = SPBRGH + SPBRGL = (Fosc/4/Baudrate)-1
  TX1STA   = 0b00100100;            // CSRC=0; TX9=0; TXEN=1; SYNC=0; SENDB=0; BRGH=1; TRMT=0; TX9D=0
  RC1STA   = 0b10010000;            // SPEN=1; RX9=0; SREN=0; CREN=1; ADDEN=0; FERR=0; OERR=0; RX9D=0
}

char Read_Uart1(void)
{
  return RC1REG;
}

void Write_Uart1(char Data)
{
   while (!TX1IF_bit) ;
   TX1REG = Data;
}

//----------------------------------------------------------------------------------------------------
void Init_Uart2( unsigned long baudrate)
{
  BAUD2CON = 0b00001000;            // ABDOVF=0; RCIDL=0; bit5=vide; SCKP=0; BRG16=1; bit2=vide; WUE=0; ABDEN=0
  SP2BRG   = 64000000/4/baudrate-1; // SP1BRG = SPBRGH + SPBRGL = (Fosc/4/Baudrate)-1
  TX2STA   = 0b00100100;            // CSRC=0; TX9=0; TXEN=1; SYNC=0; SENDB=0; BRGH=1; TRMT=0; TX9D=0
  RC2STA   = 0b10010000;            // SPEN=1; RX9=0; SREN=0; CREN=1; ADDEN=0; FERR=0; OERR=0; RX9D=0
}

char Read_Uart2(void)
{
  return RC2REG;
}

void Write_Uart2(char Data)
{
   while (!TX2IF_bit) ;
   TX2REG = Data;
}