programmation DSPI33F - commande numérique alim à decoupage

[invite1adebb8b]

Bonjour à tous!

Je suis actuellement sur un projet qui consiste à réguler une alim à découpage à l'aide d'un PIC (DSPI33FJ16GS502).

J'utilise MPLABX en association avec XC16.

VOici les principales caractéristiques de mon montage:

- Montage Half-bridge multi-sortie - commande des MOS complémentaire, conduction continue
- Entré 12V / Sortie +5V, -5V, 8V
- Controle en mode tension
- Le sensing en tension se fait à l'aide d'un pont diviseur qui me ramene la tension d'entré de l'ADC (AN0) à 3.3V
- J'utilise un correcteur PID classique
- Les sortie PWM1H, PWM1L sont utilisé pour commander les MOS

Mon programme consiste à faire l'acquisition de la tension de sortie (ramené à 3.3V pour comparer avec une reference interne au PIC).
La fonction PIDControl se charge ensuite de calculer l'erreur et de calculer le nouveau rapport cyclique à injecter.

Pour résumer le résultat de l'acquisition est stocké dans ma variable ADC_RSLT0 et la nouvelle valeur du rapport cyclique est stocké dans PDC1.

Enfin c'est comme ca que cela devrait fonctionner, le probleme c'est que apres compilation et programmation je n'ai aucune activitée sur les sorties PWM... et je ne vois pas d'ou pourrait venir l'erreur.
Aussi je laisse mon code en pièce jointesi jamais quelqu'un à une idée sur le sujet...

Merci d'avance !


poste FS.txt
-----

[RISC]

Salut,
Je n'ai a priori rien vu dans ton code qui initialise le PPS (les sorties digitales sont programmables).
Si tu n'initialises pas le PPS ,aucune des broches en sortie n'est connecté aux sorties des périphériques à l'intérieur du dsPIC.
Il y a plein de notes d'applications qui montrent comment initialiser le PPS (avec des séquences de Unlock et Lock)
a+

[Montd'est]

C'est hors sujet, mais utiliser un demi pont (et ses complications) pour faire de la conversion TBT vers TBT... ? pour quelle puissance d'ailleurs ? isolation galva nécessaire à tout prix ?

[invite1adebb8b]

Oui isolation galvanique à tout prix...
En entré j'ai 12V et 3 Output à +5V, -5V et 8V


Oui effectivement j'ai completement oublié d'implémenter ma fonction PortInit() ^^....
Je m'y met de ce pas

[A voir en vidéo sur Futura]

[invite1adebb8b]

Re-bonjour,

Alors j'ai implémenter ma fonction PortInit() qui permet de faire un mapping des Input/Output du PIC. Je pense qu'elle fonctionne bien. Je la met ci-dessous en cas:

//****************************************************************************
//
//      Function: void PortInit
//
//****************************************************************************

void PortInit (void)
{
    //*************PWM**************//
    
    // PWM1H, PWM1L : init individual init value
    
    LATAbits.LATA3 = 0;
    LATAbits.LATA4 = 0;
    
    // PWM1H, PWM1L : init PWM output pins as output
    TRISAbits.TRISA3 = 0;
    TRISAbits.TRISA4 = 0;
    
    
    //*************ADC**************//
    
    // AN0 configure as analog pin
    ADPCFGbits.PCFG0 = 0;                       // Select CH0 as analog pin
   
    
    // AN0 configure as input pin
    TRISAbits.TRISA0 = 1;
    
    //*************unused PIN**************//
    // All unused pin have to be configure as output and driven at low level
    TRISAbits.TRISA1 = 0;
    LATAbits.LATA1 = 0;
    
    TRISAbits.TRISA2 = 0;
    LATAbits.LATA2 = 0;
    
    TRISBbits.TRISB0 = 0;
    LATBbits.LATB0 = 0;
    
    TRISBbits.TRISB1 = 0;
    LATBbits.LATB1 = 0;
    
    TRISBbits.TRISB2 = 0;
    LATBbits.LATB2 = 0;
    
    TRISBbits.TRISB5 = 0;
    LATBbits.LATB5 = 0;
    
    TRISBbits.TRISB6 = 0;
    LATBbits.LATB6 = 0;
    
    TRISBbits.TRISB7 = 0;
    LATBbits.LATB7 = 0;
    
    TRISBbits.TRISB8 = 0;
    LATBbits.LATB8 = 0;
    
    TRISBbits.TRISB9 = 0;
    LATBbits.LATB9 = 0;
    
    TRISBbits.TRISB10 = 0;
    LATBbits.LATB10 = 0;
    
    TRISBbits.TRISB11 = 0;
    LATBbits.LATB11 = 0;
    
    TRISBbits.TRISB12 = 0;
    LATBbits.LATB12 = 0;
    
    TRISBbits.TRISB13 = 0;
    LATBbits.LATB13 = 0;
    
    TRISBbits.TRISB14 = 0;
    LATBbits.LATB14 = 0;
    
    TRISBbits.TRISB15 = 0;
    LATBbits.LATB15 = 0;

}

Cependant mon code n'a pas l'air de vouloir fonctionner ^^.
C'est à dire que maintenant j'ai une activité sur mes sortie PWM1H et PWM1L (sortie complémentaire car montage type Push-pull / Half-bridge).
Mais la forme d'onde obtenue n'est pas du celle souhaitée: J'ai un semblant de découpage sauf que la tension ne tombe jamais à zero ...

Je remet en piece jointe le code en entier ainsi qu'un screencshot de la forme d'onde PWM obtenue...

Je pense que le probleme vient des différentes fréquences de fonctionnement. C'est à dire que que mon bloc ADC doit fonctionner trop vite ou trop lentement... A creuser...

Si quelqu'un à une idée qu'il n'hésite pas à m'en faire partager surtout

tek00003.pngcode.txt

[Montd'est]

C'est à dire que maintenant j'ai une activité sur mes sortie PWM1H et PWM1L (sortie complémentaire car montage type Push-pull / Half-bridge).
Mais la forme d'onde obtenue n'est pas du celle souhaitée: J'ai un semblant de découpage sauf que la tension ne tombe jamais à zero ...

Le schéma électrique serait le bien venu... driver... ?

Si quelqu'un à une idée qu'il n'hésite pas à m'en faire partager surtout

Mon idée serait de laisser tomber le programmable pour cet application et de prendre un bon vieux TL494 ou SG3525 qui a mon sens ne peux qu'être mieux.

[RISC]

Salut Gagaetan,

Tu n'as pas bien lu mon message....il existe une procédure spéciale pour connecter les périphériques digitaux aux broches qui utilise le PPS (Peripheral Pin Select).
Si tu ne fais pas cela tes unités de PWM internes ne sont pas connectées aux broches même si les broches ont été initialisées correctement en entrée ou sortie.
Lis la documentation, chapitre 10 et aussi le Family Reference Manual

a+

[invite5637435c]

Faire une alim à découpage avec un dsPIC, y en a qui aime se faire mal... pour rien.

[invite1adebb8b]

Merci pour ta réponse RISC. Cependant toutes les pins ne sont pas concernées par le PPS (pour ce PIC la). En outre seul les sorties PWM4L/H le sont donc je n'ai à prioris pas besoin de cette procédure (sauf erreur de ma part ).

De plus, j'avais au préalable tester une fonction PWM toute simple et cela marchait. J'avais simplement programmer les sorties PWM pour qu'elles me sortent un signal de découpage simple à 100kHz

Je met en pièce jointe le schéma non complet (seul la partie correction y est représentée) pour la simple et bonne raison que je ne peux pas mettre en ligne le schéma du montage complet (confidentialité).

Le but de ce projet est d'utiliser un PIC pour réguler la tension de sortie donc on oublie les TL494 et compagnie.

Pour Hulk28: Les DSPIC famille GS sont spécialement concues pour être utilisés dans une boucle de régulation dans les alimentations à découpage... les modules PWM permettent un large choix de controle (controle en fréquence, tension, peak-current mode control etc...) et permettent de réguler une palette assez conséquente de topologies. C'est donc un choix sensé que d'avoir choisie ce PIC

[invitee05a3fcc]

Le but de ce projet est d'utiliser un PIC pour réguler la tension de sortie donc on oublie les TL494 et compagnie.

Tu colles avec de l'araldite un DSPI33FJ16GS502 sur un TL494 ...et ton cahier des charges est tenu !

[Montd'est]

C'est donc un choix sensé que d'avoir choisie ce PIC

Tu m'en diras tant le jour ou t'auras un plantage qui te fera sauter ton électronique de puissance et/ou ta charge. ( surtension, saturation du transfo, I_peak non détecté...)

J'ai encore jamais ouvert une alim et trouvé dedans un contrôleur numérique, peut-être qu'il y a de bonnes raisons, sans parler du prix.

[invite1adebb8b]

Mon controleur sera implanté sur ancien modele de vol. En fait la conception de cette carte est le sujet de mon stage en entreprise (je travail dans le spécial donc niveau robustesse, sureté on a vu pire ).
Donc pas de souci de plantage de ce coté la

Justement l'utilisation de PIC dans ce genre d'activité est un sujet tres recent et tres interessant pour plusieurs raisons :
- Cout réduit malgré ce que tu en pense. (le pic ca ne coute quasiment rien).
- Reutilisation aisé, adaptation à différentes topologies (reprogrammation de la partie PID uniquement). Donc tres interessant à utiliser dans un banc de test.
- Poid et volume réduit (ce qui rejoint la réduction de cout).

Plusieurs constructeurs se sont déja pencher sur la question (Microchip, T.I ..). D'ailleurs pas mal de démoboard sont actuellement disponibles et une étude un peu approfondie de ces cartes te montrera qu'utiliser un µC pour ce genre d'application n'est pas une si mauvaise idée que ca

[invite5637435c]

Pourquoi? tu as la prétention de m'apprendre comment on fait une alim?J'ai conçu ma première alim à découpage alors que tu n'étais pas encore dans les rêves de tes parents.Et ça vient se la péter...

[invite1adebb8b]

Oula j'ai aucune prétention du tout!
Je suis simplement venue pour essayer de résoudre les problèmes que j'avais sur mon projet. Sur l'ensemble de mes message je ne pense pas déceler une trace de prétention..
En ce qui concerne l'alim à découpage, comme je l'ai dit c'est un ancien modèle de vol donc c'est pas moi qui l'ai fait.. c'est peut etre pour ça que ça fonctionne ^^

Hulk28 : je trouve ton commentaire assez déplacé. Je sais que ma démarche et mon projet peut paraître assez étrange puisqu'on a rarement l'habitude d'implanter une PIC dans une boucle d'asservissement. Mais ça reste un projet intéressant qui mérite qu'on y passe du temps dessus .

[Montd'est]

- Cout réduit malgré ce que tu en pense. (le pic ca ne coute quasiment rien).

Rien que quand je vois ton µC + ton driver externe je ne peux pas y croire...

Les contrôleurs pour flyback par exemple, intègrent tous à ce que je saches le driver pour le mosfet et pour les "petites" puissances peuvent même intégrer le mosfet !

Ceux pour les convertisseurs résonants ou asymmetrical half-bridge intègrent à ce que je saches les 2 drivers high side / low side...

Comment ça pourrait revenir moins cher si c'est pas intégré dans un µC et que tu dois donc les ajouter ?....

- Poid et volume réduit

Absolument pas crédible... notamment si il faut ajouter: driver, diode de bootstrap, (ou un transfo d'impulsion) et un quartz...

[invite1adebb8b]

Montd'est : Quel probleme as tu noté avec le driver? Si il y a effectivement une incohérence dans mon montage je suis tout ouie !

Pour le reste encore une fois je sais qu'il existe des controleurs tres efficaces et dédiés pour ce type d'utilisation, mais le sujet actuel c'est bien d'essayer de réaliser un asservissement avec un PIC.

Je ne suis pas la pour justifier et argumenter mon sujet de stage, mais simplement pour essayer de trouver le probleme dans mon code.

Au passage j'ai tester ce montage avec un programme qui balance des signaux de découpage PWM (sans acquisition ni intervention du bloc DSP). Le driver faisait très bien son boulot... Les MOS découpaient bien à la fréquence voulue

[Montd'est]

Montd'est : Quel probleme as tu noté avec le driver?

Aucun, je répondais simplement au sujet du prix/place/poids

Sans schéma complet j'aurais bien du mal à juger de toute manière

mais simplement pour essayer de trouver le probleme dans mon code.

Ce qui n'est pas dans mes compétences, je t'avouerais.

[invite5637435c]

Commentaire déplacé ou pas, c'est le mien et j'ai, contrairement à toi qui visiblement débute, toute légitimité à l'exprimé, que ça te plaise ou pas.Tu parles dans le vide car visiblement tu n'as jamais réalisé ni conçu la moindre alim à découpage.Sans quoi tu n'avancerai pas sur ce chemin voué à l'échec assuré.Réalise déjà une alim ensuite tu viendras faire de la philo sur un dsPIC sensé remplir une tâche pour laquelle il est inadapté industriellement.J'ai eu entre les mains à peu près tous type de reference design de ce type, il n'ont jamais passé nos tests.En plus Microchip n'est pas une référence en la matière, ça tout le monde le sait.La différence? C'est juste un métier à part entière, la réalité est bien plus complexe et exigeante qu'un simple proto qui évolue à son aise sur une paillasse de labo ou confidentiellement sur un salon pour tenter de faire vendre du dsPIC dont personne ne veux sauf les étudiants comme toi un peu gogo attirés par les as du marketing...

[invite1adebb8b]

Encore un message très constructif de ta part, on sent beaucoup de frustration peut être lié à un besoin de reconnaissance de la part des autres internautes chez toi ça fais plaisir.
On va mettre les choses au clair : C'est un projet réalisé dans entreprise spécialisé dans le spatial qui à été validé par plusieurs ingénieurs cumulant une expérience dans les alimentations à découpage de plus de 10 ans..
J'en ai un peu marre de devoir me justifier sur la faisabilité ou non de mon projet...

Je ne te parle pas non plus de mon expérience (j'ai déja réaliser des alimentation ...) non plus parce que j'ai vraiment pas envie de m'abaisser à ton niveau.

Bref a part si tu as un commentaire sur le code qui, je le rappelle, est le sujet principal de ce post, ce n'est plus la peine de répondre.De toute façon je ne lirai plus tes messages.

Merci

Si vraiment tu ressens le besoin de m'expliquer de manière constructive pourquoi ce projet est un non sens tu peux tout de même m'envoyer un message privé.

P.S. : Je suis désolé mais ton commentaire sur mes parents était déplacé. Encore une fois on ressent chez toi un manque de reconnaissance. Oui je suis d'accord tu as visiblement une grande expérience dans ce domaine mais ça ne justifie en rien la nature de ton précédent message (qui relève quand même du niveau collège ).

[Antoane]

Bonjour,

Si on peut rester sur le sujet, svp.
C'est pas le lieu pour les sortir et comparer.

On sait, Hulk, Montd'est, que vous êtes plus compétent sur le sujet qu'une bonne partie des participants du forum, donc si vous pouviez en rester sur des questions techniques et éviter les arguments d'autorité...

Bonne journée.

[invite1adebb8b]

Merci !

[invite5637435c]

Enfin c'est comme ca que cela devrait fonctionner, le probleme c'est que apres compilation et programmation je n'ai aucune activitée sur les sorties PWM... et je ne vois pas d'ou pourrait venir l'erreur.

Pièce jointe 315984

Quand on en est là on évite de venir avec des certitudes à 2 balles.
Donc pour moi ce sera tout vu le ton donné dès le départ par le demandeur et son "assurance" en la matière.

[invite1adebb8b]

Quand on en est là on évite de venir avec des certitudes à 2 balles..

Encore une fois gros probleme d'appréciation de ta part. J'ai bien "devrait" donc c'est bien qu'il y a un probleme au niveau de mon code.. Niveau carte pas de probleme A PRIORIS puisque comme je l'ai répété au moins 10 fois j'ai tester la carte avec un programme PWM. Mais je ne prétend absolument pas être le plus fort dans ce domaine, contrairement à certain...


C'est dommage tout de même d'en arriver la car si seulement tu n'avais pas pris en grippe mon post et posté des messages sous le signe de l'orgueil tu aurais certainement pu m'aider sur mon projet (niveau carte je parle puisqu'en l'occurence la programmation PIC n'est absolument pas ton domaine)

Donc pour moi ce sera tout vu le ton donné dès le départ part le demandeur et son "assurance" en la matière.

Sage décision. Merci quand même pour tes précieux conseils. Il a fallu quelques posts mais on y est arrivé!

[RISC]

Salut,

Ou en es-tu des sorties PWM ?
Toujours rien qui sort sur PWM1H et PWM1L ?
Je te recommande faire un tout petit programme qui ne génère que ces 2 signaux et si tu n'as rien, compresses le projet MPLABX et poste le car voir seulement une partie du projet à ce stade ne suffit pas...
As-tu regardé les examples de code pour ce dsPIC ou pour les autres de la même famille ?

a+

[invite1adebb8b]

Salut RISC!

Alors j'ai reprogrammer le PIC avec un programme qui ne sollicite que les sorties PWM. C'est quasiment le même que mon code complet. J'en déduis donc que si je ne visualise rien en sortie avec mon programme complet c'est que la partie acquisition du signal et/ou traitement PID n'est pas codé correctement.

Je te met en pièce jointe le code du programme "test PWM" ainsi que le screenshot de l'oscillo qui permet de visualiser les sorties PW1H et PWM1L.

/*
 * File:   newmainXC16.c
 * Author: gaëtan
 *
 * Created on 3 juin 2016, 14:30
 */


#include "xc.h"
#include <p33FJ16GS502.h>



/* Configuration Bit Settings */
 int FBS __attribute__((space(prog), address(0xF80000))) = 0xF ;
//_FBS(
//    BWRP_WRPROTECT_OFF & // Boot Segment Write Protect (Boot Segment may be written)
//    BSS_NO_FLASH         // Boot Segment Program Flash Code Protection (No Boot program Flash segment)
//);
 int FGS __attribute__((space(prog), address(0xF80004))) = 0x7 ;
//_FGS(
//    GWRP_OFF &           // General Code Segment Write Protect (General Segment may be written)
//    GSS_OFF              // General Segment Code Protection (User program memory is not code-protected)
//);
 int FOSCSEL __attribute__((space(prog), address(0xF80006))) = 0x87 ;
//_FOSCSEL(
//    FNOSC_FRCDIVN &      // Oscillator Source Selection (Internal Fast RC (FRC) oscillator with postscaler)
//    IESO_ON              // Internal External Switch Over Mode (Start up device with FRC, then automatically switch to user-selected oscillator source)
//);
 int FOSC __attribute__((space(prog), address(0xF80008))) = 0x3 ;
//_FOSC(
//    POSCMD_NONE &        // Primary Oscillator Source (Primary oscillator disabled)
//    OSCIOFNC_ON &        // OSC2 Pin Function (OSC2 is general purpose digital I/O pin)
//    IOL1WAY_OFF &        // Peripheral Pin Select Configuration (Allow multiple reconfigurations)
//    FCKSM_CSECME         // Clock Switching and Monitor (Clock switching and Fail-Safe Clock Monitor are enabled)
//);
 int FWDT __attribute__((space(prog), address(0xF8000A))) = 0xDF ;
//_FWDT(
//    WDTPOST_PS32768 &    // Watchdog Timer Postscaler (1:32,768)
//    WDTPRE_PR128 &       // WDT Prescaler (1:128)
//    WINDIS_OFF &         // Watchdog Timer Window (Watchdog Timer in Non-Window mode)
//    FWDTEN_ON            // Watchdog Timer Enable (Watchdog timer always enabled)
//);
 int FPOR __attribute__((space(prog), address(0xF8000C))) = 0xF ;
//_FPOR(
//    FPWRT_PWR128         // POR Timer Value (128ms)
//);
 int FICD __attribute__((space(prog), address(0xF8000E))) = 0xC2 ;
//_FICD(
//    ICS_PGD2 &           // Comm Channel Select (Communicate on PGC2/EMUC2 and PGD2/EMUD2)
//    JTAGEN_OFF           // JTAG Port Enable (JTAG is disabled)
//);


int main()
{
/* Configure Oscillator to operate the device at 40Mhz
	   Fosc= Fin*M/(N1*N2), Fcy=Fosc/2
 	   Fosc= 7.37*(43)/(2*2)=80Mhz for Fosc, Fcy = 40Mhz */

	/* Configure PLL prescaler, PLL postscaler, PLL divisor */
	PLLFBD=41; 				/* M = PLLFBD + 2 */
	CLKDIVbits.PLLPOST=0;   /* N1 = 2 */
	CLKDIVbits.PLLPRE=0;    /* N2 = 2 */

    __builtin_write_OSCCONH(0x01);			/* New Oscillator FRC w/ PLL */
    __builtin_write_OSCCONL(0x01);  		/* Enable Switch */
      
	while(OSCCONbits.COSC != 0b001);		/* Wait for new Oscillator to become FRC w/ PLL */  
    while(OSCCONbits.LOCK != 1);			/* Wait for Pll to Lock */

	/* Now setup the ADC and PWM clock for 120MHz
	   ((FRC * 16) / APSTSCLR ) = (7.37 * 16) / 1 = ~ 120MHz*/

	ACLKCONbits.FRCSEL = 1;					/* FRC provides input for Auxiliary PLL (x16) */
	ACLKCONbits.SELACLK = 1;				/* Auxiliary Oscillator provides clock source for PWM & ADC */
	ACLKCONbits.APSTSCLR = 7;				/* Divide Auxiliary clock by 1 */
	ACLKCONbits.ENAPLL = 1;					/* Enable Auxiliary PLL */
	
	while(ACLKCONbits.APLLCK != 1);			/* Wait for Auxiliary PLL to Lock */

    /* ~~~~~~~~~~~~~~~~~~~~~~~~~ PWM Configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~ */
     
    PTPER = 481;            /* PTPER = ((500ns) / 1.04ns) = 481, where 500ns
							is the PWM period and 1.04ns is PWM resolution. */

    PDC1 = 250;             /* PWM1 duty cycle app 250ns */
                               
    PDC2 = 250;             /* PWM2 duty cycle app 250ns */
    
    /* Note that a pulse appears only on every other PWM cycle. So in push-pull
       mode, the effective duty cycle is 25% */
    
    DTR1 = 29;              /* DTR = (30ns / 1.04ns), where desired dead time is 30ns. */
                               
    DTR2 = 29;              /* DTR = (30ns / 1.04ns), where desired dead time is 30ns.*/
                                       
    ALTDTR1 = 29;           /* ALTDTR1 = (30ns / 1.04ns), where desired dead time is 30ns.*/
                               
    ALTDTR2 = 29;           /* ALTDTR2 = (30ns / 1.04ns), where desired dead time is 30ns. */
    
    PHASE1 = 0;             /* No phase shift for PWM1 */
    PHASE2 = 128;           /* Phase Shift = PHASE2*1.04nsec = 133 nsec */
    
    IOCON1bits.PENH = 1;    /* PWM1H output controlled by PWM */
    IOCON1bits.PENL = 1;    /* PWM1L output controlled by PWM */
    IOCON1bits.PMOD = 2;    /* Select Push-Pull PWM mode */
    
    IOCON2bits.PENH = 1;    /* PWM2H output controlled by PWM */
    IOCON2bits.PENL = 1;    /* PWM2L output controlled by PWM */
    IOCON2bits.PMOD = 2;    /* Select Push-Pull PWM mode */
    
    PTCONbits.PTEN = 1;     /* Turn ON PWM module */
  
    while(1);               /* Infinite loop */
}

[invite1adebb8b]

Ce dont je ne suis pas sur au final c'est la facon dont les différents programme sont ordonné (InitPWM, InitADC...) et le sous programme PID. Plus particulierement lorsque je rentre la tension de reference en décimal alors que la variable ADC_RSTL0 qui copie la valeur du registre ADCBUF0 est en integer...

[invite1adebb8b]

Bon alors quelques nouvelles: apres quelques modifications de la partie ADC et PWM mon programme fonctionne (quasiment...).
J'arrive a bien faire l'acquisition d'une tension via les ADC puis à la traiter via le bloc PID pour enfin me fournir un rapport cyclique.

Le problème que j'ai maintenant c'est que mon bloc PID n'a pas l'air de fonctionner comme il le devrait:

La valeur de mon rapport cyclique reste insensible aux variation de tensions que j'injecte dans la pin ADC. Il reste constamment à la valeur initiale renseigné dans le bloc PWM.

Pour réaliser la fonction PID je me sert d'une fonction inclue dans la librairie <dsp.h> . Je fais appel à la structure tPID.

Ce qu'il y a dans cette structure :

typedef struct {
        fractional* abcCoefficients;  /* coeffs derived from Kp, Ki & Kd */
        fractional* controlHistory;   /* state variables (delay line)in Y-data
        fractional controlOutput;     /* PID Controller Output  */
        fractional measuredOutput;    /* Measured Output sample */
        fractional controlReference;  /* Reference Input sample */
} tPID;

extern void PIDCoeffCalc( fractional* kCoeffs, tPID* controller );
extern void PIDInit ( tPID* controller );
extern fractional* PID ( tPID* controller );

Voila comment j'ai codé la fonction :


J'ai tout d'abord défini la structure:

tPID fooPID;                            //declaration of a pid structure

fractional abcCoefficient[3]__attribute__((section(".xbss, bss, xmemory")));
fractional controlHistory[3]__attribute__((section(".ybss, bss, ymemory")));
fractional kCoeffs[]={0,0,0};

J'ai ensuite initialisé le PID :

/* initialize the PID data structure*/
    
    fooPID.abcCoefficients = &abcCoefficient [0];
    fooPID.controlHistory = &controlHistory[0];
    PIDInit(&fooPID);
    
    kCoeffs [0] = Q15(10000000);
    kCoeffs [1] = Q15(10);
    kCoeffs [2] = Q15(10);
    PIDCoeffCalc (&kCoeffs[0], &fooPID);
    
    ref = 0.493;

Ici je renseigne les valeurs des coefficients liés aux parametres kp,ki, kd et je renseigne la reference en (0.493).

Ensuite dans la boucle while, je renseigne la nouvelle valeur actualisé du rapport cyclique en fonction des variations de tension d'entrée:

while(1)
    {
     
        if (fooPID.controlOutput>Q15(0.0))
            
            duty = (int)((fooPID.controlOutput)*4506);
        
        else
            
            duty = 0;
        if (duty > duty_max)
            
            duty = duty_max;
        else PDC1 = duty;
        
    }

et enfin dans mon interruption d'acquisition adc :

void __attribute__((__interrupt__,no_auto_psv))_ADCP0Interrupt ()
{
    unsigned int ADC_RSLT0;
    
    
    IFS0bits.ADIF = 0;                          // clear AD interrupt
    IFS6bits.ADCP0IF = 0;
    ADSTATbits.P0RDY = 0;                       // clear the data in buffer bit
    
    controle = ADCBUF0;
    
    /* use the PID data structure*/
    
    fooPID.controlReference = ref/2;                                     //set the reference input
    fooPID.measuredOutput = controle;                                 //plant reponse measured fromA/D input
      
        PID(&fooPID);
     
        
         
}

Donc dans cette partie je renseigne la reference a partir de laquelle le bloc pid compare la valeur de la tension d'acquisition présent dans le registre ADCBUF0.

Sauf que je n'ai en sortie aucune variation de rapport cyclique. Je pense que mon probleme vient de celle ligne : duty = (int)((fooPID.controlOutput)*4 506);

Le fait est que je n'ai pas trouvé beaucoup d'info sur le format de fooPID.controlOutput. J'ai supposé qu'il était compris entre 0 et 1, c'est d'ailleur pour ca que je l'ai ensuite multipliéé par la valeur de mon rapport cyclique max (4506) mais sans grand succé...


Si quelqu'un a une idée ...

[RISC]

Salut,
les nombres fractionnels doivent être compris entre 0 et 1 (non signé) ou (-1 et +1) si tu travailles avec l'unité DSP des dsPIC.
Il y a donc un travail de mise à l'échelle nécessaire.
Autre point intéressant, tu peux définir dans ton programme tous les coefficients sous forme de floats ce qui rend le debug plus simple. il suffit ensuite d'appeler les fonctions/macros Float2frac et Frac2Float pour avoir la conversion (vérifier les librairies).
Ci-joint un exemple de PID pour le controle moteur qui utilise directement la partie DSP sans passer par les librairies mais le principe est similaire.
Le "RTDM" permet de remonter les données au travers du plugin DMCI pou visualiser les données sous forme graphique dans MPLABX
a+

[invite1adebb8b]

Ok merci pour la réponse! En effet j'avais bien un probleme de mise à l'echelle. Cependant le probleme n'est pas encore résolue. En fait il se trouve que la fonction tPID disponible dans la librairie <dsp.h> ne semble pas fonctionner...(ou du moins je dois mal la codée).

En effet cette fonction a deux entrées : measuredOutput et ControlReference qui sont donc mon sensing en tension et la reference de tension. Ensuite le registre controlHistory fais la différence de ces deux valeurs (il s'agit en fait de l'erreur). Quand je fais du debuggage pas à pas le registre copntrolhistory fais bien son travail (l'erreur est bien calculé). Ensuite la valeur de ce registre est censé passer par un traitement PID et ensuite une valeur de sortie ControlOutput est censé nous fournir le nouveau rapport cyclique:


controlOutput[n] = controlOutput[n-1]
+ controlHistory[n] * abcCoefficient[0]
+ controlHistory[n-1] * abcCoefficient[1]
+ controlHistory[n-2] * abcCoefficient[2]


Le probleme c'est que en mode pas à pas je me suis aprecu que les valeurs contenue dans les registres abcCoefficient étaient nuls alors que je les avais bien renseigné au départ :

fooPID.abcCoefficients = &abcCoefficient [0];
    fooPID.controlHistory = &controlHistory[0];
    PIDInit(&fooPID);
    
    kCoeffs [0] = Q15(10000000);
    kCoeffs [1] = Q15(10);
    kCoeffs [2] = Q15(10);
    PIDCoeffCalc (&kCoeffs[0], &fooPID);

Du coup la valeur de controlOutput vaut toujours 0 ...

[RISC]

Salut,
Du à la facon dont le PID est adapté à la partie DSP, les coefficients K1, K2, K3 sont normalement calculés à partir de Kp, Ki et Kd.
Je n'ai pas utilisé la librairie mais directement la partie DSP à partir de l'assembleur.
J'ai l'impression dans ton programme que tu confonds K1,K2,K3 avec Kp,Ki et Kd. Peux-tu revérifier la librairie ?
Je "suppose" qu'elle devrait proposer une fonction qui calcule K1,K2 K3 à partir de Kp, Ki et Kd
a+