Wireless Control of ESP32CAM via Mobile App (UDP Communication)

The development environment for the ESP32CAM program is Arduino, and the steps to be completed are as follows.

1. Open the Arduino example program, File – Examples – ESP32-Camera – CameraWebServer.

#define CAMERA_MODEL_AI_THINKER// Has PSRAM

#include <Arduino.h>#include <WiFi.h>#include <WiFiUdp.h>#include "esp_camera.h"
#define CAMERA_MODEL_AI_THINKER  #include "camera_pins.h"  const char *ssid = "phonenova"; const char *password = "123456789"; WiFiUDP Udp;  void setup() {  Serial.begin(115200);  Serial.println();  WiFi.mode(WIFI_STA);  WiFi.setSleep(false);   WiFi.begin(ssid,password);  while(!WiFi.isConnected())  {    delay(500);    Serial.print(".");  }  Serial.print("Connected IP Address:");  Serial.println(WiFi.localIP());  initCamera();   //Camera initialization  Udp.begin(20000);   //Open UDP listening port, ESP32's port number, server  }

void loop() {   int packetSize = Udp.parsePacket();    //Get the length of the current packet,   if(packetSize)  {    char buf[packetSize];    Udp.read(buf,packetSize); //Read specified length of data    Serial.println(buf);    }  }

(1) uint8_t begin(uint16_t p)

(2) uint8_t begin(IPAddress a, uint16_t p)

Start listening on a certain port or for data sent to a certain port from a certain address;

(3) void stop()

Stop listening, release resources;

(4) int beginPacket()

Prepare to send a data packet (only available when running the parsePacket() method and the return value is greater than 0);

(5) int beginPacket(IPAddress ip, uint16_t port)

Prepare to send a data packet, with parameters being the target IP and target port number;

(6) size_t write(uint8_t)

(7) size_t write(const uint8_t *buffer, size_t size)

Copy data to the send buffer (the maximum size for a single data packet is 1460 bytes);

(8) int endPacket()

Send data;

(9) int parsePacket()

Get information on received data; if there is a data packet available, return the length of the first packet, otherwise return 0;

(10) int read()

Read the first byte of data (only available when running the parsePacket() method and the return value is greater than 0);

(11) int read(unsigned char* buffer, size_t len)

(12) int read(char* buffer, size_t len)

Read data (only available when running the parsePacket() method and the return value is greater than 0);

(13) int peek()

Read the first byte of data but does not remove it from the receive buffer (only available when running the parsePacket() method and the return value is greater than 0);

(14) void flush()

Clear the current receive buffer (only available when running the parsePacket() method and the return value is greater than 0);

(15) IPAddress remoteIP()

Return the remote address (only available when running the parsePacket() method and the return value is greater than 0);

(16) uint16_t remotePort()

Return the remote port number (only available when running the parsePacket() method and the return value is greater than 0);

#include "esp_camera.h"#include <WiFi.h>#include "AsyncUDP.h"#define CAMERA_MODEL_AI_THINKER #include "camera_pins.h"AsyncUDP udp;

void onPacketCallBack(AsyncUDPPacket packet){  unsigned char buf[packet.length()];  packet.read(buf,packet.length());

if((buf[0] == 36) && (buf[8] == 35))    {            switch(buf[2])      {        case 48:Serial.print("$,0,0,0,#");digitalWrite(4,LOW);break;        case 49:Serial.print("$,1,3,2,#");digitalWrite(4,HIGH);break; //1 forward        case 50:Serial.print("$,2,3,2,#");break; //2 backward        case 51:Serial.print("$,3,3,2,#");break; //3 left        case 52:Serial.print("$,4,3,2,#");break; //4 right        default:break;      }      switch(buf[4]){        case 48:Serial.print("$,5,0,2,#");break; //        case 49:Serial.print("$,5,1,2,#");break; //Turret left        case 50:Serial.print("$,5,2,2,#");break; //Turret right        default:break;       }      switch(buf[6]){        case 48:Serial.print("$,5,3,0,#");break; //        case 49:Serial.print("$,5,3,1,#");break; //Fire        default:break;      }      }}void setup() {  Serial.begin(115200);  Serial.setDebugOutput(true);  Serial.println();  void Camera_Init();    WiFi.mode(WIFI_STA);          //Set WiFi connection mode to router mode  WiFi.begin(ssid, password);   //Connect to the router  WiFi.setSleep(false);         //Disable WiFi_STA mode sleep to improve response speed  while (WiFi.status() != WL_CONNECTED) {    delay(500);    Serial.print(".");  }  Serial.println("");  Serial.println("WiFi connected");  startCameraServer();  Serial.print("Camera Ready! Use 'http://");  Serial.print(WiFi.localIP());  Serial.println("' to connect");  while(!udp.listen(WiFi.localIP(),1688));  udp.onPacket(onPacketCallBack);  // udp.onPacket([](AsyncUDPPacket packet){  //   string UDP_RXD(packet.data(), packet.length())});  //string UDP_RXD(packet.data(), packet.length())  //string (const char* s, size_t n);  // from buffer Copies the first n characters from the array of characters pointed by s}void loop() {  // Do nothing. Everything is done in another task by the web server    delay(10);  }

AsyncUDP class:

void onPacket(AuPacketHandlerFunctionWithArg cb, void * arg=NULL)

void onPacket(AuPacketHandlerFunction cb)

Register an event and bind a callback function;

bool listen(const IPAddress addr, uint16_t port)

bool listen(uint16_t port)

bool listen(const IPv6Address addr, uint16_t port)

bool listen(uint16_t port)

Start listening;

bool listenMulticast(const ip_addr_t *addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

bool listenMulticast(const IPAddress addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

bool listenMulticast(const IPv6Address addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

Start multicast listening;

bool connect(const ip_addr_t *addr, uint16_t port)

bool connect(const IPAddress addr, uint16_t port)

bool connect(const IPv6Address addr, uint16_t port)

Connect as a client to the server (after successful connection, you can directly use write or send methods without using writeTo or sendTo);

void close()

Close UDP;

size_t writeTo(const uint8_t *data, size_t len, const ip_addr_t *addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t writeTo(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t writeTo(const uint8_t *data, size_t len, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t write(const uint8_t *data, size_t len)

size_t write(uint8_t data)

Send data;

size_t broadcastTo(uint8_t *data, size_t len, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t broadcastTo(const char * data, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t broadcast(uint8_t *data, size_t len)

size_t broadcast(const char * data)

Broadcast data;

size_t sendTo(AsyncUDPMessage &message, const ip_addr_t *addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t sendTo(AsyncUDPMessage &message, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t sendTo(AsyncUDPMessage &message, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t send(AsyncUDPMessage &message)

Send data;

size_t broadcastTo(AsyncUDPMessage &message, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX)

size_t broadcast(AsyncUDPMessage &message)

Broadcast data;

AsyncUDPPacket class:

AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif * netif)

Constructor;

uint8_t * data()

Return data pointer;

size_t length()

Return data length;

bool isBroadcast()

Check if it is broadcast data;

bool isMulticast()

Check if it is a multicast address;

IPAddress localIP()

Return the target (local) IP;

uint16_t localPort()

Return the target (local) port number;

IPAddress remoteIP()

Return the remote IP;

uint16_t remotePort()

Return the remote port number;

size_t read(uint8_t *data, size_t len)

Read data;

int read()

Read the first byte of data;

int peek()

Read the first byte of data but does not remove it from the receive buffer;

void flush()

Clear the current receive buffer;

size_t write(const uint8_t *data, size_t len)

size_t write(uint8_t data)

Send data to the remote;

AsyncUDPMessage class:

AsyncUDPMessage(size_t size=CONFIG_TCP_MSS)

Constructor (this acts as a buffer, putting the data to be sent here, and then sending it through the corresponding method);

size_t write(const uint8_t *data, size_t len)

size_t write(uint8_t data)

Write data into the AsyncUDPMessage object;

size_t space()

Return the remaining available space in the AsyncUDPMessage object;

uint8_t * data()

Return the data pointer in the AsyncUDPMessage object;

size_t length()

Return the current used length of the AsyncUDPMessage object;

void flush()

Clear the current data in the AsyncUDPMessage object;

Mobile App Program Design

The development environment for the mobile app program is MIT App Inventor, and the steps to be completed are as follows.

1. Create a new project, and add extensions UDPXmitter1 and UDPListener1.

The new page is shown in the figure below, which includes a Web browser frame, buttons, and extension UDP communication instructions.

2. The program design (part) is shown in the figure below.

3. Package the APK, and install the mobile app to connect.

4. Debug.