Est-ce possible en langage C?

[Seb.26]

Donc ton algo devient :

...
uInt16 valeur_PWM = 0;
...

timer()
{
  uInt16 consigne_PWM = ((uInt16)CAN) << 6; // si CAN sort un 8b et que tu veux un 14b

  if( valeur_PWM > consigne_PWM )
  {
    valeur_PWM--;
    registre_PWM = valeur_PWM;
  }

  if( valeur_PWM < consigne_PWM )
  {
    valeur_PWM++;
    registre_PWM = valeur_PWM;
  }
}

<< and voila ! >>
-----

[invitead51e543]

Je vais regarder ton bout de code, mais est ce que tu as lu la conversation depuis le début?Est ce le fonctionnement attendu?

[Seb.26]

Je vais regarder ton bout de code, mais est ce que tu as lu la conversation depuis le début?Est ce le fonctionnement attendu?

"non" et "à toi de voir" ...

[invitead51e543]

Je pense qu'en procédant de cette façon, étant donné que la mesure du CAN n'est pas très précise, il y aura pas mal de fluctuations sur ma PWM même si on ne fait pas varier la consigne..

[Seb.26]

Je pense qu'en procédant de cette façon, étant donné que la mesure du CAN n'est pas très précise, il y aura pas mal de fluctuations sur ma PWM même si on ne fait pas varier la consigne..

OK, alors dans ce cas tu refais ton tableau de 16 valeurs, tu additionne les 16 valeurs et tu utilise cette valeur comme consigne.

Reste le souci d'avoir bien un vrai 0% et un vrai 100% ...

Je te donne une solution à ce problème :

...
uInt8 pos = 0;
uInt8 tableau_moyenne[16];

uInt16 valeur_PWM = 0;
...

timer()
{
  tableau_moyenne[pos++] = valeur_CAN;
  if( pos >= 16 )
  {
    pos = 0;
  }

  uInt16 consigne_PWM = TOTAL( tableau_moyenne[] );
  consigne_PWM = (consigne_PWM<<2) + ((consigne_PWM&0x0C00)>>10); // je te laisse voir si ça marche et si oui pourquoi ... ;-)

  if( valeur_PWM > consigne_PWM )
  {
    valeur_PWM--;
    registre_PWM = valeur_PWM;
  }

  if( valeur_PWM < consigne_PWM )
  {
    valeur_PWM++;
    registre_PWM = valeur_PWM;
  }
}

[invitead51e543]

consigne_PWM = (consigne_PWM<<2) + ((consigne_PWM&0x0C00)>>10); // je te laisse voir si ça marche et si oui pourquoi ... ;-)

Cette instruction permet de passer de 12 bits à du 14 bits, avec comme 2 derniers bits les 2 bits de poids fort.

  if( valeur_PWM > consigne_PWM )
  {
    valeur_PWM--;
    registre_PWM = valeur_PWM;
  }

  if( valeur_PWM < consigne_PWM )
  {
    valeur_PWM++;
    registre_PWM = valeur_PWM;
  }
}

Peut-on écrire :

  if( valeur_PWM > consigne_PWM )
  {
    valeur_PWM--;
  }

  if( valeur_PWM < consigne_PWM )
  {
    valeur_PWM++;
  }
    registre_PWM = valeur_PWM;
}

Cela revient au même, non?

[Seb.26]

Cette instruction permet de passer de 12 bits à du 14 bits, avec comme 2 derniers bits les 2 bits de poids fort.

c'est ça ... et donc tu as bien ton 100% ...

Cela revient au même, non?

à voir avec la datsheet, car dans ce cas tu écris le registre PWM à chaque fois, y compris quand la valeur est identique ... je ne sais pas si cela pose un problème à ton uCPU ou pas ??!

[invitead51e543]

Je vais être chiant, mais tu le trouves ou dans la datasheet?

[invitead51e543]

J'ai testé sur des leds en sortie pour vérifier le fonctionnement, j'ai pas l'impression que ça fonctionne, on voit bien l'escalier quand j'ai une valeur faible de consigne.

[invitead51e543]

Je vais donc voir si paulfjujo a réussi à déchiffrer mon code

[invitead51e543]

Après test si des leds, on distingue bien les marches en basse consigne, le PWM produit est donc du 8 bits et non du 14!!!
Tu as pu regarder mon code paulfjujo?

[paulfjujo]

bonjour,

quelques remarques


le timer2 genere une IT toute les 50µS
ce n'est pas possible de gerer tout le code compris entre chaque IT...
interrompu aussi par la routine acquisition ADC, qui risque de ne pas etre souvent servie
puisque en low priorité

n'importe comment la mise à jour du PWM se fera QUE toutes les 16 acquisition ADC
l'interrupt Timer2 HACHE considerablement l'execution du programme principal
il faut à mon avis mettre un timing uniquement sur la periodicité
d'acquisition de 16 valeurs avec un delai (Tempo) de quelques mS ..
et supprimer l'IT Timer2
ou l'elonguer à quelques mS pour s'en servir de ralentisseur de boucle principale

Verson avec notion de valeur courante et valeur ancienne ....
Attention, j'ai quelques adaptation à mon propre MCU (18F46K22)

    RCONbits.IPEN = 1; // On active les priorités des interruptions
    INTCONbits.PEIE = 1; //Active les interruptions périphériques
     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

   PIE1bits.TMR2IE = 0; // Disable the TMR2 to PR2 match interrupt

    Init_ADC(); //config_CAN();
	ADCON2bits.ADFM=1;     // left justified
    config_PWM();
    config_Timer2();
	compte=0;
	moyenne=0;
	Old_Moyenne=0;

  	INTCONbits.GIE = 1; // Active les interruptions
    ADCON0bits.GO = 1; // On lance une conversion
    while(1)
    {
           if (compte == 16)  
            {   PIE1bits.TMR2IE = 0;
                PIE1bits.ADIE = 0; // Désactive les interruptions de l'AD
                moyenne =result_conv >> 4 ; // Décalage de 4 bits à droite correspond à division par 16
                PDC0H = (unsigned char)(Old_Moyenne>>2);  // On écrit 6 bits de poids fort de moyenne dans PDC0H
				// On écrit 2 derniers bits de poids fort de moyenne dans PDC0 sans toucher les 6 bits complementaires
                PDC0L = (unsigned char) (Old_Moyenne & 0x00CF) << 6;  
                PWM_Val_14 = ( (int) PDC0H <<8) + PDC0L;  // Consigne PWM sur 14 bits

                if (moyenne >Old_Moyenne)  
				{
 					
					PWM_Val_14++;
                                        PDC0L = (unsigned char) (PWM_Val_14 & 0x00CF); 
				}
 				if (moyenne <Old_Moyenne)  
				{
 					PWM_Val_14--;
                                        PDC0L = (unsigned char) (PWM_Val_14 & 0x00CF); 
				}

				if (moyenne==Old_Moyenne) 
				{
					PWM_Val_14=	PWM_Val_14 & 0xFFC0; // Raz partie 6 bits details
					Old_Moyenne=moyenne;
				}
  			  compte = 0;
			  moyenne = 0;
              result_conv = 0;
              PIE1bits.ADIE = 1; // réActive les interruptions de l'AD
            }
          Tempo(1000);   // eventuel ralentissement de la boucle
       }// while

c'est l'idee , mais pas encore testé... j'ai faim..

[invitead51e543]

Je ne veux pas t'empêcher de manger .
N'ayant pas vraiment le temps cet après midi, j'ai juste lancer ton code en le survolant, je n'ai rien en sortie, enfin si tu le teste tu pourra le constater.
J’essaierais de m'y pencher dessus cet après midi.

[Seb.26]

J'ai testé sur des leds en sortie pour vérifier le fonctionnement, j'ai pas l'impression que ça fonctionne, on voit bien l'escalier quand j'ai une valeur faible de consigne.

si tu applique bien des +1 et des -1 à ta consigne de PWM, il ne peut pas y avoir de marche puisque tu change la valeur le plus finement possible ( +1 et -1 ).

donc si tu vois des escaliers, tu as un bug quelque part ... et il est très probablement dans ton interface chaise-clavier ... ... relis ton code, exécute le dans ta tête, utilise des sorties pour visualiser la durée de tes interruptions avec un oscillo ...etc... mets les mains dans le cambouis ! ... c'est ça qui est bon.

[paulfjujo]

bonsoir,

Pas tres evident le debugging.. testé avec 2 bytes representant le s registre PWM ,au lieu du vrai PWM
valeur du potar et valeur de la consigne 14 bits à chaque pas... > 16384 lignes sur le terminal
La diifculté est sur le verouilage du franchissement des limites du "compteur ajustement fin" ,
au niveau de changement de sens lorsqu'une action est en cours..
A VERIFIER ..

Le code en C18 MPLAB pour un 18F46K22 ..
MPLABX me parait beaucoup trop lourd avec ses multiples directories et fichiers !
et j'utilise aussi maintenant MikroC Pro.

J'ai viré le timer2 , la boucle tourne sur le temps de conversion ADC + eventuelle tempo
On pourrait garder le timer2 pour cadencer la boucle principale, mais surement pas à 50µS...

18F46K22_test_Rampe.zip

[invitead51e543]

Bonjour,

Désolé pour ce retard, j'étais très occupé.
Je vais jeter un coup d’œil à ton code.
Alors j'ai modifié un peu mon code et ma façon de procéder.

J'utilise toujours le Timer2 en interruption (50µs), afin d'avoir un "rafraichissement" de la valeur de ma PWM.

- Timer2 en haute priorité
- Conversion du CAN en basse priorité

Je pense que c'est plus logique qu'il n'y est pas de lien en terme de durée entre ces 2 interruptions.

J'ai également fait la partie verrouillage pour les limites.

Mais petite question, pour aller de zéro à 100% de consigne, quelle sera la durée?

- 16384 * 50µs = 819ms
- 16384 * 420µs (durée d'une période PWM) = 6,8s

La première solution m'arrangerait, mais faut-il envoyer une trame entière à chaque changement de la variable PWM_Val_14?

J'écris dans PDC0H & PDC0L à chaque interruption Timer, donc en tout je mets environ 7 seoncdes pour 0% ->100%
Mais est-ce bien comme ça qu'il faut procéder?

Merci.

[invitead51e543]

Bonjour,

Pour comprendre le problème, je fais donc du debeug, et voici le soucis que je rencontre.

Je simule le comportement de mon CAN manuellement, et je lui rentre la valeur : unsigned char moyenne_8bits = 0x01;

Je mets un Breakpoint dans mon interruption Timer, et règle ma valeur de PWM par défaut à 0. Toutes les 50 µs, PWM_Val_14 s'incrémente bien, l'écriture dans PDC0L s'effectue bien. En revanche, quand j’atteins la valeur PWM_Val_14 = 26, moyenne_8bits passe à 0, et ma valeur PWM_Val_14 se décrémente.

Je ne sais pas du tout ce qu'il se passe, pourquoi moyenne_8bits passe à 0...

[Seb.26]

Bonjour,

Pour comprendre le problème, je fais donc du debeug, et voici le soucis que je rencontre.

Je simule le comportement de mon CAN manuellement, et je lui rentre la valeur : unsigned char moyenne_8bits = 0x01;

Je mets un Breakpoint dans mon interruption Timer, et règle ma valeur de PWM par défaut à 0. Toutes les 50 µs, PWM_Val_14 s'incrémente bien, l'écriture dans PDC0L s'effectue bien. En revanche, quand j’atteins la valeur PWM_Val_14 = 26, moyenne_8bits passe à 0, et ma valeur PWM_Val_14 se décrémente.

Je ne sais pas du tout ce qu'il se passe, pourquoi moyenne_8bits passe à 0...

a mon avis : ajouter 16 byte (8b) ne tient pas dans un 8b ... 16 * 2^8 = 4096... soit un 16b ... ton 8b deborde et retombe donc à 0 ...

[invitead51e543]

Problème résolu, juste un petit beug de mon simulateur. Nouvelle étape, jouer sur la vitesse de ma PWM en sortie suivant la vitesse à laquelle on tourne le potar en entrée.

- Si on le tourne rapidement, PWM de 0% à 100% en 1 ou 2 secondes
- Si on le tourne lentement, PWM le plus lent possible afin de ne pas voir d'avoir une belle courbe en sortie.

En avant