mv调参保存

于 2024-08-15 16:14:14 发布
阅读量62 收藏 1
点赞数
分类专栏： mv 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmf666/article/details/141225075
版权 
import sensor, image, time
from pyb import LED,Pin
from pyb import Timer
import lcd









task_mode = 0  #0:初始模式，就是录像，1：调参模式
blue_led = LED(1)


#thresholds = [
#    (15, 25, 10, 25, -5, 20),  # generic_red_thresholds(15, 23, 10, 24, 0, 18)
#    (30, 100, -64, -8, -32, 32),  # generic_green_thresholds
#    (0, 15, 0, 40, -80, -20),
#]  # generic_blue_thresholds

g_thread_red   =[15, 25, 10, 25, -5, 20]
g_thread_green =[30, 100, -64, -8, -32, 32]
g_thread_blue  =[0, 15, 0, 40, -80, -20]
EXPOSURE_TIME_SCALE = 1.0

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.VGA)
sensor.set_windowing(320,320)
sensor.set_auto_whitebal(False)

#gain_par =0.8
#sensor.set_auto_gain(False, gain_db_ceiling=gain_par)  # Default gain 10.
sensor.set_auto_gain(False)  # Default gain 10.

#EXPOSURE_MICROSECONDS = 500000
##sensor.set_auto_exposure(False, exposure_us=EXPOSURE_MICROSECONDS)
#sensor.set_auto_exposure(True, exposure_us=EXPOSURE_MICROSECONDS)
#sensor.set_auto_exposure(False)



current_exposure_time_in_microseconds = sensor.get_exposure_us()
print("Current Exposure == %d" % current_exposure_time_in_microseconds)

# Auto exposure control (AEC) is enabled by default. Calling the below function
# disables sensor auto exposure control. The additionally "exposure_us"
# argument then overrides the auto exposure value after AEC is disabled.
sensor.set_auto_exposure(
    False, exposure_us=int(current_exposure_time_in_microseconds * EXPOSURE_TIME_SCALE)
)

print("New exposure == %d" % sensor.get_exposure_us())


sensor.skip_frames(time = 500)

try:
    # The camera will now focus on whatever is in front of it.
    sensor.ioctl(sensor.IOCTL_TRIGGER_AUTO_FOCUS)
except:
    raise (Exception("Auto focus is not supported by your sensor/board combination."))

sensor.skip_frames(time = 500)



clock = time.clock()
lcd.init(1, 128, height=160, framesize=0, refresh=30, triple_buffer=False, bgr=False)


#lcd_img =img.scale(0.4,0.5)
#lcd_img.draw_string(0,0,"par_index: %d "% ((par_index)))
#lcd.display(lcd_img)

#blue_led = LED(1)
KEY = Pin('C13',Pin.IN,Pin.PULL_DOWN)

KEY1 = Pin('A0',Pin.IN,Pin.PULL_UP)
KEY2 = Pin('A2',Pin.IN,Pin.PULL_UP)
KEY3 = Pin('A5',Pin.IN,Pin.PULL_UP)#A4A6 不行
KEY4 = Pin('A7',Pin.IN,Pin.PULL_UP)
KEY5 = Pin('C4',Pin.IN,Pin.PULL_UP)
KEY6 = Pin('B0',Pin.IN,Pin.PULL_UP)

print("You're on camera!")
keycount=0
# 轻触开关

waitkeyflag=0
keyval=0
#等开关按下并松开
def wait_key():
    global keyval,waitkeyflag
    while KEY.value():

        while KEY.value():
            while KEY.value(): #wait key up
                clock.tick()
#                i=0   #anything you like
#                print("here01")
            keyval=100
            waitkeyflag=1



key1_status=0
key2_status=0
key3_status=0
key4_status=0
key5_status=0
key6_status=0

key_val =0
key_testnum=0;
key1_step =0


par_index =0

#file_abs = "save1.txt"
f =open("save1.txt","r",encoding = "unicode")
content=""
try :
    while(True):
        chunk = f.read().strip('\x00') #读取文件
        print(chunk)
        if not chunk:
           break
        content =chunk
finally:
    f.seek(0)
    f.close()  #关闭文件
    
print("content=")
print(content)
print(type(content))
readnum = content.split(",")
print("readnum=")
print(readnum)
print(type(readnum))
print("readnum0=")
print(readnum[0])
print(type(readnum[0]))
g_thread_red[0]=int(readnum[0])
g_thread_red[1]=int(readnum[1])
g_thread_red[2]=int(readnum[2])
g_thread_red[3]=int(readnum[3])
g_thread_red[4]=int(readnum[4])
g_thread_red[5]=int(readnum[5])

g_thread_green[0]=int(readnum[6])
g_thread_green[1]=int(readnum[7])
g_thread_green[2]=int(readnum[8])
g_thread_green[3]=int(readnum[9])
g_thread_green[4]=int(readnum[10])
g_thread_green[5]=int(readnum[11])

g_thread_blue[0]=int(readnum[12])
g_thread_blue[1]=int(readnum[13])
g_thread_blue[2]=int(readnum[14])
g_thread_blue[3]=int(readnum[15])
g_thread_blue[4]=int(readnum[16])
g_thread_blue[5]=int(readnum[17])


print("-@@red--start")
print(g_thread_red[0])
print(g_thread_red[1])
print(g_thread_red[2])
print(g_thread_red[3])
print(g_thread_red[4])
print(g_thread_red[5])
print("-@@red--end")

#----------定时器4中断函数
timer4cnt =0
def tick(timer):            # we will receive the timer object when being called
    global timer4cnt
    timer4cnt+=1
#    print("t400")
    if timer4cnt==2:
        timer4cnt =0
        KEY1_Read()
        KEY2_Read()
        KEY3_Read()
        KEY4_Read()
        KEY5_Read()
        KEY6_Read()
#----------创建一个定时器
tim = Timer(4, freq=20)      # create a timer object using timer 4 - trigger at 5Hz
tim.callback(tick)          # set the callback to our tick function
#------------------------------
def KEY1_Read():
    global key1_status
    global waitkeyflag
    global task_mode,key1_step
    global par_index
#    print("key1_read........")
    if KEY1.value()==0 and key1_status==1 and key1_step==0:#2.按键被按下的瞬间，下降沿
        task_mode =1  #调到调参模式
        key1_step =1
        print("h01333333333333333333")

    if KEY1.value()==0 and key1_status==1 and key1_step==1:#2.按键被按下的瞬间，下降沿
        #waitkeyflag =1
        print("task_mode=",task_mode)
        if task_mode==1: #如果是调参模式
            par_index +=1
            if par_index==18:#参数0-17之间,0-5红色，6-11绿，12-17蓝
                par_index=0
            print("par_index=",par_index)
#        print("h08888888888888888")
    elif KEY1.value()==0 and key1_status==0 and key1_step==1 :#3.按键被按下的状态，
        #用户自定义函数
        clock.tick()
        #print("u01444444444444444444")

    key1_status=KEY1.value()	#获取最新状态

def KEY2_Read():
    global key2_status
    global g_thread_red,g_thread_green,g_thread_blue
    global par_index

    if KEY2.value()==0 and key2_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
#        print("key2 is up to down")
        if 0<=par_index<6:

            g_thread_red[par_index] +=5
            if g_thread_red[0]>=95:g_thread_red[0] =0
            if g_thread_red[1]>=95:g_thread_red[1] =0
            if g_thread_red[2]>=128:g_thread_red[2] =-127
            if g_thread_red[3]>=128:g_thread_red[3] =-127
            if g_thread_red[4]>=128:g_thread_red[4] =-127
            if g_thread_red[5]>=128:g_thread_red[5] =-127

            print("KEY2 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] +=5
            if g_thread_green[0]>=95:g_thread_green[0] =0
            if g_thread_green[1]>=95:g_thread_green[1] =0
            if g_thread_green[2]>=128:g_thread_green[2] =-127
            if g_thread_green[3]>=128:g_thread_green[3] =-127
            if g_thread_green[4]>=128:g_thread_green[4] =-127
            if g_thread_green[5]>=128:g_thread_green[5] =-127






            print('KEY2 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] +=5
            if g_thread_blue[0]>=95:g_thread_blue[0] =0
            if g_thread_blue[1]>=95:g_thread_blue[1] =0
            if g_thread_blue[2]>=128:g_thread_blue[2] =-127
            if g_thread_blue[3]>=128:g_thread_blue[3] =-127
            if g_thread_blue[4]>=128:g_thread_blue[4] =-127
            if g_thread_blue[5]>=128:g_thread_blue[5] =-127

            print("KEY2 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")
    elif KEY2.value()==0 and key2_status==0 :#3.按键被按下的状态，
       #用户自定义函数
#        print("key2 is downing")
        if 0<=par_index<6:
           g_thread_red[par_index] +=5
           if g_thread_red[0]>=95:g_thread_red[0] =0
           if g_thread_red[1]>=95:g_thread_red[1] =0
           if g_thread_red[2]>=128:g_thread_red[2] =-127
           if g_thread_red[3]>=128:g_thread_red[3] =-127
           if g_thread_red[4]>=128:g_thread_red[4] =-127
           if g_thread_red[5]>=128:g_thread_red[5] =-127
           print("KEY2 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] +=5
            if g_thread_green[0]>=95:g_thread_green[0] =0
            if g_thread_green[1]>=95:g_thread_green[1] =0
            if g_thread_green[2]>=128:g_thread_green[2] =-127
            if g_thread_green[3]>=128:g_thread_green[3] =-127
            if g_thread_green[4]>=128:g_thread_green[4] =-127
            if g_thread_green[5]>=128:g_thread_green[5] =-127
            print('KEY2 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] +=5
            if g_thread_blue[0]>=95:g_thread_blue[0] =0
            if g_thread_blue[1]>=95:g_thread_blue[1] =0
            if g_thread_blue[2]>=128:g_thread_blue[2] =-127
            if g_thread_blue[3]>=128:g_thread_blue[3] =-127
            if g_thread_blue[4]>=128:g_thread_blue[4] =-127
            if g_thread_blue[5]>=128:g_thread_blue[5] =-127
            print("KEY2 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")
    key2_status=KEY2.value()	#获取最新状态

def KEY3_Read():
    global key3_status
    global waitkeyflag
    global thresholds
    global par_index

    if KEY3.value()==0 and key3_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        if 0<=par_index<6:
           g_thread_red[par_index] -=5
           if g_thread_red[0]<=0:g_thread_red[0] =95
           if g_thread_red[1]<=0:g_thread_red[1] =95
           if g_thread_red[2]<=-127:g_thread_red[2] =128
           if g_thread_red[3]<=-127:g_thread_red[3] =128
           if g_thread_red[4]<=-127:g_thread_red[4] =128
           if g_thread_red[5]<=-127:g_thread_red[5] =128
           print("KEY3 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] -=5
            if g_thread_green[0]<=0:g_thread_green[0] =95
            if g_thread_green[1]<=0:g_thread_green[1] =95
            if g_thread_green[2]<=-127:g_thread_green[2] =128
            if g_thread_green[3]<=-127:g_thread_green[3] =128
            if g_thread_green[4]<=-127:g_thread_green[4] =128
            if g_thread_green[5]<=-127:g_thread_green[5] =128
            print('KEY3 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] -=5
            if g_thread_blue[0]<=0:g_thread_blue[0] =100
            if g_thread_blue[1]<=0:g_thread_blue[1] =100
            if g_thread_blue[2]<=-127:g_thread_blue[2] =128
            if g_thread_blue[3]<=-127:g_thread_blue[3] =128
            if g_thread_blue[4]<=-127:g_thread_blue[4] =128
            if g_thread_blue[5]<=-127:g_thread_blue[5] =128
            print("KEY3 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")

#        print("key3 is up to down")

    elif KEY3.value()==0 and key3_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       #用户自定义函数
       if 0<=par_index<6:
          g_thread_red[par_index] -=5
          if g_thread_red[0]<=0:g_thread_red[0] =100
          if g_thread_red[1]<=0:g_thread_red[1] =100
          if g_thread_red[2]<=-127:g_thread_red[2] =128
          if g_thread_red[3]<=-127:g_thread_red[3] =128
          if g_thread_red[4]<=-127:g_thread_red[4] =128
          if g_thread_red[5]<=-127:g_thread_red[5] =128
          print("KEY3 g_thread_red[par_index]=",g_thread_red[par_index])

       elif 6<=par_index<12:
           g_thread_green[par_index-6] -=5
           if g_thread_green[0]<=0:g_thread_green[0] =100
           if g_thread_green[1]<=0:g_thread_green[1] =100
           if g_thread_green[2]<=-127:g_thread_green[2] =128
           if g_thread_green[3]<=-127:g_thread_green[3] =128
           if g_thread_green[4]<=-127:g_thread_green[4] =128
           if g_thread_green[5]<=-127:g_thread_green[5] =128
           print('KEY3 g_thread_green[par_index]=',g_thread_green[par_index-6])
#           print("key2000..")
       elif 12<=par_index<18:
           g_thread_blue[par_index-12] -=5
           if g_thread_blue[0]<=0:g_thread_blue[0] =100
           if g_thread_blue[1]<=0:g_thread_blue[1] =100
           if g_thread_blue[2]<=-127:g_thread_blue[2] =128
           if g_thread_blue[3]<=-127:g_thread_blue[3] =128
           if g_thread_blue[4]<=-127:g_thread_blue[4] =128
           if g_thread_blue[5]<=-127:g_thread_blue[5] =128
           print("KEY3 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#           print("key2111..")

    key3_status=KEY3.value()	#获取最新状态

key4val=0
def KEY4_Read():
    global key4_status
    global waitkeyflag
    global key4val
#    file_abs = "save.txt"
    if KEY4.value()==0 and key4_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        key4val=1
        #关闭定时器，不然中断会有影响
        print("key4 is up to down")
    elif KEY4.value()==0 and key4_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       clock.tick()
#       print("key4 is downing")
    key4_status=KEY4.value()	#获取最新状态

def KEY5_Read():
    global key5_status
    global task_mode,par_index
    if KEY5.value()==0 and key5_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        if task_mode==1: #如果是调参模式
            par_index -=1
            if par_index==0:#参数0-17之间,0-5红色，6-11绿，12-17蓝
                par_index=17
            print("par_index=",par_index)
#        print("key5 is up to down")

    elif KEY5.value()==0 and key5_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       clock.tick()
#       print("key5 is downing")
    key5_status=KEY5.value()	#获取最新状态


key6cnt=0
task_num=0
def KEY6_Read():
    global key6_status
    global key6cnt
    global task_num
    if KEY6.value()==0 and key6_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        print("key6 is up to down")
        if key6cnt==0:  #红色
            key6cnt=1
            task_num=0

        elif key6cnt==1: #绿色
            key6cnt=2
            task_num=0

        elif key6cnt==2:#blue color
            key6cnt=3
            task_num=0

        elif key6cnt==3:#scan code
                key6cnt=0
                task_num=1


    elif KEY6.value()==0 and key6_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       print("key6 is downing")
    key6_status=KEY6.value()	#获取最新状态



def search_max(blobs):
    max_blob = 0
    max_size = 0
    for blob in blobs:
        blob_area = blob[2] * blob[3]
        if blob_area > max_size:
            max_blob = blob
            max_size = blob_area
    return max_blob
    
    
    
#闪烁5次之后，等5秒，5秒之内看下有没有任意一个按键按下，有的话，进入调参模式，没有的话，比赛模式
num=0
blue_led.on()
for num in range(10):  # 迭代 10 到 20 (不包含) 之间的数字
    blue_led.toggle()
    time.sleep_ms(300)
    print(num)
blue_led.off()


num=0
for num in range(10):  # 迭代 10 到 20 (不包含) 之间的数字
    blue_led.toggle()
    if task_mode==1:#调参模式
        break
    time.sleep_ms(500)
    print(num)

blue_led.off()






g_thread_red00=[(15, 25, 10, 25, -5, 20)]
#绿(24, 52, -40, -4, 0, 34)
while(True):
    if task_mode==1:#调参模式[15, 25, 10, 25, -5, 20]  [g_thread_red][thresholds[threshold_index]]
       #print("tiaocan mode")
        clock.tick()
        img = sensor.snapshot()

        lcd_img =img.scale(0.4,0.5)

        lcd_img.draw_string(0,0,"par_index: %d "% (par_index))
        lcd_img.draw_string(0,10,"rL:%d,%d"% (g_thread_red[0],g_thread_red[1]),color= [200, 0, 0])
        lcd_img.draw_string(0,20,"rA:%d,%d"% (g_thread_red[2],g_thread_red[3]),color= [200, 0, 0])
        lcd_img.draw_string(0,30,"rB:%d,%d"% (g_thread_red[4],g_thread_red[5]),color= [200, 0, 0])
        lcd_img.draw_string(0,40,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 255, 0])
        lcd_img.draw_string(0,50,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 255, 0])
        lcd_img.draw_string(0,60,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 255, 0])
        lcd_img.draw_string(0,70,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 91, 170])
        lcd_img.draw_string(0,80,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 91, 170])
        lcd_img.draw_string(0,90,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 91, 170])
        lcd.display(lcd_img)

        if 0<=par_index<6:
            threadtemp = g_thread_red

        elif  6<=par_index<12:
            threadtemp = g_thread_green


        elif  12<=par_index<18:
            threadtemp = g_thread_blue


        print(threadtemp)
                                            #如果找到了目标颜色
        print("here0000")
        blobs = img.find_blobs([threadtemp], area_threshold=500, margin=10)
            #寻找对应阈值的色块，阈值小于300像素的色块过滤掉，合并相邻像素在10个像素内的色块
        if blobs:                                            #如果找到了目标颜色
                print("here0000")
                max_blob = search_max(blobs)
                lcd_img.draw_rectangle(max_blob[0:4])  # rect
                lcd_img.draw_cross(max_blob[5], max_blob[6]) # cx,cy
                lcd.display(lcd_img)




        if key4val==1:
                    print("key4--------")
                    key4val=0
                    print("-@@red--start")
                    print(g_thread_red[0])
                    print(g_thread_red[1])
                    print(g_thread_red[2])
                    print(g_thread_red[3])
                    print(g_thread_red[4])
                    print(g_thread_red[5])
                    print("-@@red--end")

                    print("-----write data to file---")

                    f =open("save1.txt","w")
                    #写入数据
                    f.seek(0)
                    f.write(str(g_thread_red[0])+","+str(g_thread_red[1])+","+str(g_thread_red[2])+","+str(g_thread_red[3])+","+str(g_thread_red[4])+","+str(g_thread_red[5])+","+\
                            str(g_thread_green[0])+","+str(g_thread_green[1])+","+str(g_thread_green[2])+","+str(g_thread_green[3])+","+str(g_thread_green[4])+","+str(g_thread_green[5])+","+\
                            str(g_thread_blue[0])+","+str(g_thread_blue[1])+","+str(g_thread_blue[2])+","+str(g_thread_blue[3])+","+str(g_thread_blue[4])+","+str(g_thread_blue[5]))
                    time.sleep_ms(10) #等待写入完成
                    f.seek(0)
            #        f.flush() #缓存刷新
                    f.close() #关闭文件
                    task_mode=0
                    print("write ok and close\r\n")


    elif task_mode==0:  #
       print("game mode")
#       print("-@@red--start")
#       print(g_thread_red[0])
#       print(g_thread_red[1])
#       print(g_thread_red[2])
#       print(g_thread_red[3])
#       print(g_thread_red[4])
#       print(g_thread_red[5])
#       print("-@@red--end")
       waitkeyflag =1
       break  #跳出这个循环














#如果上面5秒之内没有按键按下，错过这个时间点，按键1后面执行的是第二阶段的代码
if key1_step==0:
    key1_step=1


print("while(True)...")
threadtemp =g_thread_red
while(True):
    clock.tick()

    if waitkeyflag==0:
        wait_key()
#        print(waitkeyflag)
#        print("wait key00")
    elif waitkeyflag==1 :
        img = sensor.snapshot()
        lcd_img =img.scale(0.4,0.5)

        lcd_img.draw_string(0,0,"par_index: %d "% (par_index))
        lcd_img.draw_string(0,10,"rL:%d,%d"% (g_thread_red[0],g_thread_red[1]),color= [200, 0, 0])
        lcd_img.draw_string(0,20,"rA:%d,%d"% (g_thread_red[2],g_thread_red[3]),color= [200, 0, 0])
        lcd_img.draw_string(0,30,"rB:%d,%d"% (g_thread_red[4],g_thread_red[5]),color= [200, 0, 0])
        lcd_img.draw_string(0,40,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 255, 0])
        lcd_img.draw_string(0,50,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 255, 0])
        lcd_img.draw_string(0,60,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 255, 0])
        lcd_img.draw_string(0,70,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 91, 170])
        lcd_img.draw_string(0,80,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 91, 170])
        lcd_img.draw_string(0,90,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 91, 170])
        lcd_img.draw_string(0,100,"task_num:%d"% (task_num),color=[0, 91, 170])

        lcd.display(lcd_img)
        if key6cnt==1:
            threadtemp = g_thread_red
        elif   key6cnt==2:
            threadtemp = g_thread_green
        elif   key6cnt==3:
                threadtemp = g_thread_blue
        elif   key6cnt==0:
               task_mode=1

        if task_num==0:
            blobs = img.find_blobs([threadtemp], area_threshold=500, margin=10)
                #寻找对应阈值的色块，阈值小于300像素的色块过滤掉，合并相邻像素在10个像素内的色块
            if blobs:                                            #如果找到了目标颜色
                    print("here0000")
                    max_blob = search_max(blobs)
                    lcd_img.draw_rectangle(max_blob[0:4])  # rect
                    lcd_img.draw_cross(max_blob[5], max_blob[6]) # cx,cy
                    lcd.display(lcd_img)
                    
                    
                    
                    
#                    for b in blobs:
#                    #迭代找到的目标颜色区域
#                        lcd_img.draw_cross(int(b[5]), int(b[6]))                  #画十字 cx,cy
#            #            blobs.cx() 返回色块的外框的中心x坐标（int），也可以通过blob[5]来获取。
#            #            blobs.cy() 返回色块的外框的中心y坐标（int），也可以通过blob[6]来获取。
#                        lcd_img.draw_edges(b.min_corners(), color=(0,255,0))#画框
#                        lcd.display(lcd_img)
        elif task_num==1:
            for code in img.find_qrcodes():
                 lcd_img.draw_rectangle(code.rect(), color = 127)
                 outstr1=str(code.payload())
                 lcd_img.draw_string(0,110,"outstr1:%s"% (outstr1),color=[0, 0, 170])

                 print(code)
                 
                 
                 


        lcd_img.draw_string(0,0,"par_index: %d "% (par_index))


        lcd.display(lcd_img)
        print(clock.fps())

#    print(task_mode)
#    print("key1_step="+str(key1_step))
ooolmf
关注
专栏目录
【深度学习模型的部署和集成】部署深度学习模型到实际生产环境中的一些经验和方法 Deploying and Integrating Deep Learning
禅与计算机程序设计艺术
08-02 864
在深度学习火爆的今天，部署一个深度学习模型到生产环境中是非常重要的一环。部署包括训练好的模型、配置文件、数据处理流程等一系列的文件都需要准备好并保存在合适的位置，然后通过调用库或者接口加载这些文件并运行预测任务。而在生产环境中，因为需求的变化，数据量的增长，以及机器资源的不断增加，部署模型变得十分复杂，如何保证服务的稳定性、高可用性，以及快速响应，成为了非常重要的问题。因此，对于部署深度学习模型到实际生产环境中的一些经验和方法，我们将分享给大家。
服务器调参实录
qq_49215659的博客
04-12 83
pycharm部分 weileiyi实验室的密码和教程都在语雀上，可以自行查看，正版可以用远程连接 注意的是要确定好remote的环境安装正确 如果是涉及到画图的话，服务器是没法显示的，但是在pycharm的run里面是可以显示的，所以run的功能总体比直接在命令行中运行方便 但是run中可以看作为前台运行，很多情况下突然断网，关机意外发生的时候会自动停止，所以在使用长时间运行程序的角度来说不推荐 当别人复制给你文件的时候，一定要删除掉.idea这个文件，因为这个文件里面全部都是别人配置好的文件，会和你自
mv:按键调参数，定时器，文件保存参数，调出参数01
lmf666的博客
08-08 377
K1—开机5秒之内检测判断K1有没有暗下来，如果暗下来，那么进入调参模式。0-5是红色阈值，LAB，Lmin ,Lmax,Amin,Amax,Bmin,Bmax;注意，保存数据下，要重新按下板子的rst复位按键，才可以看到U盘的文件的数据有变化。读取数据之后，如果要重新读取，记得把读取指针放到最开头，f.seek(0)；K2是调参模式下，那么对数据+5,5是参数变化步长，具体可以根据实际调节；注意，加5和减5的代码，改进版本要加边界处理，因为数据是。K5是参数选择0-15，按下，参数-1；
移动机器人激光SLAM导航（五）：Cartographer SLAM 篇
qq_42994487的博客
02-14 1702
移动机器人激光SLAM导航（四）：Cartographer SLAM 篇
Betaflight通过OSD设置摄像头参数(F*V Camera Control)
nyway's博客
03-16 6397
简介 在无人机飞行中，有些摄像头支持通过飞控的OSD界面进入到摄像头系统，从而设置摄像头的相关参数，如白平衡、亮度、个性化字符信息等参数。（F*V Camera Control） 设置步骤 DALRC F405飞控支持此项功能，需要配合OSD界面进行，USB连接后进入Betaflight Configurator的CLI命令模式下按如下步骤设置命令： 1.映射端口（飞控固件内已默认映射...
VC++常用功能开发
热门推荐
Keivin
09-28 17万+
系列文章目录 第一章：VC++ ini配置文件封装类源代码 第二章：VC++实现二维码(显示+保存图片)功能源代码 第三章：VC++ 调节系统音量(与任务栏音量同步)源代码 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启..
Spark本地环境搭建（local模式）
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-01 4654
大数据实验教学系统Spark本地环境搭建（local模式）spark有以下几种运行模式，每种运行模式都有自己不同的优点和长处。了解Spark不同安装包之间的区别   安装和配置Spark环境（本地模式）   测试Spark安装是否成功。1、安装和配置Spark环境（本地模式）   2、测试Spark。硬件：x86_64 ubuntu 16.04服务器   软件：JDK1.8，Spark-2.3.2，Hadoop-2.7.3   在本实验环境中，Spark安装包位于以下位置：/data/software/sp
ASM字节码编程 | 用字节码增强技术给所有方法加上TryCatch捕获异常并输出
bugstack虫洞栈
04-17 3416
作者：小傅哥 博客：https://bugstack.cn 仓库：https://github.com/fuzhengwei/CodeGuide/wiki 沉淀、分享、成长，让自己和他人都能有所收获 一、前言 你开发的系统是裸奔的吗？深夜被老板 Diss 一套系统是否稳定运行，取决于它的运行健康度，而这包括；调用量、可用率、响应时长以及服务器性能等各项指标的一个综合值。并且在系统出现异常问...
SLAM学习笔记（二十一）3D雷达与相机的标定方法详细教程
微鉴道长的博客
11-15 4625
写在前面 把3D雷达和相机进行外参标定使用的方法我们采取LiDAR-Camera Calibration using 3D-3D Point correspondences 方法。 这里我使用的相机为realsense D435i 以及Velodyne16雷达。 其实具体的细节github上面已经写过了，但是对于没有跑过的人来说，搞定这个东西还是有一定麻烦的。因此把细节记录在这里。 希望涉及汇总方面的朋友们可以原文引用本链接，码字不易，谢谢！ 环境安装 其实这块的内容原链接已经写的非常.
P2飞控调参软件
08-19
【P2飞控调参软件】是针对极翼P2飞行控制器进行参数调整的专业工具，对于无人机爱好者和专业用户来说，这款软件是不可或缺的。它提供了直观易用的界面，使得新手也能快速上手，进行各种复杂的飞行控制设置。通过这款...
星云5100调参软件合集
07-16
《星云5100调参软件合集详解》 在摄影领域，稳定器是提升拍摄质量的关键设备，尤其对于专业摄影师和视频制作人来说，一款好的三轴稳定器至关重要。星云5100正是这样一款备受青睐的稳定器，而与其配套的调参软件则是...
穿越机调参软件
01-21
穿越机调参软件，如标题所示，主要针对的是无人机领域中的穿越机（也称为FPV无人机）进行飞行控制参数的优化。在无人机竞速或自由飞行中，穿越机的性能至关重要，而调参软件则是提升其性能的关键工具之一。这款名为...
BLHeliSuite.zip BL电调 调参软件及软件功能介绍
02-01
BLHeliSuite是一款专为多轴飞行器电机控制器（简称电调，英文Electronics Speed Controller，ESC）设计的调参软件。它支持多种类型的BL电调，如DShot、OneShot、MultiShot等通信协议，提供了细致且强大的电调设置...
Python 算法交易实验80 QTV200日常推进-目标估算
yukai08008的博客
08-10 487
业务目标在先，月利3%是第一个目标。虽然日常有在常规推进，但目标是什么？现在做的是什么？与目标的关联是什么？业务上讲，如果月利能够达到3%(几何平均)，上下波动不超过1%，就算达标了(2%~4%)。考虑到金融领域有不可测风险，所以资金还会分摊到3个月。例如，假如总投资资金是30万，那么每个月的最大投资金额是10万。这样即使遇到大跳水，问题也不大。目标达到的话，10万本金每月的盈利是3000， 按复利计,24个月就会double，我觉得已经足够理想。假设投资90万，则可以按30万计算复利效果。
汽车免拆诊断案例 | DAF（达富）汽油尾气处理液故障警示
虹科Pico汽车示波器的博客
08-14 577
一辆DAF（达富）故障警示灯亮，提示DEF系统故障，使用虹科Pico汽车示波器检查发现故障的原因是......
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 297
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
Falsk测试与部署（第九阶段）
蜡笔小新星的博客
08-09 686
在本章节中，我们学习了如何使用unittest和pytest进行单元和集成测试，以及如何配置Flask应用，使用WSGI服务器部署，容器化Flask应用并将其部署到各种云服务平台。通过这些步骤，你可以确保你的Flask应用在生产环境中的稳定性和可靠性。希望这些知识能够帮助你在实际项目中更好地实现测试和部署。
Java读写EM4305卡、将4305卡制做成4100ID卡
zhangjin7422的专栏
08-14 295
Java读写em4305低频RFID源码，支持将EM4305卡配置成4100ID卡
PID调参 matlab
04-26
PID调参是一种常用的控制算法用于调整控制系统中的比例、积分和微分参数，以实现系统的稳定性和性能优化。在Matlab中，可以使用PID工具箱来进行PID调参。 PID调参的目标是通过调整比例系数Kp、积分时间Ti和微分时间Td，使得系统的响应满足要求。一般来说，调参的过程可以分为以下几个步骤： 1. 确定系统模型：首先需要建立系统的数学模型，可以通过实验数据或者理论推导得到。 2. 初始参数设定：根据经验或者系统特性，设置初始的PID参数。 3. 调整比例系数Kp：从较小的值开始，逐渐增大Kp，观察系统的响应。如果响应过冲严重，则减小Kp；如果响应不足，则增大Kp。 4. 调整积分时间Ti：增大Ti可以减小稳态误差，但会增加系统的超调量。根据实际需求，逐渐增大或减小Ti，观察系统的响应。 5. 调整微分时间Td：增大Td可以提高系统的响应速度，但会增加噪声的放大。根据实际需求，逐渐增大或减小Td，观察系统的响应。 6. 优化参数：根据实际需求，反复调整参数，直到系统的响应满足要求。 在Matlab中，可以使用PID工具箱来进行PID调参。具体步骤如下： 1. 打开PID工具箱：在Matlab命令窗口中输入"pidtool"，打开PID工具箱。 2. 导入系统模型：在PID工具箱中，选择"Import Model"，导入系统模型。 3. 设定初始参数：在PID工具箱中，设置初始的PID参数。 4. 调整参数：通过手动调整参数或者使用自动调参功能，逐步优化PID参数。 5. 保存参数：在PID工具箱中，保存最优的PID参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值