| RobotICAM
Coupe 2006
Notre Robot
Support Elec
Support Info
Support Meca
|
Afin de repérer les trous sur le terrain de jeux, nous avons fabriqué une barre de 32 capteurs infrarouges.
Le code ci-dessous permet a partir d'un DSPic, de lire chaque capteur et d'analyser par la suite les données reçu.
Il y a plusieurs algorithmes qui détectent certaines spécificités du terrain afin de calculer les coordonnées du centre du trou.
Certains détectent les frontières entre le vert et le cercle de couleur par exemple.
Cependant, le gros problème des capteurs infrarouges, c'est qu'ils sont facilement éblouis sable si le terrain est brillant comme ce fut le cas pour la coupe de robotique. Cependant, il existe des solutions. On peut soit incliné la barre afin de supprimer les reflets. Mais l'on peut aussi, utiliser des capteurs de couleur.
Sinon, lorsque la barre est bien calfeutrée, il n'y a pas de problèmes et la barre est très fiable.
Les Tipons sont disponible en en téléchargement ci-dessus.
//--------------------------------------------------------------
//--------------------------------------------------------------
// BARRE IR by Benji
// Version 1.2.5 du 12 avril 2006
// VITESSE a 16Mips: 307 à 168 analyse par seconde.
//--------------------------------------------------------------
//--------------------------------------------------------------
#include <p30f2010.h>
#include <uart.h>
#include <stdio.h>
#include <stdlib.h>
_FOSC(CSW_FSCM_OFF & XT_PLL16); //XT with 16xPLL oscillator, Failsafe clock off
_FWDT(WDT_OFF); //Turn off the Watch-Dog Timer.
_FBORPOR(MCLR_EN & PWRT_OFF); //Enable MCLR reset pin and turn off the
//power-up timers.
_FGS(CODE_PROT_OFF); //Disable Code Protection
//----------------------------------------------------------------------------
// VARIABLE
//----------------------------------------------------------------------------
char buffer[16]; // Buffer com serie
//Variable Port Serie
#define FCY 16000000 //Nombre d'instruction seconde
#define BAUDRATE 19200 //Vitesse port serie
//Variable de seuils
unsigned char VertMax; //Seuil Vert - Noir
unsigned char VertMin; //Seuil Rouge/Bleue - Vert
//Variable d'analyse
unsigned char Centre = 0; //Variables des algos d'analyse
unsigned char Result = 0;
unsigned char Result1 = 0;
unsigned char Result2 = 0;
unsigned char Result3 = 0;
unsigned char Result4 = 0;
unsigned char Result5 = 0;
unsigned char Result6 = 0;
unsigned char Result6b = 0;
unsigned char BlueRed = 0;
unsigned char BarreNoire = 0;
unsigned char Bord1 = 0; //coordonée gauche de la bordure rouge/bleu
unsigned char Bord2 = 0; //coordonée droite de la bordure rouge/bleu
unsigned char NbrTroup = 0;
//variable aquisition
unsigned int i = 0;
unsigned int j = 0;
unsigned int k = 0;
unsigned char Digit1 = 0;
unsigned char Digit2 = 0;
unsigned char Digit3 = 0;
unsigned char mynumber;
unsigned char capteur[33];
unsigned int moyene;
//Variable de memoire
unsigned char Memoire1[10];
unsigned char Tampon1;
unsigned char Tampon2;
unsigned char BarreMemoire;
//variable couleur troup
unsigned char Couleurtroup;
unsigned char Couleurtroup2;
unsigned char notrecouleur;
unsigned int tmprb = 0;
unsigned int tmpseuil = 0;
//----------------------------------------------------------------------------
// DELAY
//----------------------------------------------------------------------------
void DelayCY(unsigned char j)
{
while(j--) { }
}
//----------------------------------------------------------------------------
// INITIALISATION PORTS
//----------------------------------------------------------------------------
void inipic(void)
{
OSCCON = 0b0011001101000000; //Config Oscillateur...
TRISB = 255; //223; //255; //RB5= interupteur couleur diode troup trouvé (VERTE)
TRISC = 24575; // Initialisation des ports
TRISD = 0; PORTD = 0; //RD0 = diode init bad (ROUGE) // RD1 = diode reception "b" (vert)
TRISE = 0; PORTE = 0;
// Initialisation CAN
ADPCFG = 0xFFF0; // all ANALOG A0-A3 et DIGITAL le reste
ADCON1 = 0x0000; // SAMP bit = 0 ends sampling ...
ADCHS = 0x0000; // Connect RB0/AN0 as CH0 input ..
ADCSSL = 0; // Skip ANx for input scan
ADCON3 = 0x0002; // Manual Sample, Tad = internal 2 Tcy
ADCON2 = 0;
ADCON1bits.ADON = 1; // turn ADC ON
}
//----------------------------------------------------------------------------
// INIT PWM
//----------------------------------------------------------------------------
void init_pwm(void)
{
//Config PWM
PTCONbits.PTEN =1;
PTCONbits.PTSIDL =0;
PTCONbits.PTOPS =0b1111; //Postcaler 1:16 (sert a rien en freemode)
PTCONbits.PTCKPS =0b00; //Prescaler 1:1
PTCONbits.PTMOD =0b00; //Free mode runing
PTMRbits.PTDIR = 0; //Counting up
PTMRbits.PTMR = 5000; //Time base Count Value
PTPER = 300; //Time base Periode value
PDC3 = 350; //Duty Cycle Rapport cyclique sur PWM3
//variation: 100 à 600. 50% pour 280.
//Config PWM3 sur Patte E5
PWMCON1bits.PEN3L =0 ;
PWMCON1bits.PEN3H =1 ;
PWMCON1bits.PMOD3 =1 ;
OVDCONbits.POVD3H =1;
OVDCONbits.POVD3L =0;
}
//----------------------------------------------------------------------------
// INIT PORT SERIE
//----------------------------------------------------------------------------
void init_serie(void)
{
unsigned int baudvalue;
unsigned int U1MODEvalue;
unsigned int U1STAvalue;
ConfigIntUART1(UART_RX_INT_DIS & UART_TX_INT_DIS );
U1MODEvalue = UART_EN & UART_IDLE_CON & UART_ALTRX_ALTTX &
UART_DIS_WAKE & UART_DIS_LOOPBACK &
UART_DIS_ABAUD & UART_NO_PAR_8BIT &
UART_1STOPBIT;
U1STAvalue = UART_INT_TX_BUF_EMPTY &
UART_TX_PIN_NORMAL &
UART_TX_ENABLE & UART_INT_RX_CHAR &
UART_ADR_DETECT_EN &
UART_RX_OVERRUN_CLEAR;
baudvalue = ((FCY/16)/BAUDRATE) - 1; //Calcul de la vitesse de communication
OpenUART1(U1MODEvalue, U1STAvalue, baudvalue);
}
//----------------------------------------------------------------------------
// COM SERIE
//----------------------------------------------------------------------------
void putsUSART_rom(char *data) // Envoi d'une chaine de caractere sur serie
{
char test;
//Reception: Lit le dernier caractére recu dans le buffer
test = 0;
IFS0bits.U1RXIF = 0;
while( DataRdyUART1())
{
test = ReadUART1();
}
//Envoie les données
if (test == 98) //si on a recu un "b"
{
// Change la couleur de la diode
if (PORTDbits.RD1 == 0) {PORTDbits.RD1 = 1;}
else {PORTDbits.RD1 = 0;}
//Envoie des données
do
{
while (BusyUART1());
putcUART1(*data);
}
while (*data++);
}
}
//----------------------------------------------------------------------------
// ENVOYER CHIFFRE PAR PORT SERIE
//----------------------------------------------------------------------------
void SendData(unsigned char myvar1,unsigned char myvar2)
{
// Ecris sur le port le mot
//Premiere variable
Digit1 = 0; Digit2 = 0; Digit3 = 0;
mynumber = myvar1;
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
for (j=0;j<9;j++){ if (mynumber>9){Digit2++; mynumber = mynumber-10;}}
Digit3 = mynumber;
//Couleur troup
//if (myvar1 != 0)
//{
// Digit1 = Digit1 + Couleurtroup;
//}
buffer[0] = Digit1+0x30;
buffer[1] = Digit2+0x30;
buffer[2] = Digit3+0x30;
//Deuxieme variable
Digit1 = 0; Digit2 = 0; Digit3 = 0;
mynumber = myvar2;
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
for (j=0;j<9;j++){ if (mynumber>9){Digit2++; mynumber = mynumber-10;}}
Digit3 = mynumber;
buffer[3] = Digit2+0x30;
buffer[4] = Digit3+0x30;
buffer[5] = '\0';
//On utilisé le meme port série pour 2 PIC.
//Donc on doit mettre la patte d'émission en entrée l'orsque l'on ne l'utilise pas.
TRISC = 24575; //Patte Tx en sortie
putsUSART_rom(buffer);
TRISC = 32767; //Patte Tx en entrée
}
//----------------------------------------------------------------------------
// FONCTIONS D ACQUISITION
//----------------------------------------------------------------------------
unsigned int LectureCH (unsigned int Chx)
{
ADCHS = Chx; // Conection à la bonne patte
ADCON1bits.SAMP = 1; // start sampling ...
DelayCY(20); // for 10 Tcy (can be more: like 1ms)
ADCON1bits.SAMP = 0; // start Converting
while (!ADCON1bits.DONE); // conversion done?
{ }
return ADCBUF0; //on renvoie la VALEUR
}
//----------------------------------------------------------------------------
// AQUISITION DES DONNEES DES CAPTEURS
//----------------------------------------------------------------------------
void Captures(void)
{
//acquisition des 4x8 valeurs
for (i=0;i<8;i++)
{
//sélectione le canal
PORTE = i;
//Attend que ca commute
for (j=0;j<10;j++) //4
{
DelayCY(250);
}
//Récupére les 4 valeurs et les passe sur 8bits
capteur[i] = LectureCH(0x0000)/4;
capteur[i+8] = LectureCH(0x0001)/4;
capteur[i+16] = LectureCH(0x0002)/4;
capteur[i+24] = LectureCH(0x0003)/4;
}
//Correction des erreurs sur certains capteurs
if(capteur[2]<230) { capteur[2]=capteur[2]+21;} else {capteur[2]=250; }
if(capteur[6]<240) { capteur[6]=capteur[6]+12;} else {capteur[6]=250; }
if(capteur[18]<240) { capteur[18]=capteur[18]+9;} else {capteur[18]=250; }
if(capteur[20]<230) { capteur[20]=capteur[20]+15;} else {capteur[20]=250; }
if(capteur[23]<240) { capteur[23]=capteur[23]+11;} else {capteur[23]=250; }
if(capteur[29]<240) { capteur[29]=capteur[29]+8;} else {capteur[29]=250; }
if(capteur[31]<230) { capteur[31]=capteur[31]+10;} else {capteur[31]=250; }
if(capteur[1]>25) { capteur[1]=capteur[1]-19;} else {capteur[1]=5; }
if(capteur[5]>30) { capteur[5]=capteur[5]-27;} else {capteur[5]=5; }
if(capteur[7]>30) { capteur[7]=capteur[7]-27;} else {capteur[7]=5; }
if(capteur[8]>30) { capteur[8]=capteur[8]-24;} else {capteur[8]=5; }
if(capteur[10]>15) { capteur[10]=capteur[10]-10;} else {capteur[10]=5; }
if(capteur[11]>20) { capteur[11]=capteur[11]-13;} else {capteur[11]=5; }
if(capteur[13]>30) { capteur[13]=capteur[13]-25;} else {capteur[13]=5; }
if(capteur[21]>20) { capteur[21]=capteur[21]-11;} else {capteur[21]=5; }
if(capteur[26]>20) { capteur[26]=capteur[26]-15;} else {capteur[26]=5; }
}
//----------------------------------------------------------------------------
// INITIALISATION DES CAPTEURS: CALIBRAGE DES SEUILS
//----------------------------------------------------------------------------
void init_calibrage(void)
{
//Lit la ligne
Captures();
Captures();
Captures();
Captures();
Captures();
Captures();
moyene = 0;
for (i=0;i<32;i++)
{
moyene = moyene + (unsigned int)capteur[i];
}
moyene = moyene /32;
//Afine la calibration
VertMax = (unsigned char)moyene + 50;
VertMin = (unsigned char)moyene - 35;
//Verifie si c pas bon
//PORTDbits.RD0 = 1;
if ((moyene < 180) || (moyene > 150))
{
PORTDbits.RD1 = 0;
} // Initialisation: Alume LED de TX
}
//----------------------------------------------------------------------------
// ANALYSE: INITIALISATION
//----------------------------------------------------------------------------
void AnalyseInit(void)
{
//Initialise
NbrTroup = 0;
BlueRed = 0;
//Applique le masque ( 0 pour < VertMin // 1 pour vert // 2 pour > VertMax
for (i=0;i<32;i++)
{
if ( capteur[i]< VertMin ) { capteur[i] = 0; BlueRed++; } // 0 = Bleu/rouge
else if ( capteur[i]> VertMax ) { capteur[i] = 2; NbrTroup++;} // 2 = Troup
else { capteur[i] = 1;} // 1 = Vert
}
}
//----------------------------------------------------------------------------
// ANALYSE1: CALCUL DU CENTRE DU TROUP (par Algo de centre): Algo peu précis mais peu corrigé de fort décalage
//----------------------------------------------------------------------------
unsigned char Analyse1(void)
{
//Calcule le centre du troup
if (NbrTroup > 5)
{
for (i=0;i<32;i++)
{
if ( capteur[i] == 2 ) { Centre = i*2 + NbrTroup - 1; i=32;}
}
}
else { Centre = 0;}
//revoie la VALEUR
return Centre; //NOTA: On a extrapolé à 64 capteurs. Le milieu est donc 31
}
//----------------------------------------------------------------------------
// ANALYSE1: CALCUL POUR LES FORTS DECALAGES: Frontiére Bleu-Rouge/Vert
//----------------------------------------------------------------------------
unsigned char Analyse1bis(void)
{
//Initialise
NbrTroup = 0;
Bord1 = 32; Bord2 = 0;
//Applique le masque ( 0 pour < VertMin // 1 pour vert // 2 pour > VertMax
//detecte les bords
for (i=1;i<10;i++)
{
if ((Bord1== 32) && (capteur[i-1]== 0) && (capteur[i]== 0) && (capteur[i+1]== 0) && (capteur[i+2]== 1) && (capteur[i+3]== 1) && (capteur[i+4]== 1)) { Bord1 = i;}
}
for (i=18;i<28;i++)
{
if ((Bord1== 32) && (Bord2== 0) && (capteur[i-1]== 1) && (capteur[i]== 1) && (capteur[i+1]== 1) && (capteur[i+2]== 0) && (capteur[i+3]== 0) && (capteur[i+4]== 0)) { Bord2 = i+3;}
}
//calcule le centre
if ((Bord1 !=32) && (Bord2 == 0)) { Centre = Bord1*2;}
else if ((Bord1 ==32) && (Bord2 != 0)) { Centre = Bord2*2;}
else { Centre = 0;}
//revoie la VALEUR
return Centre; //NOTA: On a extrapolé à 64 capteurs. Le milieu est donc 31
}
//----------------------------------------------------------------------------
// ANALYSE2: CALCUL DU CENTRE DU TROUP (par Algo des bords): Detection frontiere entre Vert et Rouge/Bleu
//----------------------------------------------------------------------------
unsigned char Analyse2(void)
{
//Initialise
NbrTroup = 0;
Bord1 = 32; Bord2 = 0;
//detecte les bords
for (i=1;i<30;i++)
{
if ((capteur[i-1]== 1) && (capteur[i]== 1) && (capteur[i+1]== 0) && (capteur[i+2]== 0)) { Bord1 = i+1;}
if ((capteur[i-1]== 0) && (capteur[i]== 0) && (capteur[i+1]== 1) && (capteur[i+2]== 1)) { Bord2 = i;}
}
//calcule le centre
if (Bord1 < Bord2) { Centre = Bord1 + Bord2;}
else { Centre = 0;}
//revoie la VALEUR
return Centre; //NOTA: On a extrapolé à 64 capteurs. Le milieu est donc 31
}
//----------------------------------------------------------------------------
// ANALYSE3: CALCUL DU CENTRE DU TROUP (par Algo des bords): Detéction frontiere Troup/cercle de couleur
//----------------------------------------------------------------------------
unsigned char Analyse3(void)
{
//Initialise
NbrTroup = 0;
Bord1 = 32; Bord2 = 0;
//Applique le masque ( 0 pour < VertMin // 1 pour vert // 2 pour > VertMax
for (i=0;i<32;i++)
{
if ( capteur[i]==2 ) { NbrTroup++;}
}
//Calcule le centre du troup
if (NbrTroup > 3)
{
//detecte les bords
for (i=1;i<30;i++)
{
if ((Bord1== 32) && (capteur[i-1]== 0) && (capteur[i]== 0) && (capteur[i+1]== 2) && (capteur[i+2]== 2)) { Bord1 = i+1;}
if ((Bord1== 32) && (capteur[i-1]== 0) && (capteur[i]== 0) && (capteur[i+1]== 1) && (capteur[i+2]== 2)) { Bord1 = i+1;}
if ((capteur[i-1]== 2) && (capteur[i]== 2) && (capteur[i+1]== 0) && (capteur[i+2]== 0)) { Bord2 = i;}
if ((capteur[i-1]== 2) && (capteur[i]== 1) && (capteur[i+1]== 0) && (capteur[i+2]== 0)) { Bord2 = i;}
}
//calcule le centre
if (Bord1 < Bord2) { Centre = Bord1 + Bord2;}
else { Centre = 0;}
}
else { Centre = 0;}
//revoie la VALEUR
return Centre; //NOTA: On a extrapolé à 64 capteurs. Le milieu est donc 32
}
//----------------------------------------------------------------------------
// ANALYSE4: CALCUL DU DIAMETRE DU TROUP
//----------------------------------------------------------------------------
unsigned char Analyse4(void)
{
//Initialise
NbrTroup = 0;
//Methode 1: Diametre troup
//Lecture du masque
for (i=0;i<32;i++)
{
if ( capteur[i]== 2 ) { NbrTroup++;}
}
return NbrTroup;
}
//----------------------------------------------------------------------------
// ANALYSE5: CONSIGNE SUR Y: Pas super précis
//----------------------------------------------------------------------------
unsigned char Analyse5(void)
{
//Methode1: Calcul avec le NOIR
if(Result4 != 0)
{
Centre = Result4;
if (Centre > 9) { return 0;}
else if (Centre == 9) { return 2;} //Correction sur Y (1=2.5mm)
else if (Centre == 8) { return 4;}
else if (Centre == 7) { return 5;}
else if (Centre == 6) { return 7;}
else if (Centre > 0) { return 8;}
else
{ return 0;} //retourne 0 pour diametre max ou si pas de correction trouvé
}
//Methode2: Calcul avec le cercle Bleu/Rouge
else if ((Bord1 != 32 ) && (Bord2!= 0)) //Si le troup est completement scanné
{
Centre = Bord2-Bord1;
if (Centre > 19) { return 0;}
else if (Centre == 19){ return 2;} //Correction sur Y (1=2.5mm)
else if (Centre == 18){ return 6;}
else if (Centre == 17){ return 9;}
else if (Centre == 16){ return 11;}
else if (Centre == 15){ return 13;}
else if (Centre == 14){ return 14;}
else if (Centre == 13){ return 15;}
else if (Centre == 12){ return 16;}
else if (Centre > 9) { return 17;}
else if (Centre == 9) { return 18;}
else if (Centre == 8) { return 19;}
else if (Centre > 0) { return 20;}
else
{ return 0;} //retourne 0 pour diametre max ou si pas de correction trouvé
}
else
{ return 0;}
}
//----------------------------------------------------------------------------
// Couleur: DETECTION BALLE BLANCHE
//----------------------------------------------------------------------------
unsigned char Couleur(void)
{
Centre = 0;
//Algo de correction d'erreurs
for (i=0;i< Bord1;i++) { if((capteur[i] == capteur[i+2]) && (capteur[i] != capteur[i+1])) { capteur[i+1] = capteur[i] ; }}// Correction AVANT
for (i=Bord2;i<31 ;i++){ if((capteur[i] == capteur[i+2]) && (capteur[i] != capteur[i+1])) { capteur[i+1] = capteur[i] ; }}// Correction APRES
//detecte si on a: 002-000 ou 002-001
for (i= Bord1;i<Bord2;i++)
{
if ((capteur[i-1]== 2) && (capteur[i]== 0)) { Centre = 100; Result6b=100;}
if ((capteur[i-1]== 2) && (capteur[i]== 1)) { Centre = 100; Result6b=100;}
}
//Si on avais détecté une balle et que l'on a pas changé de troup
if ((Result6b == 100) && (Result != 0)) {Centre = 100;}
else {Centre = 0; Result6b=0;}
// Correction APRES
if( Bord1 < Bord2){ for (i=Bord1;i<Bord2-1 ;i++){ capteur[i] = 2;}}
return Centre;
}
//----------------------------------------------------------------------------
// Barre: DETECTION de la barre noire
//----------------------------------------------------------------------------
unsigned char Barre(void)
{
if ((BlueRed < 2) && (NbrTroup > 2)) { return 1;} //PORTDbits.RD0 = 1; }
else { return 0;} //PORTDbits.RD0 = 0;}
}
//----------------------------------------------------------------------------
// CTroup: COULEUR DES TROUPS
//----------------------------------------------------------------------------
unsigned char CTroup(void)
{
Couleurtroup = 1;
Couleurtroup2= 1;
tmprb = 0;
//Lecture des capteurs
for (i=0;i<32;i++)
{
if ( capteur[i] < 50 ) { tmprb = tmprb + capteur[i]; Couleurtroup++;}
if ( capteur[i] < 15 ) { Couleurtroup2++;}
}
//tmpseuil = Couleurtroup* 12;
//if (tmpseuil > tmprb) {Couleurtroup = 1;} // couleur rouge detecté
//else {Couleurtroup = 0;} // couleur bleu detecté si un troup detecté
tmpseuil = Couleurtroup*100;
tmpseuil = tmpseuil/Couleurtroup2;
if (tmpseuil > 65) {Couleurtroup = 1;} // couleur rouge detecté
else {Couleurtroup = 0;}
if (Couleurtroup == notrecouleur) {Couleurtroup = 2;}
else {Couleurtroup = 0;}
}
//----------------------------------------------------------------------------
// Procedure de diagnostic
//----------------------------------------------------------------------------
void SendSerial2(unsigned char myvar1)
{
// Ecris sur le port le mot
//Premiere variable
Digit1 = 0; Digit2 = 0; Digit3 = 0;
mynumber = myvar1;
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
if (mynumber>99){Digit1++; mynumber = mynumber-100;}
for (j=0;j<9;j++){ if (mynumber>9){Digit2++; mynumber = mynumber-10;}}
Digit3 = mynumber;
buffer[0] = Digit1+0x30;
buffer[1] = Digit2+0x30;
buffer[2] = Digit3+0x30;
buffer[3] = 0x29;
SendSerial1(buffer);
}
void SendSerial1(char *data) // Envoi d'une chaine de caractere sur serie
{
do
{
while (BusyUART1());
putcUART1(*data);
}
while (*data++);
for (j=0;j< 15;j++) {buffer[j]=0x00;}
}
//----------------------------------------------------------------------------
// MAIN
//----------------------------------------------------------------------------
int main(void)
{
//Initialisation
inipic();
init_serie();
TRISC = 32767;
init_pwm();
PDC3 = 550;
init_calibrage();
//notrecouleur = PORTBbits.RB5;
//Lecture des capteurs et annalyse
while (1)
{
//Récupére les 32 valeurs de la ligne
Captures();
//diagnostic(1);
//Reinitialise
Result1 = 0;Result2 = 0;Result3 = 0;
Result4 = 0;Result5 = 0;Result6 = 0;
//Analyse des valeurs recus
//CTroup();
AnalyseInit();
Result3 = Analyse3(); //Frontiere Bleu/Trou
Result6 = Couleur(); //Balle blanche
//Result1 = Analyse1(); //Comptage Trou
//BarreNoire = Barre(); //Détéction barre noire
Result2 = Analyse2(); //Frontiere Vert/Bleu
Result4 = Analyse4(); //diametre
Result5 = Analyse5(); //Decalage Y
Result1 = Analyse1bis();//Fort décalage
//Eteint la diode
PORTDbits.RD0 = 1;
//SI DIAMETRE SUFISANT OU BORDS DETECTES
Result = Result1 + Result2 + Result3;
if (Result != 0)
{
//Confronte les résultats
Result = 0;
if (Result2 != 0) {Result = Result2;}
else if (Result3 != 0) {Result = Result3;}
else {Result = Result1;}
//alume la diode
PORTDbits.RD0 = 0;
}
Result1 = Result + Result6;
//Enregistre les résultats actuels
Tampon1 = Result1;
Tampon2 = Result5;
//Des mauvaises messures peuvent arrivé. Donc on compare avec les
//résultats précédent.
//Met à jours la mémoire
//Décale la mémoire de 1
for (i=0;i< 4;i++) {Memoire1[i+1]=Memoire1[i];}
//Remplit la case mémoire actuelle
if (Tampon1 != 0) {Memoire1[0]=1;} else {Memoire1[0]=0;}
//Vérifie si l'on peut envoyer au pas le résultat
k =0;
for (i=0;i< 5;i++) { k = k + Memoire1[i];}
if (k < 3){ Tampon1 = 0; Tampon2 = 0;} else {PORTDbits.RD0 = 0;}
//Envoi des résultats
SendData(Tampon1,Tampon2);
}
}
//---------------------------------------------------------------------------
Pour toutes questions: benjamin.baque AT polymtl.ca
|
