机器人制作开源方案 | 桌面级机械臂--应用设计

机器谱

       本节内容将基于机器视觉带着大家进行应用实训。机器视觉是人工智能正在快速发展的一个分支，简单说来机器视觉就是用机器代替人眼来做测量和判断。机器视觉系统是通过机器视觉产品（即图像摄取装置，分CMOS和CCD两种）将被摄取目标转换成图像信号，传送给专用的图像处理系统，得到被摄目标的形态信息，根据像素分布和亮度、颜色等信息，转变成数字化信号；图像系统对这些信号进行各种运算来抽取目标的特征，进而根据判别的结果来控制现场的设备动作。
       机器视觉基础主要包含二维码识别、颜色识别等。
       机器视觉系统最基本的特点就是提高生产的灵活性和自动化程度，在一些不适于人工作业的危险工作环境或者人工视觉难以满足要求的场合，常用机器视觉来替代人工视觉。同时在大批量重复性工业生产过程中，用机器视觉检测方法可以大大提高生产的效率和自动化程度。下面我们将结合机器视觉基础，基于开源的机器人平台，进行桌面机械臂搬运、颜色追踪等应用开发。

1. 视觉二维码识别

       二维码的应用渗透到生活的方方面面，如手机购物、微信登录等，二维码常见的分类有矩阵式、堆叠式/行排式。具有代表性的矩阵式二维条码有Code One、Maxi Code、QR Code、 Data Matrix等；具有代表性的行排式二维条码有Code 16K、Code 49、PDF417等。
       二维码的使用分为：生成二维码、识别已生成的二维码。这里我们主要是识别已生成的二维码（矩阵式二维码）。

设计思路
       本实验主要是基于矩阵式二维码进行识别。QR码（Quick Response Code）是在正方形二维矩阵内通过黑白标识编码二进制位从而编码数据。

实现思路
       利用摄像头采集二维码信息，利用zbar库识别后把结果显示在屏幕上。

器材准备
       生成QR Code码（可以用在线编辑器生成）、摄像头。
       下面是为本实验准备的二维码：（当然大家也可以直接打开微信二维码进行识别）

操作步骤
第一步：连接电路。将摄像头与控制盒进行连接。

第二步：下载文末资料中的参考程序color_experiment_ws\src\qr_detection\scripts\QrCode_Detection.py：

1. #!/usr/bin/env python
   
2. 
   
3. #!coding=utf-8
   
4. 
   
5. #write by leo at 2018.04.26
   
6. 
   
7. #function:
   
8. 
   
9. #1, Get live_video from the webcam.
   
10. 
    
11. #2, With ROS publish Image_info (to yolo and so on).
    
12. 
    
13. #3, Convert directly, don't need to save pic at local.
    
14. 
    
15. # import the necessary packages
    
16. 
    
17. import simple_barcode_detection
    
18. 
    
19. import zbar
    
20. 
    
21. from PIL import Image
    
22. 
    
23. import rospy
    
24. 
    
25. from sensor_msgs.msg import Image as lll
    
26. 
    
27. import cv2
    
28. 
    
29. import numpy as np
    
30. 
    
31. from cv_bridge import CvBridge, CvBridgeError
    
32. 
    
33. import sys
    
34. 
    
35. import time
    
36. 
    
37. # create a reader
    
38. 
    
39. scanner = zbar.ImageScanner()
    
40. 
    
41. # configure the reader
    
42. 
    
43. scanner.parse_config('enable')
    
44. 
    
45. font=cv2.FONT_HERSHEY_SIMPLEX
    
46. 
    
47. camera=cv2.VideoCapture(0)
    
48. 
    
49. def webcamImagePub():
    
50. 
    
51.     # init ros_node
    
52. 
    
53.     rospy.init_node('webcam_puber', anonymous=True)
    
54. 
    
55.     img_pub = rospy.Publisher('webcam/image_raw', lll, queue_size=2)
    
56. 
    
57.     rate = rospy.Rate(20) # 5hz
    
58. 
    
59.     scaling_factor = 0.5
    
60. 
    
61.     bridge = CvBridge()
    
62. 
    
63.     if not camera.isOpened():
    
64. 
    
65.         sys.stdout.write("Webcam is not available!")
    
66. 
    
67.         return -1
    
68. 
    
69.     count = 0
    
70. 
    
71.     # loop until press 'esc' or 'q'
    
72. 
    
73.     while not rospy.is_shutdown():
    
74. 
    
75.         # get a frame and show
    
76. 
    
77. (ret, frame) = camera.read()
    
78. 
    
79. box = simple_barcode_detection.detect(frame)
    
80. 
    
81. if np.all(box != None):
    
82. 
    
83. min=np.min(box,axis=0)
    
84. 
    
85. max=np.max(box,axis=0)
    
86. 
    
87. roi=frame[min[1]-10:max[1]+10,min[0]-10:max[0]+10]
    
88. 
    
89. #print roi.shape
    
90. 
    
91. roi=cv2.cvtColor(roi,cv2.COLOR_BGR2RGB)
    
92. 
    
93. pil= Image.fromarray(frame).convert('L')
    
94. 
    
95. width, height = pil.size
    
96. 
    
97. raw = pil.tobytes()
    
98. 
    
99. zarimage = zbar.Image(width, height, 'Y800', raw)
    
100. 
     
101. scanner.scan(zarimage)
     
102. 
     
103. for symbol in zarimage:
     
104. 
     
105. print 'decoded', symbol.type, 'symbol', '"%s"' %symbol.data
     
106. 
     
107. cv2.drawContours(frame, [box], -1, (0, 255, 0), 2)
     
108. 
     
109. cv2.putText(frame,symbol.data,(20,100),font,1,(0,255,0),4)
     
110. 
     
111.         # resize the frame
     
112. 
     
113.         if ret:
     
114. 
     
115.             count = count + 1
     
116. 
     
117.         else:
     
118. 
     
119.             rospy.loginfo("Capturing image failed.")
     
120. 
     
121.         if count == 2:
     
122. 
     
123.             count = 0
     
124. 
     
125.             frame = cv2.resize(frame,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
     
126. 
     
127.             msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
     
128. 
     
129.             img_pub.publish(msg)
     
130. 
     
131. #            print '** start ***'
     
132. 
     
133.         rate.sleep()
     
134. 
     
135. if __name__ == '__main__':
     
136. 
     
137.     try:
     
138. 
     
139.         webcamImagePub()
     
140. 
     
141.     except rospy.ROSInterruptException:
     
142. 
     
143.         pass
     
144. 
     
145. #    except IndexError:
     
146. 
     
147. #pass
     
148. 
     
149. #    except VIDEOIOERROR:
     
150. 
     
151. #pass
     
152. 
     
153. #    except Unabletostopthestream:
     
154. 
     
155. #pass
     
156. 
     
157.     finally:
     
158. 
     
159. webcamImagePub()

复制代码

第三步：运行程序并查看效果。
打开终端，输入roslaunch qr_detection qr_detection_experiment.launch命令（见下图），等待程序的运行启动界面。

界面启动后，添加Image并设置其参数，设置成功后出现以下三幅图像画面。

图1

图2

图三

把QR code类型的二维码放置在摄像头下，稍后就会在界面上显示结果（如下图所示）。

2. 形状识别—识别圆形
实现思路
利用摄像头采集图片信息，识别圆形后显示出圆的中心坐标。

器材准备
主要用到：摄像头、红色和绿色两种圆形图（如下图所示）。

操作步骤
第一步：连接电路，将摄像头与主机进行连接。（温馨提示：做实验时，大家可以灵活的把摄像头放置在圆形图片上方，以便于采集图形信息）

第二步：下载文末资料中的参考程序color_experiment_ws\src\shape_detection\scripts\shape_detection_victory.py：

1. #!/usr/bin/env python
   
2. 
   
3. #!coding=utf-8
   
4. 
   
5. import rospy
   
6. 
   
7. from sensor_msgs.msg import Image
   
8. 
   
9. import cv2
   
10. 
    
11. from cv_bridge import CvBridge
    
12. 
    
13. import numpy as np
    
14. 
    
15. #red,green,blue[h,s,v]
    
16. 
    
17. lower_blue=np.array([50,143,146])
    
18. 
    
19. upper_blue=np.array([124,255,255])
    
20. 
    
21. lower_red=np.array([0,200,55])
    
22. 
    
23. upper_red=np.array([10,255,130])
    
24. 
    
25. lower_green=np.array([40,43,46])
    
26. 
    
27. upper_green=np.array([77,255,255])
    
28. 
    
29. Video = cv2.VideoCapture(0)
    
30. 
    
31. ret = Video.set(3, 640)   # 设置帧宽
    
32. 
    
33. ret = Video.set(4, 480)   # 设置帧高
    
34. 
    
35. font = cv2.FONT_HERSHEY_SIMPLEX   # 设置字体样式
    
36. 
    
37. kernel = np.ones((5, 5), np.uint8)   # 卷积核
    
38. 
    
39. def areaCal(contour):
    
40. 
    
41.     area = 0
    
42. 
    
43.     for i in range(len(contour)):
    
44. 
    
45.         area += cv2.contourArea(contour[i])
    
46. 
    
47.     return area
    
48. 
    
49. def talker():
    
50. 
    
51.      pub = rospy.Publisher('/tutorial/image', Image, queue_size=1)
    
52. 
    
53.      rospy.init_node('talker', anonymous=True)
    
54. 
    
55.      rate = rospy.Rate(30)
    
56. 
    
57.      bridge = CvBridge()
    
58. 
    
59.      #Video = cv2.VideoCapture(1)
    
60. 
    
61.      while not rospy.is_shutdown():
    
62. 
    
63.          if Video.isOpened() is True:
    
64. 
    
65.            ret, frame = Video.read()
    
66. 
    
67.            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)   # 转换为灰色通道
    
68. 
    
69.            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)   # 转换为HSV空间
    
70. 
    
71.            mask = cv2.inRange(hsv, lower_red, upper_red)   # 设定掩膜取值范围   [消除噪声]
    
72. 
    
73.            #mask = cv2.inRange(hsv, lower_green, upper_green)   # 设定掩膜取值范围 [消除噪声]
    
74. 
    
75.            opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)   # 形态学开运算 [消除噪声]
    
76. 
    
77.            bila = cv2.bilateralFilter(mask, 10, 200, 200)   # 双边滤波消除噪声 [消除噪声]
    
78. 
    
79.            edges = cv2.Canny(opening, 50, 100)   # 边缘识别 [消除噪声]
    
80. 
    
81.            mask_green = cv2.inRange(hsv,lower_green,upper_green)
    
82. 
    
83.            opening_green = cv2.morphologyEx(mask_green, cv2.MORPH_OPEN, kernel)
    
84. 
    
85.            bila_green = cv2.bilateralFilter(mask_green, 10, 200, 200)
    
86. 
    
87.            edges_green = cv2.Canny(opening_green, 50, 100)
    
88. 
    
89.            images,contourss,hierarchvs = cv2.findContours(edges_green,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    
90. 
    
91.            image,contours,hierarchv = cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    
92. 
    
93.            print "area_red=",areaCal(contours),"area_green=",areaCal(contourss)
    
94. 
    
95.            if(areaCal(contours)>50):
    
96. 
    
97.              #circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=20, maxRadius=500)
    
98. 
    
99.              circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=0, maxRadius=0)
    
100. 
     
101.              if circles is not None:   # 如果识别出圆
     
102. 
     
103.                #print "I found the red circle"
     
104. 
     
105.                for circle in circles[0]:
     
106. 
     
107.                  x_red=int(circle[0])
     
108. 
     
109.                  y_red=int(circle[1])
     
110. 
     
111.                  r_red=int(circle[2])
     
112. 
     
113.                  cv2.circle(frame, (x_red, y_red), r_red, (0, 0, 255), 3)   # 标记圆
     
114. 
     
115.                  cv2.circle(frame, (x_red, y_red), 3, (255, 255, 0), -1)   # 标记圆心
     
116. 
     
117.                  text = 'circle' + 'x:   '+str(x_red)+' y:   '+str(y_red)
     
118. 
     
119.                  cv2.putText(frame, text, (10, 30), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)   # 显示圆心位置
     
120. 
     
121.            if(areaCal(contourss)>1000):
     
122. 
     
123.              #circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=20, maxRadius=500)
     
124. 
     
125.              circles = cv2.HoughCircles(edges_green, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=20, minRadius=0, maxRadius=0)
     
126. 
     
127.              if circles is not None:   # 如果识别出圆
     
128. 
     
129.                #print "I found the green circle"
     
130. 
     
131.                for circle in circles[0]:
     
132. 
     
133.                  x_red=int(circle[0])
     
134. 
     
135.                  y_red=int(circle[1])
     
136. 
     
137.                  r_red=int(circle[2])
     
138. 
     
139.                  cv2.circle(frame, (x_red, y_red), r_red, (0, 0, 255), 3)   # 标记圆
     
140. 
     
141.                  cv2.circle(frame, (x_red, y_red), 3, (255, 255, 0), -1)   # 标记圆心
     
142. 
     
143.                  text = 'circle' + 'x:   '+str(x_red)+' y:   '+str(y_red)
     
144. 
     
145.                  cv2.putText(frame, text, (10, 60), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)   # 显示圆心位置
     
146. 
     
147. #cv2.drawContours(img,contours,-1,(0,0,255),3)
     
148. 
     
149.          cv2.waitKey(3)
     
150. 
     
151.          pub.publish(bridge.cv2_to_imgmsg(frame, "bgr8"))
     
152. 
     
153.          rate.sleep()
     
154. 
     
155. if __name__ == '__main__':
     
156. 
     
157.      try:
     
158. 
     
159.          talker()
     
160. 
     
161.      except rospy.ROSInterruptException:
     
162. 
     
163.          pass

复制代码

第三步：运行程序并查看效果。
打开终端，输入roslaunch shape_detection shape_detection_experiment.launch 命令（见下图）, 等待程序的运行启动界面。

界面启动后，添加Image并设置其参数，设置成功后出现以下三幅图像画面。

图一

图二

图三

       放置待识别的圆形图（请把物品放置在摄像头可以采集到的区域），然后就可以在界面上看到识别结果。下图是分别识别红色圆形、蓝色圆形，并显示识别出圆心的中心坐标x、y的值。

3. 颜色识别（红绿蓝）
实现思路
       摄像头采集红绿蓝的物品颜色后，利用开源视觉库进行识别，把结果显示在屏幕上。

颜色识别算法
RGB和HSV彩色模型

       数字图像处理通常采用RGB（红、绿、蓝）和HSV（色调、饱和度、亮度）两种彩色模型，RGB虽然表示比较至直观，但R、G、B数值和色彩三属性并没有直接关系，模型通道并不能很好的反映出物体具体的颜色信息，而HSV模型更符合我们描述和解释颜色的方式，使用HSV的彩色描述会更加直观。

RGB和HSV的区别：
①. RGB模型
       三维坐标：

RGB：三原色（Red, Green, Blue）
       原点到白色顶点的中轴线是灰度线，r、g、b三分量相等，强度可以由三分量的向量表示。
用RGB来理解色彩、深浅、明暗变化：
       色彩变化： 三个坐标轴RGB最大分量顶点与黄紫青YMC色顶点的连线
       深浅变化：RGB顶点和CMY顶点到原点和白色顶点的中轴线的距离
       明暗变化：中轴线的点的位置，到原点，就偏暗，到白色顶点就偏亮

②. HSV模型
       倒锥形模型：

这个模型就是按色彩、深浅、明暗来描述的。
H是色彩
S是深浅， S = 0时，只有灰度
V是明暗，表示色彩的明亮程度，但与光强无直接联系。

③. RGB与HSV的联系
      从上面的直观的理解，把RGB三维坐标的中轴线立起来，并扁化，就能形成HSV的锥形模型了。
      但V与强度无直接关系，因为它只选取了RGB的一个最大分量。而RGB则能反映光照强度（或灰度）的变化。
      v = max(r, g, b)
      由RGB到HSV的转换：

④.HSV色彩范围

操作步骤
第一步：连接电路。将摄像头与主机进行连接。

第二步：下载文末资料中的参考程序color_experiment_ws\src\color_detection\scripts\color_test_one.py：

1. #!/usr/bin/env python
   
2. 
   
3. #!coding=utf-8
   
4. 
   
5. #write by leo at 2018.04.26
   
6. 
   
7. #function:
   
8. 
   
9. #1, Get live_video from the webcam.
   
10. 
    
11. #2, With ROS publish Image_info (to yolo and so on).
    
12. 
    
13. #3, Convert directly, don't need to save pic at local.
    
14. 
    
15. import rospy
    
16. 
    
17. from sensor_msgs.msg import Image
    
18. 
    
19. import cv2
    
20. 
    
21. import numpy as np
    
22. 
    
23. from cv_bridge import CvBridge, CvBridgeError
    
24. 
    
25. import sys
    
26. 
    
27. import time
    
28. 
    
29. cap = cv2.VideoCapture(0)
    
30. 
    
31. #lower_blue=np.array([50,143,146])
    
32. 
    
33. #upper_blue=np.array([124,255,255])
    
34. 
    
35. lower_blue=np.array([40,143,146])
    
36. 
    
37. upper_blue=np.array([124,255,255])
    
38. 
    
39. lower_red=np.array([0,200,55])
    
40. 
    
41. upper_red=np.array([10,255,130])
    
42. 
    
43. lower_green=np.array([40,43,46])
    
44. 
    
45. upper_green=np.array([77,255,255])
    
46. 
    
47. font = cv2.FONT_HERSHEY_SIMPLEX
    
48. 
    
49. def areaCal(contour):
    
50. 
    
51.     area = 0
    
52. 
    
53.     for i in range(len(contour)):
    
54. 
    
55.         area += cv2.contourArea(contour[i])
    
56. 
    
57.     return area
    
58. 
    
59. def webcamImagePub():
    
60. 
    
61.     # init ros_node
    
62. 
    
63.     rospy.init_node('webcam_puber', anonymous=True)
    
64. 
    
65.     # queue_size should be small in order to make it 'real_time'
    
66. 
    
67.     # or the node will pub the past_frame
    
68. 
    
69.     img_pub = rospy.Publisher('webcam/image_raw', Image, queue_size=2)
    
70. 
    
71.     rate = rospy.Rate(20) # 5hz
    
72. 
    
73.     # define picture to_down' coefficient of ratio
    
74. 
    
75.     scaling_factor = 0.5
    
76. 
    
77.     # the 'CVBridge' is a python_class, must have a instance.
    
78. 
    
79.     # That means "cv2_to_imgmsg() must be called with CvBridge instance"
    
80. 
    
81.     bridge = CvBridge()
    
82. 
    
83.     if not cap.isOpened():
    
84. 
    
85.         sys.stdout.write("Webcam is not available!")
    
86. 
    
87.         return -1
    
88. 
    
89.     count = 0
    
90. 
    
91.     # loop until press 'esc' or 'q'
    
92. 
    
93.     while not rospy.is_shutdown():
    
94. 
    
95.         # get a frame and show
    
96. 
    
97.         ret, frame = cap.read()
    
98. 
    
99. #       cv2.imshow('Capture', frame)
    
100. 
     
101.         # change to hsv model
     
102. 
     
103.         hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
     
104. 
     
105.         #cv2.imshow("imageHSV",hsv)
     
106. 
     
107.         # get mask
     
108. 
     
109.         mask = cv2.inRange(hsv, lower_blue, upper_blue)
     
110. 
     
111. #       cv2.imshow('Mask', mask)
     
112. 
     
113.         # detect blue
     
114. 
     
115.         res = cv2.bitwise_and(frame, frame, mask=mask)
     
116. 
     
117. #        cv2.imshow('Result', res)
     
118. 
     
119. #       cv2.imshow('SOURCE', frame)
     
120. 
     
121.         image,contours,hierarchv = cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
     
122. 
     
123.         blue_area=areaCal(contours)
     
124. 
     
125.         hsvs = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
     
126. 
     
127.         masks = cv2.inRange(hsvs, lower_red, upper_red)
     
128. 
     
129.         ress = cv2.bitwise_and(frame, frame, mask=masks)
     
130. 
     
131.         images,contourss,hierarchvs = cv2.findContours(masks,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
     
132. 
     
133.         red_area=areaCal(contourss)
     
134. 
     
135.         hsvss = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
     
136. 
     
137.         maskss = cv2.inRange(hsvss, lower_green, upper_green)
     
138. 
     
139.         resss = cv2.bitwise_and(frame, frame, mask=maskss)
     
140. 
     
141.         imagess,contoursss,hierarchvss = cv2.findContours(maskss,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
     
142. 
     
143.         green_area=areaCal(contoursss)
     
144. 
     
145.         print "blue=",blue_area,"red=",red_area,"green=",green_area,"the color is blue"
     
146. 
     
147.         if(areaCal(contours)>300):
     
148. 
     
149.                 #print("the color is blue")
     
150. 
     
151.                 #print "blue=",blue_area,"red=",red_area,"green=",green_area,"the color is blue"
     
152. 
     
153.                 text = 'the color is blue'
     
154. 
     
155.                 cv2.putText(frame, text, (10, 30), font, 1, (255, 0, 0), 2, cv2.LINE_AA, 0)            
     
156. 
     
157.         else :
     
158. 
     
159.                 if(areaCal(contourss)>3500):
     
160. 
     
161.                         #print ("Thered",areaCal(contours))
     
162. 
     
163.                         #print "blue=",blue_area,"red=",red_area,"green=",green_area,"the color is blue red"
     
164. 
     
165.                         text = 'the color is red'
     
166. 
     
167.                         cv2.putText(frame, text, (10, 60), font, 1, (0, 0, 255), 2, cv2.LINE_AA, 0)                        
     
168. 
     
169.                 else:
     
170. 
     
171.                         if(areaCal(contoursss)>3500):
     
172. 
     
173.                                 #print "blue=",blue_area,"red=",red_area,"green=",green_area,"the color is blue green"
     
174. 
     
175.                                 text = 'the color is green'
     
176. 
     
177.                                 cv2.putText(frame, text, (10, 90), font, 1, (0, 255, 0), 2, cv2.LINE_AA, 0)                                 
     
178. 
     
179.                         else:
     
180. 
     
181.                                 qwer=0
     
182. 
     
183.         # resize the frame
     
184. 
     
185.         if ret:
     
186. 
     
187.             count = count + 1
     
188. 
     
189.         else:
     
190. 
     
191.             rospy.loginfo("Capturing image failed.")
     
192. 
     
193.         if count == 2:
     
194. 
     
195.             count = 0
     
196. 
     
197.             frame = cv2.resize(frame,None,fx=scaling_factor,fy=scaling_factor,interpolation=cv2.INTER_AREA)
     
198. 
     
199.             msg = bridge.cv2_to_imgmsg(frame, encoding="bgr8")
     
200. 
     
201.             img_pub.publish(msg)   
     
202. 
     
203.         rate.sleep()
     
204. 
     
205. if __name__ == '__main__':
     
206. 
     
207.     try:
     
208. 
     
209.         webcamImagePub()
     
210. 
     
211.     except rospy.ROSInterruptException:
     
212. 
     
213.         pass
     
214. 
     
215. #    except IndexError:
     
216. 
     
217. #   pass
     
218. 
     
219. #    except VIDEOIOERROR:
     
220. 
     
221. #   pass
     
222. 
     
223. #    except Unabletostopthestream:
     
224. 
     
225. #   pass
     
226. 
     
227.     finally:
     
228. 
     
229.         webcamImagePub()

复制代码

第三步：运行程序并查看效果。
打开终端，输入roslaunch color_detection color_detectioning.launch命令（见下图）, 等待程序的运行启动界面。

界面启动后，添加Image并设置其参数，设置成功后出现以下三幅图像画面。

图一

图二

图三

放置物品（请把物品放置在摄像头可以采集到的区域），然后摄像头开始识别颜色并在界面上显示识别结果。
下面以蓝色物品为例，当摄像头识别到蓝色物品后，在界面上显示结果（the color is blue）。

蓝色物块检测环境

检测么后返回的结果

大家也可以试着去放置红色、绿色物品（识别结果见下面两幅图）。

红色物块检测环境

检测后返回的结果

绿色物块检测环境

检测后返回的结果

4. 键盘控制运动
实现思路
       按下键盘上指定的键，实现底盘、大臂、小臂朝不同方向运动。
操作步骤
       第一步：下载文末资料中的参考程序color_experiment_ws\src\visual_recognition\arduino_program\keyboard_control_arm\keyboard_control_arm.ino：

1. /*
   
2. 
   
3. _______________________________________________________________________________________________________________________________________________________
   
4. 
   
5.   【实验功能】
   
6. 
   
7.                ros中键盘控制机械臂运动。
   
8. 
   
9.   【实验接线】
   
10. 
    
11.                按照实验教程接线即可。
    
12. 
    
13.   【实验思路】
    
14. 
    
15.                 上位机（树莓派）通过串口发布按键信息，下位机（Arduino）接收到信息后，进行简单数据处理，最后将处理后的数据
    
16. 
    
17.                  转换为机械臂相应的动作。
    
18. 
    
19.   【实验操作】
    
20. 
    
21.                 按照实验教程接线。将该程序下载到arduino开发板，接着启动上位机（树莓派）程序。完成后，按下键盘不同的按键，观察
    
22. 
    
23.                 机械臂动作。键盘指令包含：
    
24. 
    
25.                 u:控制转台左转       o:控制转台右转
    
26. 
    
27.                 j:控制大臂前伸       l:控制转台后缩
    
28. 
    
29.                 m:控制小臂上抬       >:控制小臂下降
    
30. 
    
31.   create ：2020.7.17   By Boris.yuan
    
32. 
    
33.   _________________________________________________________________________________________________________________________________________
    
34. 
    
35. */
    
36. 
    
37. //DUE控制版需要启用USE_USBON或USE_NATIVE_USB,UNO不需要
    
38. 
    
39. //#define USE_USBCON          //PAOGRAMMING PORT
    
40. 
    
41. //#define USE_NATIVE_USB      //NATIVE USB PORT
    
42. 
    
43. #define ActionDelayTimes 1500
    
44. 
    
45. //#include <SoftwareSerial.h>
    
46. 
    
47. #include <Servo.h>
    
48. 
    
49. #include <ros.h>
    
50. 
    
51. #include <ros/time.h>
    
52. 
    
53. #include <geometry_msgs/Vector3.h>
    
54. 
    
55. #define mySerial Serial1
    
56. 
    
57. ros::NodeHandle   nh;
    
58. 
    
59. void XYRun(double vx, double vy, double w);
    
60. 
    
61. void messageCb( const geometry_msgs::Vector3& vel_cmd)   {
    
62. 
    
63.   XYSetVel(vel_cmd.x, vel_cmd.y, vel_cmd.z);
    
64. 
    
65. }
    
66. 
    
67. ros::Subscriber<geometry_msgs::Vector3> vel_cmd_sub("vel_cmd", &messageCb );
    
68. 
    
69. geometry_msgs::Vector3 pose_message;
    
70. 
    
71. ros::Publisher pose_feedback_pub("pose_feedback", &pose_message);
    
72. 
    
73. geometry_msgs::Vector3 vel_message;
    
74. 
    
75. ros::Publisher vel_feedback_pub("vel_feedback", &vel_message);
    
76. 
    
77. int servo_port[4] = {10, 11, 12, 13};//x,y,z,a
    
78. 
    
79. float value_init[4] = {88, 88, 96, 86};//x,y,z,a
    
80. 
    
81. const int kMessagePubRate = 5;
    
82. 
    
83. unsigned long message_pub_time = 0;
    
84. 
    
85. const int kReadMotorDeltaT = 5;
    
86. 
    
87. unsigned long position_read_time = 0;
    
88. 
    
89. float current_x = 0, current_y = 0, current_a = 0;
    
90. 
    
91. float current_vx = 0, current_vy = 0, current_va = 0;
    
92. 
    
93. float sudu = 0.87;
    
94. 
    
95. void setup()
    
96. 
    
97. {
    
98. 
    
99.   delay(1000);
    
100. 
     
101.   mySerial.begin(115200);
     
102. 
     
103.   Serial.begin(57600);
     
104. 
     
105.   Bus_servo_angle_init(); delay(1500);
     
106. 
     
107.   nh.initNode();
     
108. 
     
109.   nh.subscribe(vel_cmd_sub);
     
110. 
     
111.   nh.advertise(pose_feedback_pub);
     
112. 
     
113.   nh.advertise(vel_feedback_pub);
     
114. 
     
115.   position_read_time = millis();
     
116. 
     
117.   message_pub_time = millis();
     
118. 
     
119. }
     
120. 
     
121. void loop()
     
122. 
     
123. {
     
124. 
     
125.   if (millis() > position_read_time)
     
126. 
     
127.   {
     
128. 
     
129.     XYread();
     
130. 
     
131.     position_read_time += kReadMotorDeltaT;
     
132. 
     
133.   }
     
134. 
     
135.   if (millis() > message_pub_time)
     
136. 
     
137.   {
     
138. 
     
139.     pose_message.x = current_x;
     
140. 
     
141.     pose_message.y = current_y;
     
142. 
     
143.     pose_message.z = current_a;
     
144. 
     
145.     vel_message.x = current_vx;
     
146. 
     
147.     vel_message.y = current_vy;
     
148. 
     
149.     vel_message.z = current_va;
     
150. 
     
151.     pose_feedback_pub.publish(&pose_message);
     
152. 
     
153.     vel_feedback_pub.publish(&vel_message);
     
154. 
     
155.     message_pub_time += 1000.0 / kMessagePubRate;
     
156. 
     
157.   }
     
158. 
     
159.   nh.spinOnce();
     
160. 
     
161. }

复制代码

第二步：打开终端,输入roslaunch visual_recognition keyboard_control_arm.launch 命令（见下图）, 等待程序的运行启动界面。

终端

第三步：尝试按下【u、o、j、l、m、.】观察运动，包括底盘左转、右转、大臂向前伸、大臂向后伸、小臂下降、小臂上升。（注意：字母均为小写；按键盘时，稍微有点间隔，给转动留时间）

键盘上字母	按下字母后对应操作
u	底盘左转
o	底盘右转
j	机械大臂向前伸
l	机械大臂向后伸
m	小臂下降
.	小臂上升

键盘命令及含义表

5. 颜色识别与搬运
实现思路
       摄像头识别不同颜色的物块后，机械爪开始抓取把其搬运到不同的区域。
操作步骤
第一步：连接电路（见下图）。

第二步：下载文末资料中的参考程序color_experiment_ws\src\color_sorting\arduino_program\arm_driver\arm_driver.ino：

1. /*
   
2. 
   
3. -----------------------------------------------------------------------------------------------------------------
   
4. 
   
5. 实验功能：【实现颜色分拣。】
   
6. 
   
7. 实验思路：【上位机(即树莓派)检测到颜色(红色、蓝色)，通过串口将发送不同颜色物体的字符串。下位机
   
8. 
   
9.             Arduino Mega2560接收到字符串后，执行相应的动作指令。本实验中，上位机检测到红色后，
   
10. 
    
11.             通过串口发送“reds”，当下位机Arduino接收到“reds”后，将红色物体向左边搬运。同理，
    
12. 
    
13.             上位机检测到蓝色后，串口发送“blues”，下位机接收到“blues”后，将物体搬运到机械臂的右侧。 】
    
14. 
    
15. 实验操作：【将该程序下载到Arduino开发板后，按照教程启动上位机程序，将红色或者蓝色物体置于机械臂指定
    
16. 
    
17.                 位置后，观察机械臂抓取不同颜色物体的动作是否与教程视频中相吻合。】
    
18. 
    
19. 实验接线（主要接线）：
    
20. 
    
21.             机械臂通信口-------------（机械臂）电控箱
    
22. 
    
23.             机械爪（舵机）---------------（执行器）电控箱
    
24. 
    
25.             其他线路按照教材图片连接。
    
26. 
    
27. Created 2020.7.16     By：Boris.yuan
    
28. 
    
29. -----------------------------------------------------------------------------------------------------------------
    
30. 
    
31. */
    
32. 
    
33. #include <Servo.h>
    
34. 
    
35. #include <stdio.h>
    
36. 
    
37. #include <string.h>
    
38. 
    
39. #define CTL_BAUDRATE 115200 //总线舵机波特率
    
40. 
    
41. #define SERIAL_PRINTLN Serial1
    
42. 
    
43. #define SerialBaudrate 57600
    
44. 
    
45. String receive_string = "";
    
46. 
    
47. int catch_red_numbers=0;
    
48. 
    
49. int catch_blue_numbers=0;
    
50. 
    
51. unsigned long old_time = millis();
    
52. 
    
53. unsigned long new_time = millis();
    
54. 
    
55. void setup() {
    
56. 
    
57.   // put your setup code here, to run once:
    
58. 
    
59.   delay(1100);
    
60. 
    
61.   Serial.begin(SerialBaudrate);
    
62. 
    
63.   SERIAL_PRINTLN.begin(CTL_BAUDRATE);
    
64. 
    
65.   Bus_servo_angle_init();delay(2000);
    
66. 
    
67. //   Arm_Catch_Red_Object();delay(1000);
    
68. 
    
69. //   Arm_Catch_Blue_Object();delay(1000);
    
70. 
    
71. }
    
72. 
    
73. void loop() {
    
74. 
    
75.   // put your main code here, to run repeatedly:
    
76. 
    
77.   while(Serial.available()>0)
    
78. 
    
79.   {
    
80. 
    
81.     new_time = millis();
    
82. 
    
83.     receive_string=Serial.readStringUntil('\n');
    
84. 
    
85.     if(receive_string=="reds")
    
86. 
    
87.     {
    
88. 
    
89.       catch_red_numbers++;
    
90. 
    
91.       new_time = millis();
    
92. 
    
93. //      if(catch_red_numbers == 1)
    
94. 
    
95. //      {
    
96. 
    
97. //        //old_time = millis();
    
98. 
    
99. //        receive_string="";
    
100. 
     
101. //        //Arm_Catch_Red_Object();
     
102. 
     
103. //      }
     
104. 
     
105. //      if(catch_red_numbers == 2)
     
106. 
     
107. //      {
     
108. 
     
109. //        //old_time = millis();
     
110. 
     
111. //        receive_string="";
     
112. 
     
113. //        //Arm_Catch_Red_Object();
     
114. 
     
115. //      }     
     
116. 
     
117.       if(catch_red_numbers == 1)
     
118. 
     
119.       {
     
120. 
     
121.         old_time = millis();receive_string="";
     
122. 
     
123.         Arm_Catch_Red_Object();
     
124. 
     
125.       }
     
126. 
     
127.      
     
128. 
     
129.       if(new_time-old_time>25000)
     
130. 
     
131.       {
     
132. 
     
133.         catch_red_numbers=0;
     
134. 
     
135.       }
     
136. 
     
137.     }
     
138. 
     
139.     if(receive_string=="blues")
     
140. 
     
141.     {
     
142. 
     
143.       catch_blue_numbers++;
     
144. 
     
145.       new_time = millis();
     
146. 
     
147. //      if(catch_blue_numbers == 3)
     
148. 
     
149. //      {
     
150. 
     
151. //        //old_time = millis();
     
152. 
     
153. //        receive_string="";
     
154. 
     
155. //        //Arm_Catch_Blue_Object();
     
156. 
     
157. //      }
     
158. 
     
159. //      if(catch_blue_numbers == 3)
     
160. 
     
161. //      {
     
162. 
     
163. //        //old_time = millis();
     
164. 
     
165. //        receive_string="";
     
166. 
     
167. //        //Arm_Catch_Blue_Object();
     
168. 
     
169. //      }           
     
170. 
     
171.       if(catch_blue_numbers == 1)
     
172. 
     
173.       {
     
174. 
     
175.         old_time = millis();receive_string="";
     
176. 
     
177.         Arm_Catch_Blue_Object();
     
178. 
     
179.       }
     
180. 
     
181.       if(new_time-old_time>26000)
     
182. 
     
183.       {
     
184. 
     
185.         catch_blue_numbers=0;
     
186. 
     
187.       }
     
188. 
     
189.     }
     
190. 
     
191.     receive_string = "";
     
192. 
     
193.   }
     
194. 
     
195. }

复制代码

第三步：运行程序并查看效果。
打开终端(Alt＋ctrl＋T)，输入roslaunch color_sorting open_camera_and_get_ImageTopic.launch 命令即可（见下图）。

打开第二个终端（shift＋ctrl＋T），输入rviz命令，等待rviz界面启动。

界面启动后，添加Image并设置其参数，设置成功后出现以下三幅图像画面。

图一

图二

图三

       放置物品（请把物品放置在摄像头可以采集到的区域），然后开始识别并进行搬运。下面以红色物品为例，当摄像头识别到红色物品后，机械爪把此物品搬运到一侧；当摄像头识别到蓝色物品时，把蓝色物品搬运到另一侧。这样就完成了按颜色识别物品并搬运的过程。

       提示：颜色识别搬运时，待识别的物品周边尽量不要有过多的杂色，否则会误识别颜色。

6. 颜色识别与追踪
实现思路
       摄像头采集到物品颜色后，随着该颜色物品的运动而缓慢移动，实现追踪效果。
器材准备
       本实验中需要用到的器材如下图所示，其中键盘、鼠标、红色物品可自行准备。

操作步骤
第一步：下载文末资料中的参考程序color_experiment_ws\src\color_tracking\arduino_program\color_tracking_Red_Things\color_tracking_Red_Things.ino：

1. /*
   
2. 
   
3. -----------------------------------------------------------------------------------------------------------------
   
4. 
   
5. 实验功能：【实现颜色（红色）追踪】
   
6. 
   
7. 实验思路：【上位机实现颜色检测(红色物体)，检测到红色物体后，提取红色物体的中心点坐标想（x，y），之后通过
   
8. 
   
9.             检测红色物体的面积大小进而判断红色物体距离摄像头的远近（本实验通过比较检测红色物体面积的当前值
   
10. 
    
11.             与设定红色物体面积的标定值进行比较，进而判断红色物体距离摄像头的远近），判断结束后，会将红色
    
12. 
    
13.             物体的中心点坐标（即（x,y））及红色物体距离摄像头远近的数值（本实验使用的是字符串）通过串口发送
    
14. 
    
15.             给下位机Arduino Mega2560，下位机接收到数据后，机械臂按照该数据进行相应的动作。】
    
16. 
    
17. 实验操作：【将该程序下载到Arduino开发板，之后按照教程启动树莓派例程，观察机械臂是否会跟随红色物体移动。】
    
18. 
    
19. 实验接线（主要接线）：
    
20. 
    
21.           机械臂通信口-------------（机械臂）电控箱
    
22. 
    
23.           机械爪（舵机）---------------（执行器）电控箱
    
24. 
    
25.           其他线路按照教材图片连接。
    
26. 
    
27. Created 2020.7.16     By：Boris.yuan
    
28. 
    
29. -----------------------------------------------------------------------------------------------------------------
    
30. 
    
31. */
    
32. 
    
33. #include <Servo.h>
    
34. 
    
35. #include <stdio.h>
    
36. 
    
37. #include <string.h>
    
38. 
    
39. #define CTL_BAUDRATE 115200 //总线舵机波特率
    
40. 
    
41. #define SERIAL_PRINTLN Serial1
    
42. 
    
43. #define SerialBaudrate 57600
    
44. 
    
45. #define RGB_LED_NUMBERS 3
    
46. 
    
47. #define Bus_servo_Angle_inits 1500
    
48. 
    
49. String receive_string = "";
    
50. 
    
51. enum{RED=1,GREEN,BLUE,NONE_COLOR};
    
52. 
    
53. int catch_red_numbers=0;
    
54. 
    
55. int catch_blue_numbers=0;
    
56. 
    
57. unsigned long old_time = millis();
    
58. 
    
59. unsigned long new_time = millis();
    
60. 
    
61. int value_move[3]={1500,1500,1500};
    
62. 
    
63. int last_value[3]={0,0,0};
    
64. 
    
65. void setup() {
    
66. 
    
67.   // put your setup code here, to run once:
    
68. 
    
69.   delay(1100);
    
70. 
    
71.   Serial.begin(SerialBaudrate);
    
72. 
    
73.   SERIAL_PRINTLN.begin(CTL_BAUDRATE);
    
74. 
    
75.   Bus_servo_angle_init();delay(2000);
    
76. 
    
77. }
    
78. 
    
79. void loop() {
    
80. 
    
81.   while(Serial.available()>0)
    
82. 
    
83.   {
    
84. 
    
85.     new_time = millis();
    
86. 
    
87.     receive_string=Serial.readStringUntil('\n');
    
88. 
    
89.     if( (receive_string.length())<3 && (receive_string.length())>8 )
    
90. 
    
91.     {
    
92. 
    
93.       break;
    
94. 
    
95.     }
    
96. 
    
97.     else
    
98. 
    
99.     {
    
100. 
     
101.        int SpacePosition[2] = {0,0};
     
102. 
     
103.        int Data_one = 0;
     
104. 
     
105.        int Data_two = 0;
     
106. 
     
107.        int numbers_left=0 ,numbers_right=0;
     
108. 
     
109.        char num_left[32] = {};
     
110. 
     
111.        char num_right[32] = {};
     
112. 
     
113.        String x_data="";
     
114. 
     
115.        String y_data="";      
     
116. 
     
117.        SpacePosition[0] = receive_string.indexOf('-');   
     
118. 
     
119.       for(int j=0;j<SpacePosition[0];j++) {
     
120. 
     
121.          numbers_left++;
     
122. 
     
123.          if(receive_string[j] == 'c'){receive_string[j]='0';}
     
124. 
     
125.          x_data+=receive_string[j];
     
126. 
     
127.        }
     
128. 
     
129.       
     
130. 
     
131.        if(receive_string == "back")
     
132. 
     
133.        {
     
134. 
     
135.          value_move[1] -=3;
     
136. 
     
137.        }
     
138. 
     
139.        else if(receive_string == "forward")
     
140. 
     
141.        {
     
142. 
     
143.          value_move[1] +=3;
     
144. 
     
145.        }         
     
146. 
     
147.        for(int k=SpacePosition[0]+1,m=0;k<receive_string.length();k++,m++) {
     
148. 
     
149.          numbers_right++;
     
150. 
     
151.          if(receive_string[k] == 'c'){receive_string[k]='0';}
     
152. 
     
153.          if(numbers_right>=4)
     
154. 
     
155.          {
     
156. 
     
157.            ;
     
158. 
     
159.          }
     
160. 
     
161.          else
     
162. 
     
163.          {
     
164. 
     
165.            y_data+=receive_string[k];
     
166. 
     
167.          }
     
168. 
     
169.        }   
     
170. 
     
171.        Data_one=x_data.toInt();
     
172. 
     
173.        Data_two=y_data.toInt();
     
174. 
     
175.        if(Data_one !=0 )
     
176. 
     
177.        {
     
178. 
     
179.          last_value[0] = Data_one;
     
180. 
     
181.        }
     
182. 
     
183.        if(Data_one ==0)
     
184. 
     
185.        {
     
186. 
     
187.          Data_one = last_value[0];
     
188. 
     
189.        }
     
190. 
     
191.       
     
192. 
     
193.        if(Data_two !=0 )
     
194. 
     
195.        {
     
196. 
     
197.          last_value[2] = Data_two;
     
198. 
     
199.        }
     
200. 
     
201.        if(Data_two ==0)
     
202. 
     
203.        {
     
204. 
     
205.          Data_two = last_value[2];
     
206. 
     
207.        }
     
208. 
     
209.        if( Data_one<=280 ){value_move[0] +=2;}
     
210. 
     
211.        if( Data_one>=368 ){value_move[0] -=2;}
     
212. 
     
213.        if( Data_two<=230-50 ){value_move[2] +=2;}
     
214. 
     
215.        if( Data_two>=250+50 ){value_move[2] -=2;}
     
216. 
     
217.       ArmServoTos(value_move[0],value_move[1],value_move[2],50);//delay(100);
     
218. 
     
219.     }  
     
220. 
     
221.     receive_string = "";
     
222. 
     
223.   }
     
224. 
     
225. }

复制代码

第二步：打开终端(Alt＋ctrl＋T),输入roslaunch color_tracking color_tracking_sth.launch 命令即可，见下图。

打开第二个终端（shift＋ctrl＋T），输入rviz命令，等待rviz界面启动。

界面启动后，添加Image并设置其参数，设置成功后出现以下三幅图像画面。

图一

图二

图三

第三步：放置物品（请把物品放置在摄像头可以采集到的区域），开始追踪。下面以红色物品为例，当摄像头识别到红色物品后，随着红色物品的运动缓慢移动，实现追踪效果。（注意：受硬件的影响，物品的移动速度要稍微慢一些）。

图一

图2 上位机采集的图片信息及画轮廓

7. 资料下载
资料内容：程序源代码
资料下载地址：桌面级机械臂-应用设计 https://www.robotway.com/h-col-259.html