代码：

注释写的较少，但本文出现的代码都有注释，所以请直接在本文里看注释

–来自百度网盘超级会员V4的分享

项目概述：

基于STM32的FreeRTOS四轴机械臂

        基于FreeRTOS实时操作系统，主控为 STM32F103C8T6 ，机械臂为四轴分别被四个Mg90s舵机控制。本项目实现了 3 种控制方法，分别为 摇杆控制  、 串口蓝牙控制 和 示教器控制。可以进行动作录制和执行。

        采用8路ADC采集摇杆和示教器的模拟量并由DMA搬运数据，USART串口实时收发信息，IIC驱动OLED屏幕实时显示信息。并且实现了动作录制和执行功能，动作记忆可以由二维数组或者链表实现存储。通过SPI驱动W25Q128模块进行动作记忆扩容，即可以录制上百组动作。

一 准备阶段（都是些废话）

        首先你需要一台四轴机械臂，才能开始这个项目。可以自己建模3D打印，也可以直接某宝购买了一套成品套件，来做功能实现。而你的机械臂会配备四个电机，本文采用的是舵机，型号无所谓，控制起来是一样的，注意需要是180度的角度型舵机，而不是360度的速度型舵机。

        然后是单片机及开发环境，使用STM32F103C8T6。开发环境为STM32cubeM和Keil5。

（如果你没有STM32开发经验：首先你至少要有一点C语言基础，最基本的代码要能读懂什么意思；然后最好有过其它单片机开发经验，比如C51、ESP8266等等，或者直接学习一下STM32开发。板子随便买一个此型号的开发板就行，买最小系统板＋面包板也可以。STM32cubeMX＋Keil5，可以自行百度搜索并下载安装，我建议在B站找一个STM32HAL库的教程，跟着安装，且最好教程芯片型号与你使用的要一致。按照教程走一遍。确认开发板和开发环境可用之后，简单学习一下HAL库开发。然后可以继续下面的步骤。）

STM32cubeM和Keil5的教程推荐：

【中科大RM电控合集】手把手Keil+STM32CubeMX+VsCode环境配置_哔哩哔哩_bilibili

        其它硬件准备：

HC系列蓝牙串口模块，实测HC-05和HC-08都可以
摇杆模块，买两个即可。
四个旋钮电位器，质量别太差。
IIC协议OLED屏幕
SPI协议W25Q128模块
按钮模块若干，我用了四个，有板载的按钮也可以，尽量买带电容的防抖按钮
舵机拓展板，可有可无，面包板也能用。
各式杜邦线若干。

 二 裸机测试功能

1.摇杆控制

        首先是摇杆控制STM32，需要4路1ADC＋DMA采集摇杆输出的模拟量。根据这个数据来控制舵机角度。蓝牙串口把ADC信息和舵机角度打印出来。蓝牙直接用HC官方的HC蓝牙串口助手就行。

接线：

摇杆4个输出模拟量的引脚连接stm32的A0，A1，A2，A3，VCC这里接5V。

舵机A，夹爪    CH4_B11;adc4_A3

舵机B，上下    CH3_B10;adc3_A2

舵机C，前后    CH2_B3;adc2_A1

舵机D，底座    CH1_A15;adc1_A0

蓝牙TX对板子RX A10，

蓝牙RX对板子TX A9。

CubeMX配置：

基本配置（后面每个工程都是这一套）

 

 ADC1：4路

 

 DMA：搬运ADC数据的

PWM输出：选用799*1799，这样可以把舵机有效的 0.5~2.5ms / 20ms 这个区间分成180段，对应0~180度。

 usart，9600波特率给蓝牙模块用。

然后 generate code 即可

代码：

注：只有这种注释之间是用户自己写业务代码的地方，写其它地方再重生成功能会被清除。

  1. /* USER CODE BEGIN */
  3.     。。。。 。。。。
  5. /* USER CODE END */

main.c

关键控制代码在于check的四个函数，首先限制舵机的角度范围避免损坏，再根据采集的摇杆信息值判断每个舵机的角度是增加还是减小。

注释比较清楚，直接看代码就行。

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include 'stdio.h'
  4. /* USER CODE END Includes */
  6. /* Private variables ---------------------------------------------------------*/
  8. /* USER CODE BEGIN PV */
  9. uint16_t adc_dma[4];//DMA搬运的ADC采集值
  11. uint8_t angle[4] = {90,90,90,90};//舵机角度
  13. uint8_t cnt = 0;//计数用，定时串口打印信息
  15. /* USER CODE END PV */
  17. /* Private user code ---------------------------------------------------------*/
  18. /* USER CODE BEGIN 0 */
  19. //覆写printf，用于串口打印数据
  20. int fputc(int ch, FILE *f)
  21. {      
  22.     unsigned char temp[1]={ch};
  23.     HAL_UART_Transmit(&huart1,temp,1,0xffff);  
  24.     return ch;
  25. }
  27. //根据输入的0~180角度获取对应pwm占空比参数
  28. uint8_t Angle(uint8_t pwm_pulse)
  29. {
  30. 	return pwm_pulse + 44;
  31. }
  33. //舵机A，夹爪	CH4_B11
  34. void cheack_A()
  35. {
  36. 	if(adc_dma[3] > 4000 && angle[3] < 90)
  37. 	{
  38. 		angle[3]++;
  39. 	}
  40. 	else if(adc_dma[3] <1000 && angle[3] > 0)
  41. 	{
  42. 		angle[3]--;
  43. 	}
  44. }
  45. //舵机B，上下	CH3_B10
  46. void cheack_B()
  47. {
  48. 	if(adc_dma[2] <1000 && angle[2] < 135)
  49. 	{
  50. 		angle[2]++;
  51. 	}
  52. 	else if(adc_dma[2] > 4000 && angle[2] > 45)
  53. 	{
  54. 		angle[2]--;
  55. 	}
  56. }
  57. //舵机C，前后	CH2_B3
  58. void cheack_C()
  59. {
  60. 	if(adc_dma[1] <1000 && angle[1] < 135)
  61. 	{
  62. 		angle[1]++;
  63. 	}
  64. 	else if(adc_dma[1] > 4000 && angle[1] > 45)
  65. 	{
  66. 		angle[1]--;
  67. 	}
  68. }
  69. //舵机D，底座	CH1_A15
  70. void cheack_D()
  71. {
  72. 	if(adc_dma[0] <1000 && angle[0] < 180)
  73. 	{
  74. 		angle[0]++;
  75. 	}
  76. 	else if(adc_dma[0] > 4000 && angle[0] > 0)
  77. 	{
  78. 		angle[0]--;
  79. 	}
  80. }
  82. /* USER CODE END 0 */
  85.   /* USER CODE BEGIN 2 */
  86. 	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4); //开始ADC和DMA采集
  88. 	//开启4路PWM
  89. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  90. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  91. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  92. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  94. 	//延时半秒，系统稳定一下
  95. 	HAL_Delay(500);
  96.   /* USER CODE END 2 */
  98.   /* Infinite loop */
  99.   /* USER CODE BEGIN WHILE */
  100.   while (1)
  101.   {
  102.     /* USER CODE END WHILE */
  104.     /* USER CODE BEGIN 3 */
  105. 		//根据摇杆DMA判断舵机该如何运动
  106. 		cheack_A();
  107. 		cheack_B();
  108. 		cheack_C();
  109. 		cheack_D();
  110. 		//输出PWM波使舵机运动
  111. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  112. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  113. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  114. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  116. 		cnt++;//计数，每循环一次+1
  117. 		if(cnt>= 50)//循环50次，每次20ms，即一共1s。每一秒发送一次数据
  118. 		{
  119. 			printf('Angle = {%d, %d, %d, %d}rn',angle[0],angle[1],angle[2],angle[3]);
  120. 			cnt = 0;
  121. 		}
  122. 		HAL_Delay(20);//每20ms循环一次（改成15更流畅）
  124.   }
  125.   /* USER CODE END 3 */

这里要勾选才能使用printf串口打印信息 

2.蓝牙控制

这里提前写了一点示教器的业务代码，执行切换模式操作会切换获取摇杆模拟值还是电位器模拟值。

注意：我这里整活儿搞了个ADC通道切换，但实测还是存在一点问题，你们直接使用8通道一起就好。

接线：

先不使用示教器，但是可以先测试一下功能，切换模式和采集一下数据。

把四个旋钮电位器接好，四根线接到ADC 5 6 7 8

CubeMX配置

打开串口中断，中断接收数据。 

我这里是ADC再开四个，其它不配置。

你们开启共8个之后把下面个数也4改成8，新的组别5678也改成IN4 5 6 7 四个通道

代码：

都写在main.c里面会太冗长，我这里分文件编程了，不懂可以百度keil怎么添加.c .h文件，实在不行就都放在main.c里吧。。。

adc.c

纯粹整活儿，自定义了一个ADC初始化，把采集1234换成5678来采集电位器信号。直接用八个通道一起采集就行，然后把原来放采集数据的那个数组adc_dma长度也改成8。

  1. /* USER CODE BEGIN 1 */
  2. //写一个切换通道的函数
  3. /* ADC1_Mode2 init function */
  4. void MX_ADC1_Mode2_Init(void)
  5. {
  6.   ADC_ChannelConfTypeDef sConfig = {0};
  7.   /** Common config
  8.   */
  9.   hadc1.Instance = ADC1;
  10.   hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  11.   hadc1.Init.ContinuousConvMode = ENABLE;
  12.   hadc1.Init.DiscontinuousConvMode = DISABLE;
  13.   hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  14.   hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  15.   hadc1.Init.NbrOfConversion = 4;
  16.   if (HAL_ADC_Init(&hadc1) != HAL_OK)
  17.   {
  18.     Error_Handler();
  19.   }
  21.   /** Configure Regular Channel
  22.   */
  23.   sConfig.Channel = ADC_CHANNEL_4;
  24.   sConfig.Rank = ADC_REGULAR_RANK_1;
  25.   sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  26.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  27.   {
  28.     Error_Handler();
  29.   }
  31.   /** Configure Regular Channel
  32.   */
  33.   sConfig.Channel = ADC_CHANNEL_5;
  34.   sConfig.Rank = ADC_REGULAR_RANK_2;
  35.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  36.   {
  37.     Error_Handler();
  38.   }
  40.   /** Configure Regular Channel
  41.   */
  42.   sConfig.Channel = ADC_CHANNEL_6;
  43.   sConfig.Rank = ADC_REGULAR_RANK_3;
  44.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  45.   {
  46.     Error_Handler();
  47.   }
  49.   /** Configure Regular Channel
  50.   */
  51.   sConfig.Channel = ADC_CHANNEL_7;
  52.   sConfig.Rank = ADC_REGULAR_RANK_4;
  53.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  54.   {
  55.     Error_Handler();
  56.   }
  57. }
  58. /* USER CODE END 1 */

adc.h

  1. /* USER CODE BEGIN Prototypes */
  2. void MX_ADC1_Mode2_Init(void);
  3. /* USER CODE END Prototypes */

usart.c

注：STM32串口接收到的信息都在这里进行处理,千万别忘了最下面一行代码，开启中断。

  1. 	//=======中断信息处理=======
  3.         。。。。。。。。        
  5. 	//==========================
  1. /* USER CODE BEGIN 0 */
  2. #include 'stdio.h'
  3. #include 'string.h'
  4. #include 'PWM.h'
  6. #include 'adc.h'
  7. #include 'dma.h'
  9. /*机械臂控制模式，默认为1
  10. 1：摇杆控制	
  11. 2：示教器控制	*/
  12. uint8_t Mode = 1;
  14. /*蓝牙控制机械臂指令：
  15. s		停
  16. l/r 左右
  17. u/d 上下
  18. f/b 前后
  19. o/c 开合*/
  20. uint8_t cmd_BLE = 's';
  22. extern uint16_t adc_dma[4];//DMA搬运的ADC采集值
  24. //覆写printf
  25. int fputc(int ch, FILE *f)
  26. {      
  27.     unsigned char temp[1]={ch};
  28.     HAL_UART_Transmit(&huart1,temp,1,0xffff);  
  29.     return ch;
  30. }
  32. //=====串口（中断）=======
  33. //串口接收缓存（1字节）
  34. uint8_t buf=0;
  35. //定义最大接收字节数 200，可根据需求调整
  36. #define UART1_REC_LEN 200
  37. // 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
  38. uint8_t UART1_RX_Buffer[UART1_REC_LEN];
  39. //  接收状态
  40. //  bit15，      接收完成标志
  41. //  bit14，      接收到0x0d
  42. //  bit13~0，    接收到的有效字节数目
  43. uint16_t UART1_RX_STA=0;
  45. // 串口中断：接收完成回调函数，收到一个数据后，在这里处理
  46. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  47. {
  48. 	// 判断中断是由哪个串口触发的
  49. 	if(huart->Instance == USART1)
  50. 	{
  51. 		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
  52. 		if((UART1_RX_STA & 0x8000) == 0)
  53. 		{
  54. 			// 如果已经收到了 0x0d （回车），
  55. 			if(UART1_RX_STA & 0x4000)
  56. 			{
  57. 				// 则接着判断是否收到 0x0a （换行）
  58. 				if(buf == 0x0a)
  59. 				{
  60. 					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
  61. 					UART1_RX_STA |= 0x8000;
  63. 					//=======中断信息处理=======
  64. 					//模式切换
  65. 					if (!strcmp((const char *)UART1_RX_Buffer, 'M1')) 
  66. 					{
  67. 						Mode = 1;
  68. 						HAL_ADC_Stop_DMA(&hadc1);//停止ADC DMA
  69. 						MX_ADC1_Init();//初始化ADC1
  70. 						HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4); //开启ADC DMA
  71. 						printf('摇杆模式rn');
  72. 					}
  73. 					else if(!strcmp((const char *)UART1_RX_Buffer, 'M2')) 
  74. 					{
  75. 						Mode = 2;
  76. 						HAL_ADC_Stop_DMA(&hadc1);//停止ADC DMA
  77. 						MX_ADC1_Mode2_Init();//自定义初始化ADC1，把1234换成5678采集电位器
  78. 						HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4); //开启ADC DMA
  79. 						printf('示教器模式rn');
  80. 					}
  82. 					//获取蓝牙控制指令，A打头，后面一个字母就是指令内容
  83. 					else if(Mode == 1 && UART1_RX_Buffer[0] == 'A')
  84. 					{
  85. 						cmd_BLE = UART1_RX_Buffer[1];
  86. 					}
  88. 					else {
  89. 						if(UART1_RX_Buffer[0] != '')
  90. 							printf('指令发送错误：%srn', UART1_RX_Buffer);
  91. 					}
  93. 					//==========================
  94. 					memset(UART1_RX_Buffer, 0, strlen((const char *)UART1_RX_Buffer));
  96. 						// 重新开始下一次接收
  97. 					UART1_RX_STA = 0;
  98. 					//==========================
  99. 				}
  100. 				else
  101. 					// 否则认为接收错误，重新开始
  102. 					UART1_RX_STA = 0;
  103. 			}
  104. 			else	// 如果没有收到了 0x0d （回车）
  105. 			{
  106. 				//则先判断收到的这个字符是否是 0x0d （回车）
  107. 				if(buf == 0x0d)
  108. 				{
  109. 					// 是的话则将 bit14 位置为1
  110. 					UART1_RX_STA |= 0x4000;
  111. 				}
  112. 				else
  113. 				{
  114. 					// 否则将接收到的数据保存在缓存数组里
  115. 					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
  116. 					UART1_RX_STA++;
  118. 					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
  119. 					if(UART1_RX_STA > UART1_REC_LEN - 1)
  120. 						UART1_RX_STA = 0;
  121. 				}
  122. 			}
  123. 		}
  124. 		// 重新开启中断
  125. 		HAL_UART_Receive_IT(&huart1, &buf, 1);
  126. 	}
  127. }
  129. /* USER CODE END 0 */
  132.   /* USER CODE BEGIN USART1_Init 2 */
  133. 	// 开启接收中断
  134. 	HAL_UART_Receive_IT(&huart1, &buf, 1);
  135.   /* USER CODE END USART1_Init 2 */

我这里新建了两个PWM.c和.h文件。

把蓝牙指令控制和摇杆控制放在一起判断了。

  1. #include 'PWM.h'
  2. #include 'main.h'
  4. extern uint16_t adc_dma[4];//DMA搬运的ADC采集值
  5. extern uint8_t angle[4];//舵机角度
  6. extern uint8_t Mode;
  7. extern uint8_t cmd_BLE;
  9. //根据输入的角度获取对应pwm占空比参数
  10. uint8_t Angle(uint8_t pwm_pulse)
  11. {
  12. 	return pwm_pulse + 44;
  13. }
  15. //舵机A，夹爪	CH4_B11
  16. void check_A()
  17. {
  18. 	if(Mode == 1)
  19. 	{
  20. 		if((cmd_BLE == 'c' || adc_dma[3] > 4000) && angle[3] < 90)//合
  21. 		{
  22. 			angle[3]++;
  23. 		}
  24. 		else if((cmd_BLE == 'o' || adc_dma[3] <1000) && angle[3] > 0)//开
  25. 		{
  26. 			angle[3]--;
  27. 		}
  28. 	}
  30. }
  32. //舵机B，上下	CH3_B10
  33. void check_B()
  34. {
  35. 	if(Mode == 1)
  36. 	{
  37. 		if((cmd_BLE == 'u' || adc_dma[2] <1000) && angle[2] < 135)//上
  38. 		{
  39. 			angle[2]++;
  40. 		}
  41. 		else if((cmd_BLE == 'd' || adc_dma[2] > 4000) && angle[2] > 45)//下
  42. 		{
  43. 			angle[2]--;
  44. 		}
  45. 	}
  47. }
  49. //舵机C，前后	CH2_B3
  50. void check_C()
  51. {
  52. 	if(Mode == 1)
  53. 	{
  54. 		if((cmd_BLE == 'f' || adc_dma[1] <1000) && angle[1] < 135)//前
  55. 		{
  56. 			angle[1]++;
  57. 		}
  58. 		else if((cmd_BLE == 'b' || adc_dma[1] > 4000) && angle[1] > 45)//后
  59. 		{
  60. 			angle[1]--;
  61. 		}
  62. 	}
  64. }
  65. //舵机D，底座	CH1_A15
  66. void check_D()
  67. {
  68. 	if(Mode == 1)
  69. 	{
  70. 		if((cmd_BLE == 'l' || adc_dma[0] <1000) && angle[0] < 180)//左
  71. 		{
  72. 			angle[0]++;
  73. 		}
  74. 		else if((cmd_BLE == 'r' || adc_dma[0] > 4000) && angle[0] > 0)//右
  75. 		{
  76. 			angle[0]--;
  77. 		}
  78. 	}
  80. }
  1. #ifndef __PWM_H__
  2. #define __PWM_H__
  4. //根据输入的角度获取对应pwm占空比参数
  5. unsigned char Angle(unsigned char pwm_pulse);
  7. //舵机A，夹爪	CH4_B11
  8. void check_A(void);
  10. //舵机B，上下	CH3_B10
  11. void check_B(void);
  13. //舵机C，前后	CH2_B3
  14. void check_C(void);
  16. //舵机D，底座	CH1_A15
  17. void check_D(void);
  19. #endif

main.c 

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include 'stdio.h'
  4. #include 'PWM.h'
  5. /* USER CODE END Includes */
  7. /* Private variables ---------------------------------------------------------*/
  9. /* USER CODE BEGIN PV */
  10. uint16_t adc_dma[4];//DMA搬运的ADC采集值
  12. uint8_t angle[4] = {90,90,90,90};//舵机角度
  14. uint8_t cnt = 0;//计数用
  16. /* USER CODE END PV */
  18.   /* USER CODE BEGIN 2 */
  20. 	printf('Startrn');
  22. 	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4); 
  24. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  25. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  26. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  27. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  29. 	HAL_Delay(500);
  30.   /* USER CODE END 2 */
  32.   /* Infinite loop */
  33.   /* USER CODE BEGIN WHILE */
  34.   while (1)
  35.   {
  36.     /* USER CODE END WHILE */
  38.     /* USER CODE BEGIN 3 */
  39. 		//根据摇杆DMA判断舵机该如何运动
  40. 		check_A();
  41. 		check_B();
  42. 		check_C();
  43. 		check_D();
  44. 		//输出PWM波使舵机运动
  45. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  46. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  47. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  48. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  50. 		cnt++;
  51. 		if(cnt>= 50)
  52. 		{
  53. 			printf('Angle = {%d, %d, %d, %d}rn',angle[0],angle[1],angle[2],angle[3]);
  54. 			cnt = 0;
  55. 		}
  56. 		HAL_Delay(20);
  58.   }
  59.   /* USER CODE END 3 */

3.示教器控制

把示教器控制的业务代码也写出来，和蓝牙/摇杆控制封装在一个函数里，main里直接调用这个函数就行。

主要是PWM.c添加了一些代码,直接修改上面代码即可。

  1. extern uint16_t adc_dma[4];//DMA搬运的ADC采集值，直接用8通道就改长度8
  2. extern uint8_t angle[4];//舵机角度
  3. extern uint8_t Mode;
  4. extern uint8_t cmd_BLE;
  7. //根据输入的角度获取对应pwm占空比参数
  8. uint8_t Angle(uint8_t pwm_pulse)
  9. {
  10. 	return pwm_pulse + 44;
  11. }
  12. //舵机角度如何变化和模式判断的函数
  13. void sg()
  14. {
  15. 	if(Mode == 1)//蓝牙/摇杆模式
  16. 	{
  17. 		check_A();
  18. 		check_B();
  19. 		check_C();
  20. 		check_D();
  22. 	}
  23. 	else if(Mode == 2)//示教器模式
  24. 	{
  25. 		translate();
  26. 	}
  28. 		//输出PWM波使舵机运动
  29. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  30. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  31. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  32. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  33. 	HAL_Delay(20);
  34. }
  36. void translate()//把采集的模拟值转变为角度。即0~4095变为0~180，除以22.75即可。
  37. {
  38. 	angle[3] = (uint8_t)((double)adc_dma[0] / 22.75)/2;
  39. 	angle[2] = (uint8_t)((double)adc_dma[1] / 22.75);
  40. 	angle[1] = (uint8_t)((double)adc_dma[2] / 22.75) - 10;
  41. 	angle[0] = 180 - (uint8_t)((double)adc_dma[3] / 22.75);//电位器装反，改为 180 - 即可
  42. 	//直接用8通道就是adc_dma[4~7]
  43. }

PWM.h

  1. #ifndef __PWM_H__
  2. #define __PWM_H__
  4. //根据输入的角度获取对应pwm占空比参数
  5. unsigned char Angle(unsigned char pwm_pulse);
  7. //舵机A，夹爪	CH4_B11
  8. void check_A(void);
  10. //舵机B，上下	CH3_B10
  11. void check_B(void);
  13. //舵机C，前后	CH2_B3
  14. void check_C(void);
  16. //舵机D，底座	CH1_A15
  17. void check_D(void);
  19. void sg(void);
  21. void translate(void);
  23. #endif

 main.c

  1.   /* USER CODE BEGIN 2 */
  2. 	printf('Startrn');
  4. 	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4); 
  6. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  7. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  8. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  9. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  11. 	HAL_Delay(500);
  12.   /* USER CODE END 2 */
  14.   /* Infinite loop */
  15.   /* USER CODE BEGIN WHILE */
  16.   while (1)
  17.   {
  18.     /* USER CODE END WHILE */
  20.     /* USER CODE BEGIN 3 */
  22. 		sg();//判断舵机该如何运动
  24. 		cnt++;
  25. 		if(cnt>= 25)
  26. 		{
  27. 			 printf('Angle = {%d, %d, %d, %d}rn',angle[0],angle[1],angle[2],angle[3]);
  28. 			 //printf('adc_dma = {%d, %d, %d, %d}rn',adc_dma[0],adc_dma[1],adc_dma[2],adc_dma[3]);
  29. 			cnt = 0;
  30. 		}
  31.   }
  32.   /* USER CODE END 3 */

至此，基本的控制功能代码已经完成了。小白的话完成到这里已经很不错了。

4.记录动作信息

本质上就是保存当前的舵机的四个角度值。

这里暂时先用二维数组来做。

被添加的代码：

蓝牙指令A后的 m g D ，对应我们这里 记录当前角度、获取所有记录的角度、删除所有记录。

  1. #include 'stdio.h'
  2. #include 'string.h'
  4. uint8_t memory[10][4];//记录用的数组
  5. uint8_t i,j = 0;
  7. void sg()
  8. {
  9. 	if(Mode == 1)
  10. 	{
  11. 		check_A();
  12. 		check_B();
  13. 		check_C();
  14. 		check_D();
  16. 	}
  17. 	else if(Mode == 2)
  18. 	{
  19. 		translate();
  21. 		if(cmd_BLE == 'm' && i<9)
  22. 		{
  23. 			for(j=0;j<4;j++)
  24. 			{
  25. 				memory[i][j] = angle[j];
  26. 			}
  27. 			printf('储存动作rn');
  28. 			cmd_BLE = 's';
  29. 			i++;
  30. 		}
  31. 		else if(cmd_BLE == 'm' && i>=9)
  32. 			printf('动作已满rn');
  33. 			cmd_BLE = 's';
  34. 	}
  35. 	if(cmd_BLE == 'g')
  36. 	{
  37. 		for(i=0;i<10;i++)
  38. 		{
  39. 			for(j=0;j<4;j++)
  40. 			{
  41. 				printf('%d ',memory[i][j] + 0x30);
  42. 			}
  43. 			printf('rn');
  44. 			if(memory[i][j] == '')	break;
  45. 		}
  46. 		cmd_BLE = 's';
  47. 	}
  48. 	else if(cmd_BLE == 'D')
  49. 	{
  50. 		for(i=0;i<10;i++)
  51. 		{
  52. 			memset(memory[i],'',4);
  53. 		}
  54. 		i = 0;
  55. 		printf('已清除动作');
  56. 		cmd_BLE = 's';
  57. 	}
  58. 		//输出PWM波使舵机运动
  59. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  60. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  61. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  62. 	__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  65. 	HAL_Delay(20);
  66. }

5.执行记录的动作

这里开始已经转到FreeRTOS上了，没继续在裸机上做。所以没写对应源码，不过可以拿后面FreeRTOS上实现的代码放在这里。没区别一样可以用。需要你们自己来实现和调试。

PWM.c

主要就是下面这两个函数：

location_cnt是数组长度，宏定义出来就行，自己调整长度

  1. uint8_t memory[location_cnt][4];
  2. uint8_t i,j = 0;
  4. uint8_t angle_target[4] = {90,90,90,90};
  5. uint8_t angle_target_flag = 0;
  8. void get_target()//从数组获得位置信息并转换位角度目标值
  9. {
  10. 	angle_target_flag = 0;
  12. 	for(j=0;j<4;j++)
  13. 	{
  14. 		if(angle[j] == angle_target[j])	angle_target_flag++;
  15. 	}
  17. 	if(angle_target_flag == 4)	i++;
  20. 	for(j=0;j<4;j++)
  21. 	{
  22. 		if(memory[i][j] == '')
  23. 		{
  24. 			i = 0;
  25. 		}
  26. 		angle_target[j] = memory[i][j];
  27. 	}
  28. }
  30. void reach_target()//角度值像角度目标值靠近，用于简单防抖和执行记忆动作
  31. {
  32. 	for(j = 0;j <4;j++)
  33. 	{
  34. 		if(angle[j] > angle_target[j])
  35. 		{
  36. 			angle[j]--;
  37. 		}
  38. 		else if(angle[j] < angle_target[j])
  39. 		{
  40. 			angle[j]++;
  41. 		}
  42. 	}
  43. }
  45. void translate()//根据实际情况做了一点角度矫正和限位
  46. {
  47. 	angle_target[3] = (uint8_t)((double)adc_dma[4] / 22.75)/2;
  48. 	angle_target[2] = (uint8_t)((double)adc_dma[5] / 22.75);
  49. 	angle_target[1] = (uint8_t)((double)adc_dma[6] / 22.75) - 10;
  50. 	angle_target[0] = 180 - (uint8_t)((double)adc_dma[7] / 22.75);
  52. 	if(angle_target[1]<45)	angle_target[1]=45;
  53. 	else if(angle_target[1]>135)	angle_target[1]=135;
  55. 	if(angle_target[2]<45)	angle_target[1]=45;
  56. 	else if(angle_target[2]>135)	angle_target[1]=135;
  57. }
  59. //是否记录当前位置信息
  60. void if_BLE_cmd()
  61. {
  62. 	switch(cmd_BLE)
  63. 	{
  64. 		case 'm':
  66. 			if(i < location_cnt)
  67. 			{
  68. 				for(j=0;j<4;j++)
  69. 				{
  70. 					memory[i][j] = angle[j];
  71. 				}
  72. 				printf('储存动作rn');
  73. 				cmd_BLE = 's';
  74. 				i++;
  75. 			}
  76. 			else
  77. 			{
  78. 				printf('动作已满rn');
  79. 				cmd_BLE = 's';
  80. 			}
  81. 		break;
  83. 		case 'g':
  85. 			for(i=0;i < location_cnt;i++)
  86. 			{
  87. 				for(j=0;j<4;j++)
  88. 				{
  89. 					printf('%d ',memory[i][j]);
  90. 				}
  91. 				printf('rn');
  92. 				if(memory[i][j] == '')	break;
  93. 			}
  94. 			cmd_BLE = 's';
  95. 		break;
  97. 		case 'D':
  99. 			for(i=0; i < location_cnt ;i++)
  100. 			{
  101. 				memset(memory[i],'',4);
  102. 			}
  103. 			i = 0;
  104. 			printf('已清除动作');
  105. 			cmd_BLE = 's';
  106. 		break;
  107. 	}
  108. }
  110. void check_sg_cmd()//蓝牙和摇杆控制
  111. {
  112. 	check_A();
  113. 	check_B();
  114. 	check_C();
  115. 	check_D();
  116. }

usart.c

  1. /*机械臂控制模式，默认为1
  2. 1：摇杆控制	
  3. 2：示教器控制
  4. 3：执行记忆动作
  5. */
  6. uint8_t Mode = 1;
  12. 					//=======中断信息处理=======
  13. 					//模式切换
  14. 					if (!strcmp((const char *)UART1_RX_Buffer, 'M1')) 
  15. 					{			
  16. 						Mode = 1;
  18. 						printf('摇杆模式rn');
  20. 					}
  21. 					else if(!strcmp((const char *)UART1_RX_Buffer, 'M2')) 
  22. 					{			
  23. 						Mode = 2;
  25. 						printf('示教模式rn');
  27. 					}
  28. 					else if(!strcmp((const char *)UART1_RX_Buffer, 'M3')) 
  29. 					{			
  30. 						Mode = 3;
  32. 						printf('执行记忆动作rn');
  34. 					}

freertos.c内相关代码       

和main.c的while循环一样理解就行，一样用

  1.   /* Infinite loop */
  2.   for(;;)
  3.   {
  4. 		if(Mode == 1)//摇杆和蓝牙控制
  5. 		{
  6. 			check_sg_cmd();
  7. 		}
  8. 		else if(Mode == 2)//示教器控制
  9. 		{
  10. 			translate();
  11. 			reach_target();
  12. 		}
  13. 		else if(Mode == 3)//动作执行
  14. 		{
  15. 			get_target();
  16. 			reach_target();
  17. 		}
  19. 		if_BLE_cmd();//蓝牙指令处理
  21. 		//输出PWM波使舵机运动
  22. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  23. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  24. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  25. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  27.     osDelay(15);//通过调整此延时可以改变机械臂运行速度
  28.   }

注：

裸机开发到这里就结束了，大部分功能都简单实现出来了。

如果发现舵机运动每秒顿一次，请把每秒串口打印信息关掉就行，这是裸机的劣势之一所在。

三 FreeRTOS上完成项目

1.加入IIC的OLED屏显 和 动作执行（数组版） 

下面是移植到FreeRTOS操作系统上运行，没法介绍太详细，建议先系统学一下STM32 HAL开发以及FreeRTOS，再进行。

快速简述，就是把需求分给多个任务去执行，

一个任务负责角度信息处理，

一个任务负责串口发送数据

一个任务负责OLED屏显

且这里开始把adc改成直接测8组了

接线，把OLED的SDA和SCL对应板子接好 

CubeMX配置：

打开IIC

 设置4个外部中断，把原来的 ADC IN1~7 ==> IN2~9,因为我板载两个按钮位于A0和A1

然后B4 B5我自己外接了两个按钮。中断都是下降沿触发

FreeRTOS配置：使用了V1版本，创建三个任务，优先级都设为普通

 

打开定时器用于两个外部中断按钮B4 B5的定时器消抖，我这两个没有硬件防抖，如果你们的按钮有电容，就不用。

 

使用单次定时器 

 

 代码：

usart.c

  1. /* USER CODE BEGIN 0 */
  2. #include 'stdio.h'
  3. #include 'string.h'
  4. #include 'PWM.h'
  6. #include 'adc.h'
  7. #include 'dma.h'
  10. /*机械臂控制模式，默认为1
  11. 1：摇杆控制	
  12. 2：示教器控制
  13. 3：执行记忆动作
  14. */
  15. uint8_t Mode = 1;
  17. /*蓝牙控制机械臂指令：
  18. s/m	停/储存当前动作
  19. l/r 左右
  20. u/d 上下
  21. f/b 前后
  22. o/c 开合*/
  23. uint8_t cmd_BLE = 's';
  25. extern uint16_t adc_dma[8];//DMA搬运的ADC采集值
  26. extern uint8_t angle[4];
  28. uint8_t k;
  30. //覆写printf
  31. int fputc(int ch, FILE *f)
  32. {      
  33.     unsigned char temp[1]={ch};
  34.     HAL_UART_Transmit(&huart1,temp,1,0xffff);  
  35.     return ch;
  36. }
  38. //=====串口（中断）=======
  39. //串口接收缓存（1字节）
  40. uint8_t buf=0;
  41. //定义最大接收字节数 200，可根据需求调整
  42. #define UART1_REC_LEN 200
  43. // 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
  44. uint8_t UART1_RX_Buffer[UART1_REC_LEN];
  45. //  接收状态
  46. //  bit15，      接收完成标志
  47. //  bit14，      接收到0x0d
  48. //  bit13~0，    接收到的有效字节数目
  49. uint16_t UART1_RX_STA=0;
  51. // 串口中断：接收完成回调函数，收到一个数据后，在这里处理
  52. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  53. {
  54. 	// 判断中断是由哪个串口触发的
  55. 	if(huart->Instance == USART1)
  56. 	{
  57. 		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
  58. 		if((UART1_RX_STA & 0x8000) == 0)
  59. 		{
  60. 			// 如果已经收到了 0x0d （回车），
  61. 			if(UART1_RX_STA & 0x4000)
  62. 			{
  63. 				// 则接着判断是否收到 0x0a （换行）
  64. 				if(buf == 0x0a)
  65. 				{
  66. 					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
  67. 					UART1_RX_STA |= 0x8000;
  69. 					//=======中断信息处理=======
  70. 					//模式切换
  71. 					if (!strcmp((const char *)UART1_RX_Buffer, 'M1')) 
  72. 					{			
  73. 						Mode = 1;
  75. 						printf('摇杆模式rn');
  77. 					}
  78. 					else if(!strcmp((const char *)UART1_RX_Buffer, 'M2')) 
  79. 					{			
  80. 						Mode = 2;
  82. 						printf('示教模式rn');
  84. 					}
  85. 					else if(!strcmp((const char *)UART1_RX_Buffer, 'M3')) 
  86. 					{			
  87. 						Mode = 3;
  89. 						printf('执行记忆动作rn');
  91. 					}
  93. 					//获取蓝牙控制指令
  94. 					else if(UART1_RX_Buffer[0] == 'A')
  95. 					{
  96. 						cmd_BLE = UART1_RX_Buffer[1];
  97. 					}
  99. 					else {
  100. 						if(UART1_RX_Buffer[0] != '')
  101. 							printf('指令发送错误：%srn', UART1_RX_Buffer);
  102. 					}
  104. 					//==========================
  105. 					memset(UART1_RX_Buffer, 0, strlen((const char *)UART1_RX_Buffer));
  107. 						// 重新开始下一次接收
  108. 					UART1_RX_STA = 0;
  109. 					//==========================
  110. 				}
  111. 				else
  112. 					// 否则认为接收错误，重新开始
  113. 					UART1_RX_STA = 0;
  114. 			}
  115. 			else	// 如果没有收到了 0x0d （回车）
  116. 			{
  117. 				//则先判断收到的这个字符是否是 0x0d （回车）
  118. 				if(buf == 0x0d)
  119. 				{
  120. 					// 是的话则将 bit14 位置为1
  121. 					UART1_RX_STA |= 0x4000;
  122. 				}
  123. 				else
  124. 				{
  125. 					// 否则将接收到的数据保存在缓存数组里
  126. 					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
  127. 					UART1_RX_STA++;
  129. 					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
  130. 					if(UART1_RX_STA > UART1_REC_LEN - 1)
  131. 						UART1_RX_STA = 0;
  132. 				}
  133. 			}
  134. 		}
  135. 		// 重新开启中断
  136. 		HAL_UART_Receive_IT(&huart1, &buf, 1);
  137. 	}
  138. }
  140. /* USER CODE END 0 */
  145.   /* USER CODE BEGIN USART1_Init 2 */
  146. 	HAL_UART_Receive_IT(&huart1, &buf, 1);
  147.   /* USER CODE END USART1_Init 2 */

 PWM.c        解释注释在前面说过

  1. #include 'PWM.h'
  2. #include 'main.h'
  3. #include 'tim.h'
  4. #include 'stdio.h'
  5. #include 'string.h'
  9. extern uint16_t adc_dma[8];//DMA搬运的ADC采集值
  10. extern uint8_t angle[4];//舵机角度
  11. extern uint8_t Mode;
  12. extern uint8_t cmd_BLE;
  14. uint8_t memory[location_cnt][4];
  15. uint8_t i,j = 0;
  17. uint8_t angle_target[4] = {90,90,90,90};
  18. uint8_t angle_target_flag = 0;
  20. //根据输入的角度获取对应pwm占空比参数
  21. uint8_t Angle(uint8_t pwm_pulse)
  22. {
  23. 	return pwm_pulse + 44;
  24. }
  26. void get_target()
  27. {
  28. 	angle_target_flag = 0;
  30. 	for(j=0;j<4;j++)
  31. 	{
  32. 		if(angle[j] == angle_target[j])	angle_target_flag++;
  33. 	}
  35. 	if(angle_target_flag == 4)	i++;
  38. 	for(j=0;j<4;j++)
  39. 	{
  40. 		if(memory[i][j] == '')
  41. 		{
  42. 			i = 0;
  43. 		}
  44. 		angle_target[j] = memory[i][j];
  45. 	}
  46. }
  48. void reach_target()
  49. {
  50. 	for(j = 0;j <4;j++)
  51. 	{
  52. 		if(angle[j] > angle_target[j])
  53. 		{
  54. 			angle[j]--;
  55. 		}
  56. 		else if(angle[j] < angle_target[j])
  57. 		{
  58. 			angle[j]++;
  59. 		}
  60. 	}
  61. }
  63. void translate()//根据实际情况做了一点角度矫正和限位
  64. {
  65. 	angle_target[3] = (uint8_t)((double)adc_dma[4] / 22.75)/2;
  66. 	angle_target[2] = (uint8_t)((double)adc_dma[5] / 22.75);
  67. 	angle_target[1] = (uint8_t)((double)adc_dma[6] / 22.75) - 10;
  68. 	angle_target[0] = 180 - (uint8_t)((double)adc_dma[7] / 22.75);
  70. 	if(angle_target[1]<45)	angle_target[1]=45;
  71. 	else if(angle_target[1]>135)	angle_target[1]=135;
  73. 	if(angle_target[2]<45)	angle_target[1]=45;
  74. 	else if(angle_target[2]>135)	angle_target[1]=135;
  75. }
  77. //是否记录当前位置信息
  78. void if_BLE_cmd()
  79. {
  80. 	switch(cmd_BLE)
  81. 	{
  82. 		case 'm':
  84. 			if(i < location_cnt)
  85. 			{
  86. 				for(j=0;j<4;j++)
  87. 				{
  88. 					memory[i][j] = angle[j];
  89. 				}
  90. 				printf('储存动作rn');
  91. 				cmd_BLE = 's';
  92. 				i++;
  93. 			}
  94. 			else
  95. 			{
  96. 				printf('动作已满rn');
  97. 				cmd_BLE = 's';
  98. 			}
  99. 		break;
  101. 		case 'g':
  103. 			for(i=0;i < location_cnt;i++)
  104. 			{
  105. 				for(j=0;j<4;j++)
  106. 				{
  107. 					printf('%d ',memory[i][j]);
  108. 				}
  109. 				printf('rn');
  110. 				if(memory[i][j] == '')	break;
  111. 			}
  112. 			cmd_BLE = 's';
  113. 		break;
  115. 		case 'D':
  117. 			for(i=0; i < location_cnt ;i++)
  118. 			{
  119. 				memset(memory[i],'',4);
  120. 			}
  121. 			i = 0;
  122. 			printf('已清除动作');
  123. 			cmd_BLE = 's';
  124. 		break;
  125. 	}
  126. }
  128. void check_sg_cmd()
  129. {
  130. 	check_A();
  131. 	check_B();
  132. 	check_C();
  133. 	check_D();
  134. }
  136. //舵机A，夹爪	CH4_B11-D1;adc4_A3
  137. void check_A()
  138. {
  139. 	if(Mode == 1)
  140. 	{
  141. 		if((cmd_BLE == 'c' || adc_dma[3] > 4000) && angle[3] < 90)//合
  142. 		{
  143. 			angle[3]++;
  144. 		}
  145. 		else if((cmd_BLE == 'o' || adc_dma[3] <1000) && angle[3] > 0)//开
  146. 		{
  147. 			angle[3]--;
  148. 		}
  149. 	}
  151. }
  153. //舵机B，上下	CH3_B10-D2;adc3_A2
  154. void check_B()
  155. {
  156. 	if(Mode == 1)
  157. 	{
  158. 		if((cmd_BLE == 'u' || adc_dma[2] <1000) && angle[2] < 135)//上
  159. 		{
  160. 			angle[2]++;
  161. 		}
  162. 		else if((cmd_BLE == 'd' || adc_dma[2] > 4000) && angle[2] > 45)//下
  163. 		{
  164. 			angle[2]--;
  165. 		}
  166. 	}
  168. }
  169. 基于STM32 FreeRTOS的四轴机械臂
  170. //舵机C，前后	CH2_B3-D3;adc2_A1
  171. void check_C()
  172. {
  173. 	if(Mode == 1)
  174. 	{
  175. 		if((cmd_BLE == 'f' || adc_dma[1] <1000) && angle[1] < 135)//前
  176. 		{
  177. 			angle[1]++;
  178. 		}
  179. 		else if((cmd_BLE == 'b' || adc_dma[1] > 4000) && angle[1] > 45)//后
  180. 		{
  181. 			angle[1]--;
  182. 		}
  183. 	}
  185. }
  186. //舵机D，底座	CH1_A15-D0;adc1_A0
  187. void check_D()
  188. {
  189. 	if(Mode == 1)
  190. 	{
  191. 		if((cmd_BLE == 'l' || adc_dma[0] <1000) && angle[0] < 180)//左
  192. 		{
  193. 			angle[0]++;
  194. 		}
  195. 		else if((cmd_BLE == 'r' || adc_dma[0] > 4000) && angle[0] > 0)//右
  196. 		{
  197. 			angle[0]--;
  198. 		}
  199. 	}
  201. }

PWM.h

  1. #ifndef __PWM_H__
  2. #define __PWM_H__
  4. #define location_cnt 20
  6. //根据输入的角度获取对应pwm占空比参数
  7. unsigned char Angle(unsigned char pwm_pulse);
  9. //舵机A，夹爪	CH4_B11
  10. void check_A(void);
  12. //舵机B，上下	CH3_B10
  13. void check_B(void);
  15. //舵机C，前后	CH2_B3
  16. void check_C(void);
  18. //舵机D，底座	CH1_A15
  19. void check_D(void);
  21. void check_sg_cmd(void);
  23. void if_BLE_cmd(void);
  25. void translate(void);
  27. void get_target(void);
  29. void reach_target(void);
  31. #endif

OLED.c

  1. #include 'OLED.h'
  2. #include 'i2c.h'
  3. #include 'oledfont.h'
  6. void Oled_Write_Cmd(uint8_t OLED_cmd)
  7. {
  8. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x00, I2C_MEMADD_SIZE_8BIT, &OLED_cmd, 1, 0xff);
  9. }
  12. void Oled_Write_Data(uint8_t OLED_data)
  13. {
  14. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x40, I2C_MEMADD_SIZE_8BIT, &OLED_data, 1, 0xff);
  15. }
  17. //OLED初始化代码，直接复制粘贴
  18. void Oled_Init(void){
  19. 	Oled_Write_Cmd(0xAE);//--display off
  20. 	Oled_Write_Cmd(0x00);//---set low column address
  21. 	Oled_Write_Cmd(0x10);//---set high column address
  22. 	Oled_Write_Cmd(0x40);//--set start line address
  23. 	Oled_Write_Cmd(0xB0);//--set page address
  24. 	Oled_Write_Cmd(0x81); // contract control
  25. 	Oled_Write_Cmd(0xFF);//--128
  26. 	Oled_Write_Cmd(0xA1);//set segment remap
  27. 	Oled_Write_Cmd(0xA6);//--normal / reverse
  28. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
  29. 	Oled_Write_Cmd(0x3F);//--1/32 duty
  30. 	Oled_Write_Cmd(0xC8);//Com scan direction
  31. 	Oled_Write_Cmd(0xD3);//-set display offset
  32. 	Oled_Write_Cmd(0x00);//
  33. 	Oled_Write_Cmd(0xD5);//set osc division
  34. 	Oled_Write_Cmd(0x80);//
  35. 	Oled_Write_Cmd(0xD8);//set area color mode off
  36. 	Oled_Write_Cmd(0x05);//
  37. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
  38. 	Oled_Write_Cmd(0xF1);//
  39. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
  40. 	Oled_Write_Cmd(0x12);//
  41. 	Oled_Write_Cmd(0xDB);//set Vcomh
  42. 	Oled_Write_Cmd(0x30);//
  43. 	Oled_Write_Cmd(0x8D);//set charge pump enable
  44. 	Oled_Write_Cmd(0x14);//
  45. 	Oled_Write_Cmd(0xAF);//--turn on oled panel
  46. }
  48. void Oled_Clear()
  49. {
  50. 	unsigned char i,j; //-128 --- 127
  51. 	for(i=0;i<8;i++){
  52. 		Oled_Write_Cmd(0xB0 + i);//page0--page7
  53. 		//每个page从0列
  54. 		Oled_Write_Cmd(0x00);
  55. 		Oled_Write_Cmd(0x10);
  56. 		//0到127列，依次写入0，每写入数据，列地址自动偏移
  57. 		for(j = 0;j<128;j++){
  58. 			Oled_Write_Data(0);
  59. 		}
  60. 	}
  61. }
  63. //在屏幕上显示
  64. //===============================官方提供的代码============================================
  65. void Oled_Show_Char(char row,char col,uint8_t oledChar){ //row*2-2
  66. 	unsigned int  i;
  67. 	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
  68. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
  69. 	Oled_Write_Cmd(0x10+(col>>4));                            //high	
  70. 	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
  71. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
  72. 	}
  74. 	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
  75. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
  76. 	Oled_Write_Cmd(0x10+(col>>4));                            //high
  77. 	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
  78. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
  79. 	}		
  80. }
  83. /******************************************************************************/
  84. // 函数名称：Oled_Show_Char 
  85. // 输入参数：oledChar 
  86. // 输出参数：无 
  87. // 函数功能：OLED显示单个字符
  88. /******************************************************************************/
  89. void Oled_Show_Str(char row,char col,char *str){
  90. 	while(*str!=0){
  91. 		Oled_Show_Char(row,col,*str);
  92. 		str++;
  93. 		col += 8;	
  94. 	}		
  95. }

OLED.h

  1. #ifndef __OLED_H__
  2. #define __OLED_H__
  4. void Oled_Init(void);
  5. void Oled_Clear(void);
  7. void Oled_Show_Str(char row,char col,char *str);
  9. #endif

main.c        放了一点初始化配置

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include 'stdio.h'
  4. /* USER CODE END Includes */
  6. /* Private variables ---------------------------------------------------------*/
  8. /* USER CODE BEGIN PV */
  10. uint16_t adc_dma[8];//DMA搬运的ADC采集值
  12. uint8_t angle[4] = {90,90,90,90};//舵机角度
  14. /* USER CODE END PV */
  16.   /* USER CODE BEGIN 2 */
  17. 	// 开启接收中断
  18. 	printf('Startrn');//程序开始运行
  19. 	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,8); //开启ADC和DMA
  20. 	//系统稳定半秒
  21. 	HAL_Delay(500);
  23.   /* USER CODE END 2 */

freeRTOS.c

uint8_t anti_shake = 0;//定时器按钮消抖标志位

最下面的函数就是外部中断回调函数，anti_shake为0才能通过判断，一旦进入就将anti_shake置为1，避免因为按下的抖动导致按一次触发好几次中断。通过判断之后，启动单次定时器800ms，定时器到时间后触发定时器中断回调函数，在这里再把anti_shake重新置为0。

其中由于我的板载按键0和1本身有硬件消抖，所以不用软件定时器消抖。

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include 'stdio.h'
  4. #include 'PWM.h'
  5. #include 'tim.h'
  6. #include 'adc.h'
  7. #include 'OLED.h'
  8. /* USER CODE END Includes */
  10. /* Private variables ---------------------------------------------------------*/
  11. /* USER CODE BEGIN Variables */
  12. uint8_t anti_shake = 0;//定时器按钮消抖标志位
  14. extern uint16_t adc_dma[8];//DMA搬运的ADC采集值
  16. extern uint8_t angle[4];//舵机角度
  18. extern uint8_t Mode;
  20. extern uint8_t memory[location_cnt][4];
  21. extern uint8_t i,j;
  24. //角度信息字符串
  25. char speedMes[8];  //IIC发送角度数据的字符串缓冲区
  26. char speedMes1[8];
  27. char speedMes2[8];
  28. char speedMes3[8];
  29. char speedMes4[8];
  30. char speedMes5[8];
  32. /* USER CODE END Variables */
  35. /* USER CODE BEGIN Header_Start_check_angle */
  36. /**
  37.   * @brief  Function implementing the check_angle thread.
  38.   * @param  argument: Not used
  39.   * @retval None
  40.   */
  41. /* USER CODE END Header_Start_check_angle */
  42. void Start_check_angle(void const * argument)
  43. {
  44.   /* USER CODE BEGIN Start_check_angle */
  45. 	//开启4路PWM
  46. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  47. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  48. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  49. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  50.   /* Infinite loop */
  51.   for(;;)
  52.   {
  53. 		if(Mode == 1)
  54. 		{
  55. 			check_sg_cmd();
  56. 		}
  57. 		else if(Mode == 2)
  58. 		{
  59. 			translate();
  60. 			reach_target();
  61. 		}
  62. 		else if(Mode == 3)
  63. 		{
  64. 			get_target();
  65. 			reach_target();
  66. 		}
  68. 		if_BLE_cmd();
  70. 		//输出PWM波使舵机运动
  71. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  72. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  73. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  74. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  76.     osDelay(15);//通过调整此延时可以改变机械臂运行速度
  77.   }
  78.   /* USER CODE END Start_check_angle */
  79. }
  81. /* USER CODE BEGIN Header_Start_usart_show */
  82. /**
  83. * @brief Function implementing the usart_show thread.
  84. * @param argument: Not used
  85. * @retval None
  86. */
  87. /* USER CODE END Header_Start_usart_show */
  88. void Start_usart_show(void const * argument)
  89. {
  90.   /* USER CODE BEGIN Start_usart_show */
  92.   /* Infinite loop */
  93.   for(;;)
  94.   {
  95. 		printf('Angle = {%d, %d, %d, %d}rn',angle[0],angle[1],angle[2],angle[3]);
  96. 		printf('adc_dma1 = {%d, %d, %d, %d}rn',adc_dma[0],adc_dma[1],adc_dma[2],adc_dma[3]);
  97. 		printf('adc_dma2 = {%d, %d, %d, %d}rn',adc_dma[4],adc_dma[5],adc_dma[6],adc_dma[7]);
  98. 		printf('rn');
  99.     osDelay(1000);
  100.   }
  101.   /* USER CODE END Start_usart_show */
  102. }
  104. /* USER CODE BEGIN Header_Start_OLED_Task */
  105. /**
  106. * @brief Function implementing the OLED_Task thread.
  107. * @param argument: Not used
  108. * @retval None
  109. */
  110. /* USER CODE END Header_Start_OLED_Task */
  111. void Start_OLED_Task(void const * argument)
  112. {
  113.   /* USER CODE BEGIN Start_OLED_Task */
  114. 	Oled_Init();
  115. 	Oled_Clear();
  116.   /* Infinite loop */
  117.   for(;;)
  118.   {
  119. 		//串口数据的字符串拼装，speed是格子，每个格子1cm
  120. 		sprintf(speedMes,'A: %d ',angle[0]);
  121. 		sprintf(speedMes1,'B: %d ',angle[1]);
  122. 		sprintf(speedMes2,'C: %d ',angle[2]);
  123. 		sprintf(speedMes3,'D: %d ',angle[3]);
  124. 		sprintf(speedMes4,'Mode %d ',Mode);
  125. 		sprintf(speedMes5,'S %d ',i);
  127. 		Oled_Show_Str(1,5,speedMes);
  128. 		Oled_Show_Str(1,69,speedMes1);
  129. 		Oled_Show_Str(2,5,speedMes2);
  130. 		Oled_Show_Str(2,69,speedMes3);
  132. 		Oled_Show_Str(4,0,speedMes4);
  133. 		Oled_Show_Str(4,64,speedMes5);
  136.     osDelay(500);
  137.   }
  138.   /* USER CODE END Start_OLED_Task */
  139. }
  142. /* Callback01 function */
  143. void Callback01(void const * argument)
  144. {
  145.   /* USER CODE BEGIN Callback01 */
  146. 	anti_shake = 0;
  147.   /* USER CODE END Callback01 */
  148. }
  151. /* Private application code --------------------------------------------------*/
  152. /* USER CODE BEGIN Application */
  153. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  154. {
  155. 	switch(GPIO_Pin)
  156. 	{
  157. 		case GPIO_PIN_0:
  158. 			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
  159. 			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_SET);
  160. 			Mode = 1;
  161. 			printf('摇杆模式rn');
  163. 		break;
  164. 		case GPIO_PIN_1:
  165. 			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
  166. 			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
  167. 			Mode = 2;
  168. 			printf('示教模式rn');
  170. 		break;
  172. 		case GPIO_PIN_4:
  173. 			if(anti_shake == 0)
  174. 			{
  175. 				anti_shake = 1;
  177. 				osTimerStart(myTimer01Handle,800);
  179. 				if(i<location_cnt)
  180. 				{
  181. 					for(j=0;j<4;j++)
  182. 					{
  183. 						memory[i][j] = angle[j];
  184. 					}
  185. 					printf('储存动作rn');
  186. 					i++;
  187. 				}
  188. 				else if(i>=9)
  189. 				{
  190. 					printf('动作已满rn');
  191. 				}
  192. 			}
  194. 		case GPIO_PIN_5:
  195. 			if(anti_shake == 0)
  196. 			{
  197. 				anti_shake = 1;
  199. 				Mode = 3;
  201. 				HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
  202. 				HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET);
  204. 				printf('执行记忆动作rn');
  206. 				osTimerStart(myTimer01Handle,800);
  207. 			}
  208. 	}
  209. }
  210. /* USER CODE END Application */

2.链表的增删遍历实现动作记忆和执行

创建 Memary_LinkList.c和.h文件，放链表相关代码

  1. #include 'Memary_LinkList.h'
  2. #include 'main.h'
  3. #include 'stdio.h'
  4. #include <stdlib.h>
  6. struct Memary//每个链表节点的结构组成
  7. {
  8. 	uint8_t A,B,C,D,cnt;//四个角度和节点的对应编号
  10. 	struct Memary *next;//下一个链表节点的地址
  11. }*head,*tail,*temp;//声明三个指针，分别指向链表头尾，和一个临时指针
  13. void Memary_Init()//初始化链表
  14. {
  15. 	head = (struct Memary *)malloc(sizeof(struct Memary));
  17. 	head -> cnt = 0;//链表里没记忆信息时编号只有0
  18. 	head -> next = NULL;
  19. 	tail = head;
  20. 	temp = head;
  21. }
  24. void prinrt_List()//打印整个链表的内容
  25. {
  26. 	temp = head;
  27. 	while(1)
  28. 	{
  29. 		printf('%d:{%d,%d,%d,%d}rn',temp->cnt,temp->A,temp->B,temp->C,temp->D);
  30. 		if(temp->next != NULL)	temp = temp->next;
  31. 		else	break;
  32. 	}
  33. }
  35. void delete_List()//清空整个链表
  36. {
  37. 	while(head->next != NULL)
  38. 	{
  39. 		temp = head;
  40. 		head = head->next;
  41. 		free(temp);
  42. 	}
  43. 	temp = head;
  44. 	head->cnt = 0;
  45. }
  47. void addNode(uint8_t angle[4])//记忆动作，即新增一个节点
  48. {
  49. 	if(head->cnt != 0)//编号cnt从1开始，从头节点开始存数据
  50. 	{
  51. 		struct Memary *p = (struct Memary *)malloc(sizeof(struct Memary));
  53. 		tail->next = p;
  54. 		p->cnt = tail->cnt;
  55. 		tail = p;
  56. 	}
  57. 	tail->A = angle[0];
  58. 	tail->B = angle[1];
  59. 	tail->C = angle[2];
  60. 	tail->D = angle[3];
  61. 	tail->cnt++;
  63. 	temp = tail;
  64. }
  66. uint8_t angle_temp[4];//用于提取记忆的角度
  67. uint8_t *p = angle_temp;//用指针传递
  69. uint8_t *getNode()//把记忆信息传出去，自动循环传整个链表
  70. {
  71. 	angle_temp[0] = temp->A;
  72. 	angle_temp[1] = temp->B;
  73. 	angle_temp[2] = temp->C;
  74. 	angle_temp[3] = temp->D;
  76. 	if(temp->next == NULL)
  77. 		temp = head;
  78. 	else
  79. 		temp = temp->next;
  81. 	return p;
  82. }
  84. uint8_t sizeof_List()//别管名字，看temp在哪用的，
  85. {
  86. 	//反应在OLED上就是可以看见当前存储到第几个动作了或者正在执行第一个动作
  87. 	return temp->cnt;
  88. }
  1. #ifndef __MEMARY_LINKLIST__
  2. #define __MEMARY_LINKLIST__
  4. #include 'main.h'
  6. void Memary_Init(void);
  8. void addNode(uint8_t angle[4]);
  10. void prinrt_List(void);
  12. void delete_List(void);
  14. uint8_t *getNode(void);
  16. uint8_t sizeof_List(void);
  18. #endif

原PWM.c改成了MG90s.c

  1. #include 'MG90s.h'
  2. #include 'main.h'
  3. #include 'tim.h'
  4. #include 'stdio.h'
  5. #include 'string.h'
  6. #include 'Memary_LinkList.h'
  8. extern uint16_t adc_dma[8];//DMA搬运的ADC采集值
  9. extern uint8_t angle[4];//舵机角度
  10. extern uint8_t Mode;
  11. extern uint8_t cmd_BLE;
  13. uint8_t i;
  15. uint8_t angle_target[4] = {90,90,90,90};
  16. uint8_t *p_angle_target;
  18. uint8_t angle_target_flag = 4;//默认第一次为4
  22. //根据输入的角度获取对应pwm占空比参数
  23. uint8_t Angle(uint8_t pwm_pulse)
  24. {
  25. 	return pwm_pulse + 44;
  26. }
  28. void getAngleFromMemary()
  29. {	
  30. 	if(angle_target_flag == 4)
  31. 	{
  32. 		p_angle_target = getNode();
  33. 		for(i = 0;i <4;i++)
  34. 		{
  35. 			angle_target[i] = *(p_angle_target + i);
  36. 		}
  37. 	}
  39. 	angle_target_flag = 0;
  41. 	for(i=0;i<4;i++)
  42. 	{
  43. 		if(angle[i] == angle_target[i])	angle_target_flag++;
  44. 	}
  45. }
  47. void reach_target()
  48. {
  49. 	for(i = 0;i <4;i++)
  50. 	{
  51. 		if(angle[i] > angle_target[i])
  52. 		{
  53. 			angle[i]--;
  54. 		}
  55. 		else if(angle[i] < angle_target[i])
  56. 		{
  57. 			angle[i]++;
  58. 		}
  59. 	}
  60. }
  62. void translate()
  63. {
  64. 	angle_target[3] = (uint8_t)((double)adc_dma[4] / 22.75)/2;
  65. 	angle_target[2] = (uint8_t)((double)adc_dma[5] / 22.75);
  66. 	angle_target[1] = (uint8_t)((double)adc_dma[6] / 22.75) - 10;
  67. 	angle_target[0] = 180 - (uint8_t)((double)adc_dma[7] / 22.75);
  69. 	if(angle_target[1]<45)	angle_target[1]=45;
  70. 	else if(angle_target[1]>135)	angle_target[1]=135;
  72. 	if(angle_target[2]<45)	angle_target[1]=45;
  73. 	else if(angle_target[2]>135)	angle_target[1]=135;
  74. }
  76. //是否记录当前位置信息
  77. void if_BLE_cmd()
  78. {
  79. 	switch(cmd_BLE)
  80. 	{
  81. 		case 'm':
  83. 			addNode(angle);
  84. 			printf('储存动作rn');
  85. 			cmd_BLE = 's';
  87. 		break;
  89. 		case 'g':
  91. 			prinrt_List();
  92. 			cmd_BLE = 's';
  93. 		break;
  95. 		case 'D':
  97. 			delete_List();
  98. 			printf('已清除动作rn');
  99. 			cmd_BLE = 's';
  100. 		break;
  101. 	}
  102. }
  104. void check_sg_cmd()
  105. {
  106. 	check_A();
  107. 	check_B();
  108. 	check_C();
  109. 	check_D();
  110. }
  112. //舵机A，夹爪	CH4_B11-D1;adc4_A3
  113. void check_A()
  114. {
  115. 	if(Mode == 1)
  116. 	{
  117. 		if((cmd_BLE == 'c' || adc_dma[3] > 4000) && angle[3] < 90)//合
  118. 		{
  119. 			angle[3]++;
  120. 		}
  121. 		else if((cmd_BLE == 'o' || adc_dma[3] <1000) && angle[3] > 0)//开
  122. 		{
  123. 			angle[3]--;
  124. 		}
  125. 	}
  127. }
  129. //舵机B，上下	CH3_B10-D2;adc3_A2
  130. void check_B()
  131. {
  132. 	if(Mode == 1)
  133. 	{
  134. 		if((cmd_BLE == 'u' || adc_dma[2] <1000) && angle[2] < 135)//上
  135. 		{
  136. 			angle[2]++;
  137. 		}
  138. 		else if((cmd_BLE == 'd' || adc_dma[2] > 4000) && angle[2] > 45)//下
  139. 		{
  140. 			angle[2]--;
  141. 		}
  142. 	}
  144. }
  146. //舵机C，前后	CH2_B3-D3;adc2_A1
  147. void check_C()
  148. {
  149. 	if(Mode == 1)
  150. 	{
  151. 		if((cmd_BLE == 'f' || adc_dma[1] <1000) && angle[1] < 135)//前
  152. 		{
  153. 			angle[1]++;
  154. 		}
  155. 		else if((cmd_BLE == 'b' || adc_dma[1] > 4000) && angle[1] > 45)//后
  156. 		{
  157. 			angle[1]--;
  158. 		}
  159. 	}
  161. }
  162. //舵机D，底座	CH1_A15-D0;adc1_A0
  163. void check_D()
  164. {
  165. 	if(Mode == 1)
  166. 	{
  167. 		if((cmd_BLE == 'l' || adc_dma[0] <1000) && angle[0] < 180)//左
  168. 		{
  169. 			angle[0]++;
  170. 		}
  171. 		else if((cmd_BLE == 'r' || adc_dma[0] > 4000) && angle[0] > 0)//右
  172. 		{
  173. 			angle[0]--;
  174. 		}
  175. 	}
  177. }

FreeRTOS.c要修改的部分

  1. //                任务1
  3. /* USER CODE END Header_Start_check_angle */
  4. void Start_check_angle(void const * argument)
  5. {
  6.   /* USER CODE BEGIN Start_check_angle */
  7. 	Memary_Init();
  8. 	//开启4路PWM
  9. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  10. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  11. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  12. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  13.   /* Infinite loop */
  14.   for(;;)
  15.   {
  16. 		if(Mode == 1)
  17. 		{
  18. 			check_sg_cmd();
  19. 		}
  20. 		else if(Mode == 2)
  21. 		{
  22. 			translate();
  23. 			reach_target();
  24. 		}
  25. 		else if(Mode == 3)
  26. 		{
  27. 			getAngleFromMemary();
  28. 			reach_target();
  29. 		}
  31. 		if_BLE_cmd();
  33. 		//输出PWM波使舵机运动
  34. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  35. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  36. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  37. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  39.     osDelay(18);//通过调整此延时可以改变机械臂运行速度
  40.   }
  41.   /* USER CODE END Start_check_angle */
  42. }
  45. //         任务3
  47. /* USER CODE END Header_Start_OLED_Task */
  48. void Start_OLED_Task(void const * argument)
  49. {
  50.   /* USER CODE BEGIN Start_OLED_Task */
  51. 	Oled_Init();
  52. 	Oled_Clear();
  53.   /* Infinite loop */
  54.   for(;;)
  55.   {
  56. 		//串口数据的字符串拼装，speed是格子，每个格子1cm
  57. 		sprintf(speedMes,'A: %d ',angle[0]);
  58. 		sprintf(speedMes1,'B: %d ',angle[1]);
  59. 		sprintf(speedMes2,'C: %d ',angle[2]);
  60. 		sprintf(speedMes3,'D: %d ',angle[3]);
  61. 		sprintf(speedMes4,'Mode %d ',Mode);
  62. 		sprintf(speedMes5,'S %d ',sizeof_List());
  64. 		Oled_Show_Str(1,5,speedMes);
  65. 		Oled_Show_Str(1,69,speedMes1);
  66. 		Oled_Show_Str(2,5,speedMes2);
  67. 		Oled_Show_Str(2,69,speedMes3);
  69. 		Oled_Show_Str(4,0,speedMes4);
  70. 		Oled_Show_Str(4,54,speedMes5);
  73.     osDelay(500);
  74.   }
  75.   /* USER CODE END Start_OLED_Task */
  76. }
  81. //         外部中断
  83. 		case GPIO_PIN_4:
  84. 			if(anti_shake == 0)
  85. 			{
  86. 				anti_shake = 1;
  87. 				osTimerStart(myTimer01Handle,800);
  89. 				addNode(angle);
  91. 				printf('储存动作rn');
  92. 			}

到这里位置，视频里我实现的内容都可以完成了。

至于这个链表最大能存多长的动作我是没去实测，反正我们玩绝对是够用了。

3.SPI扩容

 不幸的是我板子的SPI2坏了，只有SPI1正常，所以我没真正去完成这个功能。

但是这里我提供了完整的存储思路。大家可自己来实现

功能测试

 PB12设为GPIO输出引脚默认设为高电平，充当CS口，接线就是CS对CS，SCK对CLK，MOSI对DI，MISO对DO

VCC用3.3，5v没试过。

 在spi.c中添加        比如如果SPI1就是hspi1，SPI2就是hspi2，别的都不用动

  1. /* USER CODE BEGIN 1 */
  2. uint8_t spi2_read_write_byte(uint8_t data)
  3. {
  4.     uint8_t rec_data = 0;
  6.     HAL_SPI_TransmitReceive(&hspi2, &data, &rec_data, 1, 1000);
  8.     return rec_data;
  9. }
  10. /* USER CODE END 1 */

spi.h

  1. /* USER CODE BEGIN Prototypes */
  2. uint8_t spi2_read_write_byte(uint8_t data);
  3. /* USER CODE END Prototypes */

w25q128.h        这里你CS用的哪个GPIO_OUT，W25Q128_CS_GPIO就改成对应的。

  1. #ifndef __W25Q128_H__
  2. #define __W25Q128_H__
  4. #include 'stdint.h'
  6. /* W25Q128片选引脚定义 */
  7. #define W25Q128_CS_GPIO_PORT           GPIOB
  8. #define W25Q128_CS_GPIO_PIN            GPIO_PIN_12
  10. /* W25Q128片选信号 */
  11. #define W25Q128_CS(x)      do{ x ? 
  12.                                   HAL_GPIO_WritePin(W25Q128_CS_GPIO_PORT, W25Q128_CS_GPIO_PIN, GPIO_PIN_SET) : 
  13.                                   HAL_GPIO_WritePin(W25Q128_CS_GPIO_PORT, W25Q128_CS_GPIO_PIN, GPIO_PIN_RESET); 
  14.                             }while(0)
  16. /* FLASH芯片列表 */
  17. #define W25Q128     0XEF17          /* W25Q128  芯片ID */
  19. /* 指令表 */
  20. #define FLASH_WriteEnable						0x06 
  21. #define FLASH_ReadStatusReg1				0x05 
  22. #define FLASH_ReadData							0x03 
  23. #define FLASH_PageProgram						0x02 
  24. #define FLASH_SectorErase						0x20 
  25. #define FLASH_ChipErase							0xC7 
  26. #define FLASH_ManufactDeviceID			0x90 
  28. /* 静态函数 */
  29. static void w25q128_wait_busy(void);               /* 等待空闲 */
  30. static void w25q128_send_address(uint32_t address);/* 发送地址 */
  31. static void w25q128_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入page */
  32. static void w25q128_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen); /* 写flash,不带擦除 */
  34. /* 普通函数 */
  35. void w25q128_init(void);                   /* 初始化25QXX */
  36. uint16_t w25q128_read_id(void);            /* 读取FLASH ID */
  37. void w25q128_write_enable(void);           /* 写使能 */
  38. uint8_t w25q128_rd_sr1(void);							/* 读取寄存器1的值 */
  40. void w25q128_erase_chip(void);             /* 整片擦除 */
  41. void w25q128_erase_sector(uint32_t saddr); /* 扇区擦除 */
  42. void w25q128_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen);     /* 读取flash */
  43. void w25q128_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入flash */
  45. #endif

w25q128.c

  1. #include 'w25q128.h'
  2. #include 'spi.h'
  3. #include 'stdio.h'
  5. /**
  6.  * @brief       初始化W25Q128
  7.  * @param       无
  8.  * @retval      无
  9.  */
  10. void w25q128_init(void)
  11. {
  12. 		uint16_t flash_type;
  13.     spi2_read_write_byte(0xFF); /* 清除DR的作用 */
  14.     W25Q128_CS(1);
  15. 		flash_type = w25q128_read_id();   /* 读取FLASH ID. */
  16. 		if (flash_type == W25Q128)
  17. 			printf('检测到W25Q128芯片rn');
  18. 		else
  19. 			printf('读取到的芯片ID为：%xrn',flash_type);
  20. 			printf('未检测到W25Q128芯片rn');
  21. }
  23. /**
  24.  * @brief       等待空闲
  25.  * @param       无
  26.  * @retval      无
  27.  */
  28. static void w25q128_wait_busy(void)
  29. {
  30.     while ((w25q128_rd_sr1() & 0x01) == 0x01);   /* 等待BUSY位清空 */
  31. }
  33. /**
  34.  * @brief       读取W25Q128的状态寄存器1的值
  35.  * @param       无
  36.  * @retval      状态寄存器值
  37.  */
  38. uint8_t w25q128_rd_sr1(void)
  39. {
  40.     uint8_t rec_data = 0;
  42.     W25Q128_CS(0);
  43.     spi2_read_write_byte(FLASH_ReadStatusReg1);     /* 读状态寄存器1 */
  44.     rec_data = spi2_read_write_byte(0xFF);
  45.     W25Q128_CS(1);
  47.     return rec_data;
  48. }
  50. /**
  51.  * @brief       W25Q128写使能
  52.  *   @note      将S1寄存器的WEL置位
  53.  * @param       无
  54.  * @retval      无
  55.  */
  56. void w25q128_write_enable(void)
  57. {
  58.     W25Q128_CS(0);
  59.     spi2_read_write_byte(FLASH_WriteEnable);   /* 发送写使能 */
  60.     W25Q128_CS(1);
  61. }
  63. /**
  64.  * @brief       W25Q128发送地址
  65.  * @param       address : 要发送的地址
  66.  * @retval      无
  67.  */
  68. static void w25q128_send_address(uint32_t address)
  69. {
  70.     spi2_read_write_byte((uint8_t)((address)>>16));     /* 发送 bit23 ~ bit16 地址 */
  71.     spi2_read_write_byte((uint8_t)((address)>>8));      /* 发送 bit15 ~ bit8  地址 */
  72.     spi2_read_write_byte((uint8_t)address);             /* 发送 bit7  ~ bit0  地址 */
  73. }
  75. /**
  76.  * @brief       擦除整个芯片
  77.  *   @note      等待时间超长...
  78.  * @param       无
  79.  * @retval      无
  80.  */
  81. void w25q128_erase_chip(void)
  82. {
  83.     w25q128_write_enable();    /* 写使能 */
  84.     w25q128_wait_busy();       /* 等待空闲 */
  85.     W25Q128_CS(0);
  86.     spi2_read_write_byte(FLASH_ChipErase);  /* 发送读寄存器命令 */ 
  87.     W25Q128_CS(1);
  88.     w25q128_wait_busy();       /* 等待芯片擦除结束 */
  89. }
  91. /**
  92.  * @brief       擦除一个扇区
  93.  *   @note      注意,这里是扇区地址,不是字节地址!!
  94.  *              擦除一个扇区的最少时间:150ms
  95.  *
  96.  * @param       saddr : 扇区地址 根据实际容量设置
  97.  * @retval      无
  98.  */
  99. void w25q128_erase_sector(uint32_t saddr)
  100. {
  101.     //printf('fe:%xrn', saddr);   /* 监视falsh擦除情况,测试用 */
  102.     saddr *= 4096;
  103.     w25q128_write_enable();        /* 写使能 */
  104.     w25q128_wait_busy();           /* 等待空闲 */
  106.     W25Q128_CS(0);
  107.     spi2_read_write_byte(FLASH_SectorErase);    /* 发送写页命令 */
  108.     w25q128_send_address(saddr);   /* 发送地址 */
  109.     W25Q128_CS(1);
  110.     w25q128_wait_busy();           /* 等待扇区擦除完成 */
  111. }
  113. /**
  114.  * @brief       读取芯片ID
  115.  * @param       无
  116.  * @retval      FLASH芯片ID
  117.  *   @note      芯片ID列表见: w25q128.h, 芯片列表部分
  118.  */
  119. uint16_t w25q128_read_id(void)
  120. {
  121.     uint16_t deviceid;
  123.     W25Q128_CS(0);
  124.     spi2_read_write_byte(FLASH_ManufactDeviceID);   /* 发送读 ID 命令 */
  125.     spi2_read_write_byte(0);    /* 写入一个字节 */
  126.     spi2_read_write_byte(0);
  127.     spi2_read_write_byte(0);
  128.     deviceid = spi2_read_write_byte(0xFF) << 8;     /* 读取高8位字节 */
  129.     deviceid |= spi2_read_write_byte(0xFF);         /* 读取低8位字节 */
  130.     W25Q128_CS(1);
  132.     return deviceid;
  133. }
  135. /**
  136.  * @brief       读取SPI FLASH
  137.  *   @note      在指定地址开始读取指定长度的数据
  138.  * @param       pbuf    : 数据存储区
  139.  * @param       addr    : 开始读取的地址(最大32bit)
  140.  * @param       datalen : 要读取的字节数(最大65535)
  141.  * @retval      无
  142.  */
  143. void w25q128_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  144. {
  145.     uint16_t i;
  147.     W25Q128_CS(0);
  148.     spi2_read_write_byte(FLASH_ReadData);       /* 发送读取命令 */
  149.     w25q128_send_address(addr);                /* 发送地址 */
  151.     for(i=0;i<datalen;i++)
  152.     {
  153.         pbuf[i] = spi2_read_write_byte(0XFF);   /* 循环读取 */
  154.     }
  156.     W25Q128_CS(1);
  157. }
  159. /**
  160.  * @brief       SPI在一页(0~65535)内写入少于256个字节的数据
  161.  *   @note      在指定地址开始写入最大256字节的数据
  162.  * @param       pbuf    : 数据存储区
  163.  * @param       addr    : 开始写入的地址(最大32bit)
  164.  * @param       datalen : 要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
  165.  * @retval      无
  166.  */
  167. static void w25q128_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  168. {
  169.     uint16_t i;
  171.     w25q128_write_enable();    /* 写使能 */
  173.     W25Q128_CS(0);
  174.     spi2_read_write_byte(FLASH_PageProgram);    /* 发送写页命令 */
  175.     w25q128_send_address(addr);                /* 发送地址 */
  177.     for(i=0;i<datalen;i++)
  178.     {
  179.         spi2_read_write_byte(pbuf[i]);          /* 循环写入 */
  180.     }
  182.     W25Q128_CS(1);
  183.     w25q128_wait_busy();       /* 等待写入结束 */
  184. }
  186. /**
  187.  * @brief       无检验写SPI FLASH
  188.  *   @note      必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
  189.  *              具有自动换页功能
  190.  *              在指定地址开始写入指定长度的数据,但是要确保地址不越界!
  191.  *
  192.  * @param       pbuf    : 数据存储区
  193.  * @param       addr    : 开始写入的地址(最大32bit)
  194.  * @param       datalen : 要写入的字节数(最大65535)
  195.  * @retval      无
  196.  */
  197. static void w25q128_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  198. {
  199.     uint16_t pageremain;
  200.     pageremain = 256 - addr % 256;  /* 单页剩余的字节数 */
  202.     if (datalen <= pageremain)      /* 不大于256个字节 */
  203.     {
  204.         pageremain = datalen;
  205.     }
  207.     while (1)
  208.     {
  209.         /* 当写入字节比页内剩余地址还少的时候, 一次性写完
  210.          * 当写入直接比页内剩余地址还多的时候, 先写完整个页内剩余地址, 然后根据剩余长度进行不同处理
  211.          */
  212.         w25q128_write_page(pbuf, addr, pageremain);
  214.         if (datalen == pageremain)   /* 写入结束了 */
  215.         {
  216.             break;
  217.         }
  218.         else     /* datalen > pageremain */
  219.         {
  220.             pbuf += pageremain;         /* pbuf指针地址偏移,前面已经写了pageremain字节 */
  221.             addr += pageremain;         /* 写地址偏移,前面已经写了pageremain字节 */
  222.             datalen -= pageremain;      /* 写入总长度减去已经写入了的字节数 */
  224.             if (datalen > 256)          /* 剩余数据还大于一页,可以一次写一页 */
  225.             {
  226.                 pageremain = 256;       /* 一次可以写入256个字节 */
  227.             }
  228.             else     /* 剩余数据小于一页,可以一次写完 */
  229.             {
  230.                 pageremain = datalen;   /* 不够256个字节了 */
  231.             }
  232.         }
  233.     }
  234. }
  236. /**
  237.  * @brief       写SPI FLASH
  238.  *   @note      在指定地址开始写入指定长度的数据 , 该函数带擦除操作!
  239.  *              SPI FLASH 一般是: 256个字节为一个Page, 4Kbytes为一个Sector, 16个扇区为1个Block
  240.  *              擦除的最小单位为Sector.
  241.  *
  242.  * @param       pbuf    : 数据存储区
  243.  * @param       addr    : 开始写入的地址(最大32bit)
  244.  * @param       datalen : 要写入的字节数(最大65535)
  245.  * @retval      无
  246.  */
  247. uint8_t g_w25q128_buf[4096];   /* 扇区缓存 */
  249. void w25q128_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  250. {
  251.     uint32_t secpos;
  252.     uint16_t secoff;
  253.     uint16_t secremain;
  254.     uint16_t i;
  255.     uint8_t *w25q128_buf;
  257.     w25q128_buf = g_w25q128_buf;
  258.     secpos = addr / 4096;       /* 扇区地址 */
  259.     secoff = addr % 4096;       /* 在扇区内的偏移 */
  260.     secremain = 4096 - secoff;  /* 扇区剩余空间大小 */
  262.     //printf('ad:%X,nb:%Xrn', addr, datalen); /* 测试用 */
  263.     if (datalen <= secremain)
  264.     {
  265.         secremain = datalen;    /* 不大于4096个字节 */
  266.     }
  268.     while (1)
  269.     {
  270.         w25q128_read(w25q128_buf, secpos * 4096, 4096);   /* 读出整个扇区的内容 */
  272.         for (i = 0; i < secremain; i++)   /* 校验数据 */
  273.         {
  274.             if (w25q128_buf[secoff + i] != 0XFF)
  275.             {
  276.                 break;      /* 需要擦除, 直接退出for循环 */
  277.             }
  278.         }
  280.         if (i < secremain)   /* 需要擦除 */
  281.         {
  282.             w25q128_erase_sector(secpos);  /* 擦除这个扇区 */
  284.             for (i = 0; i < secremain; i++)   /* 复制 */
  285.             {
  286.                 w25q128_buf[i + secoff] = pbuf[i];
  287.             }
  289.             w25q128_write_nocheck(w25q128_buf, secpos * 4096, 4096);  /* 写入整个扇区 */
  290.         }
  291.         else        /* 写已经擦除了的,直接写入扇区剩余区间. */
  292.         {
  293.             w25q128_write_nocheck(pbuf, addr, secremain);  /* 直接写扇区 */
  294.         }
  296.         if (datalen == secremain)
  297.         {
  298.             break;  /* 写入结束了 */
  299.         }
  300.         else        /* 写入未结束 */
  301.         {
  302.             secpos++;               /* 扇区地址增1 */
  303.             secoff = 0;             /* 偏移位置为0 */
  305.             pbuf += secremain;      /* 指针偏移 */
  306.             addr += secremain;      /* 写地址偏移 */
  307.             datalen -= secremain;   /* 字节数递减 */
  309.             if (datalen > 4096)
  310.             {
  311.                 secremain = 4096;   /* 下一个扇区还是写不完 */
  312.             }
  313.             else
  314.             {
  315.                 secremain = datalen;/* 下一个扇区可以写完了 */
  316.             }
  317.         }
  318.     }
  319. }

main函数里用这段代码测试 

  1.   /* USER CODE BEGIN 2 */
  2. 	w25q128_init();
  4. 	/* 写入测试数据 */
  5. 	sprintf((char *)datatemp, 'stm32f103c8t6');
  6. 	w25q128_write(datatemp, FLASH_WriteAddress, TEXT_SIZE);
  7. 	printf('数据写入完成！rn');
  9. 	/* 读出测试数据 */
  10. 	memset(datatemp, 0, TEXT_SIZE);
  11. 	w25q128_read(datatemp, FLASH_ReadAddress, TEXT_SIZE);
  12. 	printf('读出数据：%srn', datatemp);
  14.   /* USER CODE END 2 */

运行结果第一句首先一定是都没读取到 w25q128 这个芯片，这段判断代码在w25q128_init();里

w25q128芯片分析与功能实现

以前在这个文章里讲过 

STM32:SPI_我有在好好学习的博客-CSDN博客

总之， 整个存储空间的组成是

256个Block * 16个Sector * 16个Page * 256个字节 = 共16MB

而我们代码增删改查储存信息的单位是按照Sector为单位的，即一个扇区一个扇区的处理信息

阅读官方的芯片手册：

可知存储地址为六位十六进制，刚好对应16MB

0        0        0        0        0        0

前两位表示BLOCK，16*16 即256个Block

第三位对应Sector，16个

第四位对应Page，16个

五六位对应16*16 即256个字节

所以通过设置这个六位的地址，我们就可以决定把数据存在哪个扇区

例如 3FD000 ,就表示第63Block的第13个Sector，又因为我们是按照Sector操作的

所以通过前三位来选择不同的扇区来存数据

存和读都是字符串形式。写两个函数分别把字符串转化为链表，链表转化为字符串即可。

#artContent h1{font-size:16px;font-weight: 400;}