Code Explanation for Mental Health Monitoring System

Below is a detailed explanation of the code for the mental health monitoring system using ESP32 with GSR, MAX30102, and BH1750 sensors. Each function is explained in detail with relevant mathematical formulations:

1. Configuration and Initialization

This section sets up the WiFi connection, GitHub settings for data storage, and sensor initialization.

#include "WiFi.h"
#include "HTTPClient.h"
#include "ArduinoJson.h"
#include "Wire.h"
#include "MAX30105.h"
#include "heartRate.h"
#include "BH1750.h"
#include "Base64.h"
#include "time.h"

// WiFi Configuration
const char* ssid = "Brickhouse 1";
const char* password = "AVOLUTION";

// GitHub Configuration
const char* gsrUrl = "https://api.github.com/repos/4211421036/MentalHealth/contents/GSR.json";
const char* maxUrl = "https://api.github.com/repos/4211421036/MentalHealth/contents/MAX30102.json";
const char* bhUrl = "https://api.github.com/repos/4211421036/MentalHealth/contents/BH1750.json";
const char* token = "Bearer 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";

// Time Configuration
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 25200;  // GMT+7
const int daylightOffset_sec = 0;

// Sensor Objects
MAX30105 particleSensor;
BH1750 lightMeter;

// Pin Config
const int GSR_PIN = 34;
const int WINDOW_SIZE = 5;  // For moving average GSR (Boucsein, 2012)

// Sensor Variables
float eda_buffer[WINDOW_SIZE] = {0};
int buffer_index = 0;
float beatsPerMinute, beatAvg;
byte rates[4], rateSpot = 0;
long lastBeat = 0;

Explanation:

• The libraries used include WiFi connection, HTTP client, JSON parser, I2C communication, and specific libraries for the MAX30105 and BH1750 sensors.
• WiFi configuration for internet connection.
• GitHub API configuration for cloud data storage.
• Initialization of sensor objects and pin configuration.
• WINDOW_SIZE = 5 is used for the moving average filter for GSR based on Boucsein (2012) recommendations.
• Buffer variables to store and process sensor data.

2. Function getCurrentSHA

This function retrieves the SHA value of the file on GitHub for update purposes.

String getCurrentSHA(const char* url) {
  HTTPClient http;
  String sha = "";
  http.begin(url);
  http.addHeader("Authorization", token);
  int httpCode = http.GET();
  
  if (httpCode == HTTP_CODE_OK) {
    DynamicJsonDocument doc(1024);
    deserializeJson(doc, http.getString());
    sha = doc["sha"].as();
  }
  http.end();
  return sha;
}

Process Flow:

\[ \text{getCurrentSHA}: \text{URL} \rightarrow \text{SHA} \]

Explanation:

• Establishes an HTTP connection to the GitHub API to obtain file metadata.
• Sends a GET request with authorization token.
• Extracts the SHA value from the JSON response.
• SHA is a unique hash used by GitHub for version control.

3. Function uploadToGitHub

This function uploads JSON data to GitHub with Base64 encoding.

void uploadToGitHub(DynamicJsonDocument doc, const char* url, String& lastSHA) {
  HTTPClient http;
  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", token);

  String jsonStr;
  serializeJson(doc, jsonStr);
  String encodedData = base64::encode(jsonStr);

  String payload = "{\"message\":\"Update data\",\"content\":\"" + encodedData + "\",\"sha\":\"" + last SHA + "\"}";

  int httpCode = http.PUT(payload);
  if (httpCode == HTTP_CODE_OK) {
    DynamicJsonDocument respDoc(1024);
    deserializeJson(respDoc, http.getString());
    lastSHA = respDoc["content"]["sha"].as();
  }
  http.end();
}

Process Flow:

\[ \text{JSON} \xrightarrow{\text{serialize}} \text{String} \xrightarrow{\text{Base64}} \text{EncodedString} \xrightarrow{\text{HTTP PUT}} \text{GitHub} \]

Explanation:

• Takes a JSON document, URL endpoint, and a reference to lastSHA.
• Converts the JSON document to a string.
• Encodes the string with Base64 (required by GitHub API).
• Creates a payload for the PUT request containing the encoded data and previous SHA.
• Updates lastSHA with the new SHA value from the GitHub response.

4. Function getTimestamp

This function retrieves the current timestamp from the NTP server.

                            
String getTimestamp() {
    struct tm timeinfo;
    if(!getLocalTime(&timeinfo)) return "";
    char buffer[20];
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
    return String(buffer);
}
                            
                        

Output Format:

\[ \text{Timestamp} = \text{YYYY-MM-DD HH:MM:SS} \]

Explanation:

• Uses NTP (Network Time Protocol) to obtain accurate time.
• Converts time to a readable string format: year-month-day hour:minute:second.
• Important for providing consistent timestamps on sensor data.

5. Function edaMovingAverage

This function implements a moving average filter for EDA (Electrodermal Activity) signal based on Boucsein (2012) methodology.

                            
// Moving average function for EDA tonic (Boucsein, 2012)
float edaMovingAverage(float newVal) {
    eda_buffer[buffer_index] = newVal;
    buffer_index = (buffer_index + 1) % WINDOW_SIZE;
    float sum = 0;
    return sum/WINDOW_SIZE;
}
                            
                        

Mathematical Formulation:

\[ B[j] = x_{\text{new}} \]

\[ j = (j + 1) \mod W \]

\[ \bar{x} = \frac{1}{W} \sum_{i=0}^{W-1} B[i] \]

Explanation:

• \(B\): Circular buffer to store the latest EDA values.
• \(j\): Current buffer index.
• \(W\): Window size (WINDOW_SIZE = 5).
• \(x_{\text{new}}\): New EDA value.
• \(\bar{x}\): Average EDA value (EDA tonic).
• This method, based on Boucsein (2012), helps separate the tonic (baseline) component from the EDA signal.

6. Function setup

This function initializes the connection and sensors when the system is powered on.

void setup() {
  Serial.begin(115200);

  WiFi.begin(ssid, password);
  int wifiTimeout = 0;
  while (WiFi.status() != WL_CONNECTED && wifiTimeout) {
    delay(500);
    Serial.print(".");
    wifiTimeout++;
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nConnected to WiFi");
    configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  } else {
    Serial.println("\nFailed to connect WiFi");
    ESP.restart();
  }
  
  // Initialize Sensors
  Wire.begin();
  if (!particleSensor.begin(Wire, I2C_SPEED_FAST)) {
    Serial.println("MAX30102 not found");
  }
  particleSensor.setup();
  lightMeter.begin();

  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
}

Process Flow:

\[ \text{Initialize Serial} \rightarrow \text{WiFi Connection} \rightarrow \text{NTP Configuration} \rightarrow \text{Sensor Initialization} \]

Explanation:

• Initializes serial communication with a baud rate of 115200.
• Attempts to connect to WiFi with a timeout of 10 seconds (20 x 500ms).
• If the connection fails, the system will restart.
• Initializes the I2C bus (Wire) for communication with the sensors.
• Configures the MAX30102 and BH1750 sensors.
• Sets up NTP for time synchronization.

7. Function loop

The main function that runs repeatedly to read sensors, process data, and upload it to GitHub.

                            
void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi disconnected. Reconnecting...");
    WiFi.reconnect();
    delay(5000);
    return;
  }
  static unsigned long lastUpload = 0;
  
  // Read all sensors
  float gsrRaw = analogRead(GSR_PIN);
  float edaTonic = edaMovingAverage(gsrRaw);
  float edaPhasic = gsrRaw - edaTonic;  // Boucsein (2012)
  
  long irValue = particleSensor.getIR();
  if(irValue > 50000 && checkForBeat(irValue)) {  // Shaffer et al. (2014)
    long delta = millis() - lastBeat;
    lastBeat = millis();
    beatsPerMinute = 60 / (delta / 1000.0);
    if(beatsPerMinute) {
      rates[rateSpot++] = (byte)beatsPerMinute;
      rateSpot %= 4;
      beatAvg = 0;
      for(byte x=0; x; x++) beatAvg += rates[x];
      beatAvg /= 4;
    }
  }

  float lux = lightMeter.readLightLevel();  // Golden et al. (2005)

  if(millis() - lastUpload >= 10000) {  // Upload every 10 seconds
    String timestamp = getTimestamp();
    
    // Create JSON document for each sensor
    DynamicJsonDocument gsrDoc(256);
    gsrDoc["sensor"] = "GSR";
    gsrDoc["tonic"] = edaTonic;
    gsrDoc["phasic"] = edaPhasic;
    gsrDoc["timestamp"] = timestamp;
    
    DynamicJsonDocument maxDoc(256);
    maxDoc["sensor"] = "MAX30102";
    maxDoc["bpm"] = beatsPerMinute;
    maxDoc["hrv"] = beatAvg;  // SDNN calculated offline
    maxDoc["timestamp"] = timestamp;
    
    DynamicJsonDocument bhDoc(256);
    bhDoc["sensor"] = "BH1750";
    bhDoc["lux"] = lux;
    bhDoc["timestamp"] = timestamp;

    // Upload to GitHub
    if(lastSHA_GSR == "") lastSHA_GSR = getCurrentSHA(gsrUrl);
    uploadToGitHub(gsrDoc, gsrUrl, lastSHA_GSR);
    
    if(lastSHA_MAX == "") lastSHA_MAX = getCurrentSHA(maxUrl);
    uploadToGitHub(maxDoc, maxUrl, lastSHA_MAX);
    
    if(lastSHA_BH == "") lastSHA_BH = getCurrentSHA(bhUrl);
    uploadToGitHub(bhDoc, bhUrl, lastSHA_BH);

    lastUpload = millis();
  }
}

Mathematical Formulation:

Processing GSR (Galvanic Skin Response)\[ \text{EDA}_{\text{tonic}} = \text{edaMovingAverage}(\text{gsrRaw}) \]

\[ \text{EDA}_{\text{phasic}} = \text{gsrRaw} - \text{EDA}_{\text{tonic}} \]

Processing Heart Rate

\[ \Delta t = t_{\text{current}} - t_{\text{lastBeat}} \]

\[ \text{BPM} = \frac{60}{\Delta t / 1000} \]

\[ \text{beatAvg} = \frac{1}{4} \sum_{i=0}^{3} \text{rates}[i] \]

Comprehensive Explanation:

• Connection Monitoring: Checks WiFi status and reconnects if disconnected.
• Reading GSR (Galvanic Skin Response):
  • Reads raw value from the analog pin (GSR_PIN).
  • Calculates the tonic (baseline) component using moving average.
  • Calculates the phasic component as the difference between raw and tonic (Boucsein, 2012).
• Reading Heart Rate (MAX30102):
  • Reads IR value from the MAX30102 sensor.
  • Detects beats with a threshold of 50000 (Shaffer et al., 2014).
  • Calculates BPM from the interval between beats.
  • Applies averaging filter for the last 4 readings.
  • Validates BPM within the physiological range of 20-255.
• Reading Light Level (BH1750):
  • Reads lux value from the BH1750 sensor (Golden et al., 2005).
• Upload Period:
  • Uses a timer to upload data every 10 seconds.
  • Creates JSON documents for each sensor with timestamps.
  • Uploads data to the GitHub repository with SHA update mechanism.

8. GSR Component Analysis

The Galvanic Skin Response (GSR) or Electrodermal Activity (EDA) is processed according to Boucsein (2012) methodology.

Complete Mathematical Formulation:

\[ \text{EDA}_{\text{raw}}(t) = \text{analogRead}(\text{GSR\_PIN}) \]

\[ \text{EDA}_{\text{tonic}}(t) = \frac{1}{W} \sum_{i=0}^{W-1} \text{EDA}_{\text{buffer}}[i] \]

\[ \text{EDA}_{\text{phasic}}(t) = \text{EDA}_{\text{raw}}(t) - \text{EDA}_{\text{tonic}}(t) \]

Explanation:

• EDA_raw: Raw EDA signal from the sensor, measuring skin conductivity.
• EDA_tonic: Tonic component of EDA, representing long-term skin conductivity levels.
• EDA_phasic: Phasic component of EDA, representing short-term skin conductivity responses.
• W: Window size for moving average (5 samples).
• This decomposition method aligns with Boucsein (2012) for stress and emotional response analysis.

9. Heart Rate Analysis

Heart rate is measured using the MAX30102 sensor following the methodology from Shaffer et al. (2014).

Complete Mathematical Formulation:

\[ \text{IR}(t) = \text{particleSensor.getIR()} \]

\[ \text{Beat detection} = \begin{cases} 1, & \ if \text{IR}(t) > 50000 \text{ and } \text{checkForBeat}(\text{IR}(t)) \\ 0, & \text{otherwise} \end{cases} \]

\[ \Delta t = t_{\text{current}} - t_{\text{lastBeat}} \]

\[ \text{BPM} = \frac{60 \times 1000}{\Delta t} \]

\[ \text{BPM}_{\text{valid}} = \begin{cases} \end{cases} \]

\[ \text{HRV}_{\text{avg}} = \frac{1}{4} \sum_{i=0}^{3} \text{rates}[i] \]

Explanation:

• IR(t): Infrared value read from the MAX30102 sensor.
• Beat detection: Function to detect heartbeats.
• Δt: Time interval between heartbeats (ms).
• BPM: Beats Per Minute, calculated from the interval between beats.
• BPM_valid: Validated BPM within physiological range (20-255).
• HRV_avg: Heart Rate Variability, calculated as the average of the last 4 measurements.
• Threshold of 50000 for beat detection refers to Shaffer et al. (2014).

10. Light Level Analysis

Light levels are measured using the BH1750 sensor, referencing Golden et al. (2005) regarding the impact of light on mental health.

Formulation:

\[ \text{Lux}(t) = \text{lightMeter.readLightLevel()} \]

Explanation:

• Lux(t): Light level measured in lux.
• Measurement of light levels is crucial in mental health analysis based on research by Golden et al. (2005).
• Light levels correlate with circadian rhythms and melatonin production.

11. Data Upload Mechanism

Sensor data is uploaded to GitHub as a cloud storage system with SHA mechanism for version control.

Process Flow:

\[ \text{Sensor Data} \rightarrow \text{JSON Documents} \rightarrow \text{Base64 Encoding} \rightarrow \text{HTTP PUT} \rightarrow \text{GitHub} \]

Explanation:

• Upload Interval: Data is uploaded every 10 seconds (10000 ms).
• Data Format: JSON structure with sensor values and timestamps.
• SHA Mechanism: SHA values are used to ensure data integrity and conflict handling.
• Base64 Encoding: JSON data is encoded with Base64 as per GitHub API requirements.
• This system allows for longitudinal data recording for long-term mental health trend analysis.

12. Scientific References

This code implementation refers to several scientific references:

• Boucsein, W. (2012): "Electrodermal Activity" - Standard reference for processing GSR/EDA signals, including tonic and phasic component separation methods.
• Shaffer et al. (2014): "A healthy heart is not a metronome: an integrative review of the heart's anatomy and heart rate variability" - Guidelines for processing and interpreting heart rate variability data.
• Golden et al. (2005): "The efficacy of light therapy in the treatment of mood disorders: a review and meta-analysis of the evidence" - Research on the impact of light levels on mood and mental health.