"用ESP32-CAM实现输出一定时间的5V 10kHz的电流,然后再控制外接摄相机拍照,拍好后通过蓝牙将图片上传至电脑,请完整呈现具体过程"这个问题中电脑接收并保存为图片文件电脑端可写Python脚本自动接收保存,的部分请详细阐述
时间: 2025-07-24 16:32:14 浏览: 17
<think>我们首先需要明确整个流程的步骤:
1. ESP32-CAM输出5V 10kHz的PWM信号(持续一定时间)以驱动外部设备(可能是闪光灯或触发器)。
2. 然后控制外接相机拍照(这里假设外接相机可以通过某种触发方式控制,例如通过一个IO口触发)。
3. 拍好照片后,通过蓝牙将图片上传至电脑。
4. 电脑端运行Python脚本接收蓝牙传输的图片并保存为文件。
由于问题要求详细阐述电脑端接收并保存图片的部分,我们将重点放在第4步,但为了完整性,也会简要说明前3步。
### 步骤1:ESP32-CAM输出PWM
注意:ESP32-CAM的GPIO引脚是3.3V电平,不能直接输出5V。因此,如果需要5V电平,需要使用电平转换电路或者通过一个简单的晶体管电路进行升压。
这里我们使用LEDC(LED PWM控制器)来产生10kHz的PWM信号。我们选择一个GPIO引脚(例如GPIO12)作为PWM输出。
代码示例(Arduino):
```cpp
#include "esp_camera.h"
#include "driver/ledc.h"
// 定义PWM参数
#define PWM_FREQ 10000 // 10kHz
#define PWM_CHANNEL LEDC_CHANNEL_0
#define PWM_RESOLUTION LEDC_TIMER_8_BIT // 8位分辨率
#define PWM_PIN 12 // 选择GPIO12
void setup() {
// 配置PWM
ledc_timer_config_t timer_conf = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = PWM_RESOLUTION,
.timer_num = LEDC_TIMER_0,
.freq_hz = PWM_FREQ,
.clk_cfg = LEDC_AUTO_CLK
};
ledc_timer_config(&timer_conf);
ledc_channel_config_t channel_conf = {
.gpio_num = PWM_PIN,
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = PWM_CHANNEL,
.intr_type = LEDC_INTR_DISABLE,
.timer_sel = LEDC_TIMER_0,
.duty = 128, // 50%占空比,实际需要根据负载调整
.hpoint = 0
};
ledc_channel_config(&channel_conf);
}
void loop() {
// 这里我们先不写循环内容,因为PWM输出在配置后就会持续输出
}
```
注意:由于我们要输出一定时间,比如1秒,然后停止,可以在需要的时候启动PWM,并在一定时间后停止(将占空比设为0)。但这里我们假设持续输出,因为后续要触发相机。
### 步骤2:控制外接相机拍照
假设外接相机有一个触发拍照的接口(比如通过一个低电平脉冲触发),我们可以用ESP32-CAM的另一个GPIO(比如GPIO13)连接相机的触发线。
示例代码(在需要拍照时触发):
```cpp
#define CAM_TRIGGER_PIN 13
void setup() {
// ... 上面的PWM配置
pinMode(CAM_TRIGGER_PIN, OUTPUT);
digitalWrite(CAM_TRIGGER_PIN, HIGH); // 初始高电平
}
void triggerCamera() {
digitalWrite(CAM_TRIGGER_PIN, LOW);
delay(100); // 保持低电平100ms(根据相机要求调整)
digitalWrite(CAM_TRIGGER_PIN, HIGH);
}
```
### 步骤3:拍照并通过蓝牙上传
由于ESP32-CAM自带摄像头,但问题中说的是“外接相机”,这里有两种理解:
a) 使用ESP32-CAM自带的摄像头拍照,然后通过蓝牙上传。
b) 控制外接的独立相机(如单反)拍照,然后由外接相机存储照片。但这样ESP32-CAM无法直接获取照片,所以需要外接相机支持将照片传输到ESP32-CAM(比如通过SD卡读取或者网络传输),这通常不现实。
因此,我假设问题中的“外接相机”可能是误用,实际是指ESP32-CAM自带的摄像头。所以,我们使用ESP32-CAM的摄像头拍照,然后将照片数据通过蓝牙传输。
注意:ESP32-CAM没有内置蓝牙功能?实际上ESP32芯片包含蓝牙,所以我们可以使用蓝牙。
但是,蓝牙传输大量数据(图片)速度较慢,所以如果图片较大,可能需要压缩或降低分辨率。
示例代码(使用经典蓝牙SPP):
```cpp
#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
void setup() {
// ... 之前的配置
SerialBT.begin("ESP32-CAM"); // 蓝牙设备名称
// 初始化摄像头
camera_config_t config;
// 配置摄像头参数(省略具体配置)
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
// 错误处理
}
}
void loop() {
// 假设某个条件触发(比如按键或定时)
// 1. 先输出PWM一段时间(例如1秒)
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_CHANNEL, 128); // 设置占空比
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_CHANNEL);
delay(1000); // 输出1秒
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_CHANNEL, 0); // 停止PWM
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_CHANNEL);
// 2. 触发相机拍照(这里触发的是ESP32-CAM自带的摄像头)
camera_fb_t *fb = esp_camera_fb_get();
if (!fb) {
// 错误处理
return;
}
// 3. 通过蓝牙发送图片数据
SerialBT.write(fb->buf, fb->len);
// 释放帧缓冲区
esp_camera_fb_return(fb);
// 等待一段时间再重复
delay(5000);
}
```
### 步骤4:电脑端Python脚本接收蓝牙数据并保存为图片
电脑端需要使用蓝牙与ESP32-CAM配对并建立串行连接(SPP)。我们可以使用PyBluez(Windows)或socket(Linux)来实现。由于PyBluez在Windows上安装复杂,且跨平台兼容性差,这里我们使用跨平台的`bleak`库?注意:经典蓝牙SPP不是低功耗蓝牙(BLE),所以不能用`bleak`(它只支持BLE)。因此,我们使用PyBluez或系统自带的串口(蓝牙SPP模拟串口)。
实际上,当ESP32使用经典蓝牙的SPP协议时,电脑配对后会将ESP32视为一个串口设备(COM端口或/dev/rfcomm0)。因此,我们可以用Python的串口库(如pyserial)来读取。
步骤:
1. 电脑与ESP32-CAM配对(在电脑的蓝牙设置中搜索并配对,配对码通常是1234或0000)。
2. 配对后,电脑会分配一个串行端口(COMx或/dev/rfcomm0)。
3. Python脚本打开该串口,读取数据并保存为图片文件。
安装pyserial:`pip install pyserial`
Python脚本示例(假设图片格式为JPEG):
```python
import serial
import time
# 根据实际情况修改串口号
port = 'COM5' # Windows
# port = '/dev/rfcomm0' # Linux
baud_rate = 115200 # 与ESP32设置一致
# 打开串口
ser = serial.Serial(port, baud_rate, timeout=1)
# 由于图片数据是连续传输的,我们需要知道图片的大小(但ESP32没有发送大小信息)
# 因此,我们可以采用以下方法之一:
# 方法1:ESP32在发送图片前先发送图片长度(4字节),电脑端先接收长度,再接收图片数据
# 方法2:通过超时判断:如果一段时间没有数据,则认为图片传输完成(不可靠)
# 这里使用方法1:ESP32在发送图片数据前先发送4字节(32位整数)的长度信息
# 修改ESP32代码:
# SerialBT.write((const uint8_t*)&fb->len, 4); // 先发送长度
# SerialBT.write(fb->buf, fb->len); // 再发送图片数据
# 电脑端接收:
while True:
# 先读取4字节的长度
len_data = ser.read(4)
if len(len_data) < 4:
continue
# 将4字节转换为整数(小端序)
img_size = int.from_bytes(len_data, byteorder='little')
print(f"Expecting image size: {img_size} bytes")
# 读取图片数据
img_data = b''
while len(img_data) < img_size:
# 每次读取剩余字节数或1024,取较小者
remaining = img_size - len(img_data)
chunk = ser.read(1024 if remaining > 1024 else remaining)
if not chunk:
break
img_data += chunk
if len(img_data) == img_size:
# 保存为文件
filename = f"image_{int(time.time())}.jpg"
with open(filename, 'wb') as f:
f.write(img_data)
print(f"Image saved as {filename}")
else:
print(f"Image incomplete: expected {img_size}, got {len(img_data)} bytes")
# 关闭串口
ser.close()
```
注意:如果图片很大,蓝牙传输可能较慢,需要调整串口超时时间或增加等待。
### 完整流程总结:
1. ESP32-CAM启动后,初始化PWM、摄像头和蓝牙。
2. 在需要时(例如循环中每隔5秒):
a. 开启PWM输出(持续1秒)。
b. 用自带摄像头拍照。
c. 通过蓝牙发送图片长度(4字节)和图片数据。
3. 电脑端运行Python脚本,持续监听蓝牙串口,接收图片并保存。
注意:实际应用中可能需要添加错误处理、同步机制等。
§§相关问题§§
1. 您是否需要使用ESP32-CAM控制外接独立相机(而非板载摄像头)?如果是,该相机支持何种触发接口?
2. 电脑端操作系统是Windows、Linux还是macOS?这将影响蓝牙串口的使用方式。
3. 图片传输的实时性要求如何?是否需要压缩图片以减少传输时间?
4. 您计划如何同步PWM输出和拍照动作(例如PWM输出后立即拍照还是延迟拍照)?
5. 蓝牙传输距离有限(通常10米内),您的设备与电脑之间的距离是多少?</think>### 完整实现方案:电脑端Python蓝牙图片接收与保存
#### 电脑端Python脚本详细实现(支持Windows/Linux/macOS)
```python
import bluetooth
import os
import time
from datetime import datetime
from PIL import Image # 用于图片验证
def receive_bluetooth_image(save_dir="received_images"):
# 创建保存目录
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# 设置蓝牙服务
server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
server_sock.bind(("", bluetooth.PORT_ANY))
server_sock.listen(1)
port = server_sock.getsockname()[1]
uuid = "00001101-0000-1000-8000-00805F9B34FB" # 标准SPP UUID
# 广播蓝牙服务
bluetooth.advertise_service(
server_sock,
"ESP32-CAM-Receiver",
service_id=uuid,
service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS],
profiles=[bluetooth.SERIAL_PORT_PROFILE]
)
print(f"等待ESP32-CAM连接,端口: {port}...")
try:
while True:
client_sock, client_info = server_sock.accept()
print(f"已连接: {client_info}")
try:
# 接收图片大小信息 (4字节)
size_data = b''
while len(size_data) < 4:
chunk = client_sock.recv(4 - len(size_data))
if not chunk:
break
size_data += chunk
if len(size_data) != 4:
print("无效的图片大小信息")
continue
file_size = int.from_bytes(size_data, 'big')
print(f"即将接收图片大小: {file_size} 字节")
# 接收图片数据
received = 0
image_data = b''
start_time = time.time()
while received < file_size:
chunk = client_sock.recv(min(4096, file_size - received))
if not chunk:
break
image_data += chunk
received += len(chunk)
# 显示进度
progress = (received / file_size) * 100
print(f"接收进度: {progress:.1f}%", end='\r')
print(f"\n接收完成! 耗时: {time.time()-start_time:.2f}秒")
# 生成文件名
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"cam_image_{timestamp}.jpg"
filepath = os.path.join(save_dir, filename)
# 保存图片
with open(filepath, "wb") as img_file:
img_file.write(image_data)
print(f"图片已保存至: {filepath}")
# 验证图片完整性
try:
img = Image.open(filepath)
img.verify()
print("图片验证成功")
except Exception as e:
print(f"图片损坏: {str(e)}")
os.remove(filepath)
except Exception as e:
print(f"接收错误: {str(e)}")
finally:
client_sock.close()
print("连接已关闭,等待下一次连接...\n")
except KeyboardInterrupt:
print("\n程序已终止")
finally:
server_sock.close()
if __name__ == "__main__":
receive_bluetooth_image()
```
#### 关键功能说明:
1. **自动目录管理**
- 自动创建`received_images`目录存储图片
- 按时间戳生成唯一文件名(如`cam_image_20230815_143022.jpg`)
2. **可靠传输机制**
- 先接收4字节文件大小信息(大端序)
- 分块接收数据(4096字节/块)
- 实时显示传输进度
3. **图片完整性验证**
- 使用PIL库验证JPEG文件有效性
- 自动删除损坏图片
- 错误处理所有传输异常
4. **跨平台支持**
- 兼容Windows/Linux/macOS系统
- 使用标准蓝牙RFCOMM协议
- 自动广播SPP服务
#### 使用前准备:
1. 安装依赖库:
```bash
pip install pybluez pillow
```
(Linux系统需额外安装`libbluetooth-dev`)
2. 配对设备:
- 在电脑蓝牙设置中配对ESP32-CAM(默认PIN:1234)
- 脚本会自动检测配对设备
3. 运行脚本:
```bash
python bt_image_receiver.py
```
#### 高级功能扩展:
1. **自动重连**:添加断线自动重连机制
2. **实时预览**:使用OpenCV显示接收的图片
```python
import cv2
import numpy as np
# 在保存图片后添加:
img_array = np.frombuffer(image_data, dtype=np.uint8)
preview = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
cv2.imshow("Preview", preview)
cv2.waitKey(1)
```
3. **网络转发**:将图片自动上传到云存储
4. **元数据添加**:在图片EXIF中添加接收时间戳
阅读全文
相关推荐







#include "esp_camera.h" #include <WiFi.h> #include <WebServer.h> const char* ap_ssid = "ESP32-CAM-AP"; const char* ap_password = "12345678"; WebServer server(80); // 引脚定义(根据实际接线修改) #define PWDN_GPIO_NUM 32 #define RESET_GPIO_NUM -1 // 不使用复位引脚 #define XCLK_GPIO_NUM 0 #define SIOD_GPIO_NUM 26 // I2C SDA #define SIOC_GPIO_NUM 27 // I2C SCL #define Y9_GPIO_NUM 35 #define Y8_GPIO_NUM 34 #define Y7_GPIO_NUM 39 #define Y6_GPIO_NUM 36 #define Y5_GPIO_NUM 21 #define Y4_GPIO_NUM 19 #define Y3_GPIO_NUM 18 #define Y2_GPIO_NUM 5 #define VSYNC_GPIO_NUM 25 #define HREF_GPIO_NUM 23 #define PCLK_GPIO_NUM 22 void setup() { Serial.begin(115200); // 配置摄像头参数 camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; // 20MHz(OV2640支持10-24MHz) config.pixel_format = PIXFORMAT_JPEG; // 图像格式:JPEG/RGB565/YUV422等 // 分辨率配置(根据需求选择) config.frame_size = FRAMESIZE_VGA; // VGA(640x480)、QVGA(320x240)、CIF(352x288)等 config.jpeg_quality = 12; // JPEG质量(0-63,数值越小质量越高) config.fb_count = 1; // 帧缓冲数量(1-2) // 初始化摄像头 esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("摄像头初始化失败:%s\n", esp_err_to_name(err)); return; } // 检查传感器ID(确认连接正常) sensor_t *s = esp_camera_sensor_get(); if (s->id.PID != OV2640_PID) { // OV2640的PID通常为0x2640 Serial.println("未检测到OV2640传感器!"); return; } Serial.println("摄像头初始化成功!"); // 摄像头启动延迟 delay(500); // 单次WiFi初始化 WiFi.mode(WIFI_AP); if(!WiFi.softAP(ap_ssid, ap_password, 1, 0, 4)) { Serial.println("AP模式启动失败!"); } IPAddress IP = WiFi.softAPIP(); Serial.print("AP IP: "); Serial.println(IP); Serial.printf("连接数: %d\n", WiFi.softAPgetStationNum()); // Web路由 server.on("/", HTTP_GET, [](){ String html = "<html><head><meta name='viewport' content='width=device-width, initial-scale=1'>"; html += "<style>body{font-family:Arial;text-align:center;} button{padding:15px;font-size:20px;}</style></head>"; html += "<body>ESP32-CAM"; html += "<button>take photos</button>"; html += "<button>real-time video</button>"; html += "内存状态: " + String(ESP.getFreeHeap()) + " bytes"; html += "</body></html>"; server.send(200, "text/html", html); }); server.on("/capture", HTTP_GET, [](){ Serial.println("捕获请求"); // 捕获图像(保持原有代码不变) camera_fb_t *fb = NULL; for(int i=0; i<3; i++) { fb = esp_camera_fb_get(); if(fb != NULL && fb->len > 0) break; delay(100); } if (!fb || fb->len == 0) { Serial.println("捕获失败"); server.send(500, "text/plain", "Camera capture failed"); if(fb) esp_camera_fb_return(fb); return; } Serial.printf("捕获成功: %d bytes\n", fb->len); // 优化:合并响应头发送,避免重复的 Content-Length String responseHeaders = "Content-Type: image/jpeg\r\n"; responseHeaders += "Content-Length: " + String(fb->len) + "\r\n"; responseHeaders += "Cache-Control: no-cache, no-store, must-revalidate\r\n"; responseHeaders += "Pragma: no-cache\r\n"; responseHeaders += "Expires: 0\r\n"; // 使用 sendContent() 发送完整响应(包括头和内容) server.sendContent("HTTP/1.1 200 OK\r\n" + responseHeaders + "\r\n"); // 分块发送图像数据(保持原有代码不变) const size_t CHUNK_SIZE = 1024; uint8_t *ptr = fb->buf; size_t remaining = fb->len; while (remaining > 0) { size_t send_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE; server.sendContent((const char*)ptr, send_size); ptr += send_size; remaining -= send_size; } esp_camera_fb_return(fb); server.client().stop(); Serial.println("图像已发送"); }); server.begin(); } void loop() { server.handleClient(); // 定期内存检查 static uint32_t last_mem_check = 0; if(millis() - last_mem_check > 5000) { Serial.printf("空闲内存: %d bytes\n", ESP.getFreeHeap()); last_mem_check = millis(); } delay(2000); } 给以上代码增加输出1分钟 3.3V 10kHz 的pwm方波后,再进行拍照 ,其他一定不要变 参考:#include "esp_camera.h" #include <WiFi.h> #include <WebServer.h> #include <driver/ledc.h> // 修正1:更换PWM输出引脚(避免GPIO2) #define OUTPUT_PIN 12 // 改为GPIO12(确保未占用) #define FREQ 10000 #define DUTY_CYCLE 128 // 50%占空比(8位分辨率) #define CHANNEL LEDC_CHANNEL_0 #define TIMER LEDC_TIMER_0 #define RESOLUTION LEDC_TIMER_8_BIT const char* ap_ssid = "ESP32-CAM-AP"; const char* ap_password = "12345678"; // 新增全局变量 const uint32_t PWM_DURATION = 1 * 60 * 1000; // 10分钟(毫秒) bool pwmActive = false; uint32_t pwmStartTime = 0; WebServer server(80); // OV2640引脚配置 #define PWDN_GPIO_NUM 32 #define RESET_GPIO_NUM -1 #define XCLK_GPIO_NUM 0 #define SIOD_GPIO_NUM 26 #define SIOC_GPIO_NUM 27 #define Y9_GPIO_NUM 35 #define Y8_GPIO_NUM 34 #define Y7_GPIO_NUM 39 #define Y6_GPIO_NUM 36 #define Y5_GPIO_NUM 21 #define Y4_GPIO_NUM 19 #define Y3_GPIO_NUM 18 #define Y2_GPIO_NUM 5 #define VSYNC_GPIO_NUM 25 #define HREF_GPIO_NUM 23 #define PCLK_GPIO_NUM 22 void setup() { Serial.begin(115200); // PWM配置(修正引脚) ledc_timer_config_t timer_conf = { .speed_mode = LEDC_LOW_SPEED_MODE, .duty_resolution = RESOLUTION, .timer_num = TIMER, .freq_hz = FREQ, .clk_cfg = LEDC_AUTO_CLK }; ledc_timer_config(&timer_conf); ledc_channel_config_t channel_conf = { .gpio_num = OUTPUT_PIN, .speed_mode = LEDC_LOW_SPEED_MODE, .channel = CHANNEL, .intr_type = LEDC_INTR_DISABLE, .timer_sel = TIMER, .duty = 0, .hpoint = 0 }; ledc_channel_config(&channel_conf); // 在初始化PWM后,启动PWM输出 ledc_set_duty(LEDC_LOW_SPEED_MODE, CHANNEL, 128); // 50%占空比(因为8位分辨率,128/256=0.5) ledc_update_duty(LEDC_LOW_SPEED_MODE, CHANNEL); pwmStartTime = millis(); pwmActive = true; Serial.setDebugOutput(true); // 启用详细调试 // 初始化前设置PWDN引脚 pinMode(PWDN_GPIO_NUM, OUTPUT); digitalWrite(PWDN_GPIO_NUM, LOW); // 唤醒摄像头 // 摄像头配置 camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; config.pixel_format = PIXFORMAT_JPEG; // 内存优化配置 if(psramFound()){ config.frame_size = FRAMESIZE_VGA; config.jpeg_quality = 12; config.fb_count = 2; } else { config.frame_size = FRAMESIZE_SVGA; config.jpeg_quality = 10; config.fb_count = 1; } // 初始化摄像头 esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("摄像头初始化失败: 0x%x\n", err); // 详细错误处理 if(err == ESP_ERR_CAMERA_FAILED_TO_SET_FRAME_SIZE) { Serial.println("错误:无法设置分辨率"); } return; } // 摄像头启动延迟 delay(500); // 单次WiFi初始化 WiFi.mode(WIFI_AP); if(!WiFi.softAP(ap_ssid, ap_password, 1, 0, 4)) { Serial.println("AP模式启动失败!"); } IPAddress IP = WiFi.softAPIP(); Serial.print("AP IP: "); Serial.println(IP); Serial.printf("连接数: %d\n", WiFi.softAPgetStationNum()); // Web路由 server.on("/", HTTP_GET, [](){ String html = "<html><head><meta name='viewport' content='width=device-width, initial-scale=1'>"; html += "<style>body{font-family:Arial;text-align:center;} button{padding:15px;font-size:20px;}</style></head>"; html += "<body>ESP32-CAM"; html += "<button>take photos</button>"; html += "<button>real-time video</button>"; html += "内存状态: " + String(ESP.getFreeHeap()) + " bytes"; html += "</body></html>"; server.send(200, "text/html", html); }); server.on("/capture", HTTP_GET, [](){ // 检查PWM是否还在输出 if (pwmActive) { server.send(503, "text/plain", "Camera not ready: PWM is still active (wait 10 minutes after power-on)"); return; } Serial.println("捕获请求"); // 捕获图像(保持原有代码不变) camera_fb_t *fb = NULL; for(int i=0; i<3; i++) { fb = esp_camera_fb_get(); if(fb != NULL && fb->len > 0) break; delay(100); } if (!fb || fb->len == 0) { Serial.println("捕获失败"); server.send(500, "text/plain", "Camera capture failed"); if(fb) esp_camera_fb_return(fb); return; } Serial.printf("捕获成功: %d bytes\n", fb->len); // 优化:合并响应头发送,避免重复的 Content-Length String responseHeaders = "Content-Type: image/jpeg\r\n"; responseHeaders += "Content-Length: " + String(fb->len) + "\r\n"; responseHeaders += "Cache-Control: no-cache, no-store, must-revalidate\r\n"; responseHeaders += "Pragma: no-cache\r\n"; responseHeaders += "Expires: 0\r\n"; // 使用 sendContent() 发送完整响应(包括头和内容) server.sendContent("HTTP/1.1 200 OK\r\n" + responseHeaders + "\r\n"); // 分块发送图像数据(保持原有代码不变) const size_t CHUNK_SIZE = 1024; uint8_t *ptr = fb->buf; size_t remaining = fb->len; while (remaining > 0) { size_t send_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE; server.sendContent((const char*)ptr, send_size); ptr += send_size; remaining -= send_size; } esp_camera_fb_return(fb); server.client().stop(); Serial.println("图像已发送"); }); server.begin(); } void loop() { // 检查PWM是否已经输出满10分钟 if (pwmActive && (millis() - pwmStartTime >= 60000)) { // 10分钟=600000毫秒 // 停止PWM:设置占空比为0 ledc_set_duty(LEDC_LOW_SPEED_MODE, CHANNEL, 0); ledc_update_duty(LEDC_LOW_SPEED_MODE, CHANNEL); pwmActive = false; // 标记停止 Serial.println("PWM output stopped after 10 minutes."); } server.handleClient(); // 定期内存检查 static uint32_t last_mem_check = 0; if(millis() - last_mem_check > 5000) { Serial.printf("空闲内存: %d bytes\n", ESP.getFreeHeap()); last_mem_check = millis(); } }

为什么这个代码可以实现摄像头拍照:#include "esp_camera.h" #include <WiFi.h> #include <WebServer.h> const char* ap_ssid = "ESP32-CAM-AP"; const char* ap_password = "12345678"; WebServer server(80); // 引脚定义(根据实际接线修改) #define PWDN_GPIO_NUM 32 #define RESET_GPIO_NUM -1 // 不使用复位引脚 #define XCLK_GPIO_NUM 0 #define SIOD_GPIO_NUM 26 // I2C SDA #define SIOC_GPIO_NUM 27 // I2C SCL #define Y9_GPIO_NUM 35 #define Y8_GPIO_NUM 34 #define Y7_GPIO_NUM 39 #define Y6_GPIO_NUM 36 #define Y5_GPIO_NUM 21 #define Y4_GPIO_NUM 19 #define Y3_GPIO_NUM 18 #define Y2_GPIO_NUM 5 #define VSYNC_GPIO_NUM 25 #define HREF_GPIO_NUM 23 #define PCLK_GPIO_NUM 22 void setup() { Serial.begin(115200); // 配置摄像头参数 camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; // 20MHz(OV2640支持10-24MHz) config.pixel_format = PIXFORMAT_JPEG; // 图像格式:JPEG/RGB565/YUV422等 // 分辨率配置(根据需求选择) config.frame_size = FRAMESIZE_VGA; // VGA(640x480)、QVGA(320x240)、CIF(352x288)等 config.jpeg_quality = 12; // JPEG质量(0-63,数值越小质量越高) config.fb_count = 1; // 帧缓冲数量(1-2) // 初始化摄像头 esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("摄像头初始化失败:%s\n", esp_err_to_name(err)); return; } // 检查传感器ID(确认连接正常) sensor_t *s = esp_camera_sensor_get(); if (s->id.PID != OV2640_PID) { // OV2640的PID通常为0x2640 Serial.println("未检测到OV2640传感器!"); return; } Serial.println("摄像头初始化成功!"); // 摄像头启动延迟 delay(500); // 单次WiFi初始化 WiFi.mode(WIFI_AP); if(!WiFi.softAP(ap_ssid, ap_password, 1, 0, 4)) { Serial.println("AP模式启动失败!"); } IPAddress IP = WiFi.softAPIP(); Serial.print("AP IP: "); Serial.println(IP); Serial.printf("连接数: %d\n", WiFi.softAPgetStationNum()); // Web路由 server.on("/", HTTP_GET, [](){ String html = "<html><head><meta name='viewport' content='width=device-width, initial-scale=1'>"; html += "<style>body{font-family:Arial;text-align:center;} button{padding:15px;font-size:20px;}</style></head>"; html += "<body>ESP32-CAM"; html += "<button>take photos</button>"; html += "<button>real-time video</button>"; html += "内存状态: " + String(ESP.getFreeHeap()) + " bytes"; html += "</body></html>"; server.send(200, "text/html", html); }); server.on("/capture", HTTP_GET, [](){ Serial.println("捕获请求"); // 捕获图像(保持原有代码不变) camera_fb_t *fb = NULL; for(int i=0; i<3; i++) { fb = esp_camera_fb_get(); if(fb != NULL && fb->len > 0) break; delay(100); } if (!fb || fb->len == 0) { Serial.println("捕获失败"); server.send(500, "text/plain", "Camera capture failed"); if(fb) esp_camera_fb_return(fb); return; } Serial.printf("捕获成功: %d bytes\n", fb->len); // 优化:合并响应头发送,避免重复的 Content-Length String responseHeaders = "Content-Type: image/jpeg\r\n"; responseHeaders += "Content-Length: " + String(fb->len) + "\r\n"; responseHeaders += "Cache-Control: no-cache, no-store, must-revalidate\r\n"; responseHeaders += "Pragma: no-cache\r\n"; responseHeaders += "Expires: 0\r\n"; // 使用 sendContent() 发送完整响应(包括头和内容) server.sendContent("HTTP/1.1 200 OK\r\n" + responseHeaders + "\r\n"); // 分块发送图像数据(保持原有代码不变) const size_t CHUNK_SIZE = 1024; uint8_t *ptr = fb->buf; size_t remaining = fb->len; while (remaining > 0) { size_t send_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE; server.sendContent((const char*)ptr, send_size); ptr += send_size; remaining -= send_size; } esp_camera_fb_return(fb); server.client().stop(); Serial.println("图像已发送"); }); server.begin(); } void loop() { server.handleClient(); // 定期内存检查 static uint32_t last_mem_check = 0; if(millis() - last_mem_check > 5000) { Serial.printf("空闲内存: %d bytes\n", ESP.getFreeHeap()); last_mem_check = millis(); } delay(2000); } 而下面这个代码就增加了输出pwm方波就捕获失败,无法获取图片:#include "esp_camera.h" #include <WiFi.h> #include <WebServer.h> #include <driver/ledc.h> const char* ap_ssid = "ESP32-CAM-AP"; const char* ap_password = "12345678"; // PWM配置 #define OUTPUT_PIN 2 // 使用GPIO2(板载LED引脚) #define CHANNEL LEDC_CHANNEL_0 #define FREQ 10000 // 10kHz #define RESOLUTION LEDC_TIMER_10_BIT #define DUTY_CYCLE (512) // 50%占空比 (1024 * 0.5) #define TIMER LEDC_TIMER_0 // 新增全局变量 const uint32_t PWM_DURATION = 1 * 60 * 1000; // 10分钟(毫秒) bool pwmActive = false; uint32_t pwmStartTime = 0; WebServer server(80); // 引脚定义(根据实际接线修改) #define PWDN_GPIO_NUM 32 #define RESET_GPIO_NUM -1 // 不使用复位引脚 #define XCLK_GPIO_NUM 0 #define SIOD_GPIO_NUM 26 // I2C SDA #define SIOC_GPIO_NUM 27 // I2C SCL #define Y9_GPIO_NUM 35 #define Y8_GPIO_NUM 34 #define Y7_GPIO_NUM 39 #define Y6_GPIO_NUM 36 #define Y5_GPIO_NUM 21 #define Y4_GPIO_NUM 19 #define Y3_GPIO_NUM 18 #define Y2_GPIO_NUM 5 #define VSYNC_GPIO_NUM 25 #define HREF_GPIO_NUM 23 #define PCLK_GPIO_NUM 22 void setup() { Serial.begin(115200); // PWM配置(修正引脚) ledc_timer_config_t timer_conf = { .speed_mode = LEDC_LOW_SPEED_MODE, .duty_resolution = RESOLUTION, .timer_num = TIMER, .freq_hz = FREQ, .clk_cfg = LEDC_AUTO_CLK }; ledc_timer_config(&timer_conf); ledc_channel_config_t channel_conf = { .gpio_num = OUTPUT_PIN, .speed_mode = LEDC_LOW_SPEED_MODE, .channel = CHANNEL, .intr_type = LEDC_INTR_DISABLE, .timer_sel = TIMER, .duty = 0, .hpoint = 0 }; ledc_channel_config(&channel_conf); // 在初始化PWM后,启动PWM输出 ledc_set_duty(LEDC_LOW_SPEED_MODE, CHANNEL, 128); // 50%占空比(因为8位分辨率,128/256=0.5) ledc_update_duty(LEDC_LOW_SPEED_MODE, CHANNEL); pwmStartTime = millis(); pwmActive = true; // 配置摄像头参数 camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; // 20MHz(OV2640支持10-24MHz) config.pixel_format = PIXFORMAT_JPEG; // 图像格式:JPEG/RGB565/YUV422等 // 分辨率配置(根据需求选择) config.frame_size = FRAMESIZE_VGA; // VGA(640x480)、QVGA(320x240)、CIF(352x288)等 config.jpeg_quality = 12; // JPEG质量(0-63,数值越小质量越高) config.fb_count = 1; // 帧缓冲数量(1-2) // 初始化摄像头 esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("摄像头初始化失败:%s\n", esp_err_to_name(err)); return; } // 检查传感器ID(确认连接正常) sensor_t *s = esp_camera_sensor_get(); if (s->id.PID != OV2640_PID) { // OV2640的PID通常为0x2640 Serial.println("未检测到OV2640传感器!"); return; } Serial.println("摄像头初始化成功!"); // 摄像头启动延迟 delay(500); // 单次WiFi初始化 WiFi.mode(WIFI_AP); if(!WiFi.softAP(ap_ssid, ap_password, 1, 0, 4)) { Serial.println("AP模式启动失败!"); } IPAddress IP = WiFi.softAPIP(); Serial.print("AP IP: "); Serial.println(IP); Serial.printf("连接数: %d\n", WiFi.softAPgetStationNum()); // Web路由 server.on("/", HTTP_GET, [](){ String html = "<html><head><meta name='viewport' content='width=device-width, initial-scale=1'>"; html += "<style>body{font-family:Arial;text-align:center;} button{padding:15px;font-size:20px;}</style></head>"; html += "<body>ESP32-CAM"; html += "<button>take photos</button>"; html += "<button>real-time video</button>"; html += "内存状态: " + String(ESP.getFreeHeap()) + " bytes"; html += "</body></html>"; server.send(200, "text/html", html); }); server.on("/capture", HTTP_GET, [](){ // 检查PWM是否还在输出 if (pwmActive) { server.send(503, "text/plain", "Camera not ready: PWM is still active (wait 10 minutes after power-on)"); return; } Serial.println("捕获请求"); // 捕获图像(保持原有代码不变) camera_fb_t *fb = NULL; for(int i=0; i<3; i++) { fb = esp_camera_fb_get(); if(fb != NULL && fb->len > 0) break; delay(100); } if (!fb || fb->len == 0) { Serial.println("捕获失败"); server.send(500, "text/plain", "Camera capture failed"); if(fb) esp_camera_fb_return(fb); return; } Serial.printf("捕获成功: %d bytes\n", fb->len); // 优化:合并响应头发送,避免重复的 Content-Length String responseHeaders = "Content-Type: image/jpeg\r\n"; responseHeaders += "Content-Length: " + String(fb->len) + "\r\n"; responseHeaders += "Cache-Control: no-cache, no-store, must-revalidate\r\n"; responseHeaders += "Pragma: no-cache\r\n"; responseHeaders += "Expires: 0\r\n"; // 使用 sendContent() 发送完整响应(包括头和内容) server.sendContent("HTTP/1.1 200 OK\r\n" + responseHeaders + "\r\n"); // 分块发送图像数据(保持原有代码不变) const size_t CHUNK_SIZE = 1024; uint8_t *ptr = fb->buf; size_t remaining = fb->len; while (remaining > 0) { size_t send_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE; server.sendContent((const char*)ptr, send_size); ptr += send_size; remaining -= send_size; } esp_camera_fb_return(fb); server.client().stop(); Serial.println("图像已发送"); }); server.begin(); } void loop() { // 检查PWM是否已经输出满10分钟 if (pwmActive && (millis() - pwmStartTime >= 60000)) { // 10分钟=600000毫秒 // 停止PWM:设置占空比为0 ledc_set_duty(LEDC_LOW_SPEED_MODE, CHANNEL, 0); ledc_update_duty(LEDC_LOW_SPEED_MODE, CHANNEL); pwmActive = false; // 标记停止 Serial.println("PWM output stopped after 10 minutes."); } server.handleClient(); // 定期内存检查 static uint32_t last_mem_check = 0; if(millis() - last_mem_check > 5000) { Serial.printf("空闲内存: %d bytes\n", ESP.getFreeHeap()); last_mem_check = millis(); } delay(2000); } 为什么











