openmv一些常见问题与心得总结

提示：本程序测试主控为open mv4 H7，开发平台为openmv IDE

---

前言

本文主要对我在使用openmv过程中发现的一些常见小问题进行总结归纳，这些问题都不是很严重，但细微之处见差距，希望对你的使用有所帮助，同时也作为我备赛阶段性使用openmv的笔记总结。

---

一、谨慎使用画图画线功能

a.画图画线也会影响图像识别效果

当我们测试时，喜欢在图像中绘制各种线条，比如感性区域，指定的坐标点，指定区域范围等线条
这里要注意，这些画线也会影响我们的图像和目标效果追踪，要注意到我们这些函数都是img.draw_XXX这类，这类都是在图像中绘制，相当于对图像进行了二次处理，留意一些我们的图像都是通过img = sensor.snapshot()这句话实现的，那些绘制出来的线段也会影响效果

b.实际效果对比

如下图所示，这是没有加线条的正常图像颜色识别效果

如下图所示，这是拿滚球控制系统标记了点后的图像来看，可以发现图像识别区域有了明显的干扰，中心点和框大小都有了明显的变化

这是继续移动的效果，可见图像已经无法识别出来了，我们绘制的线已经影响了物体的完整性，图像由于绘制的线条出现了明显的分割现象

如果绘制的线条颜色和我们追踪的线条颜色相近，也会影响阈值选取，也可能会干扰颜色识别效果

c. 动态画线和静态画线

如下就是这些画线的函数，尤其要注意主动画线和被动画线的区别，主动画线是直接对追踪前的图像进行操作，会影响识别效果如下为静态绘线


如下就是被动绘线，img.draw_edges(max_blob1.min_corners(), color=(0,255,128))
img.draw_cross(max_blob1[5], max_blob1[6],color=(0,255,128))
这是在识别完成后的绘线，不会影响图像识别，也就是动态画线

d.小结

这里建议在测试的时候可以提前先绘制线条，测试的时候实时观看，在实际工作比赛时关闭这些不必要的线段，这样可以在一定程度上提高辨识效果，减少误差

---

二、定时器中无法运行分配内存的函数

d.定时器无法添加分配内存

定时器中无法添加分配内存的函数，否则会出现如下错误提示-uncaught exception in Timer(2) interrupt handler，程序能正常运行，但会提示定时器中断无法正常工作
这是因为我们在中断回调函数中添加了分配内存的函数，通俗的来说，就是我们在定时器中断中对定时器函数以外（主函数）中其它变量进行了修改或者值改变。
相当于openmv定时器是一个不同与主函数的新线程，不能打断影响主函数变量和进程，只能输出主函数分配内存的函数，在其中定义的值相当于局部变量，不影响全局变量

b.图示实测对比

如下图所示，使用LDE，串口等读取输出内存函数可以正常运行

这里我们在定时器中更改了test的值，可见在while中依然输出的是1，可见在定时器中更改的值不会影响除了定时器以外的地方

如下图可见定时器中的变量变化不会影响除了定时以外的地方

如下图，定时器可以正常输出访问while中的变量变化

这里在回调中添加分配内存的函数，可见我们想要的效果并没有达到，同时还输出了一个错误警告

c.小结

在回调中不允许分配内存的函数，具体解决方案还要错误问题描述如果还是没有明白，可以参考一下如下博文查看详细解释，这里由于篇幅原因不做过多解释

openmv定时器

---

三.open MV光照阈值不稳定优化

在我们实际使用中，openmv受环境光影响较大，有可能提前设置好的阈值并不适合实际比赛或者应用场地,这里给大家一些使用方法和建议,注意这里只是总结，相关详细方案在其它博文中会有详细介绍，欢迎查看

a.一种基于open mv的自适应阈值的方法

这里推荐一种基于openmv的自适应取阈值的方法，在我们实际使用中，openmv受环境光影响较大，有可能提前设置好的阈值并不适合实际比赛或者应用场地，而且如果遇到混合颜色或者极端情况提前取好的阈值可能失效，增加阈值数目又可能会出现颜色混淆，所以我设计出这种自适应阈值的取阈值方式，程序初始没有设置准确的阈值，通过将想要追踪的颜色或者混合颜色目标对准摄像头中间绘出小框，再通过按键等对P1口施加高电平，摄像头即可自动追踪目标颜色，可以根据条件一键追踪目标，一般和外接的LCD屏连用用于比赛或实际工作场地调节，无需再连接到电脑手动调节阈值，适合比赛准备或者抗光干扰实验研究

由于篇幅原因这里不过多介绍，详细资料情况请查看下面博文，我已经上传提供了完整配置教程和代码文件

一种基于open mv的自适应阈值的方法

b.多个阈值对应一个物体

一般我们追踪目标都是通过颜色追踪，颜色追踪的效果是最好的，一般我们对于一个物体只会用一个元组设置一个阈值，但随着环境中光源的不经意改变，早上取的阈值到了晚上就用不了了，这种情况很多，不利于我们比赛和实际效果。
这时，我们可以通过设置多个颜色阈值来捕捉目标，通过在一个列表中设置多个颜色元组来适应不同情况

由于篇幅原因这里不过多介绍，详细资料情况请查看下面博文，我已经上传提供了完整配置教程和代码文件

一种优化openmv目标追踪与阈值效果的几个方法

c.寻找最大物体

如果我们追踪的物体同一时间同一场景中只有一个，那我们可以通过设置如下函数找到最大的那一个，大大的减少误差和噪点

由于篇幅原因这里不过多介绍，详细资料情况请查看下面博文，我已经上传提供了完整配置教程和代码文件

一种优化openmv目标追踪与阈值效果的几个方法

d.设置限定参数

通过设置目标区域的感性区域，最小像素点合并，像素点最大最小值等限制条件提高效果，例如下列中的roi,pixels_threshold, area_threshold,merge，等限制条件

由于篇幅原因这里不过多介绍，详细资料情况请查看下面博文，我已经上传提供了完整配置教程和代码文件

一种优化openmv目标追踪与阈值效果的几个方法

---

四.open MV图像卡顿问题

a.帧率过低

通过print(clock.fps())可以查看整个全局程序运行的帧率

b.解决方案1

可以通过计算耗费的时间，通过millis()来计算不同过程的时间。 可以测量出到底是程序哪里耗费时间多来进行优化

import pyb

time_start = pyb.millis()
img = sensor.snapshot()         # Take a picture and return the image.
duration = pyb.elapsed_millis(time_start)

c.解决方案2

如果代码已经无法再继续优化，那么可以通过超频的方案提示一部分的性能，按照官网给出的数值，通过实际测试效果有一定提高，目前没有发生什么问题，不过就是主控芯片温度会高了点，一般情况下帧率是足够的，而且脱机后帧率会加倍。

# Overclocking Example
#
# 这个例子展示了如何让你的OpenMV2超频到216MHZ。
# 摄像头的超频状态会持续到下一次硬件重启，如果你需要保持这个频率，
# 你需要在主程序中调用set_frequency函数

# 警告: 超频到216MHz应该是安全的，然而需要自担风险！

import cpufreq

# 打印当前的频率
print(cpufreq.get_frequency())

# 设置频率，可用的值为 (120, 144, 168, 192, 216)
cpufreq.set_frequency(cpufreq.CPUFREQ_216MHZ)

# 打印当前的频率
print(cpufreq.get_frequency())

b.软件卡顿

有的时候我发现软件图像运行时偶尔会出现一点卡顿，不过可能这是个别现象，通过比较数据没有发现数据流出现波动，可见只是我们的观测窗口发生了卡顿，并不会对实际效果产生影响。

五.部分项目示例参考

这里附上一些项目示例部分程序，供大家参考，篇幅有限原因不做详细解释，如果有兴趣的朋友可以评论或私聊我获取相关资料和代码

a.滚球控制系统

电赛控制题：滚球控制系统（openmv部分）

# 2021.07.17 滚球控制系统 地眼计划
#  x=320 y=240
import sensor, image, time, math, json, pyb,lcd
from pyb import LED
from pyb import UART
from pyb import Pin
from pyb import Timer
#LED(1).on()
#LED(2).on()
#LED(3).on()
pin1 = Pin('P1', Pin.IN, Pin.PULL_UP)   ##将P1口作为阈值控制口 OUT_PP PULL_NONE
pin9 = Pin('P9', Pin.IN, Pin.PULL_UP)

blue_L_min=1
blue_L_max=1
blue_A_min=1
blue_A_max=1
blue_B_min=1
blue_B_max=1

# 颜色跟踪阈值(L Min, L Max, A Min, A Max, B Min, B Max)
thresholds1 =[
#(0, 26, -128, 126, -128, -18),#13；40
#(0, 100, -128, 127, -128, -26),  #17:17
#(0, 27, -128, 125, -128, -13)
#(0, 100, 23, 127, -128, 127),
(0, 25, -128, 127, -18, 127),
(blue_L_min,blue_L_max,blue_A_min,blue_A_max,blue_B_min,blue_B_max)
] #16:30  #蓝色车尾
thresholds2 =[(0, 58, -128, -20, -128, 127),#19;22反光
(0, 26, -128, -13, -128, 127),#12:43
(20, 43, -128, -16, -128, 127) #16:30  #绿色车头
]
#thresholds3 =[
#(0, 18, -128, 10, -128, 6),#18;15
#(0, 14, -128, 6, -128, 127)  #14:10  #测试黑色
#]
#thresholds4 =[(0, 100, 26, 127, -128, 127),#16：10 #修正
#(33, 100, 26, 127, 25, 127),  #15:15 #修正
#(57, 100, 8, 127, 19, 127),#21：00半黄
#(0, 99, 26, 124, -128, 127)]  #16:30  #测试橘黄

sensor.reset()
#初始化摄像头，reset()是sensor模块里面的函数
sensor.set_pixformat(sensor.RGB565)
#设置图像色彩格式，有RGB565色彩图和GRAYSCALE灰度图两种
sensor.set_framesize(sensor.QVGA)
lcd.init() # 初始化lcd屏幕。
#设置图像像素大小
sensor.skip_frames(time = 2000)
#sensor.set_vflip(True)
#sensor.set_hmirror(True)
sensor.set_contrast(0)
sensor.set_auto_gain(False) # 颜色跟踪必须关闭自动增益
sensor.set_auto_whitebal(False) # 颜色跟踪必须关闭白平衡
sensor.set_auto_exposure(True,1)
clock = time.clock()
uart = UART(3, 115200)
left_roi = [17,1,250,237]  ##感性区域，设计颜色识别的有效区域
left_roi1 = [0,120,160,120]




uart_data = 0
led_red = pyb.LED(1) # Red LED = 1, Green LED = 2, Blue LED = 3, IR LEDs = 4.
led_green = pyb.LED(2)
led_blue = pyb.LED(3)

start_x=52      ##左上角顶点坐标
start_y=40
interval_x=60   ##框外间隔
interval_y=60
roi_temp = 20
roi_sum = 0
roi_r=12       ##⚪高宽

roi_x=roi_r   ##从矩形框·变化成⚪框
roi_y=roi_r


left_1_1 = (start_x,                         start_y,                         roi_r)  ##通过比例计算框位
left_1_2 = (start_x+interval_x+(roi_x*2),    start_y,                         roi_r)
left_1_3 = (start_x+(interval_x*2)+(roi_x*4),start_y,                         roi_r)
left_2_1 = (start_x,                         start_y+interval_y+(roi_y*2),    roi_r)
left_2_2 = (start_x+interval_x+(roi_x*2),    start_y+interval_y+(roi_y*2),    roi_r)
left_2_3 = (start_x+(interval_x*2)+(roi_x*4),start_y+interval_y+(roi_y*2),    roi_r)
left_3_1 = (start_x,                         start_y+(interval_y*2)+(roi_y*4),roi_r)
left_3_2 = (start_x+interval_x+(roi_x*2),    start_y+(interval_y*2)+(roi_y*4),roi_r)
left_3_3 = (start_x+(interval_x*2)+(roi_x*4),start_y+(interval_y*2)+(roi_y*4),roi_r)
#print("x1:%d x2:%d x3:%d" % start_x,start_x+interval_x+(roi_x*2),start_x+(interval_x*2)+(roi_x*4))
print(left_1_1,left_1_2,left_1_3)
print(left_2_1,left_2_2,left_2_3)
print(left_3_1,left_3_2,left_3_3)

ROI=(140,100,roi_temp,roi_temp)
# 只有比“pixel_threshold”多的像素和多于“area_threshold”的区域才被
# 下面的“find_blobs”返回。 如果更改相机分辨率，
# 请更改“pixels_threshold”和“area_threshold”。 “merge = True”合并图像中所有重叠的色块。
def find_max(blobs):
    max_size=0
    for blob in blobs:
        if blob.pixels() > max_size:
            max_blob = blob
            max_size = blob.pixels()
    return max_blob

past_x = 0
past_y = 0
now_x = 0
now_y = 0
tu_x = 0
tu_y = 0

time_temp1=0
time_temp2=0

time_log=5
def tick(timer):      #这里开启了一个定时器
    #key0 = pin1.value()
    time_log  = 1
    #if key0 == 0:
       #print("111")
    #if key0 == 1:
       #print("222")




tim = Timer(2, freq=1)      # create a timer object using timer 2 - trigger at 1Hz
tim.callback(tick)          # set the callback to our tick function

temp =20
xiu =0
log1x=0
log1y=0
log2x=0
log2y=0
log3x=0
log3y=0
a1=0
a2=0
a3=0
a4=0
a5=0
a6=0
a7=0
a8=0
a9=0
a10=0
string=''
string3=''
string6=''
string9=''
string12=''
Lmin = 1
Lmax = 1
Amin = 1
Amax = 1
Bmin = 1
Bmax = 1

key0 = 2
key1 = 2
flag_key2=0
def callback_PIN9(line):
    global flag_key2
    flag_key2=1
    pyb.delay(10)
extint = pyb.ExtInt(pin9, pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_UP, callback_PIN9)

#pin0.value([0])
while(True):
    clock.tick()
    #img = sensor.snapshot()
    img = sensor.snapshot().lens_corr(strength = 1.6, zoom = 1.0)
    if uart.any(): #判断是否有数据接收
        uart_data = int(uart.read().decode())
        if  uart_data == 1:
            led_red.on()
            led_green.off()
            led_blue.off()
        elif uart_data == 2:
            led_red.off()
            led_green.on()
            led_blue.off()
        else:
            led_red.off()
            led_green.off()
            led_blue.on()
    else:
        uart_data = 0

    statistics=img.get_statistics(roi=ROI)   ###查询这个区域的颜色值
    color_l=statistics.l_mean()
    color_a=statistics.a_mean()
    color_b=statistics.b_mean()
    #print(color_l,color_a,color_b)

    img.draw_rectangle(left_roi)       ##绘制主框
    img.draw_rectangle(ROI,color=(255,255,100))    ##绘制校准区域

    #img.draw_circle(left_1_1,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_1_2,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_1_3,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_2_1,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_2_2,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_2_3,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_3_1,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_3_2,color = (0, 0, 160),thickness = 1, fill = False)
    #img.draw_circle(left_3_3,color = (0, 0, 160),thickness = 1, fill = False)


    Lmin = color_l - 10
    Lmax = color_l + 10
    Amin = color_a - 10
    Amax = color_a + 10
    Bmin = color_b - 10
    Bmax = color_b + 10

    key0 = pin1.value()      ##按键控制
    key2 = pin9.value()      ##按键控制
    #print(key0,key2)
    if key0 == 0:
        #LED(3).on()
        #LED(1).off()
        blue_L_min = Lmin
        blue_L_max = Lmax
        blue_A_min = Amin
        blue_A_max = Amax
        blue_B_min = Bmin
        blue_B_max = Bmax
        #print(blue_L_min,blue_L_max,blue_A_min,blue_A_max,blue_B_min,blue_B_max)
        thresholds1 =  [(blue_L_min,blue_L_max,blue_A_min,blue_A_max,blue_B_min,blue_B_max)]
    if key0 == 1:
        a10=1
        #LED(1).on()
        #LED(3).on()
        #print(blue_L_min,blue_L_max,blue_A_min,blue_A_max,blue_B_min,blue_B_max)

    if flag_key2==1 and pin9.value()==0:
        roi_sum+=1
        if(roi_sum==1):
            roi_temp = 25
        if(roi_sum==2):
            roi_temp = 30
        if(roi_sum==3):
            roi_temp = 35
        if(roi_sum==4):
            roi_temp = 40
        if(roi_sum==5):
            roi_temp = 10
        if(roi_sum==6):
            roi_temp = 15
        if(roi_sum==7):
            roi_temp = 20
            roi_sum=0
        ROI=(140,100,roi_temp,roi_temp)
        flag_key2=0

###蓝色最大目标作为车尾
    blobs = img.find_blobs(thresholds1,roi=left_roi,pixels_threshold=50, area_threshold=50,merge = True)
    if blobs:  #a5,a6,string6,string7,string8
        a5=1
        max_blob1 = find_max(blobs)
        img.draw_edges(max_blob1.min_corners(), color=(0,255,128))
        img.draw_cross(max_blob1[5], max_blob1[6],color=(0,255,128))
        output_str="(%3d%3d)" % (max_blob1[5],max_blob1[6]) #方式1
        string6 =str(max_blob1[5])+','+str(max_blob1[6])+','
        tu_x = max_blob1[5]
        tu_y = max_blob1[6]
    if a5 != 0:
        string9 = str(string6)
        string10 = list(string9) #先转换成列表
        string10.pop()   #删除列表的最后一位
        string11 =''.join(string10)  #再重新转换成字符串
        string9 ='AF'+str(string11)+'BE'
        #print(string9)
        #uart.write(string9)
        string9=''
        a5=0
        string6=''
    lcd.display(img) # 拍照并显示图像。
    print(clock.fps())

b.自动巡线避障小车

import sensor, image, time, math
from pyb import UART
from pyb import LED
# Tracks a black line. Use [(128, 255)] for a tracking a white line.
GRAYSCALE_THRESHOLD = [(35, 0, -23, 22, -33, 40)]
LED(1).on()
LED(2).on()
LED(3).on()
# Each roi is (x, y, w, h). The line detection algorithm will try to find the
# centroid of the largest blob in each roi. The x position of the centroids
# will then be averaged with different weights where the most weight is assigned
# to the roi near the bottom of the image and less to the next roi and so on.
yellow_threshold   = (34, 23, 11, 127, 0, 127)
ROIS = [ # [ROI, weight]
        (0, 100, 160, 20, 0.7), # You'll need to tweak the weights for your app
        (0,  50, 160, 20, 0.3), # depending on how your robot is setup.
        (0,   0, 160, 20, 0.1)
       ]

# Compute the weight divisor (we're computing this so you don't have to make weights add to 1).
weight_sum = 0
for r in ROIS: weight_sum += r[4] # r[4] is the roi weight.

# Camera setup...
sensor.reset() # Initialize the camera sensor.
sensor.set_pixformat(sensor.RGB565) # use grayscale.
sensor.set_framesize(sensor.QQVGA) # use QQVGA for speed.
sensor.skip_frames(time = 2000) # Let new settings take affect.
sensor.set_auto_gain(False) # must be turned off for color tracking
sensor.set_auto_whitebal(False) # must be turned off for color tracking
clock = time.clock() # Tracks FPS.
K=5000#the value should be measured
uart = UART(3, 115200)
a2=0
a1=0

while(True):
    clock.tick() # Track elapsed milliseconds between snapshots().
    img = sensor.snapshot() # Take a picture and return the image.
    blobs1 = img.find_blobs([yellow_threshold])
    if len(blobs1) == 1:
        # Draw a rect around the blob.
        b = blobs1[0]
        img.draw_rectangle(b[0:4]) # rect
        img.draw_cross(b[5], b[6]) # cx, cy
        Lm = (b[2]+b[3])/2
        length = K/Lm
        a2 = length



    centroid_sum = 0

    for r in ROIS:
        blobs = img.find_blobs(GRAYSCALE_THRESHOLD, roi=r[0:4], merge=True) # r[0:4] is roi tuple.

        if blobs:
            # Find the blob with the most pixels.
            largest_blob = max(blobs, key=lambda b: b.pixels())

            # Draw a rect around the blob.
            img.draw_rectangle(largest_blob.rect())
            img.draw_cross(largest_blob.cx(),
                           largest_blob.cy())

            centroid_sum += largest_blob.cx() * r[4] # r[4] is the roi weight.

    center_pos = (centroid_sum / weight_sum) # Determine center of line.


    deflection_angle = 0
    deflection_angle = -math.atan((center_pos-80)/60)

    # Convert angle in radians to degrees.
    deflection_angle = math.degrees(deflection_angle)
    a1 = deflection_angle
    a3 = a1+200
    print("Turn Angle: {%3d}" % a3)
    print("ledng: [%3d]" % a2)
    output_str="[%3d%3d]" % (a3,a2+100) #方式1
    uart.write(output_str)
    output_str1="{%3d}" % (a3) #方式1
    uart.write(output_str1)

c.模拟电磁曲射炮

电赛控制题：模拟电磁曲射炮（openmv部分）

import sensor, image, time, math, json, pyb
from pyb import UART
threshold_index = 0
red = (20, 76, 33, 80, -30, 54)
red2 = (36, 73, 22, 79, 4, 63)
red3 = (36, 70, 28, 124, -18, 82)

led_red = pyb.LED(1) # Red LED = 1, Green LED = 2, Blue LED = 3, IR LEDs = 4.
led_green = pyb.LED(2)
led_blue = pyb.LED(3)

WINDOW_CENTER_X = 160
WINDOW_CENTER_Y = 120

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_hmirror(True)
#sensor.set_vflip(True)
sensor.set_contrast(0)
sensor.skip_frames(200)
sensor.set_auto_gain(False) # must be turned off for color tracking
sensor.set_auto_whitebal(False) # must be turned off for color tracking
sensor.set_auto_exposure(True,1)
clock = time.clock()

uart = UART(3, 9600)
K=5000#the value should be measured

def find_max(blobs):
    max_size=0
    for blob in blobs:
        if blob.pixels() > max_size:
            max_blob = blob
            max_size = blob.pixels()
    return max_blob
l = 999
uart_data = 0
while(True):
    clock.tick()
    img = sensor.snapshot()
   # img.draw_rectangle((WINDOW_CENTER_X-15), (WINDOW_CENTER_Y-15),30,30 ,color=(255, 255, 255))

    #红色靶位识别
    if uart.any(): #判断是否有数据接收
        uart_data = int(uart.read().decode())
    #else:
        #uart_data = 0

    if  uart_data == 1:
        color_threshold = red
        led_red.on()
        led_green.off()
        led_blue.off()
    elif uart_data == 2:
        color_threshold = red2
        led_red.off()
        led_green.on()
        led_blue.off()
    else:
        color_threshold = red
        led_red.off()
        led_green.off()
        led_blue.on()

    blobs = img.find_blobs([color_threshold],pixels_threshold=100, area_threshold=100)
    if blobs:
        max_blob = find_max(blobs)
        img.draw_rectangle(max_blob.rect())
        img.draw_cross(max_blob.cx(), max_blob.cy())
        l = (int)(180*48/(max_blob.w()))
        print(l)
        num = max_blob.cx()
        output_str="[%d,%d]" % (num,l)

    else:
        num = 0
        l = 0
        output_str="[%d,%d]" % (num,l)

    uart.write(output_str+'\r\n')
    print('you send:',output_str)

d.智能分拣系统

此工程代码量较大，篇幅有限，如果有需要请评论或者私聊获取完整代码

---

六.总结归纳

相关其它笔记博文，后续还会继续更新完善，欢迎参考，比赛准备笔记，欢迎交流，如果有错误不当之处，还望各位大佬包涵指正

一种基于open mv的自适应阈值的方法

openmv定时器报错——uncaught exception in Timer(2) interrupt handler

一些基于openmv外部按键控制的几种方法

一种优化openmv目标追踪与阈值效果的几个方法