pot plugin w. example

lib/esp32_lora_wifi/WiFi/examples/SimpleWiFiServer/SimpleWiFiServer.ino

@@ -0,0 +1,116 @@
+/*
+  WiFi Web Server LED Blink
+
+ A simple web server that lets you blink an LED via the web.
+ This sketch will print the IP address of your WiFi Shield (once connected)
+ to the Serial monitor. From there, you can open that address in a web browser
+ to turn on and off the LED on pin 5.
+
+ If the IP address of your shield is yourAddress:
+ http://yourAddress/H turns the LED on
+ http://yourAddress/L turns it off
+
+ This example is written for a network using WPA encryption. For
+ WEP or WPA, change the Wifi.begin() call accordingly.
+
+ Circuit:
+ * WiFi shield attached
+ * LED attached to pin 5
+
+ created for arduino 25 Nov 2012
+ by Tom Igoe
+
+ported for sparkfun esp32 
+31.01.2017 by Jan Hendrik Berlin
+ 
+ */
+
+#include <WiFi.h>
+
+const char* ssid     = "yourssid";
+const char* password = "yourpasswd";
+
+WiFiServer server(80);
+
+void setup()
+{
+    Serial.begin(115200);
+    pinMode(5, OUTPUT);      // set the LED pin mode
+
+    delay(10);
+
+    // We start by connecting to a WiFi network
+
+    Serial.println();
+    Serial.println();
+    Serial.print("Connecting to ");
+    Serial.println(ssid);
+
+    WiFi.begin(ssid, password);
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        Serial.print(".");
+    }
+
+    Serial.println("");
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+    
+    server.begin();
+
+}
+
+int value = 0;
+
+void loop(){
+ WiFiClient client = server.available();   // listen for incoming clients
+
+  if (client) {                             // if you get a client,
+    Serial.println("new client");           // print a message out the serial port
+    String currentLine = "";                // make a String to hold incoming data from the client
+    while (client.connected()) {            // loop while the client's connected
+      if (client.available()) {             // if there's bytes to read from the client,
+        char c = client.read();             // read a byte, then
+        Serial.write(c);                    // print it out the serial monitor
+        if (c == '\n') {                    // if the byte is a newline character
+
+          // if the current line is blank, you got two newline characters in a row.
+          // that's the end of the client HTTP request, so send a response:
+          if (currentLine.length() == 0) {
+            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
+            // and a content-type so the client knows what's coming, then a blank line:
+            client.println("HTTP/1.1 200 OK");
+            client.println("Content-type:text/html");
+            client.println();
+
+            // the content of the HTTP response follows the header:
+            client.print("Click <a href=\"/H\">here</a> turn the LED on pin 5 on<br>");
+            client.print("Click <a href=\"/L\">here</a> turn the LED on pin 5 off<br>");
+
+            // The HTTP response ends with another blank line:
+            client.println();
+            // break out of the while loop:
+            break;
+          } else {    // if you got a newline, then clear currentLine:
+            currentLine = "";
+          }
+        } else if (c != '\r') {  // if you got anything else but a carriage return character,
+          currentLine += c;      // add it to the end of the currentLine
+        }
+
+        // Check to see if the client request was "GET /H" or "GET /L":
+        if (currentLine.endsWith("GET /H")) {
+          digitalWrite(5, HIGH);               // GET /H turns the LED on
+        }
+        if (currentLine.endsWith("GET /L")) {
+          digitalWrite(5, LOW);                // GET /L turns the LED off
+        }
+      }
+    }
+    // close the connection:
+    client.stop();
+    Serial.println("client disonnected");
+  }
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiClient/WiFiClient.ino

@@ -0,0 +1,94 @@
+/*
+ *  This sketch sends data via HTTP GET requests to data.sparkfun.com service.
+ *
+ *  You need to get streamId and privateKey at data.sparkfun.com and paste them
+ *  below. Or just customize this script to talk to other HTTP servers.
+ *
+ */
+
+#include <WiFi.h>
+
+const char* ssid     = "your-ssid";
+const char* password = "your-password";
+
+const char* host = "data.sparkfun.com";
+const char* streamId   = "....................";
+const char* privateKey = "....................";
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(10);
+
+    // We start by connecting to a WiFi network
+
+    Serial.println();
+    Serial.println();
+    Serial.print("Connecting to ");
+    Serial.println(ssid);
+
+    WiFi.begin(ssid, password);
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        Serial.print(".");
+    }
+
+    Serial.println("");
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+}
+
+int value = 0;
+
+void loop()
+{
+    delay(5000);
+    ++value;
+
+    Serial.print("connecting to ");
+    Serial.println(host);
+
+    // Use WiFiClient class to create TCP connections
+    WiFiClient client;
+    const int httpPort = 80;
+    if (!client.connect(host, httpPort)) {
+        Serial.println("connection failed");
+        return;
+    }
+
+    // We now create a URI for the request
+    String url = "/input/";
+    url += streamId;
+    url += "?private_key=";
+    url += privateKey;
+    url += "&value=";
+    url += value;
+
+    Serial.print("Requesting URL: ");
+    Serial.println(url);
+
+    // This will send the request to the server
+    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
+                 "Host: " + host + "\r\n" +
+                 "Connection: close\r\n\r\n");
+    unsigned long timeout = millis();
+    while (client.available() == 0) {
+        if (millis() - timeout > 5000) {
+            Serial.println(">>> Client Timeout !");
+            client.stop();
+            return;
+        }
+    }
+
+    // Read all the lines of the reply from server and print them to Serial
+    while(client.available()) {
+        String line = client.readStringUntil('\r');
+        Serial.print(line);
+    }
+
+    Serial.println();
+    Serial.println("closing connection");
+}
+

lib/esp32_lora_wifi/WiFi/examples/WiFiClientBasic/WiFiClientBasic.ino

@@ -0,0 +1,70 @@
+/*
+ *  This sketch sends a message to a TCP server
+ *
+ */
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+
+WiFiMulti WiFiMulti;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(10);
+
+    // We start by connecting to a WiFi network
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    Serial.println();
+    Serial.println();
+    Serial.print("Wait for WiFi... ");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        Serial.print(".");
+        delay(500);
+    }
+
+    Serial.println("");
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+
+    delay(500);
+}
+
+
+void loop()
+{
+    const uint16_t port = 80;
+    const char * host = "192.168.1.1"; // ip or dns
+
+
+
+    Serial.print("connecting to ");
+    Serial.println(host);
+
+    // Use WiFiClient class to create TCP connections
+    WiFiClient client;
+
+    if (!client.connect(host, port)) {
+        Serial.println("connection failed");
+        Serial.println("wait 5 sec...");
+        delay(5000);
+        return;
+    }
+
+    // This will send the request to the server
+    client.print("Send this data to server");
+
+    //read back one line from server
+    String line = client.readStringUntil('\r');
+    client.println(line);
+
+    Serial.println("closing connection");
+    client.stop();
+
+    Serial.println("wait 5 sec...");
+    delay(5000);
+}
+

lib/esp32_lora_wifi/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino

@@ -0,0 +1,51 @@
+/*
+ *  This sketch shows the WiFi event usage
+ *
+ */
+
+#include <WiFi.h>
+
+const char* ssid     = "your-ssid";
+const char* password = "your-password";
+
+
+void WiFiEvent(WiFiEvent_t event)
+{
+    Serial.printf("[WiFi-event] event: %d\n", event);
+
+    switch(event) {
+    case SYSTEM_EVENT_STA_GOT_IP:
+        Serial.println("WiFi connected");
+        Serial.println("IP address: ");
+        Serial.println(WiFi.localIP());
+        break;
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+        Serial.println("WiFi lost connection");
+        break;
+    }
+}
+
+void setup()
+{
+    Serial.begin(115200);
+
+    // delete old config
+    WiFi.disconnect(true);
+
+    delay(1000);
+
+    WiFi.onEvent(WiFiEvent);
+
+    WiFi.begin(ssid, password);
+
+    Serial.println();
+    Serial.println();
+    Serial.println("Wait for WiFi... ");
+}
+
+
+void loop()
+{
+    delay(1000);
+}
+

lib/esp32_lora_wifi/WiFi/examples/WiFiIPv6/WiFiIPv6.ino

@@ -0,0 +1,119 @@
+#include "WiFi.h"
+
+#define STA_SSID "**********"
+#define STA_PASS "**********"
+#define AP_SSID  "esp32-v6"
+
+static volatile bool wifi_connected = false;
+
+WiFiUDP ntpClient;
+
+void wifiOnConnect(){
+    Serial.println("STA Connected");
+    Serial.print("STA IPv4: ");
+    Serial.println(WiFi.localIP());
+    
+    ntpClient.begin(2390);
+}
+
+void wifiOnDisconnect(){
+    Serial.println("STA Disconnected");
+    delay(1000);
+    WiFi.begin(STA_SSID, STA_PASS);
+}
+
+void wifiConnectedLoop(){
+  //lets check the time
+  const int NTP_PACKET_SIZE = 48;
+  byte ntpPacketBuffer[NTP_PACKET_SIZE];
+
+  IPAddress address;
+  WiFi.hostByName("time.nist.gov", address);
+  memset(ntpPacketBuffer, 0, NTP_PACKET_SIZE);
+  ntpPacketBuffer[0] = 0b11100011;   // LI, Version, Mode
+  ntpPacketBuffer[1] = 0;     // Stratum, or type of clock
+  ntpPacketBuffer[2] = 6;     // Polling Interval
+  ntpPacketBuffer[3] = 0xEC;  // Peer Clock Precision
+  // 8 bytes of zero for Root Delay & Root Dispersion
+  ntpPacketBuffer[12]  = 49;
+  ntpPacketBuffer[13]  = 0x4E;
+  ntpPacketBuffer[14]  = 49;
+  ntpPacketBuffer[15]  = 52;
+  ntpClient.beginPacket(address, 123); //NTP requests are to port 123
+  ntpClient.write(ntpPacketBuffer, NTP_PACKET_SIZE);
+  ntpClient.endPacket();
+
+  delay(1000);
+  
+  int packetLength = ntpClient.parsePacket();
+  if (packetLength){
+    if(packetLength >= NTP_PACKET_SIZE){
+      ntpClient.read(ntpPacketBuffer, NTP_PACKET_SIZE);
+    }
+    ntpClient.flush();
+    uint32_t secsSince1900 = (uint32_t)ntpPacketBuffer[40] << 24 | (uint32_t)ntpPacketBuffer[41] << 16 | (uint32_t)ntpPacketBuffer[42] << 8 | ntpPacketBuffer[43];
+    //Serial.printf("Seconds since Jan 1 1900: %u\n", secsSince1900);
+    uint32_t epoch = secsSince1900 - 2208988800UL;
+    //Serial.printf("EPOCH: %u\n", epoch);
+    uint8_t h = (epoch  % 86400L) / 3600;
+    uint8_t m = (epoch  % 3600) / 60;
+    uint8_t s = (epoch % 60);
+    Serial.printf("UTC: %02u:%02u:%02u (GMT)\n", h, m, s);
+  }
+
+  delay(9000);
+}
+
+void WiFiEvent(WiFiEvent_t event){
+    switch(event) {
+
+        case SYSTEM_EVENT_AP_START:
+            //can set ap hostname here
+            WiFi.softAPsetHostname(AP_SSID);
+            //enable ap ipv6 here
+            WiFi.softAPenableIpV6();
+            break;
+
+        case SYSTEM_EVENT_STA_START:
+            //set sta hostname here
+            WiFi.setHostname(AP_SSID);
+            break;
+        case SYSTEM_EVENT_STA_CONNECTED:
+            //enable sta ipv6 here
+            WiFi.enableIpV6();
+            break;
+        case SYSTEM_EVENT_AP_STA_GOT_IP6:
+            //both interfaces get the same event
+            Serial.print("STA IPv6: ");
+            Serial.println(WiFi.localIPv6());
+            Serial.print("AP IPv6: ");
+            Serial.println(WiFi.softAPIPv6());
+            break;
+        case SYSTEM_EVENT_STA_GOT_IP:
+            wifiOnConnect();
+            wifi_connected = true;
+            break;
+        case SYSTEM_EVENT_STA_DISCONNECTED:
+            wifi_connected = false;
+            wifiOnDisconnect();
+            break;
+        default:
+            break;
+    }
+}
+
+void setup(){
+    Serial.begin(115200);
+    WiFi.disconnect(true);
+    WiFi.onEvent(WiFiEvent);
+    WiFi.mode(WIFI_MODE_APSTA);
+    WiFi.softAP(AP_SSID);
+    WiFi.begin(STA_SSID, STA_PASS);
+}
+
+void loop(){
+    if(wifi_connected){
+        wifiConnectedLoop();
+    }
+    while(Serial.available()) Serial.write(Serial.read());
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiMulti/WiFiMulti.ino

@@ -0,0 +1,35 @@
+/*
+ *  This sketch trys to Connect to the best AP based on a given list
+ *
+ */
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+
+WiFiMulti wifiMulti;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(10);
+
+    wifiMulti.addAP("ssid_from_AP_1", "your_password_for_AP_1");
+    wifiMulti.addAP("ssid_from_AP_2", "your_password_for_AP_2");
+    wifiMulti.addAP("ssid_from_AP_3", "your_password_for_AP_3");
+
+    Serial.println("Connecting Wifi...");
+    if(wifiMulti.run() == WL_CONNECTED) {
+        Serial.println("");
+        Serial.println("WiFi connected");
+        Serial.println("IP address: ");
+        Serial.println(WiFi.localIP());
+    }
+}
+
+void loop()
+{
+    if(wifiMulti.run() != WL_CONNECTED) {
+        Serial.println("WiFi not connected!");
+        delay(1000);
+    }
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiScan/WiFiScan.ino

@@ -0,0 +1,48 @@
+/*
+ *  This sketch demonstrates how to scan WiFi networks.
+ *  The API is almost the same as with the WiFi Shield library,
+ *  the most obvious difference being the different file you need to include:
+ */
+#include "WiFi.h"
+
+void setup()
+{
+    Serial.begin(115200);
+
+    // Set WiFi to station mode and disconnect from an AP if it was previously connected
+    WiFi.mode(WIFI_STA);
+    WiFi.disconnect();
+    delay(100);
+
+    Serial.println("Setup done");
+}
+
+void loop()
+{
+    Serial.println("scan start");
+
+    // WiFi.scanNetworks will return the number of networks found
+    int n = WiFi.scanNetworks();
+    Serial.println("scan done");
+    if (n == 0) {
+        Serial.println("no networks found");
+    } else {
+        Serial.print(n);
+        Serial.println(" networks found");
+        for (int i = 0; i < n; ++i) {
+            // Print SSID and RSSI for each network found
+            Serial.print(i + 1);
+            Serial.print(": ");
+            Serial.print(WiFi.SSID(i));
+            Serial.print(" (");
+            Serial.print(WiFi.RSSI(i));
+            Serial.print(")");
+            Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
+            delay(10);
+        }
+    }
+    Serial.println("");
+
+    // Wait a bit before scanning again
+    delay(5000);
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiScan/images.h

@@ -0,0 +1,28 @@
+#define WiFi_Logo_width 60
+#define WiFi_Logo_height 36
+const char WiFi_Logo_bits[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
+  0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+  0xFF, 0x03, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+  0x00, 0xFF, 0xFF, 0xFF, 0x07, 0xC0, 0x83, 0x01, 0x80, 0xFF, 0xFF, 0xFF,
+  0x01, 0x00, 0x07, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x0C, 0x00,
+  0xC0, 0xFF, 0xFF, 0x7C, 0x00, 0x60, 0x0C, 0x00, 0xC0, 0x31, 0x46, 0x7C,
+  0xFC, 0x77, 0x08, 0x00, 0xE0, 0x23, 0xC6, 0x3C, 0xFC, 0x67, 0x18, 0x00,
+  0xE0, 0x23, 0xE4, 0x3F, 0x1C, 0x00, 0x18, 0x00, 0xE0, 0x23, 0x60, 0x3C,
+  0x1C, 0x70, 0x18, 0x00, 0xE0, 0x03, 0x60, 0x3C, 0x1C, 0x70, 0x18, 0x00,
+  0xE0, 0x07, 0x60, 0x3C, 0xFC, 0x73, 0x18, 0x00, 0xE0, 0x87, 0x70, 0x3C,
+  0xFC, 0x73, 0x18, 0x00, 0xE0, 0x87, 0x70, 0x3C, 0x1C, 0x70, 0x18, 0x00,
+  0xE0, 0x87, 0x70, 0x3C, 0x1C, 0x70, 0x18, 0x00, 0xE0, 0x8F, 0x71, 0x3C,
+  0x1C, 0x70, 0x18, 0x00, 0xC0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x08, 0x00,
+  0xC0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x0C, 0x00, 0x80, 0xFF, 0xFF, 0x1F,
+  0x00, 0x00, 0x06, 0x00, 0x80, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x07, 0x00,
+  0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xF8, 0xFF, 0xFF,
+  0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
+  0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };

lib/esp32_lora_wifi/WiFi/examples/WiFiSmartConfig/WiFiSmartConfig.ino

@@ -0,0 +1,36 @@
+#include "WiFi.h"
+
+void setup() {
+  Serial.begin(115200);
+
+  //Init WiFi as Station, start SmartConfig
+  WiFi.mode(WIFI_AP_STA);
+  WiFi.beginSmartConfig();
+
+  //Wait for SmartConfig packet from mobile
+  Serial.println("Waiting for SmartConfig.");
+  while (!WiFi.smartConfigDone()) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  Serial.println("");
+  Serial.println("SmartConfig received.");
+
+  //Wait for WiFi to connect to AP
+  Serial.println("Waiting for WiFi");
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  Serial.println("WiFi Connected.");
+
+  Serial.print("IP Address: ");
+  Serial.println(WiFi.localIP());
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiUDPClient/WiFiUDPClient.ino

@@ -0,0 +1,75 @@
+/*
+ *  This sketch sends random data over UDP on a ESP32 device
+ *
+ */
+#include <WiFi.h>
+#include <WiFiUdp.h>
+
+// WiFi network name and password:
+const char * networkName = "your-ssid";
+const char * networkPswd = "your-password";
+
+//IP address to send UDP data to:
+// either use the ip address of the server or 
+// a network broadcast address
+const char * udpAddress = "192.168.0.255";
+const int udpPort = 3333;
+
+//Are we currently connected?
+boolean connected = false;
+
+//The udp library class
+WiFiUDP udp;
+
+void setup(){
+  // Initilize hardware serial:
+  Serial.begin(115200);
+  
+  //Connect to the WiFi network
+  connectToWiFi(networkName, networkPswd);
+}
+
+void loop(){
+  //only send data when connected
+  if(connected){
+    //Send a packet
+    udp.beginPacket(udpAddress,udpPort);
+    udp.printf("Seconds since boot: %u", 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);
+  
+  //Initiate connection
+  WiFi.begin(ssid, pwd);
+
+  Serial.println("Waiting for WIFI connection...");
+}
+
+//wifi event handler
+void WiFiEvent(WiFiEvent_t event){
+    switch(event) {
+      case SYSTEM_EVENT_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 SYSTEM_EVENT_STA_DISCONNECTED:
+          Serial.println("WiFi lost connection");
+          connected = false;
+          break;
+    }
+}

lib/esp32_lora_wifi/WiFi/examples/WiFiUDPClient/udp_server.py

@@ -0,0 +1,30 @@
+# This python script listens on UDP port 3333 
+# for messages from the ESP32 board and prints them
+import socket
+import sys
+
+try :
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+except socket.error, msg :
+    print 'Failed to create socket. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
+    sys.exit()
+
+try:
+    s.bind(('', 3333))
+except socket.error , msg:
+    print 'Bind failed. Error: ' + str(msg[0]) + ': ' + msg[1]
+    sys.exit()
+     
+print 'Server listening'
+
+while 1:
+    d = s.recvfrom(1024)
+    data = d[0]
+     
+    if not data: 
+        break
+    
+    print data.strip()
+    
+s.close()

lib/esp32_lora_wifi/WiFi/examples/WiFiUDPClient/udp_server.rb

@@ -0,0 +1,16 @@
+# This ruby script listens on UDP port 3333 
+# for messages from the ESP32 board and prints them
+
+require 'socket'
+include Socket::Constants
+
+udp_socket = UDPSocket.new(AF_INET)
+
+#bind 
+udp_socket.bind("", 3333)
+puts 'Server listening'
+
+while true do
+  message, sender = udp_socket.recvfrom(1024)
+  puts message
+end