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 ---
- 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 ---
Modérateur : Jérémy
2xUART en mode PPS ?
2xUART en mode PPS ?
-
Jérémy
Administrateur du site- Messages : 2722
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
Ok le code avec les deux UART focntionnent sans les Interruptions . Ca avance tranquilement :
Allez Zou je me lance dans le traitement sur interruption
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
2xUART en mode PPS ?
2xUART en mode PPS ?
-
Jérémy
Administrateur du site- Messages : 2722
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
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 .
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;
}
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 46 invités