
#include <math.h>
#include <stdio.h>
//#include <stdlib.h>
#include <strings.h>
#include "DSP281x_Device.h"     // DSP281x Headerfile Include File
#include "DSP281x_Examples.h"   // DSP281x Examples Include File
#include "IQmathLib.h"
#include "cur_loop.h"
#include "dmctype.h"
#include "parameter.h"
#include "clarke.h"
#include "Rtest.h"
#include "DSP281x_Adc.h"
#include "f281xpwm.h"
#include "svgen_dq.h"
#include "Flash281x_API_Library.h"
#include "flashdll.h"
#include "lib_RotorPosition.h"
//#include "ad_sample.h"
//#include "lib_time_test.h"
//#include "dlog4ch.h"

// Prototype statements for functions found within this file.
interrupt void adc_isr(void);
interrupt void timer_isr(void);
interrupt void eva_timer1_isr(void);
interrupt void eva_imer1Ufint_isr(void);
interrupt void eva_cmp1int_isr(void);
interrupt void eva_cmp2int_isr(void);
interrupt void eva_cmp3int_isr(void);

void Reset_f(void);
void Init_Gpio(void);
void Delay_boot();////开机延时
Uint16  pwm_enableflag = 0;
// Global variables used in this example:
Uint16 LoopCount;
Uint16 ConversionCount;
Uint32  EvaTimer1InterruptCount;

Uint16 count_pwn;//pwm 打脉冲计时
Uint16 count_adinnt = 0;
Uint16 count_intu;
Uint16 count_cmp1int = 0;
Uint16 count_cmp2int = 0;
Uint16 count_cmp3int = 0;
Uint16 count_intperiodic = 0;
Uint16 count_intuderflow = 0;
Uint16 count_adtest = 0;
Uint16 adc_flag = 0;
Uint16 fan_flag = 1;
Uint16 R_buffer_flag = 0;
float32 I_range = 50;//33.3;//电流满量程
float32 I_rated = 30;
float32 VDC_rated = 537.0;////额定总线电压
float32 vdc_80 ;//总线电压80%
float32 div_I_range;
float32 D_per_unit;
float32 Q_per_unit;
_iq     iq_div_I_range;
//////////////////////////-----------------------------------flash
Uint16 data_i_re;
FLASHWR flashwr1 = FLASHWR_DEFAULTS;
//////////////////////////////------------------------------------------电感测试
//Uint16 Ld_test_startflag,Ld_test_startendflag,Lq_test_startflag,Lq_test_startendflag;///第一次打脉冲示波器收不到
//Uint16 pulse_plus_flagstart,pulse_plus_flagend;//正脉冲开始结束标志
//Uint16 pulse_plus_flagstart_q,pulse_plus_flagend_q;//正脉冲开始结束标志
//Uint16 pulse_minus_flagstart,pulse_minus_flagend,pulse_minus_pwmout_flag;//负脉冲开始结束标志
//Uint16 pulse_minus_flagstart_q,pulse_minus_flagend_q,pulse_minus_pwmout_flag_q;//负脉冲开始结束标志
//Uint16 pulse_plus_count,pulse_minus_count,pulse_plus_count_q,pulse_minus_count_q;//正负脉冲计数
//Uint16 pulse_plus_data,pulse_minus_data;//正负脉冲采样数据
//Uint16 pulse_plus_data_q,pulse_minus_data_q;//正负脉冲采样数据
//Uint16 pulse_init_startflag,pulse_init_endflag;//脉冲初始标志
//Uint16 ad_data[16];
//Uint16 adc_wait_count;//ad转换等待计数
////Uint16 pwm_out_flag,pwm_out_flag_q;//pwm out flag
//Uint16 adc_rel_data,adc_rel_data_q;//adc 比较零点,正负脉冲比较得出
//Uint16 adc_zero_test,adc_zero_test_q,adc_zero_test_dc;//ADC 测试零点，输出0电压检测零点
//Uint16 adc_dc_data, pulse_count_dq;
//Uint16 i_d = 0;
//Uint16 i_q = 0;
//Uint16 L_meas_flag,L_meas_startflag,L_meas_endflag;///电感测试标志
//Uint16 L_meas_flag_q,L_meas_startflag_q,L_meas_endflag_q;///电感测试标志
//float32 Lmeas[5],I_data[5],I_data_q[5],U_data[5];
//float32 I_data_avg,I_data_avg_q,U_data_avg;
//float32 I_para_perdigital,I_para_perdigital_small;//每个数字量代表的电流
//float32 L_measure,L_measure_q;
//float32 I_measure,I_measure_q,I_u,I_v;
//float32 T_para_perdigital;///每个脉冲时间
//Uint16  L_meas_count,L_meas_count_q;
//Uint16  L_meas_p_count_all;//脉冲总数
//Uint16  L_meas_continue_p_count;///持续脉冲个数
//float32  U_line;//线电压   输入
//float32  L_I_rated;//额定电流  输入
//float32  I_per_pulse;
//float32  L_test_I_time,L_test_I_timecount;///电流持续时间
//float32  L_test_idout,L_test_iqout;
//float32  v_vdc, U_vdc_per;
//float32  idtest,iqtest;
//float32  U_vdc,U_d,U_q;
//Uint16   AD_status;//ad status 0 正常  100 错误
//Uint16   L_test_flag,L_test_status;
//Uint16   adsample_status;//ad 采样状态
//Uint16   L_test_pwmflag = 0;
//Uint16   L_readyflag;
//
//Uint16   L_location_count = 0;
//Uint16   L_test_fore,L_test_formal,L_test_fore_end,L_test_formal_end,L_test_all_status;
//Uint16   L_loc_startflag, L_loc_endflag,L_loc_continueflag,L_loc_pauseflag,L_loc_pwmoutflag,L_loc_status;
//Uint16   L_loc_con_count,L_loc_pause_count,L_loc_count;
//float32  L_d_formal,L_q_formal;
//float32  L_static_ldata[36][2];
void 	 L_test(void);
void 	 L_test_init(void);
void     L_location(Uint16 dq);////定位
void     L_test_all(void);
float32  L_static_sort(void);////得出测试电感最小相对的角度
///////////////////////////////////////////////

//Uint16  pwm_out_flag = 0;
//Uint16  pwm_out_flag_q = 0;
//////////////////////////----------------------------------------------DQ to pwm 20181028
void DQout(float32 Dperunit,float32 Qperunit);
void Pwmout(Uint16 enableflag);/////pwm 输出与关断

//
#pragma CODE_SECTION(read_addata,"ramfuncs");
#pragma CODE_SECTION(read_addata2,"ramfuncs");
#pragma CODE_SECTION(InitAdc_1st,"ramfuncs");
#pragma CODE_SECTION(InitAdc_2nd,"ramfuncs");
#pragma CODE_SECTION(ad_intt_init,"ramfuncs");
#pragma CODE_SECTION(AD_test,"ramfuncs");
#pragma CODE_SECTION(I_adsample_cal,"ramfuncs");
#pragma CODE_SECTION(eva_timer1_isr,"ramfuncs");
#pragma CODE_SECTION(eva_imer1Ufint_isr,"ramfuncs");
#pragma CODE_SECTION(eva_cmp1int_isr,"ramfuncs");
#pragma CODE_SECTION(AD_compU,"ramfuncs");
#pragma CODE_SECTION(AD_compV,"ramfuncs");
#pragma CODE_SECTION(AD_compW,"ramfuncs");
#pragma CODE_SECTION(I_adsample_cal_comp,"ramfuncs");
//#pragma CODE_SECTION(iq_vol_v_query,"ramfuncs");
volatile Uint16 main_flag = 1;
//////////////////////////////--------------------------------------AD  test
Uint16   ad_run_flag,   ad_zero_flag;
float32   ad_ref_u_last,ad_ref_uu_last,ad_ref_v_last,ad_ref_vv_last;
float32  ad_ref_u_now,ad_ref_uu_now,ad_ref_v_now,ad_ref_vv_now;
Uint16   ad_ref_u_final,ad_ref_uu_final,ad_ref_v_final,ad_ref_vv_final;
_iq19    iq_ad_ref_u_final,iq_ad_ref_uu_final,iq_ad_ref_v_final,iq_ad_ref_vv_final;
float32  ad_filter_para;
Uint16   ad_data_u,ad_data_uu,ad_data_v,ad_data_vv,ad_data_resv1,ad_data_resv2,ad_data_resv3,ad_data_vdc;
_iq19    iq_ad_data_u,iq_ad_data_uu,iq_ad_data_v,iq_ad_data_vv;
_iq17    iq19_div_4;
float32  I_f_u,I_f_v;///AD输出U相V相电流
Uint16   U_VDC;////
float32  P_i_resolution,P_i_resolution_small;///电流分辨率
float32  P_vdc_resolution;///总线电压分辨率
float32  ad_I_range;
void AD_test(void);
void AD_compU(void);
void AD_compV(void);
void AD_compW(void);
void read_addata(void);
void read_addata2(void);
void AD_adjust_cal(void);///ad 补偿系数计算
void I_adsample_cal(void);///电流满（大）量程计算
void AD_init(void);
void InitAdc_1st(void);
void InitAdc_2nd(void);
void I_adsample_cal_comp(void);///电流满（大）量程计算
float32 P_i_u_adjust,P_i_v_adjust;//////电流校正系数
Uint16  Flag_i_u_adjust,Flag_i_v_adjust;//////ad校正标识
float32 AD_adjust_cal_u,AD_adjust_cal_v;
Uint16  AD_adjcal_startflag,AD_adjcal_endflag;
Uint32 addata0,addata1,addata2,addata3,addata4,addata5,addata6,addata7,addata8,addata9,addata10,addata11,addata12,addata13,addata14,addata15;
Uint32 addata20,addata21,addata22,addata23,addata24,addata25,addata26,addata27;
_iq19 iq_u_now,iq_u_last,iq_uu_now,iq_uu_last,iq_v_now,iq_v_last,iq_vv_now,iq_vv_last;
_iq19 iq_last_p,iq_new_p;
_iq19 iq_I_f_u,iq_I_f_v,iq_P_i_resolution,iq_P_i_resolution_minus,iq_P_i_resolution_small,iq_P_i_u_adjust,iq_P_i_v_adjust;
_iq19 iq_U_VDC,iq_VDC,iq_P_vdc_resolution;
_iq19 iq_u_nnn,iq_u_lll;
int32 P_inttoiq,P_inttoiq_17,P_inttoiq_13,P_inttoiq_15;/////整形直接变为浮点的IQ值系数
Uint16 upper_limit,lower_limit;//////大小通道切换边界
_iq19  iq_upper_limit,iq_lower_limit;//////大小通道切换边界
_iq19 iq_I_f_u_comp,iq_I_f_v_comp,iq_I_f_w_comp,iq_I_f_wu_comp,iq_I_f_wv_comp;
_iq19 iq_ad_ref_u_final_comp,iq_ad_ref_uu_final_comp,iq_ad_ref_v_final_comp,iq_ad_ref_vv_final_comp;
_iq19 iq_u_now_comp,iq_u_last_comp,iq_uu_now_comp,iq_uu_last_comp,iq_v_now_comp,iq_v_last_comp,iq_vv_now_comp,iq_vv_last_comp;
_iq19 iq_ad_data_u_comp,iq_ad_data_v_comp,iq_ad_data_w_comp,iq_ad_data_wu_comp,iq_ad_data_wv_comp;
/////////////////////////////------------------------------------------------电流环
CLARKE clarke1 = CLARKE_DEFAULTS;
CURDQ  cur_DQ1 = CURDQ_DEFAULTS;
//SVGENDQ svgen_dq1 = SVGENDQ_DEFAULTS;
//PWMGEN pwmgen_pwm1 = PWMGEN_DEFAULTS;
float32 ID_sample = 0;//D采样
float32 IQ_sample = 0;///Q采样
float32 ID_set,IQ_set;///DQ设定电流
_iq19   iq_ID_set,iq_IQ_set;///DQ设定电流
Uint16  cur_test_flag;
float32 cur_i_set;
void cur_test(void);
void cur_test_init(void);
Uint16 cur_f1 = 24999;//3k
Uint16 cur_f2 = 12499;//6k

///////////////////-------------------------------------------------------电阻测试
void R_test(void);
void Rtest_curr(void);
void Rtest_init(void);

//Uint16  R_test_start,R_test_end,R_test_startflag,R_test_endflag;
//Uint16  R_test_startflag_d,R_test_endflag_d,R_test_startflag_q,R_test_endflag_q,\
//        R_test_halfstartflag_d,R_test_halfendflag_d,R_test_halfstartflag_q,R_test_halfendflag_q;
//float32 R_test_I_time;///电流持续时间
//Uint16  R_test_I_timecount;//电流持续时间计数
//Uint16  M_flag;///电机类型标志，
//float32 R_test_i,R_test_id,R_test_id_half,R_test_iq,R_test_iq_half,R_test_Ud,R_test_Ud_half,R_test_Uq,R_test_Uq_half;///给定电流
//float32 R_d,R_q;///d轴电阻，q轴电阻
//Uint16  R_test_I_outflag;//电流输出标志
//float32 max = 0;
//float32 qmax = 0;
//float32  adsample[10];
//float32  I_d_out,I_q_out;
//float32  R_test_vdc;
//Uint16   R_test_vdcdata;
//Uint16   i_r;
//float32  Rd_data[5],Rq_data[5];
//float32  R_vdc_test,R_vdc_test_now,R_vdc_test_last;
//float32  R_test_d_para,R_test_d_para_now,R_test_d_para_last;
//float32  R_test_q_para,R_test_q_para_now,R_test_q_para_last;
//float32  R_test_i,R_test_i_now,R_test_i_last;
////float32  R_id[200],R_id_lb[200];
////Uint16   R_vdc[200],R_vdc_lb[200];
//Uint16   R_f1_flag,R_f2_flag;///////频率标志
//Uint16   R_test_f1_endflag;/////////设定单倍频率测试结束标志
//Uint16   R_f_editflag;////////频率修改标志
//float32  R_u_f1,R_u_f2,R_u_half_f1,R_u_half_f2,R_u_delta,R_u_delta_half,R_i,R_i_half;/////f1和f2下的电压，一半电压，死区压降，测试电流
//Uint16   count_test;
//Uint16   R_test_f_change_flag;
//_iq19      R_D_cur_return,R_Q_cur_return;
//_iq19      iq_ID_set,iq_IQ_set;
//_iq19      iq_R_vdc_test,iq_R_vdc_test_now,iq_R_vdc_test_last;
//_iq19      iq_R_test_d_para,iq_R_test_d_para_now,iq_R_test_d_para_last;
//_iq19      iq_R_test_q_para,iq_R_test_q_para_now,iq_R_test_q_para_last;
//_iq19      iq_R_test_i,iq_R_test_i_now,iq_R_test_i_last;
//float32    R_vdc,R_vdc_half;
/////////////--------------------------------------------------------电压补偿  voltage compensator
float32 VC_v1,VC_vv11,VC_vv12,VC_v2,VC_vv21,VC_vv22;
float32 VC_R,VC_vu,VC_vv,VC_vw,VC_vo,VC_VD,VC_VQ;///电阻，uvwo电压
float32 VC_ID,VC_IQ;///指定DQ电流
float32 VC_f1,VC_f2;///频率
float32 VC_Iu_set,VC_I_max;///给定U相电流
#define  VC_array_length 96
#define  VC_I_set_length 15//50//

//float32 VC_V_delta[VC_I_set_length];
float32 VC_V_vf2[VC_I_set_length];///
float32 VC_V_delta[VC_I_set_length][2];
float32 VC_I_set[VC_I_set_length],VC_V_v11[VC_I_set_length],VC_V_v12[VC_I_set_length],VC_V_vf1[VC_I_set_length];
float32 VC_vdc_f1[VC_I_set_length],VC_vdc_f2[VC_I_set_length];
float32 VC_I_set_small[VC_array_length];
//float32 VC_V_big[VC_array_length],VC_V_small[VC_array_length];//
float32 VC_V_big[VC_array_length][2],VC_V_small[VC_array_length];//
_iq19   iq_VC_V_big[VC_array_length][2],iq_VC_V_small[VC_array_length];//
//float32 VC_Iu[VC_array_length],VC_Iv[VC_array_length],VC_Iw[VC_array_length],VC_Vv_V[VC_array_length],VC_Vw_V[VC_array_length],\
//        VC_Cur_Vu[VC_array_length],VC_Cur_Vv[VC_array_length];
float32 VC_unification_p;///归一化系数
float32 VC_unification_cal;///归一化系数 分母
Uint16  VC_I_set_flag;////大小电流标志，1 大电流，2小电流
Uint16  VC_I_count;///电流给定计数
Uint16  VC_cal_num,VC_count_intt;///计算计数，中断计数
Uint16  VC_start,VC_end,VC_start_flag,VC_end_flag,VC_interpn_flag;
float32 VC_udc_now,VC_udc_last,VC_D_p,VC_D_p_now,VC_D_p_last,VC_Q_p,VC_Q_p_now,VC_Q_p_last,VC_iu_now,VC_iu_last,VC_iv_now;///udc dq系数滤波
Uint16  VC_f1_flag,VC_f2_flag;////频率1和频率2标志
float32 VC_I_rated;///额定电流
float32 VC_vdc_perunit_p;////直流电压归一化参数
float32 VC_vdc_rated;////额定直流母线电压
float32 VC_Iv_set;////
float32 VC_V_u_delta,VC_V_v_delta,VC_V_w_delta,VC_Iw_now;//////uvw相补偿电压，w相电流
float32 VC_per;///大表格 电流分辨率
Uint16  VC_f1_change_flag,VC_f2_change_flag;
Uint16  VC_test_count;
Uint16  VC_DQ_wait_flag;
Uint16  VC_flash_wr_flag,VC_flash_rd_flag;///写入flash标志
void    vol_compensator(void);
void    vc_assist(void);
void    vol_compensator_currloop(void);
void    vol_compensator_filter(void);////滤波
void    vol_interpn(void);///插值
void    vol_wr_flash(void);///写入flash
void    vol_rd_flash(void);///从flash读出
void    vol_init(void);

float32 vol_query(float32 a);//查询大表格电压补偿
float32 vol_query_small(float32 a);//查询小表格电压补偿
float32 vol_v_query(float32 a);///查询补偿电压
_iq19   iq_vol_v_query(_iq19 a);///查询大电流补偿电压

_iq19   iq_VC_udc_now,iq_VC_udc_last,iq_VC_D_p,iq_VC_D_p_now,iq_VC_D_p_last,iq_VC_Q_p,iq_VC_Q_p_now,iq_VC_Q_p_last,iq_VC_iu_now,iq_VC_iu_last;///udc dq系数滤波
_iq19   iq_VC_D_return,iq_VC_Q_return;
_iq19   iq_VC_VD,iq_VC_VQ;
_iq19   iq_VC_R,iq_1414,iq_707,iq_1225,iq_408,iq_8165,iq_05,iq_333,iq_667,iq_1732;
_iq24   iq24_1225,iq24_1707;
_iq19   iq_VC_vdc_rated;
_iq19   iq_93,iq_07,iq_965,iq_035,iq_8333,iq_1667,iq_08333,iq_91667;
_iq19   iq_VC_D_p1_now,iq_VC_D_p1_last,iq_VC_D_p2_now,iq_VC_D_p2_last,iq_VC_D_p3_now,iq_VC_D_p3_last,\
        iq_VC_D_p4_now,iq_VC_D_p4_last,iq_VC_D_p5_now,iq_VC_D_p5_last,iq_VC_D_p6_now,iq_VC_D_p6_last;
_iq19   iq_VC_Q_p1_now,iq_VC_Q_p1_last,iq_VC_Q_p2_now,iq_VC_Q_p2_last,iq_VC_Q_p3_now,iq_VC_Q_p3_last,\
        iq_VC_Q_p4_now,iq_VC_Q_p4_last,iq_VC_Q_p5_now,iq_VC_Q_p5_last,iq_VC_Q_p6_now,iq_VC_Q_p6_last;
_iq19   iq_VC_UU_p1_now,iq_VC_UU_p1_last,iq_VC_UU_p2_now,iq_VC_UU_p2_last,iq_VC_UU_p3_now,iq_VC_UU_p3_last,\
        iq_VC_UU_p4_now,iq_VC_UU_p4_last;
_iq19   iq_VC_per_mpy,iq_VC_per_small_mpy,iq_VC_per_small;
_iq19   iq_VC_unification_p;///归一化系数 iq19
_iq19   iq_VC_unification_cal;///归一化系数 分母 iq19
_iq19   iq_VC_V_u_delta,iq_VC_V_v_delta,iq_VC_V_w_delta,iq_VC_Iw_now;
_iq19   iq_01,iq_0101,iq_VC_I_rated,iq_VC_I_rated_01;////额定电流的10%，判断大小电流通道的条件
float32 VC_I_rated_01;/////额定电流的10%，判断大小电流通道的条件
Uint16  v_num = 0;
float32 v_f_num = 0;
float32 v_f_part = 0;
float32 v_return = 0;
_iq19   v_f_part_iq;
_iq19   iq_vc_return;
_iq19   iq_vc_return_test,iq_vc_in_test;
float32 vc_query_in,vc_query_in_abs;
_iq19   iq_vc_query_in,iq_vc_query_in_abs;
        ////////////////////////////////////////////////////////电压补偿验证
Uint16  VC_verify_flag;
float32 VC_verify_iu,VC_verify_iv;
float32 VC_verify_iu_error,VC_verify_iv_error;
void    VC_verify(void);///////电压补偿验证
float32 ud,uq,uu,uv,vcu,vcv,vcw,vco,vcuo,vcvo;
_iq19   iq_ud,iq_uq,iq_uu,iq_uv,iq_vcu,iq_vcv,iq_I_w,iq_vcw,iq_vco,iq_vcuo,iq_vcvo;
float32 uu_vc,uv_vc;
_iq19   iq_uu_vc,iq_uv_vc;
//_iq19     VC_cur_1[VC_array_length],VC_cur_2[VC_array_length],VC_cur_3[VC_array_length],VC_cur_4[VC_array_length];
//_iq19     VC_vc_5[VC_array_length],VC_vc_6[VC_array_length];
//float32 VC_error_u[VC_array_length],VC_error_v[VC_array_length];

#define  pi 3.14159265
Uint16   sin_count,sin_out_flag,sin_data_flag,sin_data_startflag;
float32  omg,omg_delt,omg_per,VC_motor_f,pi_2;
#define  sin_test_count 100
Uint16   sin_vc_flag,sin_data_num,sin_vc_symbol_flag,sin_vc_query_flag,sin_vc_dq_filter_flag,sin_dq_filter_flag;
_iq19    sin_test[sin_test_count];
float32    D_per_unit_vc, Q_per_unit_vc;
_iq19   cur_t_vd0,cur_t_vq0,cur_t_v1,cur_t_vd01,cur_t_vq01,cur_u_vd0,cur_u_vq0,cur_u_v1,cur_u_vd01,cur_u_vq01;
_iq19   iq_iu_last_t,iq_iv_last_t,iq_iu_delt,iq_iv_delt,iq_iu_last_uf,iq_iv_last_uf;
_iq19   iq_vc_u_didt,iq_vc_v_didt;
_iq19   iq_t_div,iq_ldq;
float32 t_div;////周期分之一
Uint16  vc_ver_didt_flag = 0;/////增加didt
Uint16  vc_ver_filter_flag = 0;/////电流环是否
Uint16  vc_ver_count = 0;
/////////////------------------------------------------------------------静态找位置
//POSITION position1 = POSITION_DEFAULTS;
void  pos_cal(void);
void  L_static_init(void);
//unsigned char aa,bb;
//Uint16 pos_status_flag,L_static_sort_flag,L_static_test_flag;////找位置状态标识，找最小角度标识，静态测试标志
void  L_static_test(void);
//Uint16 L_static_test_statusflag, L_static_test_endflag;
//Uint16 min_num;
//float32 min_angle,min_radian;

main() 
{

	// Step 1. Initialize System Control:
	   InitSysCtrl();
	// For this example, set HSPCLK to SYSCLKOUT / 6 (25Mhz assuming 150Mhz SYSCLKOUT)
	   EALLOW;
	   SysCtrlRegs.HISPCP.all = 0;  // HSPCLK = 150M
	   EDIS;
	// Step 2. Initialize GPIO:
	   Init_Gpio();
	// Step 3. Clear all interrupts and initialize PIE vector table:
	// Disable CPU interrupts
	   DINT;
	   InitPieCtrl();

	   MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd, &RamfuncsRunStart);
	   InitFlash();
	   //	     Copy the Flash API functions to SARAM
	   MemCopy(&Flash28_API_LoadStart, &Flash28_API_LoadEnd, &Flash28_API_RunStart);

	   flashwr1.init(&flashwr1);
	   flashwr1.type = 0;
	   flashwr1.read_all(&flashwr1);//读取所有参数
	// Disable CPU interrupts and clear all CPU interrupt flags:
	   IER = 0x0000;
	   IFR = 0x0000;
	// Initialize the PIE vector table with pointers to the shell Interrupt
	   InitPieVectTable();

	// Interrupts that are used in this example are re-mapped to
	// ISR functions found within this file.
	   EALLOW;  // This is needed to write to EALLOW protected register
	   PieVectTable.ADCINT = &adc_isr;
	   PieVectTable.TINT0  = &timer_isr;
	   PieVectTable.T1PINT = &eva_timer1_isr;
	   PieVectTable.T1UFINT = &eva_imer1Ufint_isr;
	   PieVectTable.CMP1INT = &eva_cmp1int_isr;
	   PieVectTable.CMP2INT = &eva_cmp2int_isr;
	   PieVectTable.CMP3INT = &eva_cmp3int_isr;
	   EDIS;    // This is needed to disable write to EALLOW protected registers
	// Step 4. Initialize all the Device Peripherals:

	   InitAdc();  // For this example, init the ADC
	   InitEv();  // init eva
	   // Step 5. User specific code, enable interrupts:
	   // Enable ADCINT in PIE
	   PieCtrlRegs.PIEIER1.bit.INTx6 = 1;
	   IER |= M_INT1; // Enable CPU Interrupt 1

	   PieCtrlRegs.PIEIER2.bit.INTx4 = 1;     //GPTIMER1 pint
	   PieCtrlRegs.PIEIER2.bit.INTx6 = 1;     //GPTIMER1 ufint
	   PieCtrlRegs.PIEIER2.bit.INTx1 = 1;     //cmp1int
	   PieCtrlRegs.PIEIER2.bit.INTx2 = 1;     //cmp2int
	   PieCtrlRegs.PIEIER2.bit.INTx3 = 1;     //cmp3int
	   IER |= M_INT2;

	   //CPU timer0 interrupt seting
	   InitCpuTimers();
	   //	ConfigCpuTimer(&CpuTimer0,150,50000);//配置CPU timer0，150MH频率 ，周期50ms
	   ConfigCpuTimer(&CpuTimer0,150,1);	//1 us 中断
	   PieCtrlRegs.PIEIER1.bit.INTx7 = 1;// enable pie TINT0
	   IER |= 1;
	   StartCpuTimer0();
	   //	CpuTimer0Regs.TCR.bit.TSS = 0;
	   EINT;          // Enable Global interrupt INTM
	   ERTM;          // Enable Global realtime interrupt DBGM

	   GpioDataRegs.GPEDAT.bit.GPIOE0=fan_flag;     //FAN 风扇吸合
//	   Delay_boot();////开机延时，等待充电4
	   Pwmout(0);////关断pwm
	/////---------------------------------------------------------------current loop
	   cur_test_init();
	/////---------------------------------------------------------------voltage compensator
	   vol_init();
	   vol_rd_flash();/////补偿电压读
	/////---------------------------------------------------------------R test
	   Rtest_init();
	 ////////--------------------------------------------------------------------------ad
	   AD_init();
	 ///---------------------------------------------------------------------------静态找位置
	   L_static_init();
	 ///--------------------------------------------------------------------------
	   LoopCount = 0;
	   ConversionCount = 0;
	   count_pwn = 0;
	   vdc_80 = VDC_rated * 0.8;

  /////////--------------------------------------------------////电感测试初始化
	   L_test_init();//
///////////////////////////////////////////////////////////////////flash初始化
//	 DINT;
//	 flashwr1.init(&flashwr1);
//	 flashwr1.type = 0;
//	 flashwr1.read_all(&flashwr1);//读取所有参数
//	 EINT;          // Enable Global interrupt INTM
//	 ERTM;          // Enable Global realtime interrupt DBGM
//
//	 vol_rd_flash();/////补偿电压读

		//////////////////////////////// ---------------------------------------
	 Reset_f();
		//////////////////////////////// ---------------------------------------
//		 	EvaRegs.GPTCONA.bit.T1TOADC = 3;////比较中断启动AD转换
		 //////////////////////////////////----------------------------
	 while(main_flag)
	 {
		 LoopCount++;
		 GpioDataRegs.GPEDAT.bit.GPIOE0=fan_flag;     //FAN 风扇吸合

		 if(R_buffer_flag == 1&&U_VDC >vdc_80)
		 {
			 ////////////----------------------------缓冲电阻处理，
			 GpioDataRegs.GPADAT.bit.GPIOA13=0;
		 }


		 if(pwm_enableflag == 2)
		 {
			 Reset_f();
    		pwm_enableflag = 0;
		 }
		 if(VC_interpn_flag)
		 {
			 VC_interpn_flag = 0;
			 vol_interpn();
		 }
//			if(VC_flash_wr_flag)
//			{
//				VC_flash_wr_flag = 0;
//				vol_wr_flash();
//			}
	 }
}

interrupt void  adc_isr(void)////ad中断
{
	if(count_adinnt >= 65535)
		count_adinnt = 0;
	count_adinnt ++;
	AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;         // Reset SEQ1
	AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;   // Acknowledge interrupt to PIE
	EINT;
}
interrupt void eva_timer1_isr(void)/////周期中断
{
	EvaRegs.EVAIMRA.bit.T1PINT = 1;
	EvaRegs.EVAIFRA.bit.T1PINT = 1;
    //中断计数值
	if(count_intperiodic >= 65535)
		count_intperiodic = 0;
	count_intperiodic ++;
	if(R_buffer_flag == 0)
		if(count_intperiodic > 10000)
			R_buffer_flag = 1;
	////------------------------------------AD
	AD_test();
	if(fabs(I_f_u)>I_rated || fabs(I_f_v)>I_rated)
		pwm_enableflag = 0;
	////------------------------------------电阻测试 调用电流环
	Rtest_curr();
	////------------------------------------电压补偿 调用电流环
//	vc_assist();
	vol_compensator_filter();
	vol_compensator();
	vol_compensator_currloop();

	VC_verify();//////电压补偿验证
	//////-----------------------------static L test
	pos_cal();
	//////-----------------------------current loop test
	cur_test();
	// 状态切换
	if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断启动ADC
	{
		 cur_DQ1.ISR_flag = 2;
		 EvaRegs.GPTCONA.bit.T1TOADC = 2;// 下一次为周期中断启动ADC
	}
	else if(EvaRegs.GPTCONA.bit.T1TOADC == 2)	// 周期中断启动ADC
	{
		cur_DQ1.ISR_flag = 1;
		EvaRegs.GPTCONA.bit.T1TOADC = 1;
	}
	EvaRegs.GPTCONA.bit.T1TOADC = 1;////下溢中断启动AD转换
	PieCtrlRegs.PIEACK.all |= PIEACK_GROUP2;
}
interrupt void timer_isr()
{
	CpuTimer0.InterruptCount++;
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}
interrupt void  eva_imer1Ufint_isr(void)///下溢中断
{
	EvaRegs.EVAIFRA.bit.T1UFINT = 1;
	EvaRegs.EVAIMRA.bit.T1UFINT = 1;
/////////////----------------------------------------------
	 if(sin_vc_query_flag)//////////////电压补偿查询测试
		 iq_vc_return_test = iq_vol_v_query(iq_vc_in_test);

	if(count_intuderflow >= 65535)
		count_intuderflow = 0;
	count_intuderflow ++;

	ad_run_flag = pwm_enableflag;///pwm输出状态
	AD_test();
	if(fabs(I_f_u)>I_rated || fabs(I_f_v)>I_rated)
		pwm_enableflag = 0;
	///-----------------------------------ad 补偿系数计算
	if(AD_adjcal_startflag == 1)
	{
		AD_adjust_cal();
		AD_adjcal_startflag = 0;
	}
////------------------------------------R test
	R_test();
	Rtest_curr();
////------------------------------------L test
	L_static_sort();
	pos_cal();
	L_static_test();
	L_test_all();
////----------------------------------------------voltage compensator
//	vc_assist();
	vol_compensator_filter();
	vol_compensator();
	vol_compensator_currloop();
//
	VC_verify();//////电压补偿验证
	//////----------------------------------------current loop
	cur_test();
	// 状态切换
	if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断启动ADC
	{
		 cur_DQ1.ISR_flag = 2;
		 EvaRegs.GPTCONA.bit.T1TOADC = 2;// 下一次为周期中断启动ADC
	}
	else if(EvaRegs.GPTCONA.bit.T1TOADC == 2)	// 周期中断启动ADC
	{
		cur_DQ1.ISR_flag = 1;
		EvaRegs.GPTCONA.bit.T1TOADC = 1;
	}
	EvaRegs.GPTCONA.bit.T1TOADC = 2;////周期中断启动AD转换
	PieCtrlRegs.PIEACK.all |= PIEACK_GROUP2;   // Acknowledge interrupt to PIE

}
interrupt void eva_cmp1int_isr(void)
{
	if(count_cmp1int >= 65535)
		count_cmp1int = 0;
	count_cmp1int ++;
//	AD_test_comp();
//	AD_comp(1);
	AD_compU();
	EvaRegs.EVAIFRA.bit.CMP1INT = 1;
	EvaRegs.EVAIMRA.bit.CMP1INT = 1;
	PieCtrlRegs.PIEACK.all |= PIEACK_GROUP2;   // Acknowledge interrupt to PIE

}
interrupt void eva_cmp2int_isr(void)
{
	if(count_cmp2int >= 65535)
			count_cmp2int = 0;
	count_cmp2int ++;
	AD_compV();
	EvaRegs.EVAIFRA.bit.CMP2INT = 1;
	EvaRegs.EVAIMRA.bit.CMP2INT = 1;
	PieCtrlRegs.PIEACK.all |= PIEACK_GROUP2;   // Acknowledge interrupt to PIE
}interrupt void eva_cmp3int_isr(void)
{
	if(count_cmp3int >= 65535)
			count_cmp3int = 0;
	count_cmp3int ++;
	AD_compW();
	EvaRegs.EVAIFRA.bit.CMP3INT = 1;
	EvaRegs.EVAIMRA.bit.CMP3INT = 1;
	PieCtrlRegs.PIEACK.all |= PIEACK_GROUP2;   // Acknowledge interrupt to PIE
}
/////////////////////////////////////////////////////////////////////////////V COMPENSATION///////////////////
void vc_assist(void)
{
//	if(VC_start)
//	{
//		VC_start = 0;
//		VC_start_flag = 1;
//		VC_f1_flag = 1;///////
//		DINT;
//		EvaRegs.T1PR = cur_f2;//
//		//		pwmgen_pwm1.init(&pwmgen_pwm1);
//		cur_DQ1.Ts = 0.000166666;//0.0002;//2*EvaRegs.T1PR/150000000.0;//
//		cur_DQ1.init(&cur_DQ1);
//		EINT;
//	}
//	if(VC_f2_flag)
//	{
//		if(VC_f2_change_flag )///改变载波频率
//		{
//			DINT;
//			EvaRegs.T1PR  = cur_f1;//
//			//			pwmgen_pwm1.init(&pwmgen_pwm1);
//			cur_DQ1.Ts = 0.000333333;//0.0004;//2*EvaRegs.T1PR/150000000.0;//
//			cur_DQ1.init(&cur_DQ1);
//			EINT;
//			VC_f2_change_flag = 0;
//		}
//		if(VC_cal_num >=VC_I_count)
//		{
//			VC_f2_flag = 0;
//			VC_cal_num = 0;
//			VC_end = 1;
//			VC_start_flag = 0;//////结束测试
//		}
//	}

}
void vol_compensator()///电压补偿
{
	if(VC_start)
	{
		VC_start = 0;
		VC_start_flag = 1;
		VC_f1_flag = 1;///////
		DINT;
		EvaRegs.T1PR = cur_f2;//
		cur_DQ1.Ts = 0.000166666;//0.0002;//2*EvaRegs.T1PR/150000000.0;//
		cur_DQ1.init(&cur_DQ1);
		EINT;
	}
	if(VC_I_set_flag == 1)
		VC_I_count = VC_I_set_length;
	else if(VC_I_set_flag == 2)
		VC_I_count = VC_array_length;
	if(VC_f2_flag)
	{
		if(VC_f2_change_flag )///改变载波频率
		{
			DINT;
			EvaRegs.T1PR  = cur_f1;//
			cur_DQ1.Ts = 0.000333333;//0.0004;//2*EvaRegs.T1PR/150000000.0;//
			cur_DQ1.init(&cur_DQ1);
			EINT;

			VC_f2_change_flag = 0;

		}
		if(VC_cal_num >=VC_I_count)
		{
			VC_f2_flag = 0;
			VC_cal_num = 0;
			VC_end = 1;
			VC_start_flag = 0;//////结束测试
		}
	}
	if(VC_f1_flag&&VC_cal_num>=VC_I_count)///////f1 已经测完
	{
		VC_f1_flag = 0;
		VC_f2_flag = 1;
		VC_f2_change_flag = 1;
		VC_cal_num = 0;
	}
	if(VC_f1_change_flag)
	{
		VC_f1_change_flag = 0;
	}
	if(VC_end)
	{
		VC_end = 0;

		VC_f1_change_flag = 1;
		ID_set = 0;
		IQ_set = 0;
	}
	if(VC_start_flag)
	{
		if(VC_count_intt>=65535)
			VC_count_intt = 0;
		VC_count_intt ++;
		/////
		if(VC_I_set_flag == 1)
			VC_Iu_set = VC_I_set[VC_cal_num];////给定电流
		else if(VC_I_set_flag == 2&&VC_f2_flag == 1)
//		else if(VC_I_set_flag == 2)

			VC_Iu_set = VC_I_set_small[VC_cal_num];

		///////////////////////////////////////滤波？？？？？？？？？？？？？？？
		if(VC_f1_flag)////6k VDC滤波
		{
			iq_VC_udc_now = _IQ19mpy(U_VDC*P_inttoiq,iq_035)+_IQ19mpy(iq_VC_udc_last,iq_965);
			iq_VC_udc_last = iq_VC_udc_now;
		}
		if(VC_f2_flag&&EvaRegs.GPTCONA.bit.T1TOADC == 1)//3k VDC滤波
		{
			iq_VC_udc_now = _IQ19mpy(U_VDC*P_inttoiq,iq_07)+_IQ19mpy(iq_VC_udc_last,iq_93);
			iq_VC_udc_last = iq_VC_udc_now;
		}
//		VC_udc_now =  _IQ19toF(iq_VC_udc_now);
//		iq_VC_udc_now = U_VDC*P_inttoiq;///udc没有滤波
////-----------------------------------
//		iq_VC_iu_now =  _IQ19mpy(_IQ19(I_f_u),iq_new_p) + _IQ19mpy(iq_VC_iu_last,iq_last_p);//VC_D_p*0.01 + VC_D_p_last*0.99;
//		iq_VC_iu_last = iq_VC_iu_now;
		iq_VC_iu_now =  _IQ19(I_f_u);//VC_D_p*0.01 + VC_D_p_last*0.99;
		VC_iv_now = I_f_v;
		VC_iu_now = I_f_u;

	}
	if(VC_count_intt >200&&VC_start_flag ==1&&VC_cal_num<VC_I_count)/////等电流环稳定读取DQ系数
	{
//		VC_VD = 0.707*VC_udc_now*VC_D_p_now;
//		VC_VQ = 0.707*VC_udc_now*VC_Q_p_now;
//		VC_vu = 0.8165*VC_VD;
//		VC_vv = 0.707*VC_VQ - 0.408*VC_VD;
		iq_VC_VD = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_D_p5_now));
		iq_VC_VQ = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_Q_p5_now));
		if(VC_f1_flag)//////2倍频 载波
		{
			VC_vu = _IQ19toF(_IQ19mpy(iq_8165,iq_VC_VD));//0.8165*VC_VD;
			VC_vv = _IQ19toF(_IQ19mpy(iq_707,iq_VC_VQ)) - _IQ19toF(_IQ19mpy(iq_408,iq_VC_VD));//0.707*VC_VQ - 0.408*VC_VD;
			VC_V_vf2[VC_cal_num] = VC_vu-VC_vv;////计算v2
		}
		if(VC_f2_flag)/////1倍频载波
		{
			VC_vu = _IQ19toF(_IQ19mpy(iq_8165,iq_VC_VD));//0.8165*VC_VD;
			VC_vv = _IQ19toF(_IQ19mpy(iq_707,iq_VC_VQ)) - _IQ19toF(_IQ19mpy(iq_408,iq_VC_VD));//0.707*VC_VQ - 0.408*VC_VD;
			if(VC_I_set_flag == 1)
			{
				VC_V_vf1[VC_cal_num] = VC_vu-VC_vv;/////计算v1// _IQ19toF(iq_VC_udc_now);//
				VC_v1 = VC_V_vf2[VC_cal_num] - VC_V_vf1[VC_cal_num];
//				VC_V_v11[VC_I_set_length-1-VC_cal_num] = _IQ19toF(_IQ19div(_IQ19mpy(_IQ19mpy(_IQ19(VC_v1),iq_05),iq_VC_vdc_rated),iq_VC_udc_now));
				VC_V_v11[VC_I_set_length-1-VC_cal_num] = _IQ19toF(_IQ19div(_IQ19mpy(_IQ19(VC_v1),iq_05),iq_VC_udc_now));//去掉标准电压的运算

				VC_V_v12[VC_I_set_length-1-VC_cal_num] = _IQ19toF(_IQ19mpy(_IQ19(VC_V_vf1[VC_cal_num] ),iq_05)) \
						-_IQ19toF(_IQ19mpy(iq_VC_iu_now,iq_VC_R)) - VC_v1*0.5;
//				VC_V_delta[VC_I_set_length-1-VC_cal_num] = VC_V_v11[VC_I_set_length-1-VC_cal_num] + VC_V_v12[VC_I_set_length-1-VC_cal_num] ;
				VC_V_delta[VC_I_set_length-1-VC_cal_num][0] = VC_V_v11[VC_I_set_length-1-VC_cal_num];
				VC_V_delta[VC_I_set_length-1-VC_cal_num][1] = VC_V_v12[VC_I_set_length-1-VC_cal_num] ;

				/////////////////////大电流验证数据
//				VC_Iu[VC_cal_num] = I_f_u;
//				VC_Iv[VC_cal_num] = U_VDC;
//				VC_Cur_Vu[VC_cal_num] = VC_vu;
//				VC_Cur_Vv[VC_cal_num] = VC_vv;
			}
			if(VC_I_set_flag == 2)
			{
//				VC_Iw_now = -VC_iu_now - VC_iv_now;////w相电流
//				VC_V_v_delta = vol_query(VC_iv_now);////v相补偿电压
//				VC_V_w_delta = vol_query(VC_Iw_now);///w相补偿电压
//				VC_V_u_delta = VC_vu -1.5 * VC_iu_now * VC_R - 0.5 * (- VC_V_v_delta - VC_vu - VC_V_w_delta);
////				VC_V_u_delta = VC_vu - _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(1.5) , _IQ19(VC_iu_now) ), _IQ19(VC_R))) - _IQ19toF(_IQ19mpy(_IQ19(0.5) , _IQ19(- VC_V_v_delta - VC_vu - VC_V_w_delta)));
//				VC_V_small[VC_cal_num] = VC_V_u_delta;
////				VC_V_small[VC_cal_num] = _IQ19toF(_IQ19div(_IQ19mpy(_IQ19(VC_V_u_delta),iq_VC_vdc_rated),iq_VC_udc_now));////使用归一化系数 20191024
				////////////////IQ格式
				iq_VC_Iw_now = -iq_I_f_u - iq_I_f_v;////w相电流
				iq_VC_V_v_delta = iq_vol_v_query(iq_I_f_v);////v相补偿电压
				iq_VC_V_w_delta = iq_vol_v_query(iq_VC_Iw_now);///w相补偿电压
				iq_VC_V_u_delta = _IQ19(VC_vu) -_IQ19mpy(_IQ19mpy(_IQ19(1.5) , iq_I_f_u ), iq_VC_R) - _IQ19mpy(_IQ19(0.5) ,( - iq_VC_V_v_delta - _IQ19(VC_vu) - iq_VC_V_w_delta));
//				iq_VC_V_small[VC_cal_num] =  iq_VC_V_u_delta;// _IQ19div(_IQ19mpy(_IQ19(VC_V_u_delta),iq_VC_vdc_rated),iq_VC_udc_now);
				iq_VC_V_small[VC_cal_num] =  _IQ19div(iq_VC_V_u_delta,iq_VC_udc_now);
				//				VC_Iu[VC_cal_num] = VC_iu_now;
//				VC_Iv[VC_cal_num] = VC_iv_now;
//				VC_Vv_V[VC_cal_num] = VC_V_v_delta;
//				VC_Vw_V[VC_cal_num] = VC_V_w_delta;
//				VC_Cur_Vu[VC_cal_num] = VC_vu;
//				VC_Cur_Vv[VC_cal_num] = VC_vv;
			}
		}
		if(VC_cal_num == 0||VC_cal_num == 100)
		{
			VC_test_count ++;
			if(VC_test_count>60)
				VC_DQ_wait_flag = 1;
			if(VC_DQ_wait_flag)
				if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断更新电流给定，滤波双更新
					VC_cal_num++;
		}
		else
		{
			if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断更新电流
				VC_cal_num++;
			VC_test_count = 0;
			VC_DQ_wait_flag = 0;
		}
		VC_count_intt = 0;
	}
}
void vol_compensator_filter(void)
{
	if(VC_f1_flag)//6k
	{
		if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断
		{
			iq_VC_D_return = cur_u_vd01;
			iq_VC_Q_return = cur_u_vq01;
		}
		if(EvaRegs.GPTCONA.bit.T1TOADC == 2)// 周期中断
		{
			iq_VC_D_return = cur_t_vd01;
			iq_VC_Q_return = cur_t_vq01;
		}
		//------------------VD六次滤波
		iq_VC_D_p_now =  _IQ19mpy(iq_VC_D_return,iq_08333) + _IQ19mpy(iq_VC_D_p_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p_last = iq_VC_D_p_now;
		iq_VC_D_p1_now =  _IQ19mpy(iq_VC_D_p_now,iq_08333) + _IQ19mpy(iq_VC_D_p1_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p1_last = iq_VC_D_p1_now;
		iq_VC_D_p2_now =  _IQ19mpy(iq_VC_D_p1_now,iq_08333) + _IQ19mpy(iq_VC_D_p2_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p2_last = iq_VC_D_p2_now;
		iq_VC_D_p3_now =  _IQ19mpy(iq_VC_D_p2_now,iq_08333) + _IQ19mpy(iq_VC_D_p3_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p3_last = iq_VC_D_p3_now;
		iq_VC_D_p4_now =  _IQ19mpy(iq_VC_D_p3_now,iq_08333) + _IQ19mpy(iq_VC_D_p4_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p4_last = iq_VC_D_p4_now;
		iq_VC_D_p5_now =  _IQ19mpy(iq_VC_D_p4_now,iq_08333) + _IQ19mpy(iq_VC_D_p5_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p5_last = iq_VC_D_p5_now;
			//------------------VQ六次滤波
		iq_VC_Q_p_now =  _IQ19mpy(iq_VC_Q_return,iq_08333) + _IQ19mpy(iq_VC_Q_p_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p_last = iq_VC_Q_p_now;
		iq_VC_Q_p1_now =  _IQ19mpy(iq_VC_Q_p_now,iq_08333) + _IQ19mpy(iq_VC_Q_p1_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p1_last = iq_VC_Q_p1_now;
		iq_VC_Q_p2_now =  _IQ19mpy(iq_VC_Q_p1_now,iq_08333) + _IQ19mpy(iq_VC_Q_p2_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p2_last = iq_VC_Q_p2_now;
		iq_VC_Q_p3_now =  _IQ19mpy(iq_VC_Q_p2_now,iq_08333) + _IQ19mpy(iq_VC_Q_p3_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p3_last = iq_VC_Q_p3_now;
		iq_VC_Q_p4_now =  _IQ19mpy(iq_VC_Q_p3_now,iq_08333) + _IQ19mpy(iq_VC_Q_p4_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p4_last = iq_VC_Q_p4_now;
		iq_VC_Q_p5_now =  _IQ19mpy(iq_VC_Q_p4_now,iq_08333) + _IQ19mpy(iq_VC_Q_p5_last,iq_91667);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p5_last = iq_VC_Q_p5_now;
	}
	if(VC_f2_flag)//&&EvaRegs.GPTCONA.bit.T1TOADC == 1)///3k
	{
		if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断
		{
			iq_VC_D_return = cur_u_vd01;
			iq_VC_Q_return = cur_u_vq01;
		}
		if(EvaRegs.GPTCONA.bit.T1TOADC == 2)// 周期中断
		{
			iq_VC_D_return = cur_t_vd01;
			iq_VC_Q_return = cur_t_vq01;
		}//------------------VD六次滤波
		iq_VC_D_p_now =  _IQ19mpy(iq_VC_D_return,iq_1667) + _IQ19mpy(iq_VC_D_p_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p_last = iq_VC_D_p_now;
		iq_VC_D_p1_now =  _IQ19mpy(iq_VC_D_p_now,iq_1667) + _IQ19mpy(iq_VC_D_p1_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p1_last = iq_VC_D_p1_now;
		iq_VC_D_p2_now =  _IQ19mpy(iq_VC_D_p1_now,iq_1667) + _IQ19mpy(iq_VC_D_p2_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p2_last = iq_VC_D_p2_now;
		iq_VC_D_p3_now =  _IQ19mpy(iq_VC_D_p2_now,iq_1667) + _IQ19mpy(iq_VC_D_p3_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p3_last = iq_VC_D_p3_now;
		iq_VC_D_p4_now =  _IQ19mpy(iq_VC_D_p3_now,iq_1667) + _IQ19mpy(iq_VC_D_p4_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p4_last = iq_VC_D_p4_now;
		iq_VC_D_p5_now =  _IQ19mpy(iq_VC_D_p4_now,iq_1667) + _IQ19mpy(iq_VC_D_p5_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_D_p5_last = iq_VC_D_p5_now;
	//------------------VQ六次滤波
		iq_VC_Q_p_now =  _IQ19mpy(iq_VC_Q_return,iq_1667) + _IQ19mpy(iq_VC_Q_p_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p_last = iq_VC_Q_p_now;
		iq_VC_Q_p1_now =  _IQ19mpy(iq_VC_Q_p_now,iq_1667) + _IQ19mpy(iq_VC_Q_p1_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p1_last = iq_VC_Q_p1_now;
		iq_VC_Q_p2_now =  _IQ19mpy(iq_VC_Q_p1_now,iq_1667) + _IQ19mpy(iq_VC_Q_p2_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p2_last = iq_VC_Q_p2_now;
		iq_VC_Q_p3_now =  _IQ19mpy(iq_VC_Q_p2_now,iq_1667) + _IQ19mpy(iq_VC_Q_p3_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p3_last = iq_VC_Q_p3_now;
		iq_VC_Q_p4_now =  _IQ19mpy(iq_VC_Q_p3_now,iq_1667) + _IQ19mpy(iq_VC_Q_p4_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p4_last = iq_VC_Q_p4_now;
		iq_VC_Q_p5_now =  _IQ19mpy(iq_VC_Q_p4_now,iq_1667) + _IQ19mpy(iq_VC_Q_p5_last,iq_8333);//VC_D_p*0.01 + VC_D_p_last*0.99;
		iq_VC_Q_p5_last = iq_VC_Q_p5_now;
	}
}
void vol_compensator_currloop(void)
{
	if(VC_start_flag)
	{
		////DQ电流给定(Iw = 0,指定Iu,Iv = -Iu,根据DQ与Iuvw的关系式计算DQ）
//		ID_set = VC_Iu_set*1.225;
//		IQ_set = -0.707*VC_Iu_set;
		if(VC_cal_num == 0&&VC_I_set_flag == 1)
		{
			if(VC_test_count<10)
			{
				ID_set =  _IQ24toF(_IQ24mpy(_IQ24(3.0),iq24_1225));
				IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(3.0),_IQ24(0.707)));
			}
			else if(VC_test_count>=10&&VC_test_count<30)
			{
				ID_set =  _IQ24toF(_IQ24mpy(_IQ24(3.0),iq24_1225));
				IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(3.0),iq24_1707));
			}
			else
			{
				ID_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),iq24_1225));
				IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),iq24_1707));
			}
		}
		else if(VC_cal_num != 0&&VC_I_set_flag == 1)
		{
			ID_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),iq24_1225));
			IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),iq24_1707));
		}
		if(VC_I_set_flag == 2)
		{
			ID_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),iq24_1225));
			IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(VC_Iu_set),_IQ24(0.707))) + _IQ24toF(_IQ24mpy(_IQ24(VC_Iv_set),_IQ24(1.414)));
		}
	}
}
void vol_interpn(void)
{
	Uint16 v_i,v_i_delt ;
	float32 v_delta,v2_delta;
	for(v_i = 0; v_i <= 11; v_i++)
	{
		VC_V_big[v_i][0] = VC_V_delta[v_i][0];
		VC_V_big[v_i][1] = VC_V_delta[v_i][1];
		iq_VC_V_big[v_i][0] = _IQ19(VC_V_delta[v_i][0]);
		iq_VC_V_big[v_i][1] = _IQ19(VC_V_delta[v_i][1]);
	}
	v_delta =  VC_V_delta[12][0] - VC_V_delta[11][0];
	v2_delta = VC_V_delta[12][1] - VC_V_delta[11][1];
	for(v_i = 12; v_i <= 23; v_i++)
	{
		v_i_delt = v_i-11;
		VC_V_big[v_i][0] = VC_V_delta[11][0] + v_delta*(v_i-11)/12.0;
		VC_V_big[v_i][1] = VC_V_delta[11][1] + v2_delta*(v_i-11)/12.0;
		iq_VC_V_big[v_i][0] = _IQ19(VC_V_delta[11][0]) + _IQ19div(_IQ19mpy(_IQ19(v_delta), _IQ19(v_i_delt)),_IQ19(12.0));
		iq_VC_V_big[v_i][1] = _IQ19(VC_V_delta[11][1]) + _IQ19div(_IQ19mpy(_IQ19(v2_delta),_IQ19(v_i_delt)),_IQ19(12.0));
	}
	v_delta =  VC_V_delta[13][0] - VC_V_delta[12][0];
	v2_delta = VC_V_delta[13][1] - VC_V_delta[12][1];
	for(v_i = 24; v_i <= 47; v_i++)
	{
		v_i_delt = v_i-23;
		VC_V_big[v_i][0] = VC_V_delta[12][0] + v_delta*(v_i-23)/24.0;
		VC_V_big[v_i][1] = VC_V_delta[12][1] + v2_delta*(v_i-23)/24.0;
		iq_VC_V_big[v_i][0] = _IQ19(VC_V_delta[12][0]) + _IQ19div(_IQ19mpy(_IQ19(v_delta), _IQ19(v_i_delt)),_IQ19(24.0));
		iq_VC_V_big[v_i][1] = _IQ19(VC_V_delta[12][1]) + _IQ19div(_IQ19mpy(_IQ19(v2_delta),_IQ19(v_i_delt)),_IQ19(24.0));
	}
	v_delta =  VC_V_delta[14][0] - VC_V_delta[13][0];
	v2_delta = VC_V_delta[14][1] - VC_V_delta[13][1];
	for(v_i = 48; v_i <= 95; v_i++)
	{
		v_i_delt = v_i-47;
		VC_V_big[v_i][0] = VC_V_delta[13][0] + v_delta*(v_i-47)/48.0;
		VC_V_big[v_i][1] = VC_V_delta[13][1] + v2_delta*(v_i-47)/48.0;
		iq_VC_V_big[v_i][0] = _IQ19(VC_V_delta[13][0]) + _IQ19div(_IQ19mpy(_IQ19(v_delta), _IQ19(v_i_delt)),_IQ19(48.0));
		iq_VC_V_big[v_i][1] = _IQ19(VC_V_delta[13][1]) + _IQ19div(_IQ19mpy(_IQ19(v2_delta),_IQ19(v_i_delt)),_IQ19(48.0));
	}
}
_iq19 iq_vol_v_query(_iq19 a)
{
//	iq_VC_unification_p = _IQ19mpy(iq_VC_unification_cal,U_VDC*P_inttoiq);///归一化系数   直接用  UDC IQ19值
	iq_VC_unification_p = iq_VDC;//归一化系数   直接用  UDC IQ19值
//	vc_query_in = _IQ19toF(a);///不用转换 直接用IQ值
	if(a > iq_VC_I_rated )//////约束查询条件，不能超过额定电流
		a = iq_VC_I_rated;
	if(a < -iq_VC_I_rated)
		a = -iq_VC_I_rated;
	iq_vc_query_in = a;
//	vc_query_in_abs = fabs(vc_query_in);

//	if(vc_query_in_abs >= VC_I_rated_01)/////大电流
	if(iq_vc_query_in < 0)
		iq_vc_query_in = -iq_vc_query_in;
	if(iq_vc_query_in >= iq_VC_I_rated_01)/////大电流
	{
//		v_f_num = _IQ19toF(_IQ19mpy(_IQ19(vc_query_in_abs),iq_VC_per_mpy));//////直接用 输入值的iq绝对值
//		v_num = v_f_num;
//		v_f_part = v_f_num-v_num;
//		v_f_part_iq = _IQ19(v_f_part);
		iq_vc_query_in_abs = _IQ19mpy(iq_vc_query_in,iq_VC_per_mpy);
		v_num = _IQ19int(iq_vc_query_in_abs);//////直接用 输入值的iq绝对值
		v_f_part_iq = _IQ19frac(iq_vc_query_in_abs);
		if(v_num < 1)
//			iq_vc_return = _IQ19mpy(_IQ19mpy(iq_VC_unification_p , iq_VC_V_big[0][0]),v_f_part_iq) + _IQ19mpy(v_f_part_iq , iq_VC_V_big[0][1]);
			iq_vc_return = _IQ19mpy((_IQ19mpy(iq_VC_unification_p , iq_VC_V_big[0][0])+iq_VC_V_big[0][1]),v_f_part_iq) ;
		else
			iq_vc_return = _IQ19mpy(iq_VC_V_big[v_num-1][0],iq_VC_unification_p)\
			+ _IQ19mpy(v_f_part_iq , (_IQ19mpy((iq_VC_V_big[v_num][0]-iq_VC_V_big[v_num-1][0]),iq_VC_unification_p) + iq_VC_V_big[v_num][1]-iq_VC_V_big[v_num-1][1]))\
			+ iq_VC_V_big[v_num-1][1] ;
//
		if(a < 0)
//			iq_vc_return =  _IQ19mpy(iq_0101 , iq_vc_return);
			iq_vc_return =  -iq_vc_return;
	}
	else////////////////////////////////////小电流
	{
//		v_f_num = _IQ19toF(_IQ19mpy(_IQ19(vc_query_in_abs),iq_VC_per_small_mpy));//////
//		v_num = v_f_num;
//		v_f_part = v_f_num-v_num;
//		v_f_part_iq = _IQ19(v_f_part);////直接获取iq值的整数和小数部分
		iq_vc_query_in_abs = _IQ19mpy(iq_vc_query_in,iq_VC_per_small_mpy);//////
		v_num = _IQ19int(iq_vc_query_in_abs);//////直接用 输入值的iq绝对值
		v_f_part_iq = _IQ19frac(iq_vc_query_in_abs);
		if(a >= 0)
		{
			if(v_num >= 47)//////////?????a
				iq_vc_return = _IQ19mpy((iq_VC_V_small[95] +  _IQ19mpy(v_f_part_iq,(iq_VC_V_small[95]-iq_VC_V_small[94]))),iq_VC_unification_p);
			else
				iq_vc_return = _IQ19mpy((iq_VC_V_small[48 + v_num] + _IQ19mpy(v_f_part_iq,(iq_VC_V_small[48 +v_num+1]-iq_VC_V_small[48 +v_num]))),iq_VC_unification_p);
		}
		else
			iq_vc_return = _IQ19mpy((iq_VC_V_small[48 - v_num] + _IQ19mpy(v_f_part_iq,(iq_VC_V_small[48 - v_num - 1]-iq_VC_V_small[48 - v_num]))),iq_VC_unification_p);

//		{
//			if(v_num >= 47)//////////?????a
//				iq_vc_return = iq_VC_V_small[95] +  _IQ19mpy(v_f_part_iq,(iq_VC_V_small[95]-iq_VC_V_small[94]));
//			else
//				iq_vc_return = iq_VC_V_small[48 + v_num] + _IQ19mpy(v_f_part_iq,(iq_VC_V_small[48 +v_num+1]-iq_VC_V_small[48 +v_num]));
//		}
//		else
//			iq_vc_return = iq_VC_V_small[48 - v_num] + _IQ19mpy(v_f_part_iq,(iq_VC_V_small[48 - v_num - 1]-iq_VC_V_small[48 - v_num]));
	}
	return iq_vc_return;
}
void VC_verify()
{
//	if(VC_verify_flag)
//	{
//	///电压时序判断
//		if(EvaRegs.GPTCONA.bit.T1TOADC == 1)// 下溢中断
//		{
//			iq_VC_D_return = cur_u_vd01;
//			iq_VC_Q_return = cur_u_vq01;
//
//			iq_iu_delt = iq_I_f_u - iq_iu_last_t;
//			iq_iv_delt = iq_I_f_v - iq_iv_last_t;
//		}
//		if(EvaRegs.GPTCONA.bit.T1TOADC == 2)// 周期中断
//		{
//			iq_VC_D_return = cur_t_vd01;
//			iq_VC_Q_return = cur_t_vq01;
//
//			iq_iu_delt = iq_I_f_u - iq_iu_last_t;
//			iq_iv_delt = iq_I_f_v - iq_iv_last_t;
//		}
//		////L di/dt
//		iq_vc_u_didt = _IQ19mpy(_IQ19mpy(iq_ldq , iq_iu_delt),iq_t_div);
//		iq_vc_v_didt = _IQ19mpy(_IQ19mpy(iq_ldq , iq_iv_delt),iq_t_div);
//
//		if(vc_ver_filter_flag)/////////////////////DQ五次滤波
//		{
//			iq_VC_D_p1_now =  _IQ19mpy(iq_VC_D_return,iq_333) + _IQ19mpy(iq_VC_D_p1_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_D_p1_last = iq_VC_D_p1_now;
//			iq_VC_D_p2_now =  _IQ19mpy(iq_VC_D_p1_now,iq_333) + _IQ19mpy(iq_VC_D_p2_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_D_p2_last = iq_VC_D_p2_now;
//			iq_VC_D_p3_now =  _IQ19mpy(iq_VC_D_p2_now,iq_333) + _IQ19mpy(iq_VC_D_p3_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_D_p3_last = iq_VC_D_p3_now;
//			iq_VC_D_p4_now =  _IQ19mpy(iq_VC_D_p3_now,iq_333) + _IQ19mpy(iq_VC_D_p4_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_D_p4_last = iq_VC_D_p4_now;
//			iq_VC_D_p5_now =  _IQ19mpy(iq_VC_D_p4_now,iq_333) + _IQ19mpy(iq_VC_D_p5_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_D_p5_last = iq_VC_D_p5_now;
//
//			iq_VC_Q_p1_now =  _IQ19mpy(iq_VC_Q_return,iq_333) + _IQ19mpy(iq_VC_Q_p1_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_Q_p1_last = iq_VC_Q_p1_now;
//			iq_VC_Q_p2_now =  _IQ19mpy(iq_VC_Q_p1_now,iq_333) + _IQ19mpy(iq_VC_Q_p2_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_Q_p2_last = iq_VC_Q_p2_now;
//			iq_VC_Q_p3_now =  _IQ19mpy(iq_VC_Q_p2_now,iq_333) + _IQ19mpy(iq_VC_Q_p3_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_Q_p3_last = iq_VC_Q_p3_now;
//			iq_VC_Q_p4_now =  _IQ19mpy(iq_VC_Q_p3_now,iq_333) + _IQ19mpy(iq_VC_Q_p4_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_Q_p4_last = iq_VC_Q_p4_now;
//			iq_VC_Q_p5_now =  _IQ19mpy(iq_VC_Q_p4_now,iq_333) + _IQ19mpy(iq_VC_Q_p5_last,iq_667);//VC_D_p*0.01 + VC_D_p_last*0.99;
//			iq_VC_Q_p5_last = iq_VC_Q_p5_now;
//			/////VD VQ
//			iq_VC_udc_now = U_VDC*P_inttoiq ;
//			iq_VC_VD = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_D_p5_now));
//			iq_VC_VQ = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_Q_p5_now));
//		}
//		else
//		{
////			iq_VC_D_p5_now = iq_uu;
////			iq_VC_Q_p5_now = iq_uv;
//			/////VD VQ
//			iq_VC_udc_now = U_VDC*P_inttoiq ;
//			iq_VC_VD = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_D_return));
//			iq_VC_VQ = (_IQ19mpy(_IQ19mpy(iq_707,iq_VC_udc_now),iq_VC_Q_return));
//		}
//		if(vc_ver_didt_flag)//////uv相电压 减去Ldi/dt
//		{
//			iq_uu = _IQ19mpy(iq_8165,iq_VC_VD) - iq_vc_u_didt;//0.8165*VC_VD;
//			iq_uv = _IQ19mpy(iq_707,iq_VC_VQ) - _IQ19mpy(iq_408,iq_VC_VD) - iq_vc_v_didt;//0.707*VC_VQ - 0.408*VC_VD;
//		}
//		else
//		{
//			iq_uu = _IQ19mpy(iq_8165,iq_VC_VD);//0.8165*VC_VD;
//			iq_uv = _IQ19mpy(iq_707,iq_VC_VQ) - _IQ19mpy(iq_408,iq_VC_VD) ;//0.707*VC_VQ - 0.408*VC_VD;
//		}
//		iq_I_w = -iq_I_f_u-iq_I_f_v;////Iw
//		iq_vcu = iq_vol_v_query(iq_I_f_u);///
//		iq_vcv = iq_vol_v_query(iq_I_f_v);
//		iq_vcw = iq_vol_v_query(iq_I_w);
//		iq_vco = _IQ19mpy((iq_vcu + iq_vcv + iq_vcw),iq_333);///中心点电压
//		iq_vcuo = iq_vcu - iq_vco;///经过中心点电压计算的U相补偿电压
//		iq_vcvo = iq_vcv - iq_vco;///经过中心点电压计算的V相补偿电压
//		iq_uu_vc = iq_uu ;///经过补偿的U相电压
//		iq_uv_vc = iq_uv ;///经过补偿的V相电压
////		iq_uu_vc = iq_uu - iq_vcuo;///经过补偿的U相电压
////		iq_uv_vc = iq_uv - iq_vcvo;///经过补偿的V相电压
//		/////静态验证补偿电压误差   电流环U相电压（或减去 Ldi/dt） - U相补偿电压 - 实际电流乘以电阻
////		VC_verify_iu_error = _IQ19toF(iq_uu - iq_vcuo - _IQ19mpy(iq_I_f_u , iq_VC_R));
////		VC_verify_iv_error = _IQ19toF(iq_uv - iq_vcvo - _IQ19mpy(iq_I_f_v , iq_VC_R));
//		//////数据录取
////		if(VC_cal_num< 96)
////		{
////			VC_cur_1[VC_cal_num] = iq_VC_D_return;
////			VC_cur_2[VC_cal_num] = iq_VC_Q_return;
////			VC_cur_3[VC_cal_num] = iq_uu;
////			VC_cur_4[VC_cal_num] = iq_uv;//_IQ19mpy(iq_I_f_u,iq_1225);///ID
////			VC_vc_5[VC_cal_num]  = _IQ19mpy(iq_I_f_u,iq_1225);///IDiq_iu_delt;//_IQ19mpy(iq_I_f_u,iq_707) + _IQ19mpy(iq_I_f_v,iq_1414);///IQ
////			VC_vc_6[VC_cal_num]  = _IQ19mpy(iq_I_f_u,iq_707) + _IQ19mpy(iq_I_f_v,iq_1414);///IQiq_iv_delt;
////			VC_error_u[VC_cal_num]  = VC_verify_iu_error;//I_f_u;
////			VC_error_v[VC_cal_num]  = VC_verify_iv_error;//I_f_v;
////			VC_cal_num ++;
////		}
////		else
////			VC_cal_num = 0;
///////////////////////////////////////////////////测电流环开始的数据
////		if(vc_ver_count< 96&&cur_test_flag)
////		{
////			VC_cur_1[vc_ver_count] = iq_VC_D_return;
////			VC_cur_2[vc_ver_count] = iq_VC_Q_return;
////			VC_cur_3[vc_ver_count] = iq_uu;
////			VC_cur_4[vc_ver_count] = iq_uv;//_IQ19mpy(iq_I_f_u,iq_1225);///ID
////			VC_vc_5[vc_ver_count]  = _IQ19mpy(iq_I_f_u,iq_1225);///IDiq_iu_delt;//_IQ19mpy(iq_I_f_u,iq_707) + _IQ19mpy(iq_I_f_v,iq_1414);///IQ
////			VC_vc_6[vc_ver_count]  = _IQ19mpy(iq_I_f_u,iq_707) + _IQ19mpy(iq_I_f_v,iq_1414);///IQiq_iv_delt;
////			VC_error_u[vc_ver_count]  = I_f_u;
////			VC_error_v[vc_ver_count]  = I_f_v;
////			vc_ver_count ++;
////		}
///////////////////////////////////////////////////测电流环开始的数据
//
//////		D_per_unit_vc = uu_vc*1.732/U_VDC;
//////		Q_per_unit_vc = (uu_vc + uv_vc*2)/U_VDC;
//		D_per_unit_vc = _IQ19toF(_IQ19div(_IQ19mpy(iq_uu_vc,iq_1732),iq_VC_udc_now));
//		Q_per_unit_vc = _IQ19toF(_IQ19div((iq_uu_vc + _IQ19mpy(iq_uv_vc,_IQ19(2))),iq_VC_udc_now));
//	}
}
void vol_init(void)
{
	////	memset(VC_V_big,0,sizeof(VC_V_big));
	//	memset(VC_V_vf1,0,sizeof(VC_V_vf1));
	//	memset(VC_V_delta,0,sizeof(VC_V_delta));
	//	memset(VC_V_vf2,0,sizeof(VC_V_vf2));
	//	memset(VC_V_v11,0,sizeof(VC_V_v11));
	//	memset(VC_V_v12,0,sizeof(VC_V_v12));
	//	memset(VC_I_set_sall,0,sizeof(VC_I_set_sall));
	//	memset(VC_V_small,0,sizeof(VC_V_small));
	////	memset(VC_Iu,0,sizeof(VC_Iu));
	////	memset(VC_Iv,0,sizeof(VC_Iv));
	////	memset(VC_Iw,0,sizeof(VC_Iw));
	////	memset(VC_Vv_V,0,sizeof(VC_Vv_V));
	////	memset(VC_Vw_V,0,sizeof(VC_Vw_V));
	////	memset(VC_Cur_Vu,0,sizeof(VC_Cur_Vu));
	////	memset(VC_Cur_Vv,0,sizeof(VC_Cur_Vv));
	VC_v1=1,   VC_vv11=2,   VC_vv12=0;   VC_v2=0;   VC_vv21=0;   VC_vv22=0;
	VC_vu=0;   VC_vv=0;   VC_vw=0;   VC_vo=0;   VC_VD=0;   VC_VQ=0;
	VC_ID=0;   VC_IQ=0;   VC_f1=0;   VC_f2=0;
	t_div = 75000000.0/EvaRegs.T1PR/2;
	////  dt 除法变成乘法 3k双更新是乘以6000
//	iq_t_div = _IQ19(t_div);
	iq_t_div = _IQ19(3000);////3K 双更新_IQ19(6000) 3000只是一半，另一半由另一个系数补偿
//	iq_ldq = _IQ19(LDS);
//	iq_ldq = _IQ19(0.0128);///beijing    ///LDS（0.0064） * 2    IQ19范围4096,2是 补偿iq_t_div
	iq_ldq = _IQ19(0.00762);///taiyuan    ///LDS（0.00381） * 2  IQ19范围4096,2是 补偿iq_t_div
	VC_R =  0.186;//taiyuan//0.49; //beijing//
	VC_I_rated =  20.0;//taiyuan//10.0;//beijing额定电流//
	VC_Iv_set = 5.0;//指定V相电流VC_I_rated * 0.1;/////////////////////////
	VC_vdc_rated =  537.0;///beijing///564.0;//taiyuan///

	VC_unification_cal = 1.0/VC_vdc_rated;
	for(VC_cal_num = 0;VC_cal_num<VC_array_length;VC_cal_num++)////小电流表格初始化
	{
		VC_I_set_small[VC_cal_num] = -0.1 * VC_I_rated + 0.1 * VC_I_rated * 2 / VC_array_length * VC_cal_num;
	}
	for(VC_cal_num = 0;VC_cal_num<VC_I_set_length;VC_cal_num++)////大电流表格初始化
	{
		if(VC_cal_num <= 3 )
			VC_I_set[VC_cal_num] = VC_I_rated * pow(0.5,VC_cal_num);
		else
		{
			VC_I_set[VC_cal_num] = VC_I_rated * 0.125 * (VC_I_set_length - VC_cal_num) / 12;
		}
	}
	iq_VC_per_mpy =  _IQ19(VC_array_length/VC_I_rated);///除法变为乘法省时间，大表格电流 分辨率倒数
	VC_per =  (VC_I_rated/VC_array_length);///大表格电流 分辨率
	iq_VC_per_small_mpy = _IQ19(VC_array_length/(2*VC_I_rated*0.1));///除法变为乘法省时间，小表格电流 分辨率倒数
	iq_VC_per_small = _IQ19((2*VC_I_rated*0.1)/VC_array_length);///小表格电流 分辨率
	///////////////////////////////////////////////////////
	//	for(VC_cal_num = 0;VC_cal_num<95;VC_cal_num++)//////差值测试用， 将给定电流直接赋值补偿电压
	//		VC_V_big[VC_cal_num] = 8*(VC_cal_num );////测试
	//	for(VC_cal_num = 0;VC_cal_num<95;VC_cal_num++)//////差值测试用， 将给定电流直接赋值补偿电压
	//		VC_V_small[VC_cal_num] = -100 + 200.0/96.0*(VC_cal_num );////测试
	//	ID_set = vol_query(5.3);
	//	ID_set = vol_query_small(1.3);
	//	ID_set = vol_query_small(-1.3);
	////////////////////////////////////////////////////
	VC_I_set_flag = 1;//大电流测试标志
	VC_I_count = 0;
	VC_cal_num=0;   VC_count_intt=0;
	VC_start=0;     VC_end=0;   VC_start_flag=0;   VC_end_flag=0;
	VC_udc_now=0;   VC_udc_last=0;   VC_D_p=0;   VC_D_p_now=0;   VC_D_p_last=0;   VC_Q_p=0;   VC_Q_p_now=0;   VC_Q_p_last=0;
	VC_iu_now=0;    VC_iu_last=0;    VC_iv_now=0;
	VC_f1_flag=0;   VC_f2_flag=0;
	VC_f1_change_flag = 0;   VC_f2_change_flag = 0;
	VC_test_count = 0;
	//	I_per_pulse= 0;
	VC_DQ_wait_flag = 0;     VC_flash_wr_flag = 0;  VC_interpn_flag = 0;  VC_flash_rd_flag = 1;
	iq_VC_udc_now=0;   iq_VC_udc_last=0;   iq_VC_D_p=0;   iq_VC_D_p_now=0;   iq_VC_D_p_last=0;   iq_VC_Q_p=0;   iq_VC_Q_p_now=0;   iq_VC_Q_p_last=0;
	iq_VC_iu_now=0;    iq_VC_iu_last=0;
	iq_VC_D_return=0;    iq_VC_Q_return=0;
	iq_VC_VD=0;          iq_VC_VQ=0;
	VC_Iu_set = 0;
	iq_VC_R = _IQ19(VC_R);iq_1414 = _IQ19(1.414);iq_707 = _IQ19(0.707);iq_1225 = _IQ19(1.225);iq_408 = _IQ19(0.408);iq_8165 = _IQ19(0.8165);iq_05 = _IQ19(0.5);

	iq24_1225 = _IQ24(1.225);iq24_1707 = _IQ24(-0.707);
	iq_VC_vdc_rated = _IQ19(VC_vdc_rated);
	iq_08333 = _IQ19(0.08333); iq_91667 = _IQ19(0.91667); iq_93 = _IQ19(0.93);      iq_07 = _IQ19(0.07);
	iq_965 = _IQ19(0.965);  iq_035 = _IQ19(0.035);  iq_8333 = _IQ19(0.83333);  iq_1667 = _IQ19(0.16667);
	iq_333 = _IQ19(0.333);  iq_667 = _IQ19(0.667);  iq_1732 = _IQ19(1.732);
	iq_VC_D_p1_now=0;    iq_VC_D_p1_last=0;    iq_VC_D_p2_now=0;    iq_VC_D_p2_last=0;    iq_VC_D_p3_now=0;    iq_VC_D_p3_last=0;
	iq_VC_D_p4_now=0;    iq_VC_D_p4_last=0;    iq_VC_D_p5_now=0;    iq_VC_D_p5_last=0;    iq_VC_D_p6_now=0;    iq_VC_D_p6_last=0;
	iq_VC_Q_p1_now=0;    iq_VC_Q_p1_last=0;    iq_VC_Q_p2_now=0;    iq_VC_Q_p2_last=0;    iq_VC_Q_p3_now=0;    iq_VC_Q_p3_last=0;
	iq_VC_Q_p4_now=0;    iq_VC_Q_p4_last=0;    iq_VC_Q_p5_now=0;    iq_VC_Q_p5_last=0;    iq_VC_Q_p6_now=0;    iq_VC_Q_p6_last=0;
	iq_VC_UU_p1_now=0;    iq_VC_UU_p1_last=0;    iq_VC_UU_p2_now=0;    iq_VC_UU_p2_last=0;
	iq_VC_UU_p3_now=0;    iq_VC_UU_p3_last=0;    iq_VC_UU_p4_now=0;    iq_VC_UU_p4_last=0;
	iq_VC_unification_cal =  _IQ19(VC_unification_cal);
	iq_VC_unification_p = 0;
	iq_VC_I_rated = _IQ19(VC_I_rated);  iq_01 = _IQ19(0.1);    iq_0101 = _IQ19(-1);
	iq_VC_I_rated_01 = _IQ19mpy(iq_01,iq_VC_I_rated); VC_I_rated_01 = 0.1*VC_I_rated;

	/////////补偿电压验证
	VC_verify_flag = 0;
	VC_verify_iu = 0;    VC_verify_iu_error = 0;
	VC_verify_iv = 0;    VC_verify_iv_error = 0;
	uu_vc = 0;    		 uv_vc = 0;

	sin_count = 0;       sin_out_flag = 0;       sin_data_flag = 0;    sin_data_startflag = 0;
	sin_vc_flag = 0;	 sin_data_num= 0;   sin_vc_symbol_flag = 0;		sin_vc_query_flag = 0;
	sin_vc_dq_filter_flag = 0;	             sin_dq_filter_flag = 1;
	VC_motor_f = 1;
	omg_per = 2*pi/3000.0;  pi_2 = 2*pi;
	omg = 0;
	D_per_unit_vc = 0;     Q_per_unit_vc = 0;
	cur_t_vd0 = 0;     cur_t_vq0 = 0;     cur_t_v1 = 0;     cur_t_vd01 = 0;     cur_t_vq01 = 0;
	cur_u_vd0 = 0;     cur_u_vq0 = 0;     cur_u_v1 = 0;     cur_u_vd01 = 0;     cur_u_vq01 = 0;

}
/////////////////////////////////////////////////////////////////////////////CURRENT LOOP///////////////////

void cur_test(void)
{
	if(cur_test_flag)
	{
		/////////////////////////////clarke
		clarke1.As = _IQ24mpy(_IQ24(I_f_u),iq_div_I_range);
		clarke1.Bs = _IQ24mpy(_IQ24(I_f_v),iq_div_I_range);
//		clarke1.As = _IQ(I_f_u/I_range);
//		clarke1.Bs = _IQ(I_f_v/I_range);
		clarke1.calc(&clarke1);
		//////////////////////////////电流环计算
		if(sin_out_flag == 1)
		{
			omg_delt = omg_per * VC_motor_f;
			if(sin_count>=3000)
			{
				sin_count = 0;
//				omg = 0;
			}
			if(sin_count == 0&&sin_data_flag == 1)
			{
				sin_data_startflag = 1;
			}
			if(sin_count<sin_test_count&&sin_data_startflag == 1)
			{
				sin_data_flag = 0;
//				switch(sin_data_num)
//				{
//				case 0:
//					sin_test[sin_count] = iq_VC_D_p5_now;///滤波
//					break;
//				case 1:
//					sin_test[sin_count] = iq_VC_Q_p5_now;
//					break;
//				case 2:
//					sin_test[sin_count] = iq_uu;/////没有滤波
//					break;
//				case 3:
//					sin_test[sin_count] = iq_uv;
//					break;
//				case 4:
//					sin_test[sin_count] = _IQ19(D_per_unit_vc)-_IQ19(D_per_unit);//iq_uu_vc;//经过补偿
//					break;
//				case 5:
//					sin_test[sin_count] =_IQ19(Q_per_unit_vc)-_IQ19(Q_per_unit); //iq_uv_vc;
//					break;
//
//				case 6:
//					sin_test[sin_count] = _IQ19(D_per_unit_vc);
//					break;
//				case 7:
//					sin_test[sin_count] = _IQ19(Q_per_unit_vc);
//					break;
//				case 8:
//					sin_test[sin_count] = _IQ19(D_per_unit);
//					break;
//				case 9:
//					sin_test[sin_count] = _IQ19(Q_per_unit);
//					break;
//
//				default:
//					break;
//				}
			}
            //////////////////////交流给定
			if(EvaRegs.GPTCONA.bit.T1TOADC == 1)
			{
				omg += omg_delt ;
				if(omg >= pi_2)
					omg = 0;
				sin_count ++;
			}
			cur_DQ1.D.Is_ref = _IQ24mpy(_IQmpy(_IQ(ID_set),_IQ24cos(_IQ24(omg))),iq_div_I_range);// ID input
			cur_DQ1.Q.Is_ref = _IQ24mpy(_IQmpy(_IQ(IQ_set),_IQ24sin(_IQ24(omg))),iq_div_I_range);// IQ input
		}
		else
		{
			cur_DQ1.D.Is_ref = _IQ24mpy(_IQ24(ID_set),iq_div_I_range);// ID input
			cur_DQ1.Q.Is_ref = _IQ24mpy(_IQ24(IQ_set),iq_div_I_range);// IQ input
		}
		//////存储电流环输出，在电流环计算之前，
		///////////////////////////////////////////////////////////
		if(EvaRegs.GPTCONA.bit.T1TOADC == 1)/////下溢中断
		{
			cur_t_vd01 = _IQtoIQ19(cur_DQ1.D.Vout);
			cur_t_vq01 = _IQtoIQ19(cur_DQ1.Q.Vout);
			iq_iu_last_t = iq_I_f_u;
			iq_iv_last_t = iq_I_f_v;
		}
		if(EvaRegs.GPTCONA.bit.T1TOADC == 2)/////周期中断
		{
			cur_u_vd01 = _IQtoIQ19(cur_DQ1.D.Vout);
			cur_u_vq01 = _IQtoIQ19(cur_DQ1.Q.Vout);
			iq_iu_last_t = iq_I_f_u;
			iq_iv_last_t = iq_I_f_v;
		}
	////current calu
		cur_DQ1.D.I_back = clarke1.Alpha;	// ID FeedBack
		cur_DQ1.Q.I_back = clarke1.Beta;	// IQ FeedBack
		cur_DQ1.calc(&cur_DQ1);
		/////////////////////////////pwm out
		D_per_unit = _IQ24toF(cur_DQ1.D.Vout);
		Q_per_unit = _IQ24toF(cur_DQ1.Q.Vout);
		///////////////////////////////////////////////////////////

		if(sin_out_flag == 1)//////
		{
			if(sin_vc_flag == 1)
			{
				D_per_unit = D_per_unit_vc;
				Q_per_unit = Q_per_unit_vc;
			}
		}
		///////////////////////////////////////////////////////////
		DQout(D_per_unit,Q_per_unit);//
		Pwmout(cur_test_flag);
	}
}
void cur_test_init(void)
{
	cur_DQ1.Rs = RS;
	cur_DQ1.LDs = LDS;
	cur_DQ1.LQs = LQS;			// LQS;
	cur_DQ1.Ib = BASE_CURRENT;
	cur_DQ1.Vb = BASE_VOLTAGE;
	cur_DQ1.Ts = 2*EvaRegs.T1PR/150000000.0;		// 采样时间;		// 采样时间;
	cur_DQ1.init(&cur_DQ1);
	cur_test_flag = 0;  	cur_i_set = 0;
	ID_set = 0;             IQ_set = 0;
	div_I_range = 1.0/I_range;
	iq_div_I_range = _IQ(div_I_range);
}
//////////////////////////////////////////////////////////////////////R  TEST ///////////////////////////////////////////
void Rtest_init(void)
{
//	R_test_startflag = 0;	R_test_endflag = 0;
//	I_d_out = 0;	I_q_out = 0;
//	R_test_start = 0;R_test_end = 0;
//	R_test_startflag_d = 0;    R_test_endflag_d = 0;    R_test_startflag_q = 0;   R_test_endflag_q = 0;
//	R_test_halfstartflag_d = 0;    R_test_halfendflag_d = 0;    R_test_halfstartflag_q = 0;    R_test_halfendflag_q = 0;
//	M_flag = 0;	R_test_i = 0;
//	R_test_id = 0;    R_test_id_half = 0;    R_test_iq = 0;    R_test_iq_half = 0;
//	R_test_Ud = 0;    R_test_Ud_half = 0;    R_test_Uq = 0;    R_test_Uq_half = 0;
//	R_d = 0;    R_q = 0;
//	R_test_I_outflag = 0;	 i_r = 0;
//	R_vdc_test = 0;       R_vdc_test_now = 0;       R_vdc_test_last = 0;
//	R_test_d_para = 0;    R_test_d_para_now = 0;    R_test_d_para_last = 0;
//	R_test_q_para = 0;    R_test_q_para_now = 0;    R_test_q_para_last = 0;
//
//	R_f1_flag = 0;    R_f2_flag = 0;
//	R_u_f1 = 0;       R_u_f2 = 0;           R_u_half_f1 = 0;        R_u_half_f2 = 0;
//	R_u_delta = 0;    R_u_delta_half = 0;
//	R_i = 0;          R_i_half = 0;
//	R_test_f1_endflag = 0;
//	R_test_i = 0;    R_test_i_now = 0;    R_test_i_last = 0;
//	R_f_editflag = 0;	 count_test = 0;
//	R_test_f_change_flag = 0;
//	R_D_cur_return = _IQ19(0);      R_Q_cur_return = _IQ19(0);
//	iq_ID_set= _IQ19(0);            iq_IQ_set= _IQ19(0);
//	iq_R_vdc_test = _IQ19(0);       iq_R_vdc_test_now = _IQ19(0);       iq_R_vdc_test_last = _IQ19(0);
//	iq_R_test_d_para = _IQ19(0);    iq_R_test_d_para_now = _IQ19(0);    iq_R_test_d_para_last = _IQ19(0);
//	iq_R_test_q_para = _IQ19(0);    iq_R_test_q_para_now = _IQ19(0);    iq_R_test_q_para_last = _IQ19(0);
//	iq_R_test_i = _IQ19(0);         iq_R_test_i_now = _IQ19(0);         iq_R_test_i_last = _IQ19(0);
//	///////电阻测试等待时间，
//	R_test_I_time = 2.0;/////电阻测试时间0.1秒
//	R_test_I_timecount = R_test_I_time*75000000/EvaRegs.T1PR;///电阻测试电流持续的中断次数

}
void R_test()
{
//
//	if(R_test_f_change_flag)
//	{
//
//		EvaRegs.T1PR =  cur_f1;//0x61a7;
////			pwmgen_pwm1.init(&pwmgen_pwm1);
//		cur_DQ1.Ts = 0.000333333;//2*EvaRegs.T1PR/150000000.0;
//		cur_DQ1.init(&cur_DQ1);
//
//		R_test_f_change_flag = 0;
//	}
//	if(R_test_endflag)///电阻计算
//	{
////		R_d = (R_test_Ud_half - R_test_Ud)*2/I_d_out;
//
//		R_u_delta = R_u_f2 - R_u_f1;
//		R_u_delta_half = R_u_half_f2 - R_u_half_f1;
////			R_d = _IQ19toF(_IQ19div(_IQ19mpy(_IQ19(R_u_f1 - R_u_half_f1 - R_u_delta + R_u_delta_half) ,_IQ19( 0.5)), _IQ19(R_i - R_i_half)));
//		R_d = ((R_u_f1 - R_u_half_f1) - R_u_delta + R_u_delta_half) * 0.5 / (R_i - R_i_half);
//		R_test_endflag = 0;
//		////关断输出
//		ID_set = 0;
//		IQ_set = 0;
//
//		R_test_startflag = 0;///电阻测试完成
//		R_test_f_change_flag = 1;
//
//	}
//	if(R_test_start)
//	{
////		R_test_end = 0;
//		R_test_start = 0;
//		R_test_startflag_d = 1;
//
//		R_f1_flag = 1;
//	}
//	if(R_f1_flag&&R_test_f1_endflag)
//	{
//		R_f1_flag = 0;
//		R_test_f1_endflag = 0;
//		R_f2_flag = 1;
//		R_f_editflag = 1;
//
//	}
//	if(R_f2_flag)
//	{
//		if(R_f_editflag)
//		{
//			EvaRegs.T1PR = cur_f2;//0x30d3;
////			pwmgen_pwm1.init(&pwmgen_pwm1);
//			cur_DQ1.Ts = 0.000166666;//2*EvaRegs.T1PR/150000000.0;
//			cur_DQ1.init(&cur_DQ1);
//
//			R_f_editflag = 0;
//			R_test_startflag_d = 1;
//		}
//	}
//	if(R_test_startflag_d||R_test_halfstartflag_d)
//	{
//		//根据初始的输入值确定输出电流
//		if(R_test_startflag_d)
//		{
//			R_test_i = I_d_out/2.0;
//			R_test_endflag_d = 1;
//		}
//		else
//		{
//			R_test_i = I_d_out;
//			R_test_halfendflag_d = 1;
//		}
//		//输出设定额定或额定一半的电流
////		R_test_iq = 0;
////		中断值清零
//		count_intu = 0;//下溢中断计数值清零
//		R_test_startflag_d = 0;
//		R_test_halfstartflag_d = 0;
//
//		R_test_startflag = 1;
//	}
//	if(R_test_startflag)////电阻测试进行标识，给出电流，返回电压
//	{
//		if(count_intu >= 65535)
//			count_intu = 0;
//		count_intu ++;
////		if(pwm_enableflag)//滤波
//		{
//			/////总线电压滤波
////			R_vdc_test_now = U_VDC*0.01+R_vdc_test_last*0.99;
////			R_vdc_test_last = R_vdc_test_now;
//
//			iq_R_vdc_test_now = _IQ19mpy(U_VDC*P_inttoiq,iq_new_p)+_IQ19mpy(iq_R_vdc_test_last,iq_last_p);
//			iq_R_vdc_test_last = iq_R_vdc_test_now;
////			R_vdc_test_now = _IQ19toF(iq_R_vdc_test_now);
//			/////D轴系数滤波
////			R_test_d_para_now = D_per_unit*0.01 + R_test_d_para_last*0.99;
////			R_test_d_para_last = R_test_d_para_now;
//			iq_R_test_d_para_now = _IQ19mpy(R_D_cur_return,iq_new_p) + _IQ19mpy(iq_R_test_d_para_last,iq_last_p);
//			iq_R_test_d_para_last = iq_R_test_d_para_now;
////			R_test_q_para_now = Q_per_unit*0.01 + R_test_q_para_last*0.99;
////			R_test_q_para_last = R_test_q_para_now;
//			iq_R_test_q_para_now = _IQ19mpy(R_Q_cur_return,iq_new_p)  + _IQ19mpy(iq_R_test_q_para_last,iq_last_p);
//			iq_R_test_q_para_last = iq_R_test_q_para_now;
////			R_test_i_now = I_f_u*0.01 + R_test_i_last*0.99;
////			R_test_i_last = R_test_i_now;
//			iq_R_test_i_now = _IQ19mpy(_IQ19(I_f_u),iq_new_p) +  _IQ19mpy(iq_R_test_i_last,iq_last_p);
//			iq_R_test_i_last = iq_R_test_i_now;
//		}
////		if(count_intu>=R_test_I_timecount-200&&count_intu<=R_test_I_timecount)///////截取稳定后的最好200个数
////		{
////			R_id[count_intu+200-R_test_I_timecount] = I_f_u;
////			R_id_lb[count_intu+200-R_test_I_timecount] = I_f_v;
//////			R_id[count_intu+200-R_test_I_timecount] = D_per_unit;
//////			R_id_lb[count_intu+200-R_test_I_timecount] = R_test_d_para;
////			R_vdc[count_intu+200-R_test_I_timecount] = U_VDC;
////			R_vdc_lb[count_intu+200-R_test_I_timecount] = R_vdc_test_now;
////		}
//
////		if(count_test<199&&R_f2_flag&&R_test_endflag_d)	///获取电流环开始的200个数
////								{
////									R_id[count_test] = I_f_u;
////									R_id_lb[count_test] = I_f_v;
////									count_test++;
////								}
//
//	}
//	if(count_intu > R_test_I_timecount && R_test_startflag)///////读取稳定的电压
//	{
//
//		//读取给定电压
//		if(R_f1_flag)
//		{
//			if(R_test_endflag_d)
//			{
//				R_test_endflag_d = 0;
//				R_test_halfstartflag_d = 1;
//				R_test_Ud_half =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_d_para_now));//////// 0.707*R_vdc_test_now*R_test_d_para_now;
//				R_test_Uq_half =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_q_para_now));//0.707*R_vdc_test_now*R_test_q_para_now;
//
//				R_u_half_f1 = _IQ19toF(_IQ19mpy(_IQ19(1.2245),_IQ19(R_test_Ud_half))) - _IQ19toF(_IQ19mpy(_IQ19(0.707),_IQ19(R_test_Uq_half)));
//
////				R_u_half_f1 = 1.2245*R_test_Ud_half- 0.707*R_test_Uq_half;
////				R_u_half_f1 = 0.8165*R_test_Ud_half- (0.707*R_test_Uq_half - 0.408*R_test_Ud_half);
//				R_i_half = _IQ19toF(iq_R_test_i_now);
//				R_vdc_half =  _IQ19toF(iq_R_vdc_test_now);
//			}
//			if(R_test_halfendflag_d)
//			{
//				R_test_halfendflag_d = 0;//
//				R_test_startflag = 0;///电阻测试完成
//				R_test_f1_endflag = 1;//
//				R_test_Ud =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_d_para_now));//////// 0.707*R_vdc_test_now*R_test_d_para_now;
//				R_test_Uq =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_q_para_now));//0.707*R_vdc_test_now*R_test_q_para_now;
//
//				R_u_f1 = _IQ19toF(_IQ19mpy(_IQ19(1.2245),_IQ19(R_test_Ud))) - _IQ19toF(_IQ19mpy(_IQ19(0.707),_IQ19(R_test_Uq)));
//
////				R_u_f1 = 1.2245*R_test_Ud- 0.707*R_test_Uq ;
////				R_u_f1 = 0.8165*R_test_Ud- (0.707*R_test_Uq - 0.408*R_test_Ud);////////
//				R_i = _IQ19toF(iq_R_test_i_now);;
//				R_vdc =  _IQ19toF(iq_R_vdc_test_now);
//			}
//		}
//		if(R_f2_flag)
//		{
//			if(R_test_endflag_d)
//			{
//				R_test_endflag_d = 0;
//				R_test_halfstartflag_d = 1;
//
//				R_test_Ud_half =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_d_para_now));//////// 0.707*R_vdc_test_now*R_test_d_para_now;
//				R_test_Uq_half =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_q_para_now));//0.707*R_vdc_test_now*R_test_q_para_now;
//
//				R_u_half_f2 =  _IQ19toF(_IQ19mpy(_IQ19(1.2245),_IQ19(R_test_Ud_half))) - _IQ19toF(_IQ19mpy(_IQ19(0.707),_IQ19(R_test_Uq_half)));
//
////				R_u_half_f2 =  0.8165*R_test_Ud_half- (0.707*R_test_Uq_half - 0.408*R_test_Ud_half);
//
//			}
//			if(R_test_halfendflag_d)
//			{
//				R_test_halfendflag_d = 0;//
//
//				R_test_endflag = 1;
//				R_test_Ud =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_d_para_now));//////// 0.707*R_vdc_test_now*R_test_d_para_now;
//				R_test_Uq =  _IQ19toF(_IQ19mpy(_IQ19mpy(_IQ19(0.707),iq_R_vdc_test_now),iq_R_test_q_para_now));//0.707*R_vdc_test_now*R_test_q_para_now;
//
//
//				R_u_f2 = _IQ19toF(_IQ19mpy(_IQ19(1.2245),_IQ19(R_test_Ud))) - _IQ19toF(_IQ19mpy(_IQ19(0.707),_IQ19(R_test_Uq)));//1.2245*R_test_Ud- 0.707*R_test_Uq ;
//
////				R_u_f2 = 0.8165*R_test_Ud- (0.707*R_test_Uq - 0.408*R_test_Ud);
//
//				R_test_startflag = 0;///电阻测试完成
//				R_f2_flag = 0;
//
//			}
//		}
//
//	}

}
void Rtest_curr(void)
{
//	////////////////////////////设定电流输出
//	if(R_test_startflag)
//	{
//		////DQ电流给定(Iw = 0,指定Iu,Iv = -Iu,根据DQ与Iuvw的关系式计算DQ）
//		ID_set =  _IQ24toF(_IQ24mpy(_IQ24(R_test_i),_IQ24(1.225)));//		ID_set = R_test_i*1.225;
//		IQ_set =  _IQ24toF(_IQ24mpy(_IQ24(R_test_i),_IQ24(-0.707)));//		IQ_set = -0.707*R_test_i;
////		iq_ID_set = _IQ24mpy(_IQ24(R_test_i),_IQ24(1.225));
////		iq_IQ_set = _IQ24mpy(_IQ24(R_test_i),_IQ24(-0.707));
//		R_D_cur_return = _IQtoIQ19(cur_DQ1.D.Vout);
//		R_Q_cur_return = _IQtoIQ19(cur_DQ1.Q.Vout);
//
//	}
}
/////////////////////////////////////////////////////////////////////////////L TEST///////////////////
void L_test_all(void)
{
//	if(L_readyflag == 1&&L_test_all_status == 2)
//	{
//		L_readyflag = 0;
//		L_test_formal_end = 1;////////////调用结束后置零
//		L_d_formal = L_measure;
//		L_q_formal = L_measure_q;
//	}
//	if(L_test_formal == 1)
//	{
//		L_test_formal = 0;
//		L_test_all_status = 2;
//		L_loc_startflag = 1;	///开始定位
//	}
//	if(L_test_fore_end == 1 )
//	{
//		L_test_formal = 1;
//		L_test_fore_end = 0;
//		///////////////估测电感结束，需要调用电流环，电流环关键参数置零
//		ID_set = 0;
//		IQ_set = 0;
//		D_per_unit = 0;
//		Q_per_unit = 0;
//	}
//
//	if(L_readyflag == 1&&L_test_all_status == 1)
//	{
//		/////将电感预估值赋给电流环
//		if(L_measure_q>L_measure)
//		{
//			cur_DQ1.LDs = L_measure*0.5;
//			cur_DQ1.LQs = cur_DQ1.LDs;
//		}
//		else
//		{
//			cur_DQ1.LDs = L_measure_q*0.5;
//			cur_DQ1.LQs = cur_DQ1.LDs;
//		}
//		cur_DQ1.init(&cur_DQ1);
//		////与测试结束，，开始正式定位和电感测试
//		L_readyflag = 0;
//		L_test_fore_end = 1;
//	}
//	if(L_test_fore == 1)
//	{
//		L_test_fore = 0;
//		L_test_flag = 1;
//		L_test_all_status = 1;
//		cur_test_flag = 0;////电流环不输出
//	}
//	L_test();
//	L_location(1);
}
void L_location(Uint16 dq)
{
//	if(dq == 1&&L_loc_status)////定位到D轴
//	{
//		ID_set = 5;////D轴电流
//		IQ_set = 0;
//	}
//	if(dq == 2&&L_loc_status)/////定位到Q轴
//	{
//		ID_set = 0;
//		IQ_set = 5;
//	}
//	if(L_location_count >= 65535)////计数
//		L_location_count = 0;
//	L_location_count ++;////////下溢中断计数
//	if(L_loc_startflag == 1)////定位开始
//	{
//		L_loc_startflag = 0;
//		L_location_count = 0;
//		L_loc_status = 1;///定位状态
//		L_loc_continueflag = 1;
//		cur_test_flag = 1;////电流环使能
//	}
//	if(L_location_count < L_loc_con_count && L_loc_continueflag)///持续状态
//	{
//		L_loc_pwmoutflag = 1;
//	}
//	if(L_location_count>=L_loc_con_count&&L_loc_continueflag)///持续状态结束
//	{
//		L_loc_continueflag = 0;
//		L_loc_pwmoutflag = 0;
//		L_loc_pauseflag = 1;
//		L_loc_count++;///计数加1，超过设定次数，结束定位
//		if(L_loc_count > 10)/////电流持续/停歇次数
//		{
//			L_loc_count = 0;
//			L_loc_endflag = 1;
//			L_loc_pauseflag = 0;
//		}
//	}
//	if(L_location_count>=L_loc_pause_count&&L_loc_pauseflag)///停歇状态结束
//	{
//		L_location_count = 0;
//		L_loc_continueflag = 1;
//		L_loc_pauseflag = 0;
//
//	}
//	if(L_loc_status)
//	{
//		Pwmout(L_loc_pwmoutflag);
//	}
//	if(L_loc_endflag == 1)///定位结束
//	{
//		ID_set = 0;
//		IQ_set = 0;
//		L_loc_status = 0;
//		cur_test_flag = 0;
//		L_loc_endflag = 0;
//		L_test_flag = 1;///开始电感测试
//	}
}
void pos_cal(void)
{
//	if(pos_status_flag)
//	{
//		float32 vi_p = 0;
//		vi_p = 1.2247*I_f_u /50.0;
//		position1.ID = _IQ24(vi_p);
//		vi_p = (0.707*I_f_u + 1.414*I_f_v) /50.0;
//		position1.IQ = _IQ24(vi_p);
//		vi_p = U_VDC / 537.0;
//		position1.vdc = _IQ24(vi_p);
//		PNCur(&position1);
//		Pwmout(position1.Switch);
//		DQout(_IQ24toF(position1.DOUT),_IQ24toF(position1.QOUT));
//		if(position1.FlagStart == 1)
//		{
//			position1.ADNum++;
//		}
//		else
//		{
//			position1.ADNum = 0;
//		}
//		if(position1.Finish == 1)
//		{
//			pos_status_flag = 0;
//			position1.Finish = 0;
//
//			L_static_sort_flag = 1;
//		}
//	}
}
float32   L_static_sort(void)
{
//	if(L_static_sort_flag == 1)
//	{
//		DINT;
//
//		Uint16  lm,ln;
//		float32  L_static_min;
//		for(lm = 0;lm < 36;lm ++)
//		{
//			L_static_ldata[lm][0] = sqrt(pow(_IQ24toF(position1.Record[lm][1]),2) + pow(_IQ24toF(position1.Record[lm][2]),2)) / \
//					                sqrt(pow(_IQ24toF(position1.Record[lm][3]),2) + pow(_IQ24toF(position1.Record[lm][4]),2));
//			L_static_ldata[lm][1] = _IQ24toF(position1.Record[lm][0]);
//			if(lm == 0)
//			{
//				L_static_min = L_static_ldata[0][0];
//				min_num = lm;
//			}
//			else
//			{
//				if(L_static_ldata[lm][0] < L_static_min)
//				{
//					L_static_min = L_static_ldata[lm][0];
//					min_num = lm;
//				}
//			}
//		}
//		if(min_num == 0)
//		{
//			if(L_static_ldata[1][0] > L_static_ldata[35][0])
//				min_angle = 357.5;
//			else
//				min_angle = 2.5;
//		}
//		else if(min_num == 35)
//		{
//			if(L_static_ldata[0][0] > L_static_ldata[34][0])
//				min_angle = 347.5;
//			else
//				min_angle = 352.5;
//		}
//		else
//		{
//			if(L_static_ldata[min_num-1][0] > L_static_ldata[min_num+1][0])
//				min_angle = (min_num )*10 + 2.5;
//			else
//				min_angle = (min_num )*10 - 2.5;
//		}
//
//		min_radian = min_angle *  2 * pi / 360.0;
//		///////////////////////////计算电感
//
//		L_measure = _IQ24toF(position1.Record[min_num][1])*U_VDC*0.707*T_para_perdigital*0.5/ \
//				   _IQ24toF(position1.Record[min_num][3]) / 50;
//		if((min_num + 9)>=36)
//			ln = min_num + 9 - 36;
//		else
//			ln = min_num + 9;
//		L_measure_q =  _IQ24toF(position1.Record[ln][2])*U_VDC*0.707*T_para_perdigital*0.5/ \
//				_IQ24toF(position1.Record[ln][4]) / 50;
////		L_static_min =  position1.Record[ln][2];
////		L_static_min =  _IQ24toF(position1.Record[ln][2]);
////		L_measure_q =  L_static_min*U_VDC*0.707*T_para_perdigital*0.5;
////		L_static_min = position1.Record[ln][4];
////		L_static_min = _IQ24toF(position1.Record[ln][4]);
////		L_measure_q =  L_measure_q / L_static_min / 50;
//
//
//		L_static_sort_flag = 0;///只执行一次
//		L_static_test_flag = 1;////静态测试标志
//
//		EINT;
//
//	}
//	return min_radian;
}
void L_static_test(void)
{
//	if(L_static_test_flag == 1)
//	{
//		L_static_test_statusflag = 1;
//		L_static_test_flag = 0;
//		L_test_flag = 1;
//	}
//	if(L_static_test_statusflag == 1)
//	{
//
//		L_test();
//	}
//
}
void L_static_init(void)
{
////	for(aa = 0;aa < 36;aa ++)
////		 for(bb = 0;bb < 5;bb ++)
////			 position1.Record[aa][bb] = 0;
//	 memset(position1.Record,0,sizeof(position1.Record));
//	 position1.coe = _IQ24(0.8);
//	 position1.vlevel = _IQ24(1);
//	 pos_status_flag = 0;
//	 L_static_sort_flag = 0;
//	 L_static_test_flag = 0;
//	 L_static_test_statusflag = 0;
//	 L_static_test_endflag = 0;
//	 min_angle = 0;
//	 min_radian = 0;
//	 min_num = 0;
}

void L_test(void)
{
//	if(count_intu >= 65535)
//		count_intu = 0;
//	count_intu ++;////////下溢中断计数
//	if(L_test_flag)
//	{
//		Ld_test_startflag = 1;////D轴电感测试
//		L_readyflag = 0;
//		L_test_status = 1;
//	}
//	if(pulse_plus_flagstart && L_test_pwmflag)///////正脉冲
//	{
//		I_per_pulse = fabs(I_f_u);
//		pulse_plus_count++;
//		pulse_plus_flagstart = 0;
//		pulse_plus_flagend = 1;//正脉冲结束
//	}
//	if(pulse_minus_pwmout_flag && L_test_pwmflag)///////////负脉冲
//	{
//		pulse_minus_count ++;
//		pulse_minus_pwmout_flag = 0;
//		pulse_minus_flagend = 1;//负脉冲结束
//	}
//	if(L_meas_startflag && L_test_pwmflag)//////////////电感测试
//	{
//		I_data[i_d] = fabs(I_f_u);
//		U_data[i_d] = U_VDC;
//		L_meas_count ++;
//		if(L_meas_count>=L_meas_continue_p_count)///////电感测试持续脉冲数量   一组测试结束
//		{
//			L_meas_startflag = 0;
//			L_test_pwmflag = 0;
//			L_meas_endflag = 1;
//			i_d++;
//		}
//	}
//	if(pulse_minus_flagend)//////////////////////////////////////负脉冲结束
//	{
//		pulse_minus_flagend = 0;
//		L_meas_flag = 1;////电感检测开始
//		count_intu = 0;///计数归零
//		L_test_pwmflag = 0;//Pwmout(0);
//
//		if(I_per_pulse > L_I_rated)
//			I_per_pulse = L_I_rated;
//		L_meas_p_count_all = L_I_rated/I_per_pulse;//脉冲总数，也决定了D的系数
//		if(L_meas_p_count_all<2)
//			L_meas_p_count_all = 2;
//		if(L_meas_p_count_all>10)
//			L_meas_p_count_all = 10;
//		L_meas_continue_p_count = 1;
//		D_per_unit = L_meas_p_count_all*0.08;
//		if(D_per_unit < 0.1)
//			D_per_unit = 0.1;
//	}
//	if(pulse_minus_pwmout_flag)
//	{
//		L_test_pwmflag = 1;//Pwmout(1);
//	}
//	if(pulse_minus_flagstart)////////////////////////////////负脉冲开始
//	{
//		L_test_idout = -0.1;//DQout(-0.1,0);
//		L_test_iqout = 0;
//		pulse_minus_flagstart = 0;
//		pulse_minus_pwmout_flag = 1;
//	}
//	if(pulse_plus_flagend)////////////////////////////////////正脉冲结束
//	{
//		pulse_plus_flagend = 0;
//		pulse_minus_flagstart = 1;///负脉冲开始
//		L_test_pwmflag = 0;//Pwmout(0);
//	}
//	if(pulse_plus_flagstart)/////////////////////////正脉冲开始
//	{
//		L_test_pwmflag = 1;//Pwmout(1);
//	}
//	if(Ld_test_startendflag)
//	{
//		L_test_pwmflag = 0;//Pwmout(0);
//		Ld_test_startendflag = 0;
//		pulse_plus_flagstart = 1;
//	}
//	if(Ld_test_startflag)/////////////////////////////////////////////电感开始检测
//	{
//		L_test_idout = 0.1;
//		L_test_iqout = 0;		//DQout(0.1,0);
//		L_test_flag = 0;
//		Ld_test_startflag = 0;
//		Ld_test_startendflag = 1;
//	}
//	if(pulse_plus_count >= 1)
//	{
//		pulse_plus_count = 0;
//	}
//	if(pulse_minus_count >= 1)
//	{
//		pulse_minus_count = 0;
//	}
//	if(L_meas_startflag)
//	{
//		L_test_pwmflag = 1;//Pwmout(1);
//	}
//	if(L_meas_flag)
//	{
//		if(L_static_test_statusflag == 1)
//		{
//			L_test_idout = D_per_unit * cos(min_radian);
//			L_test_iqout = D_per_unit * sin(min_radian);//DQout(0,Q_per_unit);
//		}
//		else
//		{
//			L_test_idout = D_per_unit;//DQout(D_per_unit,0);
//			L_test_iqout = 0;
//		}
//
//
//	}
//
//	if(L_meas_endflag && L_meas_flag)
//	{
//		L_meas_endflag = 0;//准备下一次测试
//		count_intu = 0;///计数归零，等待一段时间
//		L_meas_count = 0;//脉冲计数清零
//		L_test_pwmflag = 0;//Pwmout(0);
//	}
//	if(i_d >= 5)////电感测试结束
//	{
//		L_meas_flag = 0;
//		i_d = 0;
//		//计算电感
//		I_u = (I_data[1]+I_data[2]+I_data[3]+I_data[4])*0.25;//u相电流	避免用除法
//		I_measure = 1.2247*I_u;///电流没有补偿
//		U_vdc = (U_data[1]+U_data[2]+U_data[3]+U_data[4])*0.25;///总线电压
//		U_d =  0.707*U_vdc;
//
//		if(L_static_test_statusflag == 1)
//		{
//			L_measure = U_d*L_test_idout*L_meas_continue_p_count*T_para_perdigital/I_measure;
//		}
//		else
//			L_measure = U_d*D_per_unit*L_meas_continue_p_count*T_para_perdigital/I_measure;
//
//		Lq_test_startflag = 1;//////////////////////////////////////////q轴电感测试开始
//	}
//	if(count_intu > L_test_I_timecount && L_meas_flag)
//	{
//		L_meas_startflag = 1;//延时0.2s，可以下一次测试
//	}
//
////////////////////////////////////////////
//	if(pulse_plus_flagstart_q && L_test_pwmflag)//////////////////正脉冲
//	{
//		I_per_pulse = fabs(I_f_v);
//		pulse_plus_count_q++;
//		pulse_plus_flagstart_q = 0;
//		pulse_plus_flagend_q = 1;//正脉冲结束
//	}
//		//////////////////////
//	if(pulse_minus_pwmout_flag_q && L_test_pwmflag)///////////////////负脉冲
//	{
//		pulse_minus_count_q ++;
//		pulse_minus_pwmout_flag_q = 0;
//		pulse_minus_flagend_q = 1;//负脉冲结束
//	}
//		///////////////////////////////////////q轴电感测试
//	if(L_meas_startflag_q && L_test_pwmflag)
//	{
//		I_data[i_q] = I_f_u;//iu
//		I_data_q[i_q] = I_f_v;//iv
//		U_data[i_q] = U_VDC;//总线电压
//		L_meas_count_q ++;
//		if(L_meas_count_q>=L_meas_continue_p_count)///////电感测试持续脉冲数量   一组测试结束
//		{
//			L_meas_startflag_q = 0;
//			L_meas_endflag_q = 1;
//			i_q++;
//		}
//	}
//	if(pulse_minus_flagend_q)////////////////////////////////负脉冲结束
//	{
//		pulse_minus_flagend_q = 0;
//		L_meas_flag_q = 1;////检测开始
//		count_intu = 0;///计数归零
//		L_test_pwmflag = 0;//Pwmout(0);//关断脉冲输出
//
//		if(I_per_pulse > L_I_rated)
//			I_per_pulse = L_I_rated;
//		L_meas_p_count_all = L_I_rated/I_per_pulse;//脉冲总数
//		if(L_meas_p_count_all<2)
//			L_meas_p_count_all = 2;
//		if(L_meas_p_count_all>10)
//			L_meas_p_count_all = 10;
//		L_meas_continue_p_count = 1;///只打一次脉冲
//		Q_per_unit = L_meas_p_count_all*0.08;
//		if(Q_per_unit < 0.1)
//			Q_per_unit = 0.1;
//	}
//	if(pulse_minus_pwmout_flag_q)
//	{
//		L_test_pwmflag = 1;//Pwmout(1);//允许pwm输出
//	}
//	if(pulse_minus_flagstart_q)/////////////////////////////////负脉冲开始
//	{
//		L_test_idout = 0;
//		L_test_iqout = -0.2;//DQout(0,-0.1);
//		pulse_minus_flagstart_q = 0;
//		pulse_minus_pwmout_flag_q = 1;
//	}
//	if(pulse_plus_flagend_q)///////////////////////////////正脉冲结束
//	{
//		pulse_plus_flagend_q = 0;
//		pulse_minus_flagstart_q = 1;///负脉冲开始
//		L_test_pwmflag = 0;//Pwmout(0);//关断pwm		;
//	}
//	if(pulse_plus_flagstart_q)////////////////////////////正脉冲开始
//	{
//		L_test_pwmflag = 1;//Pwmout(1);//允许pwm输出
//	}
//	if(Lq_test_startendflag)
//	{
//		L_test_pwmflag = 0;//Pwmout(0);
//		Lq_test_startendflag = 0;
//		pulse_plus_flagstart_q = 1;
//	}
//	if(Lq_test_startflag)
//	{
//		L_test_idout = 0;
//		L_test_iqout = 0.2;//		DQout(0,0.1);
//		Lq_test_startflag = 0;
//		Lq_test_startendflag = 1;
//	}
//	if(pulse_plus_count_q >= 1)
//	{
//		pulse_plus_count_q = 0;
//	}
//	if(pulse_minus_count_q >= 1)
//	{
//		pulse_minus_count_q = 0;
//	}
//	////////////////////////////////////////////////////////////adc L measure
//	if(L_meas_flag_q)
//	{
//		if(L_static_test_statusflag == 1)
//		{
//			L_test_idout = Q_per_unit * cos(min_radian+1.57);
//			L_test_iqout = Q_per_unit * sin(min_radian+1.57);//DQout(0,Q_per_unit);
//		}
//		else
//		{
//			L_test_idout = 0;
//			L_test_iqout = Q_per_unit;//DQout(0,Q_per_unit);
//		}
//
//	}
//	if(L_meas_startflag_q)
//	{
//		L_test_pwmflag = 1;//Pwmout(1);//允许pwm输出
//	}
//	if(L_meas_endflag_q && L_meas_flag_q)
//	{
//		L_meas_endflag_q = 0;//准备下一次测试
//		count_intu = 0;///计数归零，等待一段时间
//		L_meas_count_q = 0;//脉冲计数清零
//		L_test_pwmflag = 0;//Pwmout(0);//关断pwm
//	}
//	if(i_q >= 5)////电感测试结束
//	{
//		L_meas_flag_q = 0;
//		i_q = 0;
//		//计算电感
//		I_u = (I_data[1]+I_data[2]+I_data[3]+I_data[4])*0.25;
//		I_v = (I_data_q[1]+I_data_q[2]+I_data_q[3]+I_data_q[4])*0.25;
//		I_measure_q = 0.707*I_u + 1.414*I_v;//电流没有补偿
//		U_vdc = (U_data[1]+U_data[2]+U_data[3]+U_data[4])*0.25;///总线电压
//		U_q = 0.707*U_vdc;
//		if(L_static_test_statusflag == 1)
//		{
////			L_measure =   U_q * L_test_idout * T_para_perdigital / I_u/ 1.2247;
//			L_measure_q = U_q * L_test_iqout * L_meas_continue_p_count*T_para_perdigital / I_measure_q;
//		}
//		else
//			L_measure_q = U_q*Q_per_unit*L_meas_continue_p_count*T_para_perdigital/I_measure_q;//
//
//		L_readyflag = 1;
//	}
//	if(count_intu > L_test_I_timecount && L_meas_flag_q)
//	{
//		L_meas_startflag_q = 1;//延时0.2s，可以下一次测试
//	}
//	/////////////////////////////////////////////////////////////DQ out
//	if(L_test_status == 1)
//	{
//		DQout(L_test_idout,L_test_iqout);
//		Pwmout(L_test_pwmflag);
//	}
//	if(L_test_status == 1&&L_readyflag == 1)
//	{
//		L_test_idout = 0;
//		L_test_iqout = 0;
//		L_test_pwmflag = 0;
//		L_test_status = 0;
//		if(L_static_test_statusflag == 1)
//		{
//			L_static_test_statusflag = 0;
//			L_static_test_endflag = 1;
//		}
//	}

}

void Delay_boot()
{
//	Uint16 mm,nn;
//	for(mm = 0;mm < 600;mm++)
//		for(nn = 0;nn < 15000;nn++)
//			;
}
void DQout(float32 Dperunit,float32 Qperunit)
{
	        _iq Va,Vb,Vc,t1,t2,Diqvalue,Qiqvalue,Ta,Tb,Tc;
		    Uint32 Sector = 0;  // Sector is treated as Q0 - independently with global Q
		    int16 MPeriod;
		    int32 Tmp;
		    int16 c1,c2,c3;
		    Diqvalue = _IQ(Dperunit);
		    Qiqvalue = _IQ(Qperunit);

		// Inverse clarke transformation
		    Va = Qiqvalue;
		    Vb = _IQmpy(_IQ(-0.5),Qiqvalue) + _IQmpy(_IQ(0.8660254),Diqvalue);  // 0.8660254 = sqrt(3)/2
		    Vc = _IQmpy(_IQ(-0.5),Qiqvalue) - _IQmpy(_IQ(0.8660254),Diqvalue);  // 0.8660254 = sqrt(3)/2

		// 60 degree Sector determination
		    if (Va>_IQ(0))
		       Sector = 1;
		    if (Vb>_IQ(0))
		       Sector = Sector + 2;
		    if (Vc>_IQ(0))
		       Sector = Sector + 4;

		// X,Y,Z (Va,Vb,Vc) calculations
		    Va = Qiqvalue;                                                       // X = Va
		    Vb = _IQmpy(_IQ(0.5),Qiqvalue) + _IQmpy(_IQ(0.8660254),Diqvalue);   // Y = Vb
		    Vc = _IQmpy(_IQ(0.5),Qiqvalue) - _IQmpy(_IQ(0.8660254),Diqvalue);   // Z = Vc

		    if (Sector==0)  // Sector 0: this is special case for (Ualpha,Ubeta) = (0,0)
		    {
		       Ta = _IQ(0.5);
		       Tb = _IQ(0.5);
		       Tc = _IQ(0.5);
		    }
		    if (Sector==1)  // Sector 1: t1=Z and t2=Y (abc ---> Tb,Ta,Tc)
		    {
		       t1 = Vc;
		       t2 = Vb;
		       Tb = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // tbon = (1-t1-t2)/2
		       Ta = Tb+t1;                             // taon = tbon+t1
		       Tc = Ta+t2;                             // tcon = taon+t2
		    }
		    else if (Sector==2)  // Sector 2: t1=Y and t2=-X (abc ---> Ta,Tc,Tb)
		    {
		       t1 = Vb;
		       t2 = -Va;
		       Ta = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // taon = (1-t1-t2)/2
		       Tc = Ta+t1;                             // tcon = taon+t1
		       Tb = Tc+t2;                             // tbon = tcon+t2
		    }
		    else if (Sector==3)  // Sector 3: t1=-Z and t2=X (abc ---> Ta,Tb,Tc)
		    {
		       t1 = -Vc;
		       t2 = Va;
		       Ta = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // taon = (1-t1-t2)/2
		       Tb = Ta+t1;                             // tbon = taon+t1
		       Tc = Tb+t2;                             // tcon = tbon+t2
		    }
		    else if (Sector==4)  // Sector 4: t1=-X and t2=Z (abc ---> Tc,Tb,Ta)
		    {
		       t1 = -Va;
		       t2 = Vc;
		       Tc = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // tcon = (1-t1-t2)/2
		       Tb = Tc+t1;                             // tbon = tcon+t1
		       Ta = Tb+t2;                             // taon = tbon+t2
		    }
		    else if (Sector==5)  // Sector 5: t1=X and t2=-Y (abc ---> Tb,Tc,Ta)
		    {
		       t1 = Va;
		       t2 = -Vb;
		       Tb = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // tbon = (1-t1-t2)/2
		       Tc = Tb+t1;                             // tcon = tbon+t1
		       Ta = Tc+t2;                             // taon = tcon+t2
		    }
		    else if (Sector==6)  // Sector 6: t1=-Y and t2=-Z (abc ---> Tc,Ta,Tb)
		    {
		       t1 = -Vb;
		       t2 = -Vc;
		       Tc = _IQmpy(_IQ(0.5),(_IQ(1)-t1-t2));      // tcon = (1-t1-t2)/2
		       Ta = Tc+t1;                             // taon = tcon+t1
		       Tb = Ta+t2;                             // tbon = taon+t2
		    }

		// Convert the unsigned GLOBAL_Q format (ranged (0,1)) -> signed GLOBAL_Q format (ranged (-1,1))
		    Ta = _IQmpy(_IQ(2.0),(Ta-_IQ(0.5)));
		    Tb = _IQmpy(_IQ(2.0),(Tb-_IQ(0.5)));
		    Tc = _IQmpy(_IQ(2.0),(Tc-_IQ(0.5)));

		    c1 = _IQtoIQ15(Ta);
		    c2 = _IQtoIQ15(Tb);
		    c3 = _IQtoIQ15(Tc);

//		    PeriodMax = 7500;//150*1000000* 0.001/20/2;  // Perscaler X1 (T1), ISR period = T x 1
//		    MfuncPeriod = 0x7fff;
//
//		    // Compute the timer period (Q0) from the period modulation input (Q15)
//		    Tmp = (int32)PeriodMax*(int32)MfuncPeriod;           // Q15 = Q0*Q15
//		    MPeriod = (int16)(Tmp>>16) + (int16)(PeriodMax>>1);     // Q0 = (Q15->Q0)/2 + (Q0/2)
//		    EvaRegs.T1PR = MPeriod;
		     MPeriod = EvaRegs.T1PR;
		    // Compute the compare 1 (Q0) from the PWM 1&2 duty cycle ratio (Q15)
		    Tmp = (int32)MPeriod*(int32)c1;                    // Q15 = Q0*Q15
//		    comptmp1 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);
		    EvaRegs.CMPR1 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);    // Q0 = (Q15->Q0)/2 + (Q0/2)
		    // Compute the compare 2 (Q0) from the PWM 3&4 duty cycle ratio (Q15)
		    Tmp = (int32)MPeriod*(int32)c2;                   // Q15 = Q0*Q15
//		    comptmp2 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);
		    EvaRegs.CMPR2 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);   // Q0 = (Q15->Q0)/2 + (Q0/2)
		    // Compute the compare 3 (Q0) from the PWM 5&6 duty cycle ratio (Q15)
		    Tmp = (int32)MPeriod*(int32)c3;                   // Q15 = Q0*Q15
//		    comptmp3 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);
		    EvaRegs.CMPR3 = (int16)(Tmp>>16) + (int16)(MPeriod>>1);   // Q0 = (Q15->Q0)/2 + (Q0/2)
}


void Init_Gpio(void)
{
	  EALLOW;

	  GpioMuxRegs.GPAMUX.all |= 0x003f;//0000 0000 0011 1111,PWM 1-6 pins
	  GpioMuxRegs.GPBMUX.all |= 0x003f;//0000 0000 0011 1111,PWM 7-12 pins
	  GpioMuxRegs.GPFMUX.all |= 0x0030;//SCIA
	  GpioMuxRegs.GPGMUX.all |= 0x0030;//SCIB

	  GpioMuxRegs.GPADIR.all |= 0xE000;
	  GpioMuxRegs.GPBDIR.bit.GPIOB12 = 1;
	  GpioMuxRegs.GPBDIR.bit.GPIOB13 = 1;
	  GpioMuxRegs.GPBDIR.bit.GPIOB14 = 1;
	  GpioMuxRegs.GPDDIR.bit.GPIOD1 = 1;
	  GpioMuxRegs.GPDDIR.bit.GPIOD6 = 1;
	  GpioMuxRegs.GPEDIR.bit.GPIOE0 = 1;
	//  GpioMuxRegs.GPBQUAL.bit.QUALPRD = 0;
	  EDIS;
	  GpioDataRegs.GPADAT.bit.GPIOA13=1;    //SD 电阻继电器断开，缓冲电阻
	  GpioDataRegs.GPADAT.bit.GPIOA14=1;    //PWM输出需要
	  GpioDataRegs.GPDDAT.bit.GPIOD1=1;     //pwm输出关断
//	  GpioDataRegs.GPDDAT.bit.GPIOD1=0;     //pwm输出打开	20181206
	  GpioDataRegs.GPEDAT.bit.GPIOE0=1;     //FAN 风扇吸合

}
void Pwmout(Uint16 enableflag)
{
	if(enableflag == 1)
	{
		GpioDataRegs.GPDDAT.bit.GPIOD1 = 0;/////pwm输出
	}
	else if(enableflag == 0)
	{
		GpioDataRegs.GPDDAT.bit.GPIOD1 = 1;////pwm关断
	}
}
void L_test_init()
{
//	Ld_test_startflag = 0;  	Ld_test_startendflag = 0;	Lq_test_startflag = 0;	Lq_test_startendflag = 0;
//	pulse_minus_flagstart = 0;	pulse_minus_flagend = 0;	pulse_plus_flagend = 0;	pulse_plus_flagstart = 0;
//	pulse_plus_flagstart_q = 0;	pulse_minus_flagstart_q = 0;	pulse_plus_flagend_q = 0;
//	L_meas_startflag_q = 0;	L_meas_endflag_q = 0;
//	pulse_minus_flagend_q = 0;	pulse_minus_flagend_q = 0;	pulse_init_endflag = 0;	pulse_init_startflag = 0;
//	pulse_plus_count = 0;	pulse_minus_count = 0;	pulse_minus_count_q = 0;	pulse_plus_count_q = 0;
//	pulse_minus_data = 0;	pulse_plus_data = 0;	adc_wait_count = 0;
////	pwm_out_flag = 0;
////	pwm_out_flag_q = 0;
//	adc_rel_data = 0;	adc_rel_data_q = 0;
//	L_meas_endflag = 0;  	L_meas_flag = 0;	L_meas_flag_q = 0;
//	L_meas_startflag = 0;	L_measure = 0;  	L_measure_q = 0;
//	L_meas_count = 0;   	L_meas_count_q = 0;	I_data_avg = 0;
//	I_measure = 0;
//	pulse_count_dq = 1;
//	L_test_flag = 0;///////L test flag
//	L_I_rated = 35.0;///taiyuan电机额定电流
//	pulse_init_startflag = 1;////零点采样标志
//	L_test_flag = 0;///////////电感自动测试开始
//	L_test_status = 0;
//	adsample_status = 0;
//	L_test_I_time = 0.1;/////电感测试时间0.1秒
//	L_test_I_timecount = L_test_I_time*75000000/EvaRegs.T1PR;///电感测试电流持续的中断次数
//
////	T_para_perdigital = 2*EvaRegs.T1PR/75000000.0;//每个周期0.333;//单位ms 1/3 1/载波频率
//	T_para_perdigital = 2*EvaRegs.T1PR/150000000.0;//每个周期0.333;//单位ms 1/3 1/载波频率
//	U_vdc_per = 1000.0/4095.0;////每个数字量对应的电压
//
//	L_meas_continue_p_count = 1;
//	D_per_unit = 0;   Q_per_unit = 0;
//	count_intu = 0;////下溢中断计数
//	L_readyflag = 0;
//	L_test_idout = 0;              L_test_iqout = 0;
//	pulse_minus_pwmout_flag = 0;   pulse_minus_pwmout_flag_q = 0;
//	L_loc_startflag = 0;   L_loc_endflag = 0;    L_loc_continueflag = 0;   L_loc_pauseflag = 0;
//	L_loc_pwmoutflag = 0;
//	L_loc_con_count = 0.5*75000000/EvaRegs.T1PR;///电感测试电流持续的中断次数
//	L_loc_pause_count = 0.8*75000000/EvaRegs.T1PR;///电感测试电流持续的中断次数
//	L_loc_count = 0;     L_loc_status= 0;
//	L_test_fore = 0;     L_test_formal = 0;     L_test_fore_end = 0;     L_test_formal_end = 0;   L_test_all_status = 0;
}


///////////////////////////////////////////////////////////////////////////////////////////AD /////////////////////////
void AD_init(void)
{
	ad_run_flag = 0;	 ad_zero_flag = 0;
	ad_data_u = 0; ad_data_uu = 0; ad_data_v = 0; ad_data_vv = 0; ad_data_resv1 = 0; ad_data_resv2 = 0; ad_data_resv3 = 0; ad_data_vdc = 0;
	ad_ref_u_last = 0;  ad_ref_uu_last = 0;  ad_ref_v_last = 0;  ad_ref_vv_last = 0;
	ad_ref_u_now = 0;   ad_ref_uu_now = 0;   ad_ref_v_now = 0;   ad_ref_vv_now = 0;
	iq_ad_ref_u_final = _IQ19(2048); iq_ad_ref_uu_final = _IQ19(2048); iq_ad_ref_v_final = _IQ19(2048); iq_ad_ref_vv_final = _IQ19(2048);
	ad_ref_u_final = 2048; ad_ref_uu_final = 2048; ad_ref_v_final = 2048; ad_ref_vv_final = 2048;
	ad_filter_para = 0.01;

	addata0 = 0;  addata1 = 0;  addata2 = 0;  addata3 = 0;  addata4 = 0;
	addata5 = 0;  addata6 = 0;  addata7 = 0;  addata8 = 0;  addata9 = 0;
	addata10 = 0;  addata11 = 0;  addata12 = 0;  addata13 = 0;  addata14 = 0;  addata15 = 0;
	addata20 = 0;  addata21 = 0;  addata22 = 0;  addata23 = 0;  addata24 = 0;  addata25 = 0;
	addata26 = 0;  addata27 = 0;
	iq_u_now = _IQ19(0);   iq_u_last = _IQ19(0);
	iq_uu_now = _IQ19(0);   iq_uu_last = _IQ19(0);
	iq_v_now = _IQ19(0);   iq_v_last = _IQ19(0);
	iq_vv_now = _IQ19(0);   iq_vv_last = _IQ19(0);
	iq_last_p = _IQ19(0.99);  iq_new_p = _IQ19(0.01);
	P_i_u_adjust = 4.312;  P_i_v_adjust = 4.3648;
	Flag_i_u_adjust = 0;     Flag_i_v_adjust = 0;

	I_range = 50;///taiyuan //66;//beijign//
	P_vdc_resolution = 0.5449;//taiyuan//0.3398;//beijing//

	P_i_resolution = I_range/2048.0;///电流大量程
	P_i_resolution_small = I_range/2048.0/P_i_u_adjust;///电流小量程
	I_f_u = 0;               I_f_v = 0;
	iq_P_i_u_adjust = _IQ19(P_i_u_adjust);
	iq_P_i_v_adjust = _IQ19(P_i_v_adjust);
	iq_P_i_resolution = _IQ19(P_i_resolution);
	iq_P_i_resolution_small = _IQ19(P_i_resolution_small);
	iq_P_vdc_resolution  = _IQ19(P_vdc_resolution);
	P_inttoiq = pow(2,19);
	P_inttoiq_13 = pow(2,13);
	P_inttoiq_15 = pow(2,15);
	upper_limit = 3000;	 lower_limit = 1200;
	iq_upper_limit = _IQ19(upper_limit);	 iq_lower_limit = _IQ19(lower_limit);
	AD_adjcal_startflag = 0;  AD_adjcal_endflag = 0;
}
void AD_test()
{
	////处理比较中断数据
	I_adsample_cal_comp();
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 0)///等待ad转换完成
		;
	read_addata();
	if(ad_run_flag == 0)
	{
		InitAdc_2nd();///init 2nd ad channel
		AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
		while(AdcRegs.ADCST.bit.INT_SEQ1 == 1)
			;
		AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;////reset seq1
		AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1;///软件中断启动AD转换
		//二次AD转换期间处理一次AD的数据
		iq_ad_data_u = (addata0 +addata1 + addata2 + addata3)*P_inttoiq_13;
		iq_ad_data_v = (addata4 +addata5 + addata6 + addata7)*P_inttoiq_13;
		iq_ad_data_vv =  (addata8 +addata9 + addata10 + addata11)*P_inttoiq_13;
		iq_ad_data_uu =  (addata12 +addata13 + addata14 + addata15)*P_inttoiq_13;

		iq_u_now =_IQ19mpy(iq_new_p,iq_ad_data_u) + _IQ19mpy(iq_last_p,iq_u_last);
		iq_u_last = iq_u_now;
		ad_ref_u_now = _IQ19toF(iq_u_now);
		iq_uu_now =_IQ19mpy(iq_new_p,iq_ad_data_uu) + _IQ19mpy(iq_last_p,iq_uu_last);
		iq_uu_last = iq_uu_now;
		ad_ref_uu_now = _IQ19toF(iq_uu_now);
		iq_v_now =_IQ19mpy(iq_new_p,iq_ad_data_v) + _IQ19mpy(iq_last_p,iq_v_last);
		iq_v_last = iq_v_now;
		ad_ref_v_now = _IQ19toF(iq_v_now);
		iq_vv_now =_IQ19mpy(iq_new_p,iq_ad_data_vv) + _IQ19mpy(iq_last_p,iq_vv_last);
		iq_vv_last = iq_vv_now;
		ad_ref_vv_now = _IQ19toF(iq_vv_now);
		/////比较中断零点滤波
		iq_ad_data_u_comp = addata24*P_inttoiq_15;
		iq_ad_data_v_comp = addata25*P_inttoiq_15;
		iq_u_now_comp =_IQ19mpy(iq_new_p,iq_ad_data_u_comp) + _IQ19mpy(iq_last_p,iq_u_last_comp);
		iq_u_last_comp = iq_u_now_comp;
		iq_v_now_comp =_IQ19mpy(iq_new_p,iq_ad_data_v_comp) + _IQ19mpy(iq_last_p,iq_v_last_comp);
		iq_v_last_comp = iq_v_now_comp;

		ad_zero_flag = 1;
	}
	else
	{
		//////二次启动AD转换
		InitAdc_2nd();///init 2nd ad channel
		AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
		while(AdcRegs.ADCST.bit.INT_SEQ1 == 1)
			;
		AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;////reset seq1
		AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1;///软件中断启动AD转换
		//二次AD转换期间处理一次AD的数据

		iq_ad_data_u = (addata0 +addata1 + addata2 + addata3)*P_inttoiq_13;
		iq_ad_data_v = (addata4 +addata5 + addata6 + addata7)*P_inttoiq_13;
		iq_ad_data_vv =  (addata8 +addata9 + addata10 + addata11)*P_inttoiq_13;
		iq_ad_data_uu =  (addata12 +addata13 + addata14 + addata15)*P_inttoiq_13;

		if(ad_zero_flag)
		{
			iq_ad_ref_u_final = iq_u_now;
			iq_ad_ref_v_final = iq_v_now;
			iq_ad_ref_vv_final = iq_vv_now;
			iq_ad_ref_uu_final = iq_uu_now;

			iq_ad_ref_u_final_comp = iq_u_now_comp;
			iq_ad_ref_v_final_comp = iq_v_now_comp;

			ad_zero_flag = 0;
		}
	}

	I_adsample_cal();///大小通道切换
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 0)///等待二次ad转换完成
		;
	read_addata2();//读取二次AD数据
	ad_data_vdc = (addata20 + addata21 + addata22 + addata23)>>6;
//	iq_U_VDC = _IQ19mpy(iq_P_vdc_resolution,ad_data_vdc<<3);///_IQ16toIQ19
//	U_VDC = iq_U_VDC>>3;///_IQ19toIQ16
	U_VDC = _IQ19mpy(iq_P_vdc_resolution,ad_data_vdc);///_IQ16toIQ19

	iq_VDC = U_VDC*P_inttoiq;
	InitAdc_1st();///AD第一次转换初始化
}
void AD_compU(void)
{
	AdcRegs.ADCMAXCONV.all = 0x0000;        // 一个通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x1;  // U相
	AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 1)
		;
	AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;////reset seq1
	AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1;///软件中断启动AD转换
	InitAdc_1st();///AD第一次转换初始化
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 0)///等待二次ad转换完成
		;
	////read data
	addata24 =   AdcRegs.ADCRESULT0 ;
}
void AD_compV(void)
{
	AdcRegs.ADCMAXCONV.all = 0x0000;        // 一个通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x9;  // V相
	AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 1)
		;
	AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;////reset seq1
	AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1;///软件中断启动AD转换
	InitAdc_1st();///AD第一次转换初始化
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 0)///等待二次ad转换完成
		;
	////read data
	addata25 =   AdcRegs.ADCRESULT0 ;
}
void AD_compW(void)
{
	AdcRegs.ADCMAXCONV.all = 0x0001;        // 八个通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x1;  // 过采样，连续采样4次
	AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x9;

	AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;       // Clear INT SEQ1 bit
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 1)
		;
	AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;////reset seq1
	AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 1;///软件中断启动AD转换
	/////等待处理的过程中初始化AD，AD的第一次初始化，为周期和下溢中断做准备
	InitAdc_1st();///AD第一次转换初始化
	while(AdcRegs.ADCST.bit.INT_SEQ1 == 0)///等待二次ad转换完成
		;
	////read data
	addata26 =   AdcRegs.ADCRESULT0 ;
	addata27 =   AdcRegs.ADCRESULT1 ;
}
void I_adsample_cal_comp(void)///电流满（大）量程计算
{
	iq_ad_data_u_comp = addata24*P_inttoiq_15;
	iq_ad_data_v_comp = addata25*P_inttoiq_15;
	iq_ad_data_wu_comp = addata26*P_inttoiq_15;
	iq_ad_data_wv_comp = addata27*P_inttoiq_15;

	iq_I_f_u_comp = _IQ19mpy((iq_ad_ref_u_final_comp- iq_ad_data_u_comp),iq_P_i_resolution);
	iq_I_f_v_comp = _IQ19mpy(((iq_ad_ref_v_final_comp- iq_ad_data_v_comp)),iq_P_i_resolution);
	iq_I_f_wu_comp = _IQ19mpy((iq_ad_ref_u_final_comp- iq_ad_data_wu_comp),iq_P_i_resolution);
	iq_I_f_wv_comp = _IQ19mpy(((iq_ad_ref_v_final_comp- iq_ad_data_wv_comp)),iq_P_i_resolution);
	iq_I_f_w_comp = -iq_I_f_wu_comp - iq_I_f_wv_comp;

}
void I_adsample_cal()
{
	if(iq_ad_data_uu<=iq_lower_limit || iq_ad_data_uu>=iq_upper_limit)///u超出小量程百分之七十  大量程
		iq_I_f_u = _IQ19mpy((iq_ad_ref_u_final- iq_ad_data_u),iq_P_i_resolution);
	else/////小量程
		iq_I_f_u = _IQ19mpy((iq_ad_ref_uu_final- iq_ad_data_uu),iq_P_i_resolution_small);
	if(iq_ad_data_vv<=iq_lower_limit || iq_ad_data_vv>=iq_upper_limit)//v超出小量程百分之七十  大量程
		iq_I_f_v = _IQ19mpy(((iq_ad_ref_v_final- iq_ad_data_v)),iq_P_i_resolution);
	else////v小量程
		iq_I_f_v = _IQ19mpy(((iq_ad_ref_vv_final- iq_ad_data_vv)),iq_P_i_resolution_small);

	I_f_u = _IQ19toF(iq_I_f_u);
	I_f_v = _IQ19toF(iq_I_f_v);
}
void AD_adjust_cal()
{
	AD_adjust_cal_u = _IQ19toF(_IQ19div((ad_ref_uu_final - ad_data_uu)*P_inttoiq,(ad_ref_u_final - ad_data_u)*P_inttoiq));
	AD_adjust_cal_v = _IQ19toF(_IQ19div((ad_ref_vv_final - ad_data_vv)*P_inttoiq,(ad_ref_v_final - ad_data_v)*P_inttoiq));
}
void read_addata(void)
{
	addata0 =   AdcRegs.ADCRESULT0 ;
	addata1 =   AdcRegs.ADCRESULT1 ;
	addata2 =   AdcRegs.ADCRESULT2 ;
	addata3 =   AdcRegs.ADCRESULT3 ;
	addata4 =   AdcRegs.ADCRESULT4 ;
	addata5 =   AdcRegs.ADCRESULT5 ;
	addata6 =   AdcRegs.ADCRESULT6 ;
	addata7 =   AdcRegs.ADCRESULT7 ;
	addata8 =   AdcRegs.ADCRESULT8 ;
	addata9 =   AdcRegs.ADCRESULT9 ;
	addata10 = AdcRegs.ADCRESULT10 ;
	addata11 = AdcRegs.ADCRESULT11 ;
	addata12 = AdcRegs.ADCRESULT12 ;
	addata13 = AdcRegs.ADCRESULT13 ;
	addata14 = AdcRegs.ADCRESULT14 ;
	addata15 = AdcRegs.ADCRESULT15 ;
}
void read_addata2(void)
{
	addata20 =   AdcRegs.ADCRESULT0 ;
	addata21 =   AdcRegs.ADCRESULT1 ;
	addata22 =   AdcRegs.ADCRESULT2 ;
	addata23 =   AdcRegs.ADCRESULT3 ;
}

void InitAdc_1st(void)
{
	AdcRegs.ADCMAXCONV.all = 0x000F;
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x1;  // 过采样，连续采样4次
	AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x1;
	AdcRegs.ADCCHSELSEQ1.bit.CONV02 = 0x1;
	AdcRegs.ADCCHSELSEQ1.bit.CONV03 = 0x1;
}
void InitAdc_2nd(void)
{
	AdcRegs.ADCMAXCONV.all = 0x0003;        // 四个通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x0;  // 过采样，连续采样4次
	AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x0;
	AdcRegs.ADCCHSELSEQ1.bit.CONV02 = 0x0;
	AdcRegs.ADCCHSELSEQ1.bit.CONV03 = 0x0;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////
void Reset_f(void)
{
	 char ii = 0;
	 GpioDataRegs.GPADAT.bit.GPIOA14 = 0;
	 for(ii = 0;ii < 50;ii++);
	 GpioDataRegs.GPADAT.bit.GPIOA14 = 1;
	 GpioDataRegs.GPDDAT.bit.GPIOD1 = 0;
	 EvaRegs.EVAIFRA.all = EvaRegs.EVAIFRA.all & 0x0001;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////FLASH
void vol_wr_flash()
{
//	Uint16 vi;
//    DINT;
//    flashwr1.init(&flashwr1);
//    flashwr1.read_all(&flashwr1);//读取所有参数
//    flashwr1.type = 0;
//    for(vi = 0; vi < 96; vi ++)
//    {
//    	flashwr1.data_f_write  = VC_V_big[vi];//要写入的值
//    	flashwr1.shift  = 100 + vi;//指定偏移地址
//    	flashwr1.wr_f(&flashwr1);//修改参数
//    }
//    flashwr1.wr_flash(&flashwr1);
//
//    EINT;          // Enable Global interrupt INTM
//    ERTM;
}
void vol_rd_flash()
{
//	Uint16 vi;
//    flashwr1.type = 0;
//    for(vi = 0; vi < 96; vi ++)
//    {
//    	flashwr1.shift = 100 + vi;//指定偏移地址
//    	flashwr1.read_f(&flashwr1);//
//    	if(flashwr1.Status == 0)
//    		VC_V_big[vi] = flashwr1.data_f_read;//读取参数返回值
//    }
}
float32 vol_query(float32 a)//
{
////	Uint16 v_num = 0;
////	float32 v_f_num = 0;
////	float32 v_f_part = 0;
////	float32 v_return = 0;
////	_iq19  v_f_part_iq;
//	v_f_num = _IQ19toF(_IQ19mpy(_IQ19(fabs(a)),iq_VC_per_mpy));
//	v_num = v_f_num;
//	v_f_part = v_f_num-v_num;
//	v_f_part_iq = _IQ19(v_f_part);
//	if(v_f_num<1)
//		v_return = _IQ19toF(_IQ19mpy(_IQ19mpy(v_f_part_iq , _IQ19(VC_V_big[0][0])),iq_VC_unification_p) + _IQ19mpy(v_f_part_iq , _IQ19(VC_V_big[0][1])));
//	else
//		v_return = _IQ19toF(_IQ19mpy(_IQ19(VC_V_big[v_num-1][0]),iq_VC_unification_p))\
//		+ _IQ19toF(_IQ19mpy(v_f_part_iq , (_IQ19mpy((_IQ19(VC_V_big[v_num][0])-_IQ19(VC_V_big[v_num-1][0])),iq_VC_unification_p) + _IQ19(VC_V_big[v_num][1])-_IQ19(VC_V_big[v_num-1][1]))))\
//		+ VC_V_big[v_num-1][1] ;
//
//	if(a>0)
//		return v_return;
//	else
//		return -1 * v_return;
}
float32 vol_query_small(float32 a)
{
////	Uint16 v_num = 0;
////	float32 v_f_num = 0;
////	float32 v_f_part = 0;
////	float32 v_return = 0;
////	_iq19  v_f_part_iq;
//	v_f_num =  _IQ19toF(_IQ19mpy(_IQ19(fabs(a)),iq_VC_per_small_mpy));
//	v_num = v_f_num;
//	v_f_part = v_f_num-v_num;
//	v_f_part_iq = _IQ19(v_f_part) ;
//	if(a>=0)
//	{
//		if(v_f_num>47)
////			v_return = VC_V_small[95] +  v_f_part*(VC_V_small[95]-VC_V_small[94]);
//			v_return = _IQ19toF(_IQ19mpy((_IQ19(VC_V_small[95]) +  _IQ19mpy(v_f_part_iq,(_IQ19(vol_query(_IQ19toF(_IQ19mpy(iq_01,iq_VC_I_rated))))-_IQ19(VC_V_small[95])))),iq_VC_unification_p));
//		else
//			v_return = _IQ19toF(_IQ19mpy((_IQ19(VC_V_small[48 + v_num]) + _IQ19mpy(v_f_part_iq,(_IQ19(VC_V_small[48 +v_num+1])-_IQ19(VC_V_small[48 +v_num])))),iq_VC_unification_p));
//	}
//	else
//		v_return = _IQ19toF(_IQ19mpy((_IQ19(VC_V_small[48 - v_num]) + _IQ19mpy(v_f_part_iq,(_IQ19(VC_V_small[48 - v_num - 1])-_IQ19(VC_V_small[48 - v_num])))),iq_VC_unification_p));
//	return v_return;
}
float32 vol_v_query(float32 a)///查询补偿电压
{
////	VC_unification_p = U_VDC * VC_unification_cal;
//	iq_VC_unification_p = _IQ19mpy(iq_VC_unification_cal,U_VDC*P_inttoiq);
//	float32 vc_v = 0;
//	if(a>VC_I_rated )
//		a = VC_I_rated;
//	if(a<-VC_I_rated)
//		a = -VC_I_rated;
////	if(fabs(a)< 0.1*VC_I_rated)
//	if(fabs(a)< _IQ19toF(_IQ19mpy(iq_01,iq_VC_I_rated)))
//		vc_v = vol_query_small(a);
//	else
//		vc_v = vol_query(a);
//	return vc_v;

}
