uart_deal.c

基于Cortex-M3的全自动焊接机

#include "define.h"
#include "globaltype.h"
#include "motor.h"
unsigned char error_report = 1;
unsigned char send_sem;//485发送信号量
extern unsigned char Uart_recBuf[];
extern struct placed_relate_parm palced_magor[];
extern unsigned char UartBufWp;
extern unsigned char TxData[];
extern unsigned int timerloadvalue;
extern unsigned char new_data_flag;
extern unsigned char Dirflag_Mor0;
extern unsigned char Dirflag_Mor1;
extern unsigned char Dirflag_Mor2;

extern unsigned char work_par_set(unsigned char motor, unsigned char usr_require);
extern void uart_driver_motor(unsigned char motor_number ,unsigned char usr_command);
extern void TxFIFOFill(void);
extern void start_timer1(unsigned char uc_delay);//定时uc_delay ms
unsigned char  deal_usr_data(void);

void clear_uart_buf(void);
void set_return_motordata(unsigned char motor_num);
void return_motor_data(void);
void fill_motor_data(unsigned char motor_num);
void return_ack(unsigned char ack_flag);
void  timeDelay(unsigned int  ulVal)
{
    for(;ulVal>0;ulVal--);
}

unsigned char  uart_rec_deal(void)
{
    static unsigned char data_deal_step = 0;
    unsigned int verify_sum = 0;
    unsigned char data_num;
    switch(data_deal_step)
    {
        case 0:
                if((Uart_recBuf[0]&0xf0)!=0xa0)//帧头校验
                {
                    return_ack(0);//参数0为出错应答
                    new_data_flag = 1;
                    send_sem = 1;//转为接收时发送信号量要置为零
                    start_timer1(30);//定时30ms
                    error_report = 0;
                    return error_report;
                }
                else data_deal_step = 1;//校验和 校验	
                //break;
        case 1:
                for(data_num =1;data_num < MAX_UART_REC_NUMBER-1;data_num++)
                {
                        verify_sum += Uart_recBuf[data_num];
                }
                if((verify_sum%255) == Uart_recBuf[data_num])
                {
                        data_deal_step = 2;	//数据散转处理
                }
                else 
                {
                        return_ack(0);//参数0为出错应答
                        new_data_flag = 1;
    
                        send_sem = 1;//转为接收时发送信号量要置为零
                        start_timer1(30);//定时30ms
                        error_report = 0;
                        return error_report;
                } 
                //break;
        case 2:
                data_deal_step = 0;
                return_ack(1);//参数1为正确应答
                new_data_flag = 1;

                send_sem = 1;//转为接收时发送信号量要置为零
                start_timer1(30);//定时30ms

                deal_usr_data();
                break;
    }
}

/*unsigned char  uart_rec_deal(void)
{
    unsigned int verify_sum = 0;
    unsigned char data_num;

    if((Uart_recBuf[0]&0xf0)!=0xa0)                                             //帧头校验
    {
        return_ack(0);                                                          //参数0为出错应答
        new_data_flag = 1;
        send_sem = 1;                                                           //转为接收时发送信号量要置为零
        start_timer1(30);                                                       //定时30ms
        error_report = 0;
     }
    else
    {
        for(data_num =1;data_num < MAX_UART_REC_NUMBER-1;data_num++)
        {
             verify_sum += Uart_recBuf[data_num];
        }
        if((verify_sum%255) == Uart_recBuf[data_num])
        {
            return_ack(1);                                                      //参数1为正确应答
            new_data_flag = 1;
            send_sem = 1;                                                       //转为接收时发送信号量要置为零
            start_timer1(30);                                                   //定时30ms
            deal_usr_data();
        }
        else 
        {
            return_ack(0);                                                      //参数0为出错应答
            new_data_flag = 1;
            send_sem = 1;                                                       //转为接收时发送信号量要置为零
            start_timer1(30);                                                   
            error_report = 0;
        }
    } 
    return error_report;
}*/

unsigned char  deal_usr_data(void)
{
    unsigned char i;
    switch(Uart_recBuf[0]&0x0f)                           //Uart_recBuf[0]为0x01处理数据；0x02发送电机状态数据
    { 
      case 0x01:
        if((Uart_recBuf[1]&0x10)==0x10)                        //判断En是否为一，为一可以改变电机状态
        {
            switch((Uart_recBuf[1]&0x0c)>>2)                        //第一台电机usr_require编号从0x01开始
            {
                case 0x01:                                   //固定速度，方向，不指定距离
                    work_par_set(0,0x01);                    //0号电机，工作需求1设置
                    break;
                case 0x02:                                   //固定速度指定距离和方向
                    work_par_set(0,0x02);                    //0号电机，工作需求2设置
                    break;
                case 0x03:                                   //停止
                    Motor1_Enable(Stop);
                    palced_magor[0].stop_sem = 1;
                    palced_magor[0].EncoCnt = 0;
                    palced_magor[0].IS_driver = 0;
                    break;
                case 0x00:                                  //清零绝对码 
                  
                    palced_magor[0].absulotely_code = 0;
                    Dirflag_Mor0 = 2;
                    break;
                default://其他情况扩展或返回错误
                    break;
            }
        }
        //第二台电机
        if((Uart_recBuf[5]&0x10)==0x10)
        {
            switch((Uart_recBuf[5]&0x0c)>>2)
            {
                case 0x01://固定速度，方向
                  work_par_set(1,0x01);
                  break;
                case 0x02:
                  work_par_set(1,0x02);
                  break;
                case 0x03:
                  Motor2_Enable(Stop);
                  palced_magor[1].stop_sem = 1;
                  palced_magor[1].EncoCnt = 0;
                  palced_magor[1].IS_driver = 0;
                  break;
                case 0x00:                                  //清零绝对码 
                    palced_magor[1].absulotely_code = 0;
                    Dirflag_Mor1 = 2;
                  break;
                default://其他情况扩展或返回错误
                  break;
            }
        }
        //第三台电机
        if((Uart_recBuf[9]&0x10)==0x10)
        {
            switch((Uart_recBuf[9]&0x0c)>>2)
            {
                case 0x01://固定速度，方向
                  work_par_set(2,0x01);
                  break;
                case 0x02:
                  work_par_set(2,0x02);
                  break;
                case 0x03:
                  Motor3_Enable(Stop);
                  palced_magor[2].stop_sem = 1;
                  palced_magor[2].EncoCnt = 0;
                  palced_magor[2].IS_driver = 0;//注意实际并没有真实停掉，这个变量名字不是很好
                  break;
                case 0x00:                                  //清零绝对码 
                    palced_magor[2].absulotely_code = 0;
                    Dirflag_Mor2 = 2;
                  break;
                default://其他情况扩展或返回错误
                  break;
            }
        }
        clear_uart_buf();
        for(i= 0;i<MOTOR_NUMBER;i++)
        {
            if(palced_magor[i].IS_driver)
            {
                uart_driver_motor(i,0x00);//工作参数设置完毕
            }
        }
        break;
      case 0x02://获取数据
        if((Uart_recBuf[1]==0xaa)&&(Uart_recBuf[2]==0x55))
        {            
            return_motor_data();
            new_data_flag = 1;
            send_sem = 1;//转为接收时发送信号量要置为零
            start_timer1(30);//定时30ms
        }

        else
        {
            error_report = 0;//要不要返回错误应答
            return error_report;
        }
        clear_uart_buf();
        break;
      case 0x03://应答
        if(Uart_recBuf[1]==0x55)
        {
             switch(Uart_recBuf[2])
             {
                case 0xaa:
                  return_motor_data();//重发数据
                  new_data_flag = 1;
                  send_sem = 1;//转为接收时发送信号量要置为零
                  start_timer1(30);//定时30ms
                  //TxFIFOFill();//几十ms之前的位置信息
                  break;
                case 0x55:
                  break;
                default:break;
             }
        }
        break;
      default: 
        error_report = 0;
        return error_report;
    }
    
}
void clear_uart_buf(void)
{
    unsigned char i;
    for(i=0;i<MAX_UART_REC_NUMBER;i++)
    {
        Uart_recBuf[i] = 0;
        UartBufWp = 0; 
    }
}
void return_motor_data(void)
{
    unsigned char i;
    unsigned int temp = 0;
    TxData[0] = 0xa1;//返回头
    for(i = 0;i<3;i++)
    {
        fill_motor_data(i);
    }
    for(i=1;i<=12;i++)
    {
        temp += TxData[i];
    }
    TxData[13] = temp % 255; 
    new_data_flag = 1;
}
void fill_motor_data(unsigned char motor_num)
{
    switch(motor_num)
    {
        case 0:
          set_return_motordata(0);
          break;
        case 1:
          set_return_motordata(1);
          break;
        case 2:
          set_return_motordata(2);
          break;
    }
}

void set_return_motordata(unsigned char motor_num)
{
    unsigned char temp;
    
    switch(motor_num)
    {
      case 0:
        temp = 1;
        break;
      case 1:
        temp = 5;
        break;
      case 2:
        temp = 9;
        break;
    }
    switch(palced_magor[motor_num].dir)
    {
      case Forward:
        TxData[temp] = 0x01;                                     //最低位为1表示正传
        break; 
      case Reverse:
        TxData[temp] = 0x00;                                     //防止上一次数据影响到此次设置数据
        break;
    }
    switch(palced_magor[motor_num].IS_driver)                    //检测电机何时停止,要确保真的停止
    {
      case 1:
        TxData[temp]+=0x02;                                      //第7位表示驱动位
        break;                                                   //电机驱动中
      case 0:
        TxData[temp]+=0x00;
        break;
    }
    switch(motor_num)//某台电机速速提取
    {
        case 0:
          temp = 2;
          break;
        case 1:
          temp = 6;
          break;
        case 2:
          temp = 10;
          break;
    }
    if(palced_magor[motor_num].not_normlation_timerunit)
    {
        TxData[temp] = timerloadvalue/(palced_magor[motor_num].not_normlation_timerunit);
    }
    else
    {
        TxData[temp] = 0x00;
    }
    switch(motor_num)
    {
        case 0:
          TxData[3] = palced_magor[0].absulotely_code>>8;//先发数据存放高位字节
          TxData[4] = palced_magor[0].absulotely_code;
          break;
        case 1:
          TxData[7] = palced_magor[1].absulotely_code>>8;//先发数据存放高位字节
          TxData[8] = palced_magor[1].absulotely_code;
          break;
        case 2:
          TxData[11] = palced_magor[2].absulotely_code>>8;//先发数据存放高位字节
          TxData[12] = palced_magor[2].absulotely_code;
          break;
    }
    
}
void return_ack(unsigned char ack_flag)
{
    unsigned char i;
    TxData[0] = 0xA3;
    TxData[1] = 0x55;
    switch(ack_flag)
    {
      case 0://出错
        TxData[2] = 0x55;
        break;
      case 1://正确
        TxData[2] = 0xAA;
        break;
    }
    for(i = 3;i<14;i++)
    {
        TxData[i] = 0x00;
    }
    
}