devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OPENMV脱机调阈值_openmv如何实现脱机调阈值

作者：寸_铁 | 2024-08-02 22:24:55

赞

踩

openmv如何实现脱机调阈值

用到了7个按钮，第一个用来选择是否进入调阈值模式。

后6个用来调整OPENMV阈值编辑器的6个滑动条

OPENMV代码

  1. import sensor, image, time, pyb,math, display
  2. from pyb import UART
  3.  
  4. sensor.reset()
  5. sensor.set_framesize(sensor.QQVGA)
  6. sensor.set_pixformat(sensor.RGB565)
  7. sensor.skip_frames(time = 10)
  8. clock = time.clock()
  9. threshold_index = 0 
  10. red=[24, 69, 16, 127, -128, 127]
  11. #
  12. uart = UART(3, 9600)
  13.  
  14. lcd = display.SPIDisplay()
  15.  
  16.  
  17. while True:
  18.    
  19.     # 检查是否有数据可读
  20.     if uart.any():
  21.         # 读取数据
  22.         data = uart.read()
  23.  
  24.         # 检查数据是否符合要求
  25.         if len(data) >= 3 and data[0] == 0xa1 and data[1] == 0xb2 and data[-1] == 0xc3:
  26.             # 打印接收到的数据包
  27.             print("接收到的数据包：", list(data))
  28.  
  29.  
  30.             if data[2]==0: thr = 0;
  31.             if data[2]==1: thr = 1;
  32.             if thr == 1:
  33.                red[0]=data[3]
  34.                red[1]=data[4]
  35.                red[2]=data[5]-128
  36.                red[3]=data[6]-128
  37.                red[4]=data[7]-128
  38.                red[5]=data[8]-128
  39.                
  40.                for i in range(100):
  41.                     clock.tick()
  42.                     img = sensor.snapshot()  
  43.                     img.binary([red])
  44.                     lcd.write(img)  
  45.                     print("阈值",list(red))
  46.                     print("data",data[8])
  47.             if thr == 0:   
  48.                 clock.tick()
  49.                 img = sensor.snapshot()
  50.               # 拍照并显示图像。
  51.                 
  52.                 
  53.                 for blob in img.find_blobs([red],pixels_threshold=200,area_threshold=200):#循环blobs
  54.                     img.draw_rectangle(blob.rect())#返回这个色块的外框
  55.                 lcd.write(img)

 

 MSPM0G3507代码

  1.  
  2. #include "ti_msp_dl_config.h"
  3.  
  4. #include "oled.h"
  5. #include "stdio.h"
  6. uint8_t Serial_TxPacket[7];				//定义发送数据包数组，数据包格式：aa bb 01 02 03 04 cc
  7.  
  8.  
  9. int openmv_data[5]; //openmv发来的数据包
  10.  
  11.  
  12. //给OPENMV脱机调阈值发的数据
  13. int a1=0;
  14. int a2=0;
  15. int a3=0;
  16. int a4=0;
  17. int a5=0;
  18. int a6=0;
  19. int a7=0;
  20.  
  21. /**
  22.   * 函    数：串口发送一个字节
  23.   * 参    数：Byte 要发送的一个字节
  24.   * 返 回 值：无
  25.   */
  26. void Serial_SendByte(uint8_t Byte)
  27. {
  28. 	DL_UART_Main_transmitDataBlocking(UART_1_INST  ,Byte);	//将字节数据写入数据寄存器，写入后USART自动生成时序波形
  29. }
  30.  
  31.  
  32.  
  33. /**
  34.   * 函    数：串口发送一个数组
  35.   * 参    数：Array 要发送数组的首地址
  36.   * 参    数：Length 要发送数组的长度
  37.   * 返 回 值：无
  38.   */
  39. void Serial_SendArray(uint8_t *Array, uint16_t Length)
  40. {
  41. 	uint16_t i;
  42. 	for (i = 0; i < Length; i ++)		//遍历数组
  43. 	{
  44. 		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
  45. 	}
  46. }
  47.  
  48.  
  49. /**
  50.   * 函    数：串口发送数据包
  51.   * 参    数：无
  52.   * 返 回 值：无
  53.   * 说    明：调用此函数后，Serial_TxPacket数组的内容将加上包头（FF）包尾（FE）后，作为数据包发送出去
  54.   */
  55. void Serial_SendPacket(void)
  56. {
  57.  
  58. Serial_SendByte(0xa1);    
  59. Serial_SendByte(0xb2);        
  60. Serial_SendArray(Serial_TxPacket, 7);
  61. Serial_SendByte(0xc3);
  62.     	    
  63. }
  64.  
  65.  
  66.  
  67. int data_test(int data[])           //判断数据是否合理的函数
  68. {
  69.  
  70. 	if(data[4]!=0xc3) return 0;  //帧尾
  71. 	
  72. 	//if(data[2]>150)   return 0;  //x坐标上限
  73. 	//if(data[3]>110)   return 0;  //y坐标上限
  74. 	
  75. 	return 1;
  76. }
  77.  
  78.  
  79.  
  80. void delay_ms(uint32_t ms)
  81. {
  82.     while(ms--)
  83.     {
  84.         delay_cycles(CPUCLK_FREQ/2500);
  85.     }
  86. }
  87.  
  88.  
  89.  
  90. int main(void)
  91. {
  92.  
  93.    
  94.     SYSCFG_DL_init();
  95.  
  96.     OLED_Init(I2C_OLED_INST     );//初始化OLED
  97.     OLED_Clear(I2C_OLED_INST     );//OLED清屏
  98.  
  99.     // NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN);                 //先清除一下中断，防止直接接入中断
  100.     // NVIC_EnableIRQ(UART_0_INST_INT_IRQN);                       //开启串口的中断
  101.  
  102.       //NVIC_EnableIRQ(UART_1_INST_INT_IRQN);                           //允许串口1的中断，OPENMV中断
  103.  
  104.  
  105.    
  106.     while (1)
  107.      {
  108.    
  109.     OLED_ShowFloat(I2C_OLED_INST     , 0,0, a1, 3, 1, 8);
  110.  OLED_ShowFloat(I2C_OLED_INST     , 0,1, a2, 3, 1, 8);
  111.   OLED_ShowFloat(I2C_OLED_INST     , 0,2, a3, 3, 1, 8);
  112.    OLED_ShowFloat(I2C_OLED_INST     , 0,3, a4, 3, 1, 8);
  113.     OLED_ShowFloat(I2C_OLED_INST     , 0,4, a5, 3, 1, 8);
  114.      OLED_ShowFloat(I2C_OLED_INST     , 0,5, a6, 3, 1, 8);
  115.       OLED_ShowFloat(I2C_OLED_INST     , 0,6, a7, 3, 1, 8);
  116.   
  117.  
  118.  
  119.             //第一个按键用来判断是否进入调阈值模式
  120.              if (DL_GPIO_readPins(KEY1_PORT_PORT     ,KEY1_PORT_KET1_PIN_PIN )==KEY1_PORT_KET1_PIN_PIN)       //按下为高电平
  121.             {
  122.                     while(DL_GPIO_readPins(KEY1_PORT_PORT     , KEY1_PORT_KET1_PIN_PIN )==KEY1_PORT_KET1_PIN_PIN)       //一直按下
  123.                     {
  124.  
  125.                     }
  126.                     //松手之后
  127.                     a1++;           //a1为1则进入调阈值模式，a1为0则退出调阈值模式
  128.                     if(a1>1)
  129.                     {
  130.                         a1=0;
  131.                     }
  132.                     
  133.             }     
  134.  
  135.             //第二个按键调第一个阈值
  136.              if (DL_GPIO_readPins(KEY2_PORT_PORT     ,KEY2_PORT_KEY2_PIN_PIN )==KEY2_PORT_KEY2_PIN_PIN)       //按下为高电平
  137.             {
  138.                     while(DL_GPIO_readPins(KEY2_PORT_PORT     , KEY2_PORT_KEY2_PIN_PIN )==KEY2_PORT_KEY2_PIN_PIN)       //一直按下
  139.                     {
  140.  
  141.                     }
  142.                     a2=a2+4;
  143.                     if(a2>100)
  144.                     {
  145.                         a2=0;
  146.                     }
  147.             }     
  148.  
  149.              //第三个按键调第二个阈值
  150.              if (DL_GPIO_readPins(KEY3_PORT_PORT     ,KEY3_PORT_KEY3_PIN_PIN )==KEY3_PORT_KEY3_PIN_PIN)       //按下为高电平
  151.             {
  152.                     while(DL_GPIO_readPins(KEY3_PORT_PORT     , KEY3_PORT_KEY3_PIN_PIN )==KEY3_PORT_KEY3_PIN_PIN)       //一直按下
  153.                     {
  154.  
  155.                     }
  156.                     a3=a3+4;
  157.                     if(a3>100)
  158.                     {
  159.                         a3=0;
  160.                     }
  161.             }     
  162.  
  163.             //第四个按键调第三个阈值
  164.              if (DL_GPIO_readPins(KEY4_PORT_PORT     ,KEY4_PORT_KEY4_PIN_PIN )==KEY4_PORT_KEY4_PIN_PIN)       //按下为高电平
  165.             {
  166.                     while(DL_GPIO_readPins(KEY4_PORT_PORT     , KEY4_PORT_KEY4_PIN_PIN )==KEY4_PORT_KEY4_PIN_PIN)       //一直按下
  167.                     {
  168.  
  169.                     }
  170.                     a4=a4+4;
  171.                     if(a4>=252)
  172.                     {
  173.                         a4=0;
  174.                     }
  175.             }
  176.  
  177.             //第五个按键调第四个阈值
  178.              if (DL_GPIO_readPins(KEY5_PORT_PORT     ,KEY5_PORT_KEY5_PIN_PIN )==KEY5_PORT_KEY5_PIN_PIN)       //按下为高电平
  179.             {
  180.                     while(DL_GPIO_readPins(KEY5_PORT_PORT     , KEY5_PORT_KEY5_PIN_PIN )==KEY5_PORT_KEY5_PIN_PIN)       //一直按下
  181.                     {
  182.  
  183.                     }
  184.                     a5=a5+4;
  185.                     if(a5>=252)
  186.                     {
  187.                         a5=0;
  188.                     }
  189.             }
  190.  
  191.             //第六个按键调第五 个阈值
  192.              if (DL_GPIO_readPins(KEY6_PORT_PORT     ,KEY6_PORT_KEY6_PIN_PIN )==KEY6_PORT_KEY6_PIN_PIN)       //按下为高电平
  193.             {
  194.                     while(DL_GPIO_readPins(KEY6_PORT_PORT     , KEY6_PORT_KEY6_PIN_PIN )==KEY6_PORT_KEY6_PIN_PIN)       //一直按下
  195.                     {
  196.  
  197.                     }
  198.                     a6=a6+4;
  199.                     if(a6>=252)
  200.                     {
  201.                         a6=0;
  202.                     }
  203.             }  
  204.  
  205.  
  206.              //第七个按键调第六个阈值
  207.              if (DL_GPIO_readPins(KEY7_PORT_PORT     ,KEY7_PORT_KEY7_PIN_PIN )==KEY7_PORT_KEY7_PIN_PIN)       //按下为高电平
  208.             {
  209.                     while(DL_GPIO_readPins(KEY7_PORT_PORT     , KEY7_PORT_KEY7_PIN_PIN )==KEY7_PORT_KEY7_PIN_PIN)       //一直按下
  210.                     {
  211.  
  212.                     }
  213.                     a7=a7+4;
  214.                     if(a7>=252)
  215.                     {
  216.                         a7=0;
  217.                     }
  218.             }  
  219.  
  220.             Serial_TxPacket[0] =a1;
  221.             Serial_TxPacket[1] =a2;
  222.             Serial_TxPacket[2] =a3;
  223.             Serial_TxPacket[3] =a4;
  224.             Serial_TxPacket[4] =a5;
  225.             Serial_TxPacket[5] =a6;
  226.             Serial_TxPacket[6] =a7;
  227.             Serial_SendPacket();        //将帧头帧尾和中间的7个数据都发过去
  228.  
  229.  
  230.     }
  231. }

 

 

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

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

  

闽ICP备14008679号