CAN sur PIC18F45K22

[flolarajasse]

Bonjour à tous,

J'utilise le CAN du PIC18F45K22 afin de lire l'entrée d'un potentiomètre de 10KOhm.
Je n'ai jamais utilisé le CAN, j'ai regardé sur la Datasheet les différents registres à paramétrer.

Travaillant sous MPLABX v2.10 avec XC8 comme compilateur, je voulais utiliser le simulateur afin de vérifier le résultat de ma conversion en temps réel.
N'ayant jamais utilisé le simulateur, est ce que c'est possible?
Je pensais mettre le résultat de la conversion dans une variable, et ensuite la visualiser.

Merci,
-----

[RISC]

Salut,

La carte PICDEM 2 PLUS utilise soit un PIC16F1937, soit un PIC18F46K22 (le grand frère du PIC18F45K22).
Tu peux récupérer le schéma de cette carte qui a aussi un potentiomètre dans le Manuel de la carte PICDEM 2 PLUS.
Ensuite, tu peux récupérer le code de cette carte ici.
Le programme de test utilise le potentiomètre sur la carte. Tu pourras facilement voir comment il est initialisé ;=)
Il existe aussi pas mal d'exemples de code pour les PIC18 ici..

Autre avantage de ce PIC, il est géré dans le Configurateur Graphique de MPLAB X (MCC).
En utilisant ce plugin, tu peux initialiser ton PIC de façon graphique. Le code est généré pour toi. Il suffit d'installer le plugin MCC dans MPLAB X (de préférence une version très récente >=2.15).
Le code généré est bien sûr pour le compilateur XC8 (pas le C18).

a+

[terriblement]

RISC, j'ai jetté un coup d'oeil à l'exemple de code pour le 18f46k22;

Tu sais pourquoi ils mettent 3xNOP en appelant la fonction ?

Mis à part, il faut faire attention, les registres TRIS et ANSEL sont paramétrés dans le main.

[alfounet]

Tiens un bout de code pour ton can moi c'est sur le 18F45K20 pour la carte cible du pickit3.

#include <pic18f45k20.h>

/***** bits de configuration */

#pragma config FOSC = INTIO67 //OSC interne, RA6 et RA7 sont utilisé comme entree/sortie, marche aussi en mode LP choix de l'oscillateur ne marche pas en XT ou HS ici la clock provient du PICKIT3
#pragma config WDTEN = OFF, MCLRE = OFF //WDTEN OFF ou ON ca fonctionne, pareil pour MCLRE





unsigned char    sortie;


int main(void)
{
    
    TRISD = 0x00;   //PortD configure en sortie
    TRISA = 0x01;   //Bit0 du PortA configure en entree les autres en sortie
    ADCON0 = 0x01;  //Conversion analogique digital permise bit ADC active
    ADCON1 = 0x00;  //Tension basse et haute produite par le PIC
    ADCON2 = 0x20;  //choix oscillateur FOSC/2 et choix du nombre d'echantillonnage ici 8
    ADFM = 0x00;    //Choix des huit bits en ADRESH OU ADRESL ici en ADRESH les deux bits restants etant dans l'autre registre
    PORTD = 0x00;   //PORTD mis à 0
    ANSEL = 0x01;   //Ferme toutes les autres entrees analogique (mises en digitales)
    ANS0 = 1;      //Fait que le bit RA0 (AN0) est actif en analogique
 

    while(1)
    {
       GO = 1; //ADCON0 = 0X03;     //validation du bit 2 et 1 de ADCON0 qui valide et commence la conversion

        while (GO);         //GO bit 2 de ADCON0 attente fin de conversion
       
            sortie = ADRESH;    //Lit les 8 bits de poids forts on ne s'occupe pas des 2 bits de poids faible
            PORTD = sortie;     //On envoi sur le PORTD la valeur acquise precedement
            ADRESL =0;          //Remise à 0 des deux bits une fois ADRSH pris
    }
}

le NOP veut dire no opération
comme ça l’opération prend un nombre de cycle du µcontrolleur on perd du temps pour laisser le temps à une autre opération de se réaliser complétement.

[A voir en vidéo sur Futura]

[paulfjujo]

bonjour,

pourquoi ils mettent 3xNOP en appelant la fonction ?

je pense qu'il y a un rapport avec le TAD acquisition time mini

The user is responsible for ensuring the required acquisition time
has passed between selecting the desired input
channel and setting the GO/DONE bit.

quoique cela depend de FOSC , et de la façon dont on appel la fonction lecture VoltGetV()
apres avoir selectionné le channel, dans le programme principal..



Nota, dans l'exemple de code precedent

...
PORTD = 0x00;   //PORTD mis à 0
....
 PORTD = sortie;     //On envoi sur le PORTD la valeur acquise precedement

utiliser de preference LATD au lieu de PORTD.

[flolarajasse]

Bonjour à tous,

Et merci de vos réponses.
Je vais regarder ton code RISC.

Ce que je n'arrive pas à faire, ni à comprendre, c'est l'initialisation des registres ADCON1 & ADCON2 ; je ne sais pas quelles valeurs il faut choisir, et surtout comment les choisir.
Je ne demande pas le code, je veux savoir comment cela fonctionne et quelles valeurs il faut choisir.

Je ne sais pas si cela a une grande importance, mais je travaille avec un quartz externe de 10MHz.

Ensuite, ou trouver la valeur de ma conversion si je la stocke dans une variable?Je n 'ai pas tout compris le principe de MCC, je vais tenter de comprendre.

[flolarajasse]

Bonjour,

Étant en train de comprendre le fonctionnement du CAN, une question se pose : Je ne vois pas la différence entre le bit ADIF du registre PIR1 et le bit GO/_DONE du registre ADCON0?
Je pensais faire un programme dans ce genre :

Programme principal
{
   Initialisation ADC
   while(1)
   {
      tant que (conversion non terminée) // ADIF ou GO/_DONE?
      {
           on ne fait rien
      }
      sinon
      On stocke la valeur des registres ADRESH & ADRESL dans 2 variables
   }
}

Est ce que c'est comme cela, en gros, qu'il faut procéder? Encore une petite question, comment mettre la valeurs de mes registres ADRESH & ADRESL dans une seule même variable, un unsigned int par exemple, afin que je puisse faire du traitement après?

Merci d'avance pour vos réponses.

[flolarajasse]

Voilà ou j'en suis, malheureusement ma led ne s'allume pas lorsque cela est souhaité. Ou est-ce que je me suis trompé?

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#define _XTAL_FREQ 10000000

void config_ADC (void)
{
    TRISAbits.RA2 = 0; // On met RA2 en sortie
    ANSELCbits.ANSC5 = 1; // Entrée numérique sur C5 désactivée
    ADCON0bits.CHS4 = 1;
    ADCON0bits.CHS3 = 0;
    ADCON0bits.CHS2 = 0; // Entrée ADC sur AN17 (RC5)
    ADCON0bits.CHS1 = 0;
    ADCON0bits.CHS0 = 1;
    ADCON0bits.ADON = 1; //ADC is enabled
    ADCON2bits.ADFM = 0; // 8 bits de poids fort dans ADRESH
}

int main(int argc, char** argv)
{
    unsigned char result_conv;
    config_ADC();
    while(1)
    {
        ADCON0bits.GO_NOT_DONE = 1;
        while (ADCON0bits.GO_NOT_DONE == 1)
        {
        }
        result_conv = ADRESH; // On met la valeur de la conversion dans la variable result_conv
        if (result_conv <= 128)
        {
            LATAbits.LA2 = 0; // On éteint la led
        }
        else
        {
            LATAbits.LA2 = 1; // On allume la led
        }
        result_conv = 0;
    }
}

Est-ce que c'est comme cela qu'il faut procéder?

[flolarajasse]

Franchement là je sèche....

J'ai essayé avec une interruption, mais toujours rien. Ma led Rx1 reste allumée continuellement...

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#define _XTAL_FREQ 10000000

unsigned char result_conv =0;

void config_ADC (void)
{
    TRISAbits.RA2 = 0; // On met RA2 en sortie
    TRISAbits.RA3 = 0; // On met RA3 en sortie
    ANSELCbits.ANSC5 = 1; // Entrée numérique sur C5 désactivée
    ADCON0 = 0x25;
    ADCON1 = 0x00;
    ADCON2bits.ADFM = 0; // 8 bits de poids fort dans ADRESH
}

void interrupt high_priority conv_CAN ()
{
   if (PIR1bits.ADIF == 1) // Si conversion terminée
   {
       result_conv = ADRESH; // On met la valeur de la conversion dans la variable result_conv
       Nop();
       Nop();
       Nop();
       PIR1bits.ADIF = 0; // On réintialise ADIF
       ADCON0bits.GO = 1; // On lance une conversion
   }
}

int main(int argc, char** argv)
{
    RCONbits.IPEN = 0; // On désactive les priorités des interruptions
    INTCONbits.GIE = 1;
    INTCONbits.PEIE = 1;
    config_ADC();
    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (result_conv <= 128)
        {
            LATAbits.LA2 = 0; // On éteint la led RUN
            LATAbits.LA3 = 1; // On allume la led Rx1
        }
        else
        {
            LATAbits.LA2 = 1; // On allume la led RUN
            LATAbits.LA3 = 0; // On éteint la led Rx1
        }
    }
}

[RISC]

Salut,

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#define _XTAL_FREQ 10000000

unsigned char result_conv =0;

void config_ADC (void)
{
    ANSELAbits.ANSA2 = 0; // Entrée numérique sur RA2 activée
    ANSELAbits.ANSA3 = 0; // Entrée numérique sur RA3 activée
    TRISAbits.TRISA2 = 0; // On met RA2 en sortie
    TRISAbits.TRISA3 = 0; // On met RA3 en sortie

    ANSELCbits.ANSC5 = 1; // Entrée analogique sur AN17 (C5)

    ADCON0 = 0x25;
    ADCON1 = 0x00;
    ADCON2bits.ADFM = 0; // 8 bits de poids fort dans ADRESH
}

void interrupt high_priority conv_CAN ()
{
   if (PIR1bits.ADIF == 1) // Si conversion terminée
   {
       result_conv = ADRESH; // On met la valeur de la conversion dans la variable result_conv
       Nop();
       Nop();
       Nop();
       PIR1bits.ADIF = 0; // On réintialise ADIF
       ADCON0bits.GO = 1; // On lance une conversion
   }
}

int main(int argc, char** argv)
{
    config_ADC();        // d'abord configurer le convertisseur et E/S

    RCONbits.IPEN = 0; // On désactive les priorités des interruptions
    INTCONbits.PEIE = 1;   // preferrer cet ordre là
    INTCONbits.GIE = 1;


    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (result_conv <= 128)
        {
            LATAbits.LATA2 = 0; // On éteint la led RUN
            LATAbits.LATA3 = 1; // On allume la led Rx1
        }
        else
        {
            LATAbits.LATA2 = 1; // On allume la led RUN
            LATAbits.LATA3 = 0; // On éteint la led Rx1
        }
    }
}

Attention au nom des bits dans chaque registre...lis la documentation
tu as oublie de configurer tes leds en mode digital...

Je n'ai pas vérifié tus les registres de ADCONx mais je te conseille tout d'abord de seulement clignoter les leds pour vérifier que tu les controles correctement...ce qui n'était pas possible jusque là...Il faut tester chaque fonction. Si tu utilises une led pour signifier quelquechose et que la led n'est pas controlee correctement, même si la fonction est OK tu ne le sauras jamais...

a+

[paulfjujo]

bonjour,


J'ai testé to programme avec un 18F26K22 sous C18 MPLAB
vu que j' n'avais jamais testé auparavant ce mode d'IT avec ADC..

La config du canal AN17 ( entree sur RC5) est erronée..

void config_ADC17 (void)
{
    ANSELAbits.ANSA2 = 0; // Entrée numérique sur RA2 activée
    ANSELAbits.ANSA3 = 0; // Entrée numérique sur RA3 activée
    TRISAbits.TRISA2 = 0; // On met RA2 en sortie
    TRISAbits.TRISA3 = 0; // On met RA3 en sortie
    TRISC=0xFF;
    ANSELC=0;
    ANSELCbits.ANSC5 = 1; // Entrée analogique sur AN17 (C5)


    //ADCON0 = 0x25;
    ADCON0=0x45;    // 0 AN17=10001  GO/DONE=0  ADON=1
    ADCON1 = 0x00;  // +Vref=VDD èVref=0V
    ADCON2=0;
    ADCON2bits.ACQT2=1; // 8TAD
    ADCON2bits.ADCS2=1; // FOSC/4
    ADCON2bits.ADFM = 0; // 8 bits de poids fort dans ADRESH
}

et il manque surtout la validation de l'interrupt pour ADC

config_ADC17 ();

 RCONbits.IPEN = 1; 
 //PIE1: PERIPHERAL INTERRUPT ENABLE (FLAG) REGISTER 1
 PIE1bits.ADIE=1;
 INTCONbits.PEIE = 1; 
//  REGISTER 9-14: IPR1: PERIPHERAL INTERRUPT PRIORITY REGISTER 1  INTCONbits.GIE = 1;
  IPR1bits.ADIP=0;
 INTCONbits.GIE = 1;

    
    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (result_conv <= 128)
        {
            //LATAbits.LATA2 = 0; // On éteint la led RUN
           // LATAbits.LATA3 = 1; // On allume la led Rx1
           k=fprintf(_H_USART,"ResultConv=%3d AN17 < 128\r\n",result_conv);
           
        }
        else
        { k=fprintf(_H_USART,"ResultConv=%3d AN17 >= 128\r\n",result_conv);
           // LATAbits.LATA2 = 1; // On allume la led RUN
           // LATAbits.LATA3 = 0; // On éteint la led Rx1
          }
       Tempo(100000);
    }

Je n'ai pas mes sorties PORTA dispo , j'utilise donc l'UART pour verifier ..
resultat :

16:37:42.437> Init UART 19200bds FOSC=16Mhz
16:37:42.437> hello
16:37:42.500> Type some chars and CR to send them: ResultConv= 0 AN17 < 128
16:37:44.203> ResultConv=145 AN17 >= 128
16:37:45.953> ResultConv=144 AN17 >= 128
16:37:47.765> ResultConv=143 AN17 >= 128
16:37:49.500> ResultConv=255 AN17 >= 128
16:37:51.250> ResultConv=255 AN17 >= 128
16:37:53.000> ResultConv=211 AN17 >= 128
16:37:54.812> ResultConv=189 AN17 >= 128
16:37:56.562> ResultConv=161 AN17 >= 128
16:37:58.312> ResultConv=111 AN17 < 128
16:38:00.125> ResultConv= 74 AN17 < 128
16:38:01.875> ResultConv= 36 AN17 < 128
16:38:03.625> ResultConv= 37 AN17 < 128

Par contre ,il y a un point qui m'etonne c'est le fait de devoir
mettre

 RCONbits.IPEN = 1;

pour que l'IT s'active ?

sous C18 , j'ai declaré l'interrupt Low priority en 0x0018H

// Low priority interrupt vector
#pragma code InterruptVectorLow = 0x18
void InterruptVectorLow (void)
{
  _asm
    goto InterruptHandlerLow //jump to interrupt routine
  _endasm
}

// Low priority interrupt routine
#pragma code
#pragma interrupt InterruptHandlerLow
void InterruptHandlerLow ()
{
 if (PIR1bits.ADIF == 1) // Si conversion terminée
   {
      result_conv = ADRESH; // On met la valeur de la conversion dans la variable result_conv
        PIR1bits.ADIF = 0; // On réintialise ADIF
       ADCON0bits.GO = 1; // On lance une conversion
   }   
    
}

[flolarajasse]

Bonjour à tous les 2, et merci de vos réponses.

J'ai apporté les modifications que vous m'avez fournis, par contre ma led Rx1 reste désespérement allumée quoi que je fasse.
Voici mon nouveau code :

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#define _XTAL_FREQ 10000000

unsigned char result_conv =0;

void config_ADC (void)
{
    ANSELAbits.ANSA2 = 0; // Entrée numérique sur RA2 activée
    ANSELAbits.ANSA3 = 0; // Entrée numérique sur RA3 activée
    TRISAbits.TRISA2 = 0; // On met RA2 en sortie
    TRISAbits.TRISA3 = 0; // On met RA3 en sortie
    ANSELCbits.ANSC5 = 1; // Entrée numérique sur C5 désactivée
    ADCON0 = 0x45;
    ADCON1 = 0x00;
    ADCON2=0;
    ADCON2bits.ACQT2=1; // 8TAD
    ADCON2bits.ADCS2=1; // FOSC/4
    ADCON2bits.ADFM = 0; // 8 bits de poids fort dans ADRESH
}

void interrupt high_priority conv_CAN ()
{
   if (PIR1bits.ADIF == 1) // Si conversion terminée
   {
       result_conv = ADRESH; // On met la valeur de la conversion dans la variable result_conv
       Nop();
       Nop();
       Nop();
       PIR1bits.ADIF = 0; // On réintialise ADIF
       ADCON0bits.GO = 1; // On lance une conversion
   }
}

int main(int argc, char** argv)
{
    config_ADC();
    RCONbits.IPEN = 0; // On désactive les priorités des interruptions
    PIE1bits.ADIE=1; // Active les interrutpions de l'AD
    INTCONbits.PEIE = 1;
    IPR1bits.ADIP=0;
    INTCONbits.GIE = 1;

    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (result_conv <= 128)
        {
            LATAbits.LATA2 = 0; // On éteint la led RUN
            LATAbits.LATA3 = 1; // On allume la led Rx1
        }
        else
        {
            LATAbits.LATA2 = 1; // On allume la led RUN
            LATAbits.LATA3 = 0; // On éteint la led Rx1
        }
    }
}

[flolarajasse]

Bonne nouvelle, mon programme fonctionne ; j'avais juste omis cette ligne :

    ADCON2bits.ADCS2=1; // FOSC/64
    ADCON2bits.ADCS1=1; // FOSC/64

Donc maintenant mes leds réagissent bien en fonction de la position de mon potar.

Afin de perfectionner mon programme, je voulais faire un moyennage de mes valeurs, afin d'être plus précis.
Exemple, prendre 10 valeurs reçues, faire la moyenne et ensuite effectuer mon action.

Je pensais incrémenter un compteur à chaque interruption, stocker mes valeurs dans un tableau, et ensuite faire le calcul dans la boucle principale.
Est ce que c'est la bonne façon de procéder?

[flolarajasse]

J'ai donc fait un petit programme qui permet de faire un moyennage de mes valeurs ; maintenant, j'aurais voulu savoir comment je pourrais visualiser la valeur de ma variable moyenne? Faut-il que je me mette en mode "simulateur"?Étant donné que je ne m'en suis jamais servit, je ne sais pas comment procéder.

Merci encore de votre aide

[paulfjujo]

bonjour,

Afin de perfectionner mon programme, je voulais faire un moyennage de mes valeurs, afin d'être plus précis.
Exemple, prendre 10 valeurs reçues, faire la moyenne et ensuite effectuer mon action.

et pourquoi ne pas traiter la mesure sur 10 bits pour etre plus precis..?
Voir faire la moyenne sur 16 valeurs .. pourquoi 16 ?
car il suffit alors de faire 4 decalages à gauche de la somme resultante pour avoir la moyenne...
sans utiliser de flotants.

Affichage :
Affichage du LSD resultat sur 8 leds du 8 bits du PortD
et les 2 autres bits MSB, sur 2 autres sorties PORTx dispo

ou sur un UART (.. MAX232..terminal RS232 ) ou module BlueTooth HC05 ..

[RISC]

Salut florajasse,

Une petite remarque. quand tu programmes plusieurs bits qui vont ensemble (appelés un champ de bits) il est plus efficace de tous les programmer dans la même ligne de code. Exemple au lieu de :

ADONC2bits.ADCS0 =1;
ADONC2bits.ADCS1 =1;
ADONC2bits.ADCS2 =1;

Tu peux écrire :

ADONC2bits.ADCS = 7;

a+

[flolarajasse]

bonjour,



et pourquoi ne pas traiter la mesure sur 10 bits pour etre plus precis..?
Voir faire la moyenne sur 16 valeurs .. pourquoi 16 ?
car il suffit alors de faire 4 decalages à gauche de la somme resultante pour avoir la moyenne...
sans utiliser de flotants.

Je ne comprends pas totalement comment procéder ; un simple décalage ne me permettra pas d'avoir une moyenne sur plusieurs mesures?
Je n'ai pas du tout compris comment tu comptes procéder.

Merci RISC pour le conseil

[terriblement]

une moyenne consiste a additionner plusieurs termes, et a diviser le total par le nombre de termes additionnés.

Si tu additionnes 16 termes, il faudra diviser par 16, ce qu'un decalagede 4 bits fera. Penser à stocker la valeur dans une variable pouvant avoir une valeur >= a 16x la valeur max des mesures attendues.

[RISC]

Salut Florajasse,

Ce que l'on est en train de t'expliquer c'est que si tu fais la moyenne d'un nombre d'échantillons qui est un multiple de 2 (2,4,8,16,...) en C cela sera très rapide car une division ne sera pas nécessaire. Les compilateurs C pour microcontroleurs détectent (généralement) que c'est une division par une puissance de 2 et ne font pas une division mais un décalage.
En effet il suffit de décaler à droite pour diviser par 2 (de la même manière qu'en décalant à droite en base 10 on divise par 10).
Donc 4 décalages à droite permettent de diviser par 2^4 (16).

Pour être sûr qu'un décalage à lieu il vaut d'ailleurs mieux utiliser l'opérateur décalage à doite :

Moyenne = Total16echantillons >> 4 ;

a+

[flolarajasse]

Ok, je ne gère pas trop les décalages de bits. Moi j'avais fait 1 mesures, tout stocker dans un tableau, puis j'ai diviser par 10 en mettant le résultat dans un float ; après, je ne sais pas si c'est très précis.

[flolarajasse]

Voici la boucle de traitement que j'avais faite :

            for (i = 0 ; i < 10 ; i++)
            {
                moyenne = moyenne + result_conv[i];
            }
            moyenne = moyenne / 10.0 ;

Si j'ai compris, il faut que je change en :

            for (i = 0 ; i < 16 ; i++)
            {
                moyenne = moyenne + result_conv[i];
            }
            moyenne = moyenne >> 4 ;

Ma boucle me permet de faire la somme de mes 16 mesures, et ensuite je fais mon décalage de bits. C'est ça?

[paulfjujo]

bonjour,

Tu n'es pas obligé de passer par un tableau, sauf si tu veux exploiter les valeurs intermediares
result_conv etant le resultat de la mesure ADC.
Initialiser moyenne au depart!

avec 
int Result_conv;  // au lieu de unsigned char
unsigned int moyenne;

moyenne=0;
for (i = 0 ; i < 16 ; i++)
            {
                moyenne = moyenne + result_conv;
            }
            moyenne = moyenne >> 4 ;

sinon tu peux aussi conserver la somme sur 10 valeurs
mais ne pas la diviser par 10
et au moment de l'affichage , positionner une virgule avant le dernier digit significatif.

ex avec :
int Result_conv; // au lieu de unsigned char

resul_conv =768
apres un cumul de 10 valeurs (si supposees identiques) moyenne=7680
affichage 768.0 au 1/10em , sans utiliser de flotant (division par 10.0)
avec 1023 maxi ADC mesure
*10 => 10230 , pas de risque de debordement int 16 bits.

[flolarajasse]

Bonjour paulfjujo,

Je ne sais pas si j'ai bien procédé, mais voilà comment j'avais fait :
- J'utilise une interruption à chaque fois qu'une conversion est terminée, je stocke la valeur dans un tableau et j'incrémente une variable (variable qui me décale dans mon tableau à chaque interruption).
- Dans mon programme principal, quand ma variable atteint la valeur 16, je désactive les interruptions puis je fais mon traitement (somme du tableau puis moyenne).

Je ne sais pas si c'est comme cela qu'il faut procéder, et si c'est le plus pratique.

Merci de ta réponse

[paulfjujo]

Je ne sais pas si c'est comme cela qu'il faut procéder, et si c'est le plus pratique.

C'est TON programme, à toi de faire le choix d'une solution qui te convient.

Dans mon programme principal, quand ma variable atteint la valeur 16, je désactive les interruptions puis je fais mon traitement (somme du tableau puis moyenne).

NON, c'est dans le traitement d'IT que tu dois detecter la valeur 16 pour armer un drapeau visible par le main()
sinon le programme principal fait le meme boulot que l'IT .. occupé à plein temps.
et interdire les prochaines IT.
Dans le main , tu surveille le drapeau, lorsqu'il est levé , tu fait ton traitement , somme, moyenne...
sur les 16 valeurs , puis tu RAZ le drapeau et re-autorise les IT.
du moins, c'est ainsi que je le ferai..

[flolarajasse]

Je sais bien que c'est mon programme, mais le but est de le rendre le plus fluide, et le plus "logique" possible. C'est pour ça que je demande des avis, c'est le but d'un forum .

Merci de ta réponse.

[flolarajasse]

Bonjour à tous,

Je déterre un peu ce topic, juste afin de poser une question.

Pour des raisons indépendantes de ma volonté, j'ai du changer de PIC et utiliser un PIC18F4431 ; j'ai regarder les registres, et ils ont l'air sensiblement similaires avec le 18F45K22. Le problème est quand je porte mon code, mon programme ne fonctionne plus.
J'ai changé les registres qui étaient différents, je procède exactement de la même façon dans les 2 cas, mais là, rien ne se passe.

Il y a t-il d'autres init à faire, d'autres registres à configurer?

J'ai fouillé dans les datasheets, malheureusement, je n'ai rien trouvé.

Bonne journée.