onduleur sur un dspic30f6010a

[invitea7e58a28]

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.

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 !
-----

[RISC]

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+

[invitea7e58a28]

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:

#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++); 
}

[invitea7e58a28]

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

[A voir en vidéo sur Futura]