Project Postman

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ElegantOTA.h>
#include <WebSerial.h>
#include <LittleFS.h>
#include <SoftwareSerial.h>
#include <Preferences.h>
#include <Seeed_Arduino_SSCMA.h>
#include <ArduinoJson.h>
#include "time.h"
#include "FS.h"
#include "SD.h"
#include "SPI.h"
#include "esp_mac.h"
#include <esp_task_wdt.h>

#define FIRMWAREVERSION "EO 1.0"  // E-ESP32 O-open source 1.0 Version
#define SD_CS_PIN 21              // XIAO ESP32-S3 CS pin
#define host "ProjectPostmanESP"  // Hostname for the netowrk.
#define TASK_STACK_SIZE 8192

const char *AP_ssid = "XIAO_ESP32S3";
const char *AP_password = "123456789";
// String ssid = "Xtream_2.4G_CC93";
// String password = "zwtt3xbe";
String ssid = "Thomas";
String password = "Qcpeds*7";
const char *http_username = "admin";
const char *http_password = "admin";

struct deviceInfo {
  String deviceModel;
  uint32_t chipID;
  uint8_t chipCores;
  String MAC_Address;
  String firmware;
  String ssid;
  String wifi_password;
  int32_t signalstrength;
  String hostname;
  IPAddress IP;
  bool wificonnected;
  String uptime;
  long gmtoffset;
  int daylightoffset;
  unsigned long interval;
  bool setup;
};

struct user {
  String username;
  String password;
  String email;
  String phonenumber;
  char pin[6];
  bool admin;
};

deviceInfo esp32Info = {
  "",         // deviceModel
  0,          // chipID
  0,          // chipCores
  "",         // MAC_Address
  "",         // firmware
  "",         // ssid
  "",         // wifi_password
  0,          // signalstrength
  "",         // hostname
  "",         // IP
  false,      // wificonnected
  "",         // uptime
  -3600 * 5,  // gmtoffset
  0,          // daylightoffset
  30000,      // interval
  false       // setup
};

user userid[6];
AsyncWebServer server(80);       // Create AsyncWebServer object on port 80
SoftwareSerial espSerial(4, 3);  // (D2 = 3) RX, (D3 = 4) TX pins for ESP32
Preferences device;
Preferences userdata;
SSCMA AI;

String requestBody = "";
String lastImage = "";
bool streaming = false;  // Flag to manage streaming state
bool lock = true;        // Flag to manage lock state
unsigned long previousMillis = 0;

void setTime(const char *tz);
void notFound(AsyncWebServerRequest *request);
void rebootESP(String message);
void listDirContents(File dir, String path, String &returnText, bool ishtml);
String listFiles(bool ishtml);
String humanReadableSize(const size_t bytes);
String getContentType(String filename);
String getLocalTimeStr();
bool initSDCard();
void writeFile(fs::FS &fs, const char *path, const char *message);
void appendFile(fs::FS &fs, const char *path, const char *message);
void recordGrove();
void alert(const char *message);
void logSD(const char *message, bool serial = true);
int year();
int month();
void createDirectories(const char *path);
String getInterfaceMacAddress(esp_mac_type_t interface);
bool setupWiFi(const char *newSSID, const char *newPassword);
String getUptime();
String listRecordings();
void listDirContentsJson(File dir, String path, JsonArray &filesArray);
void saveUserData(int index);
void loadUserData(int index);
void saveDeviceInfoToPreferences(const deviceInfo &info);
void getDeviceInfoFromPreferences(deviceInfo &info);
void clearAllPreferences();

void formatLittleFS() {
  Serial.println("Formatting LittleFS...");
  if (LittleFS.format()) {
    Serial.println("LittleFS formatted successfully.");
  } else {
    Serial.println("Failed to format LittleFS.");
  }
}

void notFound(AsyncWebServerRequest *request) {
  request->send(404, "text/plain", "Not found");
}

void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) {
  if (!index) {
    Serial.printf("BodyStart: %u B\n", total);
  }
  for (size_t i = 0; i < len; i++) {
    Serial.write(data[i]);
  }
  if (index + len == total) {
    Serial.printf("BodyEnd: %u B\n", total);
  }
}

void setup() {
  Serial.begin(115200);                     // Initialize the Arduino serial port
  espSerial.begin(115200);                  // Initialize the ESP8266 serial port
  getDeviceInfoFromPreferences(esp32Info);  // Retrieve device info from Preferences
  for (int i = 0; i < 6; i++) {
    loadUserData(i);
  }

  if (!LittleFS.begin()) {
    Serial.println("An Error has occurred while mounting LittleFS");
    formatLittleFS();  // Format LittleFS if mounting fails
    if (!LittleFS.begin()) {
      Serial.println("Failed to mount LittleFS after formatting");
      return;
    }
  }
  if (!initSDCard()) {
    Serial.println("An Error has occurred while initiating the SD Card");
    return;
  }
  if (!AI.begin()) {
    Serial.println("Grove Vision AI not initiated");
  }

  esp32Info.chipID = (uint32_t)(ESP.getEfuseMac() >> 32);
  esp32Info.deviceModel = String(ESP.getChipModel()) + " Rev " + String(ESP.getChipRevision());
  esp32Info.chipCores = ESP.getChipCores();
  esp32Info.firmware = FIRMWAREVERSION;
  esp32Info.wificonnected = setupWiFi(ssid.c_str(), password.c_str());

  if (!esp32Info.setup) {
    Serial.println("Device not set up. Starting setup...");
    // Setup file structure
    createDirectories("/alerts");
    createDirectories("/packages");
    createDirectories("/recordings");
    createDirectories("/device");
    createDirectories("/device/logs");
    createDirectories("/device/users");
    createDirectories("/device/config");
    createDirectories("/device/firmware");

    server.on("/finsh", HTTP_GET, [](AsyncWebServerRequest *request) {
      esp32Info.setup = true;
      saveDeviceInfoToPreferences(esp32Info);
      saveUserData(0);
      request->send(200, "text/plain", "Setup Complete");
      Serial.println("Device setup complete. Rebooting ESP32...");
      delay(5000);
      rebootESP("Device setup complete");
    });
  } else {
    Serial.println("Device already set up. Starting main program...");
    for (int i = 0; i < 6; i++)
      loadUserData(i);
  }

  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (!esp32Info.setup) {
      request->send(LittleFS, "/setup.html", "text/html");
    } else {
      request->send(LittleFS, "/index.html", "text/html");
    }
  });

  server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(LittleFS, "/style.css", "text/css");
  });
  server.on("/script.js", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(LittleFS, "/script.js", "application/javascript");
  });
  server.on("/favicon.ico", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(LittleFS, "/favicon.ico", "application/javascript");
  });

  server.on("/stream", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (lastImage.length() > 0) {
      String response = lastImage;
      request->send(200, "text/plain", response);
    } else {
      request->send(200, "text/plain", "data:,");  // Send an empty data URL to avoid errors
    }
  });

  server.on("/startStream", HTTP_GET, [](AsyncWebServerRequest *request) {
    streaming = true;
    request->send(200, "text/plain", "Stream started");
  });

  server.on("/stopStream", HTTP_GET, [](AsyncWebServerRequest *request) {
    streaming = false;
    request->send(200, "text/plain", "Stream stopped");
  });

  server.on("/lock", HTTP_GET, [](AsyncWebServerRequest *request) {
    lock = true;
    alert("Lock");
    request->send(200, "text/plain", "Locked");
  });

  server.on("/unlock", HTTP_GET, [](AsyncWebServerRequest *request) {
    lock = false;
    alert("Unlocked");
    request->send(200, "text/plain", "Unlocked");
  });

  server.on("/alerts", HTTP_GET, [](AsyncWebServerRequest *request) {
    char path[64];
    snprintf(path, sizeof(path), "/alerts/%04d-%02d.txt", year(), month());
    File file = SD.open(path, FILE_READ);
    if (file) {
      String alertContent = file.readString();
      request->send(200, "text/plain", alertContent);
      file.close();
    } else {
      request->send(500, "text/plain", "Failed to read file");
    }
  });

  server.on("/list-recordings", HTTP_GET, [](AsyncWebServerRequest *request) {
    String files = listRecordings();
    request->send(200, "application/json", files);
  });

  server.on("/play-recording", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (request->hasParam("file")) {
      String filename = request->getParam("file")->value();
      File file = SD.open("/recordings/" + filename);
      if (file) {
        AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain",
                                                                         [file](uint8_t *buffer, size_t maxLen, size_t index) mutable -> size_t {
                                                                           if (file.available()) {
                                                                             size_t bytesRead = file.read(buffer, maxLen);
                                                                             return bytesRead;
                                                                           } else {
                                                                             file.close();
                                                                             return 0;  // No more data to send
                                                                           }
                                                                         });
        request->send(response);
      } else {
        request->send(404, "text/plain", "File not found");
      }
    } else {
      request->send(400, "text/plain", "Bad Request");
    }
  });

  server.on("/download", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (request->hasParam("file")) {
      String filePath = request->getParam("file")->value();
      if (SD.exists(filePath)) {
        String contentType = getContentType(filePath);
        request->send(SD, filePath.c_str(), contentType, true);
      } else {
        request->send(404, "text/plain", "File not found");
      }
    } else {
      request->send(400, "text/plain", "Filename not specified");
    }
  });

  server.on("/delete", HTTP_DELETE, [](AsyncWebServerRequest *request) {
    if (request->hasParam("file")) {
      String filePath = request->getParam("file")->value();
      if (SD.remove(filePath.c_str())) {
        request->send(200, "text/plain", "File deleted successfully");
      } else {
        request->send(500, "text/plain", "Failed to delete file");
      }
    } else {
      request->send(400, "text/plain", "File not specified");
    }
  });

  server.on("/packages", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(LittleFS, "/index.html", "text/html");
  });

  server.on("/reboot", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(200, "text/plain", "Rebooting ESP32...");
    delay(100);
    rebootESP("Requested from the Async Web Server");
  });

  server.on("/scan-networks", HTTP_GET, [](AsyncWebServerRequest *request) {
    int numNetworks = WiFi.scanNetworks();
    String response = "[";
    for (int i = 0; i < numNetworks; i++) {
      if (i > 0) response += ",";
      response += "{\"ssid\":\"" + WiFi.SSID(i) + "\",\"signal_strength\":" + String(WiFi.RSSI(i)) + "}";
    }
    response += "]";
    request->send(200, "application/json", response);
  });

  server.on("/connect", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (request->hasParam("ssid") && request->hasParam("password")) {
      String tempssid = request->getParam("ssid")->value();
      String temppassword = request->getParam("password")->value();
      Serial.println("Connecting to SSID: " + tempssid);

      if (setupWiFi(tempssid.c_str(), temppassword.c_str())) {  // Attempt to connect to the new Wi-Fi network
        esp32Info.wificonnected = true;
        request->send(200, "text/plain", "Connected to new network");
      } else {  // Failed to connect, try reconnecting to the previous network or set up an access point
        if (!setupWiFi(esp32Info.ssid.c_str(), esp32Info.wifi_password.c_str())) {
          esp32Info.wificonnected = false;
          request->send(500, "text/plain", "Failed to connect to new network and access point set up.");
        } else {
          request->send(200, "text/plain", "Failed to connect to new network, reconnected to previous network.");
        }
      }
    } else {
      request->send(400, "text/plain", "Missing SSID or password");
    }
  });

  server.on("/set-timezone", HTTP_GET, [](AsyncWebServerRequest *request) {
    if (request->hasParam("timezone")) {
      String timezone = request->getParam("timezone")->value();
      Serial.println(timezone);
      setTime(timezone.c_str());
    }
    if (request->hasParam("gmtoffset") && request->hasParam("daylightoffset")) {
      esp32Info.gmtoffset = request->getParam("gmtoffset")->value().toInt();
      esp32Info.gmtoffset = esp32Info.gmtoffset * 3600;
      Serial.println(esp32Info.gmtoffset);
      esp32Info.daylightoffset = request->getParam("daylightoffset")->value().toInt();
      Serial.println(esp32Info.daylightoffset);
      configTime(esp32Info.gmtoffset, esp32Info.daylightoffset, "pool.ntp.org");
    }

    time_t now;
    struct tm timeinfo;
    time(&now);
    localtime_r(&now, &timeinfo);

    char timeString[64];
    strftime(timeString, sizeof(timeString), "%Y-%m-%d %H:%M:%S", &timeinfo);
    Serial.println(String(timeString));
    request->send(200, "text/plain", String(timeString));
  });

  server.on("/logs", HTTP_GET, [](AsyncWebServerRequest *request) {
    String logs = listFiles(true);  // Pass true to get HTML-formatted output
    request->send(200, "text/html", logs);
  });

  server.on("/manage-users", HTTP_GET, [](AsyncWebServerRequest *request) {
    DynamicJsonDocument doc(1024);
    JsonArray users = doc.createNestedArray("users");

    for (int i = 0; i < 6; i++) {
      JsonObject userObj = users.createNestedObject();
      userObj["username"] = userid[i].username;
      userObj["password"] = userid[i].password;
      userObj["email"] = userid[i].email;
      userObj["phonenumber"] = userid[i].phonenumber;
      userObj["admin"] = userid[i].admin;
      userObj["pin"] = String(userid[i].pin, 6);
    }

    String response;
    serializeJson(doc, response);
    request->send(200, "application/json", response);
  });

  server.on("/add-user", HTTP_POST, [](AsyncWebServerRequest *request) {
    String name, mail, word, phone, pinStr;
    bool admin;
    if (request->hasParam("username", true)) {
      name = request->getParam("username", true)->value();
    }
    if (request->hasParam("password", true)) {
      word = request->getParam("password", true)->value();
    }
    if (request->hasParam("email", true)) {
      mail = request->getParam("email", true)->value();
    }
    if (request->hasParam("phonenumber", true)) {
      phone = request->getParam("phonenumber", true)->value();
    }
    if (request->hasParam("pin", true)) {
      pinStr = request->getParam("pin", true)->value();
    }
    if (request->hasParam("admin", true)) {
      admin = request->getParam("admin", true)->value();
    }

    Serial.println("User Profile Updated:");
    Serial.println("Username: " + name);
    Serial.println("Password: " + word);
    Serial.println("Email: " + mail);
    Serial.println("Phone Number: " + phone);
    Serial.print("PIN: ");
    Serial.println(pinStr);
    Serial.println("Admin: " + String(admin));

    for (int i = 0; i < 6; i++) {
      if (userid[i].username == "") {
        userid[i].username = name;
        userid[i].password = word;
        userid[i].email = mail;
        userid[i].phonenumber = phone;
        userid[i].admin = admin;
        pinStr.toCharArray(userid[i].pin, 6);
        saveUserData(i);
        request->send(200, "text/plain", "User added successfully");
        return;
      }
    }
  });

  server.on("/delete-user", HTTP_DELETE, [](AsyncWebServerRequest *request) {
    if (request->hasParam("index")) {
      int index = request->getParam("index")->value().toInt();
      if (index >= 0 && index < 6) {
        userid[index] = user();  // Clear user data
        saveUserData(index);
        request->send(200, "text/plain", "User deleted successfully");
      } else {
        request->send(400, "text/plain", "Invalid index");
      }
    } else {
      request->send(400, "text/plain", "Missing index parameter");
    }
  });

  server.on(
    "/post", HTTP_POST, [](AsyncWebServerRequest *request) {},
    NULL, [](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) {
      //Handling function implementation
      for (size_t i = 0; i < len; i++) {
        Serial.write(data[i]);
      }
    });

  server.on(
    "/modify-user", HTTP_POST, [](AsyncWebServerRequest *request) {},
    NULL, [](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) {
      // Allocate a temporary JsonDocument
      const size_t capacity = JSON_OBJECT_SIZE(6) + 200;
      DynamicJsonDocument doc(capacity);

      // Create a static buffer to hold the incoming data
      static String requestBody;

      // Append the incoming data to the requestBody
      for (size_t i = 0; i < len; i++) {
        requestBody += (char)data[i];
      }

      // If this is the last chunk of data
      if (index + len == total) {
        // Log the request body
        Serial.println("Request Body: " + requestBody);

        // Parse JSON object
        DeserializationError error = deserializeJson(doc, requestBody);
        if (error) {
          Serial.print(F("deserializeJson() failed: "));
          Serial.println(error.f_str());
          request->send(400, "text/plain", "Invalid JSON");
          requestBody = "";  // Clear the buffer
          return;
        }

        // Extract values
        int index = doc["index"];
        if (index >= 0 && index < 6) {
          userid[index].username = doc["username"].as<String>();
          userid[index].password = doc["password"].as<String>();
          userid[index].email = doc["email"].as<String>();
          userid[index].phonenumber = doc["phonenumber"].as<String>();
          strcpy(userid[index].pin, doc["pin"].as<String>().c_str());
          userid[index].admin = doc["admin"].as<bool>();
          saveUserData(index);
          request->send(200, "text/plain", "User modified successfully");
        } else {
          request->send(400, "text/plain", "Invalid index");
        }

        // Clear the buffer after processing
        requestBody = "";
      }
    });

  server.on("/device-info", HTTP_GET, [](AsyncWebServerRequest *request) {
    DynamicJsonDocument doc(1024);

    doc["deviceModel"] = esp32Info.deviceModel;
    doc["chipID"] = esp32Info.chipID;
    doc["chipCores"] = esp32Info.chipCores;
    doc["MAC_Address"] = esp32Info.MAC_Address;
    doc["firmware"] = esp32Info.firmware;
    doc["ssid"] = esp32Info.ssid;
    doc["wifi_password"] = esp32Info.wifi_password;
    doc["signalstrength"] = esp32Info.signalstrength;
    doc["hostname"] = esp32Info.hostname;
    doc["IP"] = esp32Info.IP.toString();
    doc["wificonnected"] = esp32Info.wificonnected;
    doc["uptime"] = millis();
    doc["gmtoffset"] = esp32Info.gmtoffset;
    doc["daylightoffset"] = esp32Info.daylightoffset;
    doc["interval"] = esp32Info.interval;
    doc["setup"] = esp32Info.setup;
    doc["time"] = getLocalTimeStr();

    String response;
    serializeJson(doc, response);
    request->send(200, "application/json", response);
  });

  server.on("/module-status", HTTP_GET, [](AsyncWebServerRequest *request) {
    DynamicJsonDocument doc(1024);  // Create a JSON document with sufficient memory

    JsonObject sdCard = doc.createNestedObject("sdCard");
    sdCard["module"] = "SD Card";
    if (SD.begin()) {
      sdCard["status"] = "Connected";
      sdCard["ready"] = true;
    } else {
      sdCard["status"] = "Disconnected";
      sdCard["ready"] = false;
    }

    // AI Sensor status (pseudo-code)
    JsonObject aiSensor = doc.createNestedObject("aiSensor");
    aiSensor["module"] = "AI Sensor";
    if (!AI.invoke(1, false, false)) {
      aiSensor["status"] = "Connected";
      aiSensor["ready"] = true;
    } else {
      aiSensor["status"] = "Disconnected";
      aiSensor["ready"] = false;
    }

    // nRF45 status
    JsonObject nrf45 = doc.createNestedObject("nrf45");
    nrf45["module"] = "nRF45";
    if (false) {
      nrf45["status"] = "Connected";
      nrf45["ready"] = true;
    } else {
      nrf45["status"] = "Disconnected";
      nrf45["ready"] = false;
    }

    // Unihiker status
    JsonObject unihiker = doc.createNestedObject("unihiker");
    unihiker["module"] = "Unihiker";
    if (false) {  //Need to update
      unihiker["status"] = "Connected";
      unihiker["ready"] = true;
    } else {
      unihiker["status"] = "Disconnected";
      unihiker["ready"] = false;
    }

    String json;
    serializeJson(doc, json);
    request->send(200, "application/json", json);
  });

  server.on("/resestxyz", HTTP_GET, [](AsyncWebServerRequest *request) {
    //Check user name and password and admin status
    if (true) {
      //clear SD card.
      if (SD.begin(SD_CS_PIN)) {
        Serial.println("SD card initialized to be formated");
        File root = SD.open("/");
        while (true) {
          File entry = root.openNextFile();
          if (!entry) {
            break;
          }
          if (entry.isDirectory()) {
            entry.close();
            continue;
          }
          Serial.print("Deleting file: ");
          Serial.println(entry.name());
          SD.remove(entry.name());
          entry.close();
        }
        root.close();
      } else {
        Serial.println("Failed to initialize SD card");
      }
      //clear preferences
      clearAllPreferences();
      Serial.println("Preferences cleared. Rebooting ESP32...");
      delay(5000);
      rebootESP("Reset Requested");
    }

    request->send(200, "text/html", "Reset Requested");
  });

  ElegantOTA.begin(&server);
  WebSerial.begin(&server);
  WebSerial.onMessage([&](uint8_t *data, size_t len) {
    Serial.printf("Received %lu bytes from WebSerial: ", len);
    Serial.write(data, len);
    Serial.println();
    WebSerial.println("Received Data...");
    String d = "";
    for (size_t i = 0; i < len; i++) {
      d += char(data[i]);
    }
    WebSerial.println(d);
  });
  server.onRequestBody(handleBody);
  server.begin();
  Serial.print("Web Server Ready! Use 'http://");
  Serial.print(esp32Info.IP);
  Serial.println("' to connect");
}

void loop() {
  if (streaming)  // Streaming imgages
    while (streaming) {
      if (!AI.invoke(1, false, true)) {
        if (AI.last_image().length() > 0) {
          lastImage = AI.last_image();
          // Serial.println("Captured Image: " + lastImage);
        }
      }
    }
  else if (!AI.invoke()) {  // if sensor sees person then take snapshots for 30 seconds as according to recordGrove
    for (int i = 0; i < AI.boxes().size(); i++)
      if (AI.boxes()[i].score > 70) {
        alert("Person detected. 30sec recording to begin.");
        recordGrove();
      }
  }
  ElegantOTA.loop();
  WebSerial.loop();
}

void rebootESP(String message) {
  logSD("Rebooting ESP32: ");
  logSD(message.c_str());
  ESP.restart();
}

void listDirContents(File dir, String path, String &returnText, bool ishtml) {
  File file = dir.openNextFile();
  while (file) {
    if (file.isDirectory()) {
      String dirName = path + "/" + String(file.name());
      if (ishtml) {
        returnText += "<tr><td><b>Directory:</b> " + dirName + "</td><td></td><td></td><td></td></tr>";
      } else {
        returnText += "Directory: " + dirName + "\n";
      }
      listDirContents(file, dirName, returnText, ishtml);  // Recursively list the contents of the directory
    } else {
      if (ishtml) {
        returnText += "<tr align='left'><td>" + path + "/" + String(file.name()) + "</td><td>" + humanReadableSize(file.size()) + "</td>";
        returnText += "<td><button onclick=\"downloadDeleteButton('" + path + "/" + String(file.name()) + "', 'download')\">Download</button></td>";
        returnText += "<td><button onclick=\"downloadDeleteButton('" + path + "/" + String(file.name()) + "', 'delete')\">Delete</button></td></tr>";
      } else {
        returnText += "File: " + path + "/" + String(file.name()) + " Size: " + humanReadableSize(file.size()) + "\n";
      }
    }
    file = dir.openNextFile();
  }
}

// Function to list all files and directories on the SD card
String listFiles(bool ishtml) {
  String returnText = "";
  Serial.println("Listing files stored on SD card");

  File root = SD.open("/");
  if (ishtml) {
    returnText += "<table><tr><th align='left'>Name</th><th align='left'>Size</th><th></th><th></th></tr>";
  }
  listDirContents(root, "", returnText, ishtml);  // Call the recursive function
  if (ishtml) {
    returnText += "</table>";
    Serial.println(returnText);
  }
  root.close();

  return returnText;
}

String humanReadableSize(const size_t bytes) {  // Make size of files human readable
  if (bytes < 1024)
    return String(bytes) + " B";
  else if (bytes < (1024 * 1024))
    return String(bytes / 1024.0) + " KB";
  else if (bytes < (1024 * 1024 * 1024))
    return String(bytes / 1024.0 / 1024.0) + " MB";
  else
    return String(bytes / 1024.0 / 1024.0 / 1024.0) + " GB";
}

String getContentType(String filename) {  // need to remove if not using
  if (filename.endsWith(".htm"))
    return "text/html";
  else if (filename.endsWith(".html"))
    return "text/html";
  else if (filename.endsWith(".css"))
    return "text/css";
  else if (filename.endsWith(".js"))
    return "application/javascript";
  else if (filename.endsWith(".png"))
    return "image/png";
  else if (filename.endsWith(".gif"))
    return "image/gif";
  else if (filename.endsWith(".jpg"))
    return "image/jpeg";
  else if (filename.endsWith(".ico"))
    return "image/x-icon";
  else if (filename.endsWith(".xml"))
    return "text/xml";
  else if (filename.endsWith(".pdf"))
    return "application/pdf";
  else if (filename.endsWith(".zip"))
    return "application/zip";
  else if (filename.endsWith(".gz"))
    return "application/x-gzip";
  else if (filename.endsWith(".txt"))
    return "text/plain";
  return "application/octet-stream";  // Default binary type
}

bool initSDCard() {
  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("Card Mount Failed");
    return 0;
  }
  uint8_t cardType = SD.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return 0;
  }
  Serial.print("SD Card Type: ");
  if (cardType == CARD_MMC) {
    Serial.println("MMC");
  } else if (cardType == CARD_SD) {
    Serial.println("SDSC");
  } else if (cardType == CARD_SDHC) {
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);
  return 1;
}

void writeFile(fs::FS &fs, const char *path, const char *message) {
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.printf("Failed to open file for writing: %s\n", path);
    return;
  }
  if (file.print(message)) {
    // Serial.println("File written");
  } else {
    // Serial.println("Write failed");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char *path, const char *message) {
  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.printf("Failed to open file for appedning: %s\n", path);
    return;
  }
  if (file.print(message)) {
    // Serial.println("Message appended");
  } else {
    // Serial.println("Append failed");
  }
  file.close();
}

void recordGrove() {
  previousMillis = millis();
  unsigned long currentMillis = previousMillis;
  struct tm timeinfo;
  char filename[40];
  char timestamp[32];
  getLocalTime(&timeinfo);
  snprintf(filename, sizeof(filename), "/recordings/%04d-%02d-%02d-%02d-%02d-%02d.txt", timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
  writeFile(SD, filename, "Initial log\n");
  String dataToAppend = "";  // Initialize an empty string to accumulate data

  while (millis() - previousMillis < esp32Info.interval) {
    if (!AI.invoke(1, false, true))
      if (AI.last_image().length() > 0) {
        dataToAppend = AI.last_image() + "\n";  // Accumulate image data
        lastImage = dataToAppend;
        appendFile(SD, filename, dataToAppend.c_str());
      }
    currentMillis = millis();
  }
}

void alert(const char *message) {  // Function to append a message to an alert file
  char path[64];
  snprintf(path, sizeof(path), "/alerts/%04d-%02d.txt", year(), month());
  createDirectories(path);
  Serial.printf("Appending to alert file: %s\n", path);

  File file = SD.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open alert file for appending");
    return;
  }
  char timestamp[32];
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    snprintf(timestamp, sizeof(timestamp), "%04d-%02d-%02d %02d:%02d:%02d ", timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
    file.print(timestamp);
  }

  String messageWithNewline = String(message) + "\n";
  if (file.print(messageWithNewline))
    Serial.println("Alert message appended");
  else
    Serial.println("Append to alert file failed");
  file.close();
}

void logSD(const char *message, bool serial) {  // Function to append a message to a log file
  if (serial)
    Serial.println(message);
  char path[64];
  snprintf(path, sizeof(path), "/device/logs/%04d-%02d.txt", year(), month());
  createDirectories(path);
  Serial.printf("Appending to log file: %s\n", path);

  File file = SD.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open log file for appending");
    return;
  }

  char timestamp[32];
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    snprintf(timestamp, sizeof(timestamp), "%04d-%02d-%02d %02d:%02d:%02d ", timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
    file.print(timestamp);
  }

  String messageWithNewline = String(message) + "\n";
  if (file.print(messageWithNewline))
    Serial.println("Log message appended");
  else
    Serial.println("Append to log file failed");
  file.close();
}

int year() {  // Helper functions to get the current year
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    return timeinfo.tm_year + 1900;
  }
  return 1970;  // Default year if time is not available
}

int month() {  // Helper functions to get the current month
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    return timeinfo.tm_mon + 1;
  }
  return 1;  // Default month if time is not available
}

String getLocalTimeStr() {  // Helper function to get the current time as a string
  struct tm timeinfo;
  if (getLocalTime(&timeinfo)) {
    char timeString[32];
    strftime(timeString, sizeof(timeString), "%Y-%m-%d %H:%M:%S", &timeinfo);
    return String(timeString);
  }
  return "1970-01-01 00:00:00";  // Default time if time is not available
}

void createDirectories(const char *path) {  // Function to create directories if they do not exist
  char temp[64];
  char *pos = temp;
  snprintf(temp, sizeof(temp), "%s", path);

  for (pos = temp + 1; *pos; pos++) {
    if (*pos == '/') {
      *pos = '\0';
      SD.mkdir(temp);
      *pos = '/';
    }
  }
}

void setTime(const char *tz = "America/Chicago") {
  setenv("TZ", tz, 1);
  tzset();
}

String getInterfaceMacAddress(esp_mac_type_t interface) {
  String mac = "";
  unsigned char mac_base[6] = { 0 };
  if (esp_read_mac(mac_base, interface) == ESP_OK) {
    char buffer[18];  // 6*2 characters for hex + 5 characters for colons + 1 character for null terminator
    sprintf(buffer, "%02X:%02X:%02X:%02X:%02X:%02X", mac_base[0], mac_base[1], mac_base[2], mac_base[3], mac_base[4], mac_base[5]);
    mac = buffer;
  }
  return mac;
}

bool setupWiFi(const char *newSSID, const char *newPassword) {
  bool connected = false;
  int attempts;

  if (WiFi.getMode() == WIFI_AP) {  // Switch from AP mode to STA mode if necessary
    Serial.println("Currently in AP mode. Switching to STA mode...");
    WiFi.softAPdisconnect(true);
    delay(3000);
  }

  auto attemptConnection = [](const char *ssid, const char *password) {  // Function to attempt connection to a given Wi-Fi network
    WiFi.begin(ssid, password);
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
      delay(500);
      attempts++;
    }
    if (WiFi.status() == WL_CONNECTED) {
      WiFi.setHostname(host);
      esp32Info.ssid = ssid;
      esp32Info.wifi_password = password;
      esp32Info.signalstrength = WiFi.RSSI();
      esp32Info.IP = WiFi.localIP();
      esp32Info.MAC_Address = getInterfaceMacAddress(ESP_MAC_WIFI_STA);
      esp32Info.hostname = WiFi.getHostname();
      setTime("America/Chicago");
      configTime(esp32Info.gmtoffset, esp32Info.daylightoffset, "pool.ntp.org");
      return true;
    } else return false;
  };

  if (WiFi.status() == WL_CONNECTED) {  // If already connected, disconnect and try new network
    logSD("Currently connected to Wi-Fi. Disconnecting...");
    WiFi.disconnect();
    delay(3000);
    if (attemptConnection(newSSID, newPassword)) {
      logSD("Connected to new Wi-Fi network.");
      return true;
    } else {  // Retrieve previous network credentials
...

This file has been truncated, please download it to see its full contents.