加急，函数嵌套后程序运行不正常

sqsnlg · 发表于 2016-12-7 14:23:10

在main函数里直接调用函数comm2()，运行正常；在main函数里调用comm1()，在comm1()函数再调用comm2()，就运行不正常了，如果函数comm1()里代码很长也运行不正常，请问这是什么问题？好像是堆栈问题，但是堆栈已经设置很大了，堆栈设置：Stack_Size设置成0x0000A000，Heap_Size设置成0x00000500，还是运行不正常，求原子哥和大侠们指点！！

ARM学员 · 发表于 2016-12-7 14:23:11

本帖最后由 ARM学员于 2016-12-12 16:42 编辑

sqsnlg 发表于 2016-12-9 10:50
问题已解决

你这个代码这么多，说明你对整个工程的结构还不够清晰，想让别人帮你看代码，你也是怀疑代码其他地方有问题，并不是你认为的出错的地方，除非是很有耐心的人才会给你看，问题重点也不突出，感觉通篇全是重点，如果仅仅是因为嵌套多了就出现问题，我还没遇到过，而且有网友耐心给你回答问题，后面有人问你是怎么解决的，都不屌别人，你这种下次鬼才会屌你。

g0314023 · 发表于 2016-12-7 14:38:09

代码帖出来看下

dengxingling8 · 发表于 2016-12-7 14:41:07

运行不正常是神么意思？出现的什么现象？

sqsnlg · 发表于 2016-12-7 15:10:23

用定时8的四个通道的PWM驱动四个步进电机，现在的问题是中断服务函数不是中断一次就进去一次，而是比定时时间延后很多才进去一次，我无法计算输出的脉冲个数。

sqsnlg · 发表于 2016-12-7 15:11:10

本帖最后由 sqsnlg 于 2016-12-7 18:00 编辑

乱码清了

sqsnlg · 发表于 2016-12-7 15:18:41

发帖的时候注释乱码怎么弄？是不是定时器8的中断服务函数太长了？

wenzh3333 · 发表于 2016-12-7 15:37:33

C:\Users\Administrator\Desktop

这里面设置一下

wenzh3333 · 发表于 2016-12-7 15:39:40

额图片显示不出来
在KEIL - Edit-Configuration 里的Editor中 Encoding设置成Chinese GB2312
这样复制出来就不是乱码

sqsnlg · 发表于 2016-12-7 17:38:08

用定时器8的四个通道的PWM驱动四个步进电机，现在的问题是中断服务函数不是中断一次就进去一次，而是比定时时间延后很多才进去一次，我无法计算输出的脉冲个数，而且是有的时候是按设定时间进入中断服务函数的，有的时候是延时一倍时间后进入中断服务函数的，同样的程序，进入中断服务的时间不一样，有时感觉和外面其他函数的嵌套多少有关系，请各位大神帮忙啊

void MOTOR_TIM8_NVIC_CHX_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);  //使能GPIOC外设和AFIO复用功能模块时钟

RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE); //使能定时器8时钟

TIM_ITConfig(TIM8,TIM_IT_Update,ENABLE); //使能指定的TIM8中断,允许更新中断

NVIC_InitStructure.NVIC_IRQChannel = TIM8_UP_IRQn;  //TIM8中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级0级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级0级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器

   //设置该引脚为复用输出功能,输出TIM8 CH3的PWM脉冲波形 GPIOC.8
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure); //GPIOC.8=CLK1 水平电机PWM输出引脚初始化

//设置该引脚为复用输出功能,输出TIM8 CH4的PWM脉冲波形 GPIOC.9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure); //GPIOC.9=CLK2 点针电机PWM输出引脚初始化

//设置该引脚为复用输出功能,输出TIM8 CH2的PWM脉冲波形 GPIOC.7
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure); //GPIOC.7=CLK3 上升电机PWM输出引脚初始化

//设置该引脚为复用输出功能,输出TIM8 CH1的PWM脉冲波形 GPIOC.6
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure); //GPIOC.6=CLK4 下降电机PWM输出引脚初始化
}

//TIM3 PWM部分初始化
//PWM输出初始化
//arr：自动重装值
//psc：时钟预分频数
void MOTOR_TIM8_PwmInit(u16 arr,u16 psc,u16 PWM_Compare,MOTOR_TypeFlag MotorType)
{

TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
TIM_OCInitTypeDef  TIM_OCInitStructure;

MOTOR_arr=arr;
//初始化TIM8
TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值
TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
TIM_TimeBaseInit(TIM8, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位

//清空TIM8四个通道PWM设置
TIM_OCStructInit(&TIM_OCInitStructure);//结构体初始化
TIM_OC1Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM8 OC1
TIM_OC2Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM8 OC2
TIM_OC3Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM8 OC3
TIM_OC4Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM8 OC4
TIM_OC1PreloadConfig(TIM8, TIM_OCPreload_Disable);  //不使能TIM8在CCR1上的预装载寄存器
TIM_OC2PreloadConfig(TIM8, TIM_OCPreload_Disable);  //不使能TIM8在CCR2上的预装载寄存器
TIM_OC3PreloadConfig(TIM8, TIM_OCPreload_Disable);  //不使能TIM8在CCR3上的预装载寄存器
TIM_OC4PreloadConfig(TIM8, TIM_OCPreload_Disable);  //不使能TIM8在CCR4上的预装载寄存器

//配置TIM8通道参数
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2; //选择定时器模式:TIM脉冲宽度调制模式2
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出使能
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性:TIM输出比较极性高

switch(MotorType)
{
case MOTOR_RISE:
TIM_OC2Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM3 OC3
TIM_OC2PreloadConfig(TIM8, TIM_OCPreload_Enable);  //使能TIM3在CCR3上的预装载寄存器
TIM_SetCompare2(TIM8,PWM_Compare);  //设置比较值
break;
case MOTOR_LEVEL:
TIM_OC3Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM3 OC3
TIM_OC3PreloadConfig(TIM8, TIM_OCPreload_Enable);  //使能TIM3在CCR3上的预装载寄存器
TIM_SetCompare3(TIM8,PWM_Compare);  //设置比较值
break;
case MOTOR_DROP:
TIM_OC4Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM3 OC3
TIM_OC4PreloadConfig(TIM8, TIM_OCPreload_Enable);  //使能TIM3在CCR3上的预装载寄存器
TIM_SetCompare4(TIM8,PWM_Compare);  //设置比较值
break;
case MOTOR_FALL:
TIM_OC1Init(TIM8, &TIM_OCInitStructure);  //根据T指定的参数初始化外设TIM3 OC3
TIM_OC1PreloadConfig(TIM8, TIM_OCPreload_Enable);  //使能TIM3在CCR3上的预装载寄存器
TIM_SetCompare1(TIM8,PWM_Compare);  //设置比较值
break;
}

TIM_CtrlPWMOutputs(TIM8,ENABLE);  //MOE 主输出使能

TIM_ARRPreloadConfig(TIM8,ENABLE);//启动定时器前重装载周期值

//TIM_Cmd(TIM8,ENABLE); //启动定时器
}

void TIM8_UP_IRQHandler(void) //TIM8中断电机PWM输出
{
TIM_ClearITPendingBit(TIM8, TIM_IT_Update);  //清除TIMx的中断待处理位:TIM 中断源

MOTOR_PWM_Count++;

if(MOTOR_TYPE_CURRENT==MOTOR_RISE)
{
if(MOTOR_DIRECT_CURRENT==MOTOR_Forward)
MOTOR_ENCODE_Count=TIM5->CNT;
else
MOTOR_ENCODE_Count=64000-TIM5->CNT;
}
else if(MOTOR_TYPE_CURRENT==MOTOR_LEVEL)
{
if(MOTOR_DIRECT_CURRENT==MOTOR_Forward)
MOTOR_ENCODE_Count=TIM1->CNT;
else
MOTOR_ENCODE_Count=64000-TIM1->CNT;
}

else if(MOTOR_TYPE_CURRENT==MOTOR_DROP)
{
if(MOTOR_DIRECT_CURRENT==MOTOR_Forward)
MOTOR_ENCODE_Count=TIM4->CNT;
else
MOTOR_ENCODE_Count=64000-TIM4->CNT;
}
else if(MOTOR_TYPE_CURRENT==MOTOR_FALL)
{
if(MOTOR_DIRECT_CURRENT==MOTOR_Forward)
MOTOR_ENCODE_Count=TIM3->CNT;
else
MOTOR_ENCODE_Count=64000-TIM3->CNT;
}

if(MOTOR_TYPE_CURRENT==MOTOR_LEVEL)
{
MOTOR_ENCODE_Run=(float)MOTOR_ENCODE_Count*0.006; //一个编码器脉冲对应0.006mm = 12mm/2000(编码器一圈的脉冲) 导程=12mm
MOTOR_PWM_Run=(float)MOTOR_PWM_Count*0.00375; //一个PWM周期对应0.001875mm=12mm/6400(32分频一圈的脉冲) 导程=12mm
}
else
{
MOTOR_ENCODE_Run=(float)MOTOR_ENCODE_Count*0.001; //一个编码器脉冲对应0.001mm = 2mm/2000
MOTOR_PWM_Run=(float)MOTOR_PWM_Count*0.00125; //一个PWM周期对应0.00125mm=2mm/1600
}

if(MOTOR_PWM_Count>=MOTOR_PWM_Num) //脉冲数到了
{
TIM_Cmd(TIM8,DISABLE);  //关闭PWM
MOTOR_ChipEnable(MOTOR_TYPE_CURRENT,DISABLE);//电机芯片不使能

if(MOTOR_ENCODE_Run<MOTOR_PWM_Run)  //判断丢步编码器的运行距离小于设置的距离
{
MOTOR_PWM_ENCODE_DIF=(MOTOR_PWM_Run-MOTOR_ENCODE_Run)*100; //差值放大100倍精确到0.01mm

if(MOTOR_PWM_ENCODE_DIF>=1) //判断差值是否大于0.01mm
{
if(MOTOR_TYPE_CURRENT==MOTOR_LEVEL)
{
MOTOR_PWM_Count_Cnt=(float)((MOTOR_PWM_ENCODE_DIF/100)/0.00375);
MOTOR_PWM_ENCODE_DIF=MOTOR_PWM_Count_Cnt;
MOTOR_PWM_Count_Cnt-=MOTOR_PWM_ENCODE_DIF;

if(MOTOR_PWM_Count_Cnt>=0.5)
MOTOR_PWM_ENCODE_DIF++;
MOTOR_PWM_Count=MOTOR_PWM_Count-MOTOR_PWM_ENCODE_DIF;
}
else
MOTOR_PWM_Count=MOTOR_PWM_Count-MOTOR_PWM_ENCODE_DIF*8;  //减去丢掉的脉冲个数，继续计数

MOTOR_ChipEnable(MOTOR_TYPE_CURRENT,ENABLE);  //使能电机
   TIM_Cmd(TIM8,ENABLE); //开启PWM
}
else
{
MOTOR_CurRun=MOTOR_ENCODE_Run*100; //放大100倍，精确到0.01mm
MOTOR_SaveMotorPlace(MOTOR_CurRun,MOTOR_TYPE_CURRENT,MOTOR_DIRECT_CURRENT); //保存电机位置
}
}
else  //标志电机位置
{
MOTOR_CurRun=MOTOR_ENCODE_Run*100;       //放大100倍，精确到0.01mm
MOTOR_SaveMotorPlace(MOTOR_CurRun,MOTOR_TYPE_CURRENT,MOTOR_DIRECT_CURRENT); //保存电机位置
}

}

else if((MOTOR_PWM_Run-MOTOR_ENCODE_Run)>=1)  //PWM的距离-编码器的距离大于1MM，认为堵转
{
TIM_Cmd(TIM8,DISABLE);  //关闭PWM
MOTOR_ChipEnable(MOTOR_TYPE_CURRENT,DISABLE);  //不使能电机

MOTOR_CurRun=MOTOR_ENCODE_Run*100;       //放大100倍，精确到0.01mm
MOTOR_SaveMotorPlace(MOTOR_CurRun,MOTOR_TYPE_CURRENT,MOTOR_DIRECT_CURRENT); //保存电机位置
}

}

sqsnlg · 发表于 2016-12-7 17:48:01

在主函数里调用MOTOR_Run(1000,MOTOR_FALL,MOTOR_Forward)，运行正常。

在通信函数里调用MOTOR_Run(1000,MOTOR_FALL,MOTOR_Forward)，运行就不正常，就多了一次函数嵌套就不行了

void MOTOR_Run(u16 RUN_Len,MOTOR_TypeFlag MotorType,MOTOR_DirectFlag MorotDirect)
{
float MOTOR_RUN_PwmNum;

MOTOR_TYPE_CURRENT=MotorType;                //保存电机运行方式
MOTOR_DIRECT_CURRENT=MorotDirect;

//MOTOR_TIM8_Channel(MotorType);
//MOTOR_TIM8_PwmInit(17999,0,8999,MotorType);  //TIM8电机PWM初始化  每秒走5mm  丝杠导程=2mm

CHECK_ReadMotorPlace();

if(MotorType==MOTOR_LEVEL)
{
MOTOR_RUN_PwmNum=(float)((RUN_Len/100)/0.00375); //0.12mm/32细分=0.00375

MOTOR_PWM_Num=MOTOR_RUN_PwmNum;

MOTOR_RUN_PwmNum-=MOTOR_PWM_Num;

if(MOTOR_RUN_PwmNum>=0.5)
MOTOR_PWM_Num++;

MOTOR_TIM8_PwmInit(11249,0,5624,MotorType);  //TIM8电机PWM初始化  每秒走12mm  丝杠导程=12mm
}
else
{
MOTOR_PWM_Num=RUN_Len*8; //本次运行总脉冲数  0.01mm对应8个PWM脉冲
MOTOR_TIM8_PwmInit(17999,0,8999,MotorType);  //TIM8电机PWM初始化  每秒走5mm  丝杠导程=2mm
}

delay_ms(10);

MOTOR_PWM_Count=0; //脉冲计数清零

if(MorotDirect==MOTOR_Forward) //正向
{
if(MotorType==MOTOR_RISE)
TIM5->CNT=0;
if(MotorType==MOTOR_LEVEL)
TIM1->CNT=0;
if(MotorType==MOTOR_DROP)
TIM4->CNT=0;
if(MotorType==MOTOR_FALL)
TIM3->CNT=0;
}
else //反向
{
if(MotorType==MOTOR_RISE)
TIM5->CNT=64000;
if(MotorType==MOTOR_LEVEL)
TIM1->CNT=64000;
if(MotorType==MOTOR_DROP)
TIM4->CNT=64000;
if(MotorType==MOTOR_FALL)
TIM3->CNT=64000;
}

MOTOR_PSC_Config();
MOTOR_ChipEnable(MotorType,DISABLE); //电机不使能
MOTOR_UpDown(MotorType,MorotDirect); //电机运行方向
MOTOR_ChipEnable(MotorType,ENABLE); //电机使能
TIM_Cmd(TIM8,ENABLE); //运行电机
}

int main(void)
{
  u8  i;
u16 t;
u16 len;
/**************************延时初始化*******************************/
delay_init();
delay_ms(3000);
/******************************中断优先级设置******************************/
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
/******************************定时************************************/
TIMER_TIM6_Init(10000,72);  //72分频  定时10MS
/**********************************************************************/
uart3_init(9600); //CCD通信
uart4_init(9600); //采样器通信
uart5_init(9600); //主机通信
/******************************传感器初始化*****************************/
SENSER_Init();
/******************************编码器************************************/

ENCODER_RISE_TIM5_Init(); //CLK3上升电机编码器初始化
ENCODER_LEVEL_TIM1_Init(); //CLK1水平电机编码器初始化
ENCODER_DROP_TIM4_Init(); //CLK2点样电机编码器初始化
  ENCODER_FALL_TIM3_Init(); //CLK4下落电机编码器初始化
/********************************电机***********************************/

MOTOR_Rise_ControlInit();
MOTOR_LEVEL_ControlInit();
  MOTOR_DROP_ControlInit();
  MOTOR_FALL_ControlInit();
MOTOR_PSC_Config();
MOTOR_TIM8_NVIC_CHX_Init();
MOTOR_Run(0,MOTOR_DROP,MOTOR_Forward);
//MOTOR_TIM8_Channel(MOTOR_LEVEL);

//MOTOR_TIM8_PwmInit(17999,0,8999,MOTOR_RISE);  //TIM8电机PWM初始化  每秒走5mm  丝杠导程=2mm

/*******************************自检复位**********************************************/
//CHECK_SelfInspect();
/****************************自检完成后蜂鸣器响*************************************************/
BEEP_TIM2_Init(400,72,200); //72分频 72MHz/72=1M 2500Hz=1MHz/400
TIM_Cmd(TIM2,ENABLE);    //开启蜂鸣器
delay_ms(200);
TIM_Cmd(TIM2,DISABLE);    //关闭蜂鸣器
delay_ms(200);
TIM_Cmd(TIM2,ENABLE);    //开启蜂鸣器
delay_ms(800);
TIM_Cmd(TIM2,DISABLE);    //关闭蜂鸣器


while(1)
{
if(USART5_RX_STA&0x8000)//主机通信
{
COMM_UART5_MostComm();  //通信运行电机
}

if(COMM_CheckStart==0xaa)//启动检测
{
COMM_CheckStart=0x00;
CHEAK_Start(CHECK_MODE);
}

if(SENSER_RisePlace==1) //传感器
{

MOTOR_Run(1000,MOTOR_FALL,MOTOR_Forward);    //电机运行 10.00mm

delay_ms(500);
}

delay_ms(1);
}
}

void COMM_UART5_MostComm(void)
{
u8 ReturnLen;
u16 Run_Len;
u32 Card_NUM;
//u8 ReturnData[12]={0x5a,0xa5,0x00,0x00,0x00,0x35,0x53,0x00,0x00,0x00,0x35,0x53};
u8 ReturnData_7BY[7]={0x5a,0xa5,0x81,0x11,0x11,0x35,0x53};

USART5_RX_STA=0;

if(USART5_RX_BUF[0]==0x5A&&USART5_RX_BUF[1]==0xA5)
{
if(USART5_RX_BUF[2]==0x51)
{
if(USART5_RX_BUF[3]==0xA0&&USART5_RX_BUF[4]==0x0A) //蜂鸣器响
{
BEEP_TIME=40; //报警计时  响400Ms  定时器5定时10MS
TIM_Cmd(TIM2,ENABLE);    //开启蜂鸣器
TIM_Cmd(TIM6,ENABLE); //开启蜂鸣器计时
}
else if(USART5_RX_BUF[3]==0xA1&&USART5_RX_BUF[4]==0x1A)//自动模式
{
COMM_CheckStart=0xaa;
CHECK_MODE=MOTOR_AUTO_MODE;
}
else if(USART5_RX_BUF[3]==0xA2&&USART5_RX_BUF[4]==0x2A)//手动模式
{
COMM_CheckStart=0xaa;
CHECK_MODE=MOTOR_MANU_MODE;
}
else if(USART5_RX_BUF[3]==0xA3&&USART5_RX_BUF[4]==0x3A)//检测器复位
{
///////////////////////////////////////////////////////////////
if(SENSER_LevelStart==1)
{
MOTOR_Run(40000,MOTOR_LEVEL,MOTOR_Reversal); //水平电机反转400mm
while(SENSER_LevelStart==1);
TIM_Cmd(TIM8,DISABLE);
MOTOR_ChipEnable(MOTOR_LEVEL,DISABLE);    //至复位位置关闭水平电机

STMFLASH_DataTemp[STMFLASH_LevelPlace_BYTE3]=0;
STMFLASH_DataTemp[STMFLASH_LevelPlace_BYTE2]=0;
STMFLASH_DataTemp[STMFLASH_LevelPlace_BYTE1]=0;
STMFLASH_DataTemp[STMFLASH_LevelPlace_BYTE0]=0;
STMFLASH_Write(STMFLASH_FLASH_SAVE_ADDR,(u16*)STMFLASH_DataTemp,STMFLASH_DataTemp_SIZE); //  保存水平电机复位位置
}
/////////////////////////////////////////////////////////////////
if(SENSER_RisePlace==0)
{
while(SENSER_RisePlace==0&&SENSER_RiseTop!=0) //卡没送进槽，托盘没运行到顶部
{
MOTOR_Run(800,MOTOR_RISE,MOTOR_Reversal); //反转上升电机8mm向上推盘
while((TIM8->CR1&0x0001)==1); //等待电机停
}
}

if(SENSER_RisePlace==1)
{
MOTOR_Run(800,MOTOR_RISE,MOTOR_Forward); //正转上升电机8mm向下推盘
while((TIM8->CR1&0x0001)==1); //等待电机停
}
///////////////////////////////////////////////////////////////
if(SENSER_FallPlace==0)
{
while(SENSER_FallPlace==0&&SENSER_FallTop!=0) //卡没送存卡槽，托盘没运行到顶部
{
MOTOR_Run(800,MOTOR_FALL,MOTOR_Reversal); //反转存盘电机8mm向上推盘
while((TIM8->CR1&0x0001)==1); //等待电机停
}
}

if(SENSER_FallPlace==1)
{
MOTOR_Run(800,MOTOR_RISE,MOTOR_Forward); //正转存盘电机8mm向下推盘
while((TIM8->CR1&0x0001)==1); //等待电机停
}
///////////////////////////////////////////////////////
}
else if(USART5_RX_BUF[3]==0xA4&&USART5_RX_BUF[4]==0x4A)//加盘
{
if(SENSER_RiseBottom==1)
{
MOTOR_Run(20000,MOTOR_RISE,MOTOR_Forward); //推盘电机正转到复位位置
while(SENSER_RiseBottom==1); //等待到达推盘电机复位传感器
TIM_Cmd(TIM8,DISABLE);
MOTOR_ChipEnable(MOTOR_RISE,DISABLE);

STMFLASH_DataTemp[STMFLASH_RisePlace_BYTE3]=0;
STMFLASH_DataTemp[STMFLASH_RisePlace_BYTE2]=0;
STMFLASH_DataTemp[STMFLASH_RisePlace_BYTE1]=0;
STMFLASH_DataTemp[STMFLASH_RisePlace_BYTE0]=0;
STMFLASH_Write(STMFLASH_FLASH_SAVE_ADDR,(u16*)STMFLASH_DataTemp,STMFLASH_DataTemp_SIZE); //  保存推盘电机复位位置
}
}
else if(USART5_RX_BUF[3]==0xA5&&USART5_RX_BUF[4]==0x5A)//取盘
{
if(SENSER_FallBottom==1)
{
MOTOR_Run(20000,MOTOR_FALL,MOTOR_Forward); //推存盘电机正转到复位位置
while(SENSER_FallBottom==1);
TIM_Cmd(TIM8,DISABLE);
MOTOR_ChipEnable(MOTOR_FALL,DISABLE);    //至复位位置关闭水平电机

STMFLASH_DataTemp[STMFLASH_FallPlace_BYTE3]=0;
STMFLASH_DataTemp[STMFLASH_FallPlace_BYTE2]=0;
STMFLASH_DataTemp[STMFLASH_FallPlace_BYTE1]=0;
STMFLASH_DataTemp[STMFLASH_FallPlace_BYTE0]=0;
STMFLASH_Write(STMFLASH_FLASH_SAVE_ADDR,(u16*)STMFLASH_DataTemp,STMFLASH_DataTemp_SIZE); //  保存存盘电机复位位置
}
}

for(ReturnLen=0;ReturnLen<7;ReturnLen++)
{
USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}

}
else if(USART5_RX_BUF[2]==0x59) //读取待检测盘数
{
CHECK_ReadMotorPlace();

Card_NUM=CHEAK_RiseMotorCurPlase/800;

if(CHEAK_RiseMotorCurPlase%800>=790)
Card_NUM++;

ReturnData_7BY[2]=0x89; //命令

ReturnData_7BY[3]=Card_NUM%0x100;  //盘数

ReturnData_7BY[4]=Card_NUM%0x100;  //盘数

for(ReturnLen=0;ReturnLen<7;ReturnLen++)
{
USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}
}
else if(USART5_RX_BUF[2]==0x5B) //读取已检测盘数
{
CHECK_ReadMotorPlace();

Card_NUM=CHEAK_FallMotorCurPlase/800;

if(CHEAK_FallMotorCurPlase%800>=790)
Card_NUM++;

ReturnData_7BY[2]=0x8B; //命令

ReturnData_7BY[3]=Card_NUM%0x100;  //盘数

ReturnData_7BY[4]=Card_NUM%0x100;  //盘数

for(ReturnLen=0;ReturnLen<7;ReturnLen++)
{
USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}
}
else if(USART5_RX_BUF[2]==0x5C) //读取自检结果
{

ReturnData_7BY[2]=0x8B; //命令

for(ReturnLen=0;ReturnLen<3;ReturnLen++)
{
USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据    //5A A5 8B
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}

for(ReturnLen=0;ReturnLen<16;ReturnLen++)
{
USART_SendData(UART5,CHECK_SelfInspectData[ReturnLen]);//向串口5发送数据    //自检16个字节数据
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}

for(ReturnLen=5;ReturnLen<7;ReturnLen++)
{
USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据    //0D 0A
while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
delay_us(10);
}
}
else if(USART5_RX_BUF[2]==0x5D) //电机运行
{
MOTOR_Run(1000,MOTOR_FALL,MOTOR_Forward);    //电机运行 10.00mm

// Run_Len=USART5_RX_BUF[5]*256+USART5_RX_BUF[6];
// MOTOR_Run(Run_Len,(MOTOR_TypeFlag)USART5_RX_BUF[3],(MOTOR_DirectFlag)USART5_RX_BUF[4]);
//
// for(ReturnLen=0;ReturnLen<7;ReturnLen++)
// {
// USART_SendData(UART5,ReturnData_7BY[ReturnLen]);//向串口5发送数据
// while(USART_GetFlagStatus(UART5,USART_FLAG_TC)!=SET);//等待发送结束
// delay_us(10);
// }

}
}
}