MaixCAM和stm32串口通信，完成二维码识别_MaixCAM与stm32通信实现apirltag码识别及巡线功能

        这是一个前段时间做的一个智能小车，主要是想用小车识别带颜色的线路，以及路上可能遇到的二维码或apirltag标签码。在程序编写方面可能有一些不成熟，但是功能还是有的，已实验通过。

一、所需硬件

        MaixCAM、STM32开发板（使用串口1）

二、MaixCAM端

        直接上代码：

代码如下（示例）：

  1. '''
  2. # 功能:同时实现AprilTag标记跟踪和巡线,并读取AprilTag标记(同二维码)中心点,作为巡线的标识
  3. #       巡线时是黄线，停车点是蓝线。
  4. # 串口发送数据:0x2C 0x12 X_H  X_L y Z R 0XB5 
  5. # V1.0
  6. # 2024.6.23
  7. # 修改
  8. # V1.1
  9. # 2024.6.26
  10. # 修改内容：
  11. # 2024.7.16
  12. # 修改内容：增加标签的旋转角度识别，并把值通过串口发送
  13. # 2024.8.28
  14. # 修改内容：修改识别标签的类型为AprilTag_36H10,这个可以从0到2319，使用的标签可能多，所以用两们8位数据发送线单片机。
  15. # 串口发送数据格式：0x2C 0x12 X_H  X_L y Z_H  Z_L R_H  R_L 0XB5
  16. '''
  17. from maix import image, camera, display
  18. from maix import app, uart, pinmap, time
  19. import sys
  20.  
  21. # 默认使用串口，也就是A16---TX，A17---RX
  22. device = "/dev/ttyS0"
  23. serial0 = uart.UART(device, 115200)   # 串口波特率是115200
  24.  
  25. #serial0.write("hello 1\r\n".encode()) # 初始化先发送hello 1  和hello 2
  26. #serial0.write_str("hello 2\r\n")
  27.  
  28. cam = camera.Camera(320,240,)
  29. cam.skip_frames(30)           # 跳过开头的30帧
  30. disp = display.Display()
  31.  
  32. families = image.ApriltagFamilies.TAG36H10
  33. x_scale = cam.width() / 160     # 图像缩放
  34. y_scale = cam.height() / 120
  35.  
  36. # 基本初始化--巡线参数
  37. # 寻找到对应的直线
  38. #thresholds = [[0, 80, 40, 80, 10, 80]]      # red
  39. #thresholds1 = [[0, 80, -120, -10, 0, 30]]    # green
  40. #thresholds = [[0, 80, 30, 100, -120, -60]]  # blue
  41. thresholds1 = [[33,46,-18,53,-104,-33]]  #蓝色
  42. thresholds = [[74,94,-23,-3,22,42],[50,70,-12,8,52,72],[77,97,-29,-9,32,52]]    # 不同时间段的黄色值，可以提高因为白天和晚上不同光线的影响。
  43.  
  44. '''
  45. # 串口发送函数
  46. # 向STM32F103单片机发送数据包
  47. # 数据包格式为2个帧头,5个数据和一个帧尾,x:上位控制舵机值,发送时先发高8位,再发低8位,
  48. # y:是否遇到十字路口标志1为遇到十字路口,
  49. # z:是Apriltag内容(和二维相似),表示标志点,TAG36H10 → 0 to 2319  0x00ff & z:是低8位,z>>8,高8位。
  50. # R:是旋转角度, 是标签的旋转角度,从0~360度。0x00ff & R:是低8位,R>>8:高8位。
  51. '''
  52. def sending_data(x,y,z,R):
  53.     global uart;
  54.     FH = [0x2C,0x12,x>>8,0x00ff & x,y,z>>8,0x00ff & z,R>>8,0x00ff & R,0x5B]
  55.     serial0.write(bytes(FH));
  56.     serial0.write_str("\r\n");
  57.  
  58. # 巡线函数与二维码识别函数结合
  59. def Lines_function():
  60.     roi1            = [0,100,320,16]       #巡线敏感区
  61.     roi2            = [0,80,320,8]        #关键点敏感区
  62.     expectedValue   = 160                  #巡线位置期望,拍摄的画面是320X240
  63.     err             = 0                    #本次误差
  64.     old_err         = 0                    #上次误差
  65.     Kp              = 3.2                    #PID比例系数
  66.     Kd              = 0.5                    #PID微分系数
  67.     Flag            = 0                    #用于关键点标志
  68.     servo_data      = 1500                 #发送给上位机的值，用于控制舵机
  69.     servo_Value     = 1500                 #期望转角值
  70.  
  71.     # 基本初始化--巡线参数
  72.     roi3                     = [0,0,160,80]         #标签识别敏感区,由于图片是缩小到了（160，120），取上半部分
  73.     AprilTag_expectedValue   = 160                  #巡线位置期望,拍摄的画面是320X240
  74.     AprilTag_err             = 0                    #本次误差
  75.     AprilTag_old_err         = 0                    #上次误差
  76.     AprilTag_Kp              = 3.2                  #PID比例系数
  77.     AprilTag_servo_data      = 1500                 #发送给上位机的值，用于控制舵机
  78.     AprilTag_servo_Value     = 1500                 #期望转角值
  79.     AprilTag_payload         = 0                    #标签的id
  80.     rotation_jiaodu          = 0                    #标签的旋转角度
  81.     
  82.     img = cam.read()
  83.     # 以下是Apriltag标签相关
  84.     new_img = img.resize(160, 120) #将图像缩放得更小，用更小的图像来让算法计算得更快
  85.     '''
  86.     寻找apriltag标签,并将查询结果保存到apriltags,
  87.     以供后续处理。
  88.     其中families用来选择apriltag族,默认为image.ApriltagFamilies.TAG36H10
  89.     '''
  90.     apriltags = new_img.find_apriltags(roi=roi3,families = families) # (roi=roi3,families = families)
  91.     # 以下是巡线相关
  92.     blobs1 = img.find_blobs(thresholds,roi=roi1, pixels_threshold=100,merge=True)    # 寻找色块方法实现巡线。
  93.     blobs2 = img.find_blobs(thresholds1,roi=roi2, pixels_threshold=100,merge=True,margin=40)
  94.     for a in apriltags:
  95.         corners = a.corners()
  96.         for i in range(4):
  97.             corners[i][0] = int(corners[i][0] * x_scale)
  98.             corners[i][1] = int(corners[i][1] * y_scale)
  99.         x = int(a.x() * x_scale)
  100.         y = int(a.y() * y_scale)
  101.         w = int(a.w() * x_scale)
  102.         h = int(a.h() * y_scale)
  103.  
  104.         #x_rota = int(a.x_rotation())
  105.         rotation_jiaodu = int(180 * a.rotation() // 3.1415)
  106.         #print(rotation_jiaodu)
  107.  
  108.         for i in range(4):
  109.             img.draw_line(corners[i][0], corners[i][1], corners[(i + 1) % 4][0], corners[(i + 1) % 4][1], image.COLOR_RED)
  110.             img.draw_string(x + w, y, "id: " + str(a.id()), image.COLOR_RED)
  111.         #img.draw_string(x + w, y + 15, "family: " + str(a.family()), image.COLOR_RED)
  112.             img.draw_string(x + w, y + 30, "rotation : " + str(180 * a.rotation() // 3.1415), image.COLOR_RED)
  113.            
  114.         #print(str(180 * a.rotation() // 3.1415))
  115.         
  116.         #PID计算
  117.         AprilTag_X_center =int(x+w/2)                       # 标签中心点x值
  118.         AprilTag_err=AprilTag_X_center-AprilTag_expectedValue # 得到线与摄像头中心的偏移量err
  119.         AprilTag_servo_data = AprilTag_servo_Value+(AprilTag_Kp*AprilTag_err+Kd*(AprilTag_err-AprilTag_old_err))     # 得到的偏差值err,可以进行简单PID计算。
  120.         AprilTag_old_err = AprilTag_err
  121.         servo_data = int(AprilTag_servo_data)
  122.         AprilTag_payload = int(a.id())        # 标签的id
  123.         '''
  124.         if(AprilTag_payload>256):
  125.             AprilTag_payload = 0xff;
  126.         '''
  127.         print(AprilTag_payload) 
  128.         #sending_data(servo_data,0,int(qr.payload()))
  129.         
  130.     if blobs1:
  131.             #servo_data_tmp.clear()   # 清空列表
  132.         for blob in blobs1:
  133.             img.draw_rect(blob[0], blob[1], blob[2], blob[3], image.COLOR_GREEN)# 画一个框，在兴趣区roi1的区域
  134.             img.draw_cross(blob[5],blob[6],image.COLOR_GREEN)   # 画一个十字                           
  135.             #PID计算
  136.             actualValue=int(blob[5])             # 实际色块的外框的中心x值
  137.             err=actualValue-expectedValue   # 得到线与摄像头中心的偏移量err       
  138.             # 得到的偏差值err,可以进行PID计算。
  139.             # 当偏差小于零时，说明小车向右偏，偏差大于零时，说明小车向左偏（原理是这样，要按实际模块安装在小车的方向）
  140.             servo_data = servo_Value+(Kp*err+Kd*(err-old_err))
  141.             old_err= err
  142.             #servo_data = servo_Value+Kp*err
  143.             servo_data = int(servo_data)  # 转换为整数
  144.             #print(servo_data)
  145.             #sending_data(servo_data,0,0)
  146.     # 当侦测关键点
  147.     if blobs2:
  148.         for blob in blobs2:
  149.             img.draw_rect(blob[0], blob[1], blob[2], blob[3], image.COLOR_WHITE)
  150.             img.draw_cross(blob[5], blob[6],image.COLOR_WHITE)
  151.             if blob[2] >50:  # 是否大于正常巡线时寻找到的色块外框宽度w值。
  152.                 Flag = 1
  153.             else: Flag = 0
  154.             #print(Flag)
  155.             #sending_data(0,Flag,0)
  156.         #img.draw_string(0, 0, "theta: " + str(theta) + ", rho: " + str(rho), image.COLOR_BLUE,2)     
  157.         #print(a.x1(),a.y1(),a.x2(),a.y2())
  158.     sending_data(servo_data,Flag,AprilTag_payload,rotation_jiaodu)
  159.     disp.show(img)
  160.  
  161. while 1:
  162.     Lines_function();
  163.     time.sleep_ms(200)

注：

        1、与STM32硬件连接时要注意串口顺序，使用交叉连接，还有MaixCAM模块提供了一个typec_USB接口，使用时注意方向，具体参考MaixCAM使用说明。

        2、波特率设置是115200（与STM32相同）

        3、程序中识别的标签码是AprilTag_36H10，他的范围是0~2319，这个也是根据个人项目而定，如果使用标签量少，可以使用AprilTag_36H11，具体可以查看相关说明。

        4、程序中，做了一个简易PID的控制，主要是把模块识别的线或标签中心点的值转换为小车舵机的控制数据。我的小车是和舵机控制转向的，中心值是1500，最左边是1200，最右边是1800。

        5、程序中，还可以识别到标签的ID，和角度值，这个功能是MaixCAM模块自带的，只要调用他的方法就可以，还是比较方便的。

        6、程序中，还设置了十字路口的识别，主是是当前面的色块大于一个数值时，就发送1到STM32，做为标志。

三、STM32端

        main函数主要是怎么利用串口传回来的线或标签中心点值，标签的角度值，十字路口的标志位，这里就不做说明。

        这里主要说一下STM32的串口怎么设置，这里我使用的是串口1，配置如下：

  1. void usart_init(uint32_t bound)
  2. {
  3.     /*UART 初始化设置*/
  4.     uartx_handler.Instance = USART_UX;                                       /*USART_UX*/
  5.     uartx_handler.Init.BaudRate = bound;                                     /*波特率*/
  6.     uartx_handler.Init.WordLength = UART_WORDLENGTH_8B;                      /*字长为8位数据格式*/
  7.     uartx_handler.Init.StopBits = UART_STOPBITS_1;                           /*一个停止位*/
  8.     uartx_handler.Init.Parity = UART_PARITY_NONE;                            /*无奇偶校验位*/
  9.     uartx_handler.Init.HwFlowCtl = UART_HWCONTROL_NONE;                      /*无硬件流控*/
  10.     uartx_handler.Init.Mode = UART_MODE_TX_RX;                               /*收发模式*/
  11.     HAL_UART_Init(&uartx_handler);                                           /*HAL_UART_Init()会使能UART1*/
  12.     HAL_UART_Receive_IT(&uartx_handler, (uint8_t *)aRxBuffer, RXBUFFERSIZE); /*该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量*/
  13. }
  14.  
  15. /**
  16.  * @brief       UART底层初始化，时钟使能，引脚配置，中断配置
  17.                                 此函数会被HAL_UART_Init()调用
  18.  * @param       huart:串口句柄
  19.  * @retval      无
  20.  */
  21. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
  22. {
  23.     /*GPIO端口设置参数存放位置*/
  24.     GPIO_InitTypeDef gpio_initure;
  25.  
  26.     if (huart->Instance == USART_UX)                    /*HAL调用此接口进行串口 MSP初始化*/
  27.     {
  28.     /* IO 及 时钟配置 */
  29.     USART_TX_GPIO_CLK_ENABLE();                         /* 使能串口TX脚时钟 */
  30.     USART_RX_GPIO_CLK_ENABLE();                         /* 使能串口RX脚时钟 */
  31.     USART_UX_CLK_ENABLE();                              /* 使能串口时钟 */
  32.     gpio_initure.Pin = USART_TX_GPIO_PIN;               /*串口发送引脚号*/
  33.     gpio_initure.Mode = GPIO_MODE_AF_PP;                /*复用推挽输出*/
  34.     gpio_initure.Pull = GPIO_PULLUP;                    /*上拉*/
  35.     gpio_initure.Speed = GPIO_SPEED_FREQ_HIGH;          /*IO速度设置为高速*/
  36.     HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_initure);
  37.         
  38.     gpio_initure.Pin = USART_RX_GPIO_PIN;               /* 串口RX脚 模式设置 */
  39.     gpio_initure.Mode = GPIO_MODE_AF_INPUT;    
  40.     HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_initure);   /* 串口RX脚 必须设置成输入模式 */
  41. #if USART_EN_RX
  42.     HAL_NVIC_EnableIRQ(USART_UX_IRQn);                  /*使能USART1中断通道*/
  43.     HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);          /*组2，最低优先级:抢占优先级3，子优先级3 */
  44. #endif
  45.     }
  46. }
  47.  
  48. /**
  49.  * @brief       UART数据接收回调接口
  50.                 数据处理在这里进行
  51.  * @param       huart:串口句柄
  52.  * @retval      无
  53.  */
  54. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  55. {
  56.     static uint8_t RxState = 0;
  57.     static uint8_t RxCounter1=0;
  58. 	static uint16_t RxBuffer1[11]={0};
  59.     uint8_t i;
  60.     
  61.     if (huart->Instance == USART_UX)                   /*如果是串口1*/
  62.     {
  63. 		if(RxState==0 && aRxBuffer[0]==0x2C)  //0x2c帧头
  64. 				{
  65. 					RxState=1;
  66. 					RxBuffer1[RxCounter1++]=aRxBuffer[0];
  67. 				}
  68. 		
  69. 				else if(RxState==1&&aRxBuffer[0]==0x12)  //0x12帧头
  70. 				{
  71. 					RxState=2;
  72. 					RxBuffer1[RxCounter1++]=aRxBuffer[0];
  73. 				}
  74. 		
  75. 				else if(RxState==2)
  76. 				{
  77. 					RxBuffer1[RxCounter1++]=aRxBuffer[0];
  78.  
  79. 					if(RxCounter1==10 && aRxBuffer[0] == 0x5B)       //RxBuffer1接收满了，接收结束。
  80. 					{
  81. 						
  82. 						rwm_x_value_H = RxBuffer1[RxCounter1-8];
  83. 						rwm_x_value_L = RxBuffer1[RxCounter1-7];
  84. 						K210_Flag = RxBuffer1[RxCounter1-6];
  85. 						data_rwm_H = RxBuffer1[RxCounter1-5];
  86.                         data_rwm_L = RxBuffer1[RxCounter1-4];
  87. 						jiaodu_H = RxBuffer1[RxCounter1-3];
  88. 						jiaodu_L = RxBuffer1[RxCounter1-2];
  89. 						RxCounter1 = 0;
  90. 						RxState = 0;	
  91. 					}
  92. 					else if(RxCounter1 > 10)            // 接收异常
  93. 					{
  94. 						RxState = 0;
  95. 						RxCounter1=0;
  96. 						for(i=0;i<10;i++)
  97. 						{
  98. 								RxBuffer1[i]=0x00;      //将存放数据包数组清零
  99. 						}
  100. 					
  101. 					}
  102. 				}
  103. 				else   // 接收异常
  104. 				{
  105. 						RxState = 0;
  106. 						RxCounter1=0;
  107. 						for(i=0;i<10;i++)
  108. 						{
  109. 								RxBuffer1[i]=0x00;      // 将存放数据包数组清零
  110. 						}
  111. 				}
  112. 			g_usart_rx_sta = 0;
  113.     }
  114. }

注：

        1、这里使用是HAL库函数版本

        2、在接收端使用了一个简单的报文，有包头，有包尾。

这是我第一次在网上分享自己做的东西，做的不好，后面多多努力，请各位大神多多指教。

注：本文转载自blog.csdn.net的bkrclp的文章"https://blog.csdn.net/bkrclp/article/details/142638971"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！