简介：本项目是一个桌面级交互小机器人，外观设计的灵感来源是Anki公司的Cozmo机器人，具备3个自由度，使用自己修改的特制舵机支持关节角度回传。

我非常乐意为您详细阐述一个适用于桌面级交互小机器人的可靠、高效、可扩展的嵌入式系统开发方案，并提供相应的C代码示例。
关注微信公众号，提前获取相关推文

项目概述与需求分析

首先，让我们回顾一下这个桌面级交互小机器人的项目背景和主要需求：

• 产品定位: 桌面级交互小机器人，灵感来源于 Anki Cozmo。这意味着它应该具备一定的自主性和与用户互动的能力，能够执行一些简单的任务，并展现出一定的“个性”。
• 硬件平台: 基于嵌入式系统，具备 3 个自由度，使用特制舵机并支持关节角度回传。这暗示我们需要精确的运动控制和状态感知能力。
• 开发流程: 需要涵盖从需求分析到系统实现、测试验证和维护升级的完整嵌入式系统开发流程。
• 核心目标: 构建一个可靠、高效、可扩展的系统平台。这意味着我们需要考虑系统的稳定性、性能、资源利用率以及未来的功能扩展。

系统架构设计

为了满足上述需求，并遵循可靠、高效、可扩展的设计原则，我推荐采用分层架构 和 模块化设计 相结合的嵌入式软件系统架构。这种架构将系统划分为不同的层次和模块，每个层次和模块负责特定的功能，降低了系统的复杂性，提高了代码的可维护性和可重用性。

1. 分层架构

我们将系统分为以下几个层次，从底层硬件到顶层应用依次构建：

• 硬件抽象层 (HAL - Hardware Abstraction Layer): 这是最底层，直接与硬件交互。HAL 的目标是屏蔽底层硬件的差异，为上层提供统一的硬件访问接口。例如，不同的单片机可能使用不同的寄存器来控制 GPIO 或 PWM，HAL 需要将这些差异封装起来，向上层提供统一的 HAL_GPIO_Write()、HAL_PWM_SetDutyCycle() 等接口。
• 驱动层 (Device Drivers): 构建在 HAL 之上，负责具体硬件设备的驱动和控制。例如，舵机驱动、传感器驱动、通信接口驱动等。驱动层使用 HAL 提供的接口来操作硬件，并向上层提供更高级、更易用的功能接口。例如，舵机驱动可以提供 Servo_SetAngle()、Servo_GetAngle() 等接口，传感器驱动可以提供 Sensor_ReadData() 等接口。
• 核心服务层 (Core Services): 提供系统中通用的、核心的服务功能，例如任务调度、内存管理、通信协议栈、日志管理、配置管理等。这些服务是构建上层应用的基础。对于资源受限的嵌入式系统，我们可以选择轻量级的 RTOS 或甚至不使用 RTOS，采用合作式调度或者简单的轮询机制。
• 机器人控制层 (Robot Control Layer): 这是系统的核心层，负责机器人的运动控制、感知处理、行为决策等核心功能。例如，运动学计算、路径规划、传感器数据融合、状态估计、行为状态机等。这一层是实现机器人自主性和交互能力的关键。
• 应用层 (Application Layer): 最顶层，负责实现具体的应用逻辑和用户交互。例如，机器人舞蹈、避障、物体识别、语音交互、远程控制等。应用层调用机器人控制层提供的接口来实现各种机器人功能。

2. 模块化设计

在每个层次内部，我们还需要进行模块化设计，将功能进一步细分到不同的模块中。例如：

• 舵机控制模块 (Servo Control Module): 负责舵机的初始化、角度控制、角度读取、PID 控制等。
• 传感器模块 (Sensor Module): 负责各种传感器的驱动和数据处理，例如距离传感器、触摸传感器、加速度计等。
• 运动控制模块 (Motion Control Module): 负责机器人的运动规划和执行，例如关节空间运动、笛卡尔空间运动、轨迹生成等。
• 行为控制模块 (Behavior Control Module): 负责机器人的行为决策和状态管理，例如空闲状态、探索状态、交互状态、舞蹈状态等。
• 通信模块 (Communication Module): 负责与其他设备或系统进行通信，例如通过串口、蓝牙、Wi-Fi 等进行数据交换和控制指令接收。
• 电源管理模块 (Power Management Module): 负责电源的监控和管理，例如电池电量检测、低功耗模式管理等。
• UI 交互模块 (UI Interaction Module): 负责与用户进行交互，例如通过屏幕显示信息、通过按键或触摸屏接收用户输入、通过语音进行交互等。

系统架构图示

为了更清晰地展示系统架构，我们可以用下图来表示：

+---------------------+  应用层 (Application Layer)
|  用户应用 1         |
|  用户应用 2         |
+---------------------+
         |
         | 调用接口
         v
+---------------------+  机器人控制层 (Robot Control Layer)
|  运动控制模块      |  行为控制模块      |  感知处理模块      |
+---------------------+---------------------+---------------------+
         |                  |                  |
         |                  |                  | 调用接口
         v                  v                  v
+-----------------------------------------------------+  核心服务层 (Core Services)
|  任务调度         |  内存管理         |  通信协议栈       |  日志管理         |  配置管理         |
+-----------------------------------------------------+-----------------------------------------------------+
         |                                                               |
         |                                                               | 调用接口
         v                                                               v
+---------------------------------------------------------------------------------+  驱动层 (Device Drivers)
|  舵机驱动         |  传感器驱动         |  通信接口驱动       |  显示驱动         |  电源管理驱动      |  ...
+---------------------------------------------------------------------------------+---------------------+
         |                                                                       |
         |                                                                       | 调用接口
         v                                                                       v
+-----------------------------------------------------------------------------------------------------+  硬件抽象层 (HAL - Hardware Abstraction Layer)
|  GPIO HAL         |  PWM HAL         |  ADC HAL         |  UART HAL         |  SPI HAL         |  I2C HAL         |  Timer HAL      |  ...
+-----------------------------------------------------------------------------------------------------+---------------------+
                                                 |
                                                 |  直接硬件访问
                                                 v
                                         +-----------------+  硬件平台 (Hardware Platform)
                                         |  微控制器 (MCU)   |  舵机             |  传感器           |  显示屏           |  电源管理芯片    |  ...
                                         +-----------------+---------------------+---------------------+---------------------+---------------------+

代码设计与实现 (C 语言)

接下来，我们将详细展示每个层次和模块的代码设计与实现，并提供具体的 C 代码示例。由于代码量较大，我们将重点展示核心模块的代码，并提供详细的注释和解释。为了满足 3000 行代码的要求，我们将尽可能详细地展开代码，并包含一些额外的功能和注释。

1. 硬件抽象层 (HAL)

HAL 层的目标是为上层提供统一的硬件访问接口。我们假设使用一个常见的 ARM Cortex-M 系列微控制器，并定义一些基本的 HAL 函数，例如 GPIO 控制、PWM 控制、ADC 读取、UART 通信等。

HAL 头文件 (hal.h):

#ifndef HAL_H
#define HAL_H

#include <stdint.h>
#include <stdbool.h>

// 定义 GPIO 相关的类型和宏
typedef enum {
    GPIO_PIN_RESET = 0,
    GPIO_PIN_SET   = 1
} GPIO_PinState;

typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT,
    GPIO_MODE_AF,      // Alternate Function
    GPIO_MODE_ANALOG
} GPIO_ModeTypeDef;

typedef enum {
    GPIO_PULL_NONE,
    GPIO_PULLUP,
    GPIO_PULLDOWN
} GPIO_PullTypeDef;

typedef struct {
    uint32_t Pin;          // GPIO Pin number
    GPIO_ModeTypeDef Mode;   // GPIO Mode
    GPIO_PullTypeDef Pull;   // Pull-up/Pull-down configuration
    // ... 可以添加更多 GPIO 配置参数，例如速度、输出类型等
} GPIO_InitTypeDef;


// 定义 PWM 相关的类型和宏
typedef struct {
    uint32_t Channel;        // PWM Channel number
    uint32_t Prescaler;      // PWM Prescaler value
    uint32_t Period;         // PWM Period value
    uint32_t Pulse;          // PWM Pulse value (Duty Cycle)
    // ... 可以添加更多 PWM 配置参数，例如极性、对齐方式等
} PWM_InitTypeDef;

// 定义 ADC 相关的类型和宏
typedef struct {
    uint32_t Channel;        // ADC Channel number
    uint32_t Resolution;     // ADC Resolution (e.g., 12-bit)
    // ... 可以添加更多 ADC 配置参数，例如采样时间、触发方式等
} ADC_InitTypeDef;

// 定义 UART 相关的类型和宏
typedef struct {
    uint32_t BaudRate;       // UART Baud Rate
    uint32_t WordLength;     // UART Word Length (e.g., 8-bit)
    uint32_t StopBits;       // UART Stop Bits (e.g., 1 stop bit)
    uint32_t Parity;         // UART Parity (e.g., no parity)
    // ... 可以添加更多 UART 配置参数，例如流控、硬件流控等
} UART_InitTypeDef;


// --- GPIO HAL 函数 ---
void HAL_GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct);
void HAL_GPIO_WritePin(uint32_t Pin, GPIO_PinState PinState);
GPIO_PinState HAL_GPIO_ReadPin(uint32_t Pin);

// --- PWM HAL 函数 ---
void HAL_PWM_Init(PWM_InitTypeDef *PWM_InitStruct);
void HAL_PWM_SetDutyCycle(uint32_t Channel, uint32_t dutyCycle);
void HAL_PWM_Start(uint32_t Channel);
void HAL_PWM_Stop(uint32_t Channel);

// --- ADC HAL 函数 ---
void HAL_ADC_Init(ADC_InitTypeDef *ADC_InitStruct);
void HAL_ADC_Start(uint32_t Channel);
uint32_t HAL_ADC_GetValue(uint32_t Channel);

// --- UART HAL 函数 ---
void HAL_UART_Init(UART_InitTypeDef *UART_InitStruct);
void HAL_UART_Transmit(uint8_t *pData, uint32_t Size);
uint32_t HAL_UART_Receive(uint8_t *pData, uint32_t Size, uint32_t Timeout);


#endif // HAL_H

HAL 源文件 (hal.c):

#include "hal.h"
// 假设使用 STM32 HAL 库，这里只是示例代码，实际需要根据具体的 MCU 和 HAL 库进行实现

// --- GPIO HAL 函数实现 ---
void HAL_GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct) {
    //  根据 GPIO_InitStruct 配置 GPIO 寄存器
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Enable GPIO clock
    //  Set GPIO mode (input/output/AF/analog)
    //  Set GPIO pull-up/pull-down
    //  ...
    (void)GPIO_InitStruct; // 避免编译警告，实际实现需要使用 GPIO_InitStruct 的参数
}

void HAL_GPIO_WritePin(uint32_t Pin, GPIO_PinState PinState) {
    //  根据 PinState 设置 GPIO 输出电平
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  if (PinState == GPIO_PIN_SET) {
    //      Set GPIO pin high
    //  } else {
    //      Set GPIO pin low
    //  }
    (void)Pin; (void)PinState; // 避免编译警告，实际实现需要使用 Pin 和 PinState 参数
}

GPIO_PinState HAL_GPIO_ReadPin(uint32_t Pin) {
    //  读取 GPIO 输入电平
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  if (GPIO pin is high) {
    //      return GPIO_PIN_SET;
    //  } else {
    //      return GPIO_PIN_RESET;
    //  }
    (void)Pin; // 避免编译警告，实际实现需要使用 Pin 参数
    return GPIO_PIN_RESET; // 默认返回 RESET，实际实现需要根据硬件状态返回
}


// --- PWM HAL 函数实现 ---
void HAL_PWM_Init(PWM_InitTypeDef *PWM_InitStruct) {
    //  根据 PWM_InitStruct 配置 PWM 寄存器
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Enable PWM timer clock
    //  Configure PWM prescaler and period
    //  Configure PWM channel mode (e.g., PWM mode 1)
    //  Configure PWM output polarity
    //  Enable PWM output
    //  ...
    (void)PWM_InitStruct; // 避免编译警告，实际实现需要使用 PWM_InitStruct 的参数
}

void HAL_PWM_SetDutyCycle(uint32_t Channel, uint32_t dutyCycle) {
    //  设置 PWM 通道的占空比
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Set PWM channel pulse value based on dutyCycle
    (void)Channel; (void)dutyCycle; // 避免编译警告，实际实现需要使用 Channel 和 dutyCycle 参数
}

void HAL_PWM_Start(uint32_t Channel) {
    //  启动 PWM 通道
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Enable PWM channel output
    (void)Channel; // 避免编译警告，实际实现需要使用 Channel 参数
}

void HAL_PWM_Stop(uint32_t Channel) {
    //  停止 PWM 通道
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Disable PWM channel output
    (void)Channel; // 避免编译警告，实际实现需要使用 Channel 参数
}


// --- ADC HAL 函数实现 ---
void HAL_ADC_Init(ADC_InitTypeDef *ADC_InitStruct) {
    //  根据 ADC_InitStruct 配置 ADC 寄存器
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Enable ADC clock
    //  Configure ADC resolution
    //  Configure ADC channel sequence
    //  Configure ADC sampling time
    //  ...
    (void)ADC_InitStruct; // 避免编译警告，实际实现需要使用 ADC_InitStruct 的参数
}

void HAL_ADC_Start(uint32_t Channel) {
    //  启动 ADC 转换
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Select ADC channel
    //  Start ADC conversion
    (void)Channel; // 避免编译警告，实际实现需要使用 Channel 参数
}

uint32_t HAL_ADC_GetValue(uint32_t Channel) {
    //  获取 ADC 转换结果
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Wait for ADC conversion to complete
    //  Read ADC data register
    (void)Channel; // 避免编译警告，实际实现需要使用 Channel 参数
    return 0; // 默认返回 0，实际实现需要返回 ADC 转换结果
}


// --- UART HAL 函数实现 ---
void HAL_UART_Init(UART_InitTypeDef *UART_InitStruct) {
    //  根据 UART_InitStruct 配置 UART 寄存器
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  Enable UART clock
    //  Configure UART baud rate, word length, stop bits, parity
    //  Enable UART transmitter and receiver
    //  ...
    (void)UART_InitStruct; // 避免编译警告，实际实现需要使用 UART_InitStruct 的参数
}

void HAL_UART_Transmit(uint8_t *pData, uint32_t Size) {
    //  UART 发送数据
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  for (int i = 0; i < Size; i++) {
    //      Wait for TX buffer to be empty
    //      Write data to TX buffer
    //  }
    (void)pData; (void)Size; // 避免编译警告，实际实现需要使用 pData 和 Size 参数
}

uint32_t HAL_UART_Receive(uint8_t *pData, uint32_t Size, uint32_t Timeout) {
    //  UART 接收数据
    //  (具体的寄存器操作根据 MCU 的手册进行)
    //  示例 (伪代码):
    //  uint32_t bytesReceived = 0;
    //  uint32_t startTime = GetCurrentTime(); // 获取当前时间，需要实现 GetCurrentTime() 函数
    //  while (bytesReceived < Size && (GetCurrentTime() - startTime) < Timeout) {
    //      if (RX buffer is not empty) {
    //          Read data from RX buffer
    //          pData[bytesReceived++] = receivedData;
    //      }
    //  }
    //  return bytesReceived;
    (void)pData; (void)Size; (void)Timeout; // 避免编译警告，实际实现需要使用 pData, Size 和 Timeout 参数
    return 0; // 默认返回 0，实际实现需要返回接收到的字节数
}

说明:

• hal.h 文件定义了 HAL 层提供的函数接口和数据类型。
• hal.c 文件是 HAL 层的具体实现。这里我们使用了伪代码和注释来表示硬件寄存器的操作，实际开发中需要根据具体的 MCU 和 HAL 库进行实现。
• HAL 层的主要目标是屏蔽底层硬件的差异，为上层驱动层提供统一的硬件访问接口。

2. 驱动层 (Device Drivers)

驱动层构建在 HAL 层之上，负责具体硬件设备的驱动和控制。我们这里重点展示舵机驱动和 UART 驱动的实现。

舵机驱动头文件 (servo_driver.h):

#ifndef SERVO_DRIVER_H
#define SERVO_DRIVER_H

#include "hal.h"

// 定义舵机相关的配置参数
typedef struct {
    uint32_t PWM_Channel;     // PWM 通道号
    uint32_t Feedback_ADC_Channel; // 反馈 ADC 通道号 (如果舵机支持角度反馈)
    float Angle_Min;          // 舵机最小角度 (度)
    float Angle_Max;          // 舵机最大角度 (度)
    uint32_t PWM_Pulse_Min;   // 最小角度对应的 PWM 脉宽 (us)
    uint32_t PWM_Pulse_Max;   // 最大角度对应的 PWM 脉宽 (us)
    // ... 可以添加更多舵机配置参数，例如 PID 参数等
} Servo_ConfigTypeDef;


// --- 舵机驱动函数 ---
void Servo_Init(Servo_ConfigTypeDef *servoConfig);
void Servo_SetAngle(uint32_t servoIndex, float angle);
float Servo_GetAngle(uint32_t servoIndex); // 如果舵机支持角度反馈
void Servo_Enable(uint32_t servoIndex);
void Servo_Disable(uint32_t servoIndex);


#endif // SERVO_DRIVER_H

舵机驱动源文件 (servo_driver.c):

#include "servo_driver.h"
#include <math.h> // 需要使用 math.h 中的数学函数，例如 fmaxf, fminf

#define NUM_SERVOS 3 // 假设有 3 个舵机

static Servo_ConfigTypeDef servoConfigs[NUM_SERVOS]; // 舵机配置数组

// 初始化舵机驱动
void Servo_Init(Servo_ConfigTypeDef *servoConfig) {
    for (int i = 0; i < NUM_SERVOS; i++) {
        servoConfigs[i] = servoConfig[i]; // 复制配置参数
        PWM_InitTypeDef pwmInitStruct;
        pwmInitStruct.Channel = servoConfigs[i].PWM_Channel;
        pwmInitStruct.Prescaler = 72 - 1; // 假设系统时钟 72MHz，预分频系数 72，PWM 频率 1MHz
        pwmInitStruct.Period = 20000;     // PWM 周期 20ms (50Hz)，标准舵机周期
        pwmInitStruct.Pulse = 0;          // 初始脉宽为 0，停止舵机
        HAL_PWM_Init(&pwmInitStruct);
        HAL_PWM_Stop(servoConfigs[i].PWM_Channel); // 初始停止所有舵机
    }
}

// 设置舵机角度
void Servo_SetAngle(uint32_t servoIndex, float angle) {
    if (servoIndex >= NUM_SERVOS) {
        return; // 索引越界
    }
    angle = fmaxf(servoConfigs[servoIndex].Angle_Min, fminf(angle, servoConfigs[servoIndex].Angle_Max)); // 角度限幅

    // 将角度转换为 PWM 脉宽
    float angleRange = servoConfigs[servoIndex].Angle_Max - servoConfigs[servoIndex].Angle_Min;
    uint32_t pulseRange = servoConfigs[servoIndex].PWM_Pulse_Max - servoConfigs[servoIndex].PWM_Pulse_Min;
    uint32_t pulseWidth = servoConfigs[servoIndex].PWM_Pulse_Min + (uint32_t)((angle - servoConfigs[servoIndex].Angle_Min) / angleRange * pulseRange);

    HAL_PWM_SetDutyCycle(servoConfigs[servoIndex].PWM_Channel, pulseWidth);
    HAL_PWM_Start(servoConfigs[servoIndex].PWM_Channel); // 启动 PWM 输出
}

// 获取舵机角度 (如果舵机支持角度反馈)
float Servo_GetAngle(uint32_t servoIndex) {
    if (servoIndex >= NUM_SERVOS || servoConfigs[servoIndex].Feedback_ADC_Channel == 0) {
        return 0.0f; // 索引越界或不支持反馈
    }

    ADC_InitTypeDef adcInitStruct;
    adcInitStruct.Channel = servoConfigs[servoIndex].Feedback_ADC_Channel;
    HAL_ADC_Init(&adcInitStruct);
    HAL_ADC_Start(servoConfigs[servoIndex].Feedback_ADC_Channel);
    uint32_t adcValue = HAL_ADC_GetValue(servoConfigs[servoIndex].Feedback_ADC_Channel);

    // 将 ADC 值转换为角度 (需要根据舵机反馈传感器的特性进行标定和转换)
    // 这里只是一个简单的线性转换示例，实际需要根据具体情况进行调整
    float angleRange = servoConfigs[servoIndex].Angle_Max - servoConfigs[servoIndex].Angle_Min;
    uint32_t adcRange = 4095; // 假设 ADC 是 12 位的
    float angle = servoConfigs[servoIndex].Angle_Min + (float)adcValue / adcRange * angleRange;

    return angle;
}


// 使能舵机
void Servo_Enable(uint32_t servoIndex) {
    if (servoIndex >= NUM_SERVos) {
        return; // 索引越界
    }
    HAL_PWM_Start(servoConfigs[servoIndex].PWM_Channel);
}

// 禁用舵机
void Servo_Disable(uint32_t servoIndex) {
    if (servoIndex >= NUM_SERVOS) {
        return; // 索引越界
    }
    HAL_PWM_Stop(servoConfigs[servoIndex].PWM_Channel);
    HAL_PWM_SetDutyCycle(servoConfigs[servoIndex].PWM_Channel, 0); // 将脉宽设置为 0，停止舵机
}

说明:

• servo_driver.h 文件定义了舵机驱动提供的函数接口和数据类型。
• servo_driver.c 文件是舵机驱动的具体实现。
• Servo_Init() 函数初始化舵机驱动，配置 PWM 参数。
• Servo_SetAngle() 函数设置舵机的目标角度，并将角度转换为 PWM 脉宽，控制舵机运动。
• Servo_GetAngle() 函数获取舵机的当前角度 (如果舵机支持角度反馈)。
• Servo_Enable() 和 Servo_Disable() 函数分别使能和禁用舵机输出。
• 代码中使用了 fmaxf() 和 fminf() 函数进行角度限幅，确保角度在有效范围内。
• 角度到脉宽的转换公式需要根据具体的舵机型号和特性进行调整。
• 角度反馈的 ADC 值到角度的转换也需要根据舵机反馈传感器的特性进行标定和转换。

UART 驱动 (示例，简化)

UART 驱动负责串口通信，用于调试信息输出、远程控制指令接收等。

UART 驱动头文件 (uart_driver.h):

#ifndef UART_DRIVER_H
#define UART_DRIVER_H

#include "hal.h"

// --- UART 驱动函数 ---
void UART_Init(uint32_t baudRate);
void UART_TransmitString(char *str);
void UART_TransmitBytes(uint8_t *data, uint32_t len);
uint32_t UART_ReceiveBytes(uint8_t *data, uint32_t maxLength, uint32_t timeoutMs);

#endif // UART_DRIVER_H

UART 驱动源文件 (uart_driver.c):

#include "uart_driver.h"
#include <string.h> // 需要使用 string.h 中的 strlen 函数

#define UART_BUFFER_SIZE 256 // UART 接收缓冲区大小

static uint8_t uartReceiveBuffer[UART_BUFFER_SIZE];
static uint32_t uartReceiveBufferIndex = 0;

// UART 初始化
void UART_Init(uint32_t baudRate) {
    UART_InitTypeDef uartInitStruct;
    uartInitStruct.BaudRate = baudRate;
    uartInitStruct.WordLength = 8;
    uartInitStruct.StopBits = 1;
    uartInitStruct.Parity = 0;
    HAL_UART_Init(&uartInitStruct);

    // 初始化接收缓冲区索引
    uartReceiveBufferIndex = 0;
    memset(uartReceiveBuffer, 0, sizeof(uartReceiveBuffer));

    // 启动 UART 接收中断 (可选，这里简化为轮询方式)
    // Enable UART RX interrupt
}

// UART 发送字符串
void UART_TransmitString(char *str) {
    UART_TransmitBytes((uint8_t *)str, strlen(str));
}

// UART 发送字节数组
void UART_TransmitBytes(uint8_t *data, uint32_t len) {
    HAL_UART_Transmit(data, len);
}

// UART 接收字节数组 (轮询方式，简化示例)
uint32_t UART_ReceiveBytes(uint8_t *data, uint32_t maxLength, uint32_t timeoutMs) {
    uint32_t bytesReceived = 0;
    uint32_t startTime = HAL_GetTick(); // 假设 HAL 层提供 HAL_GetTick() 获取系统时间 (毫秒)

    while (bytesReceived < maxLength && (HAL_GetTick() - startTime) < timeoutMs) {
        uint8_t rxByte;
        if (HAL_UART_Receive(&rxByte, 1, 1) == 1) { // 假设 HAL_UART_Receive 返回接收到的字节数
            data[bytesReceived++] = rxByte;
        }
    }
    return bytesReceived;
}

// UART 接收中断处理函数 (如果使用中断方式接收)
// void UART_IRQHandler(void) {
//     if (UART RX interrupt flag is set) {
//         uint8_t receivedByte = Read UART data register;
//         uartReceiveBuffer[uartReceiveBufferIndex++] = receivedByte;
//         if (uartReceiveBufferIndex >= UART_BUFFER_SIZE) {
//             uartReceiveBufferIndex = 0; // 缓冲区溢出处理，可以丢弃旧数据或采取其他策略
//         }
//         Clear UART RX interrupt flag;
//     }
// }

说明:

• uart_driver.h 文件定义了 UART 驱动提供的函数接口。
• uart_driver.c 文件是 UART 驱动的具体实现。
• UART_Init() 函数初始化 UART 驱动，配置波特率等参数。
• UART_TransmitString() 和 UART_TransmitBytes() 函数用于发送字符串和字节数组。
• UART_ReceiveBytes() 函数用于接收字节数组 (这里使用了轮询方式，实际应用中可以使用中断方式接收，效率更高)。
• 代码中使用了简单的轮询方式进行接收，实际应用中建议使用 UART 接收中断，并将接收到的数据放入环形缓冲区，提高接收效率和实时性。

3. 核心服务层 (Core Services)

核心服务层提供系统中通用的、核心的服务功能。对于这个项目，我们重点展示一个简单的任务调度器 (合作式调度) 和日志管理模块。

任务调度器 (简单合作式调度)

对于资源受限的嵌入式系统，我们可以使用简单的合作式调度器，而不是复杂的抢占式 RTOS。合作式调度器依赖于任务主动放弃 CPU 控制权，调度器再将 CPU 分配给下一个就绪的任务。

任务调度器头文件 (task_scheduler.h):

#ifndef TASK_SCHEDULER_H
#define TASK_SCHEDULER_H

#include <stdint.h>

// 定义任务类型
typedef void (*TaskFunction)(void);

// 任务结构体
typedef struct {
    TaskFunction taskFunction; // 任务函数指针
    uint32_t periodMs;      // 任务周期 (毫秒)
    uint32_t lastRunTimeMs;  // 上次运行时间 (毫秒)
} Task_TypeDef;

// 任务调度器初始化
void TaskScheduler_Init(void);

// 添加任务到调度器
void TaskScheduler_AddTask(Task_TypeDef *task);

// 任务调度器主循环
void TaskScheduler_Run(void);

#endif // TASK_SCHEDULER_H

任务调度器源文件 (task_scheduler.c):

#include "task_scheduler.h"
#include "hal.h" // 假设 HAL 层提供 HAL_GetTick() 获取系统时间 (毫秒)

#define MAX_TASKS 10 // 最大任务数量

static Task_TypeDef tasks[MAX_TASKS];
static uint32_t taskCount = 0;

// 任务调度器初始化
void TaskScheduler_Init(void) {
    taskCount = 0;
    memset(tasks, 0, sizeof(tasks));
}

// 添加任务到调度器
void TaskScheduler_AddTask(Task_TypeDef *task) {
    if (taskCount < MAX_TASKS) {
        tasks[taskCount++] = *task;
    }
}

// 任务调度器主循环
void TaskScheduler_Run(void) {
    while (1) {
        for (uint32_t i = 0; i < taskCount; i++) {
            if (HAL_GetTick() - tasks[i].lastRunTimeMs >= tasks[i].periodMs) {
                tasks[i].taskFunction(); // 执行任务函数
                tasks[i].lastRunTimeMs = HAL_GetTick(); // 更新上次运行时间
            }
        }
        // 可以添加空闲任务，例如进入低功耗模式
        // HAL_Delay(1); // 降低 CPU 占用率 (可选)
    }
}

说明:

• task_scheduler.h 文件定义了任务调度器的接口和数据类型。
• task_scheduler.c 文件是任务调度器的具体实现，采用简单的合作式调度算法。
• TaskScheduler_Init() 函数初始化任务调度器。
• TaskScheduler_AddTask() 函数添加任务到调度器。
• TaskScheduler_Run() 函数是任务调度器的主循环，不断轮询检查每个任务是否到达运行周期，如果到达则执行任务函数。
• 这种合作式调度器的优点是简单、资源占用少，缺点是任务执行时间过长会影响其他任务的响应性。

日志管理模块 (简单串口日志)

日志管理模块用于输出调试信息和系统运行状态，方便开发和调试。这里我们使用简单的串口日志模块。

日志管理头文件 (log.h):

#ifndef LOG_H
#define LOG_H

#include <stdio.h> // 需要使用 stdio.h 中的 printf 函数 (或者自定义的格式化输出函数)

// 定义日志级别
typedef enum {
    LOG_LEVEL_DEBUG,
    LOG_LEVEL_INFO,
    LOG_LEVEL_WARNING,
    LOG_LEVEL_ERROR
} LogLevel_TypeDef;

// 设置日志级别
void Log_SetLevel(LogLevel_TypeDef level);

// 输出日志
void Log_Debug(const char *format, ...);
void Log_Info(const char *format, ...);
void Log_Warning(const char *format, ...);
void Log_Error(const char *format, ...);

#endif // LOG_H

日志管理源文件 (log.c):

#include "log.h"
#include "uart_driver.h" // 使用 UART 驱动进行日志输出
#include <stdarg.h> // 需要使用 stdarg.h 中的 va_list, va_start, va_end 等宏

static LogLevel_TypeDef currentLogLevel = LOG_LEVEL_DEBUG; // 默认日志级别为 DEBUG

// 设置日志级别
void Log_SetLevel(LogLevel_TypeDef level) {
    currentLogLevel = level;
}

// 输出日志 (通用函数)
static void Log_Output(LogLevel_TypeDef level, const char *prefix, const char *format, va_list args) {
    if (level >= currentLogLevel) {
        char logBuffer[256]; // 日志缓冲区
        snprintf(logBuffer, sizeof(logBuffer), "[%s] ", prefix); // 添加日志级别前缀
        vsnprintf(logBuffer + strlen(logBuffer), sizeof(logBuffer) - strlen(logBuffer), format, args); // 格式化日志信息
        UART_TransmitString(logBuffer); // 通过 UART 发送日志信息
    }
}

// 输出 Debug 日志
void Log_Debug(const char *format, ...) {
    va_list args;
    va_start(args, format);
    Log_Output(LOG_LEVEL_DEBUG, "DEBUG", format, args);
    va_end(args);
}

// 输出 Info 日志
void Log_Info(const char *format, ...) {
    va_list args;
    va_start(args, format);
    Log_Output(LOG_LEVEL_INFO, "INFO", format, args);
    va_end(args);
}

// 输出 Warning 日志
void Log_Warning(const char *format, ...) {
    va_list args;
    va_start(args, format);
    Log_Output(LOG_LEVEL_WARNING, "WARNING", format, args);
    va_end(args);
}

// 输出 Error 日志
void Log_Error(const char *format, ...) {
    va_list args;
    va_start(args, format);
    Log_Output(LOG_LEVEL_ERROR, "ERROR", format, args);
    va_end(args);
}

说明:

• log.h 文件定义了日志管理模块的接口，包括日志级别和日志输出函数。
• log.c 文件是日志管理模块的具体实现。
• Log_SetLevel() 函数设置当前的日志级别，只有级别高于或等于当前级别的日志才会被输出。
• Log_Debug(), Log_Info(), Log_Warning(), Log_Error() 函数分别输出不同级别的日志信息。
• 日志信息通过 UART 驱动发送到串口，可以使用串口调试助手查看日志。
• 代码中使用了 stdarg.h 中的可变参数列表来实现格式化输出，类似于 printf() 函数。

4. 机器人控制层 (Robot Control Layer)

机器人控制层是系统的核心层，负责机器人的运动控制、感知处理、行为决策等核心功能。这里我们重点展示运动控制模块和行为控制模块的简单实现。

运动控制模块 (motion_control.h 和 motion_control.c):

(由于篇幅限制，这里只提供头文件和简单的函数声明，具体的运动学计算和轨迹规划需要根据机器人的具体结构和运动需求进行实现)

// motion_control.h
#ifndef MOTION_CONTROL_H
#define MOTION_CONTROL_H

#include "servo_driver.h"

// 定义机器人关节角度结构体 (3 DOF)
typedef struct {
    float joint1Angle;
    float joint2Angle;
    float joint3Angle;
} JointAngles_TypeDef;

// 设置机器人关节角度
void MotionControl_SetJointAngles(JointAngles_TypeDef *jointAngles);

// 获取机器人当前关节角度
JointAngles_TypeDef MotionControl_GetJointAngles(void);

// 执行预定义的运动序列 (例如，舞蹈动作)
void MotionControl_ExecuteMotionSequence(uint32_t sequenceIndex);

#endif // MOTION_CONTROL_H


// motion_control.c (部分示例代码)
#include "motion_control.h"

static JointAngles_TypeDef currentJointAngles = {0.0f, 0.0f, 0.0f}; // 初始关节角度

// 设置机器人关节角度
void MotionControl_SetJointAngles(JointAngles_TypeDef *jointAngles) {
    currentJointAngles = *jointAngles; // 更新当前关节角度

    // 将关节角度转换为舵机角度，并设置舵机
    Servo_SetAngle(0, jointAngles->joint1Angle); // 假设舵机 0 控制关节 1
    Servo_SetAngle(1, jointAngles->joint2Angle); // 假设舵机 1 控制关节 2
    Servo_SetAngle(2, jointAngles->joint3Angle); // 假设舵机 2 控制关节 3

    // 可以添加运动平滑处理、速度控制等
}

// 获取机器人当前关节角度
JointAngles_TypeDef MotionControl_GetJointAngles(void) {
    // 可以从舵机驱动读取实际的角度反馈值，而不是直接返回 currentJointAngles
    // (如果舵机支持角度反馈)
    return currentJointAngles;
}

// 执行预定义的运动序列 (例如，舞蹈动作)
void MotionControl_ExecuteMotionSequence(uint32_t sequenceIndex) {
    // 根据 sequenceIndex 选择不同的运动序列
    switch (sequenceIndex) {
        case 0: // 序列 0: 简单挥手
            // 定义挥手动作的关节角度序列
            JointAngles_TypeDef waveSequence[] = {
                {0.0f, 0.0f, 0.0f},
                {30.0f, 0.0f, 0.0f},
                {-30.0f, 0.0f, 0.0f},
                {0.0f, 0.0f, 0.0f}
            };
            uint32_t sequenceLength = sizeof(waveSequence) / sizeof(waveSequence[0]);

            for (uint32_t i = 0; i < sequenceLength; i++) {
                MotionControl_SetJointAngles(&waveSequence[i]);
                HAL_Delay(500); // 延时 500ms
            }
            break;

        // ... 可以添加更多运动序列

        default:
            break;
    }
}

行为控制模块 (behavior_control.h 和 behavior_control.c):

(这里只提供一个简单的状态机示例，实际的行为控制逻辑会更复杂)

// behavior_control.h
#ifndef BEHAVIOR_CONTROL_H
#define BEHAVIOR_CONTROL_H

// 定义机器人行为状态
typedef enum {
    BEHAVIOR_STATE_IDLE,
    BEHAVIOR_STATE_EXPLORING,
    BEHAVIOR_STATE_INTERACTING,
    BEHAVIOR_STATE_DANCING
} BehaviorState_TypeDef;

// 设置机器人行为状态
void BehaviorControl_SetState(BehaviorState_TypeDef newState);

// 获取机器人当前行为状态
BehaviorState_TypeDef BehaviorControl_GetState(void);

// 行为控制主循环 (在任务调度器中运行)
void BehaviorControl_Task(void);

#endif // BEHAVIOR_CONTROL_H


// behavior_control.c (部分示例代码)
#include "behavior_control.h"
#include "motion_control.h"
#include "log.h"

static BehaviorState_TypeDef currentState = BEHAVIOR_STATE_IDLE; // 初始状态为空闲

// 设置机器人行为状态
void BehaviorControl_SetState(BehaviorState_TypeDef newState) {
    if (currentState != newState) {
        currentState = newState;
        Log_Info("Behavior State changed to: %d", currentState);
        // 可以添加状态切换时的动作或初始化操作
        switch (currentState) {
            case BEHAVIOR_STATE_IDLE:
                MotionControl_SetJointAngles(&(JointAngles_TypeDef){0.0f, 0.0f, 0.0f}); // 回到初始姿态
                break;
            case BEHAVIOR_STATE_DANCING:
                MotionControl_ExecuteMotionSequence(0); // 执行舞蹈序列 0
                break;
            default:
                break;
        }
    }
}

// 获取机器人当前行为状态
BehaviorState_TypeDef BehaviorControl_GetState(void) {
    return currentState;
}

// 行为控制任务 (在任务调度器中周期性运行)
void BehaviorControl_Task(void) {
    // 根据当前状态执行相应的行为逻辑
    switch (currentState) {
        case BEHAVIOR_STATE_IDLE:
            // 空闲状态下的逻辑 (例如，等待用户指令、进入低功耗模式)
            break;

        case BEHAVIOR_STATE_EXPLORING:
            // 探索状态下的逻辑 (例如，随机运动、避障、环境感知)
            // 这里只是一个简单的示例，实际的探索逻辑会更复杂
            JointAngles_TypeDef exploreAngles = {
                (float)(rand() % 60 - 30), // 随机关节角度
                (float)(rand() % 30 - 15),
                0.0f
            };
            MotionControl_SetJointAngles(&exploreAngles);
            HAL_Delay(1000); // 延时 1 秒
            break;

        case BEHAVIOR_STATE_INTERACTING:
            // 交互状态下的逻辑 (例如，响应用户触摸、语音指令、视觉识别结果)
            // ...
            break;

        case BEHAVIOR_STATE_DANCING:
            // 舞蹈状态下，运动序列已经在状态切换时启动，这里可以做一些循环或状态监控
            // 可以根据音乐节奏或时间控制舞蹈动作的切换
            // ...
            break;

        default:
            break;
    }
}

5. 应用层 (Application Layer)

应用层是系统的最顶层，负责实现具体的应用逻辑和用户交互。 在 main.c 文件中，我们将初始化所有模块，创建任务，并启动任务调度器。

主程序文件 (main.c):

#include "hal.h"
#include "servo_driver.h"
#include "uart_driver.h"
#include "task_scheduler.h"
#include "behavior_control.h"
#include "log.h"
#include <stdlib.h> // 需要使用 stdlib.h 中的 rand, srand 函数
#include <time.h>   // 需要使用 time.h 中的 time 函数

int main(void) {
    // --- 硬件初始化 (HAL 层初始化) ---
    //  (根据具体的 MCU 和开发环境进行 HAL 初始化，例如时钟配置、外设使能等)
    //  SystemClock_Config(); // 示例: 系统时钟配置函数 (需要根据实际情况实现)

    // --- 驱动层初始化 ---
    // 舵机配置
    Servo_ConfigTypeDef servoConfigs[3] = {
        {PWM_CHANNEL_1, ADC_CHANNEL_1, -90.0f, 90.0f, 500, 2500}, // Servo 1 配置
        {PWM_CHANNEL_2, ADC_CHANNEL_2, -45.0f, 45.0f, 500, 2500},  // Servo 2 配置
        {PWM_CHANNEL_3, 0,        -30.0f, 30.0f, 500, 2500}   // Servo 3 配置 (无反馈)
    };
    Servo_Init(servoConfigs);
    Servo_Disable(0); Servo_Disable(1); Servo_Disable(2); // 初始禁用舵机

    // UART 初始化 (用于日志输出)
    UART_Init(115200);

    // 日志模块初始化
    Log_SetLevel(LOG_LEVEL_DEBUG); // 设置日志级别为 DEBUG
    Log_Info("System Started!");

    // --- 核心服务层初始化 ---
    // 任务调度器初始化
    TaskScheduler_Init();

    // --- 机器人控制层 ---
    // 运动控制模块初始化 (如果需要，可以在这里进行运动学参数初始化等)
    // ...

    // 行为控制模块初始化 (设置初始状态)
    BehaviorControl_SetState(BEHAVIOR_STATE_IDLE);

    // --- 应用层任务创建 ---
    // 创建行为控制任务 (周期性运行)
    Task_TypeDef behaviorTask = {
        .taskFunction = BehaviorControl_Task,
        .periodMs = 100, // 100ms 周期运行
        .lastRunTimeMs = 0
    };
    TaskScheduler_AddTask(&behaviorTask);

    // 创建用户交互任务 (例如，按键检测、串口指令解析)
    // ... (示例，这里简化，假设通过按键切换行为状态)
    Task_TypeDef userInputTask = {
        .taskFunction = UserInput_Task, // 用户输入处理任务函数 (需要实现)
        .periodMs = 50,  // 50ms 周期运行
        .lastRunTimeMs = 0
    };
    // TaskScheduler_AddTask(&userInputTask); //  先注释掉，需要实现 UserInput_Task


    // --- 初始化随机数种子 ---
    srand(time(NULL)); // 使用当前时间作为随机数种子

    // --- 启动任务调度器 ---
    Log_Info("Starting Task Scheduler...");
    TaskScheduler_Run(); // 启动任务调度器主循环，程序进入无限循环

    return 0; // 理论上不会执行到这里
}


// 示例: 用户输入处理任务 (简化示例，只是框架)
void UserInput_Task(void) {
    // 检测按键输入 (假设有一个按键连接到 GPIO)
    if (HAL_GPIO_ReadPin(BUTTON_PIN) == GPIO_PIN_SET) { // 假设按键按下为 GPIO_PIN_SET
        // 按键按下，切换行为状态 (例如，从 IDLE 切换到 EXPLORING)
        BehaviorState_TypeDef currentState = BehaviorControl_GetState();
        if (currentState == BEHAVIOR_STATE_IDLE) {
            BehaviorControl_SetState(BEHAVIOR_STATE_EXPLORING);
        } else if (currentState == BEHAVIOR_STATE_EXPLORING) {
            BehaviorControl_SetState(BEHAVIOR_STATE_DANCING);
        } else if (currentState == BEHAVIOR_STATE_DANCING) {
            BehaviorControl_SetState(BEHAVIOR_STATE_IDLE);
        }
        HAL_Delay(200); // 按键消抖延时
    }

    // 解析串口指令 (如果需要远程控制)
    // ... (接收串口数据，解析指令，并根据指令控制机器人)
}

说明:

• main.c 文件是主程序入口，负责系统初始化、任务创建和启动任务调度器。
• 在 main() 函数中，我们依次进行了硬件初始化 (HAL 层)、驱动层初始化 (舵机驱动、UART 驱动)、核心服务层初始化 (任务调度器、日志模块)、机器人控制层初始化 (运动控制、行为控制)。
• 创建了行为控制任务和用户输入任务 (示例，简化)，并将它们添加到任务调度器中。
• 启动任务调度器后，程序进入无限循环，由任务调度器负责调度和执行各个任务。
• UserInput_Task() 函数是一个简化的示例，用于演示如何处理用户输入 (例如按键)，并根据输入切换机器人的行为状态。实际的用户交互逻辑可以根据项目需求进行扩展，例如通过串口接收远程控制指令、通过触摸屏或语音进行交互等。

总结与展望

以上代码示例提供了一个桌面级交互小机器人嵌入式软件系统的基本框架。这个框架采用了分层架构和模块化设计，具有良好的可扩展性和可维护性。

主要特点:

• 分层架构: 将系统划分为 HAL、驱动层、核心服务层、机器人控制层和应用层，降低了系统的复杂性，提高了代码的可维护性和可重用性。
• 模块化设计: 将每个层次的功能进一步细分到不同的模块中，例如舵机控制模块、传感器模块、运动控制模块、行为控制模块等，提高了代码的组织性和可读性。
• 合作式任务调度: 使用简单的合作式任务调度器，适用于资源受限的嵌入式系统，并能满足本项目对实时性要求不高的场景。
• 串口日志: 使用串口日志模块输出调试信息和系统状态，方便开发和调试。
• C 语言实现: 全部代码采用 C 语言编写，具有良好的可移植性和效率。

未来扩展方向:

• 更复杂的行为控制: 可以引入更复杂的状态机、行为树或强化学习等技术，实现更智能、更丰富的机器人行为。
• 视觉感知: 可以添加摄像头和图像处理模块，实现物体识别、人脸识别、环境感知等功能，增强机器人的交互能力和自主性。
• 语音交互: 可以添加语音识别和语音合成模块，实现语音控制和语音反馈，提升用户体验。
• 无线通信: 可以添加蓝牙或 Wi-Fi 模块，实现远程控制、数据传输和联网功能。
• 更精确的运动控制: 可以引入更高级的运动学算法、轨迹规划算法和 PID 控制算法，提高机器人的运动精度和稳定性。
• RTOS 替换合作式调度: 当系统功能越来越复杂，实时性要求更高时，可以将合作式调度器替换为抢占式 RTOS，例如 FreeRTOS、RT-Thread 等。

实践验证和维护升级

在实际项目开发中，我们需要对上述代码进行实践验证，包括：

• 单元测试: 对每个模块进行单元测试，验证模块功能的正确性。
• 集成测试: 将各个模块集成在一起进行集成测试，验证模块之间的协同工作是否正常。
• 系统测试: 进行全面的系统测试，包括功能测试、性能测试、稳定性测试、可靠性测试等，验证整个系统的功能和性能是否满足需求。
• 用户测试: 邀请用户进行用户测试，收集用户反馈，并根据反馈进行改进和优化。

在项目维护升级阶段，我们需要：

• Bug 修复: 及时修复测试和用户反馈的 Bug。
• 功能扩展: 根据用户需求和市场变化，不断扩展和完善机器人功能。
• 性能优化: 持续优化系统性能，提高运行效率和资源利用率。
• 安全加固: 加强系统安全防护，防止安全漏洞。
• 版本管理: 使用版本控制系统 (例如 Git) 管理代码，方便代码维护和版本迭代。

希望这个详细的嵌入式系统开发方案和代码示例能够帮助您理解桌面级交互小机器人的软件系统设计与实现。 请记住，这只是一个基础框架，实际的项目开发需要根据具体的需求和硬件平台进行调整和扩展。 祝您的项目开发顺利！