如何制作一款电子桌宠小狗（软件部分）开源（文章中内置代码附有详细的表明 ...

文章目次

  

• 
  
  
  
  • 概要
    
  • 整体架构流程
    
  • 技术名词表明
    
  • 技术细节
    
  • 小结
    
  
  

  

概要

本项目接纳模块化编程
一、USART1 与 USART3 的运用
USART1 和 USART3 主要负责数据的传输。我们可以通过它们与其他装备举行通讯，实现小狗与外界的互动（STM32 的 USART1 和 USART3 通常会有默认的引脚分配）。见下图

二、PWM 的功能实现
利用 PWM 技术，我们可以精确控制小狗的动作，比如通过调整占空比来模拟小狗的行走结果。
三、TIM 的应用
PWM（脉宽调制）的实现通常必要使用定时器（TIM）来提供精确的时间基准。定时器可以产生周期性的时钟信号，通过对定时器的配置，可以控制 PWM 信号的周期和占空比。利用定时器的计数功能，我们可以在特定的时间点切换输出电平，从而实现不同占空比的 PWM 信号。
四、I2C 控制 OLED
I2C 是毗连 OLED 显示屏的重要方式。通过 I2C 协议，我们能够将小狗的图像和动画数据正确地传输到显示屏上，使其生动呈现。
整体架构流程

通过串口对蓝牙和语音识别功能举行接收和发送，从而实现对单片机的控制。通过 PWM 实现对舵机的控制。通过II2通讯对 OLED 屏举行控制。
技术名词表明

PWM：脉冲宽度调制，通过调节脉冲的宽度来控制信号的平均值。
TIM：定时器，用于产生定时信号或举行时间丈量。
USART：通用同步/异步收发器，用于串行数据通讯。“TX”的全称是“Transmit”（发送），“RX”的全称是“Receive”（接收）。
II2：这个不太明确详细含义，大概是某种特定的标识或参数。
使能：意思是使某一功能或操纵得以启用、生效或实现。
它通常用于描述开启或激活某个特定的本领或机制。
遍历：按照肯定的规则依次访问和处理数据结构中的每个元素的过程。
它就像是逐一查抄数据结构中的每一项，确保不遗漏任何一个元素。
常见的数据结构遍历包括数组遍历、链表遍历、树结构遍历等。通过遍历，可以对数据举行各种操纵，如读取、修改、统计等。
技术细节

蓝牙部分

在界说 TX（发送）引脚时，通常初始化为推挽输出模式；而界说 RX（接收）引脚时，一般初始化为浮空输入或上拉输入模式。设置PA9,PA10分别为TX,RX.

1. #include "stm32f10x.h"                  // Device header
2. #include <stdio.h>
3. #include <stdarg.h>
4. #include "Delay.h"
5. #include <stdlib.h>
8. uint8_t USART1_RxData;                //存储从串口接收到的数据的变量
9. uint8_t USART1_RxFlag;                //指示串口接收状态的变量，通常用于表示是否有新的数据接收到、接收是否完成等状态信息。
12. void USART1_Init(void)
13. {
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);       
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        //开启时钟
19.         GPIO_InitTypeDef GPIO_InitStructure;   //定义结构体
20.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//复用推挽输出，TX
21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
22.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
23.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
24.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//表示输入上拉模式。
25. 在这种模式下，对应引脚被配置为输入模式，并且内部有上拉电阻，使得引脚在没有外部输入时保持高电平。
27.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
28.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
29.        
30.         USART_InitTypeDef USART_InitStructure;                                       
31.         USART_InitStructure.USART_BaudRate = 9600;        //波特率                       
32.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//这里是选择不用硬件流控制，硬件流控制是一种数据传输的控制方式。它通过使用特定的硬件信号线（如 RTS/CTS 等）来在发送方和接收方之间进行通信，以协调数据的发送和接收速度，确保数据传输的准确性和稳定性，避免数据丢失或错乱。以下情况通常会使用硬件流控制：
33. 高速数据传输：当数据传输速率较高，需要更精确地控制数据发送和接收时。
34. 对数据准确性要求高：在一些关键应用中，为了保证数据的完整性，会采用硬件流控制。
35. 长距离传输：在信号容易受到干扰的长距离传输中，硬件流控制有助于提高传输的可靠性。
37.         USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;        //两种模式均选择
38.         USART_InitStructure.USART_Parity = USART_Parity_No;        //        Parity 的意思是奇偶，这里是选择不需要奇偶校验，奇偶校验是一种简单的校验方法，用于检测数据在传输或存储过程中是否发生错误。
39. 它通过在数据编码中添加一位校验位，使数据中“1”的个数为奇数（奇校验）或偶数（偶校验）。接收方通过检查校验位来判断数据是否正确。
40.         USART_InitStructure.USART_StopBits = USART_StopBits_1;        //停止位1位
41.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;                //数据位8位，8b就是8bit。
42.         USART_Init(USART1, &USART_InitStructure);               
43.        
45.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);                //开启中断       
46.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                //配置 NVIC 优先级分组为 2。       
47.         NVIC_InitTypeDef NVIC_InitStructure;                                       
48.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;               
49.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                       
50.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;               
51.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                //使能中断、抢占优先级和响应优先级都设置为 1。抢占优先级：指的是中断能够抢占其他低优先级中断的能力。具有较高抢占优先级的中断可以先被执行，从而中断正在执行的低优先级中断。
52. 响应优先级：也称为子优先级，它决定了在具有相同抢占优先级的中断同时发生时的执行顺序。响应优先级较高的中断会先被处理。对比串口3，第一个串口的抢占优先级和响应优先级都为 1，意味着它在中断处理中的优先级相对较低。
53. 第三个串口的抢占优先级为 1，与第一个串口相同，但响应优先级设置为 3，相对较高。这意味着在相同抢占优先级的中断中，第二个串口的中断会优先得到响应和处理
55.         NVIC_Init(&NVIC_InitStructure);                                               
56.        
58.         USART_Cmd(USART1, ENABLE);                //使能                                               
59. }
61. //下面是一些函数
62. USART1_SendByte 和 USART1_SendArray 函数用于通过串口发送单个字节或数组数据。
63. USART1_SendString 函数用于发送字符串数据。
64. Serial_Pow 函数用于计算幂运算。
65. USART1_SendNumber 函数用于发送数字。
66. USART1_fputc 函数用于将字符输出到串口，使其可以像标准输出一样使用。
67. USART1_Printf 函数用于格式化并发送数据到串口。
68. USART1_GetRxFlag 和 USART1_GetRxData 函数用于获取接收标志和接收数据。
69. USART1_IRQHandler 函数是串口中断处理函数，用于处理接收数据的事件。
71. void USART1_SendByte(uint8_t Byte)
72. {
73.         USART_SendData(USART1, Byte);        //将指定的字节数据写入串口 1 的发送寄存器。       
74.         while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);        //这是一个等待循环，它会一直等待，直到串口 1 的发送缓冲区为空（即发送完成标志 USART_FLAG_TXE 被设置）。
75. }
78. void USART1_SendArray(uint8_t *Array, uint16_t Length)
79. {
80.         uint16_t i;
81.         for (i = 0; i < Length; i ++)               
82.         {
83.                 USART1_SendByte(Array[i]);               
84.         }
85. }//uint16_t i：定义一个循环变量 i。
86. for (i = 0; i < Length; i ++)：通过循环，从数组的第一个元素开始，依次将每个元素作为一个字节发送出去。
87. 在每次循环中，通过调用 USART1_SendByte(Array[i])，将当前数组元素发送出去。
90. void USART1_SendString(char *String)
91. {
92.         uint8_t i;
93.         for (i = 0; String[i] != '\0'; i ++)
94.         {
95.                 USART1_SendByte(String[i]);               
96.         }
97. }
98. //uint8_t i：定义一个用于遍历字符串的索引变量i。
99. for (i = 0; String[i]!= '\0'; i ++)：这是一个循环，从字符串的开头开始，一直到遇到字符串的结束标志（'\0'）为止。
100. 在循环中，通过USART1_SendByte(String[i])，将字符串的每个字符依次作为一个字节发送出去。这样就实现了将整个字符串通过串口发送出去的功能。
103. uint32_t Serial_Pow(uint32_t X, uint32_t Y)
104. {
105.         uint32_t Result = 1;       
106.         while (Y --)               
107.         {
108.                 Result *= X;               
109.         }
110.         return Result;
111. }
112. //Serial_Pow 函数用于计算一个数的指定次幂。
113. uint32_t Result = 1：初始化结果为 1。
114. while (Y --)：这是一个循环，循环次数为 Y 次。
115. 在循环中，通过不断将当前结果乘以 X，来计算幂值。每次循环后，Y 的值减 1。
116. 当循环结束后，返回计算得到的幂值。
118. void USART1_SendNumber(uint32_t Number, uint8_t Length)
119. {
120.         uint8_t i;
121.         for (i = 0; i < Length; i ++)               
122.         {
123.                 USART1_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');       
124.         }
125. }
127. //uint8_t i：定义一个循环变量 i。
128. for (i = 0; i < Length; i ++)：通过循环，从数字的高位到低位，逐位处理。
129. 在每次循环中，计算当前位的数值，即 Number 除以 Serial_Pow(10, Length - i - 1) 取余后再加上 '0'，将其转换为字符。然后使用 USART1_SendByte 发送该字符。这样就实现了将数字按位发送的效果。
130. int USART1_fputc(int ch, FILE *f)
131. {
132.         USART1_SendByte(ch);                       
133.         return ch;
134. }
135. //USART1_fputc 函数：
136. USART1_SendByte(ch)：将输入的字符 ch 通过 USART1_SendByte 发送出去。
137. return ch：返回输入的字符。
139. void USART1_Printf(char *format, ...)
140. {
141.         char String[100];                               
142.         va_list arg;                                       
143.         va_start(arg, format);                       
144.         vsprintf(String, format, arg);       
145.         va_end(arg);                                       
146.         USART1_SendString(String);
147. }//定义一个字符数组 String[100] 用于存储格式化后的字符串。
148. 使用 va_list 和相关函数来处理可变参数，将格式化后的字符串存储到 String 中。
149. 最后通过 USART1_SendString 将格式化后的字符串发送出去
153. uint8_t USART1_GetRxFlag(void)
154. {
155.         if (USART1_RxFlag == 1)                       
156.         {
157.                 USART1_RxFlag = 0;
158.                 return 1;                                       
159.         }
160.         return 0;                                               
161. }
162. //检查 USART1_RxFlag 是否为 1，如果是则将其重置为 0，并返回 1，表示接收到数据。
164. uint8_t USART1_GetRxData(void)
165. {
166.         return USART1_RxData;                       
167. }//返回接收到的串口数据 USART1_RxData。
170. void USART1_IRQHandler(void)
171. {
172.         if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)               
173.         {
174.                 USART1_RxData = USART_ReceiveData(USART1);                               
175.                 USART1_RxFlag = 1;                                                                               
176.                 USART_ClearITPendingBit(USART1, USART_IT_RXNE);//清除中断挂起位。               
177.                                                                                                                                
178.                                                                                                                                
179.         }
180. }
181. //在中断处理函数中，当接收到串口数据（USART_IT_RXNE 标志位被设置为 SET）时，获取接收到的数据并设置 USART1_RxFlag 为 1。

复制代码

语言控制部分（与上文代码大体结构雷同，上文代码中均有表明，此段代码不做表明，参考上文即可理解）

1. #include "stm32f10x.h"                  // Device header
2. #include <stdio.h>
3. #include <stdarg.h>
4. #include "Delay.h"
5. #include <stdlib.h>
8. uint8_t USART3_RxData;               
9. uint8_t USART3_RxFlag;       
11. void USART3_Init(void)
12. {
13.        
14.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);       
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);       
16.         GPIO_InitTypeDef GPIO_InitStructure;
17.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
19.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
20.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                       
21.        
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
23.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
24.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                       
25.        
26.        
27.         USART_InitTypeDef USART_InitStructure;                                       
28.         USART_InitStructure.USART_BaudRate = 9600;                               
29.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
30.         USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;       
31.         USART_InitStructure.USART_Parity = USART_Parity_No;               
32.         USART_InitStructure.USART_StopBits = USART_StopBits_1;       
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;               
34.         USART_Init(USART3, &USART_InitStructure);                                       
36.         USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);                       
37.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);               
38.         NVIC_InitTypeDef NVIC_InitStructure;                                                 
39.     NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;               
40.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                       
41.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;               
42.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
43.         NVIC_Init(&NVIC_InitStructure);                                                       
44.        
45.        
46.         USART_Cmd(USART3, ENABLE);                                                               
47. }
51. uint8_t USART3_GetRxFlag(void)
52. {
53.         if (USART3_RxFlag == 1)                       
54.         {
55.                 USART3_RxFlag = 0;
56.                 return 1;                               
57.         }
58.         return 0;                                               
59. }
62. uint8_t USART3_GetRxData(void)
63. {
64.         return USART3_RxData;               
65. }
69. void USART3_IRQHandler(void)
70. {
71.         if (USART_GetITStatus(USART3, USART_IT_RXNE) == SET)
72.         {
73.                 USART3_RxData = USART_ReceiveData(USART3);                       
74.                 USART3_RxFlag = 1;                                                                               
75.                 USART_ClearITPendingBit(USART3, USART_IT_RXNE);                       
76.                                                                                                                                
77.         }
78. }

复制代码

OLED部分

因内容太多，放于下一期文章，本文侧重点在于控制体系
舵机部分

舵机原理见（【STM32(意法半导体推出的32位微控制器)通过HC-05主从机一体蓝牙模块实现对舵机(SG90)的控制（含源码） - CSDN App】http://t.csdnimg.cn/O6hDl）
PWM、Servo、Movement三个文件共同为驱动舵机服务
PA6：右前脚，PA7：右后脚，PB0：左前脚，PB1：左后脚
PWM

1. #include "stm32f10x.h"                  // Device header
3. void PWM_Init(void)
4. {
6.     // 使能 TIM3 的时钟
7.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);   
8.     // 使能 GPIOA 的时钟
9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);   
10.     // 使能 GPIOB 的时钟
11.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);   
13.     // GPIO 初始化结构体设置
14.     GPIO_InitTypeDef GPIO_InitStructure;
15.     // 设置 GPIO 模式为复用推挽输出
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
17.     // 设置 GPIO 引脚为 PA6 和 PA7
18.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
19.     // 设置 GPIO 速度为 50MHz
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
21.     // 初始化 GPIOA
22.     GPIO_Init(GPIOA, &GPIO_InitStructure);                    
23.     // 设置 GPIO 引脚为 PB0 和 PB1
24.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
25.     // 初始化 GPIOB
26.     GPIO_Init(GPIOB, &GPIO_InitStructure);                    
28.     // 配置 TIM3 内部时钟
29.     TIM_InternalClockConfig(TIM3);        
31.     // TIM 时间基准初始化结构体设置
32.     TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;           
33.     // 设置时钟分频为 1
34.     TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;  
35.     // 设置计数器模式为向上计数
36.     TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
37.     // 设置周期为 20000 - 1
38.     TIM_TimeBaseInitStructure.TIM_Period = 20000 - 1;            
39.     // 设置预分频器为 72 - 1
40.     TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1;            
41.     // 设置重复计数器为 0
42.     TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;         
43.     // 初始化 TIM3 的时间基准
44.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure);           
46.     // TIM 输出比较初始化结构体设置
47.     TIM_OCInitTypeDef TIM_OCInitStructure;                        
48.     // 结构体初始化
49.     TIM_OCStructInit(&TIM_OCInitStructure);                        
51.     // 设置输出比较模式为 PWM1
52.     TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;            
53.     // 设置输出极性为高
54.     TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;      
55.     // 设置输出使能为启用
56.     TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  
57.     // 设置脉冲宽度为 0
58.     TIM_OCInitStructure.TIM_Pulse = 0;                              
59.     // 初始化 TIM3 的通道 2
60.     TIM_OC2Init(TIM3, &TIM_OCInitStructure);                       
61.     // 初始化 TIM3 的通道 3
62.     TIM_OC3Init(TIM3, &TIM_OCInitStructure);
63.     // 初始化 TIM3 的通道 1
64.     TIM_OC1Init(TIM3, &TIM_OCInitStructure);
65.     // 初始化 TIM3 的通道 4
66.     TIM_OC4Init(TIM3, &TIM_OCInitStructure);
68.     // 使能 TIM3
69.     TIM_Cmd(TIM3, ENABLE);      
70. }
72. void PWM_SetCompare1(uint16_t Compare)
73. {
74.         TIM_SetCompare1(TIM3, Compare);               
75. }
76. void PWM_SetCompare2(uint16_t Compare)
77. {
78.         TIM_SetCompare2(TIM3, Compare);               
79. }
80. void PWM_SetCompare3(uint16_t Compare)
81. {
82.         TIM_SetCompare3(TIM3, Compare);               
83. }
84. void PWM_SetCompare4(uint16_t Compare)
85. {
86.         TIM_SetCompare4(TIM3, Compare);               
87. }
88. //设置比较值的主要目的是控制 PWM（脉冲宽度调制）信号的占空比。
89. 通过改变比较值，可以调整输出信号高电平的持续时间，从而实现对被控对象的精确控制，比如调节电机的转速、灯光的亮度等。不同的比较值对应着不同的占空比，进而影响输出的效果。

复制代码

SERVO

Angle 是舵机角度，范围：0~180

1. #include "stm32f10x.h"                  // Device header  // 包含 STM32 芯片相关的头文件
2. #include "PWM.h"  // 包含 PWM 相关的头文件
4. void Servo_Init(void)  // 定义 Servo_Init 函数
5. {
6.     PWM_Init();                                                                          // 调用 PWM_Init 函数进行初始化
7. }
9. void Servo_SetAngle1(float Angle)  // 定义 Servo_SetAngle1 函数，用于设置角度 1
10. {
11.     PWM_SetCompare1(Angle / 180 * 2000 + 500);        // 根据输入的角度计算比较值并设置
12. }
14. void Servo_SetAngle2(float Angle)  // 定义 Servo_SetAngle2 函数，用于设置角度 2
15. {
16.     PWM_SetCompare2(Angle / 180 * 2000 + 500);        // 同上
17. }
19. void Servo_SetAngle3(float Angle)  // 定义 Servo_SetAngle3 函数，用于设置角度 3
20. {
21.     PWM_SetCompare3(Angle / 180 * 2000 + 500);        // 同上
22. }
24. void Servo_SetAngle4(float Angle)  // 定义 Servo_SetAngle4 函数，用于设置角度 4
25. {
26.     PWM_SetCompare4(Angle / 180 * 2000 + 500);        // 同上
27. }
29. uint8_t Servo_GetAngle1(void)  // 定义 Servo_GetAngle1 函数，用于获取角度 1
30. {
31.     return (TIM_GetCapture1(TIM3) - 500) * 180 / 2000;  // 通过定时器捕获值计算并返回角度
32. }
34. uint8_t Servo_GetAngle2(void)  // 定义 Servo_GetAngle2 函数，用于获取角度 2
35. {
36.     return (TIM_GetCapture2(TIM3) - 500) * 180 / 2000;  // 同上
37. }
39. uint8_t Servo_GetAngle3(void)  // 定义 Servo_GetAngle3 函数，用于获取角度 3
40. {
41.     return (TIM_GetCapture3(TIM3) - 500) * 180 / 2000;  // 同上
42. }
44. uint8_t Servo_GetAngle4(void)  // 定义 Servo_GetAngle4 函数，用于获取角度 4
45. {
46.     return (TIM_GetCapture4(TIM3) - 500) * 180 / 2000;  // 同上
47. }
48. //这样的计算是为了将角度范围转换为相应的定时器比较值，从而实现对 PWM 信号占空比的精确控制，以达到控制伺服o 电机转动角度的目的。

复制代码

MOVEMENT（此段函数是设置一些角度）

1. #include "stm32f10x.h"                  // Device header
2. #include "Servo.h"
3. #include "PWM.h"
4. #include "Delay.h"
5. #include "stdlib.h"
7. int i,j;
8. int movedelay=150;
9. uint8_t angle_1, angle_2, angle_3, angle_4;
10.        
11. void move_stand(void){
12.         Servo_SetAngle1(90);
13.         Servo_SetAngle2(90);
14.         Servo_SetAngle3(90);
15.         Servo_SetAngle4(90);
16.         Delay_ms(500);
17. }
19. void move_forward(void){
21.         Servo_SetAngle1(135);
22.         Servo_SetAngle4(45);
23.         Delay_ms(movedelay);
24.        
25.         Servo_SetAngle2(45);
26.         Servo_SetAngle3(135);
27.         Delay_ms(movedelay);
28.        
29.         Servo_SetAngle1(90);
30.         Servo_SetAngle4(90);
31.         Delay_ms(movedelay);
32.        
33.         Servo_SetAngle2(90);
34.         Servo_SetAngle3(90);
35.         Delay_ms(movedelay);
36.        
37.         Servo_SetAngle2(135);
38.         Servo_SetAngle3(45);
39.         Delay_ms(movedelay);
40.        
41.         Servo_SetAngle1(45);
42.         Servo_SetAngle4(135);
43.         Delay_ms(movedelay);
44.        
45.         Servo_SetAngle2(90);
46.         Servo_SetAngle3(90);
47.         Delay_ms(movedelay);
48.        
49.         Servo_SetAngle1(90);
50.         Servo_SetAngle4(90);
51.         Delay_ms(movedelay);
52. }
54. void move_behind(void){
55.        
56.         Servo_SetAngle1(45);
57.         Servo_SetAngle4(135);
58.         Delay_ms(movedelay);
59.                
60.         Servo_SetAngle2(135);
61.         Servo_SetAngle3(45);
62.         Delay_ms(movedelay);
63.                
64.         Servo_SetAngle1(90);
65.         Servo_SetAngle4(90);
66.         Delay_ms(movedelay);
67.        
68.         Servo_SetAngle2(90);
69.         Servo_SetAngle3(90);
70.         Delay_ms(movedelay);
72.         Servo_SetAngle2(45);
73.         Servo_SetAngle3(135);
74.         Delay_ms(movedelay);
75.                
76.         Servo_SetAngle1(135);
77.         Servo_SetAngle4(45);
78.         Delay_ms(movedelay);
79.        
80.         Servo_SetAngle2(90);
81.         Servo_SetAngle3(90);
82.         Delay_ms(movedelay);
83.        
84.         Servo_SetAngle1(90);
85.         Servo_SetAngle4(90);
86.         Delay_ms(movedelay);
87. }
89. void move_right(void){
90.         Servo_SetAngle1(45);
91.         Servo_SetAngle4(45);
92.         Delay_ms(movedelay);
93.        
94.         Servo_SetAngle2(135);
95.         Servo_SetAngle3(135);
96.         Delay_ms(movedelay);
97.        
98.         Servo_SetAngle1(90);
99.         Servo_SetAngle4(90);
100.         Delay_ms(movedelay);
101.        
102.         Servo_SetAngle2(90);
103.         Servo_SetAngle3(90);
104.         Delay_ms(movedelay);
105. }
107. void move_left(void)
108. {
109.         Servo_SetAngle2(135);
110.         Servo_SetAngle3(135);
111.         Delay_ms(movedelay);
112.        
113.         Servo_SetAngle1(45);
114.         Servo_SetAngle4(45);
115.         Delay_ms(movedelay);
116.        
117.         Servo_SetAngle2(90);
118.         Servo_SetAngle3(90);
119.         Delay_ms(movedelay);
120.        
121.         Servo_SetAngle1(90);
122.         Servo_SetAngle4(90);
123.         Delay_ms(movedelay);
124. }
126. void move_hello(void)
127. {
128.         for(i=0;i<20;i++)//
129.         {
130.         Servo_SetAngle1(90-i);
131.         Servo_SetAngle2(90+i);
132.         Servo_SetAngle4(90-i);
133.                 Delay_ms(4);
134.         }
135.         for(i=0;i<60;i++)
136.         {
137.         Servo_SetAngle2(110+i);
138.         Servo_SetAngle4(70-i);
139.                 Delay_ms(4);
140.         }
141.         for(i=0;i<60;i++)
142.         {
143.                 Servo_SetAngle1(70+i);
144.                 Delay_ms(4);
145.         }
146.         Delay_ms(50);
147.         Servo_SetAngle1(180);
148.         Delay_ms(500);
149.         Servo_SetAngle1(130);
150.         Delay_ms(500);
151.         Servo_SetAngle1(180);
152.         Delay_ms(500);
153.         Servo_SetAngle1(130);
154.         Delay_ms(500);
155.         Servo_SetAngle1(70);
156.         Delay_ms(500);
157. }
159. void move_shake_qianhou(void)
160. {  
161.         Servo_SetAngle2(135);
162.         Servo_SetAngle1(135);
163.         Servo_SetAngle3(45);
164.         Servo_SetAngle4(45);
165.         Delay_ms(150);
166.         Servo_SetAngle1(90);
167.         Servo_SetAngle2(90);
168.         Servo_SetAngle3(90);
169.         Servo_SetAngle4(90);
170.         Delay_ms(150);
171.         Servo_SetAngle2(45);
172.         Servo_SetAngle1(45);
173.         Servo_SetAngle3(135);
174.         Servo_SetAngle4(135);
175.         Delay_ms(150);
176.         Servo_SetAngle1(90);
177.         Servo_SetAngle2(90);
178.         Servo_SetAngle3(90);
179.         Servo_SetAngle4(90);
180.         Delay_ms(150);
181.        
182.        
183. }
184. void move_shake_zuoyou(void)
185. {
186.         Servo_SetAngle1(135);
187.         Servo_SetAngle2(135);
188.         Delay_ms(movedelay);
189.         Servo_SetAngle3(135);
190.         Servo_SetAngle4(135);
191.         Delay_ms(movedelay);
192.         Servo_SetAngle1(90);
193.         Servo_SetAngle2(90);
194.         Delay_ms(movedelay);
195.         Servo_SetAngle3(90);
196.         Servo_SetAngle4(90);
197.         Delay_ms(movedelay);
198.         Servo_SetAngle3(45);
199.         Servo_SetAngle4(45);
200.         Delay_ms(movedelay);
201.         Servo_SetAngle1(45);
202.         Servo_SetAngle2(45);
203.         Delay_ms(movedelay);
204.         Servo_SetAngle3(90);
205.         Servo_SetAngle4(90);
206.         Delay_ms(movedelay);
207.         Servo_SetAngle1(90);
208.         Servo_SetAngle2(90);
209.         Delay_ms(movedelay);
210. }
211. void move_dance(void)
212. {
213.         Servo_SetAngle1(135);
214.         Servo_SetAngle2(135);
215.         Delay_ms(movedelay);
216.         Servo_SetAngle3(135);
217.         Servo_SetAngle4(135);
218.         Delay_ms(movedelay);
219.         Servo_SetAngle1(90);
220.         Servo_SetAngle2(90);
221.         Delay_ms(movedelay);
222.         Servo_SetAngle3(90);
223.         Servo_SetAngle4(90);
224.         Delay_ms(movedelay);
225.        
226.         Servo_SetAngle2(135);
227.         Servo_SetAngle1(135);
228.         Servo_SetAngle3(45);
229.         Servo_SetAngle4(45);
230.         Delay_ms(150);
231.         Servo_SetAngle1(90);
232.         Servo_SetAngle2(90);
233.         Servo_SetAngle3(90);
234.         Servo_SetAngle4(90);
235.         Delay_ms(150);
236.        
237.        
238.         Servo_SetAngle3(45);
239.         Servo_SetAngle4(45);
240.         Delay_ms(movedelay);
241.         Servo_SetAngle1(45);
242.         Servo_SetAngle2(45);
243.         Delay_ms(movedelay);
244.         Servo_SetAngle3(90);
245.         Servo_SetAngle4(90);
246.         Delay_ms(movedelay);
247.         Servo_SetAngle1(90);
248.         Servo_SetAngle2(90);
249.         Delay_ms(movedelay);
250.        
251.         Servo_SetAngle2(45);
252.         Servo_SetAngle1(45);
253.         Servo_SetAngle3(135);
254.         Servo_SetAngle4(135);
255.         Delay_ms(150);
256.         Servo_SetAngle1(90);
257.         Servo_SetAngle2(90);
258.         Servo_SetAngle3(90);
259.         Servo_SetAngle4(90);
260.         Delay_ms(150);
261.        
262. }
263. void move_head_up(void)
264. {
265.         for(i=0;i<20;i++)
266.         {
267.                 Servo_SetAngle1(90-i);
268.                 Servo_SetAngle3(90+i);
269.                 Delay_ms(10);
270.         }
271.         for(i=0;i<65;i++)
272.         {
273.                 Servo_SetAngle2(90+i);
274.                 Servo_SetAngle4(90-i);
275.                 Delay_ms(10);
276.         }
277. }
278. void move(uint16_t set1 , uint16_t set2 , uint16_t set3 , uint16_t set4 , uint16_t speed){
279.         angle_1 = Servo_GetAngle1();
280.         angle_2 = Servo_GetAngle2();
281.         angle_3 = Servo_GetAngle3();
282.         angle_4 = Servo_GetAngle4();
283.         while (angle_1 != set1 || angle_3 != set3 || angle_2 != set2 || angle_4 != set4) {
284.                 if (angle_1 > set1) {
285.                         --angle_1;
286.                         Servo_SetAngle1(angle_1);
287.                 } else if (angle_1 < set1) {
288.                         ++angle_1;
289.                         Servo_SetAngle1(angle_1);
290.                 }
291.        
292.                 if (angle_3 > set3) {
293.                         --angle_3;
294.                         Servo_SetAngle3(angle_3);
295.                 } else if (angle_3 < set3) {
296.                         ++angle_3;
297.                         Servo_SetAngle3(angle_3);
298.                 }
299.                 if (angle_2 > set2) {
300.                         --angle_2;
301.                         Servo_SetAngle2(angle_2);
302.                 } else if (angle_2 < set2) {
303.                         ++angle_2;
304.                         Servo_SetAngle2(angle_2);
305.                 }
306.                 if (angle_4 > set4) {
307.                         --angle_4;
308.                         Servo_SetAngle4(angle_4);
309.                 } else if (angle_4 < set4) {
310.                         ++angle_4;
311.                         Servo_SetAngle4(angle_4);
312.                 }
313.                 Delay_ms(1000/speed);
314.         }
315. }
316. void move_slow_stand(uint8_t previous_mode){
317.         if (previous_mode == '0')
318.                 return;
319.         angle_1 = Servo_GetAngle1();
320.         angle_2 = Servo_GetAngle2();
321.         angle_3 = Servo_GetAngle3();
322.         angle_4 = Servo_GetAngle4();
323.         while (angle_1 != 90 || angle_3 != 90 || angle_2 != 90 || angle_4 != 90) {
324.                 if (angle_1 > 90) {
325.                         --angle_1;
326.                         Servo_SetAngle1(angle_1);
327.                 } else if (angle_1 < 90) {
328.                         ++angle_1;
329.                         Servo_SetAngle1(angle_1);
330.                 }
331.                 //
332.                 if (angle_3 > 90) {
333.                         --angle_3;
334.                         Servo_SetAngle3(angle_3);
335.                 } else if (angle_3 < 90) {
336.                         ++angle_3;
337.                         Servo_SetAngle3(angle_3);
338.                 }
339.                 if (angle_2 > 90) {
340.                         --angle_2;
341.                         Servo_SetAngle2(angle_2);
342.                 } else if (angle_2 < 90) {
343.                         ++angle_2;
344.                         Servo_SetAngle2(angle_2);
345.                 }
346.                 //
347.                 if (angle_4 > 90) {
348.                         --angle_4;
349.                         Servo_SetAngle4(angle_4);
350.                 } else if (angle_4 < 90) {
351.                         ++angle_4;
352.                         Servo_SetAngle4(angle_4);
353.                 }
354.                 Delay_ms(10);
355.         }
356. }
357. void move_stretch(void){
358.           for(i=0;i<65;i++)
359.         {
360.     Servo_SetAngle2(90+i);
361.         Servo_SetAngle4(90-i);
362.         Delay_ms(5);
363.         }
364.           for(i=0;i<20;i++)
365.         {
366.   Servo_SetAngle1(90-i);
367.         Servo_SetAngle3(90+i);
368.         Delay_ms(5);
369.         }
370.         Delay_ms(1000);
371.         for(i=0;i<60;i++)
372.         {
373.                 Servo_SetAngle1(70+i);
374.                 Delay_ms(4);
375.         }
376.         Delay_ms(1000);
377.         Servo_SetAngle1(180);
378.         Delay_ms(500);
379.         Servo_SetAngle1(130);
380.         Delay_ms(500);
381.         Servo_SetAngle1(180);
382.         Delay_ms(500);
383.         Servo_SetAngle1(130);
384.         Delay_ms(500);
385.         Servo_SetAngle1(70);
386.         Delay_ms(5);
387. }
388. void move_two_hands(void){
389.         Servo_SetAngle3(20);
390.         Servo_SetAngle2(20);
391.         Delay_ms(200);
392.         Servo_SetAngle3(90);
393.         Servo_SetAngle2(90);
394.         Delay_ms(200);
395.         Servo_SetAngle1(160);
396.         Servo_SetAngle4(160);
397.         Delay_ms(200);
398.         Servo_SetAngle1(90);
399.         Servo_SetAngle4(90);
400.         Delay_ms(200);
401. }
402. void lan_yao(void){
403.   for(i=0;i<75;i++)
404.         {
405.         Servo_SetAngle1(90+i);
406.         Servo_SetAngle3(90-i);
407.         Servo_SetAngle2(90+i/2);
408.         Servo_SetAngle4(90-i/2);
409.         Delay_ms(5);
410.         }
411.         Delay_ms(movedelay*50);
412.         for(i=0;i<75;i++)
413.         {
414.         Servo_SetAngle1(165-i);
415.         Servo_SetAngle3(15+i);
416.         Servo_SetAngle2(127-i/2);
417.         Servo_SetAngle4(53+i/2);
418.         Delay_ms(5);
419.         }
420.         Delay_ms(movedelay);
421. }
422. void move_sleep_p(void) {
423.         for(i=0;i<75;i++)
424.         {
425.                 Servo_SetAngle1(90+i);
426.                 Servo_SetAngle3(90-i);
427.                 Delay_ms(10);
428.         }
429.         for(i=0;i<75;i++)
430.         {
431.                 Servo_SetAngle4(90+i);
432.                 Servo_SetAngle2(90-i);
433.                 Delay_ms(10);
434.         }
435. }
436. void move_sleep_w(void) {
437.                 for(i=0;i<75;i++)
438.         {
439.                 Servo_SetAngle3(90+i);
440.                 Servo_SetAngle1(90-i);
441.                 Delay_ms(10);
442.         }
443.         for(i=0;i<75;i++)
444.         {
445.                 Servo_SetAngle2(90+i);
446.                 Servo_SetAngle4(90-i);
447.                 Delay_ms(10);
448.         }
449. }

复制代码

各器件共同部分（各种器件连在一起完成某个动作）

1. #include "stm32f10x.h"                  // Device header
2. #include "stdlib.h"
3. #include "LED.h"
4. #include "Delay.h"
5. #include "OLED.h"
6. #include "Servo.h"
7. #include "PWM.h"
8. #include "Movement.h"
9. #include "usart1.h"
10. #include "usart3.h"
11. #include "stdio.h"
14. extern uint8_t move_mode1 ;
15. extern uint8_t move_mode3 ;
16. extern uint8_t move_mode ;
17. extern uint8_t previous_mode ;
21. void mode_forward(void)
22. {
23.                         OLED_ShowImage(0, 0, 128, 64, BMP2);
24.                         move_forward();
25.                         LED13_Turn();
26.                         previous_mode = move_mode;
27.        
28. }
29. void mode_behind(void)
30. {
31.                         OLED_ShowImage(0, 0, 128, 64, BMP2);
32.                         move_behind();
33.                         LED13_Turn();
34.                         previous_mode = move_mode;
35.        
36. }
37. void mode_left(void)
38. {
39.                         OLED_ShowImage(0, 0, 128, 64, BMP3);
40.                         move_left();
41.                         LED13_Turn();
42.                         previous_mode = move_mode;
43.        
44.        
45. }
46. void mode_right(void)
47. {
48.                         OLED_ShowImage(0, 0, 128, 64, BMP4);
49.                         move_right();
50.                         LED13_Turn();
51.                         previous_mode = move_mode;
52. }
54. void mode_swing_qianhou(void)
55. {
56.                         OLED_ShowImage(0, 0, 128, 64, BMP11);
57.                         move_shake_qianhou();
58.                         LED13_Turn();
59.                         previous_mode = move_mode;
60. }
61. void mode_swing_zuoyou(void)
62. {
63.                         OLED_ShowImage(0, 0, 128, 64, BMP11);
64.                         move_shake_zuoyou();
65.                         LED13_Turn();
66.                         previous_mode = move_mode;
67. }
69. void mode_dance(void)
70. {
71.                         OLED_ShowImage(0, 0, 128, 64, BMP5);
72.                         move_dance();
73.                         LED13_Turn();
74.                         previous_mode = move_mode;
75.        
76. }
77. void mode_stand(void)
78. {
79.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
80.                         move_stand();
81.                         LED13_Turn();
82.                         previous_mode = move_mode;
83.                         move_mode = '0';
84.        
85. }
86. void mode_slowstand(void)
87. {
88.                        
89.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
90.                         move_slow_stand(previous_mode);
91.                         LED13_Turn();
92.                         previous_mode = move_mode;
93.                         move_mode = '0';
94. }
96. void mode_strech(void)
97. {
98.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
99.                         move_slow_stand(previous_mode);
100.                         OLED_ShowImage(0, 0, 128, 64, BMP2);
101.                         move_stretch();
102.                         OLED_ShowImage(0, 0, 128, 64, BMP12);
103.                         LED13_Turn();
104.                         previous_mode = move_mode;
105.                         move_mode = '0';
106.                
107. }
108. void mode_hello(void)
109. {
110.                         if (previous_mode != '5' && previous_mode != 'D') {
111.                                 OLED_ShowImage(0, 0, 128, 64, BMP1);
112.                                 move_slow_stand(previous_mode);
113.                         }
114.         OLED_ShowImage(0, 0, 128, 64, BMP12);
115.                 int i;
116.         for(i=0;i<20;i++)
117.         {
118.         Servo_SetAngle1(90-i);
119.         Servo_SetAngle2(90+i);
120.         Servo_SetAngle4(90-i);
121.                 Delay_ms(7);
122.         }
123.         for(i=0;i<40;i++)
124.         {
125.         Servo_SetAngle2(110+i);
126.         Servo_SetAngle4(70-i);
127.                 Delay_ms(7);
128.         }
129.         for(i=0;i<60;i++)
130.         {
131.                 Servo_SetAngle1(70+i);
132.                 Delay_ms(4);
133.         }
134.         Delay_ms(50);
135.         Servo_SetAngle1(180);
136.         Delay_ms(400);
137.         Servo_SetAngle1(130);
138.         Delay_ms(400);
139.         Servo_SetAngle1(180);
140.         Delay_ms(400);
141.         Servo_SetAngle1(130);
142.         Delay_ms(400);
143.         Servo_SetAngle1(70);
144.         Delay_ms(500);
145.                         LED13_Turn();
146.                         previous_mode = move_mode;
147.                         move_mode = '0';
148. }
149. void mode_twohands(void)
150. {
151.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
152.                         move_stand();
153.                         move_two_hands();
154.                         LED13_Turn();
155.                         previous_mode = move_mode;
156.                         move_mode = '0';
157.        
158. }
159. void mode_lanyao(void)
160. {
161.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
162.                         move_slow_stand(previous_mode);
163.                         OLED_ShowImage(0, 0, 128, 64, BMP9);
164.                         lan_yao();
165.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
166.                         LED13_Turn();
167.                         previous_mode = move_mode;
168.                         move_mode = '0';
169.        
170. }
171. void mode_headup(void)
172. {
173.                         OLED_ShowImage(0, 0, 128, 64, BMP1);
174.                         move_slow_stand(previous_mode);
175.                         OLED_ShowImage(0, 0, 128, 64, BMP10);
176.                         move_head_up();
177.                         LED13_Turn();
178.                         previous_mode = move_mode;
179.                         move_mode = '0';
180.        
181. }
182. void mode_sleeppa(void)
183. {
184.                         if (previous_mode != '5' && previous_mode != 'q') {
185.                                 OLED_ShowImage(0, 0, 128, 64, BMP1);
186.                                 move_slow_stand(previous_mode);
187.                         }
188.                         if (rand()%2) {
189.                                 OLED_ShowImage(0, 0, 128, 64, BMP6);
190.                         }
191.                         else{
192.                                 OLED_ShowImage(0, 0, 128, 64, BMP8);
193.                         }
194.                         move_sleep_p();
195.                         previous_mode = move_mode;
196.                         move_mode = '0';
197. }
198. void mode_sleepwo(void)
199. {
200.                         if (previous_mode != '5' && previous_mode != 'q') {
201.                                 OLED_ShowImage(0, 0, 128, 64, BMP1);
202.                                 move_slow_stand(previous_mode);
203.                                 Delay_s(1);
204.                         }
205.                         if (rand()%2) {
206.                                 OLED_ShowImage(0, 0, 128, 64, BMP6);
207.                         }
208.                         else{
209.                                 OLED_ShowImage(0, 0, 128, 64 , BMP8);
210.                         }
211.                         move_sleep_w();
212.                         previous_mode = move_mode;
213.                         move_mode = '0';
214.                
215. }

复制代码

主函数逻辑

1. #include "stm32f10x.h"                  // 包含 STM32 芯片的头文件
2. #include "stdlib.h"
3. #include <stdio.h>
4. #include "LED.h"
5. #include "Delay.h"
6. #include "OLED.h"
7. #include "Servo.h"
8. #include "PWM.h"
9. #include "Movement.h"
10. #include "usart1.h"
11. #include "usart3.h"
12. #include "Mode.h"
14. // 定义变量
15. uint8_t RxData;  // 接收数据变量
16. uint8_t move_mode1 = '0';  // 模式 1
17. uint8_t move_mode3 = '0';  // 模式 3
18. uint8_t move_mode = '0';  // 当前模式
19. uint8_t previous_mode = '0';  // 上一个模式
21. int main(void)  // 主函数
22. {
23.     LED_Init();  // 初始化 LED
24.     OLED_Init();  // 初始化 OLED
25.     USART1_Init();  // 初始化 USART1
26.     USART3_Init();  // 初始化 USART3
27.     Servo_Init();  // 初始化舵机
28.     OLED_Clear();  // 清屏
29.     OLED_ShowImage(0, 0, 128, 64, BMP1);  // 显示图像
30.     mode_stand();  // 进入站立模式
32.     while (1)  // 主循环
33.     {
34.         move_mode1 = USART1_GetRxData();  // 获取 USART1 接收的数据
35.         move_mode3 = USART3_GetRxData();  // 获取 USART3 接收的数据
37.         if (USART1_GetRxFlag())  // 如果 USART1 有接收标志
38.         {
39.             move_mode = move_mode1;  // 更新当前模式为模式 1
40.         }
41.         else if (USART3_GetRxFlag())  // 如果 USART3 有接收标志
42.         {
43.             move_mode = move_mode3;  // 更新当前模式为模式 3
44.         }
46.         if (move_mode == 'f')  // 如果当前模式为前进
47.         {
48.             mode_forward();  // 执行前进模式
49.         }
50.         else if (move_mode == 'b')  // 如果当前模式为后退
51.         {
52.             mode_behind();  // 执行后退模式
53.         }
54.         else if (move_mode == 'l')  // 如果当前模式为左移
55.         {
56.             mode_left();  // 执行左移模式
57.         }
58.         else if (move_mode == 'r')  // 如果当前模式为右移
59.         {
60.             mode_right();  // 执行右移模式
61.         }
62.         else if (move_mode == 'w')  // 如果当前模式为前后摆动
63.         {
64.             mode_swing_qianhou();  // 执行前后摆动模式
65.         }
66.         else if (move_mode == 'z')  // 如果当前模式为左右摆动
67.         {
68.             mode_swing_zuoyou();  // 执行左右摆动模式
69.         }
70.         else if (move_mode == 'd')  // 如果当前模式为舞蹈
71.         {
72.             mode_dance();  // 执行舞蹈模式
73.         }
74.         else if (move_mode == '5')  // 如果当前模式为站立
75.         {
76.             mode_stand();  // 执行站立模式
77.         }
78.         else if (move_mode == 'q' && previous_mode!= '0')  // 如果当前模式为缓慢站立且上一个模式不为 0
79.         {
80.             mode_slowstand();  // 执行缓慢站立模式
81.         }
82.         else if (move_mode =='s' && previous_mode!= '')  // 如果当前模式为伸展且上一个模式不为伸展
83.         {
84.             mode_strech();  // 执行伸展模式
85.         }
86.         else if (move_mode == 'j')  // 如果当前模式为双手
87.         {
88.             mode_twohands();  // 执行双手模式
89.         }
90.         else if (move_mode == 'y')  // 如果当前模式为懒腰
91.         {
92.             mode_lanyao();  // 执行懒腰模式
93.         }
94.         else if (move_mode == '1')  // 如果当前模式为抬头
95.         {
96.             mode_headup();  // 执行抬头模式
97.         }
98.         else if (move_mode == 'p' && previous_mode!= 'p')  // 如果当前模式为睡眠且上一个模式不为睡眠
99.         {
100.             mode_sleeppa();  // 执行睡眠模式
101.         }
102.         else if (move_mode == '2' && previous_mode!= '2')  // 如果当前模式为另一种睡眠且上一个模式不为另一种睡眠
103.         {
104.             mode_sleepwo();  // 执行另一种睡眠模式
105.         }
106.     }
107. }

复制代码

LD3320串口版语音模块（需单独烧录）

放置开源代码中，不举行表明，可参考文章（http://【STM32F103C8T6与LD3320举行串口通讯控制LED灯的亮灭 - CSDN App】http://t.csdnimg.cn/8qo2F）

开源代码

通过网盘分享的文件：软件.zip
链接: https://pan.baidu.com/s/1lWq7ZRIU3ooZQUHlGB4-mg?pwd=2003 提取码: 2003


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。