main_space_vector_pwm.c

DSP实现三相异步电机矢量控制的C语言算法

/**
* @file main.c
*
* Copyright (c) 2005 Atmel.
*
* @brief This module provide services to show a simple program for  AT90PWM3 Only
* @version 1.0 (CVS revision : $Revision: 1.4 $)
* @date $Date: 2005/12/21 12:53:47 $
* @author $Author: raubree $
*****************************************************************************/

#include "config.h"
#include "lib_mcu/compiler.h"
#include "lib_mcu/mcu.h"
#include "inavr.h"
#include <stdio.h>


#pragma vector = TIMER0_COMPA_vect
__interrupt void Tech(void);

#pragma vector = ADC_vect
__interrupt void Read_Measure(void);

#define	MAX_PWM		2666
// 64MHz (PLL frequency) / 2666 / 2 = 12 kHz (PWM frequency)

#define MAX_THETA	80 // one sixth of the circle
#define K_scal          16 // used for the angle integrator


U8         Flag_IT_timer0=0, Flag_IT_ADC=0 ;
U16        Softcounter = 0 ;

S16           Omega_meas;
S16           Omega_ref = 100;
S16           Command = 0;

U16        amplitude , OmegaTe = 64 ;
U8         direction = 0 ;
U16        PWM0, PWM1, PWM2, DeadTime = 254 ;   // 254 => Dead time = 4 祍


void   init(void);
void   ADC_Init(void);
void   ADC_start_conv(void);
void   DAC_Init(void);
void   PSC_Init(unsigned int ot0,  unsigned int ot1);
void   PSC0_Load (unsigned int dt0, unsigned int dt1);
void   PSC1_Load (unsigned int dt0, unsigned int dt1);
void   PSC2_Load (unsigned int dt0, unsigned int dt1);
S16    mc_control_speed_16b(S16 speed_ref , S16 speed_measure);
U16 controlVF(U16 Omega);
void SVPWM(U16 amp, U16 Omega);
S16    read_acquisition() ;

void main(void)
{
  init();
//  DAC_Init(); /* do not init DAC if you want to use PC7 as /IO */
  ADC_Init();

  PSC_Init(0x00, MAX_PWM);

  while(1)
  {
      if (Flag_IT_timer0)
       {

        ADC_start_conv();
        Flag_IT_timer0=0;
        // generates speed reference steps in the software
        Softcounter += 1 ;
        if (Softcounter ==  2500) {
          Omega_ref = -100 ;
         } //-128; }
        if (Softcounter == 5000)
         {
           Omega_ref= -50 ;
         }
        if (Softcounter == 7500)
         {
           Omega_ref= 50 ;
         }
        if (Softcounter == 10000)
         {
           Omega_ref= 100 ;
           Softcounter = 0 ;
         }


       }
      if (Flag_IT_ADC)
       {

        // get the measured speed from the ADC
         Omega_meas = read_acquisition();

         // compute the stator frequency (PI controller)
//         Command = mc_control_speed_16b(Omega_ref,Omega_meas); // for use in closed loop
         Command = Omega_ref ; // for use in open loop


         // direction management : extract sign and absolute value
         if (Command > (S16)(0) ) {
           direction = 0 ;
           OmegaTe = Command;
         }
          else {
            direction = 1 ;
            OmegaTe = (~Command) + 1;
         }


         // ------------------------ V/f law --------------------------
         amplitude = controlVF(OmegaTe);

         // ------------ - space vector PWN algorithm -----------------
         SVPWM(amplitude, OmegaTe) ;

         // -------- load the PSCs with the new duty cycles -----------
         PSC0_Load (PWM0, PWM0+DeadTime);
         if (direction==0) {
           PSC1_Load (PWM1, PWM1+DeadTime);
           PSC2_Load (PWM2, PWM2+DeadTime);
         }
          else {
            PSC1_Load (PWM2, PWM2+DeadTime);
            PSC2_Load (PWM1, PWM1+DeadTime);
         }

    	Flag_IT_ADC=0;
      }   /* end of Flag_IT_ADC */
    }     /* end of while(1) */
}         /* end of main */

// interrupt vector for the sampling period (Ts=1 ms)
__interrupt void Tech(void) {
    Flag_IT_timer0=1;
}

// interrupt vector for the ADC (end of conversion)
__interrupt void Read_Measure(void) {
    Flag_IT_ADC=1;
}