【雕爷学编程】MicroPython手册之 ESP32-CAM 机器人视觉感知_esp32-cam robot

MicroPython是为了在嵌入式系统中运行Python 3编程语言而设计的轻量级版本解释器。与常规Python相比，MicroPython解释器体积小(仅100KB左右)，通过编译成二进制Executable文件运行，执行效率较高。它使用了轻量级的垃圾回收机制并移除了大部分Python标准库，以适应资源限制的微控制器。

MicroPython主要特点包括:
1、语法和功能与标准Python兼容,易学易用。支持Python大多数核心语法。
2、对硬件直接访问和控制,像Arduino一样控制GPIO、I2C、SPI等。
3、强大的模块系统,提供文件系统、网络、图形界面等功能。
4、支持交叉编译生成高效的原生代码,速度比解释器快10-100倍。
5、代码量少,内存占用小,适合运行在MCU和内存小的开发板上。
6、开源许可,免费使用。Shell交互环境为开发测试提供便利。
7、内置I/O驱动支持大量微控制器平台，如ESP8266、ESP32、STM32、micro:bit、掌控板和PyBoard等。有活跃的社区。

MicroPython的应用场景包括:
1、为嵌入式产品快速构建原型和用户交互。
2、制作一些小型的可 programmable 硬件项目。
3、作为教育工具,帮助初学者学习Python和物联网编程。
4、构建智能设备固件,实现高级控制和云连接。
5、各种微控制器应用如物联网、嵌入式智能、机器人等。

使用MicroPython需要注意:
1、内存和Flash空间有限。
2、解释执行效率不如C语言。
3、部分库函数与标准版有差异。
4、针对平台优化语法,订正与标准Python的差异。
5、合理使用内存资源,避免频繁分配大内存块。
6、利用原生代码提升速度关键部位的性能。
7、适当使用抽象来封装底层硬件操作。

ESP32-CAM是一款基于ESP32芯片的小尺寸摄像头模块，具有低功耗、高性能、Wi-Fi和蓝牙功能等特点。根据我从网络上搜索到的信息，ESP32-CAM的核心技术参数如下：
1、CPU：双核32位LX6微处理器，主频高达240MHz，运算能力高达600 DMIPS
2、内存：内置520 KB SRAM，外置4-8MB PSRAM
3、存储：支持TF卡，最大32G
4、无线通信：支持802.11 b/g/n Wi-Fi和蓝牙4.2 BR/EDR和BLE标准
5、接口：支持UART/SPI/I2C/PWM/ADC/DAC等接口
6、摄像头：支持OV2640和OV7670摄像头，内置闪光灯，支持图片Wi-Fi上传
7、电源管理：支持多种休眠模式，深度睡眠电流最低达到6mA
8、封装形式：DIP封装，可直接插上底板使用
9、尺寸：2740.54.5mm

MicroPython的ESP32-CAM机器人视觉感知是指利用MicroPython和ESP32-CAM模块实现对机器人环境进行实时视觉感知和处理的应用。

主要特点：

图像采集：ESP32-CAM模块搭载了高质量的图像传感器和图像处理引擎，能够实时获取环境中的图像数据。它能够捕捉高分辨率的图像，并提供丰富的图像处理功能。
图像处理：ESP32-CAM模块内置了图像处理引擎和算法库，可以进行图像增强、滤波、边缘检测、物体识别等图像处理操作。这使得机器人能够对图像进行实时分析和处理，提取有用的信息。
实时性与低功耗：ESP32-CAM模块具备较强的计算和处理能力，能够在实时性要求较高的场景下进行图像处理。同时，它也具有低功耗的特点，适合嵌入式机器人应用。

应用场景：

目标检测与跟踪：利用ESP32-CAM模块进行视觉感知，机器人可以实时检测和跟踪特定目标物体，如人脸、物体等。这在自主导航、智能监控、机器人交互等场景中都具有重要的应用价值。
环境感知与地图构建：通过对环境中的图像进行感知和处理，机器人可以构建三维地图、识别障碍物、判断地面状况等。这对于自主导航、室内定位等任务非常关键。
视觉导航与避障：基于ESP32-CAM的机器人可以通过视觉感知来进行导航和避障，利用图像处理算法识别环境中的障碍物，并规划合适的路径进行移动。

需要注意的事项：

图像处理算法选择：在进行机器人视觉感知时，需要选择合适的图像处理算法和方法，以满足具体应用的需求。不同的算法对计算资源和时间要求不同，需要根据实际情况进行权衡和选择。
图像质量和环境条件：图像质量和环境条件对机器人视觉感知的效果有重要影响。在设计机器人视觉系统时，需要考虑光照条件、摄像头位置等因素，并进行相应的调整和优化。
算法优化和硬件配置：为了提高机器人视觉感知的性能和效率，可以对算法进行优化和硬件配置进行改进。例如，使用高性能的图像处理算法库，合理配置摄像头和处理器等。
综上所述，MicroPython的ESP32-CAM机器人视觉感知具有图像采集、图像处理、实时性和低功耗等主要特点。它在目标检测与跟踪、环境感知与地图构建、视觉导航与避障等应用场景中具有广泛的应用前景。在使用时需要注意算法选择、图像质量和环境条件，以及算法优化和硬件配置等相关事项。

案例一：识别颜色

from machine import Pin, PWM
import time

# 定义引脚
red_pin = 25
green_pin = 26
blue_pin = 27

# 初始化引脚
red = Pin(red_pin, Pin.OUT)
green = Pin(green_pin, Pin.OUT)
blue = Pin(blue_pin, Pin.OUT)

# 定义颜色阈值
red_threshold = (30, 100, 15, 127, 15, 127)
green_threshold = (30, 100, -64, -8, -32, 32)
blue_threshold = (0, 100, -128, 127, -128, 127)

def set_color(r, g, b):
    red.value(r)
    green.value(g)
    blue.value(b)

def read_sensor():
    # 读取传感器数据
    # 这里需要根据实际传感器类型和连接方式进行修改
    pass

def recognize_color():
    sensor_data = read_sensor()

    # 根据阈值判断颜色
    if sensor_data[0] > red_threshold[0] and sensor_data[0] < red_threshold[1]:
        set_color(1, 0, 0)
    elif sensor_data[1] > green_threshold[0] and sensor_data[1] < green_threshold[1]:
        set_color(0, 1, 0)
    elif sensor_data[2] > blue_threshold[0] and sensor_data[2] < blue_threshold[1]:
        set_color(0, 0, 1)
    else:
        set_color(0, 0, 0)

while True:
    recognize_color()
    time.sleep(0.1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

要点解读：这个程序通过读取传感器数据，根据预设的颜色阈值来判断当前物体的颜色，并控制机器人的灯光颜色。红色、绿色和蓝色分别对应不同的阈值，当传感器数据在阈值范围内时，设置相应的颜色。

案例二：识别形状

from machine import Pin, PWM
import time

# 定义引脚
shape_pin = 28

# 初始化引脚
shape = Pin(shape_pin, Pin.IN)

def read_shape():
    # 读取形状数据
    # 这里需要根据实际传感器类型和连接方式进行修改
    pass

def recognize_shape():
    shape_data = read_shape()

    # 根据形状数据判断形状
    if shape_data == "circle":
        print("圆形")
    elif shape_data == "square":
        print("正方形")
    elif shape_data == "triangle":
        print("三角形")
    else:
        print("未知形状")

while True:
    recognize_shape()
    time.sleep(0.1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

要点解读：这个程序通过读取传感器数据，判断当前物体的形状，并输出对应的形状名称。需要根据实际传感器类型和连接方式修改read_shape函数。

案例三：识别距离

from machine import Pin, PWM
import time

# 定义引脚
distance_pin = 29

# 初始化引脚
distance = Pin(distance_pin, Pin.IN)

def read_distance():
    # 读取距离数据
    # 这里需要根据实际传感器类型和连接方式进行修改
    pass

def recognize_distance():
    distance_data = read_distance()

    # 根据距离数据判断距离
    if distance_data < 10:
        print("近距离")
    elif distance_data < 20:
        print("中等距离")
    else:
        print("远距离")

while True:
    recognize_distance()
    time.sleep(0.1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

要点解读：这个程序通过读取传感器数据，判断当前物体与机器人的距离，并输出对应的距离范围。需要根据实际传感器类型和连接方式修改read_distance函数。

案例四：人脸识别：

import esp32
import uos
import sensor
import image

def face_recognition():
    known_face = image.Image("/known_face.jpg")
    sensor.reset()
    sensor.set_pixformat(sensor.RGB565)
    sensor.set_framesize(sensor.QVGA)
    sensor.run(1)
    
    while True:
        img = sensor.snapshot()
        faces = img.find_features(image.HaarCascade("frontalface"))
        
        for face in faces:
            if img.match_descriptor(face, known_face, threshold=85):
                print("Found known face!")
            else:
                print("Unknown face detected!")

face_recognition()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

要点解读：
这段代码使用ESP32-CAM摄像头模块进行人脸识别。
首先，通过sensor.reset()、sensor.set_pixformat()和sensor.set_framesize()设置摄像头的配置。
然后，使用sensor.run(1)启动摄像头并进入图像捕获循环。
在每次循环中，调用sensor.snapshot()获取当前图像。
使用img.find_features()和Haar级联分类器来检测图像中的人脸。
对于每个检测到的人脸，通过img.match_descriptor()将其与预先存储的已知人脸图像进行比对。
如果匹配度达到阈值（这里设定为85），则输出"Found known face!“，否则输出"Unknown face detected!”。

案例五：颜色识别：

import sensor
import image
import time

def color_detection():
    sensor.reset()
    sensor.set_pixformat(sensor.RGB565)
    sensor.set_framesize(sensor.QVGA)
    sensor.run(1)
    
    while True:
        img = sensor.snapshot()
        blobs = img.find_blobs([(0, 100, -128, 127, -128, 127)], pixels_threshold=200)
        
        if blobs:
            for blob in blobs:
                img.draw_rectangle(blob.rect())
                img.draw_cross(blob.cx(), blob.cy())
                print("Detected color at ({}, {})".format(blob.cx(), blob.cy()))
        
        time.sleep(1)

color_detection()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

要点解读：
这段代码使用ESP32-CAM摄像头模块进行颜色识别。
首先，通过sensor.reset()、sensor.set_pixformat()和sensor.set_framesize()设置摄像头的配置。
然后，使用sensor.run(1)启动摄像头并进入图像捕获循环。
在每次循环中，调用sensor.snapshot()获取当前图像。
使用img.find_blobs()来寻找满足颜色阈值条件的色块。
对于每个检测到的色块，通过img.draw_rectangle()和img.draw_cross()在图像上标记出色块的位置。
最后，输出检测到的色块的中心坐标。

案例六：条形码识别：

import sensor
import image
import time
import zxing

def barcode_detection():
    sensor.reset()
    sensor.set_pixformat(sensor.RGB565)
    sensor.set_framesize(sensor.QVGA)
    sensor.run(1)
    
    scanner = zxing.Scanner()
    
    while True:
        img = sensor.snapshot()
        results = scanner.scan(img)
        
        if results:
            for result in results:
                print("Detected barcode:", result[0])
        
        time.sleep(1)

barcode_detection()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

要点解读：
这段代码使用ESP32-CAM摄像头模块进行条形码识别。
首先，通过sensor.reset()、sensor.set_pixformat()和sensor.set_framesize()设置摄像头的配置。
然后，使用sensor.run(1)启动摄像头并进入图像捕获循环。
创建一个zxing的扫描器对象。
在每次循环中，调用sensor.snapshot()获取当前图像。
使用扫描器对象的scan()方法对图像进行条形码识别。
如果识别到条形码，输出检测到的条形码信息。
以上是几个具体应用程序案例，分别涵盖了人脸识别、颜色识别和条形码识别。这些案例代码可以作为基础，根据实际需求进行修改和扩展，以实现更复杂的机器人视觉感知功能。

案例七：图像传输
ESP32-CAM拍摄的图像传输到远程服务器。

import network
import urequestsfrom machine import Pin
import time

# 连接到无线网络
ssid = 'Your WiFi SSID'
password = 'Your WiFi'
wlan = network.WLAN(network.STA_IF)
wlan(True)
wlan.connect(ssid, password)
while not wlan.isconnected():
    pass

# 拍摄发送图像
def transmit_image():
    url = 'http://your_server_url_upload'  # 替换为远程服务器的URL
    pin_led = Pin(13, Pin.OUT)
   _led.on()
    time.sleep_ms(1000)
    pin_led.off()
    
    pin_capture = Pin(14, Pin.OUT)
    pin_capture.on()
    time.sleep_ms(200)
    pin_capture.off    time.sleep(1)
    
    try:
        image = open('capt0000.jpg', 'rb')
        files = {'image': image}
        response = urequests.post(url, files=files)
        print(response.text)
        response.close()
    except:
        print('Failed to transmit image')

transmit_image()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

要点解读：
此使用网络库连接到Wi-Fi网络，并使用urequests库将图发送到远程服务器。
需将Your WiFi SSID和`Your WiFi Password替换为您的Wi-Fi网络凭据。
需将your_server_url/image_upload换为远程服务器的URL，用于接收图像文件。
拍摄图像的脚通过将其设置为适量控制。
图像传输成功后，打服务器的响应。

案例八：颜色检测
使用32-CAM检测图像中颜色并输出结果。

import sensor
import image

sensor.reset()
sensor.set_pix(sensor.RGB565)
sensor.set_framesize.QVGA)
sensor.run(1)

 detect_color():
    while True:
        img = sensor.snapshot()
        blobs = img.find_blobs0, 40, -128, 127, -128, 127)], pixels_threshold=200)
        if blobs:
            for blob in:
                img.draw_rectangle(blob.rect                img.draw_cross(blob.cx(), blob.cy())
 color = img.get_statistics(roi=blob.rect())
                print('Detected:', color)

detect_color()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

要点解读：
此代码使用像传感器库和图像库进行颜色测。
设置图像传感的参数，包括像素格式、分辨率等。
在环中，连续拍摄像，并使用find_blobs函数查找指定颜色的物体。
如果找到物体，将其位置和包围框绘制在图上，并使用get_statistics函数获取物体的颜色统信息。
打印检到的颜色信息。

案例九：获取摄像头图像并显示

from machine import I2C, Pin
import camera

# 配置摄像头模块
i2c = I2C(scl=Pin(13), sda=Pin(12), freq=400000)
camera_client = camera.TasmotaCameraClient(i2c, "YOUR_CAMER_ADDR")

while True:
    # 获取新的图像
    img = camera_client.snapshot()
    # 在LED上显示图像
    leds = machine.Pin(2, machine.Pin.OUT)
    for row in img:
        for pixel in row:
            if pixel:
                leds.value(int(1 << row_num))  # 设置像素的亮度（这里是按照亮度，实际上LED上并没有具体的亮度，但需要将LED模拟成有一定亮度的点阵）
        row_num += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

要点解读：
通过I2C接口与摄像头模块通信。注意替换“YOUR_CAMER_ADDR”为实际的摄像头地址。
使用camera库来获取摄像头的图像数据。这是一个开源库，可用于Tasmota协议的ESP32摄像头。
将图像数据逐行显示在LED上，模拟图像显示。注意这里将LED模拟成有一定亮度的点阵，以实现图像显示的效果。

案例十：识别移动物体

from machine import I2C, Pin, Timer
import camera
import cv2 as cv
import numpy as np

# 配置摄像头模块和计时器
i2c = I2C(scl=Pin(13), sda=Pin(12), freq=400000)
camera_client = camera.TasmotaCameraClient(i2c, "YOUR_CAMER_ADDR")
timer = Timer(0)  # ESP32 timer to trigger every X ms, typically for detecting motion on a frame captured at 60Hz
timer.init(period=1 / 60)  # sets the timer to fire at 60Hz (i.e., every 1/60th of a second)

# 存储所有检测到的移动物体位置的列表，初始为空
detected_objects = []

while True:
    # 获取新的图像并检测移动物体
    img = camera_client.snapshot()
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)  # convert image to grayscale for faster motion detection
    _, thresholded = cv.threshold(gray, 50, 255, cv.THRESH_BINARY)[1:]  # apply a binary threshold to enhance motion detection
    contours, _ = cv.findContours(thresholded, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)  # find contours in the image and return them as a list of lists of points in the form [[x, y], [x, y], ...]
    detected_objects = [[point[0], point[1]] for points in contours for point in points]  # convert contours into a list of coordinates (x, y) pairs for storing in detected_objects list
    # 将移动物体坐标存储在列表中，可以在需要时进行进一步处理或输出到显示屏等设备上。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

要点解读：
使用OpenCV库对图像进行灰度化和阈值化处理，以增强移动物体的检测能力。这是因为人的视觉系统通常更容易注意到对比度较大的图像内容。这里使用的阈值是一个相对简单的设置，但实际应用中可能需要调整以适应不同的环境和光照条件。
使用计时器定期触发摄像头的采集，从而保证处理的速度和效率。在60Hz的频率下进行处理可以获得相对准确的移动物体检测结果。可以根据实际需求调整计时器的周期。
将检测到的移动物体坐标存储在列表中，可以在需要时进行进一步处理或输出到其他设备上。例如，可以将检测结果发送到机器人控制器的应用程序或通过网络发送到远程服务器进行处理。

请注意，以上案例只是为了拓展思路，可能存在错误或不适用的情况。不同的硬件平台、使用场景和MicroPython版本可能会导致不同的使用方法。在实际编程中，您需要根据您的硬件配置和具体需求进行调整，并进行多次实际测试。需要正确连接硬件并了解所使用的传感器和设备的规范和特性非常重要。对于涉及到硬件操作的代码，请确保在使用之前充分了解和确认所使用的引脚和电平等参数的正确性和安全性。