Répondre à la discussion
Affichage des résultats 1 à 4 sur 4

onduleur sur un dspic30f6010a



  1. #1
    Persuadeur

    onduleur sur un dspic30f6010a


    ------

    Bonjour,

    J’utilise la carte de développement microchip basé sur le dspic30f6010a avec un module de puissance (onduleur)microchip. Mon but est de faire marcher la MLI et pour l'instant j'essai de faire marcher un pont de l’onduleur. J’ai prise un programme (an957) de microchip et j’ai tenté de l’adapter à ma carte et au capteur que j’avais c'est-à-dire d’un capteur à effet Hall à un QEI, cette dernière partie n’est pour l’instant pas implanté mais il y a un signal de position. Le registre OVDCON change bien mais il n’y a pas d’action au niveau des mosfetss de l'onduleur.

    Code:
    int main(void)
    {
    	LATE = 0x0000;
    	TRISE = 0xFFC0;		// PWMs are outputs  // 
    	CNEN1 = 0x00E0;		// CN5,6 and 7 enabled 
    	CNPU1 = 0x00E0;		// enable internal pullups
    	IFS0bits.CNIF = 0;	// clear CNIF 
    	IEC0bits.CNIE = 1;	// enable CN interrupt
    	InitMCPWM();
    	InitADC10();
    	InitUART();
    	InitTMR3();
    	timer3avg = 0;
    	while(1)
    	{	
    		HallValue = (PORTB & 0x0038) >> 3;			// shift right to get value 1, 2 ... 6
    		OVDCON = StateLoTableAntiClk[HallValue];	// Load the overide control register
    		PWMCON1 = 0x0777;					// enable PWM outputs //11101110111
    		Flags.RunMotor = 1;					// set flag
    		T3CONbits.TON = 1;			/	/ start tmr3
    		polecount = 1;
    	
    	}	
    	
    
    }
    	
    void InitMCPWM(void)
    {
    	PTPER = FCY/FPWM - 1;
    
    	PWMCON1 = 0x0700;			// disable PWMs //11100000000
    	OVDCON = 0x0000;			// allow control using OVD
    	PDC1 = 100;					// init PWM 1, 2 and 3 to 100
    	PDC2 = 100;
    	PDC3 = 100;
    	SEVTCMP = PTPER;
    	PWMCON2 = 0x0F00;		// 16 postscale values //111100000000
    	PTCON = 0x8000;			// start PWM//1000000000000000
    	 
    }
    Je pense que c’est une erreur bête mais comme je suis débutant je galère pour la trouver. Si des bonnes âmes pouvaient m’aider !

    -----

  2. Publicité
  3. #2
    RISC

    Re : onduleur sur un dspic30f6010a

    Salut,

    Il existe plusieurs sites en français sur les dsPIC30 :
    * http://electronique.marcel.free.fr/#dsPIC_Microchip
    * http://moodle.epfl.ch/mod/resource/index.php?id=467
    * http://www.baghli.com/dspic_intro.php

    Jette aussi un oeil ici dans les exemples de code pour les dsPIC30. Tu devrais trouver plusieurs d'exemples de pilotage de moteurs PWM dans les notes d'application dédiée au contrôle moteur

    Ou sont les bits de configuration ?? Tu devrais les mettre dans ton programme.

    a+

  4. #3
    Persuadeur

    Re : onduleur sur un dspic30f6010a

    Pour les liens que tu m'as donnée, je les ai vu notamment pour les exemple de code d'où j'ai pris mon programme puis modifié de la note AN957 pour le mettre sur mon dsPIC
    Voici mon programme:

    Code:
    #include "p30F6010A.h"
    
    
    #define FCY  10000000			// xtal = 5.0Mhz; PLLx8   ///FCY: Instruction Clock Rate (1/TCY)
    #define MILLISEC FCY/10000			// 1 mSec delay constant
    #define FPWM 39000
    #define POLEPAIRS	5		// number of pole pairs ///
    #define INDEX	1			// Hall sensor position index
    
    #define S4	!PORTGbits.RG6 //bouton pour demarrer le moteur
    #define S5	!PORTGbits.RC7 //
    
    #define CR	0x0D //1101 
    #define LF 	0x0A //1010 
    #define BAUD 19200 //vitesse sur uart de l'info de vitesse
    #define SPEEDMULT	2343750 //facteur pour calculer la vitesse//constantRPM= 60*(FCY/256) /
    #define OFFSET 8  // offset in InData to load speed values
    
    void InitADC10(void); //initialisation des voies A/D
    void DelayNmSec(unsigned int N); //fonction permettant de mettre un délai avec N=durée
    void InitMCPWM(void);//intialisation du moteur MLI
    void InitUART(void);//initialisation de Universal Asynchronous Receiver Transmitter
    void SendSpeed(void);//permet de calculer la vitesse?
    void InitTMR3(void);//initialisation du timer
    void SendMsg(void);
    
    
    
    struct {
    			unsigned RunMotor : 	1;
    			unsigned SndSpeed :		1;
    			unsigned CheckRX :		1;
    			unsigned SendTX :		1;
    			unsigned unused 	:	14;
    		}	Flags;    //////Définition d'un structure "Flags"
    
    unsigned int HallValue;
    unsigned int timer3value;
    unsigned int timer3avg;
    unsigned char polecount;
    unsigned char *TXPtr;
    unsigned char *RXPtr;
    unsigned char InData[] = {"000000"};
    unsigned char OutData[] = {"Speed = 00000 rpm\r\n"};
    
    
    /*************************************************************
    	Low side driver table is as below.  In the StateLoTableClk
    	and the StateLoTableAntiClk tables, the Low side driver is
    	PWM while the high side driver is either on or off.  
    *************************************************************/
    
    unsigned int StateLoTableClk[] = {0x0000, 0x0210, 0x2004, 0x0204,
    									0x0801, 0x0810, 0x2001, 0x0000};
    
    
    unsigned int StateLoTableAntiClk[] = {0x0000, 0x2001, 0x0810, 0x0801,
    									0x0204, 0x2004, 0x0210, 0x0000};
    
    
    void __attribute__((interrupt, no_auto_psv)) _CNInterrupt (void)
    {
    	IFS0bits.CNIF = 0;				// clear flag
    	HallValue = (PORTB & 0x0038); //
    	HallValue = HallValue >> 3;	// shift right 3 times /
    	OVDCON = StateLoTableAntiClk[HallValue]; //Registre PWM manuel//voir paragraphe 15.10 "PWM Output Override"
    	if (HallValue == INDEX)	// has the same position been sensed?	
    		if (polecount++ == POLEPAIRS)	//has one mech rev elasped?
    		{								// yes then read timer3
    		timer3value = TMR3;
    		TMR3 = 0;
    		timer3avg = ((timer3avg + timer3value) >> 1);
    		polecount = 1;
    
    		} 
    }
    //---------------------------------------------------------------------
    
    void __attribute__((interrupt, no_auto_psv)) _U1TXInterrupt(void)
    {
    	IFS0bits.U1TXIF = 0;	// clear interrupt flag 
    }
    
    void __attribute__((interrupt, no_auto_psv)) _U1RXInterrupt(void)
    {
    	IFS0bits.U1RXIF = 0;	// clear interrupt flag 
    	*RXPtr = U1RXREG;
    	if (*RXPtr == CR)
    		{Flags.CheckRX = 1;RXPtr = &InData[0];}
    	else *RXPtr++;
    }
      
    
    
    /*********************************************************************
    The ADC interrupt loads the PDCx registers with the demand pot
    value.  This is only done when the motor is running.
    
    *********************************************************************/
    
    void __attribute__((interrupt, no_auto_psv)) _ADCInterrupt (void)
    {
    	IFS0bits.ADIF = 0;
    	if (Flags.RunMotor)
    	{
    		PDC1 = ADCBUF0 >> 1;					// get value ...
    		PDC2 = PDC1;					// and load all three PWMs ...
    		PDC3 = PDC1;					// duty cycles
    		Flags.SndSpeed = 1;			// send speed info serially
    	}
    }
    
    int main(void)
    {
    	LATE = 0x0000;
    	TRISE = 0xFFC0;		// PWMs are outputs  
    	CNEN1 = 0x00E0;		// CN5,6 and 7 enabled
    	CNPU1 = 0x00E0;		// enable internal pullups
    	IFS0bits.CNIF = 0;	// clear CNIF 
    	IEC0bits.CNIE = 1;	// enable CN interrupt
    	InitMCPWM();
    	InitADC10();
    	InitUART();
    	InitTMR3();
    	timer3avg = 0;
    	while(1)
    	{	
    		HallValue = (PORTB & 0x0038) >> 3;		
    		OVDCON = StateLoTableAntiClk[HallValue];	// Load the overide control register
    		PWMCON1 = 0x0777;					
    		Flags.RunMotor = 1;					// set flag
    		T3CONbits.TON = 1;			/	/ start tmr3
    		polecount = 1;
    	
    	}	
    	
    
    }
    	
    /*******************************************************************
    		Below is the code required to setup the ADC registers for :
    		1. 1 channel conversion (in this case 
    /AN2)
    		2. PWM trigger starts conversion
    		3. Pot is connected to CH0 and RB2
    		4. Manual Stop Sampling and start converting
    		5. Manual check of Conversion complete 
    																
    *********************************************************************/
    void InitADC10(void)
    {
    
    
    ADPCFGbits.PCFG7 = 0;          // ensure AN7 is analog  - potentiométre vr2 
    
       
     	/* set channel scanning here, auto sampling and convert, 
     	   with default read-format mode */
    	ADCON1 = 0x00E4;
    	
    	/* channel scan for CH0+, Use MUX A,  
    	   SMPI = 5 per interrupt, Vref = AVdd/AVss */
    	ADCON2 = 0x0410;		// intializ for low speed mode
    	
    	/* Set Samples and bit conversion time */
    	//                                  |       |
    	//                     (sample time)v       v(conversion time)
    	/* Interrupt period: 5 channels * 12Tad + 12Tad  (where Tad = Tcy/2 *(ADCS<5:0> + 1))" */
    	// 						5 * 24 * 1/29491200 * 1/2 * (9 + 1) = 2.0345e-5
    	// Interrupt frequency: ~49 kHz
    	ADCON3 = 0x0C09; 
            	
    	/* scan specified channels */
    	ADCSSL =0x7880;  // Scan all 5 channels
    	
    	/* channel select AN7 */
    	ADCHS = 0x0000;
    	
    	/* reset ADC interrupt flag */
    	IFS0bits.ADIF = 0;           
    
    	/* enable ADC interrupts, disable this interrupt if the DMA is enabled */	  
    	IEC0bits.ADIE = 1;       
    
    	ADCON1bits.ADON = 1;   
    
     
    }
    
    /********************************************************************
    InitMCPWM, intializes the PWM as follows:
    1. FPWM = 16000 hz
    2. Independant PWMs
    3. Control outputs using OVDCON
    4.	Set Duty Cycle with the ADC value read from pot
    5. Set ADC to be triggered by PWM special trigger
    *********************************************************************/
    
    void InitMCPWM(void)
    {
    	PTPER = FCY/FPWM - 1;
    
    	PWMCON1 = 0x0700;			// disable PWMs //11100000000
    	OVDCON = 0x0000;			// allow control using OVD
    	PDC1 = 100;					// init PWM 1, 2 and 3 to 100
    	PDC2 = 100;
    	PDC3 = 100;
    	SEVTCMP = PTPER;
    	PWMCON2 = 0x0F00;		// 16 postscale values //111100000000
    	PTCON = 0x8000;			// start PWM//1000000000000000
    	 
    }
    
    /************************************************************************
    Tmr3 is used to determine the rotor speed so it is set to count using Tcy/256
    
    *************************************************************************/
    
    
    void InitTMR3(void)
    {
    	T3CON = 0x0030;			// internal Tcy/256 clock //110000//et 48 en décimal
    
    	TMR3 = 0;
    	PR3 = 0xFFFF; //1111111111111111
    }
    
    void InitUART(void)
    {
    //---------------------------------------------------------------------
    // Initialize the UART1 for BAUD = 19,200  cf p119 de 70150a.pdf
     U1MODE = 0x8000; //1000000000000000// UARTEN activé?
     U1STA = 0x0000;
     U1BRG = ((FCY/16)/BAUD) - 1;	// set baud to 19200//BRG: baud rate generator
     IEC0bits.U1RXIE = 1;
     RXPtr = &InData[0];		// point to first char in string
     Flags.CheckRX = 0;
     Flags.SendTX = 0;
    
     U1STAbits.UTXEN = 1;           // Initiate transmission
    }
    
    //------------------------------------------------------------------------
    // SendSpeed sends the speed information on the uart at 19200 baud
    //------------------------------------------------------------------------
    void SendSpeed()
    {
    unsigned int k;
    unsigned char c;
    	
    	k = SPEEDMULT/timer3avg;
    	c = k/10000;
    	if (c > 0)
    		k = k - c*10000;
    	OutData[OFFSET] = (c + 0x30); //110000
    	c = k/1000;
    	if (c > 0)
    		k = k - c*1000;
    	OutData[OFFSET+1] = (c + 0x30);
    	c = k/100;
    	if (c > 0)
    		k = k - c*100;
    	OutData[OFFSET+2] = (c + 0x30);
    	c = k/10;
    	if (c > 0)
    		k = k - c*10;
    	OutData[OFFSET+3] = (c + 0x30);
    	OutData[OFFSET+4] = (char)(k + 0x30);
    	TXPtr = &OutData[0];
    	SendMsg();
    	Flags.SndSpeed = 0;
    }
    
    void SendMsg(void)
    {
    while (*TXPtr)
    	{
    	while (U1STAbits.UTXBF);
    	U1TXREG = *TXPtr++;// post incrementation: U1TXREG = *TXPtr puis *TXPtr=*TXPtr+1
    	}
    }
    
    
    
    
    //---------------------------------------------------------------------
    // This is a generic 1ms delay routine to give a 1mS to 65.5 Seconds delay
    // For N = 1 the delay is 1 mS, for N = 65535 the delay is 65,535 mS. 
    // Note that FCY is used in the computation.  Please make the necessary
    // Changes(PLLx4 or PLLx8 etc) to compute the right FCY as in the define
    // statement above.
    
    void DelayNmSec(unsigned int N)
    {
    unsigned int j;
    while(N--)
     	for(j=0;j < MILLISEC;j++); 
    }

  5. #4
    Persuadeur

    Re : onduleur sur un dspic30f6010a

    c'est bon, j'ai reglé mon probléme, il manquait une ligne de configuration, RD11 en l'occurence!

  6. A voir en vidéo sur Futura

Sur le même sujet


Discussions similaires

  1. Onduleur monophasé sur secteur triphasé?
    Par Big Whoop dans le forum Électronique
    Réponses: 11
    Dernier message: 07/03/2009, 02h12
  2. surproduction d'énergie eoilen sur onduleur réseau
    Par EOLIENNE31 dans le forum Technologies
    Réponses: 1
    Dernier message: 04/09/2008, 15h48
  3. Questions sur onduleur
    Par LTHOMAS dans le forum Électronique
    Réponses: 2
    Dernier message: 23/05/2008, 19h58
  4. des information sur onduleur mli monophase
    Par ajab dans le forum Électronique
    Réponses: 2
    Dernier message: 29/02/2008, 22h29
  5. Filtre pour télé 220v sur onduleur .
    Par Niktsartsoy dans le forum Électronique
    Réponses: 6
    Dernier message: 02/06/2005, 20h05
Découvrez nos comparatifs produits sur l'informatique et les technologies.