devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于STM32与FreeRTOS的四轴机械臂项目_基于stm32的机械臂项项目

作者：菜鸟追梦旅行 | 2024-04-11 13:34:37

赞

踩

基于stm32的机械臂项项目

目录

一、项目介绍

二、前期准备

1.硬件准备

2.开发环境

3.CubeMX配置

三、裸机各种模块测试

1.舵机模块

2.蓝牙模块

3.按键摇杆传感器模块和旋钮电位器模块

4.OLED模块

5.W25Q128模块

四、裸机三种控制测试

1.摇杆控制

2.示教器控制

3.蓝牙控制

五、裸机与FreeRTOS

1.CubeMX配置

2.移植裸机三种控制代码

六、项目演示视频

一、项目介绍

        该项目是基于FreeRTOS实时操作系统，主控为 STM32F103C8T6 开发板 ，机械臂为四轴分别被四个舵机控制。本项目实现了 3 种控制方法，分别为摇杆控制、示教器控制和串口蓝牙控制，采用8路ADC采集按键摇杆传感器和旋钮电位器的模拟量并由DMA搬运数据，可自制手机蓝牙APP或者直接使用官方手机蓝牙助手作为上位机，USART串口蓝牙实时收发信息，IIC驱动OLED屏幕实时显示机械臂移动张爪夹爪信息，人为控制抓取目标物。

        扩展：后续可以通过二维数组或者链表实现存储动作，通过SPI驱动W25Q128模块进行动作记忆扩容，即可以录制上百组动作，还可以附加树莓派等开发板进行视觉抓取开发，等以后有时间我再把扩展功能一起实现呈现给大家。

二、前期准备

1.硬件准备

本项目可用步进电机和驱动器作为支撑，以便提高项目扩展性，但在这里我直接用四个舵机实现。

首先你可以自己建模3D打印四轴机械臂模型，也可以直接去网上购买一套成品套件。然后需要四个舵机控制机械臂，型号无所谓，控制起来是一样的，注意需要是180度的角度型舵机，而不是360度的速度型舵机。

然后需要购买两个按键摇杆传感器实现摇杆控制，购买蓝牙模块实现串口蓝牙控制，购买四个旋钮电位器实现示教器控制。

硬件清单：

  • 四轴机械臂模型
  • 四个舵机
  • 两个按键摇杆传感器
  • HC系列蓝牙串口模块
  • 四个旋钮电位器
  • IIC协议OLED屏幕
  • SPI协议W25Q128模块

2.开发环境

单片机型号为STM32F103C8T6，开发环境为STM32CubeMX和Keil5，蓝牙控制需要手机下载蓝牙助手，在这里我下载的是官方给的HC蓝牙助手，（需要蓝牙调试助手的可以私信作者提供）

STM32F103C8T6原理图：

3.CubeMX配置

我用STM32CubeMX配置如下，仅供参考：

RCC:配置外部高速晶振        

SYS:Debug设置成Serial Wire

      ADC：打开8个通道

   

DMA：搬运ADC数据

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

usart：设置波特率为9600，因为蓝牙模块默认波特率为9600，开启NVIC中断接收信息

I2C：用来显示OLED模块

时钟树配置：

最后点击 generate code 生成代码

三、裸机各种模块测试

硬件模块接线：

  • 四个舵机分别接CH1_A15，CH2_B3，CH3_B10， CH4_B11
  • 蓝牙模块TX接RX，RX接TX
  • 两个按键摇杆传感器分别接 PA0 到 PA3 对应 IN0 到 IN3
  • 四个旋钮电位器分别接 PA4 到 PA7 对应 IN4 到 IN7
  • OLED模块 SCL 和 SDA 分别接 PB6 和 PB7
  • W25Q128模块自行扩展

1.舵机模块

舵机模块测试可以看之前我写过的文章，链接如下：

SG90舵机模块测试

然后对四个舵机进行函数封装，舵机初始化角度跟运动角度自行配置调试：

  1. //舵机A，夹爪	CH4_B11  45-135 张开闭合 初始化135
  2. void sg90_A()
  3. {
  4. 	if(adc_dma[3] > 4000 && angle[3] < 135)
  5. 	{
  6. 		angle[3]++;
  7. 	}
  8. 	else if(adc_dma[3] <1000 && angle[3] > 45)
  9. 	{
  10. 		angle[3]--;
  11. 	}
  12. }
  13.  
  14. //舵机B，上下	CH3_B10  45-180    初始化180
  15. void sg90_B()
  16. {
  17. 	if(adc_dma[2] <1000 && angle[2] < 180)
  18. 	{
  19. 		angle[2]++;
  20. 	}
  21. 	else if(adc_dma[2] > 4000 && angle[2] > 45)
  22. 	{
  23. 		angle[2]--;
  24. 	}
  25. }
  26.  
  27. //舵机C，前后	CH2_B3  45-180  前后   初始化45
  28. void sg90_C()
  29. {
  30. 	if(adc_dma[1] <1000 && angle[1] < 180)
  31. 	{
  32. 		angle[1]++;
  33. 	}
  34. 	else if(adc_dma[1] > 4000 && angle[1] > 45)
  35. 	{
  36. 		angle[1]--;
  37. 	}
  38. }
  39.  
  40. //舵机D，底座	CH1_A15 45-135 左到右   初始化45
  41. void sg90_D()
  42. {
  43. 	if(adc_dma[0] <1000 && angle[0] < 135)
  44. 	{
  45. 		angle[0]++;
  46. 	}
  47. 	else if(adc_dma[0] > 4000 && angle[0] > 45)
  48. 	{
  49. 		angle[0]--;
  50. 	}
  51. }
  52.  
  53. 	//开启4路PWM
  54. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  55. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  56. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  57. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  58.

2.蓝牙模块

可以使用HC-05(下图蓝色）或者HC-08（下图绿色），这两种我都测试通过。

有关蓝牙模块具体使用跟AT指令可以看以下两篇博客，链接如下：

HC-05介绍 和 HC-08介绍

使用串口中断测试收发的数据，串口重映射设置：

重映射代码：

  1. int fputc(int ch, FILE *f)
  2. {      
  3. 	unsigned char temp[1]={ch};
  4. 	HAL_UART_Transmit(&huart1,temp,1,0xffff);  
  5. 	return ch;
  6. }

中断接收信息代码：

  1. // 接收完成回调函数，收到一个数据后，在这里处理
  2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  3. {
  4. 	// 判断中断是由哪个串口触发的
  5. 	if(huart->Instance == USART1)
  6. 	{
  7. 		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
  8. 		if((UART1_RX_STA & 0x8000) == 0)
  9. 		{
  10. 			// 如果已经收到了 0x0d （回车），
  11. 			if(UART1_RX_STA & 0x4000)
  12. 			{
  13. 				// 则接着判断是否收到 0x0a （换行）
  14. 				if(buf == 0x0a)
  15. 					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
  16. 					UART1_RX_STA |= 0x8000;
  17. 				else
  18. 					// 否则认为接收错误，重新开始
  19. 					UART1_RX_STA = 0;
  20. 			}
  21. 			else	// 如果没有收到了 0x0d （回车）
  22. 			{
  23. 				//则先判断收到的这个字符是否是 0x0d （回车）
  24. 				if(buf == 0x0d)
  25. 				{
  26. 					// 是的话则将 bit14 位置为1
  27. 					UART1_RX_STA |= 0x4000;
  28. 				}
  29. 				else
  30. 				{
  31. 					// 否则将接收到的数据保存在缓存数组里
  32. 					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
  33. 					UART1_RX_STA++;
  34. 					
  35. 					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
  36. 					if(UART1_RX_STA > UART1_REC_LEN - 1)
  37. 						UART1_RX_STA = 0;
  38. 				}
  39. 			}
  40. 		}
  41. 		// 重新开启中断
  42. 		HAL_UART_Receive_IT(&huart1, &buf, 1);
  43. 	}
  44. }
  45.

在main.c函数中开启中断测试，然后打开蓝牙助手：

  1.   // 开启接收中断
  2.   HAL_UART_Receive_IT(&huart1, &buf, 1);
  3.  
  4.   while (1)
  5.   {
  6. 		//判断判断串口是否接收完成
  7. 		if(UART1_RX_STA & 0x8000)
  8. 		{
  9. 			if(!strcmp((const char *)UART1_RX_Buffer, "open"))
  10. 			{
  11.                 printf("张爪\r\n");
  12. 			}
  13. 			else if (!strcmp((const char *)UART1_RX_Buffer, "close"))
  14. 			{
  15.                 printf("夹爪\r\n");
  16. 			}
  17. 			else
  18. 			{
  19. 				if(UART1_RX_Buffer[0] != '\0')
  20. 					printf("指令发送错误：%s\r\n", UART1_RX_Buffer);
  21. 			}
  22. 			printf("\r\n");
  23. 			// 重新开始下一次接收
  24. 			UART1_RX_STA = 0;
  25. 		}
  26. 		HAL_Delay(40);
  27.   }

手机打开蓝牙助手，记得把发送新行勾上，不然中断接收不到数据

3.按键摇杆传感器模块和旋钮电位器模块

这里用两个按键摇杆传感器分别接收 IN0~3 ADC的模拟量，用四个旋钮电位器分别接收 IN4~7 ADC的模拟量

利用DMA传输接收到的ADC的值通过串口打印进行调试，通过按钮和电位器控制角度

代码示例：

  1. uint16_t adc_dma[8];//DMA搬运的ADC采集值
  2.  
  3. uint8_t angle[4] = {45,45,180,135};//舵机角度
  4.  
  5. uint8_t cnt = 0;//计数用，定时串口打印信息
  6.  
  7. //根据输入的0~180角度获取对应pwm占空比参数
  8. uint8_t Angle(uint8_t pwm_pulse)
  9. {
  10. 	return pwm_pulse + 44;
  11. }
  12.  
  13.  
  14.   //开始ADC和DMA采集
  15.   HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,8);
  16.  
  17.   while (1)
  18.   {
  19. 		sg90_A();
  20. 		sg90_B();
  21. 		sg90_C();
  22. 		sg90_D();
  23. 		
  24. 		//输出PWM波使舵机运动
  25. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  26. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  27. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  28. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  29. 		
  30. 		cnt++;//计数，每循环一次+1
  31. 		if(cnt>= 50)//循环50次，每次20ms，即一共1s。每一秒发送一次数据
  32. 		{
  33. 			printf("Angle = {%d, %d, %d, %d}\r\n",angle[0],angle[1],angle[2],angle[3]);
  34. 			printf("adc_dma = {%d, %d, %d, %d, %d, %d, %d, %d}\r\n",adc_dma[0],adc_dma[1],adc_dma[2],adc_dma[3],adc_dma[4],adc_dma[5],adc_dma[6],adc_dma[7]);
  35. 			cnt = 0;
  36. 		}
  37. 		HAL_Delay(20);//每20ms循环一次
  38.   }

4.OLED模块

在这里我们可以用取模软件显示机械臂动作，张爪夹爪，向左向右，向前向后，向上向下，也可以后续自行扩展其他内容，例如角度和控制模式等。

oled介绍可看我之前写过的：OLED取模生成文字图片

代码实现如下：

  1. /*--  文字:  向  --*/
  2. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  3. char x1[16] = {0x00,0xF8,0x08,0x08,0x0C,0xCA,0x49,0x48,0x48,0xC8,0x08,0x08,0x08,0xF8,0x00,0x00};
  4. char x2[16] = {0x00,0xFF,0x00,0x00,0x00,0x1F,0x08,0x08,0x08,0x1F,0x00,0x40,0x80,0x7F,0x00,0x00};
  5.  
  6. /*--  文字:  前  --*/
  7. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  8. char f1[16] = {0x08,0x08,0xE8,0x29,0x2E,0x28,0xE8,0x08,0x08,0xC8,0x0C,0x0B,0xE8,0x08,0x08,0x00};
  9. char f2[16] = {0x00,0x00,0xFF,0x09,0x49,0x89,0x7F,0x00,0x00,0x0F,0x40,0x80,0x7F,0x00,0x00,0x00};
  10.  
  11. /*--  文字:  后  --*/
  12. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  13. char b1[16] = {0x00,0x00,0x00,0xFC,0x24,0x24,0x24,0x24,0x22,0x22,0x22,0x23,0x22,0x20,0x20,0x00};
  14. char b2[16] = {0x40,0x20,0x18,0x07,0x00,0xFE,0x42,0x42,0x42,0x42,0x42,0x42,0xFE,0x00,0x00,0x00};
  15.  
  16. /*--  文字:  上  --*/
  17. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  18. char u1[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x40,0x40,0x40,0x40,0x40,0x40,0x00,0x00,0x00};
  19. char u2[16] = {0x40,0x40,0x40,0x40,0x40,0x40,0x7F,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00};
  20.  
  21. /*--  文字:  下  --*/
  22. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  23. char d1[16] = {0x02,0x02,0x02,0x02,0x02,0x02,0xFE,0x02,0x02,0x42,0x82,0x02,0x02,0x02,0x02,0x00};
  24. char d2[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x01,0x06,0x00,0x00,0x00};
  25.  
  26. /*--  文字:  左  --*/
  27. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  28. char l1[16] = {0x08,0x08,0x08,0x08,0x88,0x78,0x0F,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00};
  29. char l2[16] = {0x20,0x10,0x48,0x46,0x41,0x41,0x41,0x41,0x7F,0x41,0x41,0x41,0x41,0x40,0x40,0x00};
  30.  
  31. /*--  文字:  右  --*/
  32. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  33. char r1[16] = {0x08,0x08,0x08,0x08,0xC8,0x38,0x0F,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00};
  34. char r2[16] = {0x08,0x04,0x02,0x01,0xFF,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0xFF,0x00,0x00,0x00};
  35.  
  36. /*--  文字:  张  --*/
  37. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  38. char o1[16] = {0x02,0xE2,0x22,0x22,0x3E,0x80,0x80,0xFF,0x80,0xA0,0x90,0x88,0x86,0x80,0x80,0x00};
  39. char o2[16] = {0x00,0x43,0x82,0x42,0x3E,0x00,0x00,0xFF,0x40,0x21,0x06,0x08,0x10,0x20,0x40,0x00};
  40.  
  41. /*--  文字:  夹  --*/
  42. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  43. char c1[16] = {0x00,0x08,0x08,0x28,0x48,0x08,0x08,0xFF,0x08,0x08,0x48,0x28,0x08,0x08,0x00,0x00};
  44. char c2[16] = {0x81,0x81,0x41,0x41,0x21,0x11,0x0D,0x03,0x0D,0x11,0x21,0x41,0x41,0x81,0x81,0x00};
  45.  
  46. /*--  文字:  爪  --*/
  47. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  48. char z1[16] = {0x00,0x00,0x00,0xFC,0x04,0x04,0xFC,0x04,0x02,0x02,0xFE,0x03,0x02,0x00,0x00,0x00};
  49. char z2[16] = {0x80,0x60,0x18,0x07,0x00,0x00,0x7F,0x00,0x00,0x00,0x01,0x0E,0x30,0x40,0x80,0x00};
  50.  
  51. void Oled_Write_Cmd(uint8_t dataCmd)
  52. {
  53. 	
  54. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x00, I2C_MEMADD_SIZE_8BIT,
  55. 										&dataCmd, 1, 0xff);
  56. }
  57.  
  58. void Oled_Write_Data(uint8_t dataData)
  59. {
  60. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x40, I2C_MEMADD_SIZE_8BIT,
  61. 										&dataData, 1, 0xff);
  62. }
  63.  
  64. void Oled_Init(void){
  65. 	Oled_Write_Cmd(0xAE);//--display off
  66. 	Oled_Write_Cmd(0x00);//---set low column address
  67. 	Oled_Write_Cmd(0x10);//---set high column address
  68. 	Oled_Write_Cmd(0x40);//--set start line address  
  69. 	Oled_Write_Cmd(0xB0);//--set page address
  70. 	Oled_Write_Cmd(0x81); // contract control
  71. 	Oled_Write_Cmd(0xFF);//--128   
  72. 	Oled_Write_Cmd(0xA1);//set segment remap 
  73. 	Oled_Write_Cmd(0xA6);//--normal / reverse
  74. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
  75. 	Oled_Write_Cmd(0x3F);//--1/32 duty
  76. 	Oled_Write_Cmd(0xC8);//Com scan direction
  77. 	Oled_Write_Cmd(0xD3);//-set display offset
  78. 	Oled_Write_Cmd(0x00);//
  79. 	
  80. 	Oled_Write_Cmd(0xD5);//set osc division
  81. 	Oled_Write_Cmd(0x80);//
  82. 	
  83. 	Oled_Write_Cmd(0xD8);//set area color mode off
  84. 	Oled_Write_Cmd(0x05);//
  85. 	
  86. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
  87. 	Oled_Write_Cmd(0xF1);//
  88. 	
  89. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
  90. 	Oled_Write_Cmd(0x12);//
  91. 	
  92. 	Oled_Write_Cmd(0xDB);//set Vcomh
  93. 	Oled_Write_Cmd(0x30);//
  94. 	
  95. 	Oled_Write_Cmd(0x8D);//set charge pump enable
  96. 	Oled_Write_Cmd(0x14);//
  97. 	
  98. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
  99. }
  100.  
  101. void Oled_Screen_Clear(void){
  102. 	unsigned char i,n;
  103. 	Oled_Write_Cmd (0x20);                    //set memory addressing mode
  104. 	Oled_Write_Cmd (0x02);                    //page addressing mode
  105.  
  106. 	for(i=0;i<8;i++){
  107. 		Oled_Write_Cmd(0xb0+i);               //
  108. 		Oled_Write_Cmd(0x00);                 //
  109. 		Oled_Write_Cmd(0x10);                 //
  110. 		for(n=0;n<128;n++)Oled_Write_Data(0x00); 			
  111. 	}	
  112. }
  113.  
  114. void Oled_Show_open()
  115. {
  116. 		unsigned char  i;
  117.  
  118. 		Oled_Init();
  119. 		// 选择一个位置确认页寻址模式
  120. 		Oled_Write_Cmd(0x20);
  121. 		Oled_Write_Cmd(0x02);
  122. 		Oled_Screen_Clear();
  123. 		// 选择PAGE0   1011 0000 0xB0			
  124. 		Oled_Write_Cmd(0xB0);
  125. 		Oled_Write_Cmd(0x00);
  126. 		Oled_Write_Cmd(0x10);
  127.  
  128. 		for(i=0;i<16;i++){
  129. 			Oled_Write_Data(o1[i]);
  130. 		}
  131. 		for(i=0;i<16;i++){
  132. 			Oled_Write_Data(z1[i]);
  133. 		}
  134.  
  135. 		Oled_Write_Cmd(0xB1);
  136. 		Oled_Write_Cmd(0x00);
  137. 		Oled_Write_Cmd(0x10);
  138.  
  139. 		for(i=0;i<16;i++){
  140. 			Oled_Write_Data(o2[i]);
  141. 		}
  142. 		for(i=0;i<16;i++){
  143. 			Oled_Write_Data(z2[i]);
  144. 		}
  145.  
  146. }
  147.  
  148. void Oled_Show_close()
  149. {
  150. 		unsigned char  i;
  151.  
  152. 		Oled_Init();
  153.  
  154. 		Oled_Write_Cmd(0x20);
  155. 		Oled_Write_Cmd(0x02);
  156. 		Oled_Screen_Clear();
  157.  
  158. 		Oled_Write_Cmd(0xB0);
  159. 		Oled_Write_Cmd(0x00);
  160. 		Oled_Write_Cmd(0x10);
  161.  
  162. 		for(i=0;i<16;i++){
  163. 			Oled_Write_Data(c1[i]);
  164. 		}
  165. 		for(i=0;i<16;i++){
  166. 			Oled_Write_Data(z1[i]);
  167. 		}
  168.  
  169. 		Oled_Write_Cmd(0xB1);
  170. 		Oled_Write_Cmd(0x00);
  171. 		Oled_Write_Cmd(0x10);
  172.  
  173. 		for(i=0;i<16;i++){
  174. 			Oled_Write_Data(c2[i]);
  175. 		}
  176. 		for(i=0;i<16;i++){
  177. 			Oled_Write_Data(z2[i]);
  178. 		}
  179.  
  180. }
  181.  
  182. void Oled_Show_up()
  183. {
  184. 		unsigned char  i;
  185.  
  186. 		Oled_Init();
  187.  
  188. 		Oled_Write_Cmd(0x20);
  189. 		Oled_Write_Cmd(0x02);
  190. 		Oled_Screen_Clear();
  191.  
  192. 		Oled_Write_Cmd(0xB0);
  193. 		Oled_Write_Cmd(0x00);
  194. 		Oled_Write_Cmd(0x10);
  195.  
  196. 		for(i=0;i<16;i++){
  197. 			Oled_Write_Data(x1[i]);
  198. 		}
  199. 		for(i=0;i<16;i++){
  200. 			Oled_Write_Data(u1[i]);
  201. 		}
  202.  
  203. 		Oled_Write_Cmd(0xB1);
  204. 		Oled_Write_Cmd(0x00);
  205. 		Oled_Write_Cmd(0x10);
  206.  
  207. 		for(i=0;i<16;i++){
  208. 			Oled_Write_Data(x2[i]);
  209. 		}
  210. 		for(i=0;i<16;i++){
  211. 			Oled_Write_Data(u2[i]);
  212. 		}
  213.  
  214. }
  215.  
  216. void Oled_Show_down()
  217. {
  218. 		unsigned char  i;
  219. 	
  220. 		Oled_Init();
  221.  
  222. 		Oled_Write_Cmd(0x20);
  223. 		Oled_Write_Cmd(0x02);
  224. 		Oled_Screen_Clear();
  225.  
  226. 		Oled_Write_Cmd(0xB0);
  227. 		Oled_Write_Cmd(0x00);
  228. 		Oled_Write_Cmd(0x10);
  229.  
  230. 		for(i=0;i<16;i++){
  231. 			Oled_Write_Data(x1[i]);
  232. 		}
  233. 		for(i=0;i<16;i++){
  234. 			Oled_Write_Data(d1[i]);
  235. 		}
  236.  
  237. 		Oled_Write_Cmd(0xB1);
  238. 		Oled_Write_Cmd(0x00);
  239. 		Oled_Write_Cmd(0x10);
  240.  
  241. 		for(i=0;i<16;i++){
  242. 			Oled_Write_Data(x2[i]);
  243. 		}
  244. 		for(i=0;i<16;i++){
  245. 			Oled_Write_Data(d2[i]);
  246. 		}
  247.  
  248. }
  249.  
  250. void Oled_Show_left()
  251. {
  252. 		unsigned char  i;
  253.  
  254. 		Oled_Init();
  255.  
  256. 		Oled_Write_Cmd(0x20);
  257. 		Oled_Write_Cmd(0x02);
  258. 		Oled_Screen_Clear();
  259.  
  260. 		Oled_Write_Cmd(0xB0);
  261. 		Oled_Write_Cmd(0x00);
  262. 		Oled_Write_Cmd(0x10);
  263.  
  264. 		for(i=0;i<16;i++){
  265. 			Oled_Write_Data(x1[i]);
  266. 		}
  267. 		for(i=0;i<16;i++){
  268. 			Oled_Write_Data(l1[i]);
  269. 		}
  270.  
  271. 		Oled_Write_Cmd(0xB1);
  272. 		Oled_Write_Cmd(0x00);
  273. 		Oled_Write_Cmd(0x10);
  274.  
  275. 		for(i=0;i<16;i++){
  276. 			Oled_Write_Data(x2[i]);
  277. 		}
  278. 		for(i=0;i<16;i++){
  279. 			Oled_Write_Data(l2[i]);
  280. 		}
  281.  
  282. }
  283.  
  284. void Oled_Show_right()
  285. {
  286. 		unsigned char  i;
  287.  
  288. 		Oled_Init();
  289.  
  290. 		Oled_Write_Cmd(0x20);
  291. 		Oled_Write_Cmd(0x02);
  292. 		Oled_Screen_Clear();
  293.  
  294. 		Oled_Write_Cmd(0xB0);
  295. 		Oled_Write_Cmd(0x00);
  296. 		Oled_Write_Cmd(0x10);
  297.  
  298. 		for(i=0;i<16;i++){
  299. 			Oled_Write_Data(x1[i]);
  300. 		}
  301. 		for(i=0;i<16;i++){
  302. 			Oled_Write_Data(r1[i]);
  303. 		}
  304.  
  305. 		Oled_Write_Cmd(0xB1);
  306. 		Oled_Write_Cmd(0x00);
  307. 		Oled_Write_Cmd(0x10);
  308.  
  309. 		for(i=0;i<16;i++){
  310. 			Oled_Write_Data(x2[i]);
  311. 		}
  312. 		for(i=0;i<16;i++){
  313. 			Oled_Write_Data(r2[i]);
  314. 		}
  315.  
  316. }
  317.  
  318. void Oled_Show_front()
  319. {
  320. 		unsigned char  i;
  321.  
  322. 		Oled_Init();
  323.  
  324. 		Oled_Write_Cmd(0x20);
  325. 		Oled_Write_Cmd(0x02);
  326. 		Oled_Screen_Clear();
  327.  
  328. 		Oled_Write_Cmd(0xB0);
  329. 		Oled_Write_Cmd(0x00);
  330. 		Oled_Write_Cmd(0x10);
  331.  
  332. 		for(i=0;i<16;i++){
  333. 			Oled_Write_Data(x1[i]);
  334. 		}
  335. 		for(i=0;i<16;i++){
  336. 			Oled_Write_Data(f1[i]);
  337. 		}
  338.  
  339. 		Oled_Write_Cmd(0xB1);
  340. 		Oled_Write_Cmd(0x00);
  341. 		Oled_Write_Cmd(0x10);
  342.  
  343. 		for(i=0;i<16;i++){
  344. 			Oled_Write_Data(x2[i]);
  345. 		}
  346. 		for(i=0;i<16;i++){
  347. 			Oled_Write_Data(f2[i]);
  348. 		}
  349.  
  350. }
  351.  
  352. void Oled_Show_behind()
  353. {
  354. 		unsigned char  i;
  355.  
  356. 		Oled_Init();
  357.  
  358. 		Oled_Write_Cmd(0x20);
  359. 		Oled_Write_Cmd(0x02);
  360. 		Oled_Screen_Clear();
  361.  
  362. 		Oled_Write_Cmd(0xB0);
  363. 		Oled_Write_Cmd(0x00);
  364. 		Oled_Write_Cmd(0x10);
  365.  
  366. 		for(i=0;i<16;i++){
  367. 			Oled_Write_Data(x1[i]);
  368. 		}
  369. 		for(i=0;i<16;i++){
  370. 			Oled_Write_Data(b1[i]);
  371. 		}
  372.  
  373. 		Oled_Write_Cmd(0xB1);
  374. 		Oled_Write_Cmd(0x00);
  375. 		Oled_Write_Cmd(0x10);
  376.  
  377. 		for(i=0;i<16;i++){
  378. 			Oled_Write_Data(x2[i]);
  379. 		}
  380. 		for(i=0;i<16;i++){
  381. 			Oled_Write_Data(b2[i]);
  382. 		}
  383.  
  384. }
  385.  
  386.   while (1)
  387.   {
  388. 			Oled_Show_open();
  389. 			HAL_Delay(1000);
  390. 			Oled_Show_close();
  391. 			HAL_Delay(1000);
  392. 			Oled_Show_up();
  393. 			HAL_Delay(1000);
  394. 			Oled_Show_down();
  395. 			HAL_Delay(1000);
  396. 			Oled_Show_left();
  397. 			HAL_Delay(1000);
  398. 			Oled_Show_right();
  399. 			HAL_Delay(1000);
  400. 			Oled_Show_front();
  401. 			HAL_Delay(1000);	
  402. 			Oled_Show_behind();
  403. 			HAL_Delay(1000);
  404.   }

5.W25Q128模块

W25Q128模块测试可看我之前写过的文章然后自行扩展：W25Q128模块测试

四、裸机三种控制测试

首先我在Core文件夹里面的Src和Inc里分别创建pwm和oled的.c和.h文件

1.摇杆控制

摇杆控制在这里我用上面讲到的两个按键摇杆传感器模块实现，只需要开启四路ADC采集，两个按键摇杆传感器分别接收 IN0~3 ADC的模拟量，其中需要结合实际操作控制舵机初始化角度和运动过程中的角度变化。

代码示例：

pwm.c

  1. extern uint16_t adc_dma[4];//DMA搬运的ADC采集值
  2.  
  3. extern int8_t angle[4] = {45,45,180,135};//舵机角度
  4.  
  5. //根据输入的0~180角度获取对应pwm占空比参数
  6. unsigned char Angle(unsigned char pwm_pulse)
  7. {
  8. 	return pwm_pulse + 44;
  9. }
  10.  
  11. //舵机A，夹爪	CH4_B11  45-135 张开闭合 初始化135
  12. void sg90_A()
  13. {
  14. 	if(adc_dma[3] > 4000 && angle[3] < 135)
  15. 	{
  16. 		angle[3]++;
  17. 	}
  18. 	else if(adc_dma[3] <1000 && angle[3] > 45)
  19. 	{
  20. 		angle[3]--;
  21. 	}
  22. }
  23.  
  24. //舵机B，上下	CH3_B10  45-180    初始化180
  25. void sg90_B()
  26. {
  27. 	if(adc_dma[2] <1000 && angle[2] < 180)
  28. 	{
  29. 		angle[2]++;
  30. 	}
  31. 	else if(adc_dma[2] > 4000 && angle[2] > 45)
  32. 	{
  33. 		angle[2]--;
  34. 	}
  35. }
  36.  
  37. //舵机C，前后	CH2_B3  45-180  前后   初始化45
  38. void sg90_C()
  39. {
  40. 	if(adc_dma[1] <1000 && angle[1] < 180)
  41. 	{
  42. 		angle[1]++;
  43. 	}
  44. 	else if(adc_dma[1] > 4000 && angle[1] > 45)
  45. 	{
  46. 		angle[1]--;
  47. 	}
  48. }
  49.  
  50. //舵机D，底座	CH1_A15 45-135 左到右   初始化45
  51. void sg90_D()
  52. {
  53. 	if(adc_dma[0] <1000 && angle[0] < 135)
  54. 	{
  55. 		angle[0]++;
  56. 	}
  57. 	else if(adc_dma[0] > 4000 && angle[0] > 45)
  58. 	{
  59. 		angle[0]--;
  60. 	}
  61. }

pwm.h

  1. #ifndef __PWM_H__
  2. #define __PWM_H__
  3.  
  4. unsigned char Angle(unsigned char pwm_pulse);
  5.  
  6. void sg90_A(void);
  7.  
  8. void sg90_B(void);
  9.  
  10. void sg90_C(void);
  11.  
  12. void sg90_D(void);
  13.  
  14. #endif

oled.c

  1. #include "main.h"
  2. #include "i2c.h"
  3. #include "oled.h"
  4.  
  5. /*--  文字:  向  --*/
  6. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  7. char x1[16] = {0x00,0xF8,0x08,0x08,0x0C,0xCA,0x49,0x48,0x48,0xC8,0x08,0x08,0x08,0xF8,0x00,0x00};
  8. char x2[16] = {0x00,0xFF,0x00,0x00,0x00,0x1F,0x08,0x08,0x08,0x1F,0x00,0x40,0x80,0x7F,0x00,0x00};
  9.  
  10. /*--  文字:  前  --*/
  11. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  12. char f1[16] = {0x08,0x08,0xE8,0x29,0x2E,0x28,0xE8,0x08,0x08,0xC8,0x0C,0x0B,0xE8,0x08,0x08,0x00};
  13. char f2[16] = {0x00,0x00,0xFF,0x09,0x49,0x89,0x7F,0x00,0x00,0x0F,0x40,0x80,0x7F,0x00,0x00,0x00};
  14.  
  15. /*--  文字:  后  --*/
  16. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  17. char b1[16] = {0x00,0x00,0x00,0xFC,0x24,0x24,0x24,0x24,0x22,0x22,0x22,0x23,0x22,0x20,0x20,0x00};
  18. char b2[16] = {0x40,0x20,0x18,0x07,0x00,0xFE,0x42,0x42,0x42,0x42,0x42,0x42,0xFE,0x00,0x00,0x00};
  19.  
  20. /*--  文字:  上  --*/
  21. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  22. char u1[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x40,0x40,0x40,0x40,0x40,0x40,0x00,0x00,0x00};
  23. char u2[16] = {0x40,0x40,0x40,0x40,0x40,0x40,0x7F,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00};
  24.  
  25. /*--  文字:  下  --*/
  26. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  27. char d1[16] = {0x02,0x02,0x02,0x02,0x02,0x02,0xFE,0x02,0x02,0x42,0x82,0x02,0x02,0x02,0x02,0x00};
  28. char d2[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x01,0x06,0x00,0x00,0x00};
  29.  
  30. /*--  文字:  左  --*/
  31. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  32. char l1[16] = {0x08,0x08,0x08,0x08,0x88,0x78,0x0F,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00};
  33. char l2[16] = {0x20,0x10,0x48,0x46,0x41,0x41,0x41,0x41,0x7F,0x41,0x41,0x41,0x41,0x40,0x40,0x00};
  34.  
  35. /*--  文字:  右  --*/
  36. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  37. char r1[16] = {0x08,0x08,0x08,0x08,0xC8,0x38,0x0F,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00};
  38. char r2[16] = {0x08,0x04,0x02,0x01,0xFF,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0xFF,0x00,0x00,0x00};
  39.  
  40. /*--  文字:  张  --*/
  41. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  42. char o1[16] = {0x02,0xE2,0x22,0x22,0x3E,0x80,0x80,0xFF,0x80,0xA0,0x90,0x88,0x86,0x80,0x80,0x00};
  43. char o2[16] = {0x00,0x43,0x82,0x42,0x3E,0x00,0x00,0xFF,0x40,0x21,0x06,0x08,0x10,0x20,0x40,0x00};
  44.  
  45. /*--  文字:  夹  --*/
  46. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  47. char c1[16] = {0x00,0x08,0x08,0x28,0x48,0x08,0x08,0xFF,0x08,0x08,0x48,0x28,0x08,0x08,0x00,0x00};
  48. char c2[16] = {0x81,0x81,0x41,0x41,0x21,0x11,0x0D,0x03,0x0D,0x11,0x21,0x41,0x41,0x81,0x81,0x00};
  49.  
  50. /*--  文字:  爪  --*/
  51. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
  52. char z1[16] = {0x00,0x00,0x00,0xFC,0x04,0x04,0xFC,0x04,0x02,0x02,0xFE,0x03,0x02,0x00,0x00,0x00};
  53. char z2[16] = {0x80,0x60,0x18,0x07,0x00,0x00,0x7F,0x00,0x00,0x00,0x01,0x0E,0x30,0x40,0x80,0x00};
  54.  
  55. void Oled_Write_Cmd(uint8_t dataCmd)
  56. {
  57. 	
  58. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x00, I2C_MEMADD_SIZE_8BIT,
  59. 										&dataCmd, 1, 0xff);
  60. }
  61.  
  62. void Oled_Write_Data(uint8_t dataData)
  63. {
  64. 	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x40, I2C_MEMADD_SIZE_8BIT,
  65. 										&dataData, 1, 0xff);
  66. }
  67.  
  68. void Oled_Init(void){
  69. 	Oled_Write_Cmd(0xAE);//--display off
  70. 	Oled_Write_Cmd(0x00);//---set low column address
  71. 	Oled_Write_Cmd(0x10);//---set high column address
  72. 	Oled_Write_Cmd(0x40);//--set start line address  
  73. 	Oled_Write_Cmd(0xB0);//--set page address
  74. 	Oled_Write_Cmd(0x81); // contract control
  75. 	Oled_Write_Cmd(0xFF);//--128   
  76. 	Oled_Write_Cmd(0xA1);//set segment remap 
  77. 	Oled_Write_Cmd(0xA6);//--normal / reverse
  78. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
  79. 	Oled_Write_Cmd(0x3F);//--1/32 duty
  80. 	Oled_Write_Cmd(0xC8);//Com scan direction
  81. 	Oled_Write_Cmd(0xD3);//-set display offset
  82. 	Oled_Write_Cmd(0x00);//
  83. 	
  84. 	Oled_Write_Cmd(0xD5);//set osc division
  85. 	Oled_Write_Cmd(0x80);//
  86. 	
  87. 	Oled_Write_Cmd(0xD8);//set area color mode off
  88. 	Oled_Write_Cmd(0x05);//
  89. 	
  90. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
  91. 	Oled_Write_Cmd(0xF1);//
  92. 	
  93. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
  94. 	Oled_Write_Cmd(0x12);//
  95. 	
  96. 	Oled_Write_Cmd(0xDB);//set Vcomh
  97. 	Oled_Write_Cmd(0x30);//
  98. 	
  99. 	Oled_Write_Cmd(0x8D);//set charge pump enable
  100. 	Oled_Write_Cmd(0x14);//
  101. 	
  102. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
  103. }
  104.  
  105. void Oled_Screen_Clear(void){
  106. 	unsigned char i,n;
  107. 	Oled_Write_Cmd (0x20);                    //set memory addressing mode
  108. 	Oled_Write_Cmd (0x02);                    //page addressing mode
  109.  
  110. 	for(i=0;i<8;i++){
  111. 		Oled_Write_Cmd(0xb0+i);               //
  112. 		Oled_Write_Cmd(0x00);                 //
  113. 		Oled_Write_Cmd(0x10);                 //
  114. 		for(n=0;n<128;n++)Oled_Write_Data(0x00); 			
  115. 	}	
  116. }
  117.  
  118. void Oled_Show_open()
  119. {
  120. 		unsigned char  i;
  121.  
  122. 		Oled_Init();
  123. 		// 选择一个位置确认页寻址模式
  124. 		Oled_Write_Cmd(0x20);
  125. 		Oled_Write_Cmd(0x02);
  126. 		Oled_Screen_Clear();
  127. 		// 选择PAGE0   1011 0000 0xB0			
  128. 		Oled_Write_Cmd(0xB0);
  129. 		Oled_Write_Cmd(0x00);
  130. 		Oled_Write_Cmd(0x10);
  131.  
  132. 		for(i=0;i<16;i++){
  133. 			Oled_Write_Data(o1[i]);
  134. 		}
  135. 		for(i=0;i<16;i++){
  136. 			Oled_Write_Data(z1[i]);
  137. 		}
  138.  
  139. 		Oled_Write_Cmd(0xB1);
  140. 		Oled_Write_Cmd(0x00);
  141. 		Oled_Write_Cmd(0x10);
  142.  
  143. 		for(i=0;i<16;i++){
  144. 			Oled_Write_Data(o2[i]);
  145. 		}
  146. 		for(i=0;i<16;i++){
  147. 			Oled_Write_Data(z2[i]);
  148. 		}
  149.  
  150. }
  151.  
  152. void Oled_Show_close()
  153. {
  154. 		unsigned char  i;
  155.  
  156. 		Oled_Init();
  157.  
  158. 		Oled_Write_Cmd(0x20);
  159. 		Oled_Write_Cmd(0x02);
  160. 		Oled_Screen_Clear();
  161.  
  162. 		Oled_Write_Cmd(0xB0);
  163. 		Oled_Write_Cmd(0x00);
  164. 		Oled_Write_Cmd(0x10);
  165.  
  166. 		for(i=0;i<16;i++){
  167. 			Oled_Write_Data(c1[i]);
  168. 		}
  169. 		for(i=0;i<16;i++){
  170. 			Oled_Write_Data(z1[i]);
  171. 		}
  172.  
  173. 		Oled_Write_Cmd(0xB1);
  174. 		Oled_Write_Cmd(0x00);
  175. 		Oled_Write_Cmd(0x10);
  176.  
  177. 		for(i=0;i<16;i++){
  178. 			Oled_Write_Data(c2[i]);
  179. 		}
  180. 		for(i=0;i<16;i++){
  181. 			Oled_Write_Data(z2[i]);
  182. 		}
  183.  
  184. }
  185.  
  186. void Oled_Show_up()
  187. {
  188. 		unsigned char  i;
  189.  
  190. 		Oled_Init();
  191.  
  192. 		Oled_Write_Cmd(0x20);
  193. 		Oled_Write_Cmd(0x02);
  194. 		Oled_Screen_Clear();
  195.  
  196. 		Oled_Write_Cmd(0xB0);
  197. 		Oled_Write_Cmd(0x00);
  198. 		Oled_Write_Cmd(0x10);
  199.  
  200. 		for(i=0;i<16;i++){
  201. 			Oled_Write_Data(x1[i]);
  202. 		}
  203. 		for(i=0;i<16;i++){
  204. 			Oled_Write_Data(u1[i]);
  205. 		}
  206.  
  207. 		Oled_Write_Cmd(0xB1);
  208. 		Oled_Write_Cmd(0x00);
  209. 		Oled_Write_Cmd(0x10);
  210.  
  211. 		for(i=0;i<16;i++){
  212. 			Oled_Write_Data(x2[i]);
  213. 		}
  214. 		for(i=0;i<16;i++){
  215. 			Oled_Write_Data(u2[i]);
  216. 		}
  217.  
  218. }
  219.  
  220. void Oled_Show_down()
  221. {
  222. 		unsigned char  i;
  223. 	
  224. 		Oled_Init();
  225.  
  226. 		Oled_Write_Cmd(0x20);
  227. 		Oled_Write_Cmd(0x02);
  228. 		Oled_Screen_Clear();
  229.  
  230. 		Oled_Write_Cmd(0xB0);
  231. 		Oled_Write_Cmd(0x00);
  232. 		Oled_Write_Cmd(0x10);
  233.  
  234. 		for(i=0;i<16;i++){
  235. 			Oled_Write_Data(x1[i]);
  236. 		}
  237. 		for(i=0;i<16;i++){
  238. 			Oled_Write_Data(d1[i]);
  239. 		}
  240.  
  241. 		Oled_Write_Cmd(0xB1);
  242. 		Oled_Write_Cmd(0x00);
  243. 		Oled_Write_Cmd(0x10);
  244.  
  245. 		for(i=0;i<16;i++){
  246. 			Oled_Write_Data(x2[i]);
  247. 		}
  248. 		for(i=0;i<16;i++){
  249. 			Oled_Write_Data(d2[i]);
  250. 		}
  251.  
  252. }
  253.  
  254. void Oled_Show_left()
  255. {
  256. 		unsigned char  i;
  257.  
  258. 		Oled_Init();
  259.  
  260. 		Oled_Write_Cmd(0x20);
  261. 		Oled_Write_Cmd(0x02);
  262. 		Oled_Screen_Clear();
  263.  
  264. 		Oled_Write_Cmd(0xB0);
  265. 		Oled_Write_Cmd(0x00);
  266. 		Oled_Write_Cmd(0x10);
  267.  
  268. 		for(i=0;i<16;i++){
  269. 			Oled_Write_Data(x1[i]);
  270. 		}
  271. 		for(i=0;i<16;i++){
  272. 			Oled_Write_Data(l1[i]);
  273. 		}
  274.  
  275. 		Oled_Write_Cmd(0xB1);
  276. 		Oled_Write_Cmd(0x00);
  277. 		Oled_Write_Cmd(0x10);
  278.  
  279. 		for(i=0;i<16;i++){
  280. 			Oled_Write_Data(x2[i]);
  281. 		}
  282. 		for(i=0;i<16;i++){
  283. 			Oled_Write_Data(l2[i]);
  284. 		}
  285.  
  286. }
  287.  
  288. void Oled_Show_right()
  289. {
  290. 		unsigned char  i;
  291.  
  292. 		Oled_Init();
  293.  
  294. 		Oled_Write_Cmd(0x20);
  295. 		Oled_Write_Cmd(0x02);
  296. 		Oled_Screen_Clear();
  297.  
  298. 		Oled_Write_Cmd(0xB0);
  299. 		Oled_Write_Cmd(0x00);
  300. 		Oled_Write_Cmd(0x10);
  301.  
  302. 		for(i=0;i<16;i++){
  303. 			Oled_Write_Data(x1[i]);
  304. 		}
  305. 		for(i=0;i<16;i++){
  306. 			Oled_Write_Data(r1[i]);
  307. 		}
  308.  
  309. 		Oled_Write_Cmd(0xB1);
  310. 		Oled_Write_Cmd(0x00);
  311. 		Oled_Write_Cmd(0x10);
  312.  
  313. 		for(i=0;i<16;i++){
  314. 			Oled_Write_Data(x2[i]);
  315. 		}
  316. 		for(i=0;i<16;i++){
  317. 			Oled_Write_Data(r2[i]);
  318. 		}
  319.  
  320. }
  321.  
  322. void Oled_Show_front()
  323. {
  324. 		unsigned char  i;
  325.  
  326. 		Oled_Init();
  327.  
  328. 		Oled_Write_Cmd(0x20);
  329. 		Oled_Write_Cmd(0x02);
  330. 		Oled_Screen_Clear();
  331.  
  332. 		Oled_Write_Cmd(0xB0);
  333. 		Oled_Write_Cmd(0x00);
  334. 		Oled_Write_Cmd(0x10);
  335.  
  336. 		for(i=0;i<16;i++){
  337. 			Oled_Write_Data(x1[i]);
  338. 		}
  339. 		for(i=0;i<16;i++){
  340. 			Oled_Write_Data(f1[i]);
  341. 		}
  342.  
  343. 		Oled_Write_Cmd(0xB1);
  344. 		Oled_Write_Cmd(0x00);
  345. 		Oled_Write_Cmd(0x10);
  346.  
  347. 		for(i=0;i<16;i++){
  348. 			Oled_Write_Data(x2[i]);
  349. 		}
  350. 		for(i=0;i<16;i++){
  351. 			Oled_Write_Data(f2[i]);
  352. 		}
  353.  
  354. }
  355.  
  356. void Oled_Show_behind()
  357. {
  358. 		unsigned char  i;
  359.  
  360. 		Oled_Init();
  361.  
  362. 		Oled_Write_Cmd(0x20);
  363. 		Oled_Write_Cmd(0x02);
  364. 		Oled_Screen_Clear();
  365.  
  366. 		Oled_Write_Cmd(0xB0);
  367. 		Oled_Write_Cmd(0x00);
  368. 		Oled_Write_Cmd(0x10);
  369.  
  370. 		for(i=0;i<16;i++){
  371. 			Oled_Write_Data(x1[i]);
  372. 		}
  373. 		for(i=0;i<16;i++){
  374. 			Oled_Write_Data(b1[i]);
  375. 		}
  376.  
  377. 		Oled_Write_Cmd(0xB1);
  378. 		Oled_Write_Cmd(0x00);
  379. 		Oled_Write_Cmd(0x10);
  380.  
  381. 		for(i=0;i<16;i++){
  382. 			Oled_Write_Data(x2[i]);
  383. 		}
  384. 		for(i=0;i<16;i++){
  385. 			Oled_Write_Data(b2[i]);
  386. 		}
  387.  
  388. }

oled.h

  1. #ifndef __OLED_H__
  2. #define __OLED_H__
  3.  
  4. void Oled_Write_Cmd(uint8_t dataCmd);
  5.  
  6. void Oled_Write_Data(uint8_t dataData);
  7.  
  8. void Oled_Init(void);
  9.  
  10. void Oled_Screen_Clear(void);
  11.  
  12. // oled显示封装
  13. void Oled_Show_open();
  14. void Oled_Show_close();
  15. void Oled_Show_up();
  16. void Oled_Show_down();
  17. void Oled_Show_left();
  18. void Oled_Show_right();
  19. void Oled_Show_front();
  20. void Oled_Show_behind();
  21.  
  22. #endif

main.c

  1. uint16_t adc_dma[8];//DMA搬运的ADC采集值
  2.  
  3. uint8_t angle[4] = {45,45,180,135};//舵机角度
  4.  
  5. uint8_t cnt = 0;//计数用，定时串口打印信息
  6.  
  7.  
  8. //覆写printf，用于串口打印数据
  9. int fputc(int ch, FILE *f)
  10. {      
  11.     unsigned char temp[1]={ch};
  12.     HAL_UART_Transmit(&huart1,temp,1,0xffff);  
  13.     return ch;
  14. }
  15.  
  16. //int main
  17.  
  18.     //开始ADC和DMA采集
  19. 	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_dma,4);
  20. 	
  21. 	//开启4路PWM
  22. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  23. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  24. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  25. 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  26. 	
  27. 	//延时半秒，系统稳定一下
  28. 	HAL_Delay(500);
  29. 	printf("test\r\n");
  30. 	
  31.   while (1)
  32.   {
  33. 		
  34. 		sg90_A();
  35. 		sg90_B();
  36. 		sg90_C();
  37. 		sg90_D();
  38. 		
  39. 		//输出PWM波使舵机运动
  40. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, Angle(angle[0]));
  41. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, Angle(angle[1]));
  42. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_3, Angle(angle[2]));
  43. 		__HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_4, Angle(angle[3]));
  44. 		
  45. 		cnt++;//计数，每循环一次+1
  46. 		if(cnt>= 50)//循环50次，每次20ms，即一共1s。每一秒发送一次数据
  47. 		{
  48. 			printf("Angle = {%d, %d, %d, %d}\r\n",angle[0],angle[1],angle[2],angle[3]);
  49. 			cnt = 0;
  50. 		}
  51. 		HAL_Delay(20);//每20ms循环一次（改成15更流畅）
  52. 		
  53. 	}

2.示教器控制

示教器控制在这里我用上面讲到的四个旋钮电位器模块实现，跟上面摇杆控制一样只需要开启四路ADC采集，代码跟摇杆控制基本差不多，新增加一个函数封装把采集的模拟值转换为角度，即0~4095 变为 0~180，除以22.75即可

在pwm.c上新增加一个转换函数

  1.  
  2. void translate()//直接用8通道就是adc_dma[4~7]
  3. {
  4. 	angle[3] = (uint8_t)((double)adc_dma[0] / 22.75)/2;
  5. 	angle[2] = (uint8_t)((double)adc_dma[1] / 22.75);
  6. 	angle[1] = (uint8_t)((double)adc_dma[2] / 22.75) - 10;
  7. 	angle[0] = 180 - (uint8_t)((double)adc_dma[3] / 22.75);//电位器装反，改为 180 - 即可
  8. }

在main.c上增加打印调试信息在while(1)循环里面

printf("adc_dma = {%d, %d, %d, %d}\r\n",adc_dma[0],adc_dma[1],adc_dma[2],adc_dma[3]);

3.蓝牙控制

使用蓝牙模块，打开串口中断，用串口调试助手查看中断测试收发的数据,只需要新增加串口接收中断代码和在原先的pwm.c上面做一些修改

usart.c

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

pwm.c

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

五、裸机与FreeRTOS

移植 FreeRTOS 到 STM32F103C8T6上我们可以手动移植或者使用CubeMX快速移植，在这里我用CubeMX快速移植，具体介绍可看我之前写过的文章，链接如下：CubeMx快速移植FreeRTOS

接着我们要创建三个任务，一个任务负责角度信息处理，一个任务负责串口收发数据，一个任务负责显示OLED屏幕，具体创建删除任务介绍可看我之前写过的文章，链接如下：任务的创建和删除

1.CubeMX配置

2.移植裸机三种控制代码

在这里我们只需要在CubeMX生成的freertos.c文件中移植我们裸机控制的代码放在对应的任务中，可自行进行代码扩展，例如：  

六、项目演示视频

四轴机械臂演示视频

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/405228
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号