IoT-Based Prolonged Sitting Intervention Device

#include <WiFi.h>
#include <NetworkClient.h>
#include <WiFiAP.h>

const char *ssid = "ESP32Network";
const char *password = "12345678";

const int trigPin = 4;
const int echoPin = 5;

const int buzzerPin = 23;
const int ledPin = 18;

long inches;
bool sitting;
bool buzzerState = false;
bool ledState = false;

unsigned long sittingTimer = 0;
unsigned long standingTimer = 0;

unsigned long lastUpdate = 0;

NetworkServer server(80);

inline void buzzerOn()  { digitalWrite(buzzerPin, HIGH); buzzerState = true; }
inline void buzzerOff() { digitalWrite(buzzerPin, LOW); buzzerState = false; }
inline void ledOn()  { digitalWrite(ledPin, HIGH); ledState = true; }
inline void ledOff() { digitalWrite(ledPin, LOW); ledState = false; }

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin, OUTPUT);

  Serial.begin(115200);
  Serial.println();
  Serial.println("Configuring access point...");

  if (!WiFi.softAP(ssid, password)) {
    log_e("Soft AP creation failed.");
    while (1);
  }
  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(myIP);
  server.begin();

  Serial.println("Server started");
}

void loop() {
  unsigned long now = millis();

  if (now - lastUpdate >= 100){
    lastUpdate = now;

    inches = getDistance();

    sitting = (inches > 0 && inches < 15);

    if(sitting) {
      sittingTimer += 100;
      standingTimer = 0;
    }
    else{
      standingTimer += 100;
    }


    if(standingTimer >= 5000){
      sittingTimer = 0;
    }

    Serial.print("Distance (in): ");
    Serial.print(inches);
    Serial.print(" | Sitting Timer (ms): ");
    Serial.print(sittingTimer);
    Serial.print(" | Standing Timer (ms): ");
    Serial.println(standingTimer);
  }

  if (sittingTimer >= 5000){
    ledOn();
    if(sitting){
      buzzerOn();
    }
    else{
      buzzerOff();
    }
  }
  else{
    ledOff();
    buzzerOff();
  }
  delay(100);

  NetworkClient client = server.accept(); // listen for incoming clients

  if (client) { // if we get a client,
    Serial.println("New Client.");  
    String currentLine = ""; // make a String to hold incoming data from the client
    String reqPath = "";
    bool gotRequestLine = false;

    while (client.connected()) { //loop while the client is connected
      if (client.available()) { //if there are bytes to read from the client
        char c = client.read(); //read a byte
        Serial.write(c); //print it out the serial monitor
        if (c == '\n') { //if the byte is a newline character

          //manual HTTP parsing
          if (!gotRequestLine && currentLine.startsWith("GET ")) { //only parse the first request, only parse GET requests
            int start = 4; //skip the "GET "
            int end = currentLine.indexOf(' ', start); //find the next space starting from the start
            if (end > start) reqPath = currentLine.substring(start, end); //make sure we have a valid path, then get the substring
            gotRequestLine = true;
          }

          if (currentLine.length() == 0) { //end of headers, respond based on path now

            if (reqPath == "/status") {
              sendStatusJSON(client);
            }
            else if (reqPath == "/resetsit"){
              sendResetSittingTimer(client);
            }
            else if (reqPath == "/resetstand"){
              sendResetStandingTimer(client);
            }
            else{ //if the path is anything but status, resetsit, or resetstand just give them the default page
              sendIndexPage(client);
            }
            break; //break out of header loop after response
          }
          else{
            currentLine = ""; //reset the currentLine so that multiple lines do not get jammed together
          }
        }
        else if (c != '\r'){ //we dont care about carriage return, so we skip it, any other character goes into the string
          currentLine += c;
        }
      }
      else{ //no more bytes available
        delay(1);
      }
    }
    // close the connection:
    client.stop();
    Serial.println("Client Disconnected.");
  }
}

//HTML pages
void sendStatusJSON(NetworkClient& client) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: application/json");
  client.println("Cache-Control: no-cache, no-store, must-revalidate"); //Always get the newest version, do not store it, since data will change
  client.println("Pragma: no-cache"); //Legacy cache control
  client.println("Expires: 0"); //content is already expired, must be fetched again next time
  client.println();
  String json = "{";
  json += "\"distance\":" + String(inches) + ",";
  json += "\"sitting\":" + String(sitting ? "true" : "false") + ",";
  json += "\"sitting_time\":" + String(sittingTimer) + ",";
  json += "\"standing_time\":" + String(standingTimer) + ",";
  json += "\"led_status\":" + String(ledState ? "true" : "false") + ",";
  json += "\"buzzer_status\":" + String(buzzerState ? "true" : "false");
  json += "}";
  client.print(json);
}

void sendResetSittingTimer(NetworkClient& client){ //we will only call this one async, we won't visit it, so we do not need to write actual html for the page
  sittingTimer = 0;
  client.println("HTTP/1.1 200 OK");
  client.println("Content-type: text/plain");
  client.println("Cache-Control: no-cache");
  client.println();
}


void sendResetStandingTimer(NetworkClient& client){
  standingTimer = 0;
  client.println("HTTP/1.1 200 OK");
  client.println("Content-type: text/plain");
  client.println("Cache-Control: no-cache");
  client.println();
}

void sendIndexPage(NetworkClient& client){
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println("Cache-Control: no-cache");
  client.println();
  client.println(F( //Flash string literal so we can store this large chunk of static text in flash instead of RAM
  "<html>"
  "<head>"
  "<style>"
  "body{"
  "background: black;"
  "color: white;"
  "display: flex;"
  "flex-direction: column;"
  "justify-content: center;"
  "align-items: center;"
  "min-height: 100vh;"
  "text-align: center;"
"}"

"h3{"
  "background-color: blue;"
  "margin-top: -20px;"
  "margin: 0;"
  "width: 100%;"
"}"

"table{"
  "margin-top: 5px;"
  "border-collapse: collapse;"
"}"

"td,th{"
  "border: 1px, solid;"
  "padding: 3px;"
"}"

"td:nth-child(1){"
  "text-align: left;"
"}"

"td:nth-child(2){"
  "text-align: center;"
"}"

"button{"
  "margin-top: 2px;"
  "height: 30px;"
  "width: 150px;"
"}"
  "</style>"
  "</head>"
  "<body>"
    "<h3>ESP32 Sitting Monitor</h3>"
    "<table>"
        "<tr>"
          "<td>"
            "Distance: "
          "</td>"
          "<td>"
            "<span id='distanceVal'>-</span>"
          "</td>"
          "<td>in</td>"
        "</tr>"

        "<tr>"
          "<td>"
            "Sitting: "
          "</td>"
          "<td>"
            "<span id='sittingVal'>-</span>"
          "</td>"
          "<td></td>"
        "</tr>"

        "<tr>"
          "<td>"
            "Sitting Time: "
          "</td>"
          "<td>"
            "<span id='sittingTimeVal'>-</span>"
          "</td>"
          "<td>ms</td>"
        "</tr>"

        "<tr>"
          "<td>"
            "Standing Time: "
          "</td>"
          "<td>"
            "<span id='standingTimeVal'>-</span>"
          "</td>"
          "<td>ms</td>"
        "</tr>"

        "<tr>"
          "<td>"
            "LED Status: "
          "</td>"
          "<td>"
            "<span id='ledStatusVal'>-</span>"
          "</td>"
          "<td></td>"
        "</tr>"

        "<tr>"
          "<td>"
            "Buzzer Status: "
          "</td>"
          "<td>"
            "<span id='buzzerStatusVal'>-</span>"
          "</td>"
          "<td></td>"
        "</tr>"
    "</table>"
    "<button onclick='resetSit()'>Reset Sitting Time</button>"
    "<button onclick='resetStand()'>Reset Standing Time</button>"
    "<script>"
      "async function poll(){"
        " let r=await fetch('/status');"
        " if(!r.ok)return;" //asynchronously fetch the updated values using our json page
        " let j=await r.json();" //convert the results to json
        " distanceVal.innerText=j.distance;" //update the text values of different html elements with the new values we got from the json page
        " sittingVal.innerText=j.sitting;"
        " sittingTimeVal.innerText=j.sitting_time;"
        " standingTimeVal.innerText=j.standing_time;"
        " ledStatusVal.innerText=j.led_status;"
        " buzzerStatusVal.innerText=j.buzzer_status;"
      "}"
      "setInterval(poll,1000);" //call poll once per second to keep the values current, but not overwhelm the esp32 with requests
      "poll();" //initial poll call
      "async function resetSit(){await fetch('/resetsit');sittingTimeVal.innerText=0;}" //asynchronously calls the other page, which resets the sit timer. Manually set sit timer to 0
      "async function resetStand(){await fetch('/resetstand');standingTimeVal.innerText=0;}"
    "</script>"
  "</body></html>"
  ));
}

long getDistance(){
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  long duration = pulseIn(echoPin, HIGH);

  return duration / 2 /74;
}

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>

const int ledPin = 5;
const int motorPin = 4;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(motorPin, OUTPUT);
  Serial.begin(115200);

  Serial.println();
  Serial.println();
  Serial.println();

  for (uint8_t t = 4; t > 0; t--) {
    Serial.printf("[SETUP] WAIT %d...\n", t);
    Serial.flush();
    delay(1000);
  }

  WiFi.mode(WIFI_STA); //this device should behave as a wifi client
  WiFi.begin("ESP32Network", "12345678");
}

void loop() {
  if ((WiFi.status() == WL_CONNECTED)) { //Checking if we are currently connected to a network

    WiFiClient client;
    HTTPClient http;

    if (http.begin(client, "http://192.168.4.1/status")) {

      int httpCode = http.GET(); //sending an HTTP get to the url we specified
      if (httpCode > 0) { //negative values mean communication errors

        if (httpCode == HTTP_CODE_OK) {
          String payload = http.getString();
          Serial.println(payload);

          //find LED status
          int ledIdx = payload.indexOf("\"led_status\":"); //Get the index of the led_status substring
          bool ledStatus = false;
          if (ledIdx >= 0) { // if the number is -1, that means the string was not found
            int start = payload.indexOf(":", ledIdx) + 1;
            int end = payload.indexOf(",", start);
            String val = payload.substring(start, end); //get the substring
            val.trim(); //get rid of random whitespaces or newline
            ledStatus = (val == "true");
          }

          //find buzzer status
          int buzIdx = payload.indexOf("\"buzzer_status\":");
          bool buzzerStatus = false;
          if (buzIdx >= 0) {
            int start = payload.indexOf(":", buzIdx) + 1;
            int end = payload.indexOf("}", start);
            String val = payload.substring(start, end);
            val.trim();
            buzzerStatus = (val == "true");
          }

          Serial.print("LED Status: ");
          Serial.println(ledStatus ? "ON" : "OFF");
          digitalWrite(ledPin, ledStatus);

          Serial.print("Buzzer Status: ");
          Serial.println(buzzerStatus ? "ON" : "OFF");
          digitalWrite(motorPin, buzzerStatus);
        }

      } 
      else { //code that is > 0 and not == 200 means some sort of http error
        Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str()); //convert to C style string that the errorToString expects
      }

      http.end();
    }
  }

  delay(1000);
}