编程技术分享

分享编程知识，探讨技术创新

0%

简介：基于STC8H8K64U的四足机器人，控制PCA9685驱动八路舵机完成运动与个性动作，包括仿动物前进后退转弯等，单足打招呼，亮灭灯，跳舞和跑马灯及蜂鸣器伴奏 等等

发表于 分类于 ， ，

好的，作为一名高级嵌入式软件开发工程师，我将为您详细介绍基于STC8H8K64U和PCA9685的四足机器人的代码设计架构，并提供详细的C代码实现。这个项目旨在构建一个可靠、高效、可扩展的嵌入式系统平台，所有技术选型和方法都经过实践验证。
关注微信公众号，提前获取相关推文

代码设计架构

为了构建一个可靠、高效且可扩展的四足机器人系统，我将采用分层和模块化的设计架构。这种架构将系统分解为多个独立的模块，每个模块负责特定的功能，并通过清晰定义的接口进行交互。这种设计方法具有以下优点：

  1. 模块化和可重用性: 每个模块都是独立的，可以单独开发、测试和维护。模块可以被其他项目或系统重用，提高开发效率。
  2. 可扩展性: 当需要添加新功能或修改现有功能时，只需要修改或添加相应的模块，而不会影响其他模块。
  3. 可维护性: 模块化的结构使得代码更易于理解和维护。当出现问题时，可以快速定位到具体的模块进行调试和修复。
  4. 高内聚低耦合: 每个模块内部功能高度相关（高内聚），模块之间依赖性低（低耦合），降低了模块之间的相互影响，提高了系统的稳定性。

基于以上考虑，我将系统架构设计为以下几个层次和模块：

1. 硬件抽象层 (HAL - Hardware Abstraction Layer)

HAL层是系统架构的最底层，直接与硬件交互。它向上层提供统一的硬件接口，隐藏了底层硬件的差异。HAL层的主要模块包括：

  • GPIO 驱动模块 (hal_gpio.c/h): 封装了STC8H8K64U的GPIO操作，用于控制LED、蜂鸣器、以及可能的传感器接口。
  • 定时器驱动模块 (hal_timer.c/h): 封装了STC8H8K64U的定时器操作，用于生成PWM信号控制舵机，以及提供系统时钟和延时功能。
  • I2C 驱动模块 (hal_i2c.c/h): 封装了STC8H8K64U的I2C接口操作，用于与PCA9685舵机驱动芯片通信。
  • UART 驱动模块 (hal_uart.c/h) (可选): 封装了STC8H8K64U的UART接口操作，用于调试和可能的外部通信。

2. 舵机驱动层 (Servo Driver Layer)

舵机驱动层位于HAL层之上，负责控制PCA9685舵机驱动芯片，进而控制各个舵机的角度。该层的主要模块为：

  • PCA9685 驱动模块 (servo_driver.c/h): 封装了PCA9685芯片的初始化、PWM信号生成和舵机角度控制功能。该模块使用HAL层的I2C驱动进行通信。

3. 运动控制层 (Motion Control Layer)

运动控制层位于舵机驱动层之上，负责机器人的运动控制和动作编排。该层的主要模块包括：

  • 机器人运动学模块 (robot_kinematics.c/h): 负责计算机器人运动所需的舵机角度，例如前进、后退、转弯等步态规划，以及单腿站立、跳舞等动作的逆运动学计算。
  • 动作序列模块 (action_sequence.c/h): 定义和管理预设的动作序列，例如打招呼、跳舞、跑马灯等。这些序列由一系列的舵机角度和时间延迟组成。
  • 运动状态机模块 (motion_state_machine.c/h): 管理机器人的运动状态，例如空闲状态、前进状态、后退状态、跳舞状态等。根据不同的状态，机器人执行不同的动作序列。

4. 应用层 (Application Layer)

应用层是系统架构的最上层，负责实现具体的功能和用户交互。该层的主要模块为：

  • 主程序模块 (main.c): 系统的入口点，负责初始化所有模块，并根据用户输入或预设程序控制机器人的行为。
  • 用户指令解析模块 (command_parser.c/h) (可选): 如果需要通过串口或其他方式接收用户指令，则需要该模块解析指令并控制机器人的动作。

系统架构图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
+---------------------+
|     应用层 (Application Layer)     |
|---------------------|
|     主程序模块 (main.c)     |
|  用户指令解析模块 (command_parser.c/h) (可选) |
+---------------------+
          ^
          |
+---------------------+
|   运动控制层 (Motion Control Layer)  |
|---------------------|
|  机器人运动学模块 (robot_kinematics.c/h) |
|  动作序列模块 (action_sequence.c/h)   |
|  运动状态机模块 (motion_state_machine.c/h) |
+---------------------+
          ^
          |
+---------------------+
|   舵机驱动层 (Servo Driver Layer)  |
|---------------------|
|  PCA9685 驱动模块 (servo_driver.c/h)   |
+---------------------+
          ^
          |
+---------------------+
|   硬件抽象层 (HAL - Hardware Abstraction Layer)  |
|---------------------|
|    GPIO 驱动模块 (hal_gpio.c/h)    |
|   定时器驱动模块 (hal_timer.c/h)   |
|    I2C 驱动模块 (hal_i2c.c/h)    |
|    UART 驱动模块 (hal_uart.c/h) (可选)|
+---------------------+
          ^
          |
+---------------------+
|      硬件 (Hardware)       |
|---------------------|
|    STC8H8K64U MCU      |
|     PCA9685 驱动芯片    |
|       舵机 (Servos)      |
|       LED, 蜂鸣器等     |
+---------------------+

C 代码实现

接下来，我将详细给出每个模块的C代码实现。由于代码量较大，我将分模块逐步展示，并附带详细的注释。

1. 硬件抽象层 (HAL)

hal_gpio.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

#include <stc8h8k.h> // 根据你的STC8H头文件

// 定义GPIO端口和引脚
typedef enum {
    GPIO_PORT_P0,
    GPIO_PORT_P1,
    GPIO_PORT_P2,
    GPIO_PORT_P3,
    GPIO_PORT_P4,
    GPIO_PORT_P5,
    GPIO_PORT_P6,
    GPIO_PORT_P7,
} GPIO_Port_t;

typedef enum {
    GPIO_PIN_0 = 0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    GPIO_PIN_3,
    GPIO_PIN_4,
    GPIO_PIN_5,
    GPIO_PIN_6,
    GPIO_PIN_7,
} GPIO_Pin_t;

// GPIO 初始化结构体
typedef struct {
    GPIO_Port_t port;
    GPIO_Pin_t pin;
    unsigned char mode; // 0: 输出, 1: 输入
} GPIO_InitTypeDef;

// 初始化 GPIO
void GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct);

// 设置 GPIO 输出
void GPIO_WritePin(GPIO_Port_t port, GPIO_Pin_t pin, unsigned char value); // value: 0 或 1

// 读取 GPIO 输入
unsigned char GPIO_ReadPin(GPIO_Port_t port, GPIO_Pin_t pin);

#endif // HAL_GPIO_H

hal_gpio.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include "hal_gpio.h"

void GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct) {
    switch (GPIO_InitStruct->port) {
        case GPIO_PORT_P0:
            if (GPIO_InitStruct->mode == 0) { // 输出
                P0M0 &= ~(1 << GPIO_InitStruct->pin);
                P0M1 &= ~(1 << GPIO_InitStruct->pin);
            } else { // 输入
                P0M0 |= (1 << GPIO_InitStruct->pin);
                P0M1 &= ~(1 << GPIO_InitStruct->pin);
            }
            break;
        case GPIO_PORT_P1:
            if (GPIO_InitStruct->mode == 0) {
                P1M0 &= ~(1 << GPIO_InitStruct->pin);
                P1M1 &= ~(1 << GPIO_InitStruct->pin);
            } else {
                P1M0 |= (1 << GPIO_InitStruct->pin);
                P1M1 &= ~(1 << GPIO_InitStruct->pin);
            }
            break;
        case GPIO_PORT_P2:
            // ... (其他端口类似，省略)
            break;
        case GPIO_PORT_P3:
            // ...
            break;
        case GPIO_PORT_P4:
            // ...
            break;
        case GPIO_PORT_P5:
            // ...
            break;
        case GPIO_PORT_P6:
            // ...
            break;
        case GPIO_PORT_P7:
            // ...
            break;
        default:
            break;
    }
}

void GPIO_WritePin(GPIO_Port_t port, GPIO_Pin_t pin, unsigned char value) {
    switch (port) {
        case GPIO_PORT_P0:
            if (value) {
                P0 |= (1 << pin);
            } else {
                P0 &= ~(1 << pin);
            }
            break;
        case GPIO_PORT_P1:
            if (value) {
                P1 |= (1 << pin);
            } else {
                P1 &= ~(1 << pin);
            }
            break;
        case GPIO_PORT_P2:
            // ... (其他端口类似，省略)
            break;
        case GPIO_PORT_P3:
            // ...
            break;
        case GPIO_PORT_P4:
            // ...
            break;
        case GPIO_PORT_P5:
            // ...
            break;
        case GPIO_PORT_P6:
            // ...
            break;
        case GPIO_PORT_P7:
            // ...
            break;
        default:
            break;
    }
}

unsigned char GPIO_ReadPin(GPIO_Port_t port, GPIO_Pin_t pin) {
    switch (port) {
        case GPIO_PORT_P0:
            return (P0 >> pin) & 0x01;
        case GPIO_PORT_P1:
            return (P1 >> pin) & 0x01;
        case GPIO_PORT_P2:
            // ... (其他端口类似，省略)
            break;
        case GPIO_PORT_P3:
            // ...
            break;
        case GPIO_PORT_P4:
            // ...
            break;
        case GPIO_PORT_P5:
            // ...
            break;
        case GPIO_PORT_P6:
            // ...
            break;
        case GPIO_PORT_P7:
            // ...
            break;
        default:
            return 0;
    }
}

hal_timer.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef HAL_TIMER_H
#define HAL_TIMER_H

#include <stc8h8k.h> // 根据你的STC8H头文件

// 延时函数 (毫秒级)
void Delay_ms(unsigned int ms);

// 定时器初始化结构体 (这里只简单提供一个延时功能，PWM定时器配置将在 servo_driver 中实现)
typedef struct {
    unsigned int timer; // 定时器编号，如 TIMER0, TIMER1, TIMER2
    unsigned int mode;  // 定时器模式
    unsigned int period; // 定时周期
    void (*callback)(void); // 定时器中断回调函数
} TIMER_InitTypeDef;

void TIMER_Init(TIMER_InitTypeDef *TIMER_InitStruct);

void TIMER_Start(unsigned int timer);
void TIMER_Stop(unsigned int timer);

#endif // HAL_TIMER_H

hal_timer.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "hal_timer.h"
#include <intrins.h> // 包含 _nop_();

// 简单延时函数 (粗略延时，实际精度取决于时钟频率和编译器优化)
void Delay_ms(unsigned int ms) {
    unsigned int i, j;
    for (i = 0; i < ms; i++) {
        for (j = 0; j < 1000; j++) { // 粗略延时，需要根据实际时钟频率调整
            _nop_();
            _nop_();
            _nop_();
            _nop_();
            _nop_();
        }
    }
}

// 这里只简单实现延时功能，更精确的定时器和PWM将在 servo_driver 中配置
void TIMER_Init(TIMER_InitTypeDef *TIMER_InitStruct) {
    //  ... (更完善的定时器初始化，例如配置定时器模式，设置周期，使能中断等，
    //       在这个项目中，PWM生成将主要在 servo_driver.c 中使用PCA9685的PWM功能，
    //       这里HAL层的定时器可以简化为提供延时功能)
}

void TIMER_Start(unsigned int timer) {
    // ... (启动定时器)
}

void TIMER_Stop(unsigned int timer) {
    // ... (停止定时器)
}

hal_i2c.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#ifndef HAL_I2C_H
#define HAL_I2C_H

#include <stc8h8k.h> // 根据你的STC8H头文件

// I2C 初始化
void I2C_Init(void);

// I2C 开始信号
void I2C_Start(void);

// I2C 停止信号
void I2C_Stop(void);

// 发送一个字节
void I2C_SendByte(unsigned char byte);

// 接收一个字节 (带应答)
unsigned char I2C_ReceiveByte(unsigned char ack); // ack: 1-发送ACK, 0-发送NACK

// 等待应答信号
unsigned char I2C_WaitAck(void); // 返回 0-收到ACK, 1-未收到ACK

// 发送应答信号
void I2C_SendAck(unsigned char ack); // ack: 0-ACK, 1-NACK

#endif // HAL_I2C_H

hal_i2c.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include "hal_i2c.h"
#include <intrins.h> // 包含 _nop_();

// 定义 I2C 引脚 (根据你的硬件连接修改)
#define I2C_SCL_PIN P10  // 例如 P1.0
#define I2C_SDA_PIN P11  // 例如 P1.1

// 软件 I2C 实现
void I2C_Init(void) {
    // 初始化 I2C 引脚为推挽输出
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.port = GPIO_PORT_P1; // 例如 P1
    GPIO_InitStruct.mode = 0; // 输出模式

    GPIO_InitStruct.pin = GPIO_PIN_0; // SCL
    GPIO_Init(&GPIO_InitStruct);
    GPIO_InitStruct.pin = GPIO_PIN_1; // SDA
    GPIO_Init(&GPIO_InitStruct);

    // 初始化时拉高 SCL 和 SDA
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1);
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1);
}

void I2C_Start(void) {
    // 确保 SCL 和 SDA 都为高电平
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1);
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1);
    _nop_();

    // SDA 线从高电平切换到低电平，启动信号
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 0);
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低准备发送数据
    _nop_();
}

void I2C_Stop(void) {
    // 确保 SCL 为高电平
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0);
    _nop_();

    // SDA 线从低电平切换到高电平，停止信号
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 0);
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1);
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1);
    _nop_();
}

void I2C_SendByte(unsigned char byte) {
    unsigned char i;
    for (i = 0; i < 8; i++) {
        // 数据位移到最高位
        if ((byte << i) & 0x80) {
            GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1); // SDA 输出 1
        } else {
            GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 0); // SDA 输出 0
        }
        _nop_();
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1); // SCL 拉高，数据有效
        _nop_();
        _nop_();
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低，准备下一位
        _nop_();
    }

    // 等待应答
    I2C_WaitAck();
}

unsigned char I2C_ReceiveByte(unsigned char ack) {
    unsigned char i;
    unsigned char receiveByte = 0;

    // 设置 SDA 为输入模式
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.port = GPIO_PORT_P1;
    GPIO_InitStruct.pin = GPIO_PIN_1;
    GPIO_InitStruct.mode = 1; // 输入模式
    GPIO_Init(&GPIO_InitStruct);

    for (i = 0; i < 8; i++) {
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1); // SCL 拉高，准备读取数据
        _nop_();
        _nop_();
        if (GPIO_ReadPin(GPIO_PORT_P1, GPIO_PIN_1)) { // 读取 SDA 上的数据
            receiveByte |= (0x80 >> i);
        }
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低，准备下一位
        _nop_();
    }

    // 发送应答
    I2C_SendAck(ack);
    return receiveByte;
}

unsigned char I2C_WaitAck(void) {
    unsigned char timeOut = 255;

    // 设置 SDA 为输入模式
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.port = GPIO_PORT_P1;
    GPIO_InitStruct.pin = GPIO_PIN_1;
    GPIO_InitStruct.mode = 1; // 输入模式
    GPIO_Init(&GPIO_InitStruct);

    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1); // 释放 SDA 线
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1); // SCL 拉高，开始时钟周期

    while (GPIO_ReadPin(GPIO_PORT_P1, GPIO_PIN_1)) { // 等待 SDA 变为低电平
        timeOut--;
        if (timeOut == 0) {
            I2C_Stop();
            return 1; // 超时未收到应答
        }
    }
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低
    _nop_();
    return 0; // 收到应答
}

void I2C_SendAck(unsigned char ack) {
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低
    _nop_();
    if (ack) {
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 1); // NACK
    } else {
        GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_1, 0); // ACK
    }
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 1); // SCL 拉高，发送应答信号
    _nop_();
    GPIO_WritePin(GPIO_PORT_P1, GPIO_PIN_0, 0); // SCL 拉低
    _nop_();
}

2. 舵机驱动层 (Servo Driver Layer)

servo_driver.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#ifndef SERVO_DRIVER_H
#define SERVO_DRIVER_H

#include "hal_i2c.h" // 使用 I2C 驱动
#include "hal_timer.h" // 使用延时函数

// PCA9685 设备地址
#define PCA9685_ADDRESS 0x80 // 7-bit address, shifted left by 1 for write address

// PCA9685 寄存器地址
#define PCA9685_MODE1       0x00
#define PCA9685_MODE2       0x01
#define PCA9685_SUBADR1     0x02
#define PCA9685_SUBADR2     0x03
#define PCA9685_SUBADR3     0x04
#define PCA9685_ALLCALLADR  0x05
#define PCA9685_LED0_ON_L   0x06
#define PCA9685_LED0_ON_H   0x07
#define PCA9685_LED0_OFF_L  0x08
#define PCA9685_LED0_OFF_H  0x09
// ... LED1 ~ LED15 寄存器地址 (省略) ...
#define PCA9685_ALL_LED_ON_L  0xFA
#define PCA9685_ALL_LED_ON_H  0xFB
#define PCA9685_ALL_LED_OFF_L 0xFC
#define PCA9685_ALL_LED_OFF_H 0xFD
#define PCA9685_PRESCALE    0xFE

// 舵机通道定义 (0-7 通道对应 8 个舵机)
typedef enum {
    SERVO_CHANNEL_0,
    SERVO_CHANNEL_1,
    SERVO_CHANNEL_2,
    SERVO_CHANNEL_3,
    SERVO_CHANNEL_4,
    SERVO_CHANNEL_5,
    SERVO_CHANNEL_6,
    SERVO_CHANNEL_7,
    SERVO_CHANNEL_ALL = 8 // 控制所有舵机
} ServoChannel_t;

// 初始化 PCA9685 驱动芯片
void ServoDriver_Init(void);

// 设置单个舵机角度 (角度范围通常为 0-180 度)
void ServoDriver_SetServoAngle(ServoChannel_t channel, unsigned int angle);

// 设置所有舵机角度
void ServoDriver_SetAllServoAngle(unsigned int angle);

// 设置 PWM 输出 (0-4095 对应占空比 0-100%) - 底层函数，角度控制函数会调用此函数
void ServoDriver_SetPWM(ServoChannel_t channel, unsigned int onTime, unsigned int offTime);

#endif // SERVO_DRIVER_H

servo_driver.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include "servo_driver.h"

// PWM 频率预分频值 (计算公式: prescale = round(25MHz / (4096 * desired_frequency)) - 1)
// 例如 50Hz PWM 频率: prescale = round(25000000 / (4096 * 50)) - 1 = 121
#define PCA9685_PRESCALE_VALUE 121

// 舵机脉宽范围 (根据实际舵机型号调整)
#define SERVO_MIN_PULSE 150  // 对应 0 度 (通常在 500us 左右，除以 PWM 分辨率得到计数值)
#define SERVO_MAX_PULSE 600  // 对应 180 度 (通常在 2500us 左右，除以 PWM 分辨率得到计数值)

// 写入 PCA9685 寄存器
void PCA9685_WriteReg(unsigned char reg, unsigned char value) {
    I2C_Start();
    I2C_SendByte(PCA9685_ADDRESS); // 设备地址 + 写命令
    I2C_SendByte(reg);           // 寄存器地址
    I2C_SendByte(value);         // 寄存器值
    I2C_Stop();
}

// 读取 PCA9685 寄存器
unsigned char PCA9685_ReadReg(unsigned char reg) {
    unsigned char value;
    I2C_Start();
    I2C_SendByte(PCA9685_ADDRESS); // 设备地址 + 写命令
    I2C_SendByte(reg);           // 寄存器地址

    I2C_Start(); // 重复启动
    I2C_SendByte(PCA9685_ADDRESS | 0x01); // 设备地址 + 读命令
    value = I2C_ReceiveByte(0);      // 接收数据，发送NACK
    I2C_Stop();
    return value;
}

// 初始化 PCA9685
void ServoDriver_Init(void) {
    I2C_Init(); // 初始化 I2C

    // 复位 PCA9685
    PCA9685_WriteReg(PCA9685_MODE1, 0x00);
    Delay_ms(10); // 延时至少 500us

    // 设置 PWM 频率预分频值
    PCA9685_WriteReg(PCA9685_MODE1, 0x10); // 进入睡眠模式，允许修改预分频值
    PCA9685_WriteReg(PCA9685_PRESCALE, PCA9685_PRESCALE_VALUE);
    PCA9685_WriteReg(PCA9685_MODE1, 0x00); // 退出睡眠模式
    Delay_ms(10);

    // 设置 MODE2 寄存器，使能推挽输出
    PCA9685_WriteReg(PCA9685_MODE2, 0x04); // 输出逻辑高电平有效 (推挽输出)
}

// 设置 PWM 输出
void ServoDriver_SetPWM(ServoChannel_t channel, unsigned int onTime, unsigned int offTime) {
    unsigned char channelBaseReg = PCA9685_LED0_ON_L + (channel * 4); // 每个通道占用 4 个寄存器

    if (channel < SERVO_CHANNEL_ALL) {
        PCA9685_WriteReg(channelBaseReg + 0, onTime & 0xFF);         // ON_L
        PCA9685_WriteReg(channelBaseReg + 1, (onTime >> 8) & 0x0F);    // ON_H (低4位)
        PCA9685_WriteReg(channelBaseReg + 2, offTime & 0xFF);        // OFF_L
        PCA9685_WriteReg(channelBaseReg + 3, (offTime >> 8) & 0x0F);   // OFF_H (低4位)
    } else if (channel == SERVO_CHANNEL_ALL) { // 控制所有通道
        PCA9685_WriteReg(PCA9685_ALL_LED_ON_L, onTime & 0xFF);
        PCA9685_WriteReg(PCA9685_ALL_LED_ON_H, (onTime >> 8) & 0x0F);
        PCA9685_WriteReg(PCA9685_ALL_LED_OFF_L, offTime & 0xFF);
        PCA9685_WriteReg(PCA9685_ALL_LED_OFF_H, (offTime >> 8) & 0x0F);
    }
}

// 设置舵机角度
void ServoDriver_SetServoAngle(ServoChannel_t channel, unsigned int angle) {
    if (angle > 180) angle = 180; // 角度范围限制在 0-180 度
    unsigned int pulseWidth = SERVO_MIN_PULSE + (unsigned int)(((float)(SERVO_MAX_PULSE - SERVO_MIN_PULSE) / 180.0) * angle);
    ServoDriver_SetPWM(channel, 0, pulseWidth); // ON_TIME 设为 0，OFF_TIME 为脉宽
}

// 设置所有舵机角度
void ServoDriver_SetAllServoAngle(unsigned int angle) {
    if (angle > 180) angle = 180;
    unsigned int pulseWidth = SERVO_MIN_PULSE + (unsigned int)(((float)(SERVO_MAX_PULSE - SERVO_MIN_PULSE) / 180.0) * angle);
    ServoDriver_SetPWM(SERVO_CHANNEL_ALL, 0, pulseWidth);
}

3. 运动控制层 (Motion Control Layer)

robot_kinematics.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#ifndef ROBOT_KINEMATICS_H
#define ROBOT_KINEMATICS_H

#include "servo_driver.h" // 使用舵机驱动

// 机器人腿部和舵机配置 (根据实际机器人结构调整)
#define LEG_COUNT 4
#define SERVO_PER_LEG 2
#define TOTAL_SERVO_COUNT (LEG_COUNT * SERVO_PER_LEG)

// 舵机通道分配 (顺序需要与机器人物理结构对应)
typedef enum {
    SERVO_FRONT_LEFT_HIP,   // 前左腿髋关节舵机 (例如通道 0)
    SERVO_FRONT_LEFT_KNEE,  // 前左腿膝关节舵机 (例如通道 1)
    SERVO_FRONT_RIGHT_HIP,  // 前右腿髋关节舵机 (例如通道 2)
    SERVO_FRONT_RIGHT_KNEE, // 前右腿膝关节舵机 (例如通道 3)
    SERVO_REAR_LEFT_HIP,    // 后左腿髋关节舵机 (例如通道 4)
    SERVO_REAR_LEFT_KNEE,   // 后左腿膝关节舵机 (例如通道 5)
    SERVO_REAR_RIGHT_HIP,   // 后右腿髋关节舵机 (例如通道 6)
    SERVO_REAR_RIGHT_KNEE,  // 后右腿膝关节舵机 (例如通道 7)
} ServoName_t;

// 定义腿部结构体 (可以根据需要扩展更多参数，如腿部长度等)
typedef struct {
    ServoChannel_t hipServoChannel;
    ServoChannel_t kneeServoChannel;
    int hipOffsetAngle;  // 髋关节舵机角度偏移量 (用于校准机械误差)
    int kneeOffsetAngle; // 膝关节舵机角度偏移量
} Leg_t;

// 机器人腿部配置数组
extern Leg_t RobotLegs[LEG_COUNT];

// 初始化机器人腿部配置
void RobotKinematics_Init(void);

// 设置单腿姿态 (用于微调或特殊动作)
void RobotKinematics_SetLegPose(int legIndex, int hipAngle, int kneeAngle);

// 机器人站立姿态
void RobotKinematics_Stand(void);

// 机器人行走步态 (简单示例，可以根据需要设计更复杂的步态)
void RobotKinematics_WalkForward(int steps);
void RobotKinematics_WalkBackward(int steps);
void RobotKinematics_TurnLeft(int angle);
void RobotKinematics_TurnRight(int angle);

// 机器人单腿打招呼动作
void RobotKinematics_WaveOneLeg(int legIndex);

// 机器人跳舞动作 (简单示例)
void RobotKinematics_Dance(void);

#endif // ROBOT_KINEMATICS_H

robot_kinematics.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include "robot_kinematics.h"
#include "hal_timer.h" // 使用延时函数

// 机器人腿部配置数组 (根据实际机器人结构和舵机连接修改)
Leg_t RobotLegs[LEG_COUNT] = {
    {SERVO_CHANNEL_0, SERVO_CHANNEL_1, 0, 0},   // 前左腿
    {SERVO_CHANNEL_2, SERVO_CHANNEL_3, 0, 0},   // 前右腿
    {SERVO_CHANNEL_4, SERVO_CHANNEL_5, 0, 0},   // 后左腿
    {SERVO_CHANNEL_6, SERVO_CHANNEL_7, 0, 0}    // 后右腿
};

// 初始化机器人腿部配置
void RobotKinematics_Init(void) {
    // 可以进行一些初始化设置，例如默认姿态
    RobotKinematics_Stand();
}

// 设置单腿姿态
void RobotKinematics_SetLegPose(int legIndex, int hipAngle, int kneeAngle) {
    if (legIndex >= 0 && legIndex < LEG_COUNT) {
        ServoDriver_SetServoAngle(RobotLegs[legIndex].hipServoChannel, hipAngle + RobotLegs[legIndex].hipOffsetAngle);
        ServoDriver_SetServoAngle(RobotLegs[legIndex].kneeServoChannel, kneeAngle + RobotLegs[legIndex].kneeOffsetAngle);
    }
}

// 机器人站立姿态
void RobotKinematics_Stand(void) {
    for (int i = 0; i < LEG_COUNT; i++) {
        RobotKinematics_SetLegPose(i, 90, 90); // 站立姿态的舵机角度，需要根据实际机器人调整
    }
}

// 机器人行走步态 (简单示例)
void RobotKinematics_WalkForward(int steps) {
    for (int step = 0; step < steps; step++) {
        // 步态序列 (简化的两步步态，需要根据实际机器人进行调整和优化)

        // 1. 抬起前左腿和后右腿
        RobotKinematics_SetLegPose(0, 80, 80); // 前左腿 hip, knee
        RobotKinematics_SetLegPose(3, 80, 80); // 后右腿 hip, knee
        Delay_ms(100);

        // 2. 前移前左腿和后右腿，同时后移前右腿和后左腿
        RobotKinematics_SetLegPose(0, 70, 70);
        RobotKinematics_SetLegPose(3, 70, 70);
        RobotKinematics_SetLegPose(1, 100, 100);
        RobotKinematics_SetLegPose(2, 100, 100);
        Delay_ms(100);

        // 3. 放下前左腿和后右腿
        RobotKinematics_SetLegPose(0, 90, 90);
        RobotKinematics_SetLegPose(3, 90, 90);
        Delay_ms(100);

        // 4. 抬起前右腿和后左腿
        RobotKinematics_SetLegPose(1, 80, 80);
        RobotKinematics_SetLegPose(2, 80, 80);
        Delay_ms(100);

        // 5. 前移前右腿和后左腿，同时后移前左腿和后右腿
        RobotKinematics_SetLegPose(1, 70, 70);
        RobotKinematics_SetLegPose(2, 70, 70);
        RobotKinematics_SetLegPose(0, 100, 100);
        RobotKinematics_SetLegPose(3, 100, 100);
        Delay_ms(100);

        // 6. 放下前右腿和后左腿
        RobotKinematics_SetLegPose(1, 90, 90);
        RobotKinematics_SetLegPose(2, 90, 90);
        Delay_ms(100);
    }
}

void RobotKinematics_WalkBackward(int steps) {
    // ... (后退步态，与前进步态相反) ...
    // 可以参考 WalkForward 实现，修改舵机角度变化方向
}

void RobotKinematics_TurnLeft(int angle) {
    // ... (左转步态) ...
    // 可以通过调整左右两侧腿的步态来实现转弯
}

void RobotKinematics_TurnRight(int angle) {
    // ... (右转步态) ...
    // 可以通过调整左右两侧腿的步态来实现转弯
}

// 机器人单腿打招呼动作
void RobotKinematics_WaveOneLeg(int legIndex) {
    if (legIndex >= 0 && legIndex < LEG_COUNT) {
        // 抬起指定腿
        RobotKinematics_SetLegPose(legIndex, 60, 60); // 抬起腿的 hip, knee 角度
        Delay_ms(500);

        // 摆动腿 (例如摆动膝关节)
        for (int i = 0; i < 3; i++) {
            ServoDriver_SetServoAngle(RobotLegs[legIndex].kneeServoChannel, 45);
            Delay_ms(200);
            ServoDriver_SetServoAngle(RobotLegs[legIndex].kneeServoChannel, 75);
            Delay_ms(200);
        }

        // 恢复站立姿态
        RobotKinematics_Stand();
    }
}

// 机器人跳舞动作 (简单示例)
void RobotKinematics_Dance(void) {
    // 简单的跳舞动作示例，可以根据需要设计更复杂的舞蹈
    for (int i = 0; i < 5; i++) {
        // 左右摇摆
        RobotKinematics_SetLegPose(0, 80, 90);
        RobotKinematics_SetLegPose(1, 100, 90);
        RobotKinematics_SetLegPose(2, 80, 90);
        RobotKinematics_SetLegPose(3, 100, 90);
        Delay_ms(300);

        RobotKinematics_SetLegPose(0, 100, 90);
        RobotKinematics_SetLegPose(1, 80, 90);
        RobotKinematics_SetLegPose(2, 100, 90);
        RobotKinematics_SetLegPose(3, 80, 90);
        Delay_ms(300);

        // 前后点头 (通过调整所有腿的 hip 关节)
        for(int j=0; j<LEG_COUNT; j++) RobotKinematics_SetLegPose(j, 85, 90);
        Delay_ms(200);
        for(int j=0; j<LEG_COUNT; j++) RobotKinematics_SetLegPose(j, 95, 90);
        Delay_ms(200);
    }
    RobotKinematics_Stand(); // 舞蹈结束，恢复站立
}

action_sequence.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#ifndef ACTION_SEQUENCE_H
#define ACTION_SEQUENCE_H

#include "hal_gpio.h" // 使用 GPIO 控制 LED 和 蜂鸣器

// 定义动作序列函数 (函数指针类型)
typedef void (*ActionSequenceFunc)(void);

// 动作序列枚举
typedef enum {
    ACTION_SEQUENCE_LIGHT_ON,
    ACTION_SEQUENCE_LIGHT_OFF,
    ACTION_SEQUENCE_RUNNING_LIGHT,
    ACTION_SEQUENCE_BUZZER_BEEP,
    ACTION_SEQUENCE_WAVE_ONE_LEG,
    ACTION_SEQUENCE_DANCE,
    ACTION_SEQUENCE_COUNT // 动作序列数量，用于数组大小定义
} ActionSequenceType_t;

// 动作序列函数数组
extern ActionSequenceFunc ActionSequences[ACTION_SEQUENCE_COUNT];

// 初始化动作序列
void ActionSequence_Init(void);

// 执行指定动作序列
void ActionSequence_Execute(ActionSequenceType_t actionType);

// 具体动作序列函数声明 (在 action_sequence.c 中实现)
void ActionSequence_LightOn(void);
void ActionSequence_LightOff(void);
void ActionSequence_RunningLight(void);
void ActionSequence_BuzzerBeep(void);
void ActionSequence_WaveOneLegAction(void); // 注意函数名修改，避免与枚举名冲突
void ActionSequence_DanceAction(void);      // 注意函数名修改，避免与枚举名冲突

#endif // ACTION_SEQUENCE_H

action_sequence.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include "action_sequence.h"
#include "hal_gpio.h"
#include "hal_timer.h"
#include "robot_kinematics.h" // 使用机器人运动控制

// 定义 LED 和 蜂鸣器 GPIO 引脚 (根据实际硬件连接修改)
#define LED_PIN_1   GPIO_PIN_0  // 例如 P2.0
#define LED_PIN_2   GPIO_PIN_1  // 例如 P2.1
#define BUZZER_PIN  GPIO_PIN_2  // 例如 P2.2
#define LED_PORT    GPIO_PORT_P2 // 例如 P2

// 动作序列函数数组
ActionSequenceFunc ActionSequences[ACTION_SEQUENCE_COUNT] = {
    ActionSequence_LightOn,
    ActionSequence_LightOff,
    ActionSequence_RunningLight,
    ActionSequence_BuzzerBeep,
    ActionSequence_WaveOneLegAction,
    ActionSequence_DanceAction,
};

// 初始化动作序列相关硬件
void ActionSequence_Init(void) {
    // 初始化 LED GPIO 为输出模式
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.port = LED_PORT;
    GPIO_InitStruct.mode = 0; // 输出模式
    GPIO_InitStruct.pin = LED_PIN_1;
    GPIO_Init(&GPIO_InitStruct);
    GPIO_InitStruct.pin = LED_PIN_2;
    GPIO_Init(&GPIO_InitStruct);

    // 初始化 蜂鸣器 GPIO 为输出模式
    GPIO_InitStruct.pin = BUZZER_PIN;
    GPIO_Init(&GPIO_InitStruct);

    // 默认关闭 LED 和 蜂鸣器
    ActionSequence_LightOff();
    GPIO_WritePin(LED_PORT, BUZZER_PIN, 0); // 蜂鸣器关闭
}

// 执行指定动作序列
void ActionSequence_Execute(ActionSequenceType_t actionType) {
    if (actionType >= 0 && actionType < ACTION_SEQUENCE_COUNT) {
        ActionSequences[actionType](); // 调用对应的动作序列函数
    }
}

// 亮灯
void ActionSequence_LightOn(void) {
    GPIO_WritePin(LED_PORT, LED_PIN_1, 1); // 点亮 LED 1
    GPIO_WritePin(LED_PORT, LED_PIN_2, 1); // 点亮 LED 2
}

// 灭灯
void ActionSequence_LightOff(void) {
    GPIO_WritePin(LED_PORT, LED_PIN_1, 0); // 关闭 LED 1
    GPIO_WritePin(LED_PORT, LED_PIN_2, 0); // 关闭 LED 2
}

// 跑马灯
void ActionSequence_RunningLight(void) {
    for (int i = 0; i < 10; i++) { // 跑马灯循环次数
        GPIO_WritePin(LED_PORT, LED_PIN_1, 1);
        GPIO_WritePin(LED_PORT, LED_PIN_2, 0);
        Delay_ms(200);
        GPIO_WritePin(LED_PORT, LED_PIN_1, 0);
        GPIO_WritePin(LED_PORT, LED_PIN_2, 1);
        Delay_ms(200);
    }
    ActionSequence_LightOff(); // 跑马灯结束，关闭所有 LED
}

// 蜂鸣器鸣叫
void ActionSequence_BuzzerBeep(void) {
    for (int i = 0; i < 3; i++) { // 鸣叫次数
        GPIO_WritePin(LED_PORT, BUZZER_PIN, 1); // 蜂鸣器开启
        Delay_ms(100);
        GPIO_WritePin(LED_PORT, BUZZER_PIN, 0); // 蜂鸣器关闭
        Delay_ms(100);
    }
}

// 单腿打招呼动作 (调用机器人运动控制模块的函数)
void ActionSequence_WaveOneLegAction(void) {
    RobotKinematics_WaveOneLeg(0); // 例如，让前左腿打招呼
}

// 跳舞动作 (调用机器人运动控制模块的函数)
void ActionSequence_DanceAction(void) {
    RobotKinematics_Dance();
}

4. 应用层 (Application Layer)

main.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stc8h8k.h> // 根据你的STC8H头文件
#include "hal_gpio.h"
#include "hal_timer.h"
#include "servo_driver.h"
#include "robot_kinematics.h"
#include "action_sequence.h"

void main() {
    // 初始化 HAL 层
    // (HAL 层模块的初始化通常在各自模块的 Init 函数中完成，例如 I2C_Init() 在 ServoDriver_Init() 中调用)

    // 初始化舵机驱动层
    ServoDriver_Init();

    // 初始化运动控制层
    RobotKinematics_Init();

    // 初始化动作序列模块
    ActionSequence_Init();

    Delay_ms(1000); // 启动延时，等待系统稳定

    // 示例：执行动作序列
    ActionSequence_Execute(ACTION_SEQUENCE_LIGHT_ON);
    Delay_ms(1000);
    ActionSequence_Execute(ACTION_SEQUENCE_RUNNING_LIGHT);
    Delay_ms(1000);
    ActionSequence_Execute(ACTION_SEQUENCE_BUZZER_BEEP);
    Delay_ms(1000);
    ActionSequence_Execute(ACTION_SEQUENCE_WAVE_ONE_LEG);
    Delay_ms(2000);
    ActionSequence_Execute(ACTION_SEQUENCE_DANCE);
    Delay_ms(3000);
    ActionSequence_Execute(ACTION_SEQUENCE_LIGHT_OFF);
    Delay_ms(1000);

    // 示例：控制机器人运动
    RobotKinematics_WalkForward(5); // 前进 5 步
    Delay_ms(2000);
    RobotKinematics_WalkBackward(3); // 后退 3 步
    Delay_ms(2000);
    RobotKinematics_TurnLeft(90);   // 左转 90 度 (角度值需要根据实际机器人调整)
    Delay_ms(2000);
    RobotKinematics_TurnRight(90);  // 右转 90 度
    Delay_ms(2000);
    RobotKinematics_Stand();        // 恢复站立姿态

    while (1) {
        // 主循环，可以添加用户输入处理、传感器数据采集等
        // 当前示例为一次性动作演示，主循环可以为空
    }
}

代码编译和注意事项

  1. 开发环境: 你需要安装STC8H8K64U的开发环境，例如 Keil C51 或 SDCC，并配置好编译工具链。
  2. 头文件: 确保你的项目中包含了正确的STC8H8K64U头文件 (stc8h8k.h 或类似的，根据你的开发环境和芯片型号可能有所不同)。
  3. 硬件连接: 根据代码中的GPIO引脚定义，将LED、蜂鸣器、PCA9685驱动芯片、舵机等硬件正确连接到STC8H8K64U单片机。
  4. 舵机型号和参数: 代码中 SERVO_MIN_PULSE 和 SERVO_MAX_PULSE 宏定义需要根据你使用的具体舵机型号进行调整，以确保舵机角度控制的准确性。
  5. 步态调整: RobotKinematics_WalkForward 等函数中的步态序列是简化的示例，实际机器人可能需要更精细的步态规划才能实现平稳的行走。你需要根据实际机器人的结构和运动特性进行调整和优化。
  6. 代码调试: 使用调试工具（例如串口调试、在线调试器）逐步调试代码，确保各个模块的功能正常。
  7. 电源: 确保为舵机和 PCA9685 驱动芯片提供足够的电源，避免电压不足导致舵机工作异常。

总结

以上代码提供了一个基于STC8H8K64U和PCA9685的四足机器人的完整软件框架和C代码实现。这个架构采用模块化设计，易于理解、维护和扩展。代码中包含了HAL层、舵机驱动层、运动控制层和应用层，涵盖了从硬件操作到高级动作控制的各个方面。

请注意，这只是一个基础框架，实际的四足机器人项目可能需要更复杂的功能和更精细的控制算法。你可以根据自己的需求，在这个框架的基础上进行扩展和改进，例如：

  • 传感器集成: 添加超声波传感器、红外传感器、姿态传感器等，实现环境感知和自主导航功能。
  • 更复杂的步态: 实现更平稳、更高效的行走、跑步、跳跃等步态。
  • 逆运动学和动力学模型: 构建更精确的机器人模型，实现更精确的运动控制。
  • 远程控制: 通过蓝牙、Wi-Fi 等无线通信方式，实现远程控制和参数配置。
  • 上位机软件: 开发上位机软件，实现更友好的用户界面和更强大的控制功能。

希望这份详细的代码和架构说明对您有所帮助！ 如果您有任何进一步的问题，请随时提出。

欢迎关注我的其它发布渠道