AllinToyou

这个屌丝很懒，什么也没留下！

热门标签

ESP32使用笔记_esp32 c3等待上电同步

作者：AllinToyou | 2024-04-10 10:51:17

踩

esp32 c3等待上电同步

说点什么吧
ESP32C3使用的是合宙公司的产品，主要原因就是9.9一片，尼玛就相当于白嫖，还能跑Luatos,之后趋势吧。
合宙CORE ESP32-C3核心板，是一款基于乐鑫ESP32-C3所设计的开发板，其体型小巧仅为21mm×51mm，它采用邮票孔设计，可直接嵌入开发板上来使用。该核心板支持UART、GPIO、SPI、I2C、ADC、PWM等接口，并板载 Wi-Fi/BLE天线以便于开发者在不同场景下使用。
该核心板的外观如图1所示，其引脚及分布见图2所示。
在这里插入图片描述

图1 开发板外观
在这里插入图片描述

3.ESP32-WROOM

在这里插入图片描述

这里很重要

GPIO 6-11 连接到SPI Flash。
GPIO 34-39 只能作为输入且没有内部上拉，其他的可以作为输入或者输出。
GPIO 20, 24, 28, 29, 30, 31 不对外开放。
GPIO 32，33默认连接到RTC域。可能需要如下设置：
1
2
3
4

4.ESP32-xiao

在这里插入图片描述
https://www.seeedstudio.com/Seeed-XIAO-ESP32C3-p-5431.html

一、开发环境

1.arduino ide

使用arduino开发是最方便的，而且开发周期较短，最主要是的是有大量的支持库
https://blog.csdn.net/a1415539404a/article/details/124534428
可以看看这个老哥写的，很详细了。最重要的是要选择
使用注意事项（第3条）：
IO12（GPIO12）、IO13（GPIO13）在QIO模式下为SPI信号SPIHD和SPIWP复用，为了增加可用GPIO数量，开发板选择采用2线SPI的DIO模式，IO12、IO13并未连接flash，使用自己编译的软件时需要注意配置flash为DIO模式。

![在这里插入图片描述](https://img-blog.csdnimg.cn/513d3a9220c84018b9ae65e7766d6a2f.png

2.MicroPython

固件从这个里面下载，配置如图
https://www.micropython.org/download/esp32c3/

下载最新的就行
在这里插入图片描述

在这一步这里，先点击擦除后会显示“等待上电同步”，之后我们按下板子上的BOOT键1S，进入下载程序模式，就可以了，下面下载固件操作也需要

在这里插入图片描述

升级完成后需要重新拔插一下 TPYE-C 线复位一下开发板，即可使用。

二.程序实战

1.UDP通讯（任意IP）

#include <WiFi.h>
#include <WiFiUdp.h> //引用以使用UDP

const char *ssid = "ESP82666";
const char *password = "12345678";

WiFiUDP Udp;                      //创建UDP对象
unsigned int localUdpPort = 2333; //本地端口号

void setup()
{
  Serial.begin(115200);
  Serial.println();

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (!WiFi.isConnected())
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Connected");
  Serial.print("IP Address:");
  Serial.println(WiFi.localIP());

  Udp.begin(localUdpPort); //启用UDP监听以接收数据
}

void loop()
{
  int packetSize = Udp.parsePacket(); //获取当前队首数据包长度
  if (packetSize)                     //如果有数据可用
  {
    char buf[packetSize];
    Udp.read(buf, packetSize); //读取当前包数据

    Serial.println();
    Serial.print("Received: ");
    Serial.println(buf);
    Serial.print("From IP: ");
    Serial.println(Udp.remoteIP());
    Serial.print("From Port: ");
    Serial.println(Udp.remotePort());

    Udp.beginPacket("192.168.137.122", 5678); //准备发送数据
    Udp.print("Received: ");    //复制数据到发送缓存
    Udp.write((const uint8_t*)buf, packetSize); //复制数据到发送缓存
    Udp.endPacket();            //发送数据
  }
}
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
45
46
47
48
49
50

2.DUP(AP)

#include <WiFi.h>  //wifi功能需要的库

WiFiUDP Udp;//声明UDP对象

const char* wifi_SSID="ESP32_Udp";  //存储AP的名称信息
const char* wifi_Password="ESP32_1234";  //存储AP的密码信息

uint16_t udp_port=1122;  //存储需要监听的端口号

char incomingPacket[255];  //存储Udp客户端发过来的数据

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);  //开启串口，波特率为115200
  
  WiFi.mode(WIFI_AP);                         //设置为AP模式
  WiFi.softAP(ssid, password);                //配置AP信息，并开启AP
  
  IPAddress softLocal(192,168,1,1);           //IP地址，用以设置IP第4字段
  IPAddress softGateway(192,168,1,1);         //IP网关，用以设置IP第3字段
  IPAddress softSubnet(255,255,255,0);
  //配置自定义的IP信息
  WiFi.softAPConfig(softLocal, softGateway, softSubnet);  
  IPAddress IP = WiFi.softAPIP();           //用变量IP接收AP当前的IP地址
  Serial.println(IP);                       //打印输出IP的IP地址

  Udp.begin(udp_port);//启动UDP监听这个端口
}

void loop() {
  // put your main code here, to run repeatedly:

  /*接收发送过来的Udp数据*/
  int Data_length=Udp.parsePacket();  //获取接收的数据的长度
  if(Data_length)  //如果有数据那么Data_length不为0，无数据Data_length为0
  {
    int len = Udp.read(incomingPacket, 255);  //读取数据，将数据保存在数组incomingPacket中
    if (len > 0)  //为了避免获取的数据后面乱码做的判断
    {
      incomingPacket[len] = 0;
    }
    Serial.print(incomingPacket);
    if(incomingPacket[0]=='E'){Serial.println("E");}
    if(incomingPacket[0]=='A'){Serial.println("A");}
    if(incomingPacket[0]=='B'){Serial.println("B");}
    if(incomingPacket[0]=='C'){Serial.println("C");}
  }
}

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
45
46
47
48
49

2.1

#include <ESP8266WiFi.h>  
#include <WiFiUdp.h> //引用以使用UDP

const char* wifi_SSID="ESP";  //存储AP的名称信息
const char* wifi_Password="12345678";  //存储AP的密码信息

uint16_t udp_port=2333;  //存储需要监听的端口号

char incomingPacket[255];  //存储Udp客户端发过来的数据

void setup()
{
  Serial.begin(115200);
  Serial.println();

  WiFi.mode(WIFI_AP);                         //设置为AP模式
  WiFi.softAP(wifi_SSID, wifi_Password);                //配置AP信息，并开启AP
  
  IPAddress softLocal(192,168,4,1);           //IP地址，用以设置IP第4字段
  IPAddress softGateway(192,168,4,1);         //IP网关，用以设置IP第3字段
  IPAddress softSubnet(255,255,255,0);
  //配置自定义的IP信息
  WiFi.softAPConfig(softLocal, softGateway, softSubnet);  
  IPAddress IP = WiFi.softAPIP();           //用变量IP接收AP当前的IP地址
  Serial.println(IP);                       //打印输出IP的IP地址

  Udp.begin(udp_port);//启动UDP监听这个端口

}

void loop()
{
  /*接收发送过来的Udp数据*/
  int Data_length=Udp.parsePacket();  //获取接收的数据的长度
  if(Data_length)  //如果有数据那么Data_length不为0，无数据Data_length为0
  {
    int len = Udp.read(incomingPacket, 255);  //读取数据，将数据保存在数组incomingPacket中
    if (len > 0)  //为了避免获取的数据后面乱码做的判断
    {
      incomingPacket[len] = 0;
    }
    Serial.print(incomingPacket);
  }

}
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
45

3.DUP(STP)

#include <WiFi.h>  //wifi功能需要的库

WiFiUDP Udp;//声明UDP对象

const char* wifi_SSID="ESP32";  //存储AP的名称信息
const char* wifi_Password="12345678";  //存储AP的密码信息

uint16_t udp_port=1122;  //存储需要监听的端口号

char incomingPacket[255];  //存储Udp客户端发过来的数据

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);  //开启串口，波特率为115200
  
  WiFi.softAP(wifi_SSID,wifi_Password);  //打开ESP32热点

  Serial.print("\n开发板IP地址为：");
  Serial.print(WiFi.softAPIP());  //串口输出模块IP地址

  Udp.begin(udp_port);//启动UDP监听这个端口
}

void loop() {
  // put your main code here, to run repeatedly:
udp();

}
void udp(){
  /*接收发送过来的Udp数据*/
  int Data_length=Udp.parsePacket();  //获取接收的数据的长度
  if(Data_length)  //如果有数据那么Data_length不为0，无数据Data_length为0
  {
    int len = Udp.read(incomingPacket, 255);  //读取数据，将数据保存在数组incomingPacket中
    if (len > 0)  //为了避免获取的数据后面乱码做的判断
    {
      incomingPacket[len] = 0;
    }
    /*将接受到的数据发送回去*/

    Serial.print(String(incomingPacket));
    if(String(incomingPacket)=="B1C2" or String(incomingPacket)=="C2B1"){Serial.println("启动+驻车取消");}
    if(String(incomingPacket)=="H"){Serial.println("A");}
    if(String(incomingPacket)=="F"){Serial.println("B");}
    if(String(incomingPacket)=="E"){Serial.println("C");}
  }
  }
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
45
46
47

2.ESP NOW

先说一下ESP-NOW，它是Espressif开发的一种协议，它使多个设备无需使用Wi-Fi即可相互通信。该协议类似于低功率的2.4GHz无线连接。设备之间需要进行配对，然后才能进行通信。配对完成后，连接安全且点对点，无需握手。”这意味着在将设备彼此配对后，连接将保持不变。换句话说，如果您的一块板突然断电或重置，则在重新启动时，它将自动连接到其对等端以继续通信。
简而言之，ESP-NOW是一种快速通信协议，可用于在ESP8266板之间交换小消息（最大250字节）。

ESP-NOW有多种用途

可以在不同的设置中进行单向或双向通信
一个 主 ESP8266向多个ESP8266 从 发送数据
一块ESP8266板向不同的ESP8266板发送相同或不同的命令。此配置是构建遥控器之类的理想选择
一个ESP8266从站从多个主站接收数据
如果要将多个传感器节点的数据收集到一个ESP8266板中，则此配置非常理想
ESP-NOW双向通讯
使用ESP-NOW，每个板可以同时是发送者和接收者。因此，您可以在板之间建立双向通信。
1
2
3
4
5
6
7

总而言之，ESP-NOW是构建网络的理想选择，在该网络中，您可以有多个ESP8266板相互交换数据，这篇只是测试单方向的发送数据和接受数据

1.接收端MAC地址获取

#include <ESP8266WiFi.h>
 
void setup()
{
  Serial.begin(115200);//设置串口波特率为115200
  WiFi.mode(WIFI_STA);//设置WiFi模式为STA，这里要与之后使用的模式相对应
}
 
void loop()
{
  //每隔一秒钟打印一次MAC地址
  Serial.println(WiFi.macAddress());
  delay(1000);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.ESP32发送

#include <esp_now.h>
#include <WiFi.h>

// 接收端的MAC地址
uint8_t broadcastAddress[] = {0xC4, 0x5B, 0xBE, 0x42, 0x25, 0x6C};//C4:5B:BE:42:25:6C

// 发送结构体类型
typedef struct struct_message {
  char a[32];
  int b;
  float c;
  bool d;
} struct_message;

// 创建一个结构体变量
struct_message myData;

// 回调函数,函数将在发送消息时执行。此函数告诉我们信息是否成功发送;
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}
 
void setup() {
  // 初始化串口波特率
  Serial.begin(115200);
 
  // 设置WIFI模式为STA模式，即无线终端
  WiFi.mode(WIFI_STA);

  //  初始化ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

 //注册回调函数
  esp_now_register_send_cb(OnDataSent);
  
  // 注册通信频道
  esp_now_peer_info_t peerInfo;
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  //通道
  peerInfo.encrypt = false;//是否加密为False
         
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
}
 
void loop() {
  //设置要发送的值
  strcpy(myData.a, "THIS IS A CHAR");
  myData.b = random(1,20);
  myData.c = 1.2;
  myData.d = false;
  
  //发送信息到指定ESP32上
  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
   
 //判断是否发送成功
  if (result == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  delay(2000);
}

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

3.ESP8266接受

//接收
#include <ESP8266WiFi.h>
#include <espnow.h>
 
//接收数据保存的结构体和发送方一致
typedef struct struct_message {
    char a[32];
    int b;
    float c;
    bool d;
} struct_message;
 
//创建结构体变量
struct_message myData;
 
//创建一个回调函数作为接收数据后的串口显示
void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("Char: ");
  Serial.println(myData.a);
  Serial.print("Int: ");
  Serial.println(myData.b);
  Serial.print("Float: ");
  Serial.println(myData.c);
  Serial.print("Bool: ");
  Serial.println(myData.d);
  Serial.println();
}
 
void setup() {
  //初始化窗口
  Serial.begin(115200);
  
  //设置ESP8266模式
  WiFi.mode(WIFI_STA);
 
  //初始化 ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  //设置ESP8266角色：
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  //先前创建的功能 测试ESP-NOW通信
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop(){
  
  
}
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
45
46
47
48
49
50
51
52
53
54

3.DS18B20

#include <OneWire.h>
#include <DallasTemperature.h>
 
 
// 定义DS18B20数据口连接ESP32的4号IO上
#define ONE_WIRE_BUS D7
 
// 初始连接在单总线上的单总线设备
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
 
void setup(void)
{
  // 设置串口通信波特率
  Serial.begin(9600);
  Serial.println("Dallas Temperature IC Control Library Demo");
  // 初始库
  pinMode(D7, INPUT_PULLUP);  
  sensors.begin();
}
 
void loop(void)
{
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures(); // 发送命令获取温度
  Serial.println("DONE");
   
  Serial.print("Temperature for the device 1 (index 0) is: ");
  Serial.println(sensors.getTempCByIndex(0));
  delay(500); 
}
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

4.HardwareSerial库（串口映射库）

#include <HardwareSerial.h>    //导入ESP32串口操作库,使用这个库我们可以把串口映射到其他的引脚上使用

//我们测试需要用到的串口，ESP32一共有3个串口，串口0应该是用于程序烧写和打印输出调试用的，所以我们只用1和2
HardwareSerial MySerial_stm32(1);  

void setup() {
  Serial.begin(115200);
  //串口的开启，这里还可以传一些别的参数，但是我们只传入下面四个最重要的：波特率，默认SERIAL_8N1为8位数据位、无校验、1位停止位，后面两个分别为 RXD,TXD 引脚
  MySerial_stm32.begin(115200, SERIAL_8N1, 14, 2);

  //MySerial_stm32.updateBaudRate(9600);  //重新设置波特率；
  //MySerial_stm32.end();  //失能串口，释放占用的资源
}

void loop() {
  MySerial_stm32.println("usart test!!!");
  delay(1000);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.josn（结构体）

发送

#include <ArduinoJson.h>
void setup()
{
    // 初始化串口
    Serial.begin(9600);
}
void loop() {
    /* 构建JSON */
    StaticJsonDocument<200> jsonBuffer;   //声明一个JsonDocument对象，长度200

    /* 构建JSON的另外一种方法 */
    DynamicJsonDocument doc(200);       // 声明对象的另外一种方法，和上面的 StaticJsonDocument<200> jsonBuffer 一样
    char string[100] = {"{\"time1\":45,\"time2\":420,\"time3\":863}"};  // 声明一个JSON数据
    obj["time1"] = 123;          // 修改原来的值 
    obj["add"] = 123;               // 添加新对象 
    deserializeJson(doc, string);       
    JsonObject obj = doc.as<JsonObject>(); 
    // 输出结果：打印构建好的JSON数据
    String output2;
    serializeJson(doc, output2);    // 序列化JSON数据并导出字符串
    Serial.println(output2);        // 串口打印最后输出的字符串
    delay(1000);
}

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

接收

    StaticJsonDocument<200> jsonBuffer2; //声明一个JsonDocument对象，长度200
    // 声明一个JSON数据，用作测试
    // 反序列化JSON
    DeserializationError error = deserializeJson(jsonBuffer2, comdata_ble);
    if (error) 
    {
        Serial.print(F("deserializeJson() failed: "));
        Serial.println(error.f_str());
        return;
    }
    // 解析JSON
    long data1 = jsonBuffer2["time1"];              // 读取整形数据
    long data2 = jsonBuffer2["time2"];              // 读取整形数据
    long data3 = jsonBuffer2["time3"];              // 读取整形数据
    // 输出结果：打印解析后的值
    Serial.println(data1);      
    Serial.println(data2);
    Serial.println(data3);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.esp32 cam

1.STA模式

#include "esp_camera.h"
#include <WiFi.h>

#define CAMERA_MODEL_AI_THINKER // Has PSRAM

#include "camera_pins.h"

// ===========================
// Enter your WiFi credentials
// ===========================
const char *ssid = "ESP82666";
const char *password = "12345678";
//*********设置固定IP*************//
IPAddress local_IP(192, 168, 137, 184);
// Set your Gateway IP address
IPAddress gateway(192, 168, 137, 1);
IPAddress subnet(255, 255, 0, 0);
IPAddress primaryDNS(8, 8, 8, 8); //optional
IPAddress secondaryDNS(8, 8, 4, 4); //optional
void startCameraServer();

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  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.frame_size = FRAMESIZE_UXGA;
  config.pixel_format = PIXFORMAT_JPEG; // for streaming
  //config.pixel_format = PIXFORMAT_RGB565; // for face detection/recognition
  config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
  config.fb_location = CAMERA_FB_IN_PSRAM;
  config.jpeg_quality = 12;
  config.fb_count = 1;
  
  // if PSRAM IC present, init with UXGA resolution and higher JPEG quality
  //                      for larger pre-allocated frame buffer.
  if(config.pixel_format == PIXFORMAT_JPEG){
    if(psramFound()){
      config.jpeg_quality = 10;
      config.fb_count = 2;
      config.grab_mode = CAMERA_GRAB_LATEST;
    } else {
      // Limit the frame size when PSRAM is not available
      config.frame_size = FRAMESIZE_SVGA;
      config.fb_location = CAMERA_FB_IN_DRAM;
    }
  } else {
    // Best option for face detection/recognition
    config.frame_size = FRAMESIZE_240X240;
#if CONFIG_IDF_TARGET_ESP32S3
    config.fb_count = 2;
#endif
  }

#if defined(CAMERA_MODEL_ESP_EYE)
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
#endif

  // camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

  sensor_t * s = esp_camera_sensor_get();
  // initial sensors are flipped vertically and colors are a bit saturated
  if (s->id.PID == OV3660_PID) {
    s->set_vflip(s, 1); // flip it back
    s->set_brightness(s, 1); // up the brightness just a bit
    s->set_saturation(s, -2); // lower the saturation
  }
  // drop down frame size for higher initial frame rate
  if(config.pixel_format == PIXFORMAT_JPEG){
    s->set_framesize(s, FRAMESIZE_QVGA);
  }

#if defined(CAMERA_MODEL_M5STACK_WIDE) || defined(CAMERA_MODEL_M5STACK_ESP32CAM)
  s->set_vflip(s, 1);
  s->set_hmirror(s, 1);
#endif

#if defined(CAMERA_MODEL_ESP32S3_EYE)
  s->set_vflip(s, 1);
#endif

if(!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
  Serial.println("STA Failed to configure");
}
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (!WiFi.isConnected())
  {
    delay(500);
    Serial.print(".");
  }
  startCameraServer();

  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}

void loop() {
  // Do nothing. Everything is done in another task by the web server
  delay(10000);
}
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

2.AT模式

#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "esp_http_server.h"

// 视频传输 http://192.168.xx.xx/ 
//Replace with your network credentials

const char *ssid = "OPENMV_AP";
const char *password = "12345678";

char incomingPacket[255];  //存储Udp客户端发过来的数据
#define PART_BOUNDARY "123456789000000000000987654321"

// This project was tested with the AI Thinker Model, M5STACK PSRAM Model and M5STACK WITHOUT PSRAM
#define CAMERA_MODEL_AI_THINKER
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WITHOUT_PSRAM

// Not tested with this model
//#define CAMERA_MODEL_WROVER_KIT


  #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


static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

httpd_handle_t stream_httpd = NULL;

static esp_err_t stream_handler(httpd_req_t *req){
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len = 0;
  uint8_t * _jpg_buf = NULL;
  char * part_buf[64];

  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if(res != ESP_OK){
    return res;
  }

  while(true){
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      res = ESP_FAIL;
    } else {
      if(fb->width > 400){
        if(fb->format != PIXFORMAT_JPEG){
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if(!jpeg_converted){
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        } else {
          _jpg_buf_len = fb->len;
          _jpg_buf = fb->buf;
        }
      }
    }
    if(res == ESP_OK){
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if(fb){
      esp_camera_fb_return(fb);
      fb = NULL;
      _jpg_buf = NULL;
    } else if(_jpg_buf){
      free(_jpg_buf);
      _jpg_buf = NULL;
    }
    if(res != ESP_OK){
      break;
    }
    //Serial.printf("MJPG: %uB\n",(uint32_t)(_jpg_buf_len));
  }
  return res;
}

void startCameraServer(){
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = 80;

  httpd_uri_t index_uri = {
    .uri       = "/",
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };
  
  //Serial.printf("Starting web server on port: '%d'\n", config.server_port);
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &index_uri);
  }
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector

  Serial.begin(115200);
  Serial.setDebugOutput(false);
  pinMode(4,OUTPUT); //将8号引脚设置为输出模式
  digitalWrite(4,1);//8号引脚输出高电平
  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_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  // Wi-Fi connection
  WiFi.mode(WIFI_AP);                         //设置为AP模式
  WiFi.softAP(ssid, password);                //配置AP信息，并开启AP
  
  IPAddress softLocal(192,168,4,1);           //IP地址，用以设置IP第4字段
  IPAddress softGateway(192,168,4,1);         //IP网关，用以设置IP第3字段
  IPAddress softSubnet(255,255,255,0);
  //配置自定义的IP信息
  WiFi.softAPConfig(softLocal, softGateway, softSubnet);  
  IPAddress IP = WiFi.softAPIP();           //用变量IP接收AP当前的IP地址
  Serial.println(IP);                       //打印输出IP的IP地址

  digitalWrite(4,0);//8号引脚输出高电平
startCameraServer();

}

void loop() {
  delay(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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

7.0.96oled

在这里插入图片描述

#include <SPI.h> // 加载SPI库
#include <Wire.h> // 加载Wire库
#include <Adafruit_GFX.h> // 加载Adafruit_GFX库
#include <Adafruit_SSD1306.h> // 加载Adafruit_SSD1306库

// 定义 OLED屏幕的分辨率
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire);

void setup() {
  Serial.begin(9600); // 设置串口波特率

  Serial.println("OLED FeatherWing test"); // 串口输出
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // 设置OLED的I2C地址

  display.clearDisplay(); // 清空屏幕

  display.setTextSize(1); // 设置字体大小
  display.setTextColor(SSD1306_WHITE); // 设置字体颜色
  display.setCursor(0,0); // 设置开始显示文字的坐标
  display.println("Hello World!"); // 输出的字符
  display.println("   by Lingshunlab.com");
  display.display(); // 使更改的显示生效
}

void loop() {

}
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

void Oled(){
  display.clearDisplay(); // 清空屏幕
display.setCursor(0,0); display.print("SSID:"); display.print("ESP82666");
  display.display(); // 使更改的显示生效
  } 
1
2
3
4
5

8.网络NTP时间

#include <NTPClient.h>
// change next line to use with another board/shield
#include <ESP8266WiFi.h>
//#include <WiFi.h> // for WiFi shield
//#include <WiFi101.h> // for WiFi 101 shield or MKR1000
#include <WiFiUdp.h>

const char *ssid     = "ESP826";
const char *password = "12345678";

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "ntp1.aliyun.com",60*60*8, 30*60*1000);

void setup(){
  Serial.begin(115200);

  WiFi.begin(ssid, password);

  while ( WiFi.status() != WL_CONNECTED ) {
    delay ( 500 );
    Serial.print ( "." );
  }

  timeClient.begin();
}
//***********进行日期获取*********//
void Time(){
  unsigned long epochTime = timeClient.getEpochTime();
  //***时间戳******//
//  Serial.print("Epoch Time:");
//  Serial.println(epochTime);
  //将epochTime换算成年月日
  struct tm *ptm = gmtime((time_t *)&epochTime);
  int monthDay = ptm->tm_mday;
  int currentMonth = ptm->tm_mon + 1;
  int year = 1900 + ptm->tm_year;
  Serial.print(year);
  Serial.print("年");
  Serial.print(currentMonth);
  Serial.print("月");
  Serial.print(monthDay);
  Serial.println("日");
  }
  //***********进行时间获取*********//
  void Hours(){
  int hours = timeClient.getHours();
  int minu =  timeClient.getMinutes();
  int sece =  timeClient.getSeconds();
  Serial.printf("%d:%d:%d\n", hours,minu,sece);
  }  
void loop() {
  timeClient.update();
Time();
Hours();
  delay(1000);
}

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
45
46
47
48
49
50
51
52
53
54
55
56
57

运行效果
在这里插入图片描述

9.SD卡模块（ESP32 C3 XIAO）

因为CS和RX引脚复用了。所以在PIN改了引脚，改成了D0；
主要参考这个https://blog.csdn.net/finedayforu/article/details/108727110

#include <Arduino.h>
#include "SD.h"
 
void setup()
{
  Serial.begin(115200);
  if (!SD.begin())
  {
    Serial.print(".");
  }
  Serial.println("SD card Ready!");
  Serial.printf("SD.cardSize = %lld \r\n", SD.cardSize());//SD卡大小
  Serial.printf("SD.totalBytes = %lld \r\n", SD.totalBytes());
  Serial.printf("SD.usedBytes = %lld \r\n", SD.usedBytes());
  Serial.printf("SD.cardType = %d \r\n", SD.cardType());//SD卡类型
  Serial.printf("is there /test.txt? :%d \r\n", SD.exists("/sd/doc1/test.txt"));//是否存在文件test.txt
  Serial.println(SD.mkdir("/doc1"));//创建文件夹
  Serial.printf("is there /doc1? :%d \r\n", SD.exists("/doc1"));//是否存在文件test.txt
  Serial.printf("is there /test.txt? :%d \r\n", SD.exists("/test.txt"));//是否存在文件test.txt
  File file = SD.open("/test.txt", FILE_WRITE);//创建/打开test.txt，写入
  Serial.printf("is there /test.txt? :%d \r\n", SD.exists("/test.txt"));//是否存在文件test.txt
  file.printf("hello!!!");//写入hello!!!
  file.close();//关闭
  file = SD.open("/test.txt", FILE_READ);//读取test.txt文件
  Serial.println(file.readString());
  file.close();
  Serial.printf("is there /doc1/test1.txt? :%d \r\n", SD.exists("/doc1/test1.txt"));
  File file2 = SD.open("/doc1/test1.txt", FILE_WRITE);
  Serial.printf("is there /doc1/test1.txt? :%d \r\n", SD.exists("/doc1/test1.txt"));
  file2.printf("hello!!!");
  file2.close();
  file2 = SD.open("/test.txt", FILE_READ);
  Serial.println(file2.readString());
  file2.close();
  SD.end();
}
 
void loop()
{
}
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

实测可用

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\n", path);

    File file = fs.open(path);
    if(!file){
        Serial.println("Failed to open file for reading");
        return;
    }

    Serial.print("Read from file: ");
    while(file.available()){
        Serial.write(file.read());
    }
    file.close();
}



void appendFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Appending to file: %s\n", path);

    File file = fs.open(path, FILE_APPEND);
    if(!file){
        Serial.println("Failed to open file for appending");
        return;
    }
    if(file.print(message)){
        Serial.println("Message appended");
    } else {
        Serial.println("Append failed");
    }
    file.close();
}





void setup(){
    Serial.begin(115200);
    if(!SD.begin()){
        Serial.println("Card Mount Failed");
        return;
    }

    appendFile(SD, "/hello.txt", "World!\n"); // 在hello.txt文件末尾继续写入"World!"，然后换行
    appendFile(SD, "/hello.txt", "asfdfg!\n"); // 在hello.txt文件末尾继续写入"World!"，然后换行
    appendFile(SD, "/hello.txt", "asdgfgh!\n"); // 在hello.txt文件末尾继续写入"World!"，然后换行
    readFile(SD, "/hello.txt");               // 读取hello.txt文件的内容并打印出来

}

void loop(){

}

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

10.UART

String comdata = "";

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    while (Serial.available() > 0)  
    {
        comdata += char(Serial.read());
        delay(2);
    }
    if (comdata.length() > 0)
    {
        Serial.println(comdata);
        comdata = "";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


```cpp
#include <HardwareSerial.h>    //导入ESP32串口操作库,使用这个库我们可以把串口映射到其他的引脚上使用

//我们测试需要用到的串口，ESP32一共有3个串口，串口0应该是用于程序烧写和打印输出调试用的，所以我们只用1和2
HardwareSerial MySerial_stm32(1);  

void setup() {
  Serial.begin(115200);
  //串口的开启，这里还可以传一些别的参数，但是我们只传入下面四个最重要的：波特率，默认SERIAL_8N1为8位数据位、无校验、1位停止位，后面两个分别为 RXD,TXD 引脚
  MySerial_stm32.begin(115200, SERIAL_8N1, 3, 1);

  //MySerial_stm32.updateBaudRate(9600);  //重新设置波特率；  
  //MySerial_stm32.end();  //失能串口，释放占用的资源
}

void loop() {
  MySerial_stm32.println("usart test!!!");
  delay(1000);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


## 11.MPU6050
### ESP32

```cpp

```cpp
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
Adafruit_MPU6050 mpu;
void setup(void) {
  Serial.begin(115200);
  // Try to initialize!
  if (!mpu.begin()) {
    Serial.println("Failed to find MPU6050 chip");
    while (1) {
      delay(10);
    }
  }
  Serial.println("MPU6050 Found!");
  // set accelerometer range to +-8G
  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  // set gyro range to +- 500 deg/s
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  // set filter bandwidth to 21 Hz
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
  delay(100);
}
void loop() {
  /* Get new sensor events with the readings */
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  /* Print out the readings */
  Serial.print("Acceleration X: ");
  Serial.print(a.acceleration.x);
  Serial.print(", Y: ");
  Serial.print(a.acceleration.y);
  Serial.print(", Z: ");
  Serial.print(a.acceleration.z);
  Serial.println(" m/s^2");
  Serial.print("Rotation X: ");
  Serial.print(g.gyro.x);
  Serial.print(", Y: ");
  Serial.print(g.gyro.y);
  Serial.print(", Z: ");
  Serial.print(g.gyro.z);
  Serial.println(" rad/s");
  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println(" degC");
  Serial.println("");
  delay(10);
}

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
45
46
47
48
49
50
51
52
53
54
55

ESP32C3