torsion/User/board/board.c

#include "board.h"
#include "motor.h"

void motor_process(frame_msg_t *rx, frame_msg_t *bk);
void sensor_procss(frame_msg_t *rx, frame_msg_t *bk);

/*************************************  串口通讯 *************************************/
uart_t *uarts[UART_NUM_MAX];
__IO static BOOL deal_done_flag = 0; // 数据处理标志
__IO static frame_msg_t rx_frame;
__IO static frame_msg_t bk_frame;
__IO static uint8_t send_buffer[UART_TXSIZE];

// 串口发送
static void host_send_msg(uint8_t *data, uint16_t len)
{
    uart_send_data(uarts[UART_NUM_1], data, len);
}

// 接收数据解码
static void host_data_decode(uint8_t *data, uint16_t len, frame_msg_t *msg)
{
    DBG_ASSERT(data != NULL __DBG_LINE);
    DBG_ASSERT(msg != NULL __DBG_LINE);

    msg->state = data[1];
    msg->dev_no = data[2];
    msg->cmd_no = data[3];
    msg->len = data[4];
    osel_memcpy(msg->data, (uint8_t *)&data[5], msg->len);
}

// 发送数据编码
static void send_data_encode(frame_msg_t *msg)
{
    uint16_t ver_len = 0, ver_crc = 0;
    uint8_t *sp = (uint8_t *)send_buffer;
    DBG_ASSERT(msg != NULL __DBG_LINE);

    *sp++ = PACKET_STX; // 包头
    ver_len++;
    *sp++ = msg->state; // 状态
    ver_len++;
    *sp++ = msg->dev_no; // 设备号
    ver_len++;
    *sp++ = msg->cmd_no; // 命令号
    ver_len++;
    *sp++ = msg->len; // 长度
    ver_len++;
    osel_memcpy(sp, msg->data, msg->len); // 数据
    sp += msg->len;
    ver_len += msg->len;

    ver_crc = crc16_compute((uint8_t *)&send_buffer[1], (ver_len - 1)); // 减去包头
    ver_crc = S2B_UINT16(ver_crc);
    osel_memcpy(sp, (uint8_t *)&ver_crc, 2); // 校验
    sp += 2;
    ver_len += 2;

    *sp++ = PACKET_ETX; // 包尾
    ver_len++;

    // 发送
    host_send_msg((uint8_t *)send_buffer, ver_len);
}

// 数据处理
void host_data_deal(void)
{
    frame_msg_t *rx_msg = (frame_msg_t *)&rx_frame;
    frame_msg_t *bk_msg = (frame_msg_t *)&bk_frame;

    if (deal_done_flag == TRUE)
    {
        return;
    }

    // 执行
    switch (rx_msg->dev_no)
    {
    case ADC_SENSOR:
        sensor_procss(rx_msg, bk_msg);
        break;
    case MOTOR:
        motor_process(rx_msg, bk_msg);
        break;
    default:
        return;
    }
    // 回复（组包 + 发送）
    send_data_encode(bk_msg);
    // 修改标志位
    deal_done_flag = TRUE;
    osel_memset((uint8_t *)rx_msg, 0, sizeof(rx_frame));
    osel_memset((uint8_t *)bk_msg, 0, sizeof(bk_frame));
}

// 数据完整性检查
static BOOL host_data_verify(uint8_t *data, uint16_t len)
{
    BOOL ret = TRUE;
    uint16_t ver_len = 0;
    uint16_t ver_crc = 0, rx_crc = 0;

    // 包头包尾检查
    if (data[0] != PACKET_STX || data[1] != MASTER_CODE || data[len - 1] != PACKET_ETX)
    {
        ret = FALSE;
        return ret;
    }
    // 帧长度检查
    ver_len = data[4] + PACKET_MIN_LEN;
    if (ver_len != len)
    {
        ret = FALSE;
        return ret;
    }
    // CRC校验
    ver_crc = crc16_compute((uint8_t *)(data + 1), (len - 4)); // 减去包头、包尾、校验
    ver_crc = S2B_UINT16(ver_crc);
    osel_memcpy((uint8_t *)&rx_crc, (uint8_t *)(data + len - 3), 2);
    if (ver_crc != rx_crc)
    {
        ret = FALSE;
        return ret;
    }

    return ret;
}

// 串口接收回调
static void host_rx_cb(uint8_t uart_index, uint8_t *data, uint16_t len)
{
    BOOL ret = FALSE;

    // 数据完整性检查
    ret = host_data_verify(data, len);
    // 数据处理
    if (ret == TRUE && deal_done_flag == TRUE)
    {
        host_data_decode(data, len, (frame_msg_t *)&rx_frame);
        deal_done_flag = FALSE;
    }
}

// 串口初始化
void host_uart_init(void)
{
    if (uarts[UART_NUM_1] == NULL)
    {
        uarts[UART_NUM_1] = uart_create(USART1, TRUE, UART_RXSIZE, host_rx_cb, TRUE, UART_TXSIZE, NULL);
        uarts[UART_NUM_1]->uart_index = UART_NUM_1;
        uarts[UART_NUM_1]->dma = DMA1;
        uarts[UART_NUM_1]->dma_rx_channel = LL_DMA_CHANNEL_3;
        uarts[UART_NUM_1]->dma_tx_channel = LL_DMA_CHANNEL_2;
        uart_recv_en(uarts[UART_NUM_1]);
    }
}

/*************************************  电机 *************************************/
// 电机对象
motor_t *motor;

// 电机初始化
static void motor_init(void)
{
    motor = motor_create(STEP_MOTOR);
    gpio_t dir = {
        .port = DIR_GPIO_Port,
        .pin = DIR_Pin,
    };
    gpio_t en = {
        .port = ENA_GPIO_Port,
        .pin = ENA_Pin,
    };
    motor->handle.step_motor.interface.init(motor, dir, en, MIN_STEP_ANGLE, TIM21, LL_TIM_CHANNEL_CH2);
}

// 电机任务
void motor_process(frame_msg_t *rx, frame_msg_t *bk)
{
    //    BOOL ret = TRUE;

    switch (rx->cmd_no)
    {
    case SET_MOTOR_SPEED: // 设置电机转速
        break;
    case SET_DRIVER_PULSE: // 设置驱动器脉冲
        break;
    case GET_MIN_STEP: // 获取最小步距
        break;
    case GET_MOTOR_STATE: // 获取电机运行状态
        break;
    case MOTOR_MOVE: // 运行电机
        break;
    case MOTOR_STOP: // 停止电机
        break;
    }

    bk->dev_no = MOTOR;
    bk->cmd_no = rx->cmd_no;
}

/*************************************  ADc传感器 *************************************/
// AD传感器
adc_t adc1 = {
    .adc = ADC1,
    .dma = DMA1,
    .dma_channel = LL_DMA_CHANNEL_1,
};

// 获取扭力值
static BOOL get_tors_value(frame_msg_t *bk)
{
    uint16_t value = 0;

    bk->len = sizeof(uint16_t);
    value = adc_get_result_average(IN13);
    value = S2B_UINT16(value);
    osel_memcpy(bk->data, (uint8_t *)&value, bk->len);
    return TRUE;
}

// 传感器任务
void sensor_procss(frame_msg_t *rx, frame_msg_t *bk)
{
    BOOL ret = TRUE;

    switch (rx->cmd_no)
    {
    case GET_TORS_VALUE: // 获取扭力值
        ret = get_tors_value(bk);
        break;
    }

    bk->state = ret;
    bk->dev_no = ADC_SENSOR;
    bk->cmd_no = rx->cmd_no;
}

/*************************************  板卡 *************************************/
// 板卡初始化
void board_init(void)
{
    motor = NULL;
    my_mem_init(SRAMIN);

    motor_init();     // 电机初始化
    adc_init(adc1);   // 初始化ADC1通道，默认采集AD
    host_uart_init(); // 串口初始化
    ENABLE_TIM(TIM6); // 任务流程定时器使能
}