ESP32_0812_NTU_TEM.ino

/*
 * ESP32 (translated) ((translated) - (translated) + (translated))
 */

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <SSD1306Wire.h>
#include <RTClib.h>
#include <BH1750.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <SPI.h>
#include <SD.h>
#include <time.h>

// Pin definitions
#define TEMP_SENSOR_PIN 4
#define TURBIDITY_ANALOG_PIN 34    // 🔥 (translated)pin (ADC1_CH6)
#define I2C_SDA 21
#define I2C_SCL 22
#define SD_CS_PIN 5
#define SD_MOSI_PIN 23
#define SD_MISO_PIN 19
#define SD_SCK_PIN 18

// WiFi setup
const char* ssid = "TP-Link_6D5A";
const char* password = "********";

// IFTTT setup
const String iftttEvent = "water_quality_data";
const String iftttKey = "****************";
const String iftttUrl = "http://maker.ifttt.com/trigger/" + iftttEvent + "/with/key/" + iftttKey;

// Interval settings
const long sdLogInterval = 180000;      // 3 minutes
const long uploadInterval = 180000;     // 3 minutes
const long sensorInterval = 2000;
const long displayInterval = 3000;
const long tempCheckInterval = 30000;
const long ntpSyncInterval = 3600000;   // 1 hourssync(translated)NTP

unsigned long previousSDLogTime = 0;
unsigned long previousUploadTime = 0;
unsigned long previousSensorTime = 0;
unsigned long previousDisplayTime = 0;
unsigned long lastTempCheckTime = 0;
unsigned long lastNTPSyncTime = 0;

// 🔥 Time management variables
unsigned long bootTime = 0;            // Boot timestamp
bool hasValidBootTime = false;          // (translated)
bool ntpSynced = false;                 // NTP(translated)sync

// 🔥 (translated)sensorvariable
float latestTurbidityVoltage = 0.0;     // voltage(translated)
float latestTurbidityNTU = 0.0;         // NTU(translated)
int turbidityRawValue = 0;              // ADC(translated)
const int turbidityReadings = 10;       // averageread(translated)
const float voltageReference = 3.3;     // ESP32(translated)voltage

// initialize(translated)
SSD1306Wire display(0x3C, I2C_SDA, I2C_SCL);
OneWire oneWire(TEMP_SENSOR_PIN);
DallasTemperature tempSensors(&oneWire);
RTC_DS3231 rtc;
BH1750 lightMeter;

// status(translated)
bool rtcOK = false;
bool tempSensorOK = false;
bool turbidityOK = false;
bool lightSensorOK = false;
bool oledOK = false;
bool wifiOK = false;
bool sdCardOK = false;

// sensor(translated)
float latestTemperature = -999;
float latestLightLevel = 0;
String latestDateString = "";
String latestTimeString = "";
String latestDateTime = "";

int displayPage = 0;
int uploadCounter = 0;
int sdLogCounter = 0;
char logFileName[20] = "";
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

// 🔥 (translated)RTCstatus
void checkRTCStatus() {
  if (!rtc.begin()) {
      Serial.println("RTC 模組未找到");
      rtcOK = false;
      return;
  }
  
  if (rtc.lostPower()) {
      Serial.println("RTC 失去電源，需要重新設定時間");
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
      rtcOK = true;
  } else {
      rtcOK = true;
      // record(translated)
      bootTime = rtc.now().unixtime();
      hasValidBootTime = true;
      Serial.println("RTC 時間有效，已記錄開機時間");
  }
}

// 🔥 NTP(translated)sync
void syncTimeWithNTP() {
  if (WiFi.status() != WL_CONNECTED) {
      Serial.println("WiFi未連接，無法同步NTP");
      return;
  }
  
  Serial.println("開始NTP時間同步...");
  
  // settingsNTPserver ((translated) GMT+8)
  configTime(8 * 3600, 0, "pool.ntp.org", "time.nist.gov", "time.google.com");
  
  struct tm timeinfo;
  int retries = 0;
  
  // (translated)NTPsync, (translated)10(translated)
  while (!getLocalTime(&timeinfo) && retries < 10) {
      delay(1000);
      retries++;
      Serial.print(".");
  }
  
  if (retries < 10) {
      // NTPsyncsuccess
      if (rtcOK) {
          rtc.adjust(DateTime(timeinfo.tm_year + 1900, 
                             timeinfo.tm_mon + 1, 
                             timeinfo.tm_mday,
                             timeinfo.tm_hour, 
                             timeinfo.tm_min, 
                             timeinfo.tm_sec));
          Serial.println("\nRTC時間已與NTP同步");
      }
      
      // update(translated)
      bootTime = mktime(&timeinfo) - (millis() / 1000);
      hasValidBootTime = true;
      ntpSynced = true;
      
      Serial.printf("同步時間: %04d/%02d/%02d %02d:%02d:%02d\n",
                   timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday,
                   timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
  } else {
      Serial.println("\nNTP同步失敗");
  }
}

// 🔥 (translated)read(translated) ((translated)NTU(translated)voltage)
void readTurbidityAnalog() {
  long sum = 0;
  
  // (translated)read(translated)average(translated), (translated)
  for (int i = 0; i < turbidityReadings; i++) {
      sum += analogRead(TURBIDITY_ANALOG_PIN);
      delay(10);
  }
  
  turbidityRawValue = sum / turbidityReadings;
  
  // (translated)voltage(translated) (ESP32 ADC: 0-4095 (translated) 0-3.3V)
  latestTurbidityVoltage = (turbidityRawValue * voltageReference) / 4095.0;
  
  // 🔥 voltage(translated)NTU(translated) ((translated)sensor(translated))
  // (translated)convert(translated), (translated)sensor(translated)
  if (latestTurbidityVoltage > 2.5) {
      latestTurbidityNTU = 0.0;  // (translated)
  } else if (latestTurbidityVoltage > 2.0) {
      latestTurbidityNTU = (2.5 - latestTurbidityVoltage) * 100;  // 0-50 NTU
  } else if (latestTurbidityVoltage > 1.5) {
      latestTurbidityNTU = 50 + (2.0 - latestTurbidityVoltage) * 200;  // 50-150 NTU
  } else if (latestTurbidityVoltage > 1.0) {
      latestTurbidityNTU = 150 + (1.5 - latestTurbidityVoltage) * 400;  // 150-350 NTU
  } else {
      latestTurbidityNTU = 350 + (1.0 - latestTurbidityVoltage) * 650;  // 350-1000 NTU
  }
  
  // (translated)NTU(translated)range(translated)
  if (latestTurbidityNTU < 0) latestTurbidityNTU = 0;
  if (latestTurbidityNTU > 1000) latestTurbidityNTU = 1000;
}

// SD(translated)initialize
bool initSDCard() {
  SPI.end();
  delay(100);
  SPI.begin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
  SPI.setFrequency(1000000);
  delay(200);
  
  pinMode(SD_CS_PIN, OUTPUT);
  digitalWrite(SD_CS_PIN, HIGH);
  delay(100);
  
  for (int retry = 0; retry < 3; retry++) {
      if (SD.begin(SD_CS_PIN, SPI, 1000000)) {
          // (translated)log(translated)
          if (rtcOK) {
              DateTime dt = rtc.now();
              sprintf(logFileName, "/%04u%02u%02u.csv", dt.year(), dt.month(), dt.day());
          } else {
              sprintf(logFileName, "/data.csv");
          }
          
          if (!SD.exists(logFileName)) {
              File dataFile = SD.open(logFileName, FILE_WRITE);
              if (dataFile) {
                  // 🔥 (translated)SD(translated)recordformat - (translated)record(translated)NTU(translated)voltage
                  dataFile.println("Date(Time),Turbidity(NTU),Turbidity(Voltage)");
                  dataFile.close();
              }
          }
          return true;
      }
      delay(500);
  }
  return false;
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  Serial.println("=== ESP32 水質監測系統 (類比濁度版) ===");
  
  // 🔥 setup(translated)sensorpin
  pinMode(TURBIDITY_ANALOG_PIN, INPUT);
  
  // initializeI2C
  Wire.begin(I2C_SDA, I2C_SCL);
  Wire.setClock(100000);
  delay(100);
  
  // initializeOLED
  if (display.init()) {
      display.flipScreenVertically();
      display.setFont(ArialMT_Plain_10);
      oledOK = true;
      display.clear();
      display.drawString(0, 0, "System Reset...");
      display.display();
  }
  
  // 🔥 initializeRTC ((translated))
  checkRTCStatus();
  
  // initialize(translated)sensor
  if (lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
      lightSensorOK = true;
      delay(200);
  }
  
  // initializetemperaturesensor
  tempSensors.begin();
  delay(500);
  tempSensors.requestTemperatures();
  delay(200);
  float tempC = tempSensors.getTempCByIndex(0);
  if (tempC != -127.00 && tempC != 85.00) {
      tempSensorOK = true;
  }
  
  // 🔥 (translated)sensor
  readTurbidityAnalog();
  turbidityOK = true; // (translated)sensor(translated)
  
  // initializeSD(translated)
  sdCardOK = initSDCard();
  
  // connectWiFi
  WiFi.begin(ssid, password);
  int wifiRetries = 0;
  while (WiFi.status() != WL_CONNECTED && wifiRetries < 20) {
      delay(500);
      wifiRetries++;
  }
  if (WiFi.status() == WL_CONNECTED) {
      wifiOK = true;
      Serial.println("WiFi連接成功");
      
      // 🔥 (translated)NTPsync
      syncTimeWithNTP();
      lastNTPSyncTime = millis();
  }
  
  // display(translated)status
  Serial.println("=== 系統狀態 ===");
  Serial.println("OLED: " + String(oledOK ? "OK" : "ERR"));
  Serial.println("溫度: " + String(tempSensorOK ? "OK" : "ERR"));
  Serial.println("濁度(類比): " + String(turbidityOK ? "OK" : "ERR"));
  Serial.println("光照: " + String(lightSensorOK ? "OK" : "ERR"));
  Serial.println("RTC: " + String(rtcOK ? "OK" : "ERR"));
  Serial.println("SD卡: " + String(sdCardOK ? "OK" : "ERR"));
  Serial.println("WiFi: " + String(wifiOK ? "OK" : "ERR"));
  Serial.println("NTP同步: " + String(ntpSynced ? "OK" : "ERR"));
  
  if (oledOK) {
      display.clear();
      display.drawString(0, 0, "System Ready!");
      display.drawString(0, 15, "SD:" + String(sdCardOK ? "OK" : "ERR") + " WiFi:" + String(wifiOK ? "OK" : "ERR"));
      display.drawString(0, 25, "Temp:" + String(tempSensorOK ? "OK" : "ERR") + "Turbidity(A):" + String(turbidityOK ? "OK" : "ERR"));
      display.drawString(0, 35, "Lux:" + String(lightSensorOK ? "OK" : "ERR"));
      display.drawString(0, 45, "RTC:" + String(rtcOK ? "OK" : "ERR"));
    
      display.display();
      delay(3000);
  }
  
  Serial.println("系統初始化完成");
  Serial.println("當前濁度: " + String(latestTurbidityNTU, 1) + " NTU, " + String(latestTurbidityVoltage, 3) + "V");
}

// 🔥 updatesensor(translated) ((translated))
void updateSensorData() {
  // (translated) - (translated)
  if (rtcOK) {
      DateTime now = rtc.now();
      latestDateString = getDateString(now);
      latestTimeString = getTimeString(now);
      latestDateTime = latestDateString + " " + latestTimeString;
  } else if (hasValidBootTime) {
      // (translated) + (translated)
      unsigned long currentTime = bootTime + (millis() / 1000);
      DateTime estimatedTime = DateTime(currentTime);
      latestDateString = getDateString(estimatedTime);
      latestTimeString = getTimeString(estimatedTime);
      latestDateTime = latestDateString + " " + latestTimeString + " (估計)";
  } else {
      // (translated)
      unsigned long seconds = millis() / 1000;
      unsigned long minutes = seconds / 60;
      unsigned long hours = minutes / 60;
      unsigned long days = hours / 24;
      
      char timeStr[30];
      if (days > 0) {
          sprintf(timeStr, "%lu天 %02lu:%02lu:%02lu", days, hours % 24, minutes % 60, seconds % 60);
      } else {
          sprintf(timeStr, "%02lu:%02lu:%02lu", hours % 24, minutes % 60, seconds % 60);
      }
      latestTimeString = String(timeStr);
      latestDateTime = "運行時間 " + latestTimeString;
      latestDateString = "----/--/--";
  }

  // readtemperature
  if (tempSensorOK) {
      tempSensors.requestTemperatures();
      delay(200);
      latestTemperature = tempSensors.getTempCByIndex(0);
      if (latestTemperature == -127.00 || latestTemperature == 85.00) {
          tempSensorOK = false;
          latestTemperature = -999;
      }
  }
  
  // 🔥 read(translated)
  readTurbidityAnalog();

  // read(translated)
  if (lightSensorOK) {
      latestLightLevel = lightMeter.readLightLevel();
      if (latestLightLevel < 0) {
          lightSensorOK = false;
          latestLightLevel = 0;
      }
  }
}

// 🔥 SD(translated)record ((translated) - (translated)record(translated)NTU(translated)voltage)
void logDataToSD() {
  if (!sdCardOK) return;
  
  sdLogCounter++;
  File dataFile = SD.open(logFileName, FILE_APPEND);
  if (dataFile) {
      String logEntry = latestDateTime + "," + 
                       String(latestTurbidityNTU, 2) + "," +
                       String(latestTurbidityVoltage, 3);
      
      dataFile.println(logEntry);
      dataFile.close();
      Serial.println("SD記錄 #" + String(sdLogCounter) + ": " + logEntry);
  }
}

// upload(translated)IFTTT
void uploadDataToIFTTT() {
  if (WiFi.status() != WL_CONNECTED) return;
  
  uploadCounter++;
  HTTPClient http;
  
  String allData = "時間: " + latestDateTime +
                  " | 溫度: " + String(latestTemperature, 2) + "°C" +
                  " | 濁度: " + String(latestTurbidityNTU, 1) + "NTU" +
                  " | 電壓: " + String(latestTurbidityVoltage, 3) + "V" +
                  " | 光照: " + String(latestLightLevel, 1) + "lx";
  
  String postData = "value1=" + urlEncode(allData) + "&value2=&value3=";
  
  http.begin(iftttUrl);
  http.addHeader("Content-Type", "application/x-www-form-urlencoded");
  
  int httpResponseCode = http.POST(postData);
  
  if (httpResponseCode == 200) {
      Serial.println("IFTTT上傳成功 #" + String(uploadCounter));
  } else {
      Serial.println("IFTTT上傳失敗: " + String(httpResponseCode));
  }
  
  http.end();
}

void loop() {
  unsigned long currentTime = millis();
  
  // 🔥 (translated)NTPsync
  if (currentTime - lastNTPSyncTime >= ntpSyncInterval && wifiOK) {
      lastNTPSyncTime = currentTime;
      syncTimeWithNTP();
  }
  
  // (translated)temperaturesensor
  if (currentTime - lastTempCheckTime >= tempCheckInterval && !tempSensorOK) {
      lastTempCheckTime = currentTime;
      tempSensors.begin();
      delay(500);
      tempSensors.requestTemperatures();
      delay(200);
      float tempC = tempSensors.getTempCByIndex(0);
      if (tempC != -127.00 && tempC != 85.00) {
          tempSensorOK = true;
      }
  }
  
  // updatesensor(translated)
  if (currentTime - previousSensorTime >= sensorInterval) {
      previousSensorTime = currentTime;
      updateSensorData();
  }
  
  // updateOLEDdisplay
  if (currentTime - previousDisplayTime >= displayInterval) {
      previousDisplayTime = currentTime;
      displayPage = (displayPage + 1) % 4;
      updateOLEDDisplay();
  }
  
  // upload(translated)IFTTT
  if (currentTime - previousUploadTime >= uploadInterval && wifiOK) {
      previousUploadTime = currentTime;
      uploadDataToIFTTT();
  }
  
  // record(translated)SD(translated)
  if (currentTime - previousSDLogTime >= sdLogInterval && sdCardOK) {
      previousSDLogTime = currentTime;
      logDataToSD();
  }
  
  // (translated)
  if (Serial.available()) {
      String command = Serial.readString();
      command.trim();
      command.toLowerCase();
      
      if (command == "turbidity" || command == "ntu") {
          Serial.println("=== 濁度測試 (類比模式) ===");
          readTurbidityAnalog();
          Serial.println("ADC原始值: " + String(turbidityRawValue));
          Serial.println("電壓值: " + String(latestTurbidityVoltage, 3) + "V");
          Serial.println("NTU值: " + String(latestTurbidityNTU, 2) + " NTU");
      }
      else if (command == "sd") {
          if (sdCardOK) {
              logDataToSD();
          } else {
              sdCardOK = initSDCard();
          }
      }
      else if (command == "sync" || command == "ntp") {
          Serial.println("手動NTP同步...");
          syncTimeWithNTP();
      }
      else if (command == "rtc") {
          Serial.println("檢查RTC狀態...");
          checkRTCStatus();
      }
      else if (command == "status") {
          Serial.println("=== 系統狀態 ===");
          Serial.println("OLED: " + String(oledOK ? "OK" : "ERR"));
          Serial.println("溫度: " + String(tempSensorOK ? "OK" : "ERR"));
          Serial.println("濁度(類比): " + String(turbidityOK ? "OK" : "ERR"));
          Serial.println("光照: " + String(lightSensorOK ? "OK" : "ERR"));
          Serial.println("RTC: " + String(rtcOK ? "OK" : "ERR"));
          Serial.println("SD卡: " + String(sdCardOK ? "OK" : "ERR"));
          Serial.println("WiFi: " + String(wifiOK ? "OK" : "ERR"));
          Serial.println("NTP同步: " + String(ntpSynced ? "OK" : "ERR"));
          Serial.println("當前時間: " + latestDateTime);
          Serial.println("當前濁度: " + String(latestTurbidityNTU, 2) + " NTU");
          Serial.println("當前電壓: " + String(latestTurbidityVoltage, 3) + "V");
      }
      else if (command == "help") {
          Serial.println("=== 可用命令 ===");
          Serial.println("turbidity/ntu - 測試濁度(類比)");
          Serial.println("sd - 測試SD卡");
          Serial.println("sync/ntp - 手動NTP同步");
          Serial.println("rtc - 檢查RTC狀態");
          Serial.println("status - 系統狀態");
          Serial.println("help - 顯示幫助");
      }
  }
  
  // (translated)WiFistatus
  if (WiFi.status() != WL_CONNECTED && wifiOK) {
      wifiOK = false;
      WiFi.reconnect();
  } else if (WiFi.status() == WL_CONNECTED && !wifiOK) {
      wifiOK = true;
  }
  
  delay(100);
}

// 🔥 OLEDdisplayupdate ((translated)displayNTU(translated)voltage)
void updateOLEDDisplay() {
    if (!oledOK) return;
    
    display.clear();
    
    switch (displayPage) {
        case 0:  // (translated) ((translated)displayNTU(translated)voltage)
            display.setFont(ArialMT_Plain_10);
            display.setTextAlignment(TEXT_ALIGN_CENTER);
            display.drawString(64, 0, "=== TURBIDITY ===");  
            display.drawString(64, 12, latestTimeString);
            
            if (turbidityOK) {
                display.setFont(ArialMT_Plain_16);
                display.drawString(64, 24, String(latestTurbidityNTU, 1) + " NTU");  // NTU(translated)
                display.setFont(ArialMT_Plain_10);
                display.drawString(64, 40, String(latestTurbidityVoltage, 3) + "V");  // voltage(translated)
                display.drawString(64, 52, "ADC: " + String(turbidityRawValue));      // ADC(translated)
            } else {
                display.setFont(ArialMT_Plain_24);
                display.drawString(64, 35, "ERROR");
            }
            break;
            
        case 1:  // (translated)
            display.setFont(ArialMT_Plain_10);
            display.setTextAlignment(TEXT_ALIGN_CENTER);
            display.drawString(64, 0, "=== TIME ===");  
            
            if (rtcOK) {
                DateTime now = rtc.now();
                display.setFont(ArialMT_Plain_10);
                display.drawString(64, 15, latestDateString);
                display.setFont(ArialMT_Plain_16);
                display.drawString(64, 32, latestTimeString);
                display.setFont(ArialMT_Plain_10);
                display.drawString(64, 50, daysOfTheWeek[now.dayOfTheWeek()]);
            } else {
                display.setFont(ArialMT_Plain_16);
                display.drawString(64, 20, latestDateString);
                display.setFont(ArialMT_Plain_16);
                display.drawString(64, 40, latestTimeString);
            }
            break;
            
        case 2:  // (translated)
            display.setFont(ArialMT_Plain_10);
            display.setTextAlignment(TEXT_ALIGN_CENTER);
            display.drawString(64, 0, "=== LIGHT ===");  
            display.drawString(64, 14, latestTimeString);
            
            if (lightSensorOK) {
                display.setFont(ArialMT_Plain_24);
                display.drawString(64, 28, String(latestLightLevel, 0) + " lux");
            } else {
                display.setFont(ArialMT_Plain_24);
                display.drawString(64, 35, "ERROR");
            }
            break;
            
        case 3:  // temperature(translated)
            display.setFont(ArialMT_Plain_10);
            display.setTextAlignment(TEXT_ALIGN_CENTER);
            display.drawString(64, 0, "=== TEMP ===");  
            display.drawString(64, 14, latestTimeString);
            
            if (latestTemperature == -999) {
                display.setFont(ArialMT_Plain_24);
                display.drawString(64, 35, "ERROR");
            } else {
                display.setFont(ArialMT_Plain_24);
                display.drawString(64, 28, String(latestTemperature, 1));
                display.setFont(ArialMT_Plain_16);
                display.drawString(64, 50, "°C");
            }
            break;
    }
    
    display.display();
}


// (translated)
String getDateString(const DateTime& dt) {
  char dateStr[12];
  sprintf(dateStr, "%04u/%02u/%02u", dt.year(), dt.month(), dt.day());
  return String(dateStr);
}

String getTimeString(const DateTime& dt) {
  char timeStr[10];
  sprintf(timeStr, "%02u:%02u:%02u", dt.hour(), dt.minute(), dt.second());
  return String(timeStr);
}

String urlEncode(String str) {
    String encodedString = "";
    char c;
    
    for (int i = 0; i < str.length(); i++) {
        c = str.charAt(i);
        if (c == ' ') {
            encodedString += '+';
        } else if (isalnum(c)) {
            encodedString += c;
        } else {
            char code0, code1;
            code1 = (c & 0xf) + '0';
            if ((c & 0xf) > 9) code1 = (c & 0xf) - 10 + 'A';
            c = (c >> 4) & 0xf;
            code0 = c + '0';
            if (c > 9) code0 = c - 10 + 'A';
            encodedString += '%';
            encodedString += code0;
            encodedString += code1;
        }
    }
    return encodedString;
}

/*
 * === (translated) ((translated)) ===
 * 
 * 🔥 (translated):
 * 1. (translated)sensor(translated) (ADCread)
 * 2. OLED(translated)display:
 *    - NTU(translated) ((translated)voltage(translated))
 *    - voltage(translated) (V)
 *    - ADC(translated)
 * 
 * 🔥 (translated)sensor(translated):
 * - (translated) analogRead() read 0-4095 ADC(translated)
 * - convert(translated) 0-3.3V voltage(translated)
 * - (translated)voltage(translated) NTU (translated)
 * - (translated)readaverage, (translated)
 * 
 * 🔥 (translated)SD(translated)record:
 * - (translated)record(translated), NTU(translated), voltage(translated)
 * - format:Date(Time),Turbidity(NTU),Turbidity(Voltage)
 * 
 * 🔥 NTU(translated):
 * - voltage > 2.5V: 0 NTU ((translated))
 * - voltage 2.0-2.5V: 0-50 NTU
 * - voltage 1.5-2.0V: 50-150 NTU  
 * - voltage 1.0-1.5V: 150-350 NTU
 * - voltage < 1.0V: 350-1000 NTU
 * 
 * ✅ (translated):
 * - OLED(translated)display
 * - IFTTT(translated)upload ((translated)NTU(translated)voltage(translated))
 * - NTP(translated)sync
 * - (translated)
 * - (translated)sensor(translated)
 * 
 * 📊 OLEDdisplay(translated):
 * Page 0: (translated) - NTU(translated)/voltage(translated)/ADC(translated)
 * Page 1: (translated) - (translated)/(translated)/(translated)
 * Page 2: (translated) - brightness(translated)
 * Page 3: temperature - temperature(translated)
 * 
 * 💾 SD(translated)recordformat:
 * Date(Time),Turbidity(NTU),Turbidity(Voltage)
 * 
 * 📡 IFTTTupload(translated):
 * (translated) | temperature | (translated)(NTU) | voltage | (translated)
 * 
 * 🔧 (translated):
 * - turbidity/ntu: test(translated)sensor (displayADC/voltage/NTU)
 * - sd: testSD(translated)record
 * - sync/ntp: (translated)NTPsync
 * - rtc: (translated)RTCstatus
 * - status: display(translated)status
 * - help: display(translated)
 */