STM32之智能小车，手把手从0到1，模块化编程

小车介绍

本博文将会从0到1实现一个智能小车，该小车实现功能：1. 摇头避障模式、2. 跟随模式、3. 循迹模式、4. 小车测速并显示在OLED屏幕、5. 语音控制小车等等。

硬件组成

STM32F103开发板、小车套件、L9110S电机模块、超声波模块（HC-SR04）、sg90舵机、测速模块、循迹模块、红外避障模块等等（下面有详细介绍）

模块化编程

小车采用模块化编程循序渐进，即每实现新的功能小车需要复制前一种功能小车的文件夹来进行修改，否则会因为丢失某些文件导致小车功能缺失。

移动小车

让小车动起来。

硬件组成

L9110S电机模块

L9110S电机模块用来驱动两个电机，如果需要控制四个电机则需要两个L9110S电机模块。

  • 当B-1A为高电平，B-2A为低电平时，电机反转或正转。

  • 当B-1A为低电平，B-2A为高电平时，电机正转或反转。

  • 当B-1A为低电平，B-2A为低电平时，电机不转。

  • A-1A、A-1B同理。

  • 电机的正转和反转与跟电机的接线不同而不同，注意自己调试。

L9110S电机模块与STM32F103板子接线

  • B-1A <-> PB0

  • B-2A <-> PA0

  • A-1A <-> PB2

  • A-1B <-> PA1

STM32CubeMX相关配置

配置SYS

配置RCC

配置GPIO

配置PA0引脚、PA1引脚、PB0引脚、PB2引脚输出高电平。

文件编写

添加文件car.c

  1.  
  2. #include "gpio.h"
  3.  
  4. void car_goForward()
  5. {
  6.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
  7.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);
  8.  
  9.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
  10.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
  11. }
  12.  
  13. void car_goBack()
  14. {
  15.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
  16.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
  17.  
  18.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET);
  19.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
  20. }
  21.  
  22. void car_goStop()
  23. {
  24.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
  25.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
  26.  
  27.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
  28.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
  29. }
  30.  
  31. void car_goRight()
  32. {
  33.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
  34.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);
  35.  
  36.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
  37.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
  38. }
  39.  
  40. void car_goLeft()
  41. {
  42.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
  43.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
  44.  
  45.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
  46.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
  47. }

添加文件car.h

  1.  
  2. void car_goForward(void);
  3.  
  4. void car_goBack(void);
  5.  
  6. void car_goStop(void);
  7.  
  8. void car_goRight(void);
  9.     
  10. void car_goLeft(void);

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "gpio.h"
  23. #include "car.h"
  24.  
  25. /* Private includes ----------------------------------------------------------*/
  26. /* USER CODE BEGIN Includes */
  27.  
  28. /* USER CODE END Includes */
  29.  
  30. /* Private typedef -----------------------------------------------------------*/
  31. /* USER CODE BEGIN PTD */
  32.  
  33. /* USER CODE END PTD */
  34.  
  35. /* Private define ------------------------------------------------------------*/
  36. /* USER CODE BEGIN PD */
  37. /* USER CODE END PD */
  38.  
  39. /* Private macro -------------------------------------------------------------*/
  40. /* USER CODE BEGIN PM */
  41.  
  42. /* USER CODE END PM */
  43.  
  44. /* Private variables ---------------------------------------------------------*/
  45.  
  46. /* USER CODE BEGIN PV */
  47.  
  48. /* USER CODE END PV */
  49.  
  50. /* Private function prototypes -----------------------------------------------*/
  51. void SystemClock_Config(void);
  52. /* USER CODE BEGIN PFP */
  53.  
  54. /* USER CODE END PFP */
  55.  
  56. /* Private user code ---------------------------------------------------------*/
  57. /* USER CODE BEGIN 0 */
  58.  
  59. /* USER CODE END 0 */
  60.  
  61. /**
  62.  * @brief  The application entry point.
  63.  * @retval int
  64.  */
  65. int main(void)
  66. {
  67.     /* USER CODE BEGIN 1 */
  68.  
  69.     /* USER CODE END 1 */
  70.  
  71.     /* MCU Configuration--------------------------------------------------------*/
  72.  
  73.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  74.     HAL_Init();
  75.  
  76.     /* USER CODE BEGIN Init */
  77.  
  78.     /* USER CODE END Init */
  79.  
  80.     /* Configure the system clock */
  81.     SystemClock_Config();
  82.  
  83.     /* USER CODE BEGIN SysInit */
  84.  
  85.     /* USER CODE END SysInit */
  86.  
  87.     /* Initialize all configured peripherals */
  88.     MX_GPIO_Init();
  89.     /* USER CODE BEGIN 2 */
  90.  
  91.     /* USER CODE END 2 */
  92.  
  93.     /* Infinite loop */
  94.     /* USER CODE BEGIN WHILE */
  95.     while (1)
  96.     {
  97.         /* USER CODE END WHILE */
  98.  
  99.         car_goForward();
  100.         HAL_Delay(1000);
  101.         car_goStop();
  102.         HAL_Delay(1000);
  103.  
  104.         /* USER CODE BEGIN 3 */
  105.     }
  106.     /* USER CODE END 3 */
  107. }
  108.  
  109. /**
  110.  * @brief System Clock Configuration
  111.  * @retval None
  112.  */
  113. void SystemClock_Config(void)
  114. {
  115.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  116.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  117.  
  118.     /** Initializes the RCC Oscillators according to the specified parameters
  119.      * in the RCC_OscInitTypeDef structure.
  120.      */
  121.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  122.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  123.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  124.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  125.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  126.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  127.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  128.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  129.     {
  130.         Error_Handler();
  131.     }
  132.  
  133.     /** Initializes the CPU, AHB and APB buses clocks
  134.      */
  135.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  136.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  137.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  138.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  139.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  140.  
  141.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  142.     {
  143.         Error_Handler();
  144.     }
  145. }
  146.  
  147. /* USER CODE BEGIN 4 */
  148.  
  149. /* USER CODE END 4 */
  150.  
  151. /**
  152.  * @brief  This function is executed in case of error occurrence.
  153.  * @retval None
  154.  */
  155. void Error_Handler(void)
  156. {
  157.     /* USER CODE BEGIN Error_Handler_Debug */
  158.     /* User can add his own implementation to report the HAL error return state */
  159.     __disable_irq();
  160.     while (1)
  161.     {
  162.     }
  163.     /* USER CODE END Error_Handler_Debug */
  164. }
  165.  
  166. #ifdef USE_FULL_ASSERT
  167. /**
  168.  * @brief  Reports the name of the source file and the source line number
  169.  *         where the assert_param error has occurred.
  170.  * @param  file: pointer to the source file name
  171.  * @param  line: assert_param error line source number
  172.  * @retval None
  173.  */
  174. void assert_failed(uint8_t *file, uint32_t line)
  175. {
  176.     /* USER CODE BEGIN 6 */
  177.     /* User can add his own implementation to report the file name and line number,
  178.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  179.     /* USER CODE END 6 */
  180. }
  181. #endif /* USE_FULL_ASSERT */

USART小车

利用USART接收串口信息，实现蓝牙遥控小车等功能。

STM32CubeMX相关配置

配置USART1

配置NVIC

使用Micro库

只要映射了printf用来发送数据去串口都要使用这个库。

文件编写

修改文件usart.c

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file    usart.c
  6.  * @brief   This file provides code for the configuration
  7.  *          of the USART instances.
  8.  ******************************************************************************
  9.  * @attention
  10.  *
  11.  * Copyright (c) 2023 STMicroelectronics.
  12.  * All rights reserved.
  13.  *
  14.  * This software is licensed under terms that can be found in the LICENSE file
  15.  * in the root directory of this software component.
  16.  * If no LICENSE file comes with this software, it is provided AS-IS.
  17.  *
  18.  ******************************************************************************
  19.  */
  20. /* USER CODE END Header */
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "usart.h"
  23.  
  24. /* USER CODE BEGIN 0 */
  25.  
  26. #include 
  27. #include 
  28.  
  29. #include "car.h"
  30.  
  31. #define USART_REC_LEN 200
  32.  
  33. // 串口接收缓存（1字节）
  34. uint8_t buf = 0;
  35.  
  36. uint8_t UART1_RX_Buffer[USART_REC_LEN]; // 接收缓冲，串口接收的数据存放地点
  37.  
  38. // 串口接收状态，16位
  39. uint16_t UART1_RX_STA = 0;
  40. // bit15： 如果是1表示接收完成
  41. // bit14： 如果是1表示接收到回车(0x0d)
  42. // bit13~bit0： 接收到的有效字节数目
  43.  
  44. /* USER CODE END 0 */
  45.  
  46. UART_HandleTypeDef huart1;
  47.  
  48. /* USART1 init function */
  49.  
  50. void MX_USART1_UART_Init(void)
  51. {
  52.  
  53.     /* USER CODE BEGIN USART1_Init 0 */
  54.  
  55.     /* USER CODE END USART1_Init 0 */
  56.  
  57.     /* USER CODE BEGIN USART1_Init 1 */
  58.  
  59.     /* USER CODE END USART1_Init 1 */
  60.     huart1.Instance = USART1;
  61.     huart1.Init.BaudRate = 115200;
  62.     huart1.Init.WordLength = UART_WORDLENGTH_8B;
  63.     huart1.Init.StopBits = UART_STOPBITS_1;
  64.     huart1.Init.Parity = UART_PARITY_NONE;
  65.     huart1.Init.Mode = UART_MODE_TX_RX;
  66.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  67.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  68.     if (HAL_UART_Init(&huart1) != HAL_OK)
  69.     {
  70.         Error_Handler();
  71.     }
  72.     /* USER CODE BEGIN USART1_Init 2 */
  73.  
  74.     /* 开启串口1的接收中断 */
  75.     HAL_UART_Receive_IT(&huart1, &buf, 1); /* 每接收一个串口数据调用一次串口接收完成回调函数 */
  76.  
  77.     /* USER CODE END USART1_Init 2 */
  78. }
  79.  
  80. void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
  81. {
  82.  
  83.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  84.     if (uartHandle->Instance == USART1)
  85.     {
  86.         /* USER CODE BEGIN USART1_MspInit 0 */
  87.  
  88.         /* USER CODE END USART1_MspInit 0 */
  89.         /* USART1 clock enable */
  90.         __HAL_RCC_USART1_CLK_ENABLE();
  91.  
  92.         __HAL_RCC_GPIOA_CLK_ENABLE();
  93.         /**USART1 GPIO Configuration
  94.         PA9     ------> USART1_TX
  95.         PA10     ------> USART1_RX
  96.         */
  97.         GPIO_InitStruct.Pin = GPIO_PIN_9;
  98.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  99.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  100.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  101.  
  102.         GPIO_InitStruct.Pin = GPIO_PIN_10;
  103.         GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  104.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  105.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  106.  
  107.         /* USART1 interrupt Init */
  108.         HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
  109.         HAL_NVIC_EnableIRQ(USART1_IRQn);
  110.         /* USER CODE BEGIN USART1_MspInit 1 */
  111.  
  112.         /* USER CODE END USART1_MspInit 1 */
  113.     }
  114. }
  115.  
  116. void HAL_UART_MspDeInit(UART_HandleTypeDef *uartHandle)
  117. {
  118.  
  119.     if (uartHandle->Instance == USART1)
  120.     {
  121.         /* USER CODE BEGIN USART1_MspDeInit 0 */
  122.  
  123.         /* USER CODE END USART1_MspDeInit 0 */
  124.         /* Peripheral clock disable */
  125.         __HAL_RCC_USART1_CLK_DISABLE();
  126.  
  127.         /**USART1 GPIO Configuration
  128.         PA9     ------> USART1_TX
  129.         PA10     ------> USART1_RX
  130.         */
  131.         HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9 | GPIO_PIN_10);
  132.  
  133.         /* USART1 interrupt Deinit */
  134.         HAL_NVIC_DisableIRQ(USART1_IRQn);
  135.         /* USER CODE BEGIN USART1_MspDeInit 1 */
  136.  
  137.         /* USER CODE END USART1_MspDeInit 1 */
  138.     }
  139. }
  140.  
  141. /* USER CODE BEGIN 1 */
  142.  
  143. /* 重写stdio.h文件中的prinft()里的fputc()函数 */
  144. int fputc(int my_data, FILE *p)
  145. {
  146.     unsigned char temp = my_data;
  147.     // 改写后，使用printf()函数会将数据通过串口一发送出去
  148.     HAL_UART_Transmit(&huart1, &temp, 1, 0xffff); // 0xfffff为最大超时时间
  149.     return my_data;
  150. }
  151.  
  152. /* 串口接收完成回调函数 */
  153. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  154. {
  155.     // 判断中断是哪个串口触发的
  156.     if (huart->Instance == USART1)
  157.     {
  158.  
  159.         // 判断接收是否完成，即判断UART1_RX_STA的bit15是否为1
  160.         if (!(UART1_RX_STA & 0x8000))
  161.         { // 如果没接收完成就进入接收流程
  162.  
  163.             // 判断是否接收到回车0x0d
  164.             if (UART1_RX_STA & 0x4000)
  165.             {
  166.  
  167.                 // 判断是否接收到换行0x0a
  168.                 if (buf == 0x0a)
  169.                 {
  170.  
  171.                     // 如果回车和换行都接收到了，则表示接收完成,即把bit15拉高
  172.                     UART1_RX_STA |= 0x8000;
  173.                 }
  174.                 else
  175.                 { // 如果接收到回车0x0d没有接收到换行0x0a
  176.  
  177.                     // 则认为接收错误，重新开始接收
  178.                     UART1_RX_STA = 0;
  179.                 }
  180.             }
  181.             else
  182.             { // 如果没有接收到回车0x0d
  183.  
  184.                 // 则判断收到的这个字符是否是回车0x0d
  185.                 if (buf == 0x0d)
  186.                 {
  187.  
  188.                     // 如果这个字符是回车，则将将bit14拉高，表示接收到回车
  189.                     UART1_RX_STA |= 0x4000;
  190.                 }
  191.                 else
  192.                 { // 如果不是回车
  193.  
  194.                     // 则将这个字符存放到缓存数组中
  195.                     UART1_RX_Buffer[UART1_RX_STA & 0x3ffff] = buf;
  196.                     UART1_RX_STA++;
  197.  
  198.                     // 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
  199.                     if (UART1_RX_STA > USART_REC_LEN - 1)
  200.                     {
  201.                         UART1_RX_STA = 0;
  202.                     }
  203.                 }
  204.             }
  205.         }
  206.         // 如果接收完成则重新开启串口1的接收中断
  207.         HAL_UART_Receive_IT(&huart1, &buf, 1);
  208.     }
  209. }
  210.  
  211. /* 对串口接收数据的处理 */
  212. void usart1_receive_data_handle()
  213. {
  214.     /* 判断判断串口是否接收完成 */
  215.     if (UART1_RX_STA & 0x8000)
  216.     {
  217.         printf("接收完成
");
  218.  
  219.         // 串口接收完数据后，对串口数据进行处理
  220.         if (!strcmp((const char *)UART1_RX_Buffer, "forward"))
  221.         {
  222.             printf("前进
");
  223.             car_goForward();
  224.         }
  225.         else if (!strcmp((const char *)UART1_RX_Buffer, "back"))
  226.         {
  227.             printf("后退
");
  228.             car_goBack();
  229.         }
  230.         else if (!strcmp((const char *)UART1_RX_Buffer, "left"))
  231.         {
  232.             printf("左转
");
  233.             car_goLeft();
  234.         }
  235.         else if (!strcmp((const char *)UART1_RX_Buffer, "right"))
  236.         {
  237.             printf("右转
");
  238.             car_goRight();
  239.         }
  240.         else if (!strcmp((const char *)UART1_RX_Buffer, "stop"))
  241.         {
  242.             printf("停止
");
  243.             car_goStop();
  244.         }
  245.         // 接收到其他数据，进行报错
  246.         else
  247.         {
  248.             if (UART1_RX_Buffer[0] != '')
  249.             {
  250.                 printf("%s
", "输入错误，请重新输入");
  251.             }
  252.         }
  253.  
  254.         // 换行，重新开始下一次接收
  255.         memset(UART1_RX_Buffer, 0, USART_REC_LEN);
  256.         // printf("
");
  257.         UART1_RX_STA = 0;
  258.     }
  259. }
  260.  
  261. /* USER CODE END 1 */

修改文件usart.h

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file    usart.h
  6.  * @brief   This file contains all the function prototypes for
  7.  *          the usart.c file
  8.  ******************************************************************************
  9.  * @attention
  10.  *
  11.  * Copyright (c) 2023 STMicroelectronics.
  12.  * All rights reserved.
  13.  *
  14.  * This software is licensed under terms that can be found in the LICENSE file
  15.  * in the root directory of this software component.
  16.  * If no LICENSE file comes with this software, it is provided AS-IS.
  17.  *
  18.  ******************************************************************************
  19.  */
  20. /* USER CODE END Header */
  21. /* Define to prevent recursive inclusion -------------------------------------*/
  22. #ifndef __USART_H__
  23. #define __USART_H__
  24.  
  25. #ifdef __cplusplus
  26. extern "C"
  27. {
  28. #endif
  29.  
  30. /* Includes ------------------------------------------------------------------*/
  31. #include "main.h"
  32.  
  33.     /* USER CODE BEGIN Includes */
  34.  
  35.     /* USER CODE END Includes */
  36.  
  37.     extern UART_HandleTypeDef huart1;
  38.  
  39.     /* USER CODE BEGIN Private defines */
  40.  
  41.     /* USER CODE END Private defines */
  42.  
  43.     void MX_USART1_UART_Init(void);
  44.  
  45.     /* USER CODE BEGIN Prototypes */
  46.  
  47.     void usart1_receive_data_handle(void);
  48.  
  49.     /* USER CODE END Prototypes */
  50.  
  51. #ifdef __cplusplus
  52. }
  53. #endif
  54.  
  55. #endif /* __USART_H__ */

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "usart.h"
  23. #include "gpio.h"
  24.  
  25. /* Private includes ----------------------------------------------------------*/
  26. /* USER CODE BEGIN Includes */
  27.  
  28. #include 
  29. #include "car.h"
  30.  
  31. /* USER CODE END Includes */
  32.  
  33. /* Private typedef -----------------------------------------------------------*/
  34. /* USER CODE BEGIN PTD */
  35.  
  36. /* USER CODE END PTD */
  37.  
  38. /* Private define ------------------------------------------------------------*/
  39. /* USER CODE BEGIN PD */
  40. /* USER CODE END PD */
  41.  
  42. /* Private macro -------------------------------------------------------------*/
  43. /* USER CODE BEGIN PM */
  44.  
  45. /* USER CODE END PM */
  46.  
  47. /* Private variables ---------------------------------------------------------*/
  48.  
  49. /* USER CODE BEGIN PV */
  50.  
  51. /* USER CODE END PV */
  52.  
  53. /* Private function prototypes -----------------------------------------------*/
  54. void SystemClock_Config(void);
  55. /* USER CODE BEGIN PFP */
  56.  
  57. /* USER CODE END PFP */
  58.  
  59. /* Private user code ---------------------------------------------------------*/
  60. /* USER CODE BEGIN 0 */
  61.  
  62. /* USER CODE END 0 */
  63.  
  64. /**
  65.  * @brief  The application entry point.
  66.  * @retval int
  67.  */
  68. int main(void)
  69. {
  70.     /* USER CODE BEGIN 1 */
  71.  
  72.     /* USER CODE END 1 */
  73.  
  74.     /* MCU Configuration--------------------------------------------------------*/
  75.  
  76.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  77.     HAL_Init();
  78.  
  79.     /* USER CODE BEGIN Init */
  80.  
  81.     /* USER CODE END Init */
  82.  
  83.     /* Configure the system clock */
  84.     SystemClock_Config();
  85.  
  86.     /* USER CODE BEGIN SysInit */
  87.  
  88.     /* USER CODE END SysInit */
  89.  
  90.     /* Initialize all configured peripherals */
  91.     MX_GPIO_Init();
  92.     MX_USART1_UART_Init();
  93.     /* USER CODE BEGIN 2 */
  94.  
  95.     printf("haozige
");
  96.  
  97.     /* USER CODE END 2 */
  98.  
  99.     /* Infinite loop */
  100.     /* USER CODE BEGIN WHILE */
  101.     while (1)
  102.     {
  103.         /* USER CODE END WHILE */
  104.  
  105.         /* USER CODE BEGIN 3 */
  106.  
  107.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  108.         HAL_Delay(40);
  109.     }
  110.     /* USER CODE END 3 */
  111. }
  112.  
  113. /**
  114.  * @brief System Clock Configuration
  115.  * @retval None
  116.  */
  117. void SystemClock_Config(void)
  118. {
  119.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  120.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  121.  
  122.     /** Initializes the RCC Oscillators according to the specified parameters
  123.      * in the RCC_OscInitTypeDef structure.
  124.      */
  125.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  126.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  127.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  128.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  129.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  130.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  131.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  132.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  133.     {
  134.         Error_Handler();
  135.     }
  136.  
  137.     /** Initializes the CPU, AHB and APB buses clocks
  138.      */
  139.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  140.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  141.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  142.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  143.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  144.  
  145.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  146.     {
  147.         Error_Handler();
  148.     }
  149. }
  150.  
  151. /* USER CODE BEGIN 4 */
  152.  
  153. /* USER CODE END 4 */
  154.  
  155. /**
  156.  * @brief  This function is executed in case of error occurrence.
  157.  * @retval None
  158.  */
  159. void Error_Handler(void)
  160. {
  161.     /* USER CODE BEGIN Error_Handler_Debug */
  162.     /* User can add his own implementation to report the HAL error return state */
  163.     __disable_irq();
  164.     while (1)
  165.     {
  166.     }
  167.     /* USER CODE END Error_Handler_Debug */
  168. }
  169.  
  170. #ifdef USE_FULL_ASSERT
  171. /**
  172.  * @brief  Reports the name of the source file and the source line number
  173.  *         where the assert_param error has occurred.
  174.  * @param  file: pointer to the source file name
  175.  * @param  line: assert_param error line source number
  176.  * @retval None
  177.  */
  178. void assert_failed(uint8_t *file, uint32_t line)
  179. {
  180.     /* USER CODE BEGIN 6 */
  181.     /* User can add his own implementation to report the file name and line number,
  182.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  183.     /* USER CODE END 6 */
  184. }
  185. #endif /* USE_FULL_ASSERT */

调速并测速小车

使用TIM2的通道1、通道2给左右电机输入不同占空比的PWM来达到轮子调速的目的，并使用测速模块将轮子当前速度显示在OLED屏，OLED屏使用软件模拟的I2C来驱动。

硬件组成

测速模块

  • 发射的红外线被物体遮挡时，输出高电平，发射的红外线没被物体遮挡时，输出低电平。

  • 即有物体高电平，没物体低电平。

  • 当搭配小车测速盘，会形成下降沿（有遮挡高电平，没遮挡低电平）。

模块与STM32F103板子接线

  • 测速模块DO引脚 <-> PB13

  • OLED屏SCL引脚 <-> PB6

  • OLED屏SDA引脚 <-> PB7

STM32CubeMX相关配置

配置GPIO

  • 配置PB13引脚为引脚中断。

  • 配置PB6引脚输出高电平。

  • 重置PA0、PA1引脚的状态，防止待会配置定时器2通道输出PWM时映射到其他引脚。

配置定时器2和定时器3

配置定时器2的通道1和通道2输出PWM，用来给电机调速。

配置定时器3定时时间为1s。

配置NVIC

  • 打开定时器3和PB13引脚的中断。

  • 修改定时器3响应中断优先级为4，PB13引脚中断响应优先级为3。

文件编写

修改文件car.c

利用PWM修改在一个调速周期内低电平占用的时间来达到轮子调速的效果。

  1.  
  2. #include "gpio.h"
  3. #include "tim.h"
  4.  
  5. /* B_1A、B-2A控制左边电机，A-1A、A-1B控制右边电机 */
  6. #define B_1A_LOW HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET) /* PB0 */
  7. #define B_1A_HIGH HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET)
  8.  
  9. #define A_1A_LOW HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET) /* PB2 */
  10. #define A_1A_HIGH HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET)
  11.  
  12. /* 轮子速度：0~19 */
  13. void car_goForward()
  14. {
  15.     B_1A_HIGH;
  16.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 19); // B_2A_LOW，PA0
  17.  
  18.     A_1A_HIGH;
  19.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 19); // A_1B_LOW，PA1
  20. }
  21.  
  22. void car_goBack()
  23. {
  24.     B_1A_LOW;
  25.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 0); // B_2A_HIGH;
  26.  
  27.     A_1A_LOW;
  28.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 0); // A_1B_HIGH;
  29. }
  30.  
  31. void car_goStop()
  32. {
  33.     B_1A_HIGH;
  34.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 0); // B_2A_HIGH;
  35.  
  36.     A_1A_HIGH;
  37.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 0); // A_1B_HIGH;
  38. }
  39.  
  40. void car_goRight()
  41. {
  42.     B_1A_HIGH;
  43.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 19); // B_2A_LOW;
  44.  
  45.     A_1A_HIGH;
  46.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 0); // A_1B_HIGH;
  47. }
  48.  
  49. void car_goLeft()
  50. {
  51.     B_1A_HIGH;
  52.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 0); // B_2A_HIGH;
  53.  
  54.     A_1A_HIGH;
  55.     __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 19); // A_1B_LOW;
  56. }

修改文件tim.c

启动TIM2的通道1、通道2的PWM，启动TIM3并使能中断。

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file    tim.c
  6.  * @brief   This file provides code for the configuration
  7.  *          of the TIM instances.
  8.  ******************************************************************************
  9.  * @attention
  10.  *
  11.  * Copyright (c) 2023 STMicroelectronics.
  12.  * All rights reserved.
  13.  *
  14.  * This software is licensed under terms that can be found in the LICENSE file
  15.  * in the root directory of this software component.
  16.  * If no LICENSE file comes with this software, it is provided AS-IS.
  17.  *
  18.  ******************************************************************************
  19.  */
  20. /* USER CODE END Header */
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "tim.h"
  23.  
  24. /* USER CODE BEGIN 0 */
  25.  
  26. /* USER CODE END 0 */
  27.  
  28. TIM_HandleTypeDef htim2;
  29. TIM_HandleTypeDef htim3;
  30.  
  31. /* TIM2 init function */
  32. void MX_TIM2_Init(void)
  33. {
  34.  
  35.     /* USER CODE BEGIN TIM2_Init 0 */
  36.  
  37.     /* USER CODE END TIM2_Init 0 */
  38.  
  39.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  40.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  41.     TIM_OC_InitTypeDef sConfigOC = {0};
  42.  
  43.     /* USER CODE BEGIN TIM2_Init 1 */
  44.  
  45.     /* USER CODE END TIM2_Init 1 */
  46.     htim2.Instance = TIM2;
  47.     htim2.Init.Prescaler = 71;
  48.     htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  49.     htim2.Init.Period = 19;
  50.     htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  51.     htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  52.     if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  53.     {
  54.         Error_Handler();
  55.     }
  56.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  57.     if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  58.     {
  59.         Error_Handler();
  60.     }
  61.     if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  62.     {
  63.         Error_Handler();
  64.     }
  65.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  66.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  67.     if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  68.     {
  69.         Error_Handler();
  70.     }
  71.     sConfigOC.OCMode = TIM_OCMODE_PWM1;
  72.     sConfigOC.Pulse = 0;
  73.     sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  74.     sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  75.     if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  76.     {
  77.         Error_Handler();
  78.     }
  79.     if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  80.     {
  81.         Error_Handler();
  82.     }
  83.     /* USER CODE BEGIN TIM2_Init 2 */
  84.  
  85.     /* 启动B-2A、A-1B引脚的PWM */
  86.     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  87.     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  88.  
  89.     /* USER CODE END TIM2_Init 2 */
  90.     HAL_TIM_MspPostInit(&htim2);
  91. }
  92. /* TIM3 init function */
  93. void MX_TIM3_Init(void)
  94. {
  95.  
  96.     /* USER CODE BEGIN TIM3_Init 0 */
  97.  
  98.     /* USER CODE END TIM3_Init 0 */
  99.  
  100.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  101.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  102.  
  103.     /* USER CODE BEGIN TIM3_Init 1 */
  104.  
  105.     /* USER CODE END TIM3_Init 1 */
  106.     htim3.Instance = TIM3;
  107.     htim3.Init.Prescaler = 7199;
  108.     htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  109.     htim3.Init.Period = 9999;
  110.     htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  111.     htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  112.     if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  113.     {
  114.         Error_Handler();
  115.     }
  116.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  117.     if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  118.     {
  119.         Error_Handler();
  120.     }
  121.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  122.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  123.     if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  124.     {
  125.         Error_Handler();
  126.     }
  127.     /* USER CODE BEGIN TIM3_Init 2 */
  128.  
  129.     HAL_TIM_Base_Start_IT(&htim3);  /* 启动定时器3，并使能中断 */
  130.  
  131.     /* USER CODE END TIM3_Init 2 */
  132. }
  133.  
  134. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *tim_baseHandle)
  135. {
  136.  
  137.     if (tim_baseHandle->Instance == TIM2)
  138.     {
  139.         /* USER CODE BEGIN TIM2_MspInit 0 */
  140.  
  141.         /* USER CODE END TIM2_MspInit 0 */
  142.         /* TIM2 clock enable */
  143.         __HAL_RCC_TIM2_CLK_ENABLE();
  144.         /* USER CODE BEGIN TIM2_MspInit 1 */
  145.  
  146.         /* USER CODE END TIM2_MspInit 1 */
  147.     }
  148.     else if (tim_baseHandle->Instance == TIM3)
  149.     {
  150.         /* USER CODE BEGIN TIM3_MspInit 0 */
  151.  
  152.         /* USER CODE END TIM3_MspInit 0 */
  153.         /* TIM3 clock enable */
  154.         __HAL_RCC_TIM3_CLK_ENABLE();
  155.  
  156.         /* TIM3 interrupt Init */
  157.         HAL_NVIC_SetPriority(TIM3_IRQn, 4, 0);
  158.         HAL_NVIC_EnableIRQ(TIM3_IRQn);
  159.         /* USER CODE BEGIN TIM3_MspInit 1 */
  160.  
  161.         /* USER CODE END TIM3_MspInit 1 */
  162.     }
  163. }
  164. void HAL_TIM_MspPostInit(TIM_HandleTypeDef *timHandle)
  165. {
  166.  
  167.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  168.     if (timHandle->Instance == TIM2)
  169.     {
  170.         /* USER CODE BEGIN TIM2_MspPostInit 0 */
  171.  
  172.         /* USER CODE END TIM2_MspPostInit 0 */
  173.  
  174.         __HAL_RCC_GPIOA_CLK_ENABLE();
  175.         /**TIM2 GPIO Configuration
  176.         PA0-WKUP     ------> TIM2_CH1
  177.         PA1     ------> TIM2_CH2
  178.         */
  179.         GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1;
  180.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  181.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  182.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  183.  
  184.         /* USER CODE BEGIN TIM2_MspPostInit 1 */
  185.  
  186.         /* USER CODE END TIM2_MspPostInit 1 */
  187.     }
  188. }
  189.  
  190. void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *tim_baseHandle)
  191. {
  192.  
  193.     if (tim_baseHandle->Instance == TIM2)
  194.     {
  195.         /* USER CODE BEGIN TIM2_MspDeInit 0 */
  196.  
  197.         /* USER CODE END TIM2_MspDeInit 0 */
  198.         /* Peripheral clock disable */
  199.         __HAL_RCC_TIM2_CLK_DISABLE();
  200.         /* USER CODE BEGIN TIM2_MspDeInit 1 */
  201.  
  202.         /* USER CODE END TIM2_MspDeInit 1 */
  203.     }
  204.     else if (tim_baseHandle->Instance == TIM3)
  205.     {
  206.         /* USER CODE BEGIN TIM3_MspDeInit 0 */
  207.  
  208.         /* USER CODE END TIM3_MspDeInit 0 */
  209.         /* Peripheral clock disable */
  210.         __HAL_RCC_TIM3_CLK_DISABLE();
  211.  
  212.         /* TIM3 interrupt Deinit */
  213.         HAL_NVIC_DisableIRQ(TIM3_IRQn);
  214.         /* USER CODE BEGIN TIM3_MspDeInit 1 */
  215.  
  216.         /* USER CODE END TIM3_MspDeInit 1 */
  217.     }
  218. }
  219.  
  220. /* USER CODE BEGIN 1 */
  221.  
  222. /* USER CODE END 1 */

添加文件my_i2c.c

软件模拟I2C来驱动OLED屏显示，也可以使用硬件I2C，就不用此文件了。

  1.  
  2. #include "gpio.h"
  3.  
  4. #define SCL_HIGH HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET)
  5. #define SCL_LOW HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET)
  6.  
  7. #define SDA_INPUT SDA_GPIO_PB7_INIT(GPIO_MODE_INPUT)
  8. #define SDA_OUTPUT SDA_GPIO_PB7_INIT(GPIO_MODE_OUTPUT_PP)
  9.  
  10. #define SDA_HIGH HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_SET)
  11. #define SDA_LOW HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET)
  12. #define SDA_READ HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7)
  13.  
  14. /* 微秒延时函数：只适用F1系列72M主频 */
  15. void delay_us(uint32_t us)
  16. {
  17.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 4000000 * us);
  18.     while (delay--)
  19.     {
  20.         ;
  21.     }
  22. }
  23.  
  24. /* 配置PB7为输入引脚或者输出引脚 */
  25. void SDA_GPIO_PB7_INIT(uint32_t mode)
  26. {
  27.     // 打开时钟
  28.     __HAL_RCC_GPIOB_CLK_ENABLE();
  29.  
  30.     // 配置引脚
  31.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  32.  
  33.     GPIO_InitStruct.Pin = GPIO_PIN_7;
  34.     GPIO_InitStruct.Mode = mode; // 配置为输入（GPIO_MODE_INPUT）或输出（GPIO_MODE_OUTPUT_PP）
  35.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  36.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  37. }
  38.  
  39. /* 起始信号 */
  40. void IIC_start()
  41. {
  42.     SDA_OUTPUT; /* 配置SDA引脚为输出引脚 */
  43.     SCL_HIGH;
  44.     SDA_HIGH;
  45.     delay_us(5);
  46.     SDA_LOW;
  47.     delay_us(5);
  48.     SCL_LOW;
  49.     delay_us(5);
  50. }
  51.  
  52. /* 终止信号 */
  53. void IIC_stop()
  54. {
  55.     SDA_OUTPUT; /* 配置SDA引脚为输出引脚 */
  56.     SDA_LOW;
  57.     delay_us(5);
  58.     SCL_HIGH;
  59.     delay_us(5);
  60.     SDA_HIGH;
  61.     delay_us(5);
  62. }
  63.  
  64. /* 检测应答信号：ACK返回0，NACK返回1 */
  65. uint8_t IIC_wait_ack()
  66. {
  67.     SDA_OUTPUT; /* 配置SDA引脚为输出引脚 */
  68.     SDA_HIGH;    /* 释放数据线 */
  69.     delay_us(5);
  70.     SCL_HIGH; /* 从机返回ACK */
  71.     delay_us(5);
  72.  
  73.     SDA_INPUT; /* 配置SDA引脚为输入引脚 */
  74.                /* 读取SDA的电平 */
  75.     if (SDA_READ == GPIO_PIN_SET)
  76.     {
  77.         /* 如果是高电平则为NACK */
  78.         IIC_stop();
  79.         return 1;
  80.     }
  81.  
  82.     SCL_LOW; /* 结束应答信号的检测 */
  83.     delay_us(5);
  84.     return 0;
  85. }
  86.  
  87. /* 发送一个字节数据 */
  88. void IIC_send_byte(uint8_t data)
  89. {
  90.     SDA_OUTPUT; /* 配置SDA引脚为输出引脚 */
  91.     for (uint8_t i = 0; i < 8; i++)
  92.     {
  93.         /* 从最高位开始发送 */
  94.         if ((data & 0x80) >> 7)
  95.         {
  96.             SDA_HIGH;
  97.         }
  98.         else
  99.         {
  100.             SDA_LOW;
  101.         }
  102.         delay_us(5);
  103.         SCL_HIGH;
  104.         delay_us(5);
  105.         SCL_LOW;
  106.         data <<= 1; /* 将下一位移至最高位 */
  107.     }
  108.     SCL_HIGH; /* 发送完成，释放数据线*/
  109. }

添加文件my_i2c.h

  1.  
  2. #include "main.h"
  3.  
  4. void delay_us(uint32_t us);
  5.  
  6. void SDA_GPIO_PB7_INIT(uint32_t mode);
  7.  
  8. void IIC_start(void);
  9.  
  10. void IIC_stop(void);
  11.  
  12. uint8_t IIC_wait_ack(void);
  13.  
  14. void IIC_send_byte(uint8_t data);

添加文件oled.c

  1.  
  2. #include "my_i2c.h"
  3. #include 
  4.  
  5. // OLED的字符构造点阵
  6. unsigned char oledFont[] =
  7.     {
  8.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0
  9.         0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x30, 0x00, 0x00, 0x00, //! 1
  10.         0x00, 0x10, 0x0C, 0x06, 0x10, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //" 2
  11.         0x40, 0xC0, 0x78, 0x40, 0xC0, 0x78, 0x40, 0x00, 0x04, 0x3F, 0x04, 0x04, 0x3F, 0x04, 0x04, 0x00, // # 3
  12.         0x00, 0x70, 0x88, 0xFC, 0x08, 0x30, 0x00, 0x00, 0x00, 0x18, 0x20, 0xFF, 0x21, 0x1E, 0x00, 0x00, //$ 4
  13.         0xF0, 0x08, 0xF0, 0x00, 0xE0, 0x18, 0x00, 0x00, 0x00, 0x21, 0x1C, 0x03, 0x1E, 0x21, 0x1E, 0x00, //% 5
  14.         0x00, 0xF0, 0x08, 0x88, 0x70, 0x00, 0x00, 0x00, 0x1E, 0x21, 0x23, 0x24, 0x19, 0x27, 0x21, 0x10, //& 6
  15.         0x10, 0x16, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //' 7
  16.         0x00, 0x00, 0x00, 0xE0, 0x18, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x07, 0x18, 0x20, 0x40, 0x00, //( 8
  17.         0x00, 0x02, 0x04, 0x18, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x18, 0x07, 0x00, 0x00, 0x00, //) 9
  18.         0x40, 0x40, 0x80, 0xF0, 0x80, 0x40, 0x40, 0x00, 0x02, 0x02, 0x01, 0x0F, 0x01, 0x02, 0x02, 0x00, //* 10
  19.         0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x1F, 0x01, 0x01, 0x01, 0x00, //+ 11
  20.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xB0, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, //, 12
  21.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, //- 13
  22.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, //. 14
  23.         0x00, 0x00, 0x00, 0x00, 0x80, 0x60, 0x18, 0x04, 0x00, 0x60, 0x18, 0x06, 0x01, 0x00, 0x00, 0x00, /// 15
  24.         0x00, 0xE0, 0x10, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x00, 0x0F, 0x10, 0x20, 0x20, 0x10, 0x0F, 0x00, // 0 16
  25.         0x00, 0x10, 0x10, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00, // 1 17
  26.         0x00, 0x70, 0x08, 0x08, 0x08, 0x88, 0x70, 0x00, 0x00, 0x30, 0x28, 0x24, 0x22, 0x21, 0x30, 0x00, // 2 18
  27.         0x00, 0x30, 0x08, 0x88, 0x88, 0x48, 0x30, 0x00, 0x00, 0x18, 0x20, 0x20, 0x20, 0x11, 0x0E, 0x00, // 3 19
  28.         0x00, 0x00, 0xC0, 0x20, 0x10, 0xF8, 0x00, 0x00, 0x00, 0x07, 0x04, 0x24, 0x24, 0x3F, 0x24, 0x00, // 4 20
  29.         0x00, 0xF8, 0x08, 0x88, 0x88, 0x08, 0x08, 0x00, 0x00, 0x19, 0x21, 0x20, 0x20, 0x11, 0x0E, 0x00, // 5 21
  30.         0x00, 0xE0, 0x10, 0x88, 0x88, 0x18, 0x00, 0x00, 0x00, 0x0F, 0x11, 0x20, 0x20, 0x11, 0x0E, 0x00, // 6 22
  31.         0x00, 0x38, 0x08, 0x08, 0xC8, 0x38, 0x08, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, // 7 23
  32.         0x00, 0x70, 0x88, 0x08, 0x08, 0x88, 0x70, 0x00, 0x00, 0x1C, 0x22, 0x21, 0x21, 0x22, 0x1C, 0x00, // 8 24
  33.         0x00, 0xE0, 0x10, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x00, 0x00, 0x31, 0x22, 0x22, 0x11, 0x0F, 0x00, // 9 25
  34.         0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, //: 26
  35.         0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x60, 0x00, 0x00, 0x00, 0x00, //; 27
  36.         0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, //< 28
  37.         0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, //= 29
  38.         0x00, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, //> 30
  39.         0x00, 0x70, 0x48, 0x08, 0x08, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x36, 0x01, 0x00, 0x00, //? 31
  40.         0xC0, 0x30, 0xC8, 0x28, 0xE8, 0x10, 0xE0, 0x00, 0x07, 0x18, 0x27, 0x24, 0x23, 0x14, 0x0B, 0x00, //@ 32
  41.         0x00, 0x00, 0xC0, 0x38, 0xE0, 0x00, 0x00, 0x00, 0x20, 0x3C, 0x23, 0x02, 0x02, 0x27, 0x38, 0x20, // A 33
  42.         0x08, 0xF8, 0x88, 0x88, 0x88, 0x70, 0x00, 0x00, 0x20, 0x3F, 0x20, 0x20, 0x20, 0x11, 0x0E, 0x00, // B 34
  43.         0xC0, 0x30, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00, 0x07, 0x18, 0x20, 0x20, 0x20, 0x10, 0x08, 0x00, // C 35
  44.         0x08, 0xF8, 0x08, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x20, 0x3F, 0x20, 0x20, 0x20, 0x10, 0x0F, 0x00, // D 36
  45.         0x08, 0xF8, 0x88, 0x88, 0xE8, 0x08, 0x10, 0x00, 0x20, 0x3F, 0x20, 0x20, 0x23, 0x20, 0x18, 0x00, // E 37
  46.         0x08, 0xF8, 0x88, 0x88, 0xE8, 0x08, 0x10, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00, // F 38
  47.         0xC0, 0x30, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00, 0x07, 0x18, 0x20, 0x20, 0x22, 0x1E, 0x02, 0x00, // G 39
  48.         0x08, 0xF8, 0x08, 0x00, 0x00, 0x08, 0xF8, 0x08, 0x20, 0x3F, 0x21, 0x01, 0x01, 0x21, 0x3F, 0x20, // H 40
  49.         0x00, 0x08, 0x08, 0xF8, 0x08, 0x08, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00, // I 41
  50.         0x00, 0x00, 0x08, 0x08, 0xF8, 0x08, 0x08, 0x00, 0xC0, 0x80, 0x80, 0x80, 0x7F, 0x00, 0x00, 0x00, // J 42
  51.         0x08, 0xF8, 0x88, 0xC0, 0x28, 0x18, 0x08, 0x00, 0x20, 0x3F, 0x20, 0x01, 0x26, 0x38, 0x20, 0x00, // K 43
  52.         0x08, 0xF8, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x30, 0x00, // L 44
  53.         0x08, 0xF8, 0xF8, 0x00, 0xF8, 0xF8, 0x08, 0x00, 0x20, 0x3F, 0x00, 0x3F, 0x00, 0x3F, 0x20, 0x00, // M 45
  54.         0x08, 0xF8, 0x30, 0xC0, 0x00, 0x08, 0xF8, 0x08, 0x20, 0x3F, 0x20, 0x00, 0x07, 0x18, 0x3F, 0x00, // N 46
  55.         0xE0, 0x10, 0x08, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x0F, 0x10, 0x20, 0x20, 0x20, 0x10, 0x0F, 0x00, // O 47
  56.         0x08, 0xF8, 0x08, 0x08, 0x08, 0x08, 0xF0, 0x00, 0x20, 0x3F, 0x21, 0x01, 0x01, 0x01, 0x00, 0x00, // P 48
  57.         0xE0, 0x10, 0x08, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x0F, 0x18, 0x24, 0x24, 0x38, 0x50, 0x4F, 0x00, // Q 49
  58.         0x08, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x70, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x03, 0x0C, 0x30, 0x20, // R 50
  59.         0x00, 0x70, 0x88, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00, 0x38, 0x20, 0x21, 0x21, 0x22, 0x1C, 0x00, // S 51
  60.         0x18, 0x08, 0x08, 0xF8, 0x08, 0x08, 0x18, 0x00, 0x00, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x00, 0x00, // T 52
  61.         0x08, 0xF8, 0x08, 0x00, 0x00, 0x08, 0xF8, 0x08, 0x00, 0x1F, 0x20, 0x20, 0x20, 0x20, 0x1F, 0x00, // U 53
  62.         0x08, 0x78, 0x88, 0x00, 0x00, 0xC8, 0x38, 0x08, 0x00, 0x00, 0x07, 0x38, 0x0E, 0x01, 0x00, 0x00, // V 54
  63.         0xF8, 0x08, 0x00, 0xF8, 0x00, 0x08, 0xF8, 0x00, 0x03, 0x3C, 0x07, 0x00, 0x07, 0x3C, 0x03, 0x00, // W 55
  64.         0x08, 0x18, 0x68, 0x80, 0x80, 0x68, 0x18, 0x08, 0x20, 0x30, 0x2C, 0x03, 0x03, 0x2C, 0x30, 0x20, // X 56
  65.         0x08, 0x38, 0xC8, 0x00, 0xC8, 0x38, 0x08, 0x00, 0x00, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x00, 0x00, // Y 57
  66.         0x10, 0x08, 0x08, 0x08, 0xC8, 0x38, 0x08, 0x00, 0x20, 0x38, 0x26, 0x21, 0x20, 0x20, 0x18, 0x00, // Z 58
  67.         0x00, 0x00, 0x00, 0xFE, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x40, 0x40, 0x40, 0x00, //[ 59
  68.         0x00, 0x0C, 0x30, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x38, 0xC0, 0x00, // 60
  69.         0x00, 0x02, 0x02, 0x02, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x7F, 0x00, 0x00, 0x00, //] 61
  70.         0x00, 0x00, 0x04, 0x02, 0x02, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //^ 62
  71.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, //_ 63
  72.         0x00, 0x02, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //` 64
  73.         0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x19, 0x24, 0x22, 0x22, 0x22, 0x3F, 0x20, // a 65
  74.         0x08, 0xF8, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x11, 0x20, 0x20, 0x11, 0x0E, 0x00, // b 66
  75.         0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x0E, 0x11, 0x20, 0x20, 0x20, 0x11, 0x00, // c 67
  76.         0x00, 0x00, 0x00, 0x80, 0x80, 0x88, 0xF8, 0x00, 0x00, 0x0E, 0x11, 0x20, 0x20, 0x10, 0x3F, 0x20, // d 68
  77.         0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x1F, 0x22, 0x22, 0x22, 0x22, 0x13, 0x00, // e 69
  78.         0x00, 0x80, 0x80, 0xF0, 0x88, 0x88, 0x88, 0x18, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00, // f 70
  79.         0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x6B, 0x94, 0x94, 0x94, 0x93, 0x60, 0x00, // g 71
  80.         0x08, 0xF8, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x20, 0x3F, 0x21, 0x00, 0x00, 0x20, 0x3F, 0x20, // h 72
  81.         0x00, 0x80, 0x98, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00, // i 73
  82.         0x00, 0x00, 0x00, 0x80, 0x98, 0x98, 0x00, 0x00, 0x00, 0xC0, 0x80, 0x80, 0x80, 0x7F, 0x00, 0x00, // j 74
  83.         0x08, 0xF8, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x20, 0x3F, 0x24, 0x02, 0x2D, 0x30, 0x20, 0x00, // k 75
  84.         0x00, 0x08, 0x08, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00, // l 76
  85.         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x3F, 0x20, 0x00, 0x3F, // m 77
  86.         0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x20, 0x3F, 0x21, 0x00, 0x00, 0x20, 0x3F, 0x20, // n 78
  87.         0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x1F, 0x20, 0x20, 0x20, 0x20, 0x1F, 0x00, // o 79
  88.         0x80, 0x80, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0xFF, 0xA1, 0x20, 0x20, 0x11, 0x0E, 0x00, // p 80
  89.         0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x0E, 0x11, 0x20, 0x20, 0xA0, 0xFF, 0x80, // q 81
  90.         0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x00, 0x20, 0x20, 0x3F, 0x21, 0x20, 0x00, 0x01, 0x00, // r 82
  91.         0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x33, 0x24, 0x24, 0x24, 0x24, 0x19, 0x00, // s 83
  92.         0x00, 0x80, 0x80, 0xE0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x20, 0x20, 0x00, 0x00, // t 84
  93.         0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x1F, 0x20, 0x20, 0x20, 0x10, 0x3F, 0x20, // u 85
  94.         0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x01, 0x0E, 0x30, 0x08, 0x06, 0x01, 0x00, // v 86
  95.         0x80, 0x80, 0x00, 0x80, 0x00, 0x80, 0x80, 0x80, 0x0F, 0x30, 0x0C, 0x03, 0x0C, 0x30, 0x0F, 0x00, // w 87
  96.         0x00, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x20, 0x31, 0x2E, 0x0E, 0x31, 0x20, 0x00, // x 88
  97.         0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x81, 0x8E, 0x70, 0x18, 0x06, 0x01, 0x00, // y 89
  98.         0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x21, 0x30, 0x2C, 0x22, 0x21, 0x30, 0x00, // z 90
  99.         0x00, 0x00, 0x00, 0x00, 0x80, 0x7C, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x40, 0x40, //{ 91
  100.         0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, //| 92
  101.         0x00, 0x02, 0x02, 0x7C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x3F, 0x00, 0x00, 0x00, 0x00, //} 93
  102.         0x00, 0x06, 0x01, 0x01, 0x02, 0x02, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //~ 94
  103. };
  104.  
  105. /* OLED写入一条指令 */
  106. void oledWriteCmd(char writeCmd)
  107. {
  108.     IIC_start();
  109.     IIC_send_byte(0x78); // 选择一个OLED屏，写模式
  110.     IIC_wait_ack();
  111.     IIC_send_byte(0x00); // 写入命令，D/C位为0
  112.     IIC_wait_ack();
  113.     IIC_send_byte(writeCmd);
  114.     IIC_wait_ack();
  115.     IIC_stop();
  116. }
  117.  
  118. /* OLED写入一个数据 */
  119. void oledWriteData(char writeData)
  120. {
  121.     IIC_start();
  122.     IIC_send_byte(0x78); // 选择一个OLED屏，写模式
  123.     IIC_wait_ack();
  124.     IIC_send_byte(0x40); // 写入命令，D/C位为1
  125.     IIC_wait_ack();
  126.     IIC_send_byte(writeData);
  127.     IIC_wait_ack();
  128.     IIC_stop();
  129. }
  130.  
  131. // OLCD初始化
  132. void oledInit()
  133. {
  134.     oledWriteCmd(0xAE);
  135.     oledWriteCmd(0x00);
  136.     oledWriteCmd(0x10);
  137.     oledWriteCmd(0x40);
  138.     oledWriteCmd(0xB0);
  139.     oledWriteCmd(0x81);
  140.     oledWriteCmd(0xFF);
  141.     oledWriteCmd(0xA1);
  142.     oledWriteCmd(0xA6);
  143.     oledWriteCmd(0xA8);
  144.     oledWriteCmd(0x3F);
  145.     oledWriteCmd(0xC8);
  146.     oledWriteCmd(0xD3);
  147.     oledWriteCmd(0x00);
  148.     oledWriteCmd(0xD5);
  149.     oledWriteCmd(0x80);
  150.     oledWriteCmd(0xD8);
  151.     oledWriteCmd(0x05);
  152.     oledWriteCmd(0xD9);
  153.     oledWriteCmd(0xF1);
  154.     oledWriteCmd(0xDA);
  155.     oledWriteCmd(0x12);
  156.     oledWriteCmd(0xDB);
  157.     oledWriteCmd(0x30);
  158.     oledWriteCmd(0x8D);
  159.     oledWriteCmd(0x14);
  160.     oledWriteCmd(0xAF);
  161. }
  162.  
  163. // OLED全屏清屏
  164. void oledClean()
  165. {
  166.     int i, j;
  167.     for (i = 0; i < 8; i++)
  168.     {
  169.         oledWriteCmd(0xB0 + i); // 选择PAGE
  170.         // 选择PAGE的第0列开始显示
  171.         oledWriteCmd(0x00);
  172.         oledWriteCmd(0x10);
  173.         for (j = 0; j < 128; j++)
  174.         {
  175.             oledWriteData(0); // 写入字符0
  176.         }
  177.     }
  178. }
  179.  
  180. // OLED行清屏
  181. void oled_rowClean(char rows)
  182. {
  183.     unsigned char i, j;
  184.     for (i = 0; i < 2; i++)
  185.     {
  186.         oledWriteCmd(0xB0 + (rows * 2 - (2 - i))); // 选择PAGE
  187.         // 选择PAGE的第0列开始显示
  188.         oledWriteCmd(0x00);
  189.         oledWriteCmd(0x10);
  190.         for (j = 0; j < 128; j++)
  191.         {
  192.             oledWriteData(0); // 写入字符0
  193.         }
  194.     }
  195. }
  196.  
  197. // OLED显示一个字符
  198. void oledShowByte(char rows, char columns, char oledByte)
  199. {
  200.     unsigned int i;
  201.  
  202.     // 显示字符的上半部分
  203.     oledWriteCmd(0xb0 + (rows * 2 - 2)); // 选择行
  204.  
  205.     // 选择列
  206.     oledWriteCmd(0x00 + (columns & 0x0f));
  207.     oledWriteCmd(0x10 + (columns >> 4));
  208.  
  209.     // 显示数据
  210.     for (i = ((oledByte - 32) * 16); i < ((oledByte - 32) * 16 + 8); i++)
  211.     {
  212.         oledWriteData(oledFont[i]);
  213.     }
  214.  
  215.     // 显示字符的上半部分
  216.     oledWriteCmd(0xb0 + (rows * 2 - 1)); // 选择行
  217.  
  218.     // 选择列
  219.     oledWriteCmd(0x00 + (columns & 0x0f));
  220.     oledWriteCmd(0x10 + (columns >> 4));
  221.  
  222.     // 显示数据
  223.     for (i = ((oledByte - 32) * 16 + 8); i < ((oledByte - 32) * 16 + 8 + 8); i++)
  224.     {
  225.         oledWriteData(oledFont[i]);
  226.     }
  227. }
  228.  
  229. // OLED显示一个字符串
  230. void oledShowString(char rows, char columns, char *str)
  231. {
  232.     while (*str != '')
  233.     {
  234.         oledShowByte(rows, columns, *str);
  235.         str++;
  236.         columns += 8;
  237.     }
  238. }

添加文件oled.h

  1.  
  2. #include "main.h"
  3.  
  4. // OLED写入一条指令
  5. void oledWriteCmd(uint8_t writeCmd);
  6.  
  7. // OLED写入一个数据
  8. void oledWriteData(uint8_t writeData);
  9.  
  10. // OLCD初始化
  11. void oledInit(void);
  12.  
  13. // OLED清屏
  14. void oledClean(void);
  15.  
  16. // OLED行清屏
  17. void oled_rowClean(char rows);
  18.  
  19. // OLED显示一个字符
  20. void oledShowByte(char rows, char columns, char oledByte);
  21.  
  22. // OLED显示一个字符串
  23. void oledShowString(char rows, char columns, char *str);

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "tim.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28.  
  29. #include 
  30. #include 
  31.  
  32. #include "car.h"
  33. #include "oled.h"
  34.  
  35. uint8_t speed_cnt = 0;
  36. uint8_t speedMsg[24] = {0};
  37.  
  38. /* USER CODE END Includes */
  39.  
  40. /* Private typedef -----------------------------------------------------------*/
  41. /* USER CODE BEGIN PTD */
  42.  
  43. /* USER CODE END PTD */
  44.  
  45. /* Private define ------------------------------------------------------------*/
  46. /* USER CODE BEGIN PD */
  47. /* USER CODE END PD */
  48.  
  49. /* Private macro -------------------------------------------------------------*/
  50. /* USER CODE BEGIN PM */
  51.  
  52. /* USER CODE END PM */
  53.  
  54. /* Private variables ---------------------------------------------------------*/
  55.  
  56. /* USER CODE BEGIN PV */
  57.  
  58. /* USER CODE END PV */
  59.  
  60. /* Private function prototypes -----------------------------------------------*/
  61. void SystemClock_Config(void);
  62. /* USER CODE BEGIN PFP */
  63.  
  64. /* USER CODE END PFP */
  65.  
  66. /* Private user code ---------------------------------------------------------*/
  67. /* USER CODE BEGIN 0 */
  68.  
  69. /* PB13引脚中断的回调函数 */
  70. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  71. {
  72.     if (GPIO_Pin == GPIO_PIN_13)
  73.     { /* 如果是PB13引脚产生的中断 */
  74.         // HAL_Delay(50);  /* 按键防抖，这个delay函数不知道为什么引起OLED显示失败 */
  75.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET)
  76.         {
  77.             speed_cnt++;
  78.         }
  79.     }
  80. }
  81.  
  82. /* 定时器3中断的回调函数 */
  83. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  84. {
  85.     // 判断是否是定时器3产生的中断
  86.     if (htim3.Instance == TIM3)
  87.     {
  88.         if (speed_cnt < 10)
  89.         {
  90.             sprintf((char *)speedMsg, "speed:  %d cm/s ", speed_cnt);
  91.         }
  92.         else
  93.         {
  94.             sprintf((char *)speedMsg, "speed: %d cm/s ", speed_cnt);
  95.         }
  96.  
  97.         printf("%s
", speedMsg);
  98.         oledShowString(3, 1, (char *)speedMsg);
  99.         speed_cnt = 0;
  100.     }
  101. }
  102.  
  103. /* USER CODE END 0 */
  104.  
  105. /**
  106.  * @brief  The application entry point.
  107.  * @retval int
  108.  */
  109. int main(void)
  110. {
  111.     /* USER CODE BEGIN 1 */
  112.  
  113.     /* USER CODE END 1 */
  114.  
  115.     /* MCU Configuration--------------------------------------------------------*/
  116.  
  117.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  118.     HAL_Init();
  119.  
  120.     /* USER CODE BEGIN Init */
  121.  
  122.     /* USER CODE END Init */
  123.  
  124.     /* Configure the system clock */
  125.     SystemClock_Config();
  126.  
  127.     /* USER CODE BEGIN SysInit */
  128.  
  129.     /* USER CODE END SysInit */
  130.  
  131.     /* Initialize all configured peripherals */
  132.     MX_GPIO_Init();
  133.     MX_USART1_UART_Init();
  134.     MX_TIM2_Init();
  135.     MX_TIM3_Init();
  136.     /* USER CODE BEGIN 2 */
  137.  
  138.     oledInit();     // OLED初始化
  139.     oledClean(); /* 清屏函数 */
  140.  
  141.     // 设置寻址模式
  142.     oledWriteCmd(0x20); // 设置内存
  143.     oledWriteCmd(0x02); // 选择页寻址模式
  144.  
  145.     oledShowString(1, 1, "diedie_car");
  146.     oledShowString(2, 1, "move: stop");
  147.  
  148.     oledShowString(4, 1, "mode: bizhang");
  149.  
  150.     /* USER CODE END 2 */
  151.  
  152.     /* Infinite loop */
  153.     /* USER CODE BEGIN WHILE */
  154.     while (1)
  155.     {
  156.         /* USER CODE END WHILE */
  157.  
  158.         /* USER CODE BEGIN 3 */
  159.  
  160.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  161.     }
  162.     /* USER CODE END 3 */
  163. }
  164.  
  165. /**
  166.  * @brief System Clock Configuration
  167.  * @retval None
  168.  */
  169. void SystemClock_Config(void)
  170. {
  171.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  172.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  173.  
  174.     /** Initializes the RCC Oscillators according to the specified parameters
  175.      * in the RCC_OscInitTypeDef structure.
  176.      */
  177.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  178.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  179.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  180.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  181.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  182.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  183.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  184.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  185.     {
  186.         Error_Handler();
  187.     }
  188.  
  189.     /** Initializes the CPU, AHB and APB buses clocks
  190.      */
  191.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  192.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  193.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  194.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  195.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  196.  
  197.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  198.     {
  199.         Error_Handler();
  200.     }
  201. }
  202.  
  203. /* USER CODE BEGIN 4 */
  204.  
  205. /* USER CODE END 4 */
  206.  
  207. /**
  208.  * @brief  This function is executed in case of error occurrence.
  209.  * @retval None
  210.  */
  211. void Error_Handler(void)
  212. {
  213.     /* USER CODE BEGIN Error_Handler_Debug */
  214.     /* User can add his own implementation to report the HAL error return state */
  215.     __disable_irq();
  216.     while (1)
  217.     {
  218.     }
  219.     /* USER CODE END Error_Handler_Debug */
  220. }
  221.  
  222. #ifdef USE_FULL_ASSERT
  223. /**
  224.  * @brief  Reports the name of the source file and the source line number
  225.  *         where the assert_param error has occurred.
  226.  * @param  file: pointer to the source file name
  227.  * @param  line: assert_param error line source number
  228.  * @retval None
  229.  */
  230. void assert_failed(uint8_t *file, uint32_t line)
  231. {
  232.     /* USER CODE BEGIN 6 */
  233.     /* User can add his own implementation to report the file name and line number,
  234.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  235.     /* USER CODE END 6 */
  236. }
  237. #endif /* USE_FULL_ASSERT */

摇头避障小车

利用sg90舵机转动不同的角度配合超声波获取小车前方的障碍物的距离来达到避障的效果。

硬件组成

超声波模块HC-SR04

  • 发送超声波：当Trig引脚接收到一个10微秒以上的高电平后开始发送超声波，当开始发送超声波后，Echo引脚会从低电平跳转到高电平。

  • 接收超声波：当发出去的超声波返回来并被接收后，Echo引脚会从高电平跳转到低电平。

  • 超声波从发出到被接收的时间：Echo持续高电平的时间，当超声波发出去的瞬间启动定时器，超声波被接收的瞬间停止定时器，获取中间经过的时间。

  • 测距：距离 = 声音速度（340m/s）* 时间 / 2，除以2是因为超声波经过了两倍距离。

sg90舵机

驱动sg90舵机时，PWM信号的频率不能太高，大概为50HZ，即设置一个周期为20ms左右的PWM。

  • 周期内0.5ms高电平 --> 舵机转动45°，即占空比为2.5%。

  • 周期内1.0ms高电平 --> 舵机转动90°，即占空比为5.0%。

  • 周期内1.5ms高电平 --> 舵机转动135°，即占空比为7.5%。

  • 周期内2.0ms高电平 --> 舵机转动45°，即占空比为10.0%。

  • 周期内2.5ms高电平 --> 舵机转动180°，即占空比为12.5%。

模块与STM32F103板子接线

  • 超声波Trig引脚 <-> PB3

  • 超声波Echo引脚 <-> PB4

  • 舵机PWM信号引脚 <-> PB9

STM32CubeMX相关配置

配置GPIO

  • 配置PB3引脚为输出高电平。

  • 配置PB4引脚为输入引脚。

配置定时器1和定时器4

配置定时器1作为计数器，PSC值为71，ARR值为65535，这样定时器每计数一下就经过1us。

配置定时器4的通道4输出PWM，用来驱动舵机转动不同的角度。

文件编写

修改文件tim.c

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file    tim.c
  6.  * @brief   This file provides code for the configuration
  7.  *          of the TIM instances.
  8.  ******************************************************************************
  9.  * @attention
  10.  *
  11.  * Copyright (c) 2023 STMicroelectronics.
  12.  * All rights reserved.
  13.  *
  14.  * This software is licensed under terms that can be found in the LICENSE file
  15.  * in the root directory of this software component.
  16.  * If no LICENSE file comes with this software, it is provided AS-IS.
  17.  *
  18.  ******************************************************************************
  19.  */
  20. /* USER CODE END Header */
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "tim.h"
  23.  
  24. /* USER CODE BEGIN 0 */
  25.  
  26. /* USER CODE END 0 */
  27.  
  28. TIM_HandleTypeDef htim1;
  29. TIM_HandleTypeDef htim2;
  30. TIM_HandleTypeDef htim3;
  31. TIM_HandleTypeDef htim4;
  32.  
  33. /* TIM1 init function */
  34. void MX_TIM1_Init(void)
  35. {
  36.  
  37.     /* USER CODE BEGIN TIM1_Init 0 */
  38.  
  39.     /* USER CODE END TIM1_Init 0 */
  40.  
  41.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  42.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  43.  
  44.     /* USER CODE BEGIN TIM1_Init 1 */
  45.  
  46.     /* USER CODE END TIM1_Init 1 */
  47.     htim1.Instance = TIM1;
  48.     htim1.Init.Prescaler = 71;
  49.     htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  50.     htim1.Init.Period = 65535;
  51.     htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  52.     htim1.Init.RepetitionCounter = 0;
  53.     htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  54.     if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  55.     {
  56.         Error_Handler();
  57.     }
  58.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  59.     if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  60.     {
  61.         Error_Handler();
  62.     }
  63.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  64.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  65.     if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  66.     {
  67.         Error_Handler();
  68.     }
  69.     /* USER CODE BEGIN TIM1_Init 2 */
  70.  
  71.     /* USER CODE END TIM1_Init 2 */
  72. }
  73. /* TIM2 init function */
  74. void MX_TIM2_Init(void)
  75. {
  76.  
  77.     /* USER CODE BEGIN TIM2_Init 0 */
  78.  
  79.     /* USER CODE END TIM2_Init 0 */
  80.  
  81.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  82.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  83.     TIM_OC_InitTypeDef sConfigOC = {0};
  84.  
  85.     /* USER CODE BEGIN TIM2_Init 1 */
  86.  
  87.     /* USER CODE END TIM2_Init 1 */
  88.     htim2.Instance = TIM2;
  89.     htim2.Init.Prescaler = 71;
  90.     htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  91.     htim2.Init.Period = 19;
  92.     htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  93.     htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  94.     if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  95.     {
  96.         Error_Handler();
  97.     }
  98.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  99.     if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  100.     {
  101.         Error_Handler();
  102.     }
  103.     if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  104.     {
  105.         Error_Handler();
  106.     }
  107.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  108.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  109.     if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  110.     {
  111.         Error_Handler();
  112.     }
  113.     sConfigOC.OCMode = TIM_OCMODE_PWM1;
  114.     sConfigOC.Pulse = 0;
  115.     sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  116.     sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  117.     if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  118.     {
  119.         Error_Handler();
  120.     }
  121.     if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  122.     {
  123.         Error_Handler();
  124.     }
  125.     /* USER CODE BEGIN TIM2_Init 2 */
  126.  
  127.     /* 启动B-2A、A-1B引脚的PWM */
  128.     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  129.     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  130.  
  131.     /* USER CODE END TIM2_Init 2 */
  132.     HAL_TIM_MspPostInit(&htim2);
  133. }
  134. /* TIM3 init function */
  135. void MX_TIM3_Init(void)
  136. {
  137.  
  138.     /* USER CODE BEGIN TIM3_Init 0 */
  139.  
  140.     /* USER CODE END TIM3_Init 0 */
  141.  
  142.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  143.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  144.  
  145.     /* USER CODE BEGIN TIM3_Init 1 */
  146.  
  147.     /* USER CODE END TIM3_Init 1 */
  148.     htim3.Instance = TIM3;
  149.     htim3.Init.Prescaler = 7199;
  150.     htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  151.     htim3.Init.Period = 9999;
  152.     htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  153.     htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  154.     if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  155.     {
  156.         Error_Handler();
  157.     }
  158.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  159.     if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  160.     {
  161.         Error_Handler();
  162.     }
  163.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  164.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  165.     if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  166.     {
  167.         Error_Handler();
  168.     }
  169.     /* USER CODE BEGIN TIM3_Init 2 */
  170.     HAL_TIM_Base_Start_IT(&htim3);
  171.     /* USER CODE END TIM3_Init 2 */
  172. }
  173. /* TIM4 init function */
  174. void MX_TIM4_Init(void)
  175. {
  176.  
  177.     /* USER CODE BEGIN TIM4_Init 0 */
  178.  
  179.     /* USER CODE END TIM4_Init 0 */
  180.  
  181.     TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  182.     TIM_MasterConfigTypeDef sMasterConfig = {0};
  183.     TIM_OC_InitTypeDef sConfigOC = {0};
  184.  
  185.     /* USER CODE BEGIN TIM4_Init 1 */
  186.  
  187.     /* USER CODE END TIM4_Init 1 */
  188.     htim4.Instance = TIM4;
  189.     htim4.Init.Prescaler = 7199;
  190.     htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  191.     htim4.Init.Period = 199;
  192.     htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  193.     htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  194.     if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  195.     {
  196.         Error_Handler();
  197.     }
  198.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  199.     if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
  200.     {
  201.         Error_Handler();
  202.     }
  203.     if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
  204.     {
  205.         Error_Handler();
  206.     }
  207.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  208.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  209.     if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  210.     {
  211.         Error_Handler();
  212.     }
  213.     sConfigOC.OCMode = TIM_OCMODE_PWM1;
  214.     sConfigOC.Pulse = 0;
  215.     sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  216.     sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  217.     if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  218.     {
  219.         Error_Handler();
  220.     }
  221.     /* USER CODE BEGIN TIM4_Init 2 */
  222.  
  223.     /* 启动sg90引脚的PWM */
  224.     HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4);
  225.  
  226.     /* USER CODE END TIM4_Init 2 */
  227.     HAL_TIM_MspPostInit(&htim4);
  228. }
  229.  
  230. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *tim_baseHandle)
  231. {
  232.  
  233.     if (tim_baseHandle->Instance == TIM1)
  234.     {
  235.         /* USER CODE BEGIN TIM1_MspInit 0 */
  236.  
  237.         /* USER CODE END TIM1_MspInit 0 */
  238.         /* TIM1 clock enable */
  239.         __HAL_RCC_TIM1_CLK_ENABLE();
  240.         /* USER CODE BEGIN TIM1_MspInit 1 */
  241.  
  242.         /* USER CODE END TIM1_MspInit 1 */
  243.     }
  244.     else if (tim_baseHandle->Instance == TIM2)
  245.     {
  246.         /* USER CODE BEGIN TIM2_MspInit 0 */
  247.  
  248.         /* USER CODE END TIM2_MspInit 0 */
  249.         /* TIM2 clock enable */
  250.         __HAL_RCC_TIM2_CLK_ENABLE();
  251.         /* USER CODE BEGIN TIM2_MspInit 1 */
  252.  
  253.         /* USER CODE END TIM2_MspInit 1 */
  254.     }
  255.     else if (tim_baseHandle->Instance == TIM3)
  256.     {
  257.         /* USER CODE BEGIN TIM3_MspInit 0 */
  258.  
  259.         /* USER CODE END TIM3_MspInit 0 */
  260.         /* TIM3 clock enable */
  261.         __HAL_RCC_TIM3_CLK_ENABLE();
  262.  
  263.         /* TIM3 interrupt Init */
  264.         HAL_NVIC_SetPriority(TIM3_IRQn, 4, 0);
  265.         HAL_NVIC_EnableIRQ(TIM3_IRQn);
  266.         /* USER CODE BEGIN TIM3_MspInit 1 */
  267.  
  268.         /* USER CODE END TIM3_MspInit 1 */
  269.     }
  270.     else if (tim_baseHandle->Instance == TIM4)
  271.     {
  272.         /* USER CODE BEGIN TIM4_MspInit 0 */
  273.  
  274.         /* USER CODE END TIM4_MspInit 0 */
  275.         /* TIM4 clock enable */
  276.         __HAL_RCC_TIM4_CLK_ENABLE();
  277.         /* USER CODE BEGIN TIM4_MspInit 1 */
  278.  
  279.         /* USER CODE END TIM4_MspInit 1 */
  280.     }
  281. }
  282. void HAL_TIM_MspPostInit(TIM_HandleTypeDef *timHandle)
  283. {
  284.  
  285.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  286.     if (timHandle->Instance == TIM2)
  287.     {
  288.         /* USER CODE BEGIN TIM2_MspPostInit 0 */
  289.  
  290.         /* USER CODE END TIM2_MspPostInit 0 */
  291.         __HAL_RCC_GPIOA_CLK_ENABLE();
  292.         /**TIM2 GPIO Configuration
  293.         PA0-WKUP     ------> TIM2_CH1
  294.         PA1     ------> TIM2_CH2
  295.         */
  296.         GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1;
  297.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  298.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  299.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  300.  
  301.         /* USER CODE BEGIN TIM2_MspPostInit 1 */
  302.  
  303.         /* USER CODE END TIM2_MspPostInit 1 */
  304.     }
  305.     else if (timHandle->Instance == TIM4)
  306.     {
  307.         /* USER CODE BEGIN TIM4_MspPostInit 0 */
  308.  
  309.         /* USER CODE END TIM4_MspPostInit 0 */
  310.  
  311.         __HAL_RCC_GPIOB_CLK_ENABLE();
  312.         /**TIM4 GPIO Configuration
  313.         PB9     ------> TIM4_CH4
  314.         */
  315.         GPIO_InitStruct.Pin = GPIO_PIN_9;
  316.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  317.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  318.         HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  319.  
  320.         /* USER CODE BEGIN TIM4_MspPostInit 1 */
  321.  
  322.         /* USER CODE END TIM4_MspPostInit 1 */
  323.     }
  324. }
  325.  
  326. void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *tim_baseHandle)
  327. {
  328.  
  329.     if (tim_baseHandle->Instance == TIM1)
  330.     {
  331.         /* USER CODE BEGIN TIM1_MspDeInit 0 */
  332.  
  333.         /* USER CODE END TIM1_MspDeInit 0 */
  334.         /* Peripheral clock disable */
  335.         __HAL_RCC_TIM1_CLK_DISABLE();
  336.         /* USER CODE BEGIN TIM1_MspDeInit 1 */
  337.  
  338.         /* USER CODE END TIM1_MspDeInit 1 */
  339.     }
  340.     else if (tim_baseHandle->Instance == TIM2)
  341.     {
  342.         /* USER CODE BEGIN TIM2_MspDeInit 0 */
  343.  
  344.         /* USER CODE END TIM2_MspDeInit 0 */
  345.         /* Peripheral clock disable */
  346.         __HAL_RCC_TIM2_CLK_DISABLE();
  347.         /* USER CODE BEGIN TIM2_MspDeInit 1 */
  348.  
  349.         /* USER CODE END TIM2_MspDeInit 1 */
  350.     }
  351.     else if (tim_baseHandle->Instance == TIM3)
  352.     {
  353.         /* USER CODE BEGIN TIM3_MspDeInit 0 */
  354.  
  355.         /* USER CODE END TIM3_MspDeInit 0 */
  356.         /* Peripheral clock disable */
  357.         __HAL_RCC_TIM3_CLK_DISABLE();
  358.  
  359.         /* TIM3 interrupt Deinit */
  360.         HAL_NVIC_DisableIRQ(TIM3_IRQn);
  361.         /* USER CODE BEGIN TIM3_MspDeInit 1 */
  362.  
  363.         /* USER CODE END TIM3_MspDeInit 1 */
  364.     }
  365.     else if (tim_baseHandle->Instance == TIM4)
  366.     {
  367.         /* USER CODE BEGIN TIM4_MspDeInit 0 */
  368.  
  369.         /* USER CODE END TIM4_MspDeInit 0 */
  370.         /* Peripheral clock disable */
  371.         __HAL_RCC_TIM4_CLK_DISABLE();
  372.         /* USER CODE BEGIN TIM4_MspDeInit 1 */
  373.  
  374.         /* USER CODE END TIM4_MspDeInit 1 */
  375.     }
  376. }
  377.  
  378. /* USER CODE BEGIN 1 */
  379.  
  380. /* USER CODE END 1 */

添加文件hc_sr04.c

  1.  
  2. #include "tim.h"
  3. #include "gpio.h"
  4. #include "my_i2c.h"
  5.  
  6. /* 定时器1 */
  7.  
  8. // 获取超声波的距离
  9. double getDistance()
  10. {
  11.     int cnt = 0;
  12.  
  13.     // 给Trig端口至少10us的高电平
  14.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
  15.     delay_us(15);
  16.     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
  17.  
  18.     __HAL_TIM_SetCounter(&htim1, 0); // 将定时器1的计数值设置为0
  19.  
  20.     // echo端口从低电平跳到高电平，开始发波，启动定时器1
  21.     while (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4) == GPIO_PIN_RESET);
  22.     __HAL_TIM_ENABLE(&htim1); // 启动定时器1
  23.  
  24.     // echo端口从高电平跳到低电平，停止发波，关闭定时器1
  25.     while (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4) == GPIO_PIN_SET);
  26.     __HAL_TIM_DISABLE(&htim1); // 关闭定时器1
  27.  
  28.     // 计算时间
  29.     cnt = __HAL_TIM_GetCounter(&htim1); // 读取定时器1的计数值
  30.  
  31.     // 计算距离
  32.     return cnt * 340 / 2 * 0.000001 * 100;
  33. }

添加文件hc_sr04.h

  1.  
  2. //获取超声波的距离
  3. double getDistance(void);

添加文件sg90.c

  1.  
  2. #include "sg90.h"
  3. #include "main.h"
  4. #include "tim.h"
  5.  
  6. #define LEFT 1
  7. #define MIDDLE 2
  8. #define RIGHT 3
  9.  
  10. uint8_t flag = LEFT;
  11.  
  12. void sg90Left()
  13. {
  14.     if (flag != LEFT)
  15.     {
  16.         flag = LEFT;
  17.         __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 25); // 设置舵机转动角度为180°
  18.     }
  19. }
  20.  
  21. void sg90Middle()
  22. {
  23.     if (flag != MIDDLE)
  24.     {
  25.         flag = MIDDLE;
  26.         __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 15); // 设置舵机转动角度为90°
  27.     }
  28. }
  29.  
  30. void sg90Right()
  31. {
  32.     if (flag != RIGHT)
  33.     {
  34.         flag = RIGHT;
  35.         __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 5); // 设置舵机转动角度为0°
  36.     }
  37. }

添加文件sg90.h

  1.  
  2. void sg90Left(void);
  3.  
  4. void sg90Middle(void);
  5.  
  6. void sg90Right(void);

添加文件bizhang.c

  1.  
  2. #include "tim.h"
  3. #include "car.h"
  4. #include "sg90.h"
  5. #include "hc_sr04.h"
  6.  
  7. extern double leftDistance;
  8. extern double rightDistance;
  9. extern double middleDistance;
  10.  
  11. /* 避障模式 */
  12. void bizhang_mode()
  13. {
  14.     sg90Middle();
  15.     HAL_Delay(400);
  16.  
  17.     middleDistance = getDistance();
  18.     if (middleDistance > 35)
  19.     {
  20.         car_goForward();
  21.     }
  22.     else
  23.     {
  24.         car_goStop();
  25.         HAL_Delay(50);
  26.         sg90Left();
  27.         HAL_Delay(400);
  28.         leftDistance = getDistance();
  29.  
  30.         sg90Middle();
  31.         HAL_Delay(400);
  32.  
  33.         sg90Right();
  34.         HAL_Delay(400);
  35.         rightDistance = getDistance();
  36.  
  37.         if (leftDistance < 15 && rightDistance < 15)
  38.         {
  39.             car_goBack();
  40.             HAL_Delay(500);
  41.             car_goStop();
  42.             HAL_Delay(50);
  43.         }
  44.         else
  45.         {
  46.  
  47.             if (leftDistance > rightDistance)
  48.             {
  49.                 car_goLeft();
  50.                 HAL_Delay(500);
  51.                 car_goStop();
  52.                 HAL_Delay(50);
  53.             }
  54.  
  55.             if (rightDistance > leftDistance)
  56.             {
  57.                 car_goRight();
  58.                 HAL_Delay(500);
  59.                 car_goStop();
  60.                 HAL_Delay(50);
  61.             }
  62.         }
  63.     }
  64. }

添加文件bizhang.h

  1.  
  2. /* 避障模式 */
  3. void bizhang_mode(void);

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "tim.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28.  
  29. #include 
  30. #include 
  31.  
  32. #include "car.h"
  33. #include "oled.h"
  34. #include "sg90.h"
  35. #include "hc_sr04.h"
  36. #include "my_i2c.h"
  37. #include "bizhang.h"
  38.  
  39. uint8_t speed_cnt = 0;
  40. uint8_t speedMsg[24] = {0};
  41.  
  42. double leftDistance = 0;
  43. double rightDistance = 0;
  44. double middleDistance = 0;
  45.  
  46. /* USER CODE END Includes */
  47.  
  48. /* Private typedef -----------------------------------------------------------*/
  49. /* USER CODE BEGIN PTD */
  50.  
  51. /* USER CODE END PTD */
  52.  
  53. /* Private define ------------------------------------------------------------*/
  54. /* USER CODE BEGIN PD */
  55. /* USER CODE END PD */
  56.  
  57. /* Private macro -------------------------------------------------------------*/
  58. /* USER CODE BEGIN PM */
  59.  
  60. /* USER CODE END PM */
  61.  
  62. /* Private variables ---------------------------------------------------------*/
  63.  
  64. /* USER CODE BEGIN PV */
  65.  
  66. /* USER CODE END PV */
  67.  
  68. /* Private function prototypes -----------------------------------------------*/
  69. void SystemClock_Config(void);
  70. /* USER CODE BEGIN PFP */
  71.  
  72. /* USER CODE END PFP */
  73.  
  74. /* Private user code ---------------------------------------------------------*/
  75. /* USER CODE BEGIN 0 */
  76.  
  77. /* 引脚中断的回调函数 */
  78. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  79. {
  80.     if (GPIO_Pin == GPIO_PIN_13)
  81.     { /* 如果是PB13引脚产生的中断 */
  82.         // HAL_Delay(50);  /* 按键防抖，这个delay函数不知道为什么引起OLED显示失败 */
  83.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET)
  84.         {
  85.             speed_cnt++;
  86.         }
  87.     }
  88. }
  89.  
  90. /* 定时器中断的回调函数 */
  91. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  92. {
  93.     // 判断是否是定时器3产生的中断
  94.     if (htim3.Instance == TIM3)
  95.     {
  96.         if (speed_cnt < 10)
  97.         {
  98.             sprintf((char *)speedMsg, "speed:  %d cm/s ", speed_cnt);
  99.         }
  100.         else
  101.         {
  102.             sprintf((char *)speedMsg, "speed: %d cm/s ", speed_cnt);
  103.         }
  104.         // printf("%s
",speedMsg);
  105.         oledShowString(3, 1, (char *)speedMsg);
  106.         speed_cnt = 0;
  107.     }
  108. }
  109.  
  110. /* USER CODE END 0 */
  111.  
  112. /**
  113.  * @brief  The application entry point.
  114.  * @retval int
  115.  */
  116. int main(void)
  117. {
  118.     /* USER CODE BEGIN 1 */
  119.  
  120.     /* USER CODE END 1 */
  121.  
  122.     /* MCU Configuration--------------------------------------------------------*/
  123.  
  124.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  125.     HAL_Init();
  126.  
  127.     /* USER CODE BEGIN Init */
  128.  
  129.     /* USER CODE END Init */
  130.  
  131.     /* Configure the system clock */
  132.     SystemClock_Config();
  133.  
  134.     /* USER CODE BEGIN SysInit */
  135.  
  136.     /* USER CODE END SysInit */
  137.  
  138.     /* Initialize all configured peripherals */
  139.     MX_GPIO_Init();
  140.     MX_USART1_UART_Init();
  141.     MX_TIM2_Init();
  142.     MX_TIM3_Init();
  143.     MX_TIM1_Init();
  144.     MX_TIM4_Init();
  145.     /* USER CODE BEGIN 2 */
  146.  
  147.     oledInit();     // OLED初始化
  148.     oledClean(); /* 清屏函数 */
  149.  
  150.     // 设置寻址模式
  151.     oledWriteCmd(0x20); // 设置内存
  152.     oledWriteCmd(0x02); // 选择页寻址模式
  153.  
  154.     oledShowString(1, 1, "diedie_car");
  155.     oledShowString(2, 1, "move: stop");
  156.  
  157.     oledShowString(4, 1, "mode: bizhang");
  158.  
  159.     /* USER CODE END 2 */
  160.  
  161.     /* Infinite loop */
  162.     /* USER CODE BEGIN WHILE */
  163.     while (1)
  164.     {
  165.         /* USER CODE END WHILE */
  166.  
  167.         /* USER CODE BEGIN 3 */
  168.  
  169.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  170.  
  171.         bizhang_mode();
  172.         ;
  173.     }
  174.     /* USER CODE END 3 */
  175. }
  176.  
  177. /**
  178.  * @brief System Clock Configuration
  179.  * @retval None
  180.  */
  181. void SystemClock_Config(void)
  182. {
  183.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  184.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  185.  
  186.     /** Initializes the RCC Oscillators according to the specified parameters
  187.      * in the RCC_OscInitTypeDef structure.
  188.      */
  189.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  190.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  191.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  192.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  193.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  194.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  195.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  196.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  197.     {
  198.         Error_Handler();
  199.     }
  200.  
  201.     /** Initializes the CPU, AHB and APB buses clocks
  202.      */
  203.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  204.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  205.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  206.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  207.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  208.  
  209.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  210.     {
  211.         Error_Handler();
  212.     }
  213. }
  214.  
  215. /* USER CODE BEGIN 4 */
  216.  
  217. /* USER CODE END 4 */
  218.  
  219. /**
  220.  * @brief  This function is executed in case of error occurrence.
  221.  * @retval None
  222.  */
  223. void Error_Handler(void)
  224. {
  225.     /* USER CODE BEGIN Error_Handler_Debug */
  226.     /* User can add his own implementation to report the HAL error return state */
  227.     __disable_irq();
  228.     while (1)
  229.     {
  230.     }
  231.     /* USER CODE END Error_Handler_Debug */
  232. }
  233.  
  234. #ifdef USE_FULL_ASSERT
  235. /**
  236.  * @brief  Reports the name of the source file and the source line number
  237.  *         where the assert_param error has occurred.
  238.  * @param  file: pointer to the source file name
  239.  * @param  line: assert_param error line source number
  240.  * @retval None
  241.  */
  242. void assert_failed(uint8_t *file, uint32_t line)
  243. {
  244.     /* USER CODE BEGIN 6 */
  245.     /* User can add his own implementation to report the file name and line number,
  246.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  247.     /* USER CODE END 6 */
  248. }
  249. #endif /* USE_FULL_ASSERT */

跟随小车

硬件组成

红外避障模块

  • 当发射出的红外线没有被反射回来或被反射回来但强度不够大，DO输出高电平，灯灭。没有障碍物。

  • 当发射出的红外线被反射回来，DO输出低电平，灯亮。有障碍物。

  • 即有障碍物DO输出低电平，红外避障模块灯亮，没有障碍物DO输出高电平，红外避障模块灯灭。

模块与STM32F103板子接线

  • 左红外避障模块 <-> PA4

  • 右红外避障模块 <-> PA5

STM32CubeMX相关配置

GPIO配置

配置PA4引脚、PA5引脚为输入引脚。

文件编写

添加文件gensui.c

  1.  
  2. #include "gpio.h"
  3. #include "car.h"
  4. #include "oled.h"
  5.  
  6. /* PA4:左红外避障模块，PA5:右红外避障模块 */
  7.  
  8. void followMode()
  9. {
  10.     oledShowString(4, 1, "mode: gensui");
  11.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_4) == GPIO_PIN_RESET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5) == GPIO_PIN_RESET)
  12.     { //
  13.         car_goForward();
  14.     }
  15.  
  16.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_4) == GPIO_PIN_RESET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5) == GPIO_PIN_SET)
  17.     {
  18.         car_goLeft();
  19.     }
  20.  
  21.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_4) == GPIO_PIN_SET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5) == GPIO_PIN_RESET)
  22.     {
  23.         car_goRight();
  24.     }
  25.  
  26.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_4) == GPIO_PIN_SET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5) == GPIO_PIN_SET)
  27.     {
  28.         car_goStop();
  29.     }
  30. }

添加文件gensui.h

  1.  
  2. void followMode(void);

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "tim.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28.  
  29. #include 
  30. #include 
  31.  
  32. #include "car.h"
  33. #include "oled.h"
  34. #include "sg90.h"
  35. #include "hc-08.h"
  36. #include "my_i2c.h"
  37. #include "bizhang.h"
  38. #include "gensui.h"
  39.  
  40. uint8_t speed_cnt = 0;
  41. uint8_t speedMsg[24] = {0};
  42.  
  43. double leftDistance = 0;
  44. double rightDistance = 0;
  45. double middleDistance = 0;
  46.  
  47. /* USER CODE END Includes */
  48.  
  49. /* Private typedef -----------------------------------------------------------*/
  50. /* USER CODE BEGIN PTD */
  51.  
  52. /* USER CODE END PTD */
  53.  
  54. /* Private define ------------------------------------------------------------*/
  55. /* USER CODE BEGIN PD */
  56. /* USER CODE END PD */
  57.  
  58. /* Private macro -------------------------------------------------------------*/
  59. /* USER CODE BEGIN PM */
  60.  
  61. /* USER CODE END PM */
  62.  
  63. /* Private variables ---------------------------------------------------------*/
  64.  
  65. /* USER CODE BEGIN PV */
  66.  
  67. /* USER CODE END PV */
  68.  
  69. /* Private function prototypes -----------------------------------------------*/
  70. void SystemClock_Config(void);
  71. /* USER CODE BEGIN PFP */
  72.  
  73. /* USER CODE END PFP */
  74.  
  75. /* Private user code ---------------------------------------------------------*/
  76. /* USER CODE BEGIN 0 */
  77.  
  78. /* 引脚中断的回调函数 */
  79. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  80. {
  81.     if (GPIO_Pin == GPIO_PIN_13)
  82.     { /* 如果是PB13引脚产生的中断 */
  83.         // HAL_Delay(50);  /* 按键防抖，这个delay函数不知道为什么引起OLED显示失败 */
  84.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET)
  85.         {
  86.             speed_cnt++;
  87.         }
  88.     }
  89. }
  90.  
  91. /* 定时器中断的回调函数 */
  92. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  93. {
  94.     // 判断是否是定时器3产生的中断
  95.     if (htim3.Instance == TIM3)
  96.     {
  97.         memset(speedMsg, 0, 24);
  98.         sprintf((char *)speedMsg, "speed:%d cm/s", speed_cnt);
  99.         printf("%s
", speedMsg);
  100.         oledShowString(3, 1, (char *)speedMsg);
  101.         speed_cnt = 0;
  102.     }
  103. }
  104.  
  105. /* USER CODE END 0 */
  106.  
  107. /**
  108.  * @brief  The application entry point.
  109.  * @retval int
  110.  */
  111. int main(void)
  112. {
  113.     /* USER CODE BEGIN 1 */
  114.  
  115.     /* USER CODE END 1 */
  116.  
  117.     /* MCU Configuration--------------------------------------------------------*/
  118.  
  119.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  120.     HAL_Init();
  121.  
  122.     /* USER CODE BEGIN Init */
  123.  
  124.     /* USER CODE END Init */
  125.  
  126.     /* Configure the system clock */
  127.     SystemClock_Config();
  128.  
  129.     /* USER CODE BEGIN SysInit */
  130.  
  131.     /* USER CODE END SysInit */
  132.  
  133.     /* Initialize all configured peripherals */
  134.     MX_GPIO_Init();
  135.     MX_USART1_UART_Init();
  136.     MX_TIM2_Init();
  137.     MX_TIM3_Init();
  138.     MX_TIM1_Init();
  139.     MX_TIM4_Init();
  140.     /* USER CODE BEGIN 2 */
  141.  
  142.     oledInit();     // OLED初始化
  143.     oledClean(); /* 清屏函数 */
  144.  
  145.     // 设置寻址模式
  146.     oledWriteCmd(0x20); // 设置内存
  147.     oledWriteCmd(0x02); // 选择页寻址模式
  148.  
  149.     oledShowString(1, 1, "diedie_car");
  150.     oledShowString(2, 1, "move: stop");
  151.  
  152.     oledShowString(4, 1, "mode: gensui");
  153.  
  154.     /* USER CODE END 2 */
  155.  
  156.     /* Infinite loop */
  157.     /* USER CODE BEGIN WHILE */
  158.     while (1)
  159.     {
  160.         /* USER CODE END WHILE */
  161.  
  162.         /* USER CODE BEGIN 3 */
  163.  
  164.         // printf("jiangxiaoya
");
  165.         // HAL_Delay(1000);
  166.  
  167.         // followMode();
  168.  
  169.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  170.  
  171.         // bizhang_mode();
  172.  
  173.         // printf("middle:%f
",middleDistance);
  174.     }
  175.     /* USER CODE END 3 */
  176. }
  177.  
  178. /**
  179.  * @brief System Clock Configuration
  180.  * @retval None
  181.  */
  182. void SystemClock_Config(void)
  183. {
  184.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  185.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  186.  
  187.     /** Initializes the RCC Oscillators according to the specified parameters
  188.      * in the RCC_OscInitTypeDef structure.
  189.      */
  190.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  191.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  192.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  193.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  194.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  195.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  196.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  197.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  198.     {
  199.         Error_Handler();
  200.     }
  201.  
  202.     /** Initializes the CPU, AHB and APB buses clocks
  203.      */
  204.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  205.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  206.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  207.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  208.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  209.  
  210.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  211.     {
  212.         Error_Handler();
  213.     }
  214. }
  215.  
  216. /* USER CODE BEGIN 4 */
  217.  
  218. /* USER CODE END 4 */
  219.  
  220. /**
  221.  * @brief  This function is executed in case of error occurrence.
  222.  * @retval None
  223.  */
  224. void Error_Handler(void)
  225. {
  226.     /* USER CODE BEGIN Error_Handler_Debug */
  227.     /* User can add his own implementation to report the HAL error return state */
  228.     __disable_irq();
  229.     while (1)
  230.     {
  231.     }
  232.     /* USER CODE END Error_Handler_Debug */
  233. }
  234.  
  235. #ifdef USE_FULL_ASSERT
  236. /**
  237.  * @brief  Reports the name of the source file and the source line number
  238.  *         where the assert_param error has occurred.
  239.  * @param  file: pointer to the source file name
  240.  * @param  line: assert_param error line source number
  241.  * @retval None
  242.  */
  243. void assert_failed(uint8_t *file, uint32_t line)
  244. {
  245.     /* USER CODE BEGIN 6 */
  246.     /* User can add his own implementation to report the file name and line number,
  247.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  248.     /* USER CODE END 6 */
  249. }
  250. #endif /* USE_FULL_ASSERT */

循迹小车

硬件组成

循迹模块（TCRT5000传感器）

  • 当发射出的红外线没有被反射回来或被反射回来但强度不够大时，DO输出高电平，灯灭。 黑色吸收红外线，DO输出高电平，灯亮。

  • 当发射出的红外线被反射回来或被反射回来且强度足够大，DO输出低电平，灯亮。 白色反射红外线，DO输出低电平，灯亮。

  • 即黑色DO输出高电平，模块灯灭，白色DO输出低电平，模块灯亮。

模块与STM32F103板子接线

  • 左循迹模块 <-> PA6

  • 右循迹模块 <-> PA7

STM32CubeMX相关配置

GPIO配置

配置PA6引脚、PA7引脚为输入引脚。

文件编写

添加文件xunji.c

  1.  
  2. #include "gpio.h"
  3. #include "car.h"
  4.  
  5. /* PA6:左红外循迹模块，PA7:右红外循迹模块 */
  6.  
  7. void tracingMode()
  8. {
  9.     // oledShowString(4, 1, "mode: gensui");
  10.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6) == GPIO_PIN_RESET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_RESET)
  11.     { //
  12.         car_goForward();
  13.     }
  14.  
  15.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6) == GPIO_PIN_RESET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_SET)
  16.     {
  17.         car_goLeft();
  18.     }
  19.  
  20.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6) == GPIO_PIN_SET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_RESET)
  21.     {
  22.  
  23.         car_goRight();
  24.     }
  25.  
  26.     if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6) == GPIO_PIN_SET && HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_SET)
  27.     {
  28.         car_goStop();
  29.     }
  30. }

添加文件xunji.h

  1.  
  2. void tracingMode(void);

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "tim.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28.  
  29. #include 
  30. #include 
  31.  
  32. #include "car.h"
  33. #include "oled.h"
  34. #include "sg90.h"
  35. #include "hc_sr04.h"
  36. #include "my_i2c.h"
  37. #include "bizhang.h"
  38. #include "gensui.h"
  39. #include "xunji.h"
  40.  
  41. uint8_t speed_cnt = 0;
  42. uint8_t speedMsg[24] = {0};
  43.  
  44. double leftDistance = 0;
  45. double rightDistance = 0;
  46. double middleDistance = 0;
  47.  
  48. /* USER CODE END Includes */
  49.  
  50. /* Private typedef -----------------------------------------------------------*/
  51. /* USER CODE BEGIN PTD */
  52.  
  53. /* USER CODE END PTD */
  54.  
  55. /* Private define ------------------------------------------------------------*/
  56. /* USER CODE BEGIN PD */
  57. /* USER CODE END PD */
  58.  
  59. /* Private macro -------------------------------------------------------------*/
  60. /* USER CODE BEGIN PM */
  61.  
  62. /* USER CODE END PM */
  63.  
  64. /* Private variables ---------------------------------------------------------*/
  65.  
  66. /* USER CODE BEGIN PV */
  67.  
  68. /* USER CODE END PV */
  69.  
  70. /* Private function prototypes -----------------------------------------------*/
  71. void SystemClock_Config(void);
  72. /* USER CODE BEGIN PFP */
  73.  
  74. /* USER CODE END PFP */
  75.  
  76. /* Private user code ---------------------------------------------------------*/
  77. /* USER CODE BEGIN 0 */
  78.  
  79. /* 引脚中断的回调函数 */
  80. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  81. {
  82.     if (GPIO_Pin == GPIO_PIN_13)
  83.     { /* 如果是PB13引脚产生的中断 */
  84.         // HAL_Delay(50);  /* 按键防抖，这个delay函数不知道为什么引起OLED显示失败 */
  85.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET)
  86.         {
  87.             speed_cnt++;
  88.         }
  89.     }
  90. }
  91.  
  92. /* 定时器中断的回调函数 */
  93. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  94. {
  95.     // 判断是否是定时器3产生的中断
  96.     if (htim3.Instance == TIM3)
  97.     {
  98.         if (speed_cnt < 10)
  99.         {
  100.             sprintf((char *)speedMsg, "speed:  %d cm/s ", speed_cnt);
  101.         }
  102.         else
  103.         {
  104.             sprintf((char *)speedMsg, "speed: %d cm/s ", speed_cnt);
  105.         }
  106.         // printf("%s
",speedMsg);
  107.         oledShowString(3, 1, (char *)speedMsg);
  108.         speed_cnt = 0;
  109.     }
  110. }
  111.  
  112. /* USER CODE END 0 */
  113.  
  114. /**
  115.  * @brief  The application entry point.
  116.  * @retval int
  117.  */
  118. int main(void)
  119. {
  120.     /* USER CODE BEGIN 1 */
  121.  
  122.     /* USER CODE END 1 */
  123.  
  124.     /* MCU Configuration--------------------------------------------------------*/
  125.  
  126.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  127.     HAL_Init();
  128.  
  129.     /* USER CODE BEGIN Init */
  130.  
  131.     /* USER CODE END Init */
  132.  
  133.     /* Configure the system clock */
  134.     SystemClock_Config();
  135.  
  136.     /* USER CODE BEGIN SysInit */
  137.  
  138.     /* USER CODE END SysInit */
  139.  
  140.     /* Initialize all configured peripherals */
  141.     MX_GPIO_Init();
  142.     MX_USART1_UART_Init();
  143.     MX_TIM2_Init();
  144.     MX_TIM3_Init();
  145.     MX_TIM1_Init();
  146.     MX_TIM4_Init();
  147.     /* USER CODE BEGIN 2 */
  148.  
  149.     oledInit();     // OLED初始化
  150.     oledClean(); /* 清屏函数 */
  151.  
  152.     // 设置寻址模式
  153.     oledWriteCmd(0x20); // 设置内存
  154.     oledWriteCmd(0x02); // 选择页寻址模式
  155.  
  156.     oledShowString(1, 1, "diedie_car");
  157.     oledShowString(2, 1, "move: stop");
  158.  
  159.     oledShowString(4, 1, "mode: xunji");
  160.  
  161.     /* USER CODE END 2 */
  162.  
  163.     /* Infinite loop */
  164.     /* USER CODE BEGIN WHILE */
  165.     while (1)
  166.     {
  167.         /* USER CODE END WHILE */
  168.  
  169.         /* USER CODE BEGIN 3 */
  170.  
  171.         tracingMode();
  172.  
  173.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  174.  
  175.     }
  176.     /* USER CODE END 3 */
  177. }
  178.  
  179. /**
  180.  * @brief System Clock Configuration
  181.  * @retval None
  182.  */
  183. void SystemClock_Config(void)
  184. {
  185.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  186.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  187.  
  188.     /** Initializes the RCC Oscillators according to the specified parameters
  189.      * in the RCC_OscInitTypeDef structure.
  190.      */
  191.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  192.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  193.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  194.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  195.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  196.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  197.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  198.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  199.     {
  200.         Error_Handler();
  201.     }
  202.  
  203.     /** Initializes the CPU, AHB and APB buses clocks
  204.      */
  205.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  206.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  207.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  208.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  209.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  210.  
  211.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  212.     {
  213.         Error_Handler();
  214.     }
  215. }
  216.  
  217. /* USER CODE BEGIN 4 */
  218.  
  219. /* USER CODE END 4 */
  220.  
  221. /**
  222.  * @brief  This function is executed in case of error occurrence.
  223.  * @retval None
  224.  */
  225. void Error_Handler(void)
  226. {
  227.     /* USER CODE BEGIN Error_Handler_Debug */
  228.     /* User can add his own implementation to report the HAL error return state */
  229.     __disable_irq();
  230.     while (1)
  231.     {
  232.     }
  233.     /* USER CODE END Error_Handler_Debug */
  234. }
  235.  
  236. #ifdef USE_FULL_ASSERT
  237. /**
  238.  * @brief  Reports the name of the source file and the source line number
  239.  *         where the assert_param error has occurred.
  240.  * @param  file: pointer to the source file name
  241.  * @param  line: assert_param error line source number
  242.  * @retval None
  243.  */
  244. void assert_failed(uint8_t *file, uint32_t line)
  245. {
  246.     /* USER CODE BEGIN 6 */
  247.     /* User can add his own implementation to report the file name and line number,
  248.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  249.     /* USER CODE END 6 */
  250. }
  251. #endif /* USE_FULL_ASSERT */

语音控制小车，循迹、跟随、避障三种功能切换

硬件组成

语音模块SU-03T

可以通过智能公元平台配置语音词条。

智能公元产品使用方法

  1. 创建产品

  1. 选择对应的模块

  1. 配置相应的信息

  1. 根据需要将某些引脚配置成串口或GPIO口

  1. 添加SU-03T语音模块的唤醒词

  1. 添加命令词

  1. 为某个命令词添加控制，通过某个引脚输出电平或者通过串口输出信息

  1. 配置其他信息

  1. 生成SDK

  1. 下载固件压缩包

  1. 将固件包解压到没中文路径的文件夹

  1. 去智能公元官方下载烧录软件

  1. 打开烧录软件，烧录固件

  1. 选择刚刚生成的固件烧录到语音

模块与STM32F103板子接线

  • SU-03T的PB6引脚 <-> PA9（USART1_TX引脚）

  • SU-03T的PB7引脚 <-> PA10（USART1_RX引脚）

文件编写

修改usart.c文件

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file    usart.c
  6.  * @brief   This file provides code for the configuration
  7.  *          of the USART instances.
  8.  ******************************************************************************
  9.  * @attention
  10.  *
  11.  * Copyright (c) 2023 STMicroelectronics.
  12.  * All rights reserved.
  13.  *
  14.  * This software is licensed under terms that can be found in the LICENSE file
  15.  * in the root directory of this software component.
  16.  * If no LICENSE file comes with this software, it is provided AS-IS.
  17.  *
  18.  ******************************************************************************
  19.  */
  20. /* USER CODE END Header */
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "usart.h"
  23.  
  24. /* USER CODE BEGIN 0 */
  25.  
  26. #include 
  27. #include 
  28.  
  29. #include "car.h"
  30. #include "oled.h"
  31.  
  32. #define USART_REC_LEN 200
  33.  
  34. extern uint8_t mode_mark;
  35.  
  36. // 串口接收缓存（1字节）
  37. uint8_t buf = 0;
  38.  
  39. uint8_t UART1_RX_Buffer[USART_REC_LEN]; // 接收缓冲，串口接收的数据存放地点
  40.  
  41. // 串口接收状态，16位
  42. uint16_t UART1_RX_STA = 0;
  43. // bit15： 如果是1表示接收完成
  44. // bit14： 如果是1表示接收到回车(0x0d)
  45. // bit13~bit0： 接收到的有效字节数目
  46.  
  47. /* USER CODE END 0 */
  48.  
  49. UART_HandleTypeDef huart1;
  50.  
  51. /* USART1 init function */
  52.  
  53. void MX_USART1_UART_Init(void)
  54. {
  55.  
  56.     /* USER CODE BEGIN USART1_Init 0 */
  57.  
  58.     /* USER CODE END USART1_Init 0 */
  59.  
  60.     /* USER CODE BEGIN USART1_Init 1 */
  61.  
  62.     /* USER CODE END USART1_Init 1 */
  63.     huart1.Instance = USART1;
  64.     huart1.Init.BaudRate = 115200;
  65.     huart1.Init.WordLength = UART_WORDLENGTH_8B;
  66.     huart1.Init.StopBits = UART_STOPBITS_1;
  67.     huart1.Init.Parity = UART_PARITY_NONE;
  68.     huart1.Init.Mode = UART_MODE_TX_RX;
  69.     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  70.     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  71.     if (HAL_UART_Init(&huart1) != HAL_OK)
  72.     {
  73.         Error_Handler();
  74.     }
  75.     /* USER CODE BEGIN USART1_Init 2 */
  76.  
  77.     /* 开启串口1的接收中断 */
  78.     HAL_UART_Receive_IT(&huart1, &buf, 1); /* 每接收一个串口数据调用一次串口接收完成回调函数 */
  79.  
  80.     /* USER CODE END USART1_Init 2 */
  81. }
  82.  
  83. void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
  84. {
  85.  
  86.     GPIO_InitTypeDef GPIO_InitStruct = {0};
  87.     if (uartHandle->Instance == USART1)
  88.     {
  89.         /* USER CODE BEGIN USART1_MspInit 0 */
  90.  
  91.         /* USER CODE END USART1_MspInit 0 */
  92.         /* USART1 clock enable */
  93.         __HAL_RCC_USART1_CLK_ENABLE();
  94.  
  95.         __HAL_RCC_GPIOA_CLK_ENABLE();
  96.         /**USART1 GPIO Configuration
  97.         PA9     ------> USART1_TX
  98.         PA10     ------> USART1_RX
  99.         */
  100.         GPIO_InitStruct.Pin = GPIO_PIN_9;
  101.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  102.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  103.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  104.  
  105.         GPIO_InitStruct.Pin = GPIO_PIN_10;
  106.         GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  107.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  108.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  109.  
  110.         /* USART1 interrupt Init */
  111.         HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
  112.         HAL_NVIC_EnableIRQ(USART1_IRQn);
  113.         /* USER CODE BEGIN USART1_MspInit 1 */
  114.  
  115.         /* USER CODE END USART1_MspInit 1 */
  116.     }
  117. }
  118.  
  119. void HAL_UART_MspDeInit(UART_HandleTypeDef *uartHandle)
  120. {
  121.  
  122.     if (uartHandle->Instance == USART1)
  123.     {
  124.         /* USER CODE BEGIN USART1_MspDeInit 0 */
  125.  
  126.         /* USER CODE END USART1_MspDeInit 0 */
  127.         /* Peripheral clock disable */
  128.         __HAL_RCC_USART1_CLK_DISABLE();
  129.  
  130.         /**USART1 GPIO Configuration
  131.         PA9     ------> USART1_TX
  132.         PA10     ------> USART1_RX
  133.         */
  134.         HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9 | GPIO_PIN_10);
  135.  
  136.         /* USART1 interrupt Deinit */
  137.         HAL_NVIC_DisableIRQ(USART1_IRQn);
  138.         /* USER CODE BEGIN USART1_MspDeInit 1 */
  139.  
  140.         HAL_UART_Receive_IT(&huart1, &buf, 1);
  141.  
  142.         /* USER CODE END USART1_MspDeInit 1 */
  143.     }
  144. }
  145.  
  146. /* USER CODE BEGIN 1 */
  147.  
  148. /* 重写stdio.h文件中的prinft()里的fputc()函数 */
  149. int fputc(int my_data, FILE *p)
  150. {
  151.     unsigned char temp = my_data;
  152.     // 改写后，使用printf()函数会将数据通过串口一发送出去
  153.     HAL_UART_Transmit(&huart1, &temp, 1, 0xffff); // 0xfffff为最大超时时间
  154.     return my_data;
  155. }
  156.  
  157. /* 串口接收完成回调函数 */
  158. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  159. {
  160.     // 判断中断是哪个串口触发的
  161.     if (huart->Instance == USART1)
  162.     {
  163.  
  164.         // 判断接收是否完成，即判断UART1_RX_STA的bit15是否为1
  165.         if (!(UART1_RX_STA & 0x8000))
  166.         { // 如果没接收完成就进入接收流程
  167.  
  168.             // 判断是否接收到回车0x0d
  169.             if (UART1_RX_STA & 0x4000)
  170.             {
  171.  
  172.                 // 判断是否接收到换行0x0a
  173.                 if (buf == 0x0a)
  174.                 {
  175.  
  176.                     // 如果回车和换行都接收到了，则表示接收完成,即把bit15拉高
  177.                     UART1_RX_STA |= 0x8000;
  178.                 }
  179.                 else
  180.                 { // 如果接收到回车0x0d没有接收到换行0x0a
  181.  
  182.                     // 则认为接收错误，重新开始接收
  183.                     UART1_RX_STA = 0;
  184.                 }
  185.             }
  186.             else
  187.             { // 如果没有接收到回车0x0d
  188.  
  189.                 // 则判断收到的这个字符是否是回车0x0d
  190.                 if (buf == 0x0d)
  191.                 {
  192.  
  193.                     // 如果这个字符是回车，则将将bit14拉高，表示接收到回车
  194.                     UART1_RX_STA |= 0x4000;
  195.                 }
  196.                 else
  197.                 { // 如果不是回车
  198.  
  199.                     // 则将这个字符存放到缓存数组中
  200.                     UART1_RX_Buffer[UART1_RX_STA & 0x3ffff] = buf;
  201.                     UART1_RX_STA++;
  202.  
  203.                     // 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
  204.                     if (UART1_RX_STA > USART_REC_LEN - 1)
  205.                     {
  206.                         UART1_RX_STA = 0;
  207.                     }
  208.                 }
  209.             }
  210.         }
  211.         // 如果接收完成则重新开启串口1的接收中断
  212.         HAL_UART_Receive_IT(&huart1, &buf, 1);
  213.     }
  214. }
  215.  
  216. /* 对串口接收数据的处理 */
  217. void usart1_receive_data_handle()
  218. {
  219.     /* 判断判断串口是否接收完成 */
  220.     if (UART1_RX_STA & 0x8000)
  221.     {
  222.         printf("接收完成
");
  223.  
  224.         // 串口接收完数据后，对串口数据进行处理
  225.         if (!strcmp((const char *)UART1_RX_Buffer, "bizhang"))
  226.         {
  227.             printf("避障模式
");
  228.             mode_mark = 0;
  229.         }
  230.         else if (!strcmp((const char *)UART1_RX_Buffer, "gensui"))
  231.         {
  232.             printf("跟随模式
");
  233.             mode_mark = 1;
  234.         }
  235.         else if (!strcmp((const char *)UART1_RX_Buffer, "xunji"))
  236.         {
  237.             printf("循迹模式
");
  238.             mode_mark = 2;
  239.         }
  240.  
  241.         // 接收到其他数据，进行报错
  242.         else
  243.         {
  244.             if (UART1_RX_Buffer[0] != '')
  245.             {
  246.                 printf("%s
", "输入错误，请重新输入");
  247.             }
  248.         }
  249.  
  250.         // 换行，重新开始下一次接收
  251.         memset(UART1_RX_Buffer, 0, USART_REC_LEN);
  252.         // printf("
");
  253.         UART1_RX_STA = 0;
  254.     }
  255. }
  256.  
  257. /* USER CODE END 1 */

main.c文件编写

  1.  
  2. /* USER CODE BEGIN Header */
  3. /**
  4.  ******************************************************************************
  5.  * @file           : main.c
  6.  * @brief          : Main program body
  7.  ******************************************************************************
  8.  * @attention
  9.  *
  10.  * Copyright (c) 2023 STMicroelectronics.
  11.  * All rights reserved.
  12.  *
  13.  * This software is licensed under terms that can be found in the LICENSE file
  14.  * in the root directory of this software component.
  15.  * If no LICENSE file comes with this software, it is provided AS-IS.
  16.  *
  17.  ******************************************************************************
  18.  */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "tim.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28.  
  29. #include 
  30. #include 
  31.  
  32. #include "car.h"
  33. #include "oled.h"
  34. #include "sg90.h"
  35. #include "hc-08.h"
  36. #include "my_i2c.h"
  37. #include "bizhang.h"
  38. #include "gensui.h"
  39. #include "xunji.h"
  40.  
  41. #define BZ 0
  42. #define GS 1
  43. #define XJ 2
  44.  
  45. uint8_t speed_cnt = 0;
  46. uint8_t speedMsg[24] = {0};
  47.  
  48. uint8_t mode_mark = 0;
  49. uint8_t mark = 0;
  50.  
  51. double leftDistance = 0;
  52. double rightDistance = 0;
  53. double middleDistance = 0;
  54.  
  55. /* USER CODE END Includes */
  56.  
  57. /* Private typedef -----------------------------------------------------------*/
  58. /* USER CODE BEGIN PTD */
  59.  
  60. /* USER CODE END PTD */
  61.  
  62. /* Private define ------------------------------------------------------------*/
  63. /* USER CODE BEGIN PD */
  64. /* USER CODE END PD */
  65.  
  66. /* Private macro -------------------------------------------------------------*/
  67. /* USER CODE BEGIN PM */
  68.  
  69. /* USER CODE END PM */
  70.  
  71. /* Private variables ---------------------------------------------------------*/
  72.  
  73. /* USER CODE BEGIN PV */
  74.  
  75. /* USER CODE END PV */
  76.  
  77. /* Private function prototypes -----------------------------------------------*/
  78. void SystemClock_Config(void);
  79. /* USER CODE BEGIN PFP */
  80.  
  81. /* USER CODE END PFP */
  82.  
  83. /* Private user code ---------------------------------------------------------*/
  84. /* USER CODE BEGIN 0 */
  85.  
  86. /* 引脚中断的回调函数 */
  87. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
  88. {
  89.     if (GPIO_Pin == GPIO_PIN_13)
  90.     { /* 如果是PB13引脚产生的中断 */
  91.         // HAL_Delay(50);  /* 按键防抖，这个delay函数不知道为什么引起OLED显示失败 */
  92.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == GPIO_PIN_RESET)
  93.         {
  94.             speed_cnt++;
  95.         }
  96.     }
  97. }
  98.  
  99. /* 定时器中断的回调函数 */
  100. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  101. {
  102.     // 判断是否是定时器3产生的中断
  103.     if (htim3.Instance == TIM3)
  104.     {
  105.         if (speed_cnt < 10)
  106.         {
  107.             sprintf((char *)speedMsg, "speed:  %d cm/s ", speed_cnt);
  108.         }
  109.         else
  110.         {
  111.             sprintf((char *)speedMsg, "speed: %d cm/s ", speed_cnt);
  112.         }
  113.         // printf("%s
",speedMsg);
  114.         oledShowString(3, 1, (char *)speedMsg);
  115.         speed_cnt = 0;
  116.     }
  117. }
  118.  
  119. void voice_handle()
  120. {
  121.     if (mode_mark == 0)  /* 避障模式 */
  122.     {
  123.         if (mark != BZ)
  124.         {
  125.             oled_rowClean(4);
  126.             oledShowString(4, 1, "mode: bizhang");
  127.         }
  128.         mark = BZ;
  129.         avoidMode(); 
  130.     }
  131.     else if (mode_mark == 1)  /* 跟随模式 */
  132.     {
  133.         if (mark != GS)
  134.         {
  135.             oled_rowClean(4);
  136.             oledShowString(4, 1, "mode: gensui");
  137.         }
  138.         mark = GS;
  139.         followMode(); 
  140.     }
  141.     else if (mode_mark == 2)  /* 循迹模式 */
  142.     {
  143.         if (mark != XJ)
  144.         {
  145.             oled_rowClean(4);
  146.             oledShowString(4, 1, "mode: xunji");
  147.         }
  148.         mark = XJ;
  149.         tracingMode(); 
  150.     }
  151.     else
  152.     {
  153.         oled_rowClean(4);
  154.         oledShowString(4, 1, "voice error");
  155.     }
  156. }
  157.  
  158. /* USER CODE END 0 */
  159.  
  160. /**
  161.  * @brief  The application entry point.
  162.  * @retval int
  163.  */
  164. int main(void)
  165. {
  166.     /* USER CODE BEGIN 1 */
  167.  
  168.     /* USER CODE END 1 */
  169.  
  170.     /* MCU Configuration--------------------------------------------------------*/
  171.  
  172.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  173.     HAL_Init();
  174.  
  175.     /* USER CODE BEGIN Init */
  176.  
  177.     /* USER CODE END Init */
  178.  
  179.     /* Configure the system clock */
  180.     SystemClock_Config();
  181.  
  182.     /* USER CODE BEGIN SysInit */
  183.  
  184.     /* USER CODE END SysInit */
  185.  
  186.     /* Initialize all configured peripherals */
  187.     MX_GPIO_Init();
  188.     MX_USART1_UART_Init();
  189.     MX_TIM2_Init();
  190.     MX_TIM3_Init();
  191.     MX_TIM1_Init();
  192.     MX_TIM4_Init();
  193.     /* USER CODE BEGIN 2 */
  194.  
  195.     oledInit();     // OLED初始化
  196.     oledClean(); /* 清屏函数 */
  197.  
  198.     // 设置寻址模式
  199.     oledWriteCmd(0x20); // 设置内存
  200.     oledWriteCmd(0x02); // 选择页寻址模式
  201.  
  202.     oledShowString(1, 1, "diedie_car");
  203.     oledShowString(2, 1, "move: stop");
  204.  
  205.     oledShowString(4, 1, "mode: bizhang");
  206.  
  207.     /* USER CODE END 2 */
  208.  
  209.     /* Infinite loop */
  210.     /* USER CODE BEGIN WHILE */
  211.     while (1)
  212.     {
  213.         /* USER CODE END WHILE */
  214.  
  215.         /* USER CODE BEGIN 3 */
  216.  
  217.         voice_handle();
  218.         
  219.         usart1_receive_data_handle(); /* 对串口读取的数据进行处理 */
  220.  
  221.  
  222.     }
  223.     /* USER CODE END 3 */
  224. }
  225.  
  226. /**
  227.  * @brief System Clock Configuration
  228.  * @retval None
  229.  */
  230. void SystemClock_Config(void)
  231. {
  232.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  233.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  234.  
  235.     /** Initializes the RCC Oscillators according to the specified parameters
  236.      * in the RCC_OscInitTypeDef structure.
  237.      */
  238.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  239.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  240.     RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  241.     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  242.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  243.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  244.     RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  245.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  246.     {
  247.         Error_Handler();
  248.     }
  249.  
  250.     /** Initializes the CPU, AHB and APB buses clocks
  251.      */
  252.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  253.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  254.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  255.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  256.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  257.  
  258.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  259.     {
  260.         Error_Handler();
  261.     }
  262. }
  263.  
  264. /* USER CODE BEGIN 4 */
  265.  
  266. /* USER CODE END 4 */
  267.  
  268. /**
  269.  * @brief  This function is executed in case of error occurrence.
  270.  * @retval None
  271.  */
  272. void Error_Handler(void)
  273. {
  274.     /* USER CODE BEGIN Error_Handler_Debug */
  275.     /* User can add his own implementation to report the HAL error return state */
  276.     __disable_irq();
  277.     while (1)
  278.     {
  279.     }
  280.     /* USER CODE END Error_Handler_Debug */
  281. }
  282.  
  283. #ifdef USE_FULL_ASSERT
  284. /**
  285.  * @brief  Reports the name of the source file and the source line number
  286.  *         where the assert_param error has occurred.
  287.  * @param  file: pointer to the source file name
  288.  * @param  line: assert_param error line source number
  289.  * @retval None
  290.  */
  291. void assert_failed(uint8_t *file, uint32_t line)
  292. {
  293.     /* USER CODE BEGIN 6 */
  294.     /* User can add his own implementation to report the file name and line number,
  295.        ex: printf("Wrong parameters value: file %s on line %d
", file, line) */
  296.     /* USER CODE END 6 */
  297. }
  298. #endif /* USE_FULL_ASSERT */
注：本文转载自blog.csdn.net的haozigegie的文章"https://blog.csdn.net/weixin_54076783/article/details/129676471"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！