自平衡小车程序

#include "DSP281x_Device.h" // Headerfile Include File

#include "DSP281x_Examples.h" //

#define HIST 16

unsigned int k=0;

static float adc_current_samples[6][HIST];//定义行为6，列为16的二维数组static float adclo=0.0;

static Uint16 totsamples_0;

unsigned int count;

#define OCRMAX 1023

unsigned int pwm;

static float left_cof=1.00;

static float right_cof=1.00;

struct gyro_filter pitch_filter;

static Uint16 mode=0x00;//0x00----balance mode; 0x01-------assist mode static Uint16 still=0x00; //still=1.0, no move; still=0.0,move. static Uint16 stand=0x00;

static Uint16 last_balance_s0;

static Uint16 samples[6],ticks;

static float left_steer_cof=0.05;

static float right_steer_cof=0.05;

static float steer_lim=0.13;

static float initial_angle=0.0000874;

static float hard_speed_lim=0.90;

static float bus_current;

static float cmd;

static float lpf_angle;

static float lpf_angrate;

static float lpf_steer_knob;

static float left_motor_pwm, right_motor_pwm, steer_cmd;

static float left_motor_pwm, right_motor_pwm, steer_cmd;

static float batt_voltage1, ay, ax, in_steer_knob;

static float pitch_rate;

static float interval;

static float timer0_seconds_conv;

static float p_gain;

static float d_gain;

static float p1_gain;

static float d1_gain;

static float p0_gain;

static float d0_gain;

static float tp0,td0,tp1,td1,tp,td;

static float d_step=0.0001;

static float p_step;

static float cor_bat;

static float p_cmd,d_cmd;//next_cmd;

static float sample_conv = 1.0/1024.0/(float)HIST*5.0;//=3.052exp(-4) static float sample_conv1 = 1.0/1024.0/(float)HIST*2.07;

static float sample_conv2 = 1.0/1024.0/(float)HIST*1.9;

static float sample_conv3 = 1.0/1024.0/(float)HIST*333.3*2.5;

interrupt void T2_AD_isr(void);

void InitEv(void);

void InitAdc(void);

void InitGpio(void);

struct gyro_filter {

float angle;

float ay_bias;

//float ax_bias;

float rate_bias;

float steer_knob_bias;

float rate;

float steer_knob;

float curr_bias;

float curr;

Uint16 inited;

};

void check_mode ()

{if((!pitch_rate) && (!in_steer_knob)) mode = 0x00;

else mode = 0x01; }

void delay (void)

{ Uint16 xt;

static Uint16 k_temp;

for (xt=0;xt<15;xt++){

k_temp++; }

}

void delay1(void)

{ Uint16 xt;

static Uint16 k_temp;

for (xt=0;xt<15000;xt++){

k_temp++; }

}

int adc_collect_samples(Uint16 *samples, Uint16 *lasts0)

{

unsigned int i,j;

if (*lasts0 == totsamples_0) {

return 0;//if no new adc samples, return with 0

}

*lasts0 = totsamples_0;

for (i=0; i<6; i++) {

Uint16 tot=0;

for (j=0; j

{

tot+=adc_current_samples[i][j];

}

samples[i] = tot;//samples[i]=Σadc_current_samples[i][j](j=1,2,...,ADC_HIST) }

return 1;

}

Uint16 bat_judge( float x)

{

if(x>4.30) return 0x5;//25.8

else if(x>4.18) return 0x4;//25.1

else if(x>4.07) return 0x3;//24.4

else if(x>3.95) return 0x2;//23.7

else if(x>3.83) return 0x1;//23.0

else return 0x0;

}

void lpf_update(float *state, float tc, float interval, float input)

{

float frac=interval/tc;

if (frac>1.0) frac=1.0;

*state = input*frac + *state * (1.0-frac);

}

float fmax(float a, float b)

{

if (a>=b) {

return a;

} else {

return b;

}

}

float fmin(float a, float b)

{

if (a<=b) {

return a;

} else {

return b;

}

}

float flim(float x, float lo, float hi)

{

if (x>hi) return hi;

if (x

return x;

}

void gyro_init(struct gyro_filter *it)

{ it->inited =0x00;

it->angle=0.0;

it->ay_bias=0.0;

// it->ax_bias=0.0;

it->rate_bias=0.0;

it->steer_knob_bias=0.0;

it->rate=0.0;

it->steer_knob=0.0;

it->curr_bias=0.0;

it->curr=0.0;

lpf_angle=0.0;

lpf_angrate=0.0;

lpf_steer_knob=0.0;

}

void gyro_sample(struct gyro_filter *it, float in_rate,

float in_y, float in_x, float in_steer,float curri,float interval)

{

flim( in_y, -1.0,1.0);

flim( in_x, -1.0,1.0);

if (!it->inited) {

it->angle=0.0;

it->rate_bias = in_rate;

it->ay_bias = in_y;

it->curr_bias = curri;

it->steer_knob_bias = in_steer;

it->inited=1;

return; }

it->rate = in_rate - it->rate_bias;

it->angle =in_y-it->ay_bias;//it->angle+(in_y-it->ay_bias)*last_ax-in_x*(last_ay-it->ay_bias); it->curr= curri-it->curr_bias;

it->steer_knob= flim( in_steer-it->steer_knob_bias,-5.0,5.0);

}

void set_motor_idle()

{

GpioDataRegs.GPFDA T.bit.GPIOF12=1; //SD high

GpioDataRegs.GPFDA T.bit.GPIOF13=1; //OE high

stand =0x00;

EvaRegs.T2CON.all =0x1440;

gyro_init(&pitch_filter);

return;

}

void set_motor(float level_left, float level_right)

{

int leveli_left,leveli_right;

if (fabs(level_left)<0.002 || fabs(level_right)<0.002) return;

leveli_left = (int16)(level_left*OCRMAX);

leveli_right = (int16)(level_right*OCRMAX);

if (leveli_left<-(OCRMAX-2)) leveli_left=-(OCRMAX-2);

if (leveli_left>OCRMAX-2) leveli_left=OCRMAX-2;

if (leveli_right<-(OCRMAX-2)) leveli_right=-(OCRMAX-2);

if (leveli_right>OCRMAX-2) leveli_right=OCRMAX-2;

if(still) {

GpioDataRegs.GPFDA T.bit.GPIOF12=0; // SD=0

// asm("nop");

while(GpioDataRegs.GPFDA T.bit.GPIOF12==1) continue;

GpioDataRegs.GPADA T.bit.GPIOA13=1; //PORTC |= 0x50; //enable CCW0

GpioDataRegs.GPBDA T.bit.GPIOB13=1;

// delay();

GpioDataRegs.GPADA T.bit.GPIOA14=1; //PORTC |= 0xa0; //disable CW0 GpioDataRegs.GPBDA T.bit.GPIOB14=1;

//asm("nop");

continue;

still=0x00;

}

if (leveli_left<0) {

EvaRegs.ACTRA.all=0x00C2;

pwm=-leveli_left;

}

else {

EvaRegs.ACTRA.all=0x002C;

pwm=leveli_left;

}

if (leveli_right<0) {

EvbRegs.ACTRB.all=0x002C;

pwm=-leveli_right;

}

else {

EvbRegs.ACTRB.all=0x00C2;

pwm=leveli_right;

}

}

void motor_ready(void)

{

gyro_init(&pitch_filter);

GpioDataRegs.GPADA T.bit.GPIOA13=1; //PORTC |= 0x50; //enable CCW0 GpioDataRegs.GPBDA T.bit.GPIOB13=1;

GpioDataRegs.GPADA T.bit.GPIOA14=1; //PORTC |= 0xa0; //disable CW0 GpioDataRegs.GPBDA T.bit.GPIOB14=1;

GpioDataRegs.GPFDA T.bit.GPIOF12=0; //SD low

GpioDataRegs.GPFDA T.bit.GPIOF13=0; //OE low

EvaRegs.T1CON.bit.TENABLE=1; //启动定时器T1

EvbRegs.T3CON.bit.TENABLE=1; //启动定时器T3

EvaRegs.T2CON.all =0x1440; // 16分频,使能定时器操作，连续增模式

}

void balance(void)

{ float steer_cmd_abs,temp_steer_cmd;

unsigned int T2cnt;

if (!adc_collect_samples(samples, &last_balance_s0))

return;

{

T2cnt=EvaRegs.T2CNT; //读取定时器2的值

ticks = OCRMAX * count + T2cnt;

interval = timer0_seconds_conv * (float)ticks;

}

count=0;

EvaRegs.T2CON.all = 0x1400; //关闭定时器2

EvaRegs.T2CNT = 0x0000;

EvaRegs.T2CON.all = 0x1440; //启动定时器2

EvaRegs.GPTCONA.bit.T1TOADC = 2;

ay = sample_conv1*samples[4]-sample_conv2*samples[0];//1.034

pitch_rate = samples[1]*sample_conv3;

in_steer_knob = (samples[2]+samples[3])*sample_conv;

bus_current = samples[4]*sample_conv;

batt_voltage1 = samples[5]*sample_conv;

check_mode();

if(!pitch_filter.inited)

{

if(batt_voltage1<3.0) {

set_motor_idle();

return;

}

else

cor_bat=-0.857*batt_voltage1+4.58;//-0.857=(1-1.3)/(4.18-3.83),4.58=1+0.857*4.18 cor_bat=flim(cor_bat,1.0,1.3);

}

gyro_sample(&pitch_filter, pitch_rate,ay,ax,in_steer_knob,bus_current, interval); EvaRegs.GPTCONA.bit.T1TOADC = 0;

if(!mode) {

if(fabs(pitch_filter.angle)

GpioDataRegs.GPADA T.bit.GPIOA14=0;

GpioDataRegs.GPBDA T.bit.GPIOB14=0;

GpioDataRegs.GPADA T.bit.GPIOA13=0;

GpioDataRegs.GPBDA T.bit.GPIOB13=0;

GpioDataRegs.GPFDA T.bit.GPIOF12=1;

still=0x01;

return; }

EvaRegs.GPTCONA.bit.T1TOADC = 2;

lpf_steer_knob = -pitch_filter.steer_knob;

if(stand) {

p_gain = fmax(p0_gain,p_gain-p_step);//0.1

d_gain = fmin(d0_gain,d_gain+d_step);

tp=tp0;

td=td0; }

else { p_gain = fmin(p1_gain,p_gain+p_step);

d_gain = fmax(d1_gain,d_gain-d_step);//0.1

tp=tp1;

td=td1;

}

lpf_update(&lpf_angle,tp, interval, -pitch_filter.angle*cor_bat);//0.6

lpf_update(&lpf_angrate,td, interval, -pitch_filter.rate*cor_bat);//0.5

p_cmd=p_gain*lpf_angle*fabs(lpf_angle);

d_cmd=d_gain*lpf_angrate;

cmd=p_cmd + d_cmd;

cmd=flim(cmd, -hard_speed_lim, hard_speed_lim);

if(lpf_steer_knob>0.0) steer_cmd = flim(left_steer_cof * lpf_steer_knob*(1-fabs(cmd)), -steer_lim,steer_lim);

else steer_cmd = flim(right_steer_cof * lpf_steer_knob*(1-fabs(cmd)),

-steer_lim,steer_lim);

steer_cmd_abs = fabs(steer_cmd);

if ((lpf_steer_knob>0.0 && cmd>0.01)||(lpf_steer_knob<0.0 && cmd<-0.01))

temp_steer_cmd = flim(steer_cmd+0.1*interval,-steer_cmd_abs,steer_cmd_abs); //?????????? else if ((lpf_steer_knob>0.0 && cmd<-0.01)||(lpf_steer_knob<0.0 && cmd>0.01))

temp_steer_cmd = flim(steer_cmd-0.1*interval,-steer_cmd_abs,steer_cmd_abs); //?????????? else temp_steer_cmd=0.0;

EvaRegs.GPTCONA.bit.T1TOADC = 0;

if (cmd>=0.0) {

left_motor_pwm = 1.0-cmd*left_cof - temp_steer_cmd;

right_motor_pwm =1.0-cmd*right_cof + temp_steer_cmd;

} else {

left_motor_pwm = -(1.0+cmd*left_cof) + temp_steer_cmd;

right_motor_pwm =-(1.0+cmd*right_cof)- temp_steer_cmd;

}

set_motor(left_motor_pwm, right_motor_pwm);

}

}

void stabilize_analog(void)

{

Uint16 samples[6];

Uint16 i;

Uint16 last_s0=0;

for (i=0; i

if (adc_collect_samples(samples, &last_s0)) i++;

}

}

void stand_test()

{

if(GpioDataRegs.GPBDA T.bit.GPIOB6&&GpioDataRegs.GPBDA T.bit.GPIOB7) {

stand=0x02;

return;

}

else{

if(GpioDataRegs.GPBDA T.bit.GPIOB6||GpioDataRegs.GPBDA T.bit.GPIOB7)

{

stand=0x01;

return;

}

else{

stand=0x00;

return;

}

}

}

void main(void)

{

InitSysCtrl();

EALLOW;

DINT;

IER = 0x0000; //禁止VPU中断并清除所有CPU中断标志位

IFR = 0x0000;

InitPieCtrl();

InitPieVectTable();

InitGpio();

InitAdc();

InitEv();

EALLOW; // This is needed to write to EALLOW protected registers

PieVectTable.T2PINT=&T2_AD_isr;

EDIS; // This is needed to disable write to EALLOW protected registers

PieCtrlRegs.PIEIER3.bit.INTx1=1;//T2pint中断

IER |= M_INT1;//开启中断1

PieCtrlRegs.PIEIER1.bit.INTx7=1;

EINT; // Enable Global interrupt INTM

ERTM; // Enable Global realtime interrupt DBGM

for(;;)

{

DisableDog();

GpioDataRegs.GPADA T.bit.GPIOA12=1;

GpioDataRegs.GPADA T.bit.GPIOA15=1;

GpioDataRegs.GPBDA T.bit.GPIOB12=1;

GpioDataRegs.GPBDA T.bit.GPIOB15=1;

GpioDataRegs.GPFDA T.bit.GPIOF12=0; //SD low GpioDataRegs.GPFDA T.bit.GPIOF13=0; //OE low

GpioDataRegs.GPADA T.bit.GPIOA13=0;

GpioDataRegs.GPADA T.bit.GPIOA14=0;

GpioDataRegs.GPBDA T.bit.GPIOB13=0;

GpioDataRegs.GPBDA T.bit.GPIOB14=0;

InitAdc();

stabilize_analog();

InitEv();

gyro_init(&pitch_filter);

motor_ready();

for(;;)

{

balance();

if(!stand) break;

}

set_motor_idle();

}

}

interrupt void T2_AD_isr(void)

{

if(k<16)

{

adc_current_samples[0][k]=((float)AdcRegs.ADCRESULT0)*3.0/65520.0+adclo;

adc_current_samples[1][k]=((float)AdcRegs.ADCRESULT1)*3.0/65520.0+adclo;

adc_current_samples[2][k]=((float)AdcRegs.ADCRESULT2)*3.0/65520.0+adclo;

adc_current_samples[3][k]=((float)AdcRegs.ADCRESULT3)*3.0/65520.0+adclo;

adc_current_samples[4][k]=((float)AdcRegs.ADCRESULT4)*3.0/65520.0+adclo;

adc_current_samples[5][k]=((float)AdcRegs.ADCRESULT5)*3.0/65520.0+adclo;

k++;

AdcRegs.ADCST.bit.INT_SEQ1_CLR=1; //清除状态字

AdcRegs.ADCTRL2.bit.RST_SEQ1=1;//复位seq1

EvaRegs.EV AIFRB.bit.T2PINT=1;//清除中断标志

EvaRegs.EV AIMRB.bit.T2PINT=1;//中断允许

PieCtrlRegs.PIEACK.bit.ACK3=1;//向cpu申请中断

}

else{

totsamples_0++;

k=0;

count=totsamples_0;

AdcRegs.ADCST.bit.INT_SEQ1_CLR=1; //清除状态字

AdcRegs.ADCTRL2.bit.RST_SEQ1=1;//复位seq1

EvaRegs.EV AIFRB.bit.T2PINT=1;//清除中断标志

// EvaRegs.EV AIMRB.bit.T2PINT=1;//中断允许

EvaRegs.GPTCONA.bit.T1TOADC = 0;

}

}

//--------------------------------------------------------------------------- // InitEv:

//--------------------------------------------------------------------------- // This function initializes to a known state.

//

void InitEv(void)

{

EALLOW;

/*****************************/

/***********配置ACTR**********/

/*****************************/

/* EvaRegs.ACTRA.bit.CMP1ACT=2;

//PW1引脚高电平有效

EvaRegs.ACTRA.bit.CMP2ACT=1;

//PWM2引脚低电平有效*/

/*****************************/

/*******配置死区寄存器********/

/*****************************/

EvaRegs.DBTCONA.bit.DBT=5;

//死区定时器周期为5

EvaRegs.DBTCONA.bit.EDBT1=1;

//死区定时器1使能

EvaRegs.DBTCONA.bit.DBTPS=1;

//死区定时器预定标因子，死区时钟为HSPCLK/2

/*****************************/

/*********配置COMCONA*********/

/*****************************/

https://www.360docs.net/doc/a417043013.html,CONA.bit.CENABLE=1;

//使能比较单元的比较操作

https://www.360docs.net/doc/a417043013.html,CONA.bit.CLD=2;

//当给CMPR1赋新值时，立即装载

https://www.360docs.net/doc/a417043013.html,CONA.bit.FCOMPOE=1;

//全比较操作，PWM输出由相应的比较逻辑驱动

/*****************************/

/**********设置T1CON**********/

/*****************************/

EvaRegs.T1CON.bit.TMODE=2;

//T1工作于连续增模式

EvaRegs.T1CON.bit.TPS=3;

//输入时钟预定标因子为X/8

EvaRegs.T1CON.bit.TENABLE=1;

//禁止定时器操作

EvaRegs.T1CON.bit.TCLKS10=0;

//使用内部时钟

EvaRegs.T1CON.bit.TECMPR=1;

//使能定时器比较操作

/*****************************/

/**********设置T1PR等*********/

/*****************************/

EvaRegs.T1PR =OCRMAX;

EvaRegs.T1CNT = 0x0; ///定时器1初值设为0

EvaRegs.CMPR1=pwm;

EvaRegs.CMPR2=pwm;

// EvaRegs.T1CON.bit.TENABLE=1; //启动定时器T1

/* EvbRegs.ACTRB.bit.CMP7ACT=2;

//PWM7引脚高电平有效

EvbRegs.ACTRB.bit.CMP8ACT=1;

//PWM8引脚低电平有效*/

/*****************************/

/*******配置死区寄存器********/

/*****************************/

EvbRegs.DBTCONB.bit.DBT=5;

//死区定时器周期为5

EvbRegs.DBTCONB.bit.EDBT1=1;

//死区定时器1使能

EvbRegs.DBTCONB.bit.DBTPS=3;

//死区定时器预定标因子，死区时钟为HSPCLK/8

/*****************************/

/*********配置COMCONA*********/

/*****************************/

https://www.360docs.net/doc/a417043013.html,CONB.bit.CENABLE=1;

//使能比较单元的比较操作

https://www.360docs.net/doc/a417043013.html,CONB.bit.CLD=2;

//当给CMPR1赋新值时，立即装载

https://www.360docs.net/doc/a417043013.html,CONB.bit.FCOMPOE=1;

//全比较操作，PWM输出由相应的比较逻辑驱动

/*****************************/

/**********设置T1CON**********/

/*****************************/

EvbRegs.T3CON.bit.TMODE=2;

//T1工作于连续增模式

EvbRegs.T3CON.bit.TPS=3;

//输入时钟预定标因子为X/8

EvbRegs.T3CON.bit.TENABLE=1;

//禁止定时器操作

EvbRegs.T3CON.bit.TCLKS10=0;

//使用内部时钟

EvbRegs.T3CON.bit.TECMPR=1;

//使能定时器比较操作

/*****************************/

/**********设置T1PR等*********/

/*****************************/

EvbRegs.T3PR =OCRMAX;

EvbRegs.T3CNT = 0; ///定时器3初值设为0

EvbRegs.CMPR4=pwm;

EvbRegs.CMPR5=pwm;

// EvbRegs.T3CON.bit.TENABLE=1;

//启动定时器T3

EvaRegs.GPTCONA.all=0;

EvaRegs.T2PR =OCRMAX; // 定时器2的周期为20k

EvaRegs.T2CMPR=0x0000;

EvaRegs.T2CNT =0x0000; // Timer2 counter

//EvaRegs.T2CON.all =0x1440;//16分频,使能定时器操作，连续增模式

EvaRegs.EV AIMRB.bit.T2PINT = 1;//定时器2周期中断允许

EvaRegs.EV AIFRB.bit.T2PINT = 1;//清除标志

// EvaRegs.GPTCONA.bit.T1TOADC = 2;

EDIS;

}

void InitAdc(void)

{

//unsigned int p;

// To powerup the ADC the ADCENCLK bit should be set first to enable

// clocks, followed by powering up the bandgap and reference circuitry.

// After a 5ms delay the rest of the ADC can be powered up. After ADC

// powerup, another 20us delay is required before performing the first

// ADC conversion. Please note that for the delay function below to

// operate correctly the CPU_CLOCK_SPEED define statement in the

// DSP28_Examples.h file must contain the correct CPU clock period in

// nanoseconds. For example:

AdcRegs.ADCTRL1.bit.RESET=1; //ADC模块软件复位

// asm(" NOP");

AdcRegs.ADCTRL1.bit.RESET=0; //这一句可要可不要，因为硬件会自动返回0

AdcRegs.ADCTRL1.bit.SUSMOD=3; //仿真挂起的模式3 ？？

AdcRegs.ADCTRL1.bit.ACQ_PS=0x0; //决定启动转换新号SOC的脉冲宽度，SOC用于控制持续多长时间的采样开关闭合，SOC脉冲宽度大小为ADCLK周期的（ADCTRL(11:8)+1)倍

AdcRegs.ADCTRL1.bit.CPS=0; //对外设时钟HSPCLK进行分频，1分频

AdcRegs.ADCTRL1.bit.CONT_RUN=1;//连续运转模式

AdcRegs.ADCTRL1.bit.SEQ_CASC=1;//级联模式，SEQ1和SEQ2工作时作为一个16位状态排序器（SEQ）

//ADC模块控制寄存器3（ADCTRL3）AdcRegs.ADCTRL3.bit.ADCBGRFDN=3;//ADC带间隙和参考电路上电

// for(p=0;p<10000;p++) asm(" NOP"); //延时等待ADC上电

AdcRegs.ADCTRL3.bit.ADCPWDN=1; //ADC除间隙和参考电路之外的模拟电路上电// for(p=0;p<5000;p++) asm(" NOP"); //延时等待ADC上电

AdcRegs.ADCTRL3.bit.ADCCLKPS=5; //内核时钟分频，产生ADC内核时钟ADCLK；ADCLK=HSPCLK/[30*(ADCTRL1.7+1)];ADCTRL1.7为AdcRegs.ADCTRL1.bit.CPS=0。

AdcRegs.ADCTRL3.bit.SMODE_SEL=1;//同步采样模式

//最大转换通道寄存器（MAXCONV）AdcRegs.ADCMAXCONV.bit.MAX_CONV1=5;//即在SEQ采样模式下，使用MAXCONV1(3:0)

//ADC输入通道选择排序控制寄存器（CHSELSEQn)

AdcRegs.ADCCHSELSEQ1.bit.CONV00=0; //AD转换排序

AdcRegs.ADCCHSELSEQ1.bit.CONV01=1;

AdcRegs.ADCCHSELSEQ1.bit.CONV02=2;

AdcRegs.ADCCHSELSEQ1.bit.CONV03=3;

AdcRegs.ADCCHSELSEQ2.bit.CONV04=4;

AdcRegs.ADCCHSELSEQ2.bit.CONV05=5;

//AD状态和标志寄存器（ADCST）AdcRegs.ADCST.bit.INT_SEQ1_CLR=1; //ADCST中断清除位，清除SEQ1的中断标志

AdcRegs.ADCST.bit.INT_SEQ2_CLR=1; //ADCST中断清除位，清除SEQ2的中断标志

//ADC模块控制寄存器2（ADCTRL2）AdcRegs.ADCTRL2.bit.EVB_SOC_SEQ=0; //在级联排序模式下，EVB启动转换使能不起作用

AdcRegs.ADCTRL2.bit.RST_SEQ1=1; //复位排序器1

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1=1; //SEQ1中断使能，使能通过INT SEQ1向CPU发送中断请求

AdcRegs.ADCTRL2.bit.INT_MOD_SEQ1=0; //选择SEQ1的中断模式，它会影响SEQ1排序转换结束时INT SEQ1的设置，为0表示在每个SEQ1序列结束时，INT SEQ1置位AdcRegs.ADCTRL2.bit.EV A_SOC_SEQ1=1; //SEQ1 EV A启动转换，即EV A的触发信号启动SEQ1

AdcRegs.ADCTRL2.bit.EXT_SOC_SEQ1=0; //SEQ1外部信号启动转换位，0表示没有影响

AdcRegs.ADCTRL2.bit.RST_SEQ2=0; //表示没有可执行操作

AdcRegs.ADCTRL2.bit.SOC_SEQ2=0; //清除没有处理的SOC触发信号

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ2=0; //INT SEQ2向CPU发送中断请求被禁止AdcRegs.ADCTRL2.bit.INT_MOD_SEQ2=0; //选择SEQ2的中断模式，它会影响SEQ2排序转换结束时INT SEQ2的设置，为0表示在每个SEQ2序列结束时，INT SEQ2置位AdcRegs.ADCTRL2.bit.EVB_SOC_SEQ2=0; //EVB的触发信号不能启动SEQ2

}

void InitGpio(void)

{

// Set GPIO A port pins,AL(Bits 7:0)(input)-AH(Bits 15:8) (output) 8bits

// Input Qualifier =0, none

EALLOW;

GpioMuxRegs.GPAMUX.all=0x000f;

GpioMuxRegs.GPADIR.all=0xf000;

GpioMuxRegs.GPAQUAL.all=0x0000; // Input qualifier disabled

// Set GPIO B port pins, configured as EVB signals

// Input Qualifier =0, none

// Set bits to 1 to configure peripherals signals on the pins

GpioMuxRegs.GPBMUX.all=0x003f;

GpioMuxRegs.GPBDIR.all=0xf000;

GpioMuxRegs.GPBQUAL.all=0x0000; // Input qualifier disabled

GpioMuxRegs.GPFMUX.bit.MDXA_GPIOF12=0; //确定GPIOF12为通用I/O引脚

GpioMuxRegs.GPFDIR.bit.GPIOF12=1; //方向为输出

GpioMuxRegs.GPFMUX.bit.MDRA_GPIOF13=0;

GpioMuxRegs.GPFDIR.bit.GPIOF13=1;

EDIS;

}