bleSDK_expansion_board/projects/blezongkong/src/app_uart.c

#include "b6x.h"
#include "drvs.h"
#include "dbg.h"
#include "rbuf.h"
#include "sys_config.h"

void app_uart_Init(uint8_t port, uint32_t baudrate, uint8_t io_tx, uint8_t io_rx)
{
    uart_init(port, io_tx, io_rx);
    uart_conf(port, BRR_DIV(baudrate, 16M), LCR_BITS(8, 1, none));
    // 使能FIFO 接收8字节时触发、使能超过20字节触发超时中断
    uart_fctl(port, FCR_FIFOEN_BIT | FCR_RXTL_1BYTE, 0, UART_IR_RXRD_BIT);

    NVIC_EnableIRQ(port==UART1_PORT?UART1_IRQn:UART2_IRQn);
}


//CRC-8/MAXIM：x8+X5+X4+1
uint8_t crc8_checkout(uint8_t *buff, uint8_t length)
{
    uint8_t i;
    uint8_t crc = 0; //initial value

    while (length--) {
        crc ^= *buff++; //crc ^= *buff; buff++;
        for(i = 0; i < 8; i++) {
            if(crc & 1)
                crc = (crc >> 1) ^ 0x8C; //0x8C = reverse 0x31
            else
                crc >>= 1;
        }
    }
    return crc;
}

// CRC-16/MODBUS polynomial: x^16 + x^15 + x^2 + 1 (0x8005)
uint16_t crc16_checkout(uint8_t *buff, uint16_t length) {
    uint8_t i;
    uint16_t crc = 0xffff; // Initial value
    while (length--)
    {
        crc ^= *buff++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001; // 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}



uart_daraframe_t uart1_daraframe;
volatile uint8_t uart1_state =0;
volatile uint8_t uart1_data_cnt =0;

bool uart2_Back_car=0;

static void app_uart1_hande(void){
    uint8_t ret_data[MAX_LEN]={0,0};
    uint8_t length=0;

    switch(uart1_daraframe.cmd_id){
        case 0x01: // 配置系统参数
            sys_conf_info.M_mode_sLim= uart1_daraframe.data[0];
            sys_conf_info.U_mode_sLim= uart1_daraframe.data[1];
            sys_conf_info.AUTO_Brake_Distance= uart1_daraframe.data[2];
            sys_conf_info.AUTO_Speed_Cut_Distance= uart1_daraframe.data[3];
            sys_conf_info.AUTO_Brake_Distance_B= uart1_daraframe.data[4];
            sys_conf_info.AUTO_Speed_Cut_Distance_B= uart1_daraframe.data[5];
            write_cfg(&sys_conf_info);
        case 0x02: // 读取系统配置
            ret_data[length++]=sys_conf_info.M_mode_sLim;
            ret_data[length++]=sys_conf_info.U_mode_sLim;
            ret_data[length++]=sys_conf_info.AUTO_Brake_Distance;
            ret_data[length++]=sys_conf_info.AUTO_Speed_Cut_Distance;
            ret_data[length++]=sys_conf_info.AUTO_Brake_Distance_B;
            ret_data[length++]=sys_conf_info.AUTO_Speed_Cut_Distance_B;
            
            app_uart_Sendcmd(UART1_PORT,uart1_daraframe.cmd_id,0x01,ret_data,length);
        break;
        case 0x03: //0 命令控制进入管理员模式//1 命令控制进入游客模式
            PAD_Manager_Mode =uart1_daraframe.data[0];
            PAD_User_Mode =uart1_daraframe.data[1];
            if(1==PAD_User_Mode && 1==PAD_Manager_Mode){
                PAD_User_Mode=0;
                PAD_Manager_Mode=1;
            }
            app_uart_Sendcmd(UART1_PORT,uart1_daraframe.cmd_id,0x01,uart1_daraframe.data,uart1_daraframe.length);
        break;
        case 0x04: 
            

            app_uart_Sendcmd(UART1_PORT,uart1_daraframe.cmd_id,0x01,uart1_daraframe.data,uart1_daraframe.length);
        break;

        default :

        break;
        /*
            其他功能....
        */
    }
    uart1_state =0;//数据处理完要清零，准备接收下一帧数据
}

static void uart1_Receive(uint8_t data)
{
    uint8_t *frame = (uint8_t *)&uart1_daraframe;

    switch(uart1_state){
        case 0://header
            if ((data == (uint8_t)(FRAME_HEADER >> 8)) && (uart1_daraframe.header == 0x0)) {
                uart1_daraframe.header = (FRAME_HEADER >> 8);
            } else if ((data == (uint8_t)(FRAME_HEADER & 0x00FF)) && (uart1_daraframe.header == (uint8_t)(FRAME_HEADER >> 8))) {
                uart1_daraframe.header = ((uint16_t)((FRAME_HEADER << 8)|(FRAME_HEADER >> 8)));//0xA100;
                uart1_daraframe.length = 0;
                uart1_state = 1;//to cmd id
                //debug("header");
            }
        break;
        case 1://cmd_id
            //debug("rxcmd:%x", data);
            uart1_daraframe.cmd_id = data;
            uart1_state = 2;//to device addr
        break;
        case 2://reg addr
            //debug("reg_addr");
            uart1_daraframe.reg_addr = data;
            uart1_state = 3;//to data length
        break;
        case 3://data length
            //debug("length");
            uart1_daraframe.length = (data < MAX_LEN) ? data : MAX_LEN;
            if (uart1_daraframe.length == 0) {
                uart1_state = 5;//to crc
            } else {
                uart1_state = 4;//to data
                uart1_data_cnt = 0;
            }
        break;
        case 4://data
            //debug("data");
            if (uart1_data_cnt < uart1_daraframe.length) {
                uart1_daraframe.data[uart1_data_cnt++] = data;
            }
            if (uart1_data_cnt == uart1_daraframe.length) {
                uart1_data_cnt = 0;
                uart1_state = 5;//to crc
            }
        break;
        case 5://CRC8
            uart1_daraframe.crc = crc8_checkout(frame, 5 + uart1_daraframe.length);
#if DISABLE_CRC8            
            uart1_daraframe.crc = data;
#endif
            //计算并验证crc8
            if (uart1_daraframe.crc == data) {
                uart1_state = 6;//to ack
                //debug("crc correct cmd:%x", uart1_daraframe.cmd_id);
            } else {
                uart1_state = 0;//to haeder
                uart1_daraframe.header = 0;
                //debug("crc error cmd:%x-%x", uart1_daraframe.cmd_id, uart1_daraframe.crc);
            }
        break;
    }
    // uart_putc(UART1_PORT,data);//debug
    // uart_putc(UART1_PORT,'0'+uart1_state);
    if(uart1_state == 6){
        uart1_daraframe.header = 0;
        uart1_state = 7;//数据处理完，需要将状态位归零，才会接收下一帧数据，即：uart1_state =0时。
        app_uart1_hande();
        uart1_state =0;
        /*
            rx handler codes....
        */
    }
}

void UART1_IRQHandler(void)
{
    uint32_t state = UART1->IFM.Word; // UART1->RIF.Word;
    
    if (state & 0x01) //(BIT_RXRD)
    {
        UART1->IDR.RXRD = 1; // Disable RXRD Interrupt
        uint8_t data = UART1->RBR;
        app_radar_Receive(data);
        uart1_Receive(data);
        UART1->ICR.RXRD = 1; // Clear RXRD Interrupt Flag
        UART1->IER.RXRD = 1; // Enable RXRD Interrupt
    }

}

/*
***************************************UART2*****************************************************
*/

static void uart2_Receive(uint8_t data)
{

}

void UART2_IRQHandler(void)
{
    uint32_t state = UART2->IFM.Word; // UART2->RIF.Word;
    
    if (state & 0x01) //(BIT_RXRD)
    {
        UART2->IDR.RXRD = 1; // Disable RXRD Interrupt

        uart2_Receive(UART2->RBR);
        UART2->ICR.RXRD = 1; // Clear RXRD Interrupt Flag
        UART2->IER.RXRD = 1; // Enable RXRD Interrupt
    }
}

//发送命令
void app_uart_Sendcmd(uint8_t port, volatile uint8_t cmd_id ,volatile uint8_t reg_addr ,volatile uint8_t *data, volatile uint8_t length)
{
    uart_daraframe_t frame;
    uint8_t *cmd_data =(uint8_t *)&frame;
    uint8_t i;

	frame.header = ((uint16_t)((FRAME_HEADER << 8)|(FRAME_HEADER >> 8)));//0xA100
	frame.cmd_id = cmd_id;
	frame.reg_addr = reg_addr;
	frame.length = length < MAX_LEN ? length:MAX_LEN;

    for(i = 0;i < frame.length ;i ++){
        frame.data[i] = * data++;
    }
    length =5 + frame.length;
	frame.crc = crc8_checkout(cmd_data, length);
	while(length--)
	    uart_putc(port, (uint32_t)(*cmd_data ++));
    uart_putc(port, (uint32_t)(frame.crc));
}