基于TI的DRV8305的FOC控制的技术积累

TI的官方对于DRV8305电机驱动的综合例程,理解这个例程是学习这个FOC的最佳的途径

多余的话不说,理解程序如下,本程序是采用 TMS320F2807,:

/**********************************************************************************/
//版权声明
/**********************************************************************************/
//BY zhang bo QWMIDN.   By Glassine.zhang.
//www.iotman.link 天津时序电子科技有限公司
/**********************************************************************************/
//内容概述,注意,本程序不包含motor ID,即电机参数的辨识。
/**********************************************************************************/
//文件位置:solutions/instaspin_foc/src/proj_lab011.c
//无控制器模块的简化实例 (brief A Simplified Example without Controller Module)
/**********************************************************************************/
//头文件
/**********************************************************************************/
// the includes
// system includes
#include 
#include "main.h"
/**********************************************************************************/
//预定义
/**********************************************************************************/
#ifdef FLASH
#pragma CODE_SECTION(mainISR,"ramfuncs");
#endif
// Include header files used in the main function
// **************************************************************************
// the defines
// **************************************************************************
// 全局变量
CLARKE_Handle   clarkeHandle_I;  //!< the handle for the current Clarke
                                 //!< transform
CLARKE_Obj      clarke_I;        //!< the current Clarke transform object

CLARKE_Handle   clarkeHandle_V;  //!< the handle for the voltage Clarke
                                 //!< transform
CLARKE_Obj      clarke_V;        //!< the voltage Clarke transform object

EST_Handle      estHandle;       //!< the handle for the estimator

PID_Obj         pid[3];          //!< three objects for PID controllers
                                 //!< 0 - Speed, 1 - Id, 2 - Iq
PID_Handle      pidHandle[3];    //!< three handles for PID controllers
                                 //!< 0 - Speed, 1 - Id, 2 - Iq
uint16_t        pidCntSpeed;     //!< count variable to decimate the execution
                                 //!< of the speed PID controller

IPARK_Handle    iparkHandle;     //!< the handle for the inverse Park
                                 //!< transform
IPARK_Obj       ipark;           //!< the inverse Park transform object

SVGEN_Handle    svgenHandle;     //!< the handle for the space vector generator
SVGEN_Obj       svgen;           //!< the space vector generator object

#ifdef CSM_ENABLE
#pragma DATA_SECTION(halHandle,"rom_accessed_data");
#endif
HAL_Handle      halHandle;       //!< the handle for the hardware abstraction
                                 //!< layer (HAL)

HAL_PwmData_t   gPwmData = {_IQ(0.0),_IQ(0.0),_IQ(0.0)};  //!< contains the
                                 //!< pwm values for each phase.
                                 //!< -1.0 is 0%, 1.0 is 100%

HAL_AdcData_t   gAdcData;        //!< contains three current values, three
                                 //!< voltage values and one DC buss value

MATH_vec3       gOffsets_I_pu = {_IQ(0.0),_IQ(0.0),_IQ(0.0)};  //!< contains
                                 //!< the offsets for the current feedback

MATH_vec3       gOffsets_V_pu = {_IQ(0.0),_IQ(0.0),_IQ(0.0)};  //!< contains
                                 //!< the offsets for the voltage feedback

MATH_vec2       gIdq_ref_pu = {_IQ(0.0),_IQ(0.0)};  //!< contains the Id and
                                 //!< Iq references

MATH_vec2       gVdq_out_pu = {_IQ(0.0),_IQ(0.0)};  //!< contains the output
                                 //!< Vd and Vq from the current controllers

MATH_vec2       gIdq_pu = {_IQ(0.0),_IQ(0.0)};  //!< contains the Id and Iq
                                 //!< measured values

#ifdef CSM_ENABLE
#pragma DATA_SECTION(gUserParams,"rom_accessed_data");
#endif
USER_Params     gUserParams;

volatile MOTOR_Vars_t gMotorVars = MOTOR_Vars_INIT;   //!< the global motor
                                 //!< variables that are defined in main.h and
                                 //!< used for display in the debugger's watch
                                 //!< window

#ifdef FLASH
// Used for running BackGround in flash, and ISR in RAM
extern uint16_t *RamfuncsLoadStart, *RamfuncsLoadEnd, *RamfuncsRunStart;

#ifdef CSM_ENABLE
extern uint16_t *econst_start, *econst_end, *econst_ram_load;
extern uint16_t *switch_start, *switch_end, *switch_ram_load;
#endif

#endif

#ifdef DRV8301_SPI
// Watch window interface to the 8301 SPI
DRV_SPI_8301_Vars_t gDrvSpi8301Vars;
#endif

#ifdef DRV8305_SPI
// Watch window interface to the 8305 SPI
DRV_SPI_8305_Vars_t gDrvSpi8305Vars;
#endif

_iq gFlux_pu_to_Wb_sf;

_iq gFlux_pu_to_VpHz_sf;

_iq gTorque_Ls_Id_Iq_pu_to_Nm_sf;

_iq gTorque_Flux_Iq_pu_to_Nm_sf;

_iq gSpeed_krpm_to_pu_sf = _IQ((float_t)USER_MOTOR_NUM_POLE_PAIRS * 1000.0
            / (USER_IQ_FULL_SCALE_FREQ_Hz * 60.0));

_iq gSpeed_hz_to_krpm_sf = _IQ(60.0 / (float_t)USER_MOTOR_NUM_POLE_PAIRS
            / 1000.0);
/***********************************************************************************************/
//主函数
/***********************************************************************************************/
void main(void)
{
    // 如果您不熟悉motorware编码指南请参考以下文档:
    // C:/ti/motorware/motorware_1_01_00_1x/docs/motorware_coding_standards.pdf
    //仅在从闪存运行时使用,注意变量flash是由项目定义的
    #ifdef FLASH
    // Copy time critical code and Flash setup code to RAM
    // The RamfuncsLoadStart, RamfuncsLoadEnd, and RamfuncsRunStart
    // symbols are created by the linker. Refer to the linker files.
    memCopy((uint16_t *)&RamfuncsLoadStart,(uint16_t *)&RamfuncsLoadEnd,
            (uint16_t *)&RamfuncsRunStart);
    #ifdef CSM_ENABLE
	  //copy .econst to unsecure RAM
	  if(*econst_end - *econst_start)
		{
		  memCopy((uint16_t *)&econst_start,(uint16_t *)&econst_end,(uint16_t *)&econst_ram_load);
		}
	  //copy .switch ot unsecure RAM
	  if(*switch_end - *switch_start)
		{
		  memCopy((uint16_t *)&switch_start,(uint16_t *)&switch_end,(uint16_t *)&switch_ram_load);
		}
    #endif
  	#endif
	//初始化硬件抽象层(HAL在整个代码中将使用halhandle来与hal接口
	//(设置参数、获取和设置函数等)需要halhandle,因为这是所有对象的接口方式,
	//它允许与通过简单地传递一个不同的句柄来实现多个对象。使用本文档解释了句柄:
    // C:/ti/motorware/motorware_1_01_00_1x/docs/motorware_coding_standards.pdf
    halHandle = HAL_init(&hal,sizeof(hal));
    // 检查用户参数错误。
    USER_checkForErrors(&gUserParams);
    // 在全局变量中存储用户参数错误。
    gMotorVars.UserErrorCode = USER_getErrorCode(&gUserParams);
    // 如果存在用户参数错误,不允许运行, 如果有错误,那就在这里面一直循环。
    if(gMotorVars.UserErrorCode != USER_ErrorCode_NoError)
    {
        for(;;)
        {
            gMotorVars.Flag_enableSys = false;
        }
    }
    // 初始化Clarke模块
    // Clarke handle initialization for current signals
    clarkeHandle_I = CLARKE_init(&clarke_I,sizeof(clarke_I));
    // Clarke handle initialization for voltage signals
    clarkeHandle_V = CLARKE_init(&clarke_V,sizeof(clarke_V));
    // 初始化估计器 initialize the estimator
    estHandle = EST_init((void *)USER_EST_HANDLE_ADDRESS,0x200);
    // 初始化用户参数
    // 这个函数初始化在user.h中的所有gUserParams结构体的用户参数, gUserParams的这些
    //参数将被用在HAL层去配置MCU的外围,例如PWM,ADC,中断等等其他。
    USER_setParams(&gUserParams);
    //设置这个硬件抽象层参数,这个函数的功能就是通过硬件抽象层去初始化所有外设
    //他用的所有参数存储在gUserParams中。
    HAL_setParams(halHandle,&gUserParams);
    /***************************************************/
    #ifdef FAST_ROM_V1p6
    {
        // These function calls are used to initialize the estimator with ROM
        // function calls. It needs the specific address where the controller
        // object is declared by the ROM code.
        CTRL_Handle ctrlHandle = CTRL_init((void *)USER_CTRL_HANDLE_ADDRESS
                            ,0x200);
        CTRL_Obj *obj = (CTRL_Obj *)ctrlHandle;
        // this sets the estimator handle (part of the controller object) to
        // the same value initialized above by the EST_init() function call.
        // This is done so the next function implemented in ROM, can
        // successfully initialize the estimator as part of the controller
        // object.
        obj->estHandle = estHandle;
        // initialize the estimator through the controller. These three
        // function calls are needed for the F2806xF/M implementation of
        // InstaSPIN.
        CTRL_setParams(ctrlHandle,&gUserParams);
        CTRL_setUserMotorParams(ctrlHandle);
        CTRL_setupEstIdleState(ctrlHandle);
    }
    #else
    {
        // initialize the estimator. These two function calls are needed for
        // the F2802xF implementation of InstaSPIN using the estimator handle
        // initialized by EST_init(), these two function calls configure the
        // estimator, and they set the estimator in a proper state prior to
        // spinning a motor.
        EST_setEstParams(estHandle,&gUserParams);
        EST_setupEstIdleState(estHandle);
    }
    #endif
    /***************************************************/
    // disable Rs recalculation
    // **NOTE: changing the input parameter from 'false' to 'true' will cause
    // **      run time issues. Lab11 does not support Rs Online function
    //
    EST_setFlag_enableRsRecalc(estHandle,false);
    // set the number of current sensors
    setupClarke_I(clarkeHandle_I,USER_NUM_CURRENT_SENSORS);
    // set the number of voltage sensors
    setupClarke_V(clarkeHandle_V,USER_NUM_VOLTAGE_SENSORS);
    // set the pre-determined current and voltage feeback offset values
    gOffsets_I_pu.value[0] = _IQ(I_A_offset);
    gOffsets_I_pu.value[1] = _IQ(I_B_offset);
    gOffsets_I_pu.value[2] = _IQ(I_C_offset);
    gOffsets_V_pu.value[0] = _IQ(V_A_offset);
    gOffsets_V_pu.value[1] = _IQ(V_B_offset);
    gOffsets_V_pu.value[2] = _IQ(V_C_offset);
    // initialize the PID controllers
    {
        // This equation defines the relationship between per unit current and
        // real-world current. The resulting value in per units (pu) is then
        // used to configure the controllers
        _iq maxCurrent_pu = _IQ(USER_MOTOR_MAX_CURRENT
                    / USER_IQ_FULL_SCALE_CURRENT_A);
        // This equation uses the scaled maximum voltage vector, which is
        // already in per units, hence there is no need to include the #define
        // for USER_IQ_FULL_SCALE_VOLTAGE_V
        _iq maxVoltage_pu = _IQ(USER_MAX_VS_MAG_PU * USER_VD_SF);
        float_t fullScaleCurrent = USER_IQ_FULL_SCALE_CURRENT_A;
        float_t fullScaleVoltage = USER_IQ_FULL_SCALE_VOLTAGE_V;
        float_t IsrPeriod_sec = 1.0 / USER_ISR_FREQ_Hz;
        float_t Ls_d = USER_MOTOR_Ls_d;
        float_t Ls_q = USER_MOTOR_Ls_q;
        float_t Rs = USER_MOTOR_Rs;
        // This lab assumes that motor parameters are known, and it does not
        // perform motor ID, so the R/L parameters are known and defined in
        // user.h
        float_t RoverLs_d = Rs / Ls_d;
        float_t RoverLs_q = Rs / Ls_q;
        // For the current controller, Kp = Ls*bandwidth(rad/sec)  But in order
        // to be used, it must be converted to per unit values by multiplying
        // by fullScaleCurrent and then dividing by fullScaleVoltage.  From the
        // statement below, we see that the bandwidth in rad/sec is equal to
        // 0.25/IsrPeriod_sec, which is equal to USER_ISR_FREQ_HZ/4. This means
        // that by setting Kp as described below, the bandwidth in Hz is
        // USER_ISR_FREQ_HZ/(8*pi).
        _iq Kp_Id = _IQ((0.25 * Ls_d * fullScaleCurrent) / (IsrPeriod_sec
                    * fullScaleVoltage));
        // In order to achieve pole/zero cancellation (which reduces the
        // closed-loop transfer function from a second-order system to a
        // first-order system), Ki must equal Rs/Ls.  Since the output of the
        // Ki gain stage is integrated by a DIGITAL integrator, the integrator
        // input must be scaled by 1/IsrPeriod_sec.  That's just the way
        // digital integrators work.  But, since IsrPeriod_sec is a constant,
        // we can save an additional multiplication operation by lumping this
        // term with the Ki value.
        _iq Ki_Id = _IQ(RoverLs_d * IsrPeriod_sec);
        // Now do the same thing for Kp for the q-axis current controller.
        // If the motor is not an IPM motor, Ld and Lq are the same, which
        // means that Kp_Iq = Kp_Id
        _iq Kp_Iq = _IQ((0.25 * Ls_q * fullScaleCurrent) / (IsrPeriod_sec
                    * fullScaleVoltage));
        // Do the same thing for Ki for the q-axis current controller.  If the
        // motor is not an IPM motor, Ld and Lq are the same, which means that
        // Ki_Iq = Ki_Id.
        _iq Ki_Iq = _IQ(RoverLs_q * IsrPeriod_sec);
        // There are three PI controllers; one speed controller and two current
        // controllers.  Each PI controller has two coefficients; Kp and Ki.
        // So you have a total of six coefficients that must be defined.
        // This is for the speed controller
        pidHandle[0] = PID_init(&pid[0],sizeof(pid[0]));
        // This is for the Id current controller
        pidHandle[1] = PID_init(&pid[1],sizeof(pid[1]));
        // This is for the Iq current controller
        pidHandle[2] = PID_init(&pid[2],sizeof(pid[2]));
        // The following instructions load the parameters for the speed PI
        // controller.
        PID_setGains(pidHandle[0],_IQ(1.0),_IQ(0.01),_IQ(0.0));
        // The current limit is performed by the limits placed on the speed PI
        // controller output.  In the following statement, the speed
        // controller's largest negative current is set to -maxCurrent_pu, and
        // the largest positive current is set to maxCurrent_pu.
        PID_setMinMax(pidHandle[0],-maxCurrent_pu,maxCurrent_pu);
        PID_setUi(pidHandle[0],_IQ(0.0));  // Set the initial condition value
                                           // for the integrator output to 0
        pidCntSpeed = 0;  // Set the counter for decimating the speed
                          // controller to 0
        // The following instructions load the parameters for the d-axis
        // current controller.
        // P term = Kp_Id, I term = Ki_Id, D term = 0
        PID_setGains(pidHandle[1],Kp_Id,Ki_Id,_IQ(0.0));
        // Largest negative voltage = -maxVoltage_pu, largest positive
        // voltage = maxVoltage_pu
        PID_setMinMax(pidHandle[1],-maxVoltage_pu,maxVoltage_pu);
        // Set the initial condition value for the integrator output to 0
        PID_setUi(pidHandle[1],_IQ(0.0));
        // The following instructions load the parameters for the q-axis
        // current controller.
        // P term = Kp_Iq, I term = Ki_Iq, D term = 0
        PID_setGains(pidHandle[2],Kp_Iq,Ki_Iq,_IQ(0.0));
        // The largest negative voltage = 0 and the largest positive
        // voltage = 0.  But these limits are updated every single ISR before
        // actually executing the Iq controller. The limits depend on how much
        // voltage is left over after the Id controller executes. So having an
        // initial value of 0 does not affect Iq current controller execution.
        PID_setMinMax(pidHandle[2],_IQ(0.0),_IQ(0.0));
        // Set the initial condition value for the integrator output to 0
        PID_setUi(pidHandle[2],_IQ(0.0));
    }
    // initialize the speed reference in kilo RPM where base speed is
    // USER_IQ_FULL_SCALE_FREQ_Hz.
    // Set 10 Hz electrical frequency as initial value, so the kRPM value would
    // be: 10 * 60 / motor pole pairs / 1000.
    gMotorVars.SpeedRef_krpm = _IQmpy(_IQ(10.0),gSpeed_hz_to_krpm_sf);
    // initialize the inverse Park module
    iparkHandle = IPARK_init(&ipark,sizeof(ipark));
    // initialize the space vector generator module
    svgenHandle = SVGEN_init(&svgen,sizeof(svgen));
    // setup faults
    HAL_setupFaults(halHandle);
    // initialize the interrupt vector table
    HAL_initIntVectorTable(halHandle);
    // enable the ADC interrupts
    HAL_enableAdcInts(halHandle);
    // enable global interrupts
    HAL_enableGlobalInts(halHandle);
    // enable debug interrupts
    HAL_enableDebugInt(halHandle);
    // disable the PWM
    HAL_disablePwm(halHandle);
    // compute scaling factors for flux and torque calculations
    gFlux_pu_to_Wb_sf = USER_computeFlux_pu_to_Wb_sf();
    gFlux_pu_to_VpHz_sf = USER_computeFlux_pu_to_VpHz_sf();
    gTorque_Ls_Id_Iq_pu_to_Nm_sf = USER_computeTorque_Ls_Id_Iq_pu_to_Nm_sf();
    gTorque_Flux_Iq_pu_to_Nm_sf = USER_computeTorque_Flux_Iq_pu_to_Nm_sf();
    // enable the system by default
    gMotorVars.Flag_enableSys = true;
    #ifdef DRV8301_SPI
        // turn on the DRV8301 if present
        HAL_enableDrv(halHandle);
        // initialize the DRV8301 interface
        HAL_setupDrvSpi(halHandle,&gDrvSpi8301Vars);
    #endif
    #ifdef DRV8305_SPI
        // turn on the DRV8305 if present
        HAL_enableDrv(halHandle);
        // initialize the DRV8305 interface
        HAL_setupDrvSpi(halHandle,&gDrvSpi8305Vars);
    #endif
    // 开始后台循环运行
    for(;;)
    {
        // 正在等待设置启用系统标志。Waiting for enable system flag to be set
        while(!(gMotorVars.Flag_enableSys));
        // 启用系统标志为真时循环。 loop while the enable system flag is true
        while(gMotorVars.Flag_enableSys)
        {
            //如果设置了flag_enablesys并设置了flag_run_identification,则
            //启用PWMS并设置速度参考。
            if(gMotorVars.Flag_Run_Identify)
            {
                // 更新估计状态 update estimator state
                EST_updateState(estHandle,0);
                #ifdef FAST_ROM_V1p6
                    // call this function to fix 1p6. This is only used for
                    // F2806xF/M implementation of InstaSPIN (version 1.6 of
                    // ROM), since the inductance calculation is not done
                    // correctly in ROM, so this function fixes that ROM bug.
                    softwareUpdate1p6(estHandle);
                #endif
                // 启用脉宽调制 enable the PWM
                HAL_enablePwm(halHandle);
            }
            // Flag_enableSys is set AND Flag_Run_Identify is not set
            //设置了flag_enablesys且未设置flag_run_identification
            else
            {
                // 将估计器设置为空闲 set estimator to Idle
                EST_setIdle(estHandle);
                // 失能 PWM
                HAL_disablePwm(halHandle);
                // 清除integrator输出。 clear integrator outputs
                PID_setUi(pidHandle[0],_IQ(0.0));
                PID_setUi(pidHandle[1],_IQ(0.0));
                PID_setUi(pidHandle[2],_IQ(0.0));
                // clear Id and Iq references
                gIdq_ref_pu.value[0] = _IQ(0.0);
                gIdq_ref_pu.value[1] = _IQ(0.0);
            }
            // 更新全局变量
            updateGlobalVariables(estHandle);
            // 启用/禁用强制角度 enable/disable the forced angle
            EST_setFlag_enableForceAngle(estHandle,
                    gMotorVars.Flag_enableForceAngle);
            // 设定目标速度 set target speed
            gMotorVars.SpeedRef_pu = _IQmpy(gMotorVars.SpeedRef_krpm,
                    gSpeed_krpm_to_pu_sf);
            /***************************************************/
            #ifdef DRV8301_SPI
                HAL_writeDrvData(halHandle,&gDrvSpi8301Vars);
                HAL_readDrvData(halHandle,&gDrvSpi8301Vars);
            #endif
            /***************************************************/
            #ifdef DRV8305_SPI
                HAL_writeDrvData(halHandle,&gDrvSpi8305Vars);
                HAL_readDrvData(halHandle,&gDrvSpi8305Vars);
            #endif
            /***************************************************/
        } // end of while(gFlag_enableSys) loop
        // 失能 PWM
        HAL_disablePwm(halHandle);
        gMotorVars.Flag_Run_Identify = false;
    }
}
/**********************************************************************************/
//实现电机控制的主要ISR。
//The main ISR that implements the motor control.
/**********************************************************************************/
interrupt void mainISR(void)
{
    // 声明局部变量
    _iq angle_pu = _IQ(0.0);
    _iq speed_pu = _IQ(0.0);
    _iq oneOverDcBus;
    MATH_vec2 Iab_pu;
    MATH_vec2 Vab_pu;
    MATH_vec2 phasor;
    // 确认ADC中断 acknowledge the ADC interrupt
    HAL_acqAdcInt(halHandle,ADC_IntNumber_1);
    // 转换ADC数据 convert the ADC data
    HAL_readAdcDataWithOffsets(halHandle,&gAdcData);
    // 删除偏移  remove offsets
    gAdcData.I.value[0] = gAdcData.I.value[0] - gOffsets_I_pu.value[0];
    gAdcData.I.value[1] = gAdcData.I.value[1] - gOffsets_I_pu.value[1];
    gAdcData.I.value[2] = gAdcData.I.value[2] - gOffsets_I_pu.value[2];
    gAdcData.V.value[0] = gAdcData.V.value[0] - gOffsets_V_pu.value[0];
    gAdcData.V.value[1] = gAdcData.V.value[1] - gOffsets_V_pu.value[1];
    gAdcData.V.value[2] = gAdcData.V.value[2] - gOffsets_V_pu.value[2];
    // run Clarke transform on current.  Three values are passed, two values are returned.
    //在current运行Clarke变换。传递三个值,返回两个值。
    CLARKE_run(clarkeHandle_I,&gAdcData.I,&Iab_pu);
    // run Clarke transform on voltage.  Three values are passed, two values are returned.
    //在voltage运行Clarke变换。传递三个值,返回两个值。
    CLARKE_run(clarkeHandle_V,&gAdcData.V,&Vab_pu);
    // run the estimator。The speed reference is needed so that the proper sign of the forced
    // angle is calculated. When the estimator does not do motor ID as in this lab,
    //only the sign of the speed reference is used
    //运行估计器。需要速度参考,以便计算角度。当估计器没有像这样做马达ID时,
    //只使用速度参考的符号。
    EST_run(estHandle,&Iab_pu,&Vab_pu,gAdcData.dcBus,gMotorVars.SpeedRef_pu);
    // 产生电机电角。generate the motor electrical angle
    angle_pu = EST_getAngle_pu(estHandle);
    speed_pu = EST_getFm_pu(estHandle);
    // get Idq from estimator to avoid sin and cos, and a Park transform,which saves CPU cycles
    //从估计器中获取idq以避免sin和cos以及park变换,节省CPU周期。
    EST_getIdq_pu(estHandle,&gIdq_pu);
    // 运行适当的控制器。run the appropriate controller
    if(gMotorVars.Flag_Run_Identify)
    {
        // 局部变量声明 Declaration of local variables.
        _iq refValue;         //??
        _iq fbackValue;     //??
        _iq outMax_pu;     //??
        // 适当时,运行PID速度控制器 。when appropriate, run the PID speed controller
        // 这个机制为速度环提供抽取。This mechanism provides the decimation for the speed loop.
        if(pidCntSpeed >= USER_NUM_CTRL_TICKS_PER_SPEED_TICK)
        {
            // 重置速度PID执行计数器 。Reset the Speed PID execution counter.
            pidCntSpeed = 0;
            // The next instruction executes the PI speed controller and places
            // its output in Idq_ref_pu.value[1], which is the input reference
            // value for the q-axis current controller.
            //下一条指令执行pi速度控制器并放置其输出结果在idq_ref_pu.value[1],
            //它是输入参考,q-axis电流控制器的值。
            PID_run_spd(pidHandle[0],gMotorVars.SpeedRef_pu,speed_pu,
                    &(gIdq_ref_pu.value[1]));
        }
        else
        {
            // 累加计数器。
            pidCntSpeed++;
        }
        // Get the reference value for the d-axis current controller.
        //获得d-axis电流控制器的参考值。
        refValue = gIdq_ref_pu.value[0];
        // 获取id的实际值 。Get the actual value of Id
        fbackValue = gIdq_pu.value[0];
        //The next instruction executes the PI current controller for the d axis and places its
        //output in Vdq_pu.value[0], which is the control voltage along the d-axis (Vd)。
        //下一个指令执行d axis的PI电流控制器,并将其输出置于VDQPU PU.值[0 ],
        //这是沿d-axis(VD)的控制电压。
        PID_run(pidHandle[1],refValue,fbackValue,&(gVdq_out_pu.value[0]));
        // 获取Iq参考值。
        refValue = gIdq_ref_pu.value[1];
        // 获取Iq实际值。
        fbackValue = gIdq_pu.value[1];
        // The voltage limits on the output of the q-axis current controller
        // are dynamic, and are dependent on the output voltage from the d-axis
        // current controller.  In other words, the d-axis current controller
        // gets first dibs on the available voltage, and the q-axis current
        // controller gets what's left over.  That is why the d-axis current
        // controller executes first. The next instruction calculates the
        // maximum limits for this voltage as:
        // Vq_min_max = +/- sqrt(Vbus^2 - Vd^2)
        //以上这段话自己领悟。
        outMax_pu = _IQsqrt(_IQ(USER_MAX_VS_MAG_PU * USER_MAX_VS_MAG_PU)
                - _IQmpy(gVdq_out_pu.value[0],gVdq_out_pu.value[0]));
        // Set the limits to +/- outMax_pu
        PID_setMinMax(pidHandle[2],-outMax_pu,outMax_pu);
        // The next instruction executes the PI current controller for the
        // q axis and places its output in Vdq_pu.value[1], which is the
        // control voltage vector along the q-axis (Vq)
        PID_run(pidHandle[2],refValue,fbackValue,&(gVdq_out_pu.value[1]));
        // The voltage vector is now calculated and ready to be applied to the
        // motor in the form of three PWM signals.  However, even though the
        // voltages may be supplied to the PWM module now, they won't be
        // applied to the motor until the next PWM cycle. By this point, the
        // motor will have moved away from the angle that the voltage vector
        // was calculated for, by an amount which is proportional to the
        // sampling frequency and the speed of the motor.  For steady-state
        // speeds, we can calculate this angle delay and compensate for it.
        angle_pu = angleDelayComp(speed_pu,angle_pu);
        // compute the sine and cosine phasor values which are part of the inverse
        // Park transform calculations. Once these values are computed,
        // they are copied into the IPARK module, which then uses them to
        // transform the voltages from DQ to Alpha/Beta reference frames.
        phasor.value[0] = _IQcosPU(angle_pu);
        phasor.value[1] = _IQsinPU(angle_pu);
        // set the phasor in the inverse Park transform
        IPARK_setPhasor(iparkHandle,&phasor);
        // Run the inverse Park module.  This converts the voltage vector from
        // synchronous frame values to stationary frame values.
        IPARK_run(iparkHandle,&gVdq_out_pu,&Vab_pu);
        // These 3 statements compensate for variations in the DC bus by adjusting the
        // PWM duty cycle. The goal is to achieve the same volt-second product
        // regardless of the DC bus value.  To do this, we must divide the desired voltage
        // values by the DC bus value.  Or...it is easier to multiply by 1/(DC bus value).
        oneOverDcBus = EST_getOneOverDcBus_pu(estHandle);
        Vab_pu.value[0] = _IQmpy(Vab_pu.value[0],oneOverDcBus);
        Vab_pu.value[1] = _IQmpy(Vab_pu.value[1],oneOverDcBus);
        // Now run the space vector generator (SVGEN) module.
        // There is no need to do an inverse CLARKE transform, as this is handled in the SVGEN_run function.
        //现在运行空间矢量发生器(svgen)模块。
        //不需要进行逆CLARKE变换,因为这是在svgen_run函数中处理的。
        SVGEN_run(svgenHandle,&Vab_pu,&(gPwmData.Tabc));
    }
    // 当Flag_Run_Identify为0时。gMotorVars.Flag_Run_Identify = 0
    else
    {
        // 失能 PWM
        HAL_disablePwm(halHandle);
        // 设置PWMS为50%的占空比。Set the PWMs to 50% duty cycle
        gPwmData.Tabc.value[0] = _IQ(0.0);
        gPwmData.Tabc.value[1] = _IQ(0.0);
        gPwmData.Tabc.value[2] = _IQ(0.0);
    }
    // write to the PWM compare registers, and then we are done!
    //写入脉冲宽度调制比较寄存器,然后我们就完成了!
    HAL_writePwmData(halHandle,&gPwmData);
    return;
}
/**********************************************************************************/
//角度延迟的补偿工作模块。
//The angleDelayComp function compensates for the delay introduced
//from the time when the system inputs are sampled to when the PWM
//voltages are applied to the motor windings.
//angelaycomp函数补偿从系统输入采样到将pwm电压施加到电机绕组时所引入的延迟。
/**********************************************************************************/
_iq angleDelayComp(const _iq fm_pu,const _iq angleUncomp_pu)
{
    _iq angleDelta_pu = _IQmpy(fm_pu,_IQ(USER_IQ_FULL_SCALE_FREQ_Hz
                / (USER_PWM_FREQ_kHz*1000.0)));
    _iq angleCompFactor = _IQ(1.0 + (float_t)USER_NUM_PWM_TICKS_PER_ISR_TICK
                * 0.5);
    _iq angleDeltaComp_pu = _IQmpy(angleDelta_pu,angleCompFactor);
    uint32_t angleMask = ((uint32_t)0xFFFFFFFF >> (32 - GLOBAL_Q));
    _iq angleComp_pu;
    _iq angleTmp_pu;
    // 增加角度 increment the angle
    angleTmp_pu = angleUncomp_pu + angleDeltaComp_pu;
    // 遮住环绕的角度 mask the angle for wrap around
    // 注:必须说明角度符号 note: must account for the sign of the angle
    angleComp_pu = _IQabs(angleTmp_pu) & angleMask;
    // account for sign
    if(angleTmp_pu < _IQ(0.0))
    {
        angleComp_pu = -angleComp_pu;
    }
    return(angleComp_pu);
}
/**********************************************************************************/
//本模块仅仅用在F2806xF/M的相关套件的参数设置。
//! \brief  Call this function to fix 1p6. This is only used for F2806xF/M
//! \brief  implementation of InstaSPIN (version 1.6 of ROM) since the
//! \brief  inductance calculation is not done correctly in ROM, so this
//! \brief  function fixes that ROM bug.
/**********************************************************************************/
void softwareUpdate1p6(EST_Handle handle)
{
    float_t fullScaleInductance = USER_IQ_FULL_SCALE_VOLTAGE_V
                    / (USER_IQ_FULL_SCALE_CURRENT_A
                    * USER_VOLTAGE_FILTER_POLE_rps);
    float_t Ls_coarse_max = _IQ30toF(EST_getLs_coarse_max_pu(handle));
    int_least8_t lShift = ceil(log(USER_MOTOR_Ls_d / (Ls_coarse_max
                         * fullScaleInductance)) / log(2.0));
    uint_least8_t Ls_qFmt = 30 - lShift;
    float_t L_max = fullScaleInductance * pow(2.0,lShift);
    _iq Ls_d_pu = _IQ30(USER_MOTOR_Ls_d / L_max);
    _iq Ls_q_pu = _IQ30(USER_MOTOR_Ls_q / L_max);
    // store the results
    EST_setLs_d_pu(handle,Ls_d_pu);
    EST_setLs_q_pu(handle,Ls_q_pu);
    EST_setLs_qFmt(handle,Ls_qFmt);
    return;
}
/**********************************************************************************/
//为2个或3个传感器设置Clarke变换。电流。
//param[in] handle             The clarke (CLARKE) handle
//param[in] numCurrentSensors  The number of current sensors
/**********************************************************************************/
void setupClarke_I(CLARKE_Handle handle,const uint_least8_t numCurrentSensors)
{
    _iq alpha_sf,beta_sf;
    // initialize the Clarke transform module for current
    if(numCurrentSensors == 3)
    {
        alpha_sf = _IQ(MATH_ONE_OVER_THREE);
        beta_sf = _IQ(MATH_ONE_OVER_SQRT_THREE);
    }
    else if(numCurrentSensors == 2)
    {
        alpha_sf = _IQ(1.0);
        beta_sf = _IQ(MATH_ONE_OVER_SQRT_THREE);
    }
    else
    {
        alpha_sf = _IQ(0.0);
        beta_sf = _IQ(0.0);
    }
    // set the parameters
    CLARKE_setScaleFactors(handle,alpha_sf,beta_sf);
    CLARKE_setNumSensors(handle,numCurrentSensors);
    return;
}
/**********************************************************************************/
//为2个或3个传感器设置Clarke变换。电压。
//Setup the Clarke transform for either 2 or 3 sensors.
//param[in] handle             The clarke (CLARKE) handle
//param[in] numVoltageSensors  The number of voltage sensors
/**********************************************************************************/
void setupClarke_V(CLARKE_Handle handle,const uint_least8_t numVoltageSensors)
{
    _iq alpha_sf,beta_sf;
    // initialize the Clarke transform module for voltage
    if(numVoltageSensors == 3)
    {
        alpha_sf = _IQ(MATH_ONE_OVER_THREE);
        beta_sf = _IQ(MATH_ONE_OVER_SQRT_THREE);
    }
    else
    {
        alpha_sf = _IQ(0.0);
        beta_sf = _IQ(0.0);
    }
    // In other words, the only acceptable number of voltage sensors is three.
    // set the parameters
    CLARKE_setScaleFactors(handle,alpha_sf,beta_sf);
    CLARKE_setNumSensors(handle,numVoltageSensors);
    return;
}
/**********************************************************************************/
//Update the global variables (gMotorVars).更新全局变量(gmotorvars)。
//param[in] handle  The estimator (EST) handle。param[in]handle估计量(est)handle
/**********************************************************************************/
void updateGlobalVariables(EST_Handle handle)
{
    // 得到速度估计值,get the speed estimate
    gMotorVars.Speed_krpm = EST_getSpeed_krpm(handle);
    /***************************************************/
    // 得到扭矩估计值 get the torque estimate
    {
        _iq Flux_pu = EST_getFlux_pu(handle);
        _iq Id_pu = PID_getFbackValue(pidHandle[1]);
        _iq Iq_pu = PID_getFbackValue(pidHandle[2]);
        _iq Ld_minus_Lq_pu = _IQ30toIQ(EST_getLs_d_pu(handle)
                    - EST_getLs_q_pu(handle));
        // 电抗转矩 Reactance Torque
        _iq Torque_Flux_Iq_Nm = _IQmpy(_IQmpy(Flux_pu,Iq_pu),
                    gTorque_Flux_Iq_pu_to_Nm_sf);
        // 磁阻转矩 Reluctance Torque
        _iq Torque_Ls_Id_Iq_Nm = _IQmpy(_IQmpy(_IQmpy(Ld_minus_Lq_pu,Id_pu),
                    Iq_pu),gTorque_Ls_Id_Iq_pu_to_Nm_sf);
        // 总转矩是电抗转矩和磁阻转矩之和 Total torque is sum of reactance torque and reluctance torque
        _iq Torque_Nm = Torque_Flux_Iq_Nm + Torque_Ls_Id_Iq_Nm;
        gMotorVars.Torque_Nm = Torque_Nm;
    }
    /***************************************************/
    // 得到磁化电流 get the magnetizing current
    gMotorVars.MagnCurr_A = EST_getIdRated(handle);
    // 得到转子电阻 get the rotor resistance
    gMotorVars.Rr_Ohm = EST_getRr_Ohm(handle);
    // 得到定子电阻 get the stator resistance
    gMotorVars.Rs_Ohm = EST_getRs_Ohm(handle);
    // 直接坐标方向的定子电感 get the stator inductance in the direct coordinate direction
    gMotorVars.Lsd_H = EST_getLs_d_H(handle);
    // 求出正交坐标方向上的定子电感 get the stator inductance in the quadrature coordinate direction
    gMotorVars.Lsq_H = EST_getLs_q_H(handle);
    // 求出浮点数的磁通量,单位为V/Hz get the flux in V/Hz in floating point
    gMotorVars.Flux_VpHz = EST_getFlux_VpHz(handle);
    // 得到固定点wb中的通量 get the flux in Wb in fixed point
    gMotorVars.Flux_Wb = _IQmpy(EST_getFlux_pu(handle),gFlux_pu_to_Wb_sf);
    // 得到估计状态get the estimator state
    gMotorVars.EstState = EST_getState(handle);
    // 获取直流母线电压 Get the DC buss voltage
    gMotorVars.VdcBus_kV = _IQmpy(gAdcData.dcBus,
            _IQ(USER_IQ_FULL_SCALE_VOLTAGE_V / 1000.0));
    // 每单位读取vd和vq矢量 read Vd and Vq vectors per units
    gMotorVars.Vd = gVdq_out_pu.value[0];
    gMotorVars.Vq = gVdq_out_pu.value[1];
    // 以单位计算矢量vs:(vs=sqrt(vd^2+vq^2)) calculate vector Vs in per units: (Vs = sqrt(Vd^2 + Vq^2))
    gMotorVars.Vs = _IQsqrt(_IQmpy(gMotorVars.Vd,gMotorVars.Vd)
            + _IQmpy(gMotorVars.Vq,gMotorVars.Vq));
    // 以安培为单位读取id和iq矢量 read Id and Iq vectors in amps
    gMotorVars.Id_A = _IQmpy(gIdq_pu.value[0],
            _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
    gMotorVars.Iq_A = _IQmpy(gIdq_pu.value[1],
            _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
    // 计算矢量单位为安培:(Is_a=sqrt(id_a^2+iq_a^2)) calculate vector Is in amps:  (Is_A = sqrt(Id_A^2 + Iq_A^2))
    gMotorVars.Is_A = _IQsqrt(_IQmpy(gMotorVars.Id_A,gMotorVars.Id_A)
            + _IQmpy(gMotorVars.Iq_A,gMotorVars.Iq_A));
    return;
}

 

你可能感兴趣的:(DSP,C)