Skip to main content

​
概述

嵌入式模块提供底层硬件驱动、RTOS 集成和通信协议实现。

​
支持平台

STM32

STM32F1/F4/H7 系列

ESP32

WiFi/蓝牙双模

​
架构设计

┌─────────────────────────────────────┐
│         Application                 │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│         FreeRTOS                    │
│  (任务调度、信号量、队列、事件组)     │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│         Hardware Abstraction        │
│  (HAL库、LL库、寄存器操作)           │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│         Hardware                    │
└─────────────────────────────────────┘

​
FreeRTOS 配置

// FreeRTOSConfig.h 关键配置
#define configUSE_PREEMPTION                    1
#define configUSE_IDLE_HOOK                     0
#define configUSE_TICK_HOOK                     0
#define configCPU_CLOCK_HZ                      168000000
#define configTICK_RATE_HZ                      1000
#define configMAX_PRIORITIES                    7
#define configMINIMAL_STACK_SIZE                128
#define configTOTAL_HEAP_SIZE                   32768

​
任务设计

// 任务优先级定义
#define TASK_PRIORITY_MOTOR_CONTROL     5
#define TASK_PRIORITY_SENSOR_READ       4
#define TASK_PRIORITY_COMMUNICATION     3
#define TASK_PRIORITY_DISPLAY           2
#define TASK_PRIORITY_IDLE              1

// 任务创建
void vCreateTasks(void) {
    xTaskCreate(
        vMotorControlTask,
        "Motor",
        configMINIMAL_STACK_SIZE * 4,
        NULL,
        TASK_PRIORITY_MOTOR_CONTROL,
        NULL
    );
    
    xTaskCreate(
        vSensorTask,
        "Sensor",
        configMINIMAL_STACK_SIZE * 2,
        NULL,
        TASK_PRIORITY_SENSOR_READ,
        NULL
    );
}

// 电机控制任务
void vMotorControlTask(void* pvParameters) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xFrequency = pdMS_TO_TICKS(10);  // 100Hz
    
    for (;;) {
        // 读取编码器
        encoderValue = readEncoder();
        
        // PID计算
        pidOutput = calculatePID(targetSpeed, encoderValue);
        
        // 输出PWM
        setMotorPWM(pidOutput);
        
        // 精确延时
        vTaskDelayUntil(&xLastWakeTime, xFrequency);
    }
}

​
通信协议

​
CAN Bus

// CAN 消息结构
typedef struct {
    uint32_t id;
    uint8_t data[8];
    uint8_t dlc;
} CAN_Message_t;

// 发送 CAN 消息
void CAN_SendMessage(uint32_t id, uint8_t* data, uint8_t len) {
    CAN_TxHeaderTypeDef header;
    header.StdId = id;
    header.ExtId = 0;
    header.IDE = CAN_ID_STD;
    header.RTR = CAN_RTR_DATA;
    header.DLC = len;
    
    HAL_CAN_AddTxMessage(&hcan, &header, data, &txMailbox);
}

// 中断接收
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef* hcan) {
    CAN_RxHeaderTypeDef header;
    uint8_t data[8];
    
    HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &header, data);
    
    // 放入队列处理
    CAN_Message_t msg = {
        .id = header.StdId,
        .dlc = header.DLC
    };
    memcpy(msg.data, data, header.DLC);
    xQueueSendFromISR(canRxQueue, &msg, NULL);
}

​
串口通信

// DMA 发送
void UART_SendDMA(uint8_t* data, uint16_t len) {
    HAL_UART_Transmit_DMA(&huart1, data, len);
}

// 中断接收 (空闲中断 + DMA)
void HAL_UART_IdleCpltCallback(UART_HandleTypeDef* huart) {
    // 计算接收长度
    uint16_t rxLen = RX_BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart->hdmarx);
    
    // 处理数据
    processRxData(rxBuffer, rxLen);
    
    // 重新启动接收
    HAL_UART_Receive_DMA(huart, rxBuffer, RX_BUFFER_SIZE);
}

​
驱动开发

​
GPIO 驱动

// 使用 HAL 库
void GPIO_Init(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    __HAL_RCC_GPIOA_CLK_ENABLE();
    
    GPIO_InitStruct.Pin = GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

​
PWM 输出

// TIM3 PWM 初始化
void PWM_Init(void) {
    TIM_HandleTypeDef htim3;
    TIM_OC_InitTypeDef sConfigOC = {0};
    
    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 84 - 1;  // 1MHz
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = 1000 - 1;   // 1kHz
    HAL_TIM_PWM_Init(&htim3);
    
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = 0;
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
    
    HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
}

// 设置占空比
void PWM_SetDuty(uint16_t duty) {
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, duty);
}

​
编码器读取

// TIM2 正交编码器模式
void Encoder_Init(void) {
    TIM_HandleTypeDef htim2;
    
    htim2.Instance = TIM2;
    htim2.Init.Prescaler = 0;
    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim2.Init.Period = 65535;
    HAL_TIM_Encoder_Init(&htim2, &sEncoderConfig);
    
    HAL_TIM_Encoder_Start(&htim2, TIM_CHANNEL_ALL);
}

// 获取编码器值
int16_t Encoder_GetCount(void) {
    return (int16_t)__HAL_TIM_GET_COUNTER(&htim2);
}

​
调试工具

// 断言宏
#define NEC_ASSERT(expr) \
    do { \
        if (!(expr)) { \
            NEC_AssertFailed(__FILE__, __LINE__, #expr); \
        } \
    } while(0)

// 日志输出
#define NEC_LOG_LEVEL_DEBUG 0
#define NEC_LOG_LEVEL_INFO  1
#define NEC_LOG_LEVEL_WARN  2
#define NEC_LOG_LEVEL_ERROR 3

#define NEC_LOG(level, fmt, ...) \
    printf("[%s] %s:%d " fmt "\r\n", \
           logLevelStr[level], __FILE__, __LINE__, ##__VA_ARGS__)