esp32 cam+esp8266用micropython实现人脸识别开门

是用来碎的

媒介

前里文章讲了编译micropython的编译战图传，那篇记载一下我本人DIY人脸辨认门锁的经验。
为何用esp8266，由于比esp32便宜几块钱，批收以至只需6块，哈哈
因为micropython我也刚上脚，也是教一面记载一面，当帮大家提早踩坑了~
空话未几道，间接上例子！
---------------------------------------------------------------------------------------------------------------------------------
万万没有要被题目骗了，光单片机是达没有到人脸辨认的，机能必定不敷。那末我们需求一个效劳器去对人脸停止比对，我用的是本人的一个arm效劳器。80多购的n1盒子，刷的centos，1.5G 4线程处置器关于我小我私家仍是够用。假如有同窗需求，我也能够零丁出一篇我的效劳器拆建踩坑阅历。当然您也能够用您的pc去当效劳器，机能尽对够用。怎样利用wsl刷进Ubuntu，我前里也有道，便没有空话了。
1、效劳器状况拆建

我用的是centos 7，颠末尝试，Ubuntu的操纵好未几。因为是利用centos，gcc版本必定不敷。那末需求晋级gcc版本，能够晋级到7或9，我便是那个坑华侈了一个多小时。
python3装置（皆利用micropython了，必定皆有py3，没有空话了）
centos晋级：

1. # yum装置gcc7
3. $ yum install devtoolset-7-gcc*
5. # 用gcc7自带的剧本增加到情况变量
7. $ scl enable devtoolset-7 bash
9. # 检察gcc版本
11. $ gcc -v

复造代码

Ubuntu不消晋级gcc，自带最新的
装置boost、cmake、git
centos：

1. $ yum install -y boost,cmake,git

复造代码

Ubuntu

1. $ sudo apt-get install -y git,cmake,libboost-all-dev

复造代码

编译dlib（我们用的人脸辨认依靠那个库）

1. # 克隆dlib源代码
2. $ git clone https://github.com/davisking/dlib.git
4. $ cd dlib
5. $ mkdir build
6. $ cd build
8. #那一部门是利用硬件加快的，假如硬件撑持，人脸辨认是很快的
9. $ cmake .. -DDLIB_USE_CUDA=1 -DUSE_AVX_INSTRUCTIONS=1
10. $ cmake --build .（留意中心有个空格）
11. $ cd ..
13. #python装置dlib
14. $ python3 setup.py install

复造代码

重面！！！！！
编译dlib库倡议闲暇内乱存4G以上，不敷能够暂时利用swap，否则会编译失利

最初装置face_recognition

1. # 装置 face_recognition
2. $ pip3 install face_recognition

复造代码

至此，我们的人脸辨认状况便拆建好了
能够用一下代码测试能否装置胜利

1. # 筹办两个文件夹，一个是参照图片，一个是要辨认的图片
3. $ face_recognition ./file1/ ./file2/

复造代码

能辨认出便会显现第一个文件夹内乱的照片的名字。
2、创立人脸辨认接心

我们先利用以下代码天生本人的人脸数组

1. import face_recognition
3. # 翻开您的图片文件
4. img = face_recognition.load_image_file('face.jpg')
5. # 将人脸编码成素组
6. face_encodings = face_recognition.face_encodings(img)
8. # 挨印出的便是您的人脸数组，复造到上面的代码中，也能够保留到数据库(只需求list,没有要将全部tuple皆复造)
9. print(face_encodings)

复造代码

利用python 的socket库去监听端心，当文件传进的时分停止辨认

1. import socket,threading,os
2. import face_recognition
4. # 进进指定目次施行
5. os.chdir('/root/face/')
6. # 图片格局
7. ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
9. def detect_faces_in_image(file_stream):
10.     #人脸数组
11.     face_list = [[[-0.09634063,  0.12095481, -0.00436332, -0.07643753,  0.0080383,
12.                             0.01902981, -0.07184699, -0.09383309,  0.18518871, -0.09588896,
13.                             0.23951106,  0.0986533 , -0.22114635, -0.1363683 ,  0.04405268,
14.                             0.11574756, -0.19899382, -0.09597053, -0.11969153, -0.12277931,
15.                             0.03416885, -0.00267565,  0.09203379,  0.04713435, -0.12731361,
16.                            -0.35371891, -0.0503444 , -0.17841317, -0.00310897, -0.09844551,
17.                            -0.06910533, -0.00503746, -0.18466514, -0.09851682,  0.02903969,
18.                            -0.02174894,  0.02261871,  0.0032102 ,  0.20312519,  0.02999607,
19.                            -0.11646006,  0.09432904,  0.02774341,  0.22102901,  0.26725179,
20.                             0.06896867, -0.00490024, -0.09441824,  0.11115381, -0.22592428,
21.                             0.06230862,  0.16559327,  0.06232892,  0.03458837,  0.09459756,
22.                            -0.18777156,  0.00654241,  0.08582542, -0.13578284,  0.0150229 ,
23.                             0.00670836, -0.08195844, -0.04346499,  0.03347827,  0.20310158,
24.                             0.09987706, -0.12370517, -0.06683611,  0.12704916, -0.02160804,
25.                             0.00984683,  0.00766284, -0.18980607, -0.19641446, -0.22800779,
26.                             0.09010898,  0.39178532,  0.18818057, -0.20875394,  0.03097027,
27.                            -0.21300618,  0.02532415,  0.07938635,  0.01000703, -0.07719778,
28.                            -0.12651891, -0.04318593,  0.06219772,  0.09163868,  0.05039065,
29.                            -0.04922386,  0.21839413, -0.02394437,  0.06173781,  0.0292527 ,
30.                             0.06160797, -0.15553983, -0.02440624, -0.17509389, -0.0630486 ,
31.                             0.01428208, -0.03637431,  0.03971229,  0.13983178, -0.23006812,
32.                             0.04999552,  0.0108454 , -0.03970895,  0.02501768,  0.08157793,
33.                            -0.03224047, -0.04502571,  0.0556995 , -0.24374914,  0.25514284,
34.                             0.24795187,  0.04060191,  0.17597422,  0.07966681,  0.01920104,
35.                            -0.01194376, -0.02300822, -0.17204897, -0.0596558 ,  0.05307484,
36.                             0.07417042,  0.07126575,  0.00209804],'奥巴马']]
38.     #减载上传的暂时图片
39.     img = face_recognition.load_image_file(file_stream)
40.     #获得上传图象中的人脸编码
41.     unknown_face_encodings = face_recognition.face_encodings(img)
42.     # 界说辨认成果变量
43.     is_name = 'unknow'
44.     if len(unknown_face_encodings) > 0:
45.         #检察上传图象中的第一张面目面貌能否取已知面目面貌婚配
46.         for face_who in face_list:
47.             match_results = face_recognition.compare_faces([face_who[0]], unknown_face_encodings[0])
48.             # 辨认胜利
49.             if match_results[0]:
50.                 is_name = face_who[1]
52.     #将成果返回
53.     return is_name
55. def deal_data(conn, addr):
56.     print('新毗连 {0}'.format(addr))
57.     # 两进造jpg数据
58.     buff = b''
59.     while 1:
60.         data = conn.recv(1024)
61.         # print('{0} 客户端收收数据是 {1}'.format(addr, data.decode()))
62.         print('支到数据，正正在处置...')
63.         # 因为会分包收收，我们领受的时分要兼并数据
64.         buff += data
65.         # 我利用endsend去标识表记标帜文件收收完毕
66.         if data[-7:] == b'endsend':
67.             # 来失落endsend
68.             buff = buff.strip(b'endsend')
69.             # 创立暂时文件用去存与支到的图片数据
70.             tempfile = 'temp.jpg'
71.             # 保留图片
72.             with open(tempfile,'wb') as f:
73.                 f.write(buff)
74.                 f.close()
75.             # 辨认人脸图片，只需返回的没有是'unknow',便代表辨认胜利
76.             ss = detect_faces_in_image(tempfile)
77.             # 收收辨认成果
78.             conn.send(bytes(ss,'UTF-8'))
79.             # 删除暂时图片文件
80.             os.remove(tempfile)
81.             # 封闭毗连
82.             print('{0} 毗连封闭'.format(addr))
83.             conn.close()
84.             break
85.         # 封闭毗连
86.         elif not data:
87.             print('{0} 毗连封闭'.format(addr))
88.             conn.close()
89.             break
90.    
91.    
92. if __name__ == "__main__":
93.     # 监听的地点
94.     ADDR = ('0.0.0.0',10086)
95.     #socket利用TCP毗连
96.     s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
97.     s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
98.     # 绑定套接字
99.     s.bind(ADDR)
100.     # 最年夜毗连数
101.     s.listen(10)
102.     print('等候毗连...')
103.     while 1:
104.         # 开端监听端心
105.         conn, addr = s.accept()
106.         # 另开线程运转
107.         t = threading.Thread(target=deal_data, args=(conn, addr))
108.         t.start()

复造代码

3、人脸辨认战开锁代码

esp32cam 卖力照相战上传到效劳器辨认，辨认胜利后将开门指令收收给esp8266开门
为何要弄两个单片机，没有间接用esp32cam开门？
由于我们利用的场景普通esp32cam会安排到室中，假如用esp32cam间接掌握机电会有宁静成绩，以是减了一块8266安排到室内乱去开门。
esp32cam代码：

1. import urequests,time,socket,sys
3. # 开门函数
4. def socket_client():
5.     try:
6.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
7.         s.connect(('esp8266地点', 10086))
8.     except socket.error as msg:
9.         print(msg)
10.         sys.exit(1)
11.     # 开门指令为open
12.     data = b'open'
13.     # 收收到esp8266
14.     s.send(data)
15.     while 1:
16.         # 壅闭承受数据
17.         msg1 = str(s.recv(1024),'utf-8')
18.         print(msg1 )
19.         # 支到over后封闭毗连
20.         if msg1 == 'over':
21.             s.close()
22.             return True
25. # 14号引足中止回调函数
26. def handle_interrupt(pin):
27.     global motion
28.     motion = True
29.     global interrupt_pin
30.     interrupt_pin = pin
32. # 上传函数
33. def get_face(buf):
34.     print('翻开socket')
35.     try:
36.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
37.         s.connect(('您的效劳器地点', 10086))
38.     except socket.error as msg:
39.         print(msg)
40.     # 图片数据   
41.     data = buf
42.     # 收收图片
43.     s.send(data)
44.     # 收收完毕字符串标记
45.     s.send(b'endsend')
46.     # 辨认成果
47.     face = str(s.recv(1024),'utf8')
48.     print('辨认成果->',face)
49.     # 封闭毗连
50.     s.close()
51.     # 返回辨认成果
52.     return face
54. # 中止后照相解锁   
55. def do_camera(led):
56.     #照相行动
57.     buf = camera.capture()
58.     try:
59.         print ("正正在辨认...")
60.         # 挪用上传代码
61.         face = get_face(buf)
62.         # 成果没有是'unknow'辨认胜利
63.         if face != 'unknow':
64.             print ('辨认胜利->',face)
65.             led.value(0)
66.             # 开门
67.             suo = jiesuo.socket_client()
68.             if suo ==True:
69.                 print('开门胜利!')
70.                 return True
71.             else:
72.                 print('开门失利!')
73.                 return False
74.     except Exception as e:
75.         print(e)            
77.         
78. #运转   
79. print('开端事情...')
80. print('初初化相机设置...')
81. import camera
82. camera.init(0, format=camera.JPEG)
83. #上翻下翻
84. camera.flip(0)
85. #左/左
86. camera.mirror(1)
87. # 框架
88. camera.framesize(camera.FRAME_SVGA)
89. #殊效
90. camera.speffect(camera.EFFECT_NONE)
91. #利剑均衡
92. camera.whitebalance(camera.WB_NONE)
93. #饱战
94. camera.saturation(0)
95. #明度
96. camera.brightness(0)
97. #比照度
98. camera.contrast(0)
99. #量量
100. camera.quality(10)
102. print('初初化引足...')
103. from machine import Pin
104. from time import sleep
105. motion = False
106. # 掌握led
107. led = Pin(4, Pin.OUT)
108. # 旌旗灯号引足，接按钮或pir白中模块
109. p14 = Pin(14, Pin.IN)
111. print('正正在监控绘里挪动...')
112. p14.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)
114. # 辨认次数
115. photoNum = 1
117. while True:
118.     # 14号引足支到电仄旌旗灯号
119.     if motion:
120.         if photoNum ==1:
121.             # 翻开单片机自带的闪光灯，esp32cam是4号引足
122.             led.value(1)
123.             print('检测到挪动:去自引足', interrupt_pin ,',上传图片...')
124.             
125.         print('开端第{0}次辨认'.format(str(photoNum)))
126.         # 照相并上传
127.         can_camera = do_camera(led)
128.         # 辨认胜利
129.         if can_camera:
130.             motion = False
131.             photoNum = 1
132.         # 辨认没有胜利反复施行5次，每次距离2s，避免照相恍惚辨认失利，我们用次数去补偿摄像头的不敷
133.         else:
134.             photoNum = photoNum + 1
135.             if photoNum == 6:
136.                 print ('辨认失利')
137.                 motion = False
138.                 # 封闭闪光灯
139.                 led.value(0)
140.                 photoNum = 1
141.             time.sleep(2)

复造代码

esp8266代码：

1. import machine,socket,urequests,time
3. # 操控引足函数
4. def de_pin(oc,conn):
5.     global pin14
6.     global pin12
7.     global pin4
8.     # 支到开门指令
9.     if oc == 'open':
10.         # 开门
11.         pin12.value(0)
12.         print('pin12 : 1')
14.         # 引足4确当前电压（当引足4发作电压变革，则机电开端动弹，开端检测行动能否到位）
15.         pin4sta = pin4.value()
16.         print('pin4:',pin4sta)
17.         # 检测机电能否开端动弹
18.         while 1:
19.             # 不竭检测引足4的电压
20.             ss = pin4.value()
21.             print('pin4:',ss)
22.             # 引足4发作电压变革，机电开端动弹，截至当前轮回
23.             if ss != pin4sta:
24.                 break
25.             time.sleep(0.1)
27.         # 检测开门行动能否到位
28.         while 1:
29.             time.sleep(0.1)
30.             ss = pin4.value()
31.             print('pin4:',ss)
32.             # 假如触碰着限位器，则行动到位，机电截至动弹
33.             if ss == 1:
34.                 pin12.value(1)
35.                 print('pin12 : 0')
36.                 break
38.         # 收收开门完成的指令'isopen'
39.         conn.send(bytes('isopen','utf8'))
40.         # 等候10s，您能够排闼了
41.         time.sleep(10)
43.         # 开端闭门
44.         pin14.value(0)
45.         print('pin14 : 1')
47.         # 引足4确当前电压（当引足4发作电压变革，则机电开端动弹，开端检测行动能否到位）
48.         pin4sta = pin4.value()
49.         print('pin4:',pin4sta)
51.         # 检测机电能否开端动弹
52.         while 1:
53.             # 不竭检测引足4的电压
54.             ss = pin4.value()
55.             print('pin4:',ss)
56.             # 引足4发作电压变革，面机开端动弹，截至当前轮回
57.             if ss != pin4sta:
58.                 break
59.             time.sleep(0.1)
61.         # 检测闭门行动能否到位
62.         while 1:
63.             time.sleep(0.1)
64.             ss = pin4.value()
65.             print('pin4:',ss)
66.             # 假如触碰着限位器，则行动到位，机电截至动弹
67.             if ss == 1:
68.                 time.sleep(0.5)
69.                 pin14.value(1)
70.                 print('pin14 : 0')
71.                 break
72.    
73. # 处置套接字的函数
74. def deal_data(conn, addr):
75.     print('新毗连：{0}'.format(addr))
76.     conn.send(bytes('毗连胜利!','utf8'))
77.     # 监听
78.     data = conn.recv(10240)
79.     # 支到的数据
80.     data = str(data,'utf-8')
81.     print(data)
82.     # 假如支到的为'open'指令，那末开门
83.     if data == 'open':
84.         # 开门
85.         de_pin(data,conn)
86.         # 完成后告诉esp32cam
87.         conn.send(bytes('over','utf8'))
88.     # 封闭毗连
89.     conn.close()
92. # 监听的地点战端心，0.0.0.0为一切的滥觞
93. ADDR = ('0.0.0.0',10086)
94. # 利用tcp
95. s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
96. s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
97. # 绑定套接字
98. s.bind(ADDR)
99. s.listen(1)
101. #开门引足
102. pin14 = machine.Pin(14,machine.Pin.OUT)
103. #闭门引足
104. pin12 = machine.Pin(12,machine.Pin.OUT)
105. #初初化，因为我利用的是低电仄触收的继电器，以是要设置为下电仄
106. pin14.value(1)
107. pin12.value(1)
108. pin4 = machine.Pin(4,machine.Pin.IN)
109. # led灯，我的单片机是个蓝色的，挺都雅，我便翻开了，没有念要能够正文失落
110. pin2 = machine.Pin(2,machine.Pin.OUT)
112. while True:
113.     print('等候毗连...')
114.     # led灯，我的单片机是个蓝色的，挺都雅，我便翻开了，没有念要能够正文失落
115.     pin2.value(0)
116.     # 开端监听
117.     conn, addr = s.accept()
118.     try:
119.         # 处置套接字
120.         deal_data(conn, addr)
121.     except:
122.         pass

复造代码

附：开门的质料战引足接线

质料
开门接纳两路5v低电仄继电器、12v加速机电（30转/分,能够推40斤，卖家道的，没有明白实假）、限位器（便宜，门把脚动弹到位后截至机电动弹，避免机电或把脚破坏，下附图）、12v电源、12v降5v降压板
引足：
esp32cam

• gpio 14 打仗收安装，开闭或白中
  

esp8266

• gipo 14 开门 接继电器
  
• gpio 12 闭门 接继电器
  
• gpio 4 限位器触收引足 接限位器
  

继电器：
掌握端
vcc接3.3v（那个要看您引足的电仄，由于esp系列引足皆是3.3v，那末继电器的电源必然要接3.3v，否则没法触收）
GND接GND
IN接掌握引足12、14
被控端
将12v电源线正极背极别离一分两分红两跟，共四根线接两路继电器。
常开接心（通常为第一个）接12v正，中心接机电，常闭接心（普通第三个）接12v背（两个继电器的接线必然要一样，好比第一个接线心接正，那末另外一个继电器的第一个引足也必需接正，否则没法掌握，要没有您便本人改代码。此外常闭战常开必需严厉按前里道的接正、接背战做好尽缘，不然泄电烧坏装备战没有当心短路起水概没有卖力）
限位器少上面如许子：

 高低两个打仗片为3.3v（下电仄），中心把脚上的打仗针为gpio4。机电支到开门指令后动弹，当针分开下打仗片的时分，开端监测gpio4 的电压，此时gpio4为低电仄。当打仗到上打仗片的时分，门锁已翻开，gpio4为下电仄，机电停转。闭门同理。
完成后测试：
   diy人脸辨认开门门锁，利用esp32cam战esp8266单片机
最初：

筹算减个扬声器，用于播报辨认成果。今朝借正在啃DAC的文档，先上那些经验为敬~
辛辛劳苦码字没有简单，给个批评鼓舞下呗~

免责声明：假如进犯了您的权益，请联络站少，我们会实时删除侵权内乱容，感谢协作！