ADRESH, ADRESL : Probleme de chargement

[Thibaud123]

Bonjour,

Voilà je programme un PIC18F4620 en C et j'aimerais utiliser mon ADC pour convertir un sinus en entrée (sur le pin AN1) d'une amplitude de 1V, un offset de 3V, et fréq de 50Hz, en une valeur numérique 10 bits comme le permet l'ADC.

Seulement voilà quand je tente de récupérer ADRESH et ADRESL (en les mettant en sortie sur PORTD pour ADRESL, et sur RB1 et RB2 pour les 2 bits de ADRESH) j'obiens 0 pour les deux registres (testé sur des LEDs via une simulation sur Proteus).

Il me semble avoir bien config les pins (I/0) et mon temps d'acquisition ainsi que le Tad respectent les contraintes.

Je commence vraiment à tourner en rond.. Si vous pouviez m'aiguiller c'est très aimable et ce sera plus qu'apprécié !

Merci

P.S: J'utilise INTOSC comme oscillateur, à une fréquence de 4MHz

void interrupt myInterrupt(void)
{
    if(ADIE && ADIF)
    {
        /* Steps 5 + 6 */

        // Lire les registres et les mettre en sortie
        LATD = ADRES;
        LATB = (ADRESH<<1); // seuls RB1 et RB2 nous intéressent

        // Clear ADIF
        ADIF = 0;

        // Attendre un temps 2*Tad minimum (discharge)
        _delay(100);

        // On recommence ACQ + Conv, et on sort de l'interruption
        GODONE = 1;

    }

}
int main()
{

    // OSCILLATOR SELECTION
    OSCCONbits.SCS1 = 1; // internal osc.

    OSCCONbits.IRCF2 = 1; // ATTENTION A LA FREQUENCE MAXIMALE EN FONCTION DU Tad CHOISI
    OSCCONbits.IRCF1 = 0;
    OSCCONbits.IRCF0 = 0;

    // Step 1 : Configure the A/D module

    ADCON1 = 0x02; // On n'utilise pas les pins ANx comme Digital I/O, mais uniquement AN0 comme analog input
    TRISA = 0xFF; // On met tous les pins en mode input (et donc AN0 aussi)
                  // D'après la datasheet c'est la seule chose à faire, car RA0 disabled si AN0 déf en analog input
                  // via ADCON1
    TRISB = 0x00;
    TRISD = 0x00; // Tous les pins D output
    ADCON0 = 0b00000101;  // On active le module A/D et on sélectionne AN1
    ADCON2 = 0b10010101;  // (Right Justified) ; Tad = 16*Tosc

    // Step 2 : Configure A/D Interrupt

    ADIF = 0;
    ADIE = 1;
    GIE = 1;

    // Step 3 : Wait the required acquisition Time (NOT required here because ACQT2:ACQT0 != 000)
    // Step 4 : Start conversion

    GODONE = 1; // start (ACQ + CONV) process
    // Step 5 : Detect that A/D conversion has finished (via interruption)
    // Step 6 : read ADRESH and ADRESL
    // Step 7 : Go directly to step 2 for next conversion (step 1 must not be modified in our case)


    while(1){}

    return 0;
}

-----

[paulfjujo]

bonjour,

LATD=ADRESL;

ADRESH ne peut etre lu 'que si on lit ADRESL

[Thibaud123]

Merci pour ta réponse paulfjujo, j'ai suivi ta suggestion (j'ai simplement modifier LATD = ADRESL mais toujours 0 en sortie.

En refaisant quelques tests cependant, je viens de m'apercevoir d'une anomalie à mon sens qui me déstabilise énormément... Je m'explique : Dans un tout premier temps (et avant d'introduire le module ADC), j'étais d'abord occupé à tester ma gestion des interruptions avec TIMER0. Une fois réussi, j'ai mis cette partie là de code en // (voir code ci dessous), et j'ai essayé de gérer l'ADC. Mais la condition pour que je rentre dans l'interruption myInterrupt dépend de la config de T0CON et TMREI, alors que ces registres ne sont censés influencer que l'interruption TMR0_interrupt !!

J'ai modifié le code que j'ai posté initialement afin qu'il fasse clignoter les 8 pins de PORTD (que j'ai branché sur des LEDs en simulation). Tel qu'il est ci dessous ça marche. Mais si je mets les lignes suivantes (début du main() )

T0CON = 0b11001111;
TMR0IE = 1;

en commentaire, plus de clignotement, signifie donc que je ne rentre plus dans l'interruption !

Comment est-ce possible ???

Merci infiniment pour votre aide.

* P.S *: J'ai bien recompilé après chaque changement. Vous vous apercevrez dans le code que j'utilise Fosc = 4MHz ; Tad = 16*Tosc ; Tacq = 4*Tad ; et j'attends un délai de 100 instructions en fin de conversion, donc largement suffisant puisque à Fosc ça correspond à 100µs (le temps nécessaire à une instruction vaut 4*Tosc)




int scale; // voir TMR0_interrupt

//void interrupt TMR0_interrupt(void)
//{
// // On entre dans le if si overflow de TMR0, dans ce cas on incrémente portValue
// if (INTCONbits.TMR0IE && INTCONbits.TMR0IF)
// {
// scale++;
// if (scale >= 4000)
// {
// scale = 0;
// LATD = ~LATD;
//
// }
// INTCONbits.TMR0IF = 0; // reset du flag
// }
//}

void interrupt ADC_interrupt(void)
{
if(ADIE && ADIF)
{
/* Steps 5 + 6 */

// Lire les registres et les mettre en sortie

LATD = ~LATD;

// Clear ADIF
ADIF = 0;

// Attendre un temps 2*Tad minimum (discharge)
_delay(100);

// On recommence ACQ + Conv, et on sort de l'interruption
GO = 1;
}

}
int main()
{
// TIMER0 CONFIG
T0CON = 0b11001111;
TMR0IE = 1;
scale = 0; // utilisé dans TMR0_interrupt

// OSCILLATOR SELECTION
OSCCONbits.SCS1 = 1; // internal osc.

OSCCONbits.IRCF2 = 1; // ATTENTION A LA FREQUENCE MAXIMALE EN FONCTION DU Tad CHOISI
OSCCONbits.IRCF1 = 1;
OSCCONbits.IRCF0 = 0;

// Step 1 : Configure the A/D module

ADCON1 = 0x02; // On n'utilise pas les pins ANx comme Digital I/O, mais uniquement AN0 comme analog input
TRISA = 0xFF; // On met tous les pins en mode input (et donc AN0 aussi)
// D'après la datasheet c'est la seule chose à faire, car RA0 disabled si AN0 déf en analog input
// via ADCON1
TRISB = 0x00;
TRISD = 0x00; // Tous les pins D output
ADCON0 = 0b00000101; // On active le module A/D et on sélectionne AN1
ADCON2 = 0b10010101; // (Right Justified) ; Tad = 16*Tosc

// Step 2 : Configure A/D Interrupt

ADIF = 0;
ADIE = 1;
GIE = 1;


// Step 3 : Wait the required acquisition Time (NOT required here because ACQT2:ACQT0 != 000)
// Step 4 : Start conversion

LATD = 0b01010101;
GO = 1; // start (ACQ + CONV) process
// Step 5 : Detect that A/D conversion has finished (via interruption)
// Step 6 : read ADRESH and ADRESL
// Step 7 : Go directly to step 2 for next conversion (step 1 must not be modified in our case)


while(1){}

return 0;
}

[RISC]

Thibaud,

Mets des balises [ code ] autour de ton programme car c'est illisible...

a+

[A voir en vidéo sur Futura]

[Thibaud123]

Tu suggères que je mette chaque ligne de code entre [] sauf les commentaires c'est ça ?

J'ai joint le fichier .c archivé pour plus de clarté !

 void interrupt myInterrupt(void)
{
    if(ADIE && ADIF)
    {
        /* Steps 5 + 6 */

        // Lire les registres et les mettre en sortie
        LATD = ADRES;
        LATB = (ADRESH<<1); // seuls RB1 et RB2 nous intéressent

        // Clear ADIF
        ADIF = 0;

        // Attendre un temps 2*Tad minimum (discharge)
        _delay(100);

        // On recommence ACQ + Conv, et on sort de l'interruption
        GODONE = 1;

    }

}
int main()
{

    // OSCILLATOR SELECTION
    OSCCONbits.SCS1 = 1; // internal osc.

    OSCCONbits.IRCF2 = 1; // ATTENTION A LA FREQUENCE MAXIMALE EN FONCTION DU Tad CHOISI
    OSCCONbits.IRCF1 = 0;
    OSCCONbits.IRCF0 = 0;

    // Step 1 : Configure the A/D module

    ADCON1 = 0x02; // On n'utilise pas les pins ANx comme Digital I/O, mais uniquement AN0 comme analog input
    TRISA = 0xFF; // On met tous les pins en mode input (et donc AN0 aussi)
                  // D'après la datasheet c'est la seule chose à faire, car RA0 disabled si AN0 déf en analog input
                  // via ADCON1
    TRISB = 0x00;
    TRISD = 0x00; // Tous les pins D output
    ADCON0 = 0b00000101;  // On active le module A/D et on sélectionne AN1
    ADCON2 = 0b10010101;  // (Right Justified) ; Tad = 16*Tosc

    // Step 2 : Configure A/D Interrupt

    ADIF = 0;
    ADIE = 1;
    GIE = 1;

    // Step 3 : Wait the required acquisition Time (NOT required here because ACQT2:ACQT0 != 000)
    // Step 4 : Start conversion

    GODONE = 1; // start (ACQ + CONV) process
    // Step 5 : Detect that A/D conversion has finished (via interruption)
    // Step 6 : read ADRESH and ADRESL
    // Step 7 : Go directly to step 2 for next conversion (step 1 must not be modified in our case)


    while(1){}

    return 0;
}

[Yoruk]

Nan, dans l'éditeur de message...

Ton code ici...

Pour simplifier la lecture par tous...

[Thibaud123]

Désolé pour les modif et mes msg redondantes mais je suis nouveau sur le forum

 int scale; // voir TMR0_interrupt

//void interrupt TMR0_interrupt(void)
//{
// // On entre dans le if si overflow de TMR0, dans ce cas on incrémente portValue
// if (INTCONbits.TMR0IE && INTCONbits.TMR0IF)
// {
// scale++;
// if (scale >= 4000)
// {
// scale = 0;
// LATD = ~LATD;
//
// }
// INTCONbits.TMR0IF = 0; // reset du flag
// }
//}

void interrupt ADC_interrupt(void)
{
if(ADIE && ADIF)
{
/* Steps 5 + 6 */

// Lire les registres et les mettre en sortie

LATD = ~LATD;

// Clear ADIF
ADIF = 0;

// Attendre un temps 2*Tad minimum (discharge)
_delay(100);

// On recommence ACQ + Conv, et on sort de l'interruption
GO = 1;
}

}
int main()
{
// TIMER0 CONFIG
T0CON = 0b11001111;
TMR0IE = 1;
scale = 0; // utilisé dans TMR0_interrupt

// OSCILLATOR SELECTION
OSCCONbits.SCS1 = 1; // internal osc.

OSCCONbits.IRCF2 = 1; // ATTENTION A LA FREQUENCE MAXIMALE EN FONCTION DU Tad CHOISI
OSCCONbits.IRCF1 = 1;
OSCCONbits.IRCF0 = 0;

// Step 1 : Configure the A/D module

ADCON1 = 0x02; // On n'utilise pas les pins ANx comme Digital I/O, mais uniquement AN0 comme analog input
TRISA = 0xFF; // On met tous les pins en mode input (et donc AN0 aussi)
// D'après la datasheet c'est la seule chose à faire, car RA0 disabled si AN0 déf en analog input
// via ADCON1
TRISB = 0x00;
TRISD = 0x00; // Tous les pins D output
ADCON0 = 0b00000101; // On active le module A/D et on sélectionne AN1
ADCON2 = 0b10010101; // (Right Justified) ; Tad = 16*Tosc

// Step 2 : Configure A/D Interrupt

ADIF = 0;
ADIE = 1;
GIE = 1;


// Step 3 : Wait the required acquisition Time (NOT required here because ACQT2:ACQT0 != 000)
// Step 4 : Start conversion

LATD = 0b01010101;
GO = 1; // start (ACQ + CONV) process
// Step 5 : Detect that A/D conversion has finished (via interruption)
// Step 6 : read ADRESH and ADRESL
// Step 7 : Go directly to step 2 for next conversion (step 1 must not be modified in our case)


while(1){}

return 0;
}

[paulfjujo]

bonjour,

tu utilises C18 ou ?

La declaration des interrupts me parait bizare

en C18

/gestionnaire d'interruption
//------------------------------
// High priority interrupt vector
#pragma code InterruptVectorHigh = 0x08
void InterruptVectorHigh (void)
{
  _asm
    goto InterruptHandlerHigh //jump to interrupt routine
  _endasm
}

// High priority interrupt routine
#pragma code
#pragma interrupt InterruptHandlerHigh
void InterruptHandlerHigh ()
{
  static char i ; // doit être statique pour conserver sa valeur entre les IT
 //------ SERIAL IT ---------------------
if ((PIE1bits.RC1IE == 1)&&(PIR1bits.RCIF==1)) // si un car arrive
 {
   C1 =Read1USART(); // le lire => RAZ  RCIF
    ... etc ..
  PIR1bits.RCIF=0;
}
// timer0
if (INTCONbits.TMR0IE && INTCONbits.TMR0IF)
 {
 .. traitement
INTCONbits.TMR0IF=0;
}

/  Timer3 interrupt ---------------------
 if ((PIE2bits.TMR3IE==1) && (PIR2bits.TMR3IF==1))
 {
   etc...
  PIR2bits.TMR3IF=0;
 }

}

dans la declaration d'interrupt
on met toutes les interrupt succeptibles d'etre traitees

en principe timer0 est toujours en priorité haute

il me parait tres normal d'etre obligé de mettre INTCONbits.TMR0IE=1;
pour avoir l'interrup timer 0..
je n'ai jamais utilisé l'interrupt ADC, je prefere faire l'acquisition
dans une interrupt timer ou utiliser un flag armé via le timer.

T0CON=0b11001111;
timer sur 8 bits SANS utiliser PRESCALER
soit une IT toute les 256µS at 4Mhz
puisque le timer n'est pas initialisé => =0
cela ne va-t-il pas trop vite..

surtout avec un delay(100) dans l'interrupt ADC
100 = 100µS ?
se mefier des durees de traitement dans les interrupts.

[Thibaud123]

Salut,

J'utilise xc8. Je déclare les interruptions comme dans le tuto de base http://ww1.microchip.com/downloads/e.../50002173A.pdf

Tu veux dire que tu ne fais qu'une seule fonction interrupt et tous les "if" nécessaires successivement dans cette fonction ?

Si j'ai bien compris, pour le temps d'acquisition tu le gères "manuellement" avec des timers, en t'assurant que le temps d'acquisition + temps de conversion digitale est supérieur ou égal à ce qui est requis (déterminé entre autres par la résistance d'entrée, la capa C_hold, etc) ?

_delay(n) attend le temps nécessaire à l'exécution de n instructions (dépend donc de Fosc). J'utilise delay pour attendre le temps nécessaire à la décharge du condensateur avant nouvelle acquisition. Tu remplacerais ce delay par une autre interruption ?

P.s: Pour le config de T0CON je te suis, mais c'est son utilité qui me dérange (si je l'enlève je n'ai plus d'interruption ADC), dans la mesure j'utilise UNIQUEMENT l'interruption ADC, donc pas les timers, donc pas besoin de T0CON je suppose

Merci

[paulfjujo]

Tu veux dire que tu ne fais qu'une seule fonction interrupt et tous les "if" nécessaires successivement dans cette fonction ?

oui, car je declare toutes les interrupt en priorite Haute

A priori tu n'utilises pas le mode de priorité haute ou basse sous X8 ..


le fait de declarer timer0 en interrupt active peut etre le mode priorité haute ?

PIC18F2620_4620_252539626b.pdf paragraf 9

When the IPEN bit is cleared (default state), the
interrupt priority feature is disabled and interrupts are
compatible with PICmicro® mid-range devices. In
Compatibility mode, the interrupt priority bits for each
source have no effect. INTCON<6> is the PEIE bit,
which enables/disables all peripheral interrupt sources.

voir IPEN et INTCON<6>

[Thibaud123]

le fait de declarer timer0 en interrupt active peut etre le mode priorité haute ?

Je ne comprends pas ce que tu veux dire.

Je suis allé relire la section INTERRUPTS dans la datasheet, et en effet : PEIE = 1 enables all unmasked peripheral interrupts. Donc les ADC interrupts sont des peripheral interrupts. Je pensais que GIE à 1 autorisait TOUTES les interruptions sans exception !

Je n'utilise pas les priorités non. Mais cela me pousse à me poser la Q suivante sur priority bit : Un seul bit pour définir la priorité d'une source d'interruptions. Si interruption avec bit de priorité survient lors du process d'une interruption low priority (bit de priorité à 0), alors elle est suspendue en cours de process et on y revient APRES que l'interruption de haute priority ait terminé ? Dans le cas inverse, l'interruption de priorité haute se termine jusqu'au bout, et si plusieurs flags ont été délcenchés pdt son exécution c'est celui de priorité la plus haute qui s'exécute en premier ? Et en cas d'égalité ?



Le problème de l'interruption en elle-même semble réglé, un grand merci ! Par contre ADRESL et ADRESH apparaissent toujours nuls... En effet, en simulant le code suivant, aucune LED ne s'allume sur PORTD, RB1 et RB2 :

void interrupt ADC_interrupt(void)
{
    if(ADIE && ADIF)
    {
        LATD = ADRESL; // Les 8 bits de poids faible sur PORTD
        LATB = (ADRESH<<1); // Les 2 bits de poids fort sur RB1 et RB2
       
        ADIF = 0;  // Clear ADIF
        
        _delay(10); // Attendre un temps 2*Tad minimum (discharge) 

        GO = 1; // START AGAIN (ACQ + CONV) process
    }

}
int main()
{
    // OSCILLATOR SELECTION
    OSCCONbits.SCS1 = 1; // internal osc.

    OSCCONbits.IRCF2 = 1; // ATTENTION A LA FREQUENCE MAXIMALE EN FONCTION DU Tad CHOISI
    OSCCONbits.IRCF1 = 1;
    OSCCONbits.IRCF0 = 0;

    // Step 1 : Configure the A/D module

    ADCON1 = 0x02; // On n'utilise pas les pins ANx comme Digital I/O, mais uniquement AN1 comme analog input
    TRISA = 0xFF; // On met tous les pins en mode input (et donc AN1 aussi)
                  // D'après la datasheet c'est la seule chose à faire, car RA1 disabled si AN1 déf en analog input
                 
    TRISB = 0x00; // Tous les pins B en output
    TRISD = 0x00; // Tous les pins D en output
    ADCON0 = 0b00000101;  // On active le module A/D et on sélectionne AN1
    ADCON2 = 0b10010101;  // (Right Justified) ; Tad = 16*Tosc

    // Step 2 : Configure A/D Interrupt

    ADIF = 0;
    ADIE = 1;
    PEIE = 1;
    GIE = 1;

    
    LATD = 0x00; // On initialise les sorties
    
    GO = 1; // START (ACQ + CONV) process

    while(1){}

    return 0;
}

[bisou10]

Salut, je ne peux pas tester, mais la structure semble ok

A noter que
- le resultat de conversion est dispo quand GO repasse à 0 (dans ton cas ca doit déclencher l'IT)
- l'init se fait sur ANSELx *et* TRISx qui doivent etre à 1 (ca semble ok)
- xc8 permet de spécifier le registre ce qui rend le code plus clair (tu remarques que j'utilise ADCON0bits.GO pour tester, et donc qu'en lisant ton code je ne sais pas si ADON est activé par exemple sans rentrer dans la description de ADCON0. Tu peux aussi lire ADRES directement, laisser le compilateur gérer ce point):

    // note:  ON = 1 , OFF = 0
    ADCON0bits.ADON = ON;
    ADCON0bits.CHS = 0;

    ADCON0bits.GO = ON;
    while (ADCON0bits.DONE != OFF);
    ADCON0bits.ADON = OFF;

    unsigned short resultat = ADRES;

De manière générale, la DOCUMENTATION est bien faite, et permet d'éviter sans cesse de réinventer la roue. Par exemple les macro LOW_BYTE(x) / HIGH_BYTE(x) existent, ainsi que plein d'autres fonctions. Les programmes de débutant ne tirent pas parti de toutes ces fonctions, ce qui est dommage, mais qui peut sérieusement t'aider au debug.

Bon courage !

[Thibaud123]

Par exemple les macro LOW_BYTE(x) / HIGH_BYTE(x) existent, ainsi que plein d'autres fonctions

Tu veux dire que je peux utiliser ADRESL = LOW_BYTE(ADRES) et ADRESH = HIGH_BYTE(ADRES) ?

Merci pour ton conseil d'utiliser directement ADRES je le ferai plus tard (car in fine c'est d'un entier dont j'aurai besoin), mais là j'essaye d'afficher les bits de conversion séparément pour voir si la conversion fonctionne, ce qui n'est tjrs pas le cas

"SOS mon navire part à la dérive"

P.S: En fait pour info, le but du projet c'est de stabiliser la tension de sortie d'un convertisseur DC-DC via le PIC en convertissant cette tension à l'aide de l'ADC, en la comparant avec Vref, et puis sortir un duty_cycle adéquat en fonction de l'erreur afin de rectifier le tir sur la tension de sortie.

[bisou10]

Ok.
Pas besoin de faire LOW_BYTE(ADRES), puisque ADRESL est disponible (ceci dit, ca doit marcher), c'est juste pour te guider un peu sur le dev PIC.

Pour ton problème, 2 conseils:
1) développe ca sans IT dans un premier temps
2) n'oublie pas que RAx n'est pas forcément la voie x (ex: la voie 4 est sur RA5)

Il n'y a pas de raison que tu ne récupères rien dans ADRESH/ADRESL. Au pire reboucle avec une sortie que tu positionnes à 1 pour avoir une valeur que tu connais (0x3F dans ton cas)

[Thibaud123]

[RESOLU]

Comme vous l'avez tous souligné, la config était bonne. C'est mon circuit de simulation qui n'était pas bon... En effet j'avais placé la résistance d'entrée entre le pin (AN1 ou AN0) et la source, au lieu de la placer entre le source et la masse... Impardonnable je sais Je parviens donc maintenant à récolter ADRESH et ADRESL correctement !

MERCI à tous ceux qui ont prêté attention à mon problème, cela m'a permis d'avancer (de débloquer le pb d'interruption entre autres)

A bientôt