• 机器人制作开源方案 | 智能快递付件机器人

    一、作品简介

    作者：贺沅、聂开发、王兴文、石宇航、盛余庆
    单位：黑龙江科技大学
    指导老师：邵文冕、苑鹏涛

    1. 项目背景

    受新冠疫情的影响，大学校园内都采取封闭式管理来降低传染的风险，导致学生不能外出，学校工作人员不能入校。通过封闭式的管理以此来尽最大可能保证学生在当前新冠传染和大规模人群被感染的情况下的安全，在此种情况下出现了取件困难、取件效率低、快递堆积在驿站等诸多快递服务问题，严重时也导致了快递无法进校。同时也严重提升了在校学生们的感染风险，严重影响了同学们的日常生活需要。

    疫情下快递堆积

           为了解决在校快递取件的问题，我们设计了一种由行走机构、抓取机构、控制系统和视觉系统组成的校园智能无人快递小车，以实现”无接触“式、消毒式快递配送，解决快递取件效率低的问题，减小了人力和物力，使得快递处理简单高效快捷，在快递的最后一站充分降低学生拿快递时新冠病毒感染风险，同时避免了校外人员入校传播病毒的风险。

    2. 项目进展

    2.1技术路线

    技术流程图

           如上图所示，我们所设计的快递附件机器人由机器人本体与被检测物（货物）组成。其总体流程如下：机器人通过一部分检测模块识别货物所在位置；将该信息反馈于快递附件机器人的控制板模块，控制板模块则命令驱动模块驱动，行走模块按照指定路线进行运动，等待抓取模块完成操作，抓取操作完成后控制模块驱动小车的行走模块进行下一步运动。

    2.2设计路线

    2.3项目创新点

    2.3.1结构部分
           采用了连杆机构，其运动副一般均为低副。低副两运动副元素为面接触，压强较小，可承受较大的载荷；可以方便地用来达到增力、扩大行程和实现远距离传动的优势，可方便机械臂抓取高层快递，我们采用中型球型件代替普通连杆使传动更稳定，且具有各部件之间不易松动的特点；采用齿轮传动结构，通过6个齿轮进行传动能保证稳定传动的同时具有准确的传动比，可以实现平行轴、相交轴、交错轴等空间任意两轴间传动的优点。

    中型球型件

    齿轮传动

    2.3.2运动部分
           运动部分通过四个直流马达支架将四个直流马达固定并配合四个轮胎组成运动机构，采用差速法控制小车转向，采用循迹进行路线规划，使用pwm进行调速，具有速度快的特点，且采用提取取件码第一位数字的方式，判断快递架位置和小车取完快递从后门出发，具有高效、快捷的优点，减少了空间的占用和取件的时间。

    2.3.3视觉部分
           采用了图像畸变矫正处理、轮廓提取算法和神经网络模型训练，解决了图像显示不清晰，识别率不够高问题的同时，实现了在不同光照条件下快递编号的识别，且有较高的准确率。

    3. 项目总结

           为了解决受新冠疫情影响、学校封闭式管理、学生不能外出取件、快递取件难、快递在快递站堆积的问题，我们设计了一种由行走机构、抓取机构、控制系统和视觉系统组成的校园智能无人快递小车，以实现”无接触“式、消毒式快递配送，这样避免了校外人员入校传播病毒的潜在风险，由智能快递付件机器人帮忙取校外快递，仅需对小车和快递进行消毒处理，简化了消毒流程，减少了人力、物力的开销，方便快捷了学生生活，减少了快递长时间不取退回的现象。

    二、功能介绍

    1. 产品结构图

           智能快递付件机器人由行走机构、控制模块、抓取机构和视觉模块组成，整个系统由两个12v锂电池分别对控制模块和视觉模块进行供电，以延长机器人的使用时间间隔。控制模块以Basra为主控，实现对机器人的行走、控制、抓取、视觉等过程的控制。机器人搭载了无线蓝牙和语音识别模块，在实现了蓝牙远程操控的同时也能够完成操作参数的动态调整等操作；行走机构采用探索者套件中的轮胎与联轴器相互配合，由直流减速电机驱动，在电机转动下控制小车行走。通过循迹进行路线规划；抓取机构采用连杆机构控制机械爪，对快递进行抓取；视觉模块采用Edge impulse对数字模型进行神经网络训练来实现快递编号的识别，并与下位机实现通信。

    整体结构图

    2. 主要功能

           ① 可自主抵达相应的快递架
           ② 可对所需要取的快递进行识别
           ③ 可实现远程操作与抓取参数调整
           ④ 可实现识别与抓取时的状况监控

    3. 结构介绍

           本作品总体结构由探索者套件拼装，分为主板平面、运动机构、机械臂、抓取结构、载物台、电源仓。

    3.1主板平面

           使用四个7*11孔平板和两块5*7孔平板构成的搭载主体平台，作为承载机械臂和载物台、连接运动机构主体，同时放置开发板和传感器等其他元器件。

    3.2运动机构

           通过四个直流马达支架将四个直流马达固定并配合四个轮胎组成运动机构，采用差速法控制小车转向。

    3.3机械臂

           使用4个输出支架和两个双足连杆搭建机械臂在主板平面上的支座，使用四个大舵机支架连接大舵机，机械臂的底盘舵机装上大舵机输出头后与大臂的舵机支架连接，再将两个大舵机U型支架反向连接作为机械臂大臂，一端连接大臂舵机一端连接小臂舵机。

    机械臂小臂

    机械臂大臂

           ① 机械臂小臂：由与抓取机构连接的舵机和舵机架构成，另一端连接大舵机U型支架，可实现正转70°，反转55°，可小范围调整抓取机构抓取角度。
           ② 机械臂大臂：由两个大舵机U型支架反向连接形成，正转110°反转70°，调整抓取结构置前置后，置前时抓取，置后时放置。
           ③ 机械臂底盘：由支座和舵机支架构成，可使机械手左右转动，调整抓取机构在水平方向上的位置。

    3.4抓取结构

           抓取结构的运动采用了齿轮传动结构和连杆结构，使用六个30齿齿轮两两叠加构成三个双层齿轮、使用5×7 孔平板作为机械爪零件主板，四个机械手指和四个机械手40mm驱动、两个3×5 折弯、中型球型件构成，滑动零件连接处使用轴套连接，以便抓取机构活动顺畅，且不易松动。抓机构自由度在0-55，如下图所示：

    机械爪

           ① 连杆结构：由中型球型件和大舵机输出头组成，将舵机产生的扭力，通过连杆传到齿轮上使齿轮转动，并且由于使用的连杆是弧形，中间不会因为触碰到零件主板而导致活动不顺畅。
           ② 传动结构：传动结构通过三组齿轮啮合将扭力均匀施加到两侧与齿轮连接的机械手40mm驱动上，带动机械手指，使机械手实现张合功能。

    3.5载物台

           使用一块7×11 孔平板、四块3×5 折弯、和两个大轮组成的载物平台，每个圆板为一个载物平台，每次可装载两件物品，如下图所示，载物台下方留有一定的空腔，作为电池仓，用于放置电源，在一定程度上节约了空间且载物台抬高可减少机械臂运行路程，使机械臂方便、快速放置快递，提高了运行效率。

    载物台与电池仓

    4. 电控部分

    4.1控制板的选择

           在开发板上我们选择Basra，Basra是一款基于Arduino开源方案设计的一款开发板，Basra的处理器核心是ATmega328，同时具有14路数字输入/输出口（其中6路可作为PWM输出），6路模拟输入，一个16MHz晶体振荡器，一个USB口，一个电源插座，一个ICSPheader和一个复位按钮。主CPU采用AVRATMEGA328型控制芯片，支持C语言编程方式。该系统的硬件电路包括：电源电路、串口通信电路、MCU基本电路、烧写接口、显示模块、AD/DA转换模块、输入模块、IIC存储模块等其他电路模块电路。控制板尺寸不超过60*60mm，便于安装。CPU硬件软件全部开放，除能完成对小车控制外，还能使用本实验板完成单片机所有基础实验。供电范围宽泛，支持5v~9v的电压，干电池或锂电池都适用。控制板含3A6V的稳压芯片，可为舵机提供6v额定电压。

    开发板

    4.2传感器的选择

           灰度传感器又称黑标传感器，可以帮助进行黑线的跟踪，可以识别白色背景中的黑色区域，或悬崖边缘。寻线信号可以提供稳定的输出信号，使寻线更准确更稳定。有效距离在0.7cm~3cm之间。
           工作电压：4.7～5.5V，
           工作电流：1.2mA。
           ① 固定孔，便于用螺丝将模块固定于机器人上；
           ② 四芯输入线接口，连接四芯输入线；
           ③ 黑标/白标传感器元件，用于检测黑线/白线信号。

    灰度传感器

    4.3语音模块

           语音处理技术是下一代多模式交互的人机界面设计中的核心技术之一。随着消费类电子产品中对于高性能、高稳健性的语音接口需求的快速增加，嵌入式语音处理技术快速发展。
           根据市场对嵌入式语音识别系统的需求，探索者推出了新的语音识别模块。该模块采用了基于helios-adsp新一代中大词汇语音识别协处理方案的语音识别专用芯片HBR740，非特定人语音识别技术可对用户的语音进行识别，支持中文音素识别，可任意指定中文识别词条(小于8个汉字)，单次识别可支持1000条以上的语音命令，安静环境下，标准普通话，识别率大于95%，可自动检测环境噪声，噪声环境下也能保证较好的识别率。

    4.4电动机的选择

           我们经过讨论确定选用轮式驱动，但是考虑到只是为了完成自主行走功能，实验也无需越障爬坡，所以我们选择双轴直流电机作为与轮子配合的驱动电机。

    电机实物图

           除了驱动机器人需要引用电机，检测功能也会需要电机。由于舵机的可控性强，可以在工作范围内精确控制电机的转动角度，而快递机器人的主要工作就是“识别快递、精确定位、作出处理”，所以舵机能够为智能快递付件机器人的工作提供极大的便利。四个舵机使得机器人有了四个自由度，工作范围由线性转变为面性，大大提高了机器人的工作效率。

    5. 视觉部分

    5.1 训练神经网络模型

    通过对大量的图像收集，在Edge Impulse进行图像分类、统一贴标签和训练对应的数据集，以此完成在识别过程中的识别不稳定以及减少错误信息的传递，多次调整图片训练数据集来提高匹配准确率。

    数据采集图样

    上传数据集

    训练模型效果显示

    训练准确度显示

    5.2 灰度转化（轮廓提取）以及畸变图像处理   

    ① 灰度转化
           通过灰度变换来使图像对比度扩展，图像清晰，特征明显，有选择的突出图像感兴趣的特征或者去抑制图像中不需要的特征，进而更加有效的改变图像的直方图分布，使得像素的分布更加均匀，从而提高图像识别精度。

    处理图像部分程序

    灰度数字处理图

           以12数字为例，1代表通道第一层，2代表第二个（从左到右）。先进行整体分开显示，再进行判断快递所在的位置，来传回下位机具体的信息返回值。为了提升识别的准确值，在与训练模型匹配时，再去使用轮廓提取的方法，提取出数字的形状。
    ② 轮廓提取算法
           使用闭运算的方法，即梯度=膨胀-腐蚀，得到图像的轮廓外形，通过使用findcontour ()函数，对灰度图处理过后的图像，找取边界点的坐标，存储到contours参数中，运用drawcontours绘制轮廓线。
    下面是findcontour函数的六个参数值：

    轮廓点信息特征

    ③ 畸变矫正处理
           在测试识别时出现了识别精度低，图像信息获取不全，识别效率低等问题，为此我们采用图像畸变矫正处理，以提高识别精度和效率。
           畸变矫正处理是像差的一种，在人们的感官上看原本直线变成了曲线，但是图像的信息不会丢失，调用openmv官方库中的库函数进行图像的处理。对镜头进行了畸变矫正，以去除镜头滤波造成的图像鱼眼效果。

    矫正效果演示前后

    5.3 取件抓取视觉流程图

    三、程序代码

    1. 示例程序

    1.1上位机程序
    ① data_collection.py

    1. import sensor, lcd
    2.  
    3. from Maix import GPIO
    4.  
    5. from fpioa_manager import fm
    6.  
    7. from board import board_info
    8.  
    9. import os, sys
    10.  
    11. import time
    12.  
    13. import image
    14.  
    15. import KPU as kpu
    16.  
    17. sensor.reset()
    18.  
    19. sensor.set_pixformat(sensor.RGB565)
    20.  
    21. sensor.set_framesize(sensor.QVGA)
    22.  
    23. set_windowing = (224,224)
    24.  
    25. sensor.set_windowing(set_windowing)
    26.  
    27. sensor.set_hmirror(0)
    28.  
    29. sensor.run(1)
    30.  
    31. #####Other####
    32.  
    33. deinit_flag = False     #用于在拍照的时候将yolo模型卸载，等到循环重新开始时再加载，减少内存消耗
    34.  
    35. ##############
    36.  
    37. #### lcd config ####
    38.  
    39. lcd.init(type=1, freq=15000000)
    40.  
    41. lcd.rotation(2)
    42.  
    43. #### boot key ####
    44.  
    45. boot_pin = 16
    46.  
    47. fm.register(boot_pin, fm.fpioa.GPIOHS0)
    48.  
    49. key = GPIO(GPIO.GPIOHS0, GPIO.PULL_UP)
    50.  
    51. ##############################
    52.  
    53. ######KPU#######
    54.  
    55. task = kpu.load("/sd/number.kmodel")
    56.  
    57. f=open("num_anchors.txt","r")       #修改锚点处
    58.  
    59. anchor_txt=f.read()
    60.  
    61. L=[]
    62.  
    63. for i in anchor_txt.split(","):      #直接读出来的i是str类型
    64.  
    65.     L.append(float(i))
    66.  
    67. anchor=tuple(L)
    68.  
    69. f.close()
    70.  
    71. a = kpu.init_yolo2(task, 0.6, 0.3, 5, anchor)
    72.  
    73. f=open("num_labels.txt","r")        #修改锚点处
    74.  
    75. labels_txt=f.read()
    76.  
    77. labels = labels_txt.split(",")
    78.  
    79. f.close()
    80.  
    81. ##################
    82.  
    83. #### main ####
    84.  
    85. def capture_main(key):
    86.  
    87.     global deinit_flag,anchor,task
    88.  
    89.     def draw_string(img, x, y, text, color, scale, bg=None , full_w = False):
    90.  
    91.         if bg:
    92.  
    93.             if full_w:
    94.  
    95.                 full_w = img.width()
    96.  
    97.             else:
    98.  
    99.                 full_w = len(text)*8*scale+4
    100.  
    101.             img.draw_rectangle(x-2,y-2, full_w, 16*scale, fill=True, color=bg)
    102.  
    103.         img = img.draw_string(x, y, text, color=color,scale=scale)
    104.  
    105.         return img
    106.  
    107.     def del_all_images():
    108.  
    109.         os.chdir("/sd")
    110.  
    111.         images_dir = "cap_images"
    112.  
    113.         if images_dir in os.listdir():
    114.  
    115.             os.chdir(images_dir)
    116.  
    117.             types = os.listdir()
    118.  
    119.             for t in types:
    120.  
    121.                 os.chdir(t)
    122.  
    123.                 files = os.listdir()
    124.  
    125.                 for f in files:
    126.  
    127.                     os.remove(f)
    128.  
    129.                 os.chdir("..")
    130.  
    131.                 os.rmdir(t)
    132.  
    133.             os.chdir("..")
    134.  
    135.             os.rmdir(images_dir)
    136.  
    137.     # del_all_images()
    138.  
    139.     os.chdir("/sd")
    140.  
    141.     dirs = os.listdir()
    142.  
    143.     images_dir = "cap_images"   #cap_images_1
    144.  
    145.     last_dir = 0
    146.  
    147.     for d in dirs:   #把每个已经存在的以cap_images开头的目录遍历一遍得到本次拍照的总目录序号
    148.  
    149.         if d.startswith(images_dir):
    150.  
    151.             if len(d) > 11:
    152.  
    153.                 n = int(d[11:])
    154.  
    155.                 if n > last_dir:
    156.  
    157.                     last_dir = n
    158.  
    159.     '''
    161.     这一段的作用是每次上电都重新创建一个新的最大文件夹
    163.     '''
    164.  
    165.     #images_dir = "{}_{}".format(images_dir, last_dir+1)
    166.  
    167.     #print("save to ", images_dir)
    168.  
    169.     #if images_dir in os.listdir():
    170.  
    171.         ##print("please del cap_images dir")
    172.  
    173.         #img = image.Image()
    174.  
    175.         #img = draw_string(img, 2, 200, "please del cap_images dir", color=lcd.WHITE,scale=1, bg=lcd.RED)
    176.  
    177.         #lcd.display(img)
    178.  
    179.         #sys.exit(1)
    180.  
    181.     #os.mkdir(images_dir)
    182.  
    183.     '''
    185.     这一段的作用是每次上电只有手动才重新创建一个新的最大文件夹,默认是从已经创建的编号最大的文件夹开始
    187.     '''
    188.  
    189.     images_dir = "{}_{}".format(images_dir, last_dir)
    190.  
    191.     if not images_dir in os.listdir():
    192.  
    193.         os.mkdir(images_dir)
    194.  
    195.     '''
    197.     开机检测第二级目录的起始位置
    199.     '''
    200.  
    201.     os.chdir("/sd/{}".format(images_dir))
    202.  
    203.     dirs = os.listdir()
    204.  
    205.     last_type = 0
    206.  
    207.     for d in dirs:   #把每个已经存在的以cap_images开头的目录遍历一遍得到本次拍照的总目录序号
    208.  
    209.         n = int(d[0:])
    210.  
    211.         if n > last_type:
    212.  
    213.             last_type = n
    214.  
    215.     if not str(last_type) in os.listdir():   #不存在要重新创建
    216.  
    217.         os.chdir("/sd")
    218.  
    219.         os.mkdir("{}/{}".format(images_dir, str(last_type)))
    220.  
    221.     '''
    223.     开机检测第三级目录的起始位置
    225.     '''
    226.  
    227.     os.chdir("/sd/{}/{}".format(images_dir,last_type))
    228.  
    229.     dirs = os.listdir()
    230.  
    231.     last_image = -1
    232.  
    233.     for d in dirs:   #把每个已经存在的以cap_images开头的目录遍历一遍得到本次拍照的总目录序号
    234.  
    235.         n = int(d[len(str(last_type))+1:][:-4]) #去除.jpg
    236.  
    237.         if n > last_image:
    238.  
    239.             last_image = n
    240.  
    241.     os.chdir("/sd")
    242.  
    243.     last_cap_time = 0           #用于记录按键松手前按下时候的系统时间
    244.  
    245.     last_btn_status = 1         #用于松手检测
    246.  
    247.     save_dir = last_type        #change type 第二级目录,默认跟上次开机目录一样
    248.  
    249.     save_count = last_image + 1 #保存的第几张图片
    250.  
    251.     while(True):
    252.  
    253.         if deinit_flag:
    254.  
    255.             task = kpu.load("/sd/number.kmodel")
    256.  
    257.             a = kpu.init_yolo2(task, 0.6, 0.3, 5, anchor)
    258.  
    259.             deinit_flag = False
    260.  
    261.         img0 = sensor.snapshot()
    262.  
    263.         code = kpu.run_yolo2(task, img0)
    264.  
    265.         if code:
    266.  
    267.             for i in code:
    268.  
    269.                 a=img0.draw_rectangle(i.rect(),(0,255,0),2)
    270.  
    271.                 lcd.draw_string(i.x()+45, i.y()-5, labels[i.classid()]+" "+'%.2f'%i.value(), lcd.WHITE,lcd.GREEN)
    272.  
    273.                 b=str(labels[i.classid()])
    274.  
    275.                 b.replace(" ","")
    276.  
    277.         if set_windowing:
    278.  
    279.             img = image.Image()
    280.  
    281.             img = img.draw_image(img0, (img.width() - set_windowing[0])//2, img.height() - set_windowing[1]) #//2取整
    282.  
    283.         else:
    284.  
    285.             img = img0.copy()
    286.  
    287.         if key.value() == 0:
    288.  
    289.             time.sleep_ms(30)
    290.  
    291.             if key.value() == 0 and (last_btn_status == 1) and (time.ticks_ms() - last_cap_time > 500):
    292.  
    293.                 last_btn_status = 0
    294.  
    295.                 last_cap_time = time.ticks_ms()
    296.  
    297.             else:
    298.  
    299.                 #2秒内直接拍照，四秒内提示切换数字种类，6秒内提示切换总目录，8秒后切换总目录
    300.  
    301.                 if time.ticks_ms() - last_cap_time > 4000 and time.ticks_ms() - last_cap_time <6000:
    302.  
    303.                     img = draw_string(img, 2, 200, "release to change type", color=lcd.WHITE,scale=1, bg=lcd.RED)
    304.  
    305.                 elif time.ticks_ms() - last_cap_time > 8000:
    306.  
    307.                     img = draw_string(img, 2, 200, "release to change images directory", color=lcd.WHITE,scale=1, bg=lcd.RED)
    308.  
    309.                 elif time.ticks_ms() - last_cap_time <= 8000 and time.ticks_ms() - last_cap_time >6000:
    310.  
    311.                     img = draw_string(img, 2, 200, "release to change type", color=lcd.WHITE,scale=1, bg=lcd.RED)
    312.  
    313.                     img = draw_string(img, 2, 160, "keep push to images directory", color=lcd.WHITE,scale=1, bg=lcd.RED)
    314.  
    315.                 elif time.ticks_ms() - last_cap_time <= 4000:
    316.  
    317.                     img = draw_string(img, 2, 200, "release to change type", color=lcd.WHITE,scale=1, bg=lcd.RED)
    318.  
    319.                     if time.ticks_ms() - last_cap_time > 2000:
    320.  
    321.                         img = draw_string(img, 2, 160, "keep push to change type", color=lcd.WHITE,scale=1, bg=lcd.RED)
    322.  
    323.         else:
    324.  
    325.             time.sleep_ms(30)
    326.  
    327.             if key.value() == 1 and (last_btn_status == 0):
    328.  
    329.                 a = kpu.deinit(task)
    330.  
    331.                 del task
    332.  
    333.                 deinit_flag = True
    334.  
    335.                 if time.ticks_ms() - last_cap_time >= 4000 and time.ticks_ms() - last_cap_time < 8000:
    336.  
    337.                     img = draw_string(img, 2, 200, "change object type", color=lcd.WHITE,scale=1, bg=lcd.RED)
    338.  
    339.                     lcd.display(img)
    340.  
    341.                     time.sleep_ms(1000)
    342.  
    343.                     save_dir += 1
    344.  
    345.                     save_count = 0
    346.  
    347.                     dir_name = "{}/{}".format(images_dir, save_dir)
    348.  
    349.                     os.mkdir(dir_name)
    350.  
    351.                 elif time.ticks_ms() - last_cap_time >= 8000:
    352.  
    353.                     img = draw_string(img, 2, 200, "change images directory", color=lcd.WHITE,scale=1, bg=lcd.RED)
    354.  
    355.                     lcd.display(img)
    356.  
    357.                     time.sleep_ms(1000)
    358.  
    359.                     last_dir += 1
    360.  
    361.                     save_dir = 0
    362.  
    363.                     save_count = 0
    364.  
    365.                     images_dir = "{}_{}".format('cap_images', last_dir)
    366.  
    367.                     os.mkdir(images_dir)
    368.  
    369.                     print("save to ", images_dir)
    370.  
    371.                     dir_name = "{}/{}".format(images_dir, save_dir)
    372.  
    373.                     os.mkdir(dir_name)
    374.  
    375.                 else:
    376.  
    377.                     draw_string(img, 2, 200, "capture image {}".format(save_count), color=lcd.WHITE,scale=1, bg=lcd.RED)
    378.  
    379.                     lcd.display(img)
    380.  
    381.                     f_name = "{}/{}/{}.jpg".format(images_dir, save_dir, str(save_dir)+'_'+str(save_count))
    382.  
    383.                     img0.save(f_name, quality=95)   #报错ENOENT表示路径不存在
    384.  
    385.                     save_count += 1
    386.  
    387.                 last_btn_status = 1
    388.  
    389.         img = draw_string(img, 2, 0, "will save to {}/{}/{}.jpg".format(images_dir, save_dir, str(save_dir)+'_'+str(save_count)), color=lcd.WHITE,scale=1, bg=lcd.RED, full_w=True)
    390.  
    391.         lcd.display(img)
    392.  
    393.         del img
    394.  
    395.         del img0
    396.  
    397. def main():
    398.  
    399.     try:
    400.  
    401.         capture_main(key)
    402.  
    403.     except Exception as e:
    404.  
    405.         print("error:", e)
    406.  
    407.         import uio
    408.  
    409.         s = uio.StringIO()
    410.  
    411.         sys.print_exception(e, s)
    412.  
    413.         s = s.getvalue()
    414.  
    415.         img = image.Image()
    416.  
    417.         img.draw_string(0, 0, s)
    418.  
    419.         lcd.display(img)
    420.  
    421. main()

    ② shijue.py

    1. import sensor
    2.  
    3. import image
    4.  
    5. import lcd
    6.  
    7. import KPU as kpu
    8.  
    9. lcd.init()
    10.  
    11. sensor.reset()
    12.  
    13. sensor.set_pixformat(sensor.RGB565)
    14.  
    15. sensor.set_framesize(sensor.QVGA)
    16.  
    17. sensor.set_windowing((224, 224))
    18.  
    19. sensor.set_hmirror(0)
    20.  
    21. sensor.run(1)
    22.  
    23. task = kpu.load(0x300000)
    24.  
    25. anchor=[]   #放你的标签
    26.  
    27. labels = [] #放anchor
    28.  
    29. a = kpu.init_yolo2(task, 0.6, 0.3, 5, anchor)
    30.  
    31. while(True):
    32.  
    33.     img = sensor.snapshot()
    34.  
    35.     code = kpu.run_yolo2(task, img)
    36.  
    37.     if code:
    38.  
    39.         for i in code:
    40.  
    41.             a=img.draw_rectangle(i.rect(),(0,255,0),2)
    42.  
    43.             a = lcd.display(img)
    44.  
    45.             for i in code:
    46.  
    47.                 lcd.draw_string(i.x()+45, i.y()-5, labels[i.classid()]+" "+'%.2f'%i.value(), lcd.WHITE,lcd.GREEN)
    48.  
    49.     else:
    50.  
    51.         a = lcd.display(img)
    52.  
    53. a = kpu.deinit(task)

    1.2下位机程序
    ① jixiebi.ino

    1. #include<Servo.h>//使用servo库
    2.  
    3. Servo base,fArm,rArm,claw;//创建4个servo对象
    4.  
    5. //base(底座舵机11)fArm(第三关节3)rArm(第二关节12)claw(爪4)
    6.  
    7. #include <SoftwareSerial.h>
    8.  
    9. //实例化软串口，设置虚拟输入输出串口。
    10.  
    11. SoftwareSerial BT(2, 3); // 设置数字引脚2是arduino的RX端,3是TX端
    12.  
    13.                            
    14.  
    15. VoiceRecognition Voice;//声明一个语音识别对象
    16.  
    17. #define Led 8 //定义LED控制引脚
    18.  
    19.                        
    20.  
    21. #define pi 3.1415926
    22.  
    23. void dateProcessing();
    24.  
    25. void armDataCmd(char serialCmd);//实现机械臂在openmv指示下工作
    26.  
    27. void armLanYaCmd(char serialCmd);
    28.  
    29. void servoCmd(char serialCmd,int toPos);//电机旋转功能函数
    30.  
    31. void vel_segmentation(int fromPos,int toPos,Servo arm_servo);
    32.  
    33. void reportStatus();//电机状态信息控制函数
    34.  
    35. void Arminit();
    36.  
    37. void GrabSth();
    38.  
    39. //建立4个int型变量存储当前电机角度值，设定初始值
    40.  
    41. int basePos=70;
    42.  
    43. int rArmPos=90;
    44.  
    45. int fArmPos=30;
    46.  
    47. int clawPos=45;
    48.  
    49. int data2dArray[4][5] = {   //建立二维数组用以控制四台舵机
    50.  
    51.   {0,   45,   90,   135,   180},
    52.  
    53.   {45,   90,   135,   90,   45},
    54.  
    55.   {135, 90,   45,   90,   135},
    56.  
    57.   {180, 135,   90,   45,   0}
    58.  
    59. };
    60.  
    61. //存储电机极限值
    62.  
    63. const int PROGMEM baseMin=0;
    64.  
    65. const int PROGMEM baseMax=180;
    66.  
    67. const int PROGMEM rArmMin=0;//留一定裕度空间
    68.  
    69. const int PROGMEM rArmMax=180;//留一定裕度空间
    70.  
    71. const int PROGMEM fArmMin=0;
    72.  
    73. const int PROGMEM fArmMax=270;
    74.  
    75. const int PROGMEM clawMin=0;
    76.  
    77. const int PROGMEM clawMax=54;
    78.  
    79. const int PROGMEM Dtime = 15;//机械臂运动延迟时间，通过改变该值来控制机械臂运动速度
    80.  
    81.                //机械臂运动角速度为：π*1000/(180*Dtime) rad/s
    82.  
    83. bool mode = 0;//mode = 1:指令模式；mode = 0:蓝牙模式
    84.  
    85. const int PROGMEM moveStep = 5;//按下按键，舵机的位移量
    86.  
    87. void serialEvent()
    88.  
    89. {
    90.  
    91. while (Serial.available ()) {
    92.  
    93. [char inChar = (char)Serial.read();
    94.  
    95. shuju += inChar;
    96.  
    97. if (inChar == (' n')
    98.  
    99. {
    100.  
    101. [stringComplete = true;
    102.  
    103. }
    104.  
    105.   }
    106.  
    107.     }
    108.  
    109. void yuyin();
    110.  
    111. {
    112.  
    113.   switch(Voice.read()) //判断识别
    114.  
    115. {
    116.  
    117. case 0: //若是指令“kai deng”
    118.  
    119. digitalWrite(Led,HIGH); //点亮LED
    120.  
    121. break;
    122.  
    123. case 1: //若是指令“guan deng”
    124.  
    125. digitalWrite(Led,LOW);//熄灭LED
    126.  
    127. break;
    128.  
    129. default:
    130.  
    131. break;
    132.  
    133. }
    134.  
    135.   }
    136.  
    137. void setup() {
    138.  
    139.   // put your setup code here, to run once:
    140.  
    141.   Serial.begin(9600);     //设置arduino的串口波特率与蓝牙模块的默认值相同为9600
    142.  
    143.   BT.begin(9600);         //设置虚拟输入输出串口波特率与蓝牙模块的默认值相同为9600
    144.  
    145.   Serial.println("HELLO"); //如果连接成功，在电脑串口显示HELLO，在蓝牙串口显示hello
    146.  
    147.   BT.println("hello");
    148.  
    149.  
    150.  
    151. pinMode(Led,OUTPUT); //初始化LED引脚为输出模式
    152.  
    153. digitalWrite(Led,LOW); //LED引脚低电平
    154.  
    155. Voice.init(); //初始化VoiceRecognition模块
    156.  
    157. Voice.addCommand("kai deng",0); //添加指令，参数（指令内容，指令标签（可重复））
    158.  
    159. Voice.addCommand("qidongixiebi",0);
    160.  
    161. Voice.addCommand("guan deng",1); //添加指令，参数（指令内容，指令标签（可重复））
    162.  
    163. Voice.addCommand("tingzhi",1);
    164.  
    165. Voice.start();//开始识别
    166.  
    167.   base.attach(12);
    168.  
    169.   delay(200);
    170.  
    171.   rArm.attach(9);
    172.  
    173.   delay(200);
    174.  
    175.   fArm.attach(5);
    176.  
    177.   delay(200);
    178.  
    179.   claw.attach(6);
    180.  
    181.   delay(200);
    182.  
    183. // Serial.begin(9600);
    184.  
    185.   dateProcessing();
    186.  
    187.   base.write(90);
    188.  
    189.   delay(10);
    190.  
    191.   fArm.write(140);
    192.  
    193.   delay(10);
    194.  
    195.   rArm.write(90);
    196.  
    197.   delay(10);
    198.  
    199.   claw.write(30);
    200.  
    201.   delay(10);
    202.  
    203. }
    204.  
    205. void loop() {
    206.  
    207.   // put your main code here, to run repeatedly:
    208.  
    209.  
    210.  
    211.   if(Serial.available()>0){    //判断串口缓冲区是否有数值
    212.  
    213.     char serialCmd = Serial.read(); //将Arduino串口输入的字符赋给serialCmd
    214.  
    215.     Serial.println(serialCmd);      //在串口监视器打印出输入的字符serialCmd
    216.  
    217.     BT.println(serialCmd);          //蓝牙模块的串口（在手机屏幕上显示）打印出电脑输入的字符serialCmd
    218.  
    219.   }
    220.  
    221.   //蓝牙模块有数据输入，就显示在电脑上
    222.  
    223.   if(BT.available()>0){
    224.  
    225.     int ch = BT.read();   //读取蓝牙模块获得的数据
    226.  
    227.     Serial.println(ch);
    228.  
    229.   }
    230.  
    231.   if(Serial.available()>0){
    232.  
    233.     char serialCmd=Serial.read();//read函数为按字节读取，要注意!
    234.  
    235.     delay(10);
    236.  
    237.     if(mode == 1){
    238.  
    239.       armDataCmd(serialCmd);//openmv控制
    240.  
    241.     }
    242.  
    243.     else{
    244.  
    245.       armLanYaCmd(serialCmd);//蓝牙控制机械臂
    246.  
    247.     }
    248.  
    249.   }
    250.  
    251. }
    252.  
    253. void dateProcessing(){//数据处理
    254.  
    255.  
    256.  
    257. }
    258.  
    259. void armDataCmd(char serialCmd){//实现机械臂在openmv指令下工作
    260.  
    261.   if(serialCmd == 'b' || serialCmd == 'c' || serialCmd == 'f' || serialCmd == 'r'){
    262.  
    263.     Serial.print("serialCmd = ");
    264.  
    265.     Serial.print(serialCmd);
    266.  
    267.     int servoData = Serial.parseInt();//读取指令中的电机转角
    268.  
    269.     servoCmd(serialCmd,servoData);
    270.  
    271.   }
    272.  
    273.   else{
    274.  
    275.   {//x的位置
    276.  
    277. int X location;
    278.  
    279. int Y location;//Y的位置
    280.  
    281. //Y的位置
    282.  
    283. int B location;string X str;
    284.  
    285. String Y str;
    286.  
    287. x location = foundstr('X');
    288.  
    289. Y location = foundstr('Y');
    290.  
    291. x str=shujuduan(X location+1，Y location); //x到y的位置X
    292.  
    293. location = foundstr('Y');
    294.  
    295. B location = foundstr('B');
    296.  
    297. Y str=shujuduan(Y location+1，B location); //Y到B的位置
    298.  
    299. Centerx-x str.toInt();//转成可以用的整型
    300.  
    301. CenterY=Y str.toInt();
    302.  
    303. Serial.print("Centerx:");
    304.  
    305. Serial.print(Centerx);
    306.  
    307. Serial.print("Centery: ");
    308.  
    309. Serial.printIn(Centery);
    310.  
    311. for (j1 = 0; j1 < 180; j1++)
    312.  
    313. j1 *= RAD2ANG;
    315. j3 = acos(pow(a, 2) + pow(b, 2) + pow(Ll, 2) - pow(L2, 2) - pow(L3, 2) - 2 * a*L1*sin(1) - 2 * b*L1*cos(j1)) / (2 * L2*L3);
    316.  
    317. //if (abs(ANG2RAD(j3)) >= 135) [ j1 = ANG2RAD(j1); continue; }
    318.  
    319. m = L2 * sin(j1) + L3 * sin(j1)*cos(j3) + L3 * cos(j1)*sin(j3);
    320.  
    321. n = L2 * cos(j1) + L3 * cos (j1)*cos(j3) - L3 * sin(j1)*sin(j3);
    322.  
    323. t = a - Ll *sin(jl);
    324.  
    325. p = pow(pow(n,2) + pow(m,2)，0.5);
    326.  
    327. q = asin(m / p);
    328.  
    329. j2 = asin(t / p) - q;
    330.  
    331. x1 = (Ll * sin(j1) + L2 * sin(jl + j2) + L3 * sin(jl + j2 + j3))*cos(j0);
    332.  
    333. y1 =(Ll *sin(jl) + L2 *sin(jl + j2) + L3 * sin(jl + j2 + j3))*sin(jo);
    334.  
    335. zl = Ll * cos(j1) + L2 * cos(jl + j2) + L3 * cos(jl + j2 + j3);
    336.  
    337. j1 = ANG2RAD(j1) ;
    338.  
    339. j2 = ANG2RAD(j2);
    340.  
    341. j3 = ANG2RAD(j3) ;
    342.  
    343. if (xl<(x + 0.1) && x1 >(x - 0.1) && yly + 0.1) && yl >ly - 0.1) && zl(z + 0.1) && 21 >(2 - 0.1))
    344.  
    345. if(j0>0&&j0<180&&j1>0&&j1<180&&j2>0&&j2<180&&j3>0&&j3<180)
    346.  
    347. {Serial.println(ANG2RAD(j0));
    348.  
    349. Serial.println( j1);
    350.  
    351. Serial.println( j2);
    352.  
    353. Serial.println( j3);
    354.  
    355. Serial.println( x1);
    356.  
    357. Serial.println( yl);
    358.  
    359. Serial.println( z1);
    360.  
    361. for (int i = 0; i <= 4; i++){  
    362.  
    363.     base.write(data2dArray[0][i]);   //base舵机对应data2dArray数组中第1“行”元素
    364.  
    365.     delay(100);                     
    366.  
    367.     rArm.write(data2dArray[1][i]);   //rArm舵机对应data2dArray数组中第2“行”元素
    368.  
    369.     delay(100);                     
    370.  
    371.     fArm.write(data2dArray[2][i]);   //fArm舵机对应data2dArray数组中第3“行”元素
    372.  
    373.     delay(100);                     
    374.  
    375.     claw.write(data2dArray[3][i]);   //claw舵机对应data2dArray数组中第4“行”元素
    376.  
    377.     delay(500);                     
    378.  
    379.   }
    380.  
    381.   for (int i = 4; i >= 0; i--){
    382.  
    383.     base.write(data2dArray[0][i]);   //base舵机对应data2dArray数组中第1“行”元素
    384.  
    385.     delay(100);                     
    386.  
    387.     rArm.write(data2dArray[1][i]);   //rArm舵机对应data2dArray数组中第2“行”元素
    388.  
    389.     delay(100);                     
    390.  
    391.     fArm.write(data2dArray[2][i]);   //fArm舵机对应data2dArray数组中第3“行”元素
    392.  
    393.     delay(100);                     
    394.  
    395.     claw.write(data2dArray[3][i]);   //claw舵机对应data2dArray数组中第4“行”元素
    396.  
    397.     delay(500);  
    398.  
    399.   }
    400.  
    401. }
    402.  
    403.     }
    404.  
    405.   }
    406.  
    407. void armLanYaCmd(char serialCmd){//实现机械臂在蓝牙模式下工作
    408.  
    409.   int baseJoyPos;
    410.  
    411.   int rArmJoyPos;
    412.  
    413.   int fArmJoyPos;
    414.  
    415.   int clawJoyPos;
    416.  
    417.   switch(serialCmd){
    418.  
    419.     case 'a'://小臂正转
    420.  
    421.       fArmJoyPos = fArm.read() - moveStep;
    422.  
    423.       servoCmd('f',fArmJoyPos);delay(10);
    424.  
    425.       break;
    426.  
    427.     case 's'://底盘左转
    428.  
    429.       baseJoyPos = base.read() + moveStep;
    430.  
    431.       servoCmd('b',baseJoyPos);delay(10);
    432.  
    433.       break;
    434.  
    435.     case 'd'://大臂正转
    436.  
    437.       rArmJoyPos = rArm.read() + moveStep;
    438.  
    439.       servoCmd('r',rArmJoyPos);delay(10);
    440.  
    441.       break;
    442.  
    443.     case 'w'://钳子闭合
    444.  
    445.     clawJoyPos = claw.read() - moveStep;
    446.  
    447.       servoCmd('c',clawJoyPos);delay(10);
    448.  
    449.       break;
    450.  
    451.     case '4'://小臂反转
    452.  
    453.       fArmJoyPos = fArm.read() + moveStep;
    454.  
    455.       servoCmd('f',fArmJoyPos);delay(10);
    456.  
    457.       break;
    458.  
    459.     case '5'://底盘右转
    460.  
    461.       baseJoyPos = base.read() - moveStep;
    462.  
    463.       servoCmd('b',baseJoyPos);delay(10);
    464.  
    465.       break;
    466.  
    467.     case '6'://大臂反转
    468.  
    469.       rArmJoyPos = rArm.read() - moveStep;
    470.  
    471.       servoCmd('r',rArmJoyPos);delay(10);
    472.  
    473.       break;
    474.  
    475.     case '8'://钳子张开
    476.  
    477.       clawJoyPos = claw.read() + moveStep;
    478.  
    479.       servoCmd('c',clawJoyPos);delay(10);
    480.  
    481.       break;
    482.  
    483.     case 'i': //输出电机状态信息
    484.  
    485.         reportStatus();delay(10);
    486.  
    487.         break;
    488.  
    489.     case 'l'://电机位置初始化
    490.  
    491.       Arminit();delay(10);
    492.  
    493.       break;
    494.  
    495.     case 'g'://抓取功能
    496.  
    497.       GrabSth();delay(10);
    498.  
    499.       break;
    500.  
    501.     case 'm':
    502.  
    503.       Serial.println("meArm has been changed into Instruction Mode");
    504.  
    505.       mode = 1;
    506.  
    507.       break;
    508.  
    509.     default:
    510.  
    511.       Serial.println();
    512.  
    513.       Serial.println("【Error】出现错误!");
    514.  
    515.       Serial.println();
    516.  
    517.       break;
    518.  
    519.   }
    520.  
    521. }
    522.  
    523. void servoCmd(char serialCmd,int toPos){//电机旋转功能函数
    524.  
    525.   Serial.println("");
    526.  
    527.   Serial.print("Command:Servo ");
    528.  
    529.   Serial.print(serialCmd);
    530.  
    531.   Serial.print(" to ");
    532.  
    533.   Serial.print(toPos);
    534.  
    535.   Serial.print(" at servoVelcity value ");
    536.  
    537.   Serial.print(1000*pi/(180*Dtime));
    538.  
    539.   Serial.println(" rad/s.");
    540.  
    541.  
    542.  
    543.   int fromPos;//起始位置
    544.  
    545.  
    546.  
    547.   switch(serialCmd){
    548.  
    549.     case 'b':
    550.  
    551.       if(toPos >= baseMin && toPos <= baseMax){
    552.  
    553.         fromPos = base.read();
    554.  
    555.         vel_segmentation(fromPos,toPos,base);
    556.  
    557.         basePos = toPos;
    558.  
    559.         Serial.print("Set base servo position value: ");
    560.  
    561.         Serial.println(toPos);
    562.  
    563.         Serial.println();
    564.  
    565.         break;
    566.  
    567.       }
    568.  
    569.       else{
    570.  
    571.         Serial.println("【Warning】Base Servo Position Value Out Of Limit!");
    572.  
    573.         Serial.println();
    574.  
    575.         return;
    576.  
    577.  
    578. }
    579.  
    580.       break;
    581.  
    582.     case 'r':
    583.  
    584.       if(toPos >= rArmMin && toPos <= rArmMax){
    585.  
    586.         fromPos = rArm.read();
    587.  
    588.         vel_segmentation(fromPos,toPos,rArm);
    589.  
    590.         rArmPos = toPos;
    591.  
    592.         Serial.print("Set rArm servo position value: ");
    593.  
    594.         Serial.println(toPos);
    595.  
    596.         Serial.println();
    597.  
    598.        
    599.  
    600.         break;
    601.  
    602.       }
    603.  
    604.       else{
    605.  
    606.         Serial.println("【Warning】Base Servo Value Position Out Of Limit!");
    607.  
    608.         Serial.println();
    609.  
    610.         return;
    611.  
    612.       }
    613.  
    614.       break;
    615.  
    616.     case 'f':
    617.  
    618.       if(toPos >= fArmMin && toPos <= fArmMax){
    619.  
    620.         fromPos = fArm.read();
    621.  
    622.         vel_segmentation(fromPos,toPos,fArm);
    623.  
    624.         fArmPos = toPos;
    625.  
    626.         Serial.print("Set fArm servo position value: ");
    627.  
    628.         Serial.println(toPos);
    629.  
    630.         Serial.println();
    631.  
    632.         break;
    633.  
    634.       }
    635.  
    636.       else{
    637.  
    638.         Serial.println();
    639.  
    640.         Serial.println("【Warning】Base Servo Value Position Out Of Limit!");
    641.  
    642.         Serial.println();
    643.  
    644.         return;
    645.  
    646.       }
    647.  
    648.       break;
    649.  
    650.     case 'c':
    651.  
    652.       if(toPos >= clawMin && toPos <= clawMax){
    653.  
    654.         fromPos = claw.read();
    655.  
    656.         vel_segmentation(fromPos,toPos,claw);
    657.  
    658.         clawPos = toPos;
    659.  
    660.         Serial.print("Set claw servo position value: ");
    661.  
    662.         Serial.println(toPos);
    663.  
    664.         Serial.println();
    665.  
    666.         break;
    667.  
    668.       }
    669.  
    670.       else{
    671.  
    672.         Serial.println("【Warning】Base Servo Position Value Out Of Limit!");
    673.  
    674.         Serial.println();
    675.  
    676.         return;
    677.  
    678.       }
    679.  
    680.       break;
    681.  
    682.   }
    683.  
    684. }
    685.  
    686. void vel_segmentation(int fromPos,int toPos,Servo arm_servo){//速度控制函数
    687.  
    688.   //该函数通过对位置的细分和延时实现电机速度控制
    689.  
    690.   //这样的控制平均角速度大约为：1°/15ms = 1.16 rad/s
    691.  
    692.   if(fromPos < toPos){
    693.  
    694.     for(int i=fromPos;i<=toPos;i++){
    695.  
    696.         arm_servo.write(i);
    697.  
    698.         delay(Dtime);
    699.  
    700.       }
    701.  
    702.   }
    703.  
    704.   else{
    705.  
    706.     for(int i=fromPos;i>=toPos;i--){
    707.  
    708.         arm_servo.write(i);
    709.  
    710.         delay(Dtime);
    711.  
    712.       }
    713.  
    714.   }
    715.  
    716. }
    717.  
    718. void reportStatus(){//电机状态信息控制函数
    719.  
    720.   Serial.println();
    721.  
    722.   Serial.println("---Robot-Arm Status Report---");
    723.  
    724.   Serial.print("Base Position: ");
    725.  
    726.   Serial.println(basePos);
    727.  
    728.   Serial.print("Claw Position: ");
    729.  
    730.   Serial.println(clawPos);
    731.  
    732.   Serial.print("rArm Position: ");
    733.  
    734.   Serial.println(rArmPos);
    735.  
    736.   Serial.print("fArm Position: ");
    737.  
    738.   Serial.println(fArmPos);
    739.  
    740.   Serial.println("-----------------------------");
    741.  
    742.   Serial.println("Motor Model:Micro Servo 9g-SG90");
    743.  
    744.   Serial.println("Motor size: 23×12.2×29mm");
    745.  
    746.   Serial.println("Work temperature:0-60℃");
    747.  
    748.   Serial.println("Rated voltage: 5V");
    749.  
    750.   Serial.println("Rated torque: 0.176 N·m");
    751.  
    752.   Serial.println("-----------------------------");
    753.  
    754. }
    755.  
    756. void Arminit(){//电机初始化函数
    757.  
    758.   //将电机恢复初始状态
    759.  
    760.   char ServoArr[4] = {'c','f','r','b'};
    761.  
    762.   for(int i=0;i<4;i++){
    763.  
    764.     servoCmd(ServoArr[i],90);
    765.  
    766.   }
    767.  
    768.   delay(200);
    769.  
    770.   Serial.println("meArm has been initized!");
    771.  
    772.   Serial.println();
    773.  
    774. }
    775.  
    776. void GrabSth(){//抓取函数
    777.  
    778.   //抓取功能
    779.  
    780.   int GrabSt[4][2] = {
    781.  
    782.     {'b',135},
    783.  
    784.     {'r',150},
    785.  
    786.     {'f',30},
    787.  
    788.     {'c',40}
    789.  
    790.   };
    791.  
    792.   for(int i=0;i<4;i++){
    793.  
    794.     servoCmd(GrabSt[i][0],GrabSt[i][1]);
    795.  
    796.   }
    797.  
    798. }

    ② sketch_nov05a.ino

    1. char serial_data;// 将从串口读入的消息存储在该变量中
    2.  
    3. #define STOP      0
    4.  
    5. #define RUN       1
    6.  
    7. #define BACK      2
    8.  
    9. #define LEFT      3
    10.  
    11. #define RIGHT     4
    12.  
    13. VoiceRecognition Voice;//声明一个语音识别对象
    14.  
    15. int a1 = 6;//左电机1
    16.  
    17. int a2 = 7;//左电机2
    18.  
    19. int b1 = 8;//右电机1
    20.  
    21. int b2 = 9;//右电机2
    22.  
    23. int sensorLeft = 3; //从车头方向的最右边开始排序 探测器
    24.  
    25. int sensorRight = 2;
    26.  
    27. int ENA = 10;//L298N使能端左
    28.  
    29. int ENB = 11;//L298N使能端右
    30.  
    31. int SL;//左边灰度传感器
    32.  
    33. int SR;//右边灰度传感器
    34.  
    35. void setup()
    36.  
    37. {
    38.  
    39.   Serial.begin(9600);
    40.  
    41.   pinMode(a1, OUTPUT);
    42.  
    43.   pinMode(a2, OUTPUT);
    44.  
    45.   pinMode(b1, OUTPUT);
    46.  
    47.   pinMode(b2, OUTPUT);
    48.  
    49.   pinMode(ENA, OUTPUT);
    50.  
    51.   pinMode(ENB, OUTPUT);
    52.  
    53.   pinMode(sensorLeft, INPUT);//寻迹模块引脚初始化
    54.  
    55.   pinMode(sensorRight, INPUT);
    56.  
    57.   Voice.init();//初始化VoiceRecognition模块
    58.  
    59.   Voice.addCommand("lu kou yi",1);//添加指令，参数（指定内容，指令标签）
    60.  
    61.   Voice.addCommand("lu kou er",2);//添加指令，参数（指定内容，指令标签）
    62.  
    63.   Voice.addCommand("lu kou san",3);//添加指令，参数（指定内容，指令标签）
    64.  
    65.   Voice.addCommand("lu kou si",4);//添加指令，参数（指定内容，指令标签）
    66.  
    67.   Voice.start();
    68.  
    69.  
    70.  
    71. }
    72.  
    73. void loop()
    74.  
    75. {
    76.  
    77. digitalWrite(ENA,HIGH);
    78.  
    79. digitalWrite(ENB,HIGH);
    80.  
    81. SL = digitalRead(sensorLeft);
    82.  
    83. SR = digitalRead(sensorRight);
    84.  
    85. switch(Voice.read())//判断识别
    86.  
    87. {
    88.  
    89.   case 1://指令是 lu kou yi
    90.  
    91.   crossing1();
    92.  
    93.   delay(3000);
    94.  
    95.     WORK(STOP);//停下通过openmv识别
    96.  
    97.     delay(5000);
    98.  
    99.     WORK(RUN);//识别完毕继续前进
    100.  
    101.     delay(2000);//前进两秒后停止
    102.  
    103.     WORK(STOP);
    104.  
    105.     serial_data = Serial.read();//当抓取完成后发送一个w
    106.  
    107.     if( serial_data == 'w' )
    108.  
    109.    {
    110.  
    111.      WORK(BACK);
    112.  
    113.    }
    114.  
    115.    if(SR == HIGH & SL == HIGH)//再次识别到黑线时右转
    116.  
    117.    {
    118.  
    119.     WORK(RIGHT);
    120.  
    121.     }
    122.  
    123.     tracing();//继续前进
    124.  
    125.     break;
    126.  
    127.    
    128.  
    129.     case 2://指令是 lu lou er
    130.  
    131.     crossing2();
    132.  
    133.     delay(3000);
    134.  
    135.     WORK(STOP);//停下通过openmv识别
    136.  
    137.     delay(5000);
    138.  
    139.     WORK(RUN);//识别完毕继续前进
    140.  
    141.     delay(2000);//前进两秒后停止准备抓取
    142.  
    143.     WORK(STOP);
    144.  
    145.     serial_data = Serial.read();//当抓取完成后发送一个w
    146.  
    147.     if( serial_data == 'w' )
    148.  
    149.    {
    150.  
    151.      WORK(BACK);
    152.  
    153.    }
    154.  
    155.    if(SR == HIGH & SL == HIGH)//再次识别到黑线时左转
    156.  
    157.    {
    158.  
    159.     WORK(LEFT);
    160.  
    161.     }
    162.  
    163.     tracing();//继续前进
    164.  
    165.     break;
    166.  
    167.     case 3:
    168.  
    169.     tracing();
    170.  
    171.     if(SR == HIGH & SL == HIGH)
    172.  
    173.     {
    174.  
    175.       crossing3();
    176.  
    177.       }
    178.  
    179.     delay(3000);
    180.  
    181.     WORK(STOP);//停下通过openmv识别
    182.  
    183.     delay(5000);
    184.  
    185.     WORK(RUN);//识别完毕继续前进
    186.  
    187.     delay(2000);//前进两秒后停止准备抓取
    188.  
    189.     WORK(STOP);
    190.  
    191.     serial_data = Serial.read();//当抓取完成后发送一个w
    192.  
    193.     if( serial_data == 'w' )
    194.  
    195.    {
    196.  
    197.      WORK(BACK);
    198.  
    199.    }
    200.  
    201.    if(SR == HIGH & SL == HIGH)//再次识别到黑线时右转
    202.  
    203.    {
    204.  
    205.     WORK(RIHGT);
    206.  
    207.     }
    208.  
    209.     tracing();//继续前进
    210.  
    211.     break;
    212.  
    213.      case 4:
    214.  
    215.      tracing();
    216.  
    217.     if(SR == HIGH & SL == HIGH)
    218.  
    219.     {
    220.  
    221.       crossing4();
    222.  
    223.       }
    224.  
    225.     delay(3000);
    226.  
    227.     WORK(STOP);//停下通过openmv识别
    228.  
    229.     delay(5000);
    230.  
    231.     WORK(RUN);//识别完毕继续前进
    232.  
    233.     delay(2000);//前进两秒后停止准备抓取
    234.  
    235.     WORK(STOP);
    236.  
    237.     serial_data = Serial.read();//当抓取完成后发送一个w
    238.  
    239.     if( serial_data == 'w' )
    240.  
    241.    {
    242.  
    243.      WORK(BACK);
    244.  
    245.    }
    246.  
    247.    if(SR == HIGH & SL == HIGH)//再次识别到黑线时左转
    248.  
    249.    {
    250.  
    251.     WORK(LEFT);
    252.  
    253.     }
    254.  
    255.     tracing();//继续前进
    256.  
    257.   }
    258.  
    259. }
    260.  
    261. void WORK(int cmd)
    262.  
    263. {
    264.  
    265.   switch(cmd)
    266.  
    267.   {
    268.  
    269.     case RUN:
    270.  
    271.       Serial.println("RUN"); //输出状态
    272.  
    273.       digitalWrite(a1, HIGH);
    274.  
    275.       digitalWrite(a2, LOW);
    276.  
    277.       analogWrite(leftPWM, 200);
    278.  
    279.       digitalWrite(b1, HIGH);
    280.  
    281.       digitalWrite(b2, LOW);
    282.  
    283.       analogWrite(rightPWM, 200);
    284.  
    285.       break;
    286.  
    287.      case BACK:
    288.  
    289.       Serial.println("BACK"); //输出状态
    290.  
    291.       digitalWrite(a1, LOW);
    292.  
    293.       digitalWrite(a2, HIGH);
    294.  
    295.       analogWrite(leftPWM, 200);
    296.  
    297.       digitalWrite(b1, LOW);
    298.  
    299.       digitalWrite(b2, HIGH);
    300.  
    301.       analogWrite(rightPWM, 200);
    302.  
    303.       break;
    304.  
    305.      case LEFT:
    306.  
    307.       Serial.println("TURN   LEFT"); //输出状态
    308.  
    309.       digitalWrite(a1, HIGH);
    310.  
    311.       digitalWrite(a2, LOW);
    312.  
    313.       analogWrite(leftPWM, 100);
    314.  
    315.       digitalWrite(b1, LOW);
    316.  
    317.       digitalWrite(b2, HIGH);
    318.  
    319.       analogWrite(rightPWM, 200);
    320.  
    321.       break;
    322.  
    323.      case RIGHT:
    324.  
    325.       Serial.println("TURN   RIGHT"); //输出状态
    326.  
    327.       digitalWrite(a1, LOW);
    328.  
    329.       analogWrite(leftPWM,200);
    330.  
    331.       digitalWrite(a2, HIGH);
    332.  
    333.       digitalWrite(b1, HIGH);
    334.  
    335.       digitalWrite(b2, LOW);
    336.  
    337.        analogWrite(rightPWM,100);
    338.  
    339.       break;
    340.  
    341.      default:
    342.  
    343.       Serial.println("STOP"); //输出状态
    344.  
    345.       digitalWrite(a1, LOW);
    346.  
    347.       digitalWrite(a2, LOW);
    348.  
    349.       digitalWrite(b1, LOW);
    350.  
    351.       digitalWrite(b2, LOW);
    352.  
    353.   }
    354.  
    355. }
    356.  
    357. void crossing1()//路口1函数
    358.  
    359. {
    360.  
    361.   if (SL == LOW && SR == LOW)//左右两边都没有检测到黑线
    362.  
    363.   {
    364.  
    365.     WORK(RUN);
    366.  
    367.     }
    368.  
    369.   if (SL == HIGH & SR == LOW)//左侧检测到黑线
    370.  
    371.   {
    372.  
    373.     WORK(LEFT);
    374.  
    375.     }
    376.  
    377.   if (SR == HIGH & SL == LOW)//右侧检测到黑线
    378.  
    379. {
    380.  
    381.   WORK(RIGHT);
    382.  
    383.   }
    384.  
    385.   if (SR == HIGH & SL == HIGH)//左右两边都检测到黑线
    386.  
    387.   {
    388.  
    389.     WORK(RIGHT);
    390.  
    391.     }
    392.  
    393.   }
    394.  
    395. void crossing2()//路口2函数
    396.  
    397. {
    398.  
    399.   if (SL == LOW && SR == LOW)//左右两边都没有检测到黑线
    400.  
    401.   {
    402.  
    403.     WORK(RUN);
    404.  
    405.     }
    406.  
    407.   if (SL == HIGH & SR == LOW)//左侧检测到黑线
    408.  
    409.   {
    410.  
    411.     WORK(LEFT);
    412.  
    413.     }
    414.  
    415.   if (SR == HIGH & SL == LOW)//右侧检测到黑线
    416.  
    417. {
    418.  
    419.   WORK(RIGHT);
    420.  
    421.   }
    422.  
    423.   if (SR == HIGH & SL == HIGH)//左右两边都检测到黑线
    424.  
    425.   {
    426.  
    427.     WORK(LEFT);
    428.  
    429.     }
    430.  
    431.   }
    432.  
    433. void crossing3()//路口3函数
    434.  
    435. {
    436.  
    437.   if (SL == LOW && SR == LOW)//左右两边都没有检测到黑线
    438.  
    439.   {
    440.  
    441.     WORK(RUN);
    442.  
    443.     }
    444.  
    445.   if (SL == HIGH & SR == LOW)//左侧检测到黑线
    446.  
    447.   {
    448.  
    449.     WORK(LEFT);
    450.  
    451.     }
    452.  
    453.   if (SR == HIGH & SL == LOW)//右侧检测到黑线
    454.  
    455. {
    456.  
    457.   WORK(RIGHT);
    458.  
    459.   }
    460.  
    461.   if (SR == HIGH & SL == HIGH)//左右两边都检测到黑线
    462.  
    463.   {
    464.  
    465.     WORK(LEFT);
    466.  
    467. void crossing4()//路口函数
    468.  
    469. {
    470.  
    471.   if (SL == LOW && SR == LOW)//左右两边都没有检测到黑线
    472.  
    473.   {
    474.  
    475.     WORK(RUN);
    476.  
    477.     }
    478.  
    479.   if (SL == HIGH & SR == LOW)//左侧检测到黑线
    480.  
    481.   {
    482.  
    483.     WORK(LEFT);
    484.  
    485.     }
    486.  
    487.   if (SR == HIGH & SL == LOW)//右侧检测到黑线
    488.  
    489. {
    490.  
    491.   WORK(RIGHT);
    492.  
    493.   }
    494.  
    495.   if (SR == HIGH & SL == HIGH)//左右两边都检测到黑线
    496.  
    497.   {
    498.  
    499.     WORK(RIGHT);
    500.  
    501.   void tracing()
    502.  
    503. {
    504.  
    505.     if (SL == LOW && SR == LOW)//左右两边都没有检测到黑线
    506.  
    507.   {
    508.  
    509.     WORK(RUN);
    510.  
    511.     }
    512.  
    513.   if (SL == HIGH & SR == LOW)//左侧检测到黑线
    514.  
    515.   {
    516.  
    517.     WORK(LEFT);
    518.  
    519.     }
    520.  
    521.   if (SR == HIGH & SL == LOW)//右侧检测到黑线
    522.  
    523. {
    524.  
    525.   WORK(RIGHT);
    526.  
    527.   }
    528.  
    529.   if (SR == HIGH & SL == HIGH)//左右两边都检测到黑线
    530.  
    531.   {
    532.  
    533.     WORK(RUN);
    534.  
    535.     }
    536.  
    537. }
    538.  
    539.

    更多详细资料请参考 【S021】智能快递付件机器人

  • 相关阅读:
    Ajax技术【Ajax技术详解、 Ajax 的使用、Ajax请求、 JSON详解、JACKSON 的使用 】(一)-全面详解（学习总结---从入门到深化）
    adb 获取当前界面元素
    prompt 综述
    使用bitnamiredis-sentinel部署Redis 哨兵模式
    Linux进程管理2
    前端面试题：基础理论整理（篇2）
    文件部署到服务器
    C#的类型转换
    【Linux】一
    在WPF应用程序集中添加新文件时，Page和Window有什么区别
  • 原文地址：https://blog.csdn.net/Robotway/article/details/134378017