Est-ce possible en langage C?

[invitead51e543]

Salut,
Ce que je veux faire, c'est comparer si mon PWM (8its de poids fort) est égale à la consigne (8 bits du CAN) ;

- Si PWM <, on augmente les 6 bits de poids faible jusqu'à ce que PWM atteigne la consigne. (à chaque interruption Timer).
- Si PWM >, on diminue les 6 bits de poids faible jusqu'à ce que PWM atteigne la consigne. (à chaque interruption Timer).

Ceci me permettra d'avoir une courbe linéaire en sortie. Mais pour l'instant, mon code me donne n'importe quoi en sortie (PWM à 50% puis à 0%).
-----

[invitead51e543]

Est-ce que je peux t'envoyer mon bout de code?Afin que tu me dise ou je me trompe?

[paulfjujo]

poste ton code sur le forum,
tu auras ainsi plusieurs avis ..

[invitead51e543]

Je mets simplement le main ; j'ai essayé de modifier mon code en fonction de tes remarques, mais là j'admets que je me suis complétement perdu.
Je pense que le(s) problème(s) vient des parties en gras.

//#define HI(x)    ((unsigned char)(((x)>>8)&0xFF))
//define LO(x)     ((unsigned char)((x)&0xFF))
#define HI(x)     ((unsigned int)(((x))&0xFF00)>>8)
#define LO(x)     ((unsigned int)((x)&0x00FF))
#define _XTAL_FREQ 10000000

int main(int argc, char** argv)
{
    unsigned int moyenne = 0;
    unsigned char PWM_Val = 0;
    unsigned int PWM_Val_14 = 0;
    int i = 0;
    RCONbits.IPEN = 1; // On active les priorités des interruptions
    INTCONbits.GIE = 1; // Active les interruptions
    INTCONbits.PEIE = 1; //Active les interruptions périphériques
    PIE1bits.TMR2IE = 1; // Enable the TMR2 to PR2 match interrupt
    PIE1bits.ADIE = 1; // Active les interrutpions de l'AD
    IPR1bits.ADIP = 0; // A/D Converter Interrupt Low Priority
    IPR1bits.TMR2IP = 1; // TMR2 to PR2 Match Interrupt High Priority
    config_CAN();
    config_PWM();
    config_Timer2();
    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (inter_Timer2 == 1) // Si interruption Timer
        {
            if (compte == 16)
            {
                PIE1bits.ADIE = 0; // Désactive les interrutpions de l'AD
                for (i = 0 ; i < 16 ; i++)
                {
                    moyenne = moyenne + result_conv[i];
                }
                moyenne = moyenne >> 4 ; // Décalage de 4 bits à droite correspond à division par 16
                PWM_Val = moyenne;
                PWM_Val_14 = (moyenne << 6) & 0x003F;
                //PWM_Val_14 = ( (int) PDC0L ) & 0x3F;
                //PWM_Val = ( (int) PDC0H) <<4 + PDC0L; // Consigne PWM sur 8 bits
                //PWM_Val_14 = ( (int) PDC0H) <<8 + PDC0L; // Consigne PWM sur 14 bits

                if (moyenne == PWM_Val)
                {
                    if (moyenne == 0)
                    {
                        PWM_Val_14--;
                    }
                    else if (moyenne == 255)
                    {
                        PWM_Val_14++;
                    }
                }
                else if (moyenne > PWM_Val )
                {
                    PWM_Val_14++;
                }
                else
                {
                    PWM_Val_14--;
                }
                PDC0H = HI(PWM_Val_14);
                PDC0L = LO(PWM_Val_14);
                compte = 0;
                result_conv[16] = 0;
                PIE1bits.ADIE = 1; // Active les interrutpions de l'AD
            }
            else
            {
            }
            moyenne = 0;
            inter_Timer2 = 0;
        }
    }
}

[paulfjujo]

Probleme ?
l'expression ci dessous EST TOUJOURS VRAIE ..

                ........
                PWM_Val = moyenne;
                PWM_Val_14 = (moyenne << 6) & 0x003F;
                //PWM_Val_14 = ( (int) PDC0L ) & 0x3F;
                //PWM_Val = ( (int) PDC0H) <<4 + PDC0L; // Consigne PWM sur 8 bits
                //PWM_Val_14 = ( (int) PDC0H) <<8 + PDC0L; // Consigne PWM sur 14 bits

                if (moyenne == PWM_Val)
                {
               ......

[invitead51e543]

Oui je sais, j'avais modifié ce bout de code juste avant de poster.
Mais comment faut-il que je procède?Je réexplique ce que je veux faire :
- Entrée CAN sur 8 bits, moyennage sur 16 mesures.
- Je prends les 8 bits de poids fort de mon PWM :
- Si mon PWM < CAN, à chaque interruption Timer, j'augmente de 1 mes bits de poids faible de mon PWM(en tout 6 bits donc 2^6 cycles minimum)
- Si mon PWM > CAN, à chaque interruption Timer, je diminue de 1 mes bits de poids faible de mon PWM (en tout 6 bits donc 2^6 cycles minimum)
- Si mon CAN = 0, je mets à 0 mes 6 bits de poids faible de mon PWM (en tout 6 bits donc 2^6 cycles minimum)
- Si mon CAN = 255, je mets à 1 mes 6 bits de poids faible de mon PWM (en tout 6 bits donc 2^6 cycles minimum)

Le but étant d'avoir une courbe linéaire sur ma PWM, peu importe à quelle vitesse je fais varier mon potentiomètre en entrée (entrée CAN).
Là, en voulant essayer trop de choses, je me suis un peu (beaucoup) perdu!!

[paulfjujo]

J'avoue ne pas trop comprendre aussi
Qui commande QUOI..

je fais varier mon potentiomètre en entrée (entrée CAN).

la valeur de PWM depend bien de l'entree Analogique CAN ?

Si mon PWM < CAN,

Est-ce la meme valeur Analogique (Potentiometre) ou une autre
mesure analogique, image reelle de la valeur PWM en retour ?
ce qui serait plus compréhensible


ou est-ce pour generer une rampe de montee (ou descente ) en vitesse.
si c'est le cas pourquoi se limiter aux 6 bits de poids faible....

Et pourquoi utiliser l'ADC que sur 8 bits et non pas 10 ?

[invitead51e543]

Mon potentiomètre (relié au CAN du PIC) fait varier mon PWM. A 0% du CAN, PWM vaut 0%.A 100%, PWM vaut 100%.
J'aurais pu très bien, afin de faciliter, prendre mes 8 bits de poids fort du PWM, comme ça j'aurais eu ma consigne du CAN en entrée sur 8 bits, et en sortie, PWM sur 8 bits.
Le problème est que j'ai besoin d'avoir une belle courbe en sortie, et en travaillant seulement sur 8 bits, cela ne le permet pas, d'où l'utilisation de 14 bits.

Est-ce la meme valeur Analogique (Potentiometre) ou une autre mesure analogique, image reelle de la valeur PWM en retour ?ce qui serait plus compréhensible

Image réelle de la valeur PWM en retour. En fait si ma valeur PWM lue (8 bits de poids fort) est inférieure à ma consigne, j'augmente progressivement la valeur PWM (6 bits de poids faible), puis je recompare, et ainsi de suite. Comme ça, étant donné que je travaille avec une interruption Timer, ma valeur PWM augmentera linéairement et plus lentement même si je change la valeur de mon potentiomètre à grande vitesse.

Exemple :
CAN : 10101010 ==> Valeur lue PWM (8 bits poids fort) : 10101000
A chaque interruption Timer : PWM 1010101000 000001
.............................. ............PWM 1010101000 000010
.
. 2^6 cycles
.
.............................. ............PWM 1010101000 111111

Tu comprends mieux le principe?

[paulfjujo]

ai-je bien compris ?

ta commande potar est sur 8 bits => CAN
la PWM evoulera donc par palier de 64 pas => analogie avec des marches d'ecalier
et suivant la valeur du pas (escalier), tu cherche à rejoindre la marche suivante d'une facon lineaire
sans accoups.

donc le but est de linearier la sortie PWM entre chaque pas.
Sachant qu'avec une commande sur 8 bits, tu ne pourras jamais te fixer entre 2 pas ( marches ..)

[paulfjujo]

encore un petit truc qui me chifonne dans ton exemple
le PWM est sur 16 bits cadré à gauche,
je le verrais plutot comme cela

Exemple :
CAN : 10101001 ==> Valeur lue PWM (8 bits poids fort) : 10101000
A chaque interruption Timer : PWM 10101000 000001 <- sur 14 bits
.............................. ............PWM 10101000 000010
.
. 2^6 cycles
.
.............................. ............PWM 10101000 111111
.............................. ............PWM 10101001 000000 egalité CAN et PWM 8 bits poids fort apres debordement suivant

[invitead51e543]

Tu as tout à fait compris le principe.

Exemple :
CAN : 10101001 ==> Valeur lue PWM (8 bits poids fort) : 10101000
A chaque interruption Timer : PWM 10101000 000001 <- sur 14 bits
.............................. ............PWM 10101000 000010
.
. 2^6 cycles
.
.............................. ............PWM 10101000 111111
.............................. ............PWM 10101001 000000 egalité CAN et PWM 8 bits poids fort apres debordement suivant

C'est bien ce que j'avais mis, j'avais juste omis de mettre la dernière phrase :

.............................. ............PWM 10101001 000000 egalité CAN et PWM 8 bits poids fort apres debordement suivant

[invitead51e543]

J'ai modifié mon code, mais il ne fonctionne toujours pas.

- Quand CAN = 0, PWM varie toute seule entre environ 250 & 255 (inversé?!?).
- Quand 0<CAN<255, PWM = 0 avec quelques pics?!
- Quand CAN = 255, PWM varie toute seule entre environ 0 & 5 (inversé?!?).

Voici mon code :

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>

#define HI(x)     ((unsigned int)(((x))&0xFF00)>>8)
#define LO(x)     ((unsigned int)((x)&0x00FF))
#define _XTAL_FREQ 10000000

int main(int argc, char** argv)
{
    unsigned int moyenne = 0;
    unsigned int PWM_Val = 0;
    unsigned int PWM_Val_14 = 0;
    int i = 0;
    RCONbits.IPEN = 1; // On active les priorités des interruptions
    INTCONbits.GIE = 1; // Active les interruptions
    INTCONbits.PEIE = 1; //Active les interruptions périphériques
    PIE1bits.TMR2IE = 1; // Enable the TMR2 to PR2 match interrupt
    PIE1bits.ADIE = 1; // Active les interrutpions de l'AD
    IPR1bits.TMR2IP = 1; // TMR2 to PR2 Match Interrupt High Priority
    IPR1bits.ADIP = 0; // A/D Converter Interrupt Low Priority
    config_CAN();
    config_PWM();
    config_Timer2();
    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
        if (inter_Timer2 == 1)
        {
            if (compte == 16)
            {
                PIE1bits.ADIE = 0; // Désactive les interruptions de l'AD
                for (i = 0 ; i < 16 ; i++)
                {
                    moyenne = moyenne + result_conv[i];
                }
                moyenne = moyenne >> 4 ; // Décalage de 4 bits à droite correspond à division par 16
                PDC0H = HI(moyenne);  // On écrit 6 bits de poids fort de moyenne dans PDC0H
                PDC0L = ((moyenne)&0x00C0) >> 6;  // On écrit 2 derniers bits de poids fort de moyenne dans PDC0L
                PWM_Val = ( (int) PDC0H <<2) + PDC0L;  // Consigne PWM sur 8 bits
                PWM_Val_14 = ( (int) PDC0H <<8) + PDC0L;  // Consigne PWM sur 14 bits

                if (moyenne == PWM_Val)
                {
                    if (moyenne == 0)
                    {
                        PWM_Val_14--;
                    }
                    else if (moyenne == 255)
                    {
                        PWM_Val_14++;
                    }
                }
                else if (moyenne > PWM_Val )
                {
                    PWM_Val_14++;
                }
                else if (moyenne < PWM_Val)
                {
                    PWM_Val_14--;
                }
                PDC0H = HI(PWM_Val_14);
                PDC0L = LO(PWM_Val_14);
                compte = 0;
                result_conv[16] = 0;
                PIE1bits.ADIE = 1; // Active les interruptions de l'AD
            }
            else
            {
            }
            moyenne = 0;
            inter_Timer2 = 0;
        }
    }
}

Dans le prinicpe, ça devrait fonctionner, non?

[invitead51e543]

Autre petite chose, comme j'ai dit, j'utilise une interruption timer toutes les 50µs ; or, la période de ma PWM dure 420µs ; est-ce que cela peut avoir une importance?
L'interruption ne devrait-elle pas être plus longue que ma période?
Si vous voyez ce qui beugue dans mon code ci-dessus, n'hésitez pas

[paulfjujo]

Autre petite chose, comme j'ai dit, j'utilise une interruption timer toutes les 50µs ; or, la période de ma PWM dure 420µs ; est-ce que cela peut avoir une importance?

timer2 ?
quel est le timer associé à ton PWM ?

if faudrait voir le detail de:

    config_CAN();
    config_PWM();
    config_Timer2();

avec

 PDC0L = ((moyenne)&0x00C0) >> 6;

tu RAZ les 4 bits de poids faible..
ne serait ce pas plutot 0x00CF ?

[invitead51e543]

Je t'envoie le détail des fonctions dès demain, 9h .

En faisant ça, je voulais juste écrire les 2 derniers bits de poids fort dans PDC0L, mais ce n'est peut-être pas comme ça qu'il faut procéder.

Le Timer2, je m'en sert uniquement pour déclencher une interruption toutes les 50µs.

[paulfjujo]

OK...

je pense qu'il manque un element essentiel dans ton algorithme
c'est l'evenement delta de consigne, qui devrait declencher la rampe de lissage.
D'une maniere generale c'est une rampe de montee en vitesse qu'il faudrait gerer.
Que se passe -til si tu demarres avec une consigne affichée , la sortie passe d'un coup à la valeur modulo 64
(puisqu'en 8 bits)
ou sur un gros delta de consigne..

est-ce bien cela que tu recherches à faire ?



Au fait,y a t-il une raison de ne pas utiliser l'ADC en mode complet 10bits au lieu de 8 ?

[invitead51e543]

Si tu veux, plusieurs exemples :

- Consigne réglée à 0, on met d'un coup le potard à full (255) ==> Impact sur la sortie : elle doit passer par tous les paliers (0 à 2^14 = 16383 afin d'avoir une courbe linéaire). La durée pour y parvenir sera donc de 50µs * 16384 = 819,2ms.

- Consigne réglé à 128 (environ moitié), on met le potard à 0 ==> Impact sur la sortie : elle doit passer par tous les paliers ( 8191 à 0 afin d'avoir une courbe linéaire). La durée pour y parvenir sera donc de 50µs * 8192 = 409,6ms.

Si on change la valeur de 1 en décimal :
- Consigne réglée à 50 (110010) à 51 (110011) : il faudra 2^6 = 64 * 50µs = 3,2 ms afin de passer tous les paliers (6 bits de poids faible).

Pour ta question concernant le CAN sur 10 bits, j'ai trouvé qu'il était plus précis de n'utiliser que les 8 bits de poids fort (moins de fluctuation).

[invitead51e543]

Voici les fonctions que tu me demandais :

void config_CAN (void)
{
    TRISAbits.TRISA3 = 1;
    ANSEL0bits.ANS3 = 1;
    ADCON0 = 0x2D;
    ADCON1 = 0x00;
    ADCON2 = 0x36;
    ADCHSbits.GDSEL1 = 0; //AN3
    ADCHSbits.GDSEL0 = 0; //AN3
}

void config_PWM(void)
{
    PTCON0 = 0;
    PTCON1bits.PTEN = 1;
    PWMCON0bits.PWMEN0 = 1; // PWM1 enabled
    PWMCON0bits.PMOD = 1; // PWM indépendants
    OVDCONDbits.POVD1 = 1; //
    periode_PWM =  4095; //période de 420µS
    PTPERH = periode_PWM >> 8; // On stocke les 4 bits de poids fort dans PTPERH
    PTPERL = periode_PWM; // On masque les 4 bits de poids fort et on stocke les 8 bits de poids faible
}

void config_Timer2 (void)
{
    T2CON = 0x05;
    PR2 = 125; // Periode = 50µs
}

void interrupt high_priority Timer2 ()
{
   if (PIR1bits.TMR2IF == 1)
   {
       inter_Timer2 = 1;
       PIR1bits.TMR2IF = 0;
   }
}

void interrupt low_priority conv_CAN ()
{
   if (PIR1bits.ADIF == 1) // Si conversion terminée
   {
       //result_conv[compte] = ( (int) ADRESH << 2 ); // Résultat de la conversion sur 8 bits.
       result_conv[compte] = (int) ADRESH;
       compte++;
       Nop();
       Nop();
       Nop();
       PIR1bits.ADIF = 0; // On réintialise ADIF
       ADCON0bits.GO = 1; // On lance une conversion
   }
}

[paulfjujo]

Si tu veux, plusieurs exemples :

- Consigne réglée à 0, on met d'un coup le potard à full (255) ==> Impact sur la sortie : elle doit passer par tous les paliers (0 à 2^14 = 16383 afin d'avoir une courbe linéaire). La durée pour y parvenir sera donc de 50µs * 16384 = 819,2ms.

- Consigne réglé à 128 (environ moitié), on met le potard à 0 ==> Impact sur la sortie : elle doit passer par tous les paliers ( 8191 à 0 afin d'avoir une courbe linéaire). La durée pour y parvenir sera donc de 50µs * 8192 = 409,6ms.

Si on change la valeur de 1 en décimal :
- Consigne réglée à 50 (110010) à 51 (110011) : il faudra 2^6 = 64 * 50µs = 3,2 ms afin de passer tous les paliers (6 bits de poids faible).

Pour ta question concernant le CAN sur 10 bits, j'ai trouvé qu'il était plus précis de n'utiliser que les 8 bits de poids fort (moins de fluctuation).

La au moins,ca le merite d'etre clair,et cela correspond bien
a la gestion d'une rampe.
.je vais tester ton code dabs la journee..

[invitead51e543]

OK, tant mieux si j'ai été clair .
Merci de ton aide, je vais essayer de trouver également si qui ne fonctionne pas.

[invitead51e543]

J'ai modifié une partie dans mon programme principal, je trouve que le raisonnement est le bon, malheureusement mon PWM fait toujours n'importe quoi..

 while(1)
    {
        if (inter_Timer2 == 1)
        {
            if (compte == 16)
            {
                PIE1bits.ADIE = 0; // Désactive les interruptions de l'AD
                for (i = 0 ; i < 16 ; i++)
                {
                    moyenne = moyenne + result_conv[i];
                }
                moyenne = moyenne >> 4 ; // Décalage de 4 bits à droite correspond à division par 16
                PWM_Val = ( (int) PDC0H <<2) + PDC0L; // Consigne PWM (8 bits de poids fort)
                PWM_Val_14 = ( (int) PDC0H <<8) + PDC0L; // Consigne PWM sur 14 bits

                if (moyenne == PWM_Val)
                {
                    if (moyenne == 0)
                    {
                        PWM_Val_14--;
                    }
                    else if (moyenne == 255)
                    {
                        PWM_Val_14++;
                    }
                }
                else if (moyenne > PWM_Val )
                {
                    PWM_Val_14++;
                }
                else if (moyenne < PWM_Val)
                {
                    PWM_Val_14--;
                }
                PDC0H = HI(PWM_Val_14);
                PDC0L = LO(PWM_Val_14);
                compte = 0;
                result_conv[16] = 0;
                PIE1bits.ADIE = 1; // Active les interruptions de l'AD
            }
            else
            {
            }
            moyenne = 0;
            inter_Timer2 = 0;
        }
    }

[invitead51e543]

Le seul endroit d'où peut venir le problème (Je pense), c'est ici :

PWM_Val = ( (int) PDC0H <<2) + PDC0L; // Consigne PWM sur 8 bits
PWM_Val_14 = ( (int) PDC0H <<8) + PDC0L; // Consigne PWM sur 14 bits

Le reste me parait tellement logique...

[paulfjujo]

en effet....

PWM_Val = ( (int) PDC0H <<2) + PDC0L>>6; // Consigne PWM sur 8 bits

les bits 7 et 6 de PDCOL doivent devenir respectivement bit 1 et 0

[invitead51e543]

Je ne peut pas voir ta pj encore, mais malgré la modification du code, ma PWM en sortie ne varie pas en fonction de ma consigne d'entrée. Elle varie toute seule.

[paulfjujo]

je n'ai pas encore commencé à travaillé sur ton code
mais il me semble , par instinct ou au pif ! qu'il y a un probleme de
poule et d'oeuf ...
Les registres PCD0H et PCD0L ne peuvent pas etre en meme temps
CONSIGNE et MESURE
il me semble qu'il manque une etape intermediare telle que
ancienne consigne = point de depart
et nouvelle consigne = point d'arrivée
.. à cogiter.

[Seb.26]

Pourquoi donc tu divise la somme de tes valeurs pour calculer la moyenne ???!!!

j'ai pas suivi le début, mais à ta place je ferais :

(exemple à adapter)

si j'ai un CAN qui me sort un 8b
si je veux écrire la moyenne dans un registre 12b que l'on va nommer reg_PWM
-> je fais un tableau de 16 valeurs ( car 12-8=4 et 4^2=16 )
-> additionne mes 16 valeurs et je stocke le resultat comme valeur de consigne pour le registre reg_PWM

Ensuite, sur IT d'un timer :
si ma consigne est < à la valeur actuelle du PWM, on fait -1
si la consigne est > on fait +1 ...

et on ecrit le valeur actuelle du PWM dans le registre

... et basta ...

si le CAN me sort 16 fois 0x00, somme = 0x000 = 0 ... et donc le PWM est à 0%
si le CAN me sort 16 fois 0xFF, somme = 0xFFF = 4096 ... et donc le PWM est à 100%

C'est un peu bête d'additionner des valeurs puis de diviser le résultat (donc de perdre de la précision) pour ensuite multiplier (donc créer des zéros en fin de valeur) le tout pour faire rentrer ça dans un registre trop grand ...

[invitead51e543]

Je vais travailler dans cette direction, & j'attends de tes nouvelles.
Encore merci.

[invitead51e543]

Pourquoi donc tu divise la somme de tes valeurs pour calculer la moyenne ???!!!

j'ai pas suivi le début, mais à ta place je ferais :

(exemple à adapter)

si j'ai un CAN qui me sort un 8b
si je veux écrire la moyenne dans un registre 12b que l'on va nommer reg_PWM
-> je fais un tableau de 16 valeurs ( car 12-8=4 et 4^2=16 )
-> additionne mes 16 valeurs et je stocke le resultat comme valeur de consigne pour le registre reg_PWM

Ensuite, sur IT d'un timer :
si ma consigne est < à la valeur actuelle du PWM, on fait -1
si la consigne est > on fait +1 ...

et on ecrit le valeur actuelle du PWM dans le registre

... et basta ...

si le CAN me sort 16 fois 0x00, somme = 0x000 = 0 ... et donc le PWM est à 0%
si le CAN me sort 16 fois 0xFF, somme = 0xFFF = 4096 ... et donc le PWM est à 100%

C'est un peu bête d'additionner des valeurs puis de diviser le résultat (donc de perdre de la précision) pour ensuite multiplier (donc créer des zéros en fin de valeur) le tout pour faire rentrer ça dans un registre trop grand ...

Si tu tournes ton potar d'un coup, est ce que ça peut marcher?

[Seb.26]

<< my 2 cents >>

De plus, si tu fais varier ton PWM en suivant une rampe (+1 ou -1), faire une moyenne du CAN ne sert à rien ... puisque de toute façon tu suivra une rampe linéaire ...

[Seb.26]

Si tu tournes ton potar d'un coup, est ce que ça peut marcher?

Peu importe ce que tu fais avec ton potard, ton PWM augmente ou baisse de +1 ou -1 toutes les x ms et x est fixe ... donc ...