【Follow me第二季第2期】任务补充 esp32与arduinoUNOR4之间的的udp通信

Henry-0755

【Follow me第二季第2期】任务补充 esp32与arduinoUNOR4之间的的udp通信 [复制链接]

<i class="pstatus"> 本帖最后由 Henry-0755 于 2024-12-8 21:52 编辑 </i>

【Follow me第二季第2期】任务补充 esp32与arduinoUNOR4之间的udp通信

购买的时候额外购买了块 FIREBEETLE 2 ESP32 DEV BOARD
补充下这个与开发板简单联动

首先是如何用起来的教程：
来自DFRobot家的开发板都有手把手的教程：[教程](https://wiki.dfrobot.com/SKU_DFR1075_FireBeetle_2_Board_ESP32_C6#target_10 "教程")，初学者很快就能上手

也是一个wifi的小模块，下面用它体验下arduino下的esp32与arduino UNOR4之间的udp通信

为了方便演示，当两个开发板之间建立了通信的时候，esp32会每隔1s发送一个心跳包给unoR4，uno接到后将一个一个的亮起matrix_led灯，效果如下：

附上完整代码（一行不用改就能运行滴～）：

UnoR4端（基于官方例程中的开启ap模式代码，unoR4作为热点让esp连接）：
```
/*
  WiFi Web Server LED Blink

A simple web server that lets you blink an LED via the web.
  This sketch will create a new access point (with no password).
  It will then launch a new server and print out the IP address
  to the Serial Monitor. From there, you can open that address in a web browser
  to turn on and off the LED on pin 13.

If the IP address of your board is yourAddress:
    http://yourAddress/H turns the LED on
    http://yourAddress/L turns it off

created 25 Nov 2012
  by Tom Igoe
  adapted to WiFi AP by Adafruit

Find the full UNO R4 WiFi Network documentation here:
  https://docs.arduino.cc/tutorials/uno-r4-wifi/wifi-examples#access-point
 */

#include <WiFiS3.h>

#include "Arduino_LED_Matrix.h"   // Include the LED_Matrix library

#include "arduino_secrets.h"

///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = SECRET_SSID;        // your network SSID (name)
char pass[] = SECRET_PASS;        // your network password (use for WPA, or use as key for WEP)
int keyIndex = 0;                 // your network key index number (needed only for WEP)

int led =  LED_BUILTIN;
int status = WL_IDLE_STATUS;
WiFiServer server(80);

unsigned int localPort = 2390;      // local port to listen on

ArduinoLEDMatrix matrix;          // Create an instance of the ArduinoLEDMatrix class

char packetBuffer[256]; //buffer to hold incoming packet
char  ReplyBuffer[] = "acknowledged\n";       // a string to send back

uint32_t counter[] = {
	0,
	0,
	0
};

WiFiUDP Udp;

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.println("Access Point Web Server");

pinMode(led, OUTPUT);      // set the LED pin mode
  matrix.begin();
  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }

String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Please upgrade the firmware");
  }

// by default the local IP address will be 192.168.4.1
  // you can override it with the following:
  WiFi.config(IPAddress(192,48,56,2));

// print the network name (SSID);
  Serial.print("Creating access point named: ");
  Serial.println(ssid);

// Create open network. Change this line if you want to create an WEP network:
  status = WiFi.beginAP(ssid, pass);
  if (status != WL_AP_LISTENING) {
    Serial.println("Creating access point failed");
    // don't continue
    while (true);
  }

// wait 10 seconds for connection:
  delay(10000);

// start the web server on port 80
  server.begin();

// you're connected now, so print out the status
  printWiFiStatus();

Udp.begin(localPort);
}

void loop() {
  
  // compare the previous status to the current status
  if (status != WiFi.status()) {
    // it has changed update the variable
    status = WiFi.status();

if (status == WL_AP_CONNECTED) {
      // a device has connected to the AP
      Serial.println("Device connected to AP");
    } else {
      // a device has disconnected from the AP, and we are back in listening mode
      Serial.println("Device disconnected from AP");
    }
  }

// if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if (packetSize) {
    Serial.print("Received packet of size ");
    Serial.println(packetSize);
    Serial.print("From ");
    IPAddress remoteIp = Udp.remoteIP();
    Serial.print(remoteIp);
    Serial.print(", port ");
    Serial.println(Udp.remotePort());

// read the packet into packetBuffer
    int len = Udp.read(packetBuffer, 255);
    if (len > 0) {
      packetBuffer[len] = 0;
    }
    Serial.println("Contents:");
    Serial.println(packetBuffer);

if (counter[2] != 0xffffffff)
      counter[2] = (counter[2] << 1) + 1;
    else if (counter[1] != 0xffffffff)
      counter[1] = (counter[1] << 1) + 1;
    else if (counter[0] != 0xffffffff)
      counter[0] = (counter[0] << 1) + 1;
    else {
      counter[0] = 0;
      counter[1] = 0;
      counter[2] = 0;
    }
    Serial.println(counter[2]);
    matrix.loadFrame(counter);
  }
}

void printWiFiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

// print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
}

```

firebeetle esp32c6端（基于官方例程WifiUdpClient改）
```
/*
 *  This sketch sends random data over UDP on a ESP32 device
 *
 */
#include <WiFi.h>
#include <NetworkUdp.h>

// WiFi network name and password:
const char *networkName = "testAP";
const char *networkPswd = "123456789";

#define LED_PIN 21

//IP address to send UDP data to:
// either use the ip address of the server or
// a network broadcast address
const char *udpAddress = "192.48.56.2";
const int udpPort = 2390;

//Are we currently connected?
boolean connected = false;

//The udp library class
NetworkUDP udp;

void setup() {
  // Initialize hardware serial:
  Serial.begin(115200);

//Connect to the WiFi network
  connectToWiFi(networkName, networkPswd);

pinMode(LED_PIN, OUTPUT);
}

void blink() {
  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
}

void loop() {
  //only send data when connected
  if (connected) {
    //Send a packet
    udp.beginPacket(udpAddress, udpPort);
    udp.printf("LED ON at : %lu", millis() / 1000);
    udp.endPacket();
  }
  //Wait for 1 second
  delay(1000);
}

void connectToWiFi(const char *ssid, const char *pwd) {
  Serial.println("Connecting to WiFi network: " + String(ssid));

// delete old config
  WiFi.disconnect(true);
  //register event handler
  WiFi.onEvent(WiFiEvent);  // Will call WiFiEvent() from another thread.

//Initiate connection
  WiFi.begin(ssid, pwd);

Serial.println("Waiting for WIFI connection...");
}

// WARNING: WiFiEvent is called from a separate FreeRTOS task (thread)!
void WiFiEvent(WiFiEvent_t event) {
  switch (event) {
    case ARDUINO_EVENT_WIFI_STA_GOT_IP:
      //When connected set
      Serial.print("WiFi connected! IP address: ");
      Serial.println(WiFi.localIP());
      //initializes the UDP state
      //This initializes the transfer buffer
      udp.begin(WiFi.localIP(), udpPort);
      connected = true;
      break;
    case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
      Serial.println("WiFi lost connection");
      connected = false;
      break;
    default: break;
  }
}
```

秦天qintian0303

现在的任务是买到的都要用上

【Follow me第二季第2期】任务补充 esp32与arduinoUNOR4之间的的udp通信 [复制链接]

最新回复