sample application for Arduino Nano ESP32 - sample ble service + wifi webserver for log output

bletest.ino

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include "ArduinoBLE.h"

#define LOG_BUFFER_SIZE 2048

char logBuffer[LOG_BUFFER_SIZE];  
size_t logWritePos = 0;           
size_t logReadPos = 0;            
size_t logUsed = 0;               

const char* ssid = ******
const char* password = "******";
const int led = 13;
                        
WebServer server(80);
BLEService TestService("d48203f2-c174-443c-a9bf-b1f399496000");
BLEUnsignedCharCharacteristic Auswahl("d48203f2-c174-443c-a9bf-b1f399496001", BLERead | BLEWrite | BLENotify);

void setup(void){
  Serial.begin(9600);
  pinMode(led, OUTPUT);
  digitalWrite(led, 0);

  logMessage("setup ble");
  setup_ble();

  logMessage("setup wifi");
  setup_wifi();

  logMessage("setup done");
}

void setup_ble(void){
  if (!BLE.begin()) logMessage("Bluetooth-Modul konnte nicht gestartet werden!");
  else logMessage("Bluetooth-Modul erfolgreich gestartet!");

  BLE.setLocalName("Test Service");
  BLE.setAdvertisedService(TestService);
  TestService.addCharacteristic(Auswahl);
  BLE.addService(TestService);
  Auswahl.writeValue(0);

  BLE.advertise();
}

void setup_wifi(void) {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  logMessagef("Connected to %s",ssid);
  logMessagef("IP address: %d", WiFi.localIP());

  if (MDNS.begin("bletestservice")) {
    logMessage("MDNS started");
  }

  server.on("/", handleRoot);
  server.onNotFound(handleNotFound);
  server.begin();

  logMessage("HTTP server started");
}

void loop(void) {
  loop_wifi();
  loop_ble();
  delay(2);
}

void loop_wifi(void){
  server.handleClient();
}

void loop_ble(void){
  BLEDevice Verbindung = BLE.central();

  if (Verbindung)
  {
    if (Verbindung.connected())
    {
      if (Auswahl.written())
      {
        if (Auswahl.value() == 1)
        {
          logMessage(" -> LED on");
          digitalWrite(led, 1);
        }

        if (Auswahl.value() == 0)
        {
          logMessage(" -> LED off");
          digitalWrite(led, 0);
        }    
      }
    }
  }  
}


void handleRoot() {
  digitalWrite(led, 1);
  handleLogRequest();
  digitalWrite(led, 0);
}

void handleLogRequest() {
    char buffer[LOG_BUFFER_SIZE];  
    size_t pos = logReadPos;
    size_t index = 0;

    while (pos != logWritePos && index < LOG_BUFFER_SIZE - 2) { 
        buffer[index++] = logBuffer[pos];
        pos = (pos + 1) % LOG_BUFFER_SIZE;
        if (logBuffer[pos] == '\0') {  
            buffer[index++] = '\n';
            pos = (pos + 1) % LOG_BUFFER_SIZE;  
        }
    }
    buffer[index] = '\0'; 

    server.send(200, "text/plain", buffer);
}

void handleNotFound() {
  digitalWrite(led, 1);
  String message = "Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
  digitalWrite(led, 0);
}

void logMessageChar(char c) {
    char buffer[2] = {c, '\0'};  
    logMessage(buffer);
}

void logMessageInt(uint32_t num) {
    char buffer[32]; 
    snprintf(buffer, sizeof(buffer), "%lu", num); 
    logMessage(buffer);
}

void logMessage(const __FlashStringHelper *message) {
    char buffer[256];
    strncpy_P(buffer, (PGM_P)message, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0';  
    logMessage(buffer);  
}

void logMessagef(const char *format, ...) {
    char *logEntry = (char *)malloc(256);
    if (!logEntry) return;  

    va_list args;
    va_start(args, format);
    vsnprintf(logEntry, 256, format, args);
    va_end(args);

    logMessage(logEntry);
    free(logEntry); 
}

void logMessage(const char *message) {
    char logEntry[256]; 
    unsigned long timestamp = millis(); 
    snprintf(logEntry, sizeof(logEntry), "[%lums] %s", timestamp, message);
    logToBuffer(logEntry);
}

void logToBuffer(const char *message) {
    size_t msgLen = strlen(message);

    if (msgLen >= LOG_BUFFER_SIZE) {
        msgLen = LOG_BUFFER_SIZE - 1;
    }

    while (logUsed + msgLen + 1 > LOG_BUFFER_SIZE) {
        size_t oldMsgLen = strlen(&logBuffer[logReadPos]) + 1;
        logReadPos = (logReadPos + oldMsgLen) % LOG_BUFFER_SIZE;
        logUsed -= oldMsgLen;
    }

    for (size_t i = 0; i < msgLen; i++) {
        logBuffer[logWritePos] = message[i];
        logWritePos = (logWritePos + 1) % LOG_BUFFER_SIZE;
    }

    logBuffer[logWritePos] = '\0';
    logWritePos = (logWritePos + 1) % LOG_BUFFER_SIZE;
    logUsed += msgLen + 1;
}