Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

2xUART en mode PPS ?
Jérémy
Administrateur du site
Administrateur du site
Messages : 2159
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#21 Message par Jérémy » lun. 20 août 2018 20:45 lien vers la Data-Sheet : Cliquez ici

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
C'est en faisant des erreurs, que l'on apprend le mieux !!!

2xUART en mode PPS ?
Jérémy
Administrateur du site
Administrateur du site
Messages : 2159
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#22 Message par Jérémy » lun. 20 août 2018 21:01 lien vers la Data-Sheet : Cliquez ici

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_UART1Reception_UART2 ;
 
unsigned char F_Test;

//##################################     PROTOTYPE    ##############################################
void Init_Uart1unsigned long);
void Init_Uart2unsigned 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_bitWrite_Uart1(Read_Uart1()+1);
    if (
RC2IF_bitWrite_Uart2(Read_Uart2()+2);
 }
}

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

void Init_Uart1unsigned 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_Uart2unsigned 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
C'est en faisant des erreurs, que l'on apprend le mieux !!!

2xUART en mode PPS ?
Jérémy
Administrateur du site
Administrateur du site
Messages : 2159
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#23 Message par Jérémy » lun. 20 août 2018 21:34 lien vers la Data-Sheet : Cliquez ici

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) :sifflotte:
C'est en faisant des erreurs, que l'on apprend le mieux !!!

2xUART en mode PPS ?
Jérémy
Administrateur du site
Administrateur du site
Messages : 2159
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#24 Message par Jérémy » lun. 20 août 2018 22:16 lien vers la Data-Sheet : Cliquez ici

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=;
 
unsigned char Joystick_D_HBJoystick_D_DGJoystick_G_HBJoystick_G_DG;
 
unsigned char Mem_Joystick_D_HBMem_Joystick_D_DGMem_Joystick_G_HBMem_Joystick_G_DG;
 
signed char  V_Trim_D_HBV_Trim_D_DGV_Trim_G_HBV_Trim_G_DG;

//----- UART
 
unsigned char Reception_UART1Reception_UART2ValeurValeur2,Reseau ;
 
unsigned char Commande_Mode_OKParametre_OKRESET_OKF_Message_OK;
 
unsigned char Index_Buff1Long_Buff1;
 
unsigned int XOR;
 
char Buffer_UART1[50];

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

void Init_Uart1unsigned long);
void Init_Uart2unsigned 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 ;       // 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 ;
                     }
                     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 == 0x01Valeur 3// Nombre bytes
                   
else                         Valeur 0;
                   break;

        case 
3:    if (Reception_UART1 == 0x00Valeur 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 == 0x01Valeur 21;
                    else                         
Valeur 0;
                    break;

        case 
21:    if (Reception_UART1 == 0x10Valeur 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 == 0xFFLED_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 == 0x02Valeur2 1;
                    else                         
Valeur2 0;
                    break;

        case 
1:     if (Reception_UART2 == 0x99Valeur2 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 ;
    
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   ;      // Active les Interruptions sur Rx UART 1
  
RC2IE_bit   ;      // Active les Interruptions sur Rx UART 2
  
INTCON.PEIE ;      // On active les INT périphériques
  
INTCON.GIE  ;      // 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(0x01V_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(0x01V_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(0x02V_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(0x02V_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(0x03V_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(0x03V_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(0x04V_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(0x04V_Trim_D_DG);
      
delay_ms(1);
    }
}

//---------------------------------------------------------------------------------------------------------------
void Init_Uart1unsigned 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_Uart2unsigned 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;


Merci !
C'est en faisant des erreurs, que l'on apprend le mieux !!!


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité