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

（开源）2023工训大赛智能垃圾分类项目(可循环播放视频，显示垃圾分类信息，拍照识别，垃圾分类，满载报警，压缩）_工程训练大赛垃圾分类项目

作者：你好赵伟 | 2024-04-23 11:24:05

赞

踩

工程训练大赛垃圾分类项目

省赛:由于这个比赛是两年一届，并未做足充分的准备，但是通过一定的单片机基础，加上速成能力，也就是熬夜学，通过疯狂的网络搜索，在省赛第5  入选国赛

下面来简单介绍一下我们作品：

主控：因为识别如果你不将图像处理放到主控上处理，就有点麻烦，因为我们是使用的K210作为识别装置的，识别速度很快，如果进行识别发串口，就有点赌，本来速度就快，处理都处理不过来，当然你也可以用个取平均的算法，貌似这样也不是很好，还是得把识别和分类放到一起，这样处理才连贯。

最开始考虑的使用openmv，或者opencv在树莓派上做图像识别。 这个方案现阶段真不建议尝试，说实话，效果很不好。先不说准确率了，光是识别帧率就低到离谱。 所以当时也很巧合，发现一款很不错，上手很简单的开发板。就是Sipeed科技推出的几款k210芯片的开发板，第一眼看到，真是精致，再了解它的功能，简直强大，再看它的价格，wc，好划算（虽然这一年涨价了，还涨了不少）。尤其是这么小巧的一个板子，跑图像识别真是强，还很流畅，为什么呢？自己去看吧。

原文链接：https://blog.csdn.net/GUA8122HOU/article/details/120317568

这是k210总代码：

  1. #2023 10 15 派大星改
  2. # object classifier boot.py
  3. # generated by maixhub.com
  4. from fpioa_manager import *
  5. from modules import ultrasonic
  6. from fpioa_manager import fm
  7. from Maix import GPIO
  8. import math
  9. import struct
  10. import sensor, image, lcd, time
  11. import KPU as kpu
  12. import gc, sys
  13. from Maix import GPIO
  14. from machine import UART
  15. from machine import Timer,PWM
  16. #
  17. #
  18. i= 8
  19. # 定义超声波传感器的触发引脚和回响引脚
  20. trig_pin = 0
  21. echo_pin = 1
  22.  
  23. #控制串口通信
  24. board_info_tx=15
  25. board_info_rx=17
  26. # 将GPIO口初始化为输入/输出模式
  27. fm.register(trig_pin, fm.fpioa.GPIO0)
  28. fm.register(echo_pin, fm.fpioa.GPIO1)
  29. trig = GPIO(GPIO.GPIO0, GPIO.OUT)
  30. echo = GPIO(GPIO.GPIO1, GPIO.IN)
  31. tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)               #控制2个云台舵机
  32. S1 = PWM(tim, freq=50, duty=0, pin=21)
  33. tim = Timer(Timer.TIMER1, Timer.CHANNEL0, mode=Timer.MODE_PWM)
  34. S2 = PWM(tim, freq=50, duty=0, pin=23)
  35.  
  36. value = 0xFF
  37. s = struct.pack('B', value)
  38. list_of_values = [255]*3
  39. s = struct.pack('3B', *list_of_values)                                       #串口通信结束符
  40.  
  41. fm.register(board_info_tx,fm.fpioa.UART1_TX,force=True)
  42. fm.register(board_info_rx,fm.fpioa.UART1_RX,force=True)
  43. uart_A = UART(UART.UART1, 115200, 8, None, 1, timeout=1000, read_buf_len=4096)
  44. #uart_A = UART(UART.UART1, 115200,read_buf_len=4096)
  45.  
  46.  
  47. def Servo_1(servo,angle):
  48.     S1.duty((angle+90)/180*10+2.5)              #竖直舵机
  49. def Servo_2(servo,angle):
  50.     S2.duty((angle+90)/270*10+2.5)              #水平舵机
  51. #超声波
  52. def measure_distance():
  53.     trig.value(0) # 发送触发信号
  54.     time.sleep_ms(2)
  55.     trig.value(1)
  56.     time.sleep_us(10)
  57.     trig.value(0)
  58.     start_time = time.ticks_ms()
  59.     while echo.value() == 0 and time.ticks_diff(time.ticks_ms(), start_time) < 3000:
  60.         pass
  61.  
  62.     # 如果等待超时，返回错误代码 -1
  63.     if time.ticks_diff(time.ticks_ms(), start_time) >= 3000:
  64.         print("Error: no echo received!")
  65.         return -1
  66.  
  67.     # 记录回响信号的时间戳
  68.     t1 = time.ticks_us()
  69.     while echo.value() == 1:
  70.         pass
  71.     t2 = time.ticks_us()
  72.  
  73.     print(t2)
  74.     # 计算距离（单位：厘米）
  75.     duration = t2 - t1
  76.     distance = duration * 0.017
  77.     print(distance)
  78.     if distance < 15:                                 #距离判断
  79.        write_str = ("t20.bco=63488")
  80.        uart_A.write(write_str)
  81.        print("满载")
  82.        uart_A.write(s)
  83.     else:
  84.        write_str = ("t20.bco=34784")
  85.        uart_A.write(write_str)
  86.        print("未满载")
  87.        uart_A.write(s)
  88.     return
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95. def lcd_show_except(e):
  96.     import uio
  97.     err_str = uio.StringIO()
  98.     sys.print_exception(e, err_str)
  99.     err_str = err_str.getvalue()
  100.     img = image.Image(size=(224,224))
  101.     img.draw_string(0, 10, err_str, scale=1, color=(0xff,0x00,0x00))
  102.     lcd.display(img)
  103.  #开机启动
  104.  ########################################################################################################################
  105. def main(labels = None, model_addr="/sd/m.kmodel", sensor_window=(224, 224), lcd_rotation=0, sensor_hmirror=False, sensor_vflip=False):
  106.     sensor.reset()
  107.     sensor.set_pixformat(sensor.RGB565)
  108.     sensor.set_framesize(sensor.QVGA)
  109.     sensor.set_windowing(sensor_window)
  110.     sensor.set_hmirror(sensor_hmirror)
  111.     sensor.set_vflip(sensor_vflip)
  112.     sensor.run(1)
  113.  
  114.     lcd.init(type=1,invert=1)        #小LCD屏幕
  115.     lcd.rotation(lcd_rotation)
  116.     lcd.clear(lcd.WHITE)
  117.     if not labels:
  118.         with open('labels.txt','r') as f:
  119.             exec(f.read())
  120.     if not labels:
  121.         print("no labels.txt")
  122.         img = image.Image(size=(320, 240))
  123.         img.draw_string(90, 110, "no labels.txt", color=(255, 0, 0), scale=2)
  124.         lcd.display(img)
  125.         return 1
  126.     try:
  127.         img = image.Image("startup.jpg")
  128.         lcd.display(img)
  129.     except Exception:
  130.         img = image.Image(size=(320, 240))
  131.         img.draw_string(90, 110, "loading model...", color=(255, 255, 255), scale=2)
  132.         lcd.display(img)
  133.     task = kpu.load(model_addr)
  134.     try:
  135. ####################################循环######################################################################################
  136.         a= 0
  137.         while(a<3):
  138.             print("启动")
  139.             write_str = ("page main")           #跳到计数主屏幕
  140.             uart_A.write(write_str)
  141.             uart_A.write(s)
  142.             print(write_str)
  143.             a+=1
  144.  
  145.  
  146.         while(True):
  147.             Servo_1(S1, i)
  148.             Servo_2(S2, 0)
  149.             time.sleep_ms(500)
  150.             measure_distance()                 #满载检查
  151.             print("满载jianche ")
  152.             write_str = ("n5.val=0")           #初始化串口屏幕
  153.             uart_A.write(write_str)
  154.             uart_A.write(s)
  155.             print(write_str)
  156.             while(True):
  157.  
  158.                 img = sensor.snapshot()
  159.                 t = time.ticks_ms()
  160.                 fmap = kpu.forward(task, img)
  161.                 t = time.ticks_ms() - t
  162.                 plist=fmap[:]
  163.                 pmax=max(plist)                      #判断最大置信度
  164.                 if pmax < 0.4:                       #检测空物品
  165.                     empty_str = "Not subject"
  166.                     img.draw_string(0, 0, empty_str, scale=2)
  167.                     lcd.display(img)
  168.                     Servo_1(S1, i)
  169.                     Servo_2(S2, 0)
  170.                     break
  171.                 max_index=plist.index(pmax)
  172.                 img.draw_string(0,0, "%.2f : %s" %(pmax, labels[max_index].strip()), scale=2)
  173.                 img.draw_string(0, 200, "t:%dms" %(t), scale=2)
  174.                 lcd.display(img)
  175.  
  176.  
  177.                 if plist.index(pmax)==0 or plist.index(pmax)==6:  #fruit "vegetable"    厨余垃圾
  178.                     if pmax >= 0.5:
  179.  
  180.                             time.sleep_ms(50)      #等待垃圾掉落待静止的时间
  181.                             Servo_2(S2,90)
  182.                             time.sleep_ms(1000)
  183.                             Servo_1(S1,-20)
  184.                             time.sleep_ms(1500)
  185.                             #write_str = ()
  186.                             Servo_1(S1,i)
  187.                             time.sleep_ms(400)
  188.                             Servo_2(S2,0)
  189.                             time.sleep_ms(1000)
  190.                             uart_A.write("t7.txt=\"厨余垃圾\"")
  191.                             print("厨余垃圾ok")
  192.                             uart_A.write(s)
  193.  
  194.                             time.sleep_ms(450)   #舵机归位
  195.                             Servo_1(S1,i)
  196.                             time.sleep_ms(450)
  197.                             break
  198.                             #time.sleep_ms(500)      #等待垃圾掉落待静止的时间
  199.  
  200.                 if plist.index(pmax)== 1 or plist.index(pmax)==2 or plist.index(pmax)== 7:  #capsule      有害垃圾
  201.                     if pmax >= 0.6:    #0.5
  202.  
  203.                             time.sleep_ms(50)      #时隔几秒后继续检测垃圾
  204.                             #Servo_2(S2,90)
  205.                             #time.sleep_ms(500)
  206.                             Servo_1(S1,-30)
  207.                             time.sleep_ms(1500)
  208.                             #write_str = ()
  209.                             uart_A.write("t7.txt=\"有害垃圾\"")
  210.                             print("有害垃圾ok")
  211.                             uart_A.write(s)
  212.  
  213.                             time.sleep_ms(450)   #舵机归位
  214.                             Servo_1(S1,i)
  215.                             Servo_2(S2,0)
  216.                             time.sleep_ms(450)
  217.                             break
  218.  
  219.  
  220.  
  221.                 if plist.index(pmax)==4 or plist.index(pmax)==8:  #bottle        可回收垃圾
  222.                     if pmax >= 0.5:
  223.  
  224.                             time.sleep_ms(50)      #等待垃圾掉落待静止的时间
  225.                             Servo_2(S2,180)
  226.                             time.sleep_ms(1000)
  227.                             Servo_1(S1,-20)
  228.                             time.sleep_ms(1500)
  229.                             #write_str = ()
  230.                             Servo_1(S1,i)
  231.                             time.sleep_ms(400)
  232.                             Servo_2(S2,0)
  233.                             time.sleep_ms(1000)
  234.                             uart_A.write("t7.txt=\"可回收垃圾\"")
  235.                             print("可回收垃圾ok")
  236.                             uart_A.write(s)
  237.                             time.sleep_ms(1200)   #舵机归位
  238.                             break
  239.  
  240.  
  241.  
  242.                 if plist.index(pmax)==3 or plist.index(pmax)== 5 or plist.index(pmax)== 9:  #cigarette      其他垃圾
  243.                     if pmax >= 0.7:  #0.5
  244.  
  245.                             time.sleep_ms(50)      #等待垃圾掉落待静止的时间
  246.                             Servo_2(S2,-90)
  247.                             time.sleep_ms(1000)
  248.                             Servo_1(S1,-20)
  249.                             time.sleep_ms(1500)
  250.                             #write_str = ()
  251.                             Servo_1(S1,i)
  252.                             time.sleep_ms(400)
  253.                             Servo_2(S2,0)
  254.                             time.sleep_ms(1000)
  255.  
  256.                             uart_A.write("t7.txt=\"其他垃圾\"")
  257.                             print("其他垃圾ok")
  258.                             uart_A.write(s)
  259.                             time.sleep_ms(450)   #舵机归位
  260.                             Servo_1(S1,i)
  261.                             Servo_2(S2,0)
  262.                             time.sleep_ms(500)
  263.                             break
  264.         uart.deinit()                   # uart.deinit()和kpu.deinit(task)用于关闭UART和释放模型资源。
  265.         del uart
  266.     except Exception as e:
  267.         raise e
  268.     finally:
  269.         if not task is None:
  270.             kpu.deinit(task)
  271.  
  272. if __name__ == "__main__":
  273.   try :
  274.       #labels = ["bottle", "brick", "capsule", "pill", "stone", "vegetable"]
  275.       #labels = ["chuyu", "dainci", "jiaolang", "shitou", "shuiping", "taoci", "yaobaozhung", "yilaguan"]
  276.       labels = ["chuyu", "dainci", "jiaolang", "shitou", "shuiping", "taoci", "xiaotudou", "yaobaozhung", "yilaguan", "zhuangtou"]
  277.       main(labels=labels, model_addr="/sd/m.kmodel")
  278.   except Exception as e:
  279.       sys.print_exception(e)
  280.       lcd_show_except(e)
  281.   finally:
  282.       gc.collect()
  283.

识别：K210，虽然这东西是挺强的，但是模型有点难训练。我们是根据maixpy 官网的本地环境来进行训练的，环境有点麻烦，也可以直接CPU跑 但是有点发烫 我电脑都跑坏了，修了我300大洋，所以还是使用GPU跑，训练速度也快、

分类装置：初赛直接就是云台加舵机，没啥讲的，k210控制就可以了

满载检测：超声波检查，省赛的时候就做了一个，因为超声波挺费时间的，比赛一个物体识别的时间是有要求的，我们做了一个，结果没用上，没抽到，国赛我把其他三个加上去，结果是我自己选一个，气死，开始我还用小车的红外避障模块来做，简单的一批，后面还是觉得测的不如超声波准。还是用的

  1. import time
  2. from fpioa_manager import fm
  3. from Maix import GPIO
  4.  
  5. # 定义超声波传感器的触发引脚和回响引脚
  6. trig_pin = 0
  7. echo_pin = 1
  8.  
  9. # 将GPIO口初始化为输入/输出模式
  10. fm.register(trig_pin, fm.fpioa.GPIO0)
  11. fm.register(echo_pin, fm.fpioa.GPIO1)
  12. trig = GPIO(GPIO.GPIO0, GPIO.OUT)
  13. echo = GPIO(GPIO.GPIO1, GPIO.IN)
  14.  
  15.  
  16. def measure_distance():
  17.     # 发送触发信号
  18.     trig.value(0)
  19.     time.sleep_ms(2)
  20.     trig.value(1)
  21.     time.sleep_us(10)
  22.     trig.value(0)
  23.  
  24.     # 等待回响信号
  25.     while echo.value() == 0:
  26.         pass
  27.     t1 = time.ticks_us()
  28.  
  29.     while echo.value() == 1:
  30.         pass
  31.     t2 = time.ticks_us()
  32.  
  33.     # 计算距离（单位：厘米）
  34.     duration = t2 - t1
  35.     distance = duration * 0.034 / 2
  36.     return distance
  37.  
  38.  
  39. while True:
  40.     distance = measure_distance()
  41.     print("Distance: %.2f cm" % distance)
  42.     time.sleep(1)

屏幕：直接使用串口屏，简单的要si,不要十分复杂的代码，你会发串口就可以用。

压缩：我们使用的是电动推杆，用arduino uno 控制 通过监听串口判断是不是可回收垃圾，然后启动

项目地址，求求了点个stars把

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号