UV Alert Wristband Logger

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <math.h>
#include <Adafruit_LTR390.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_NeoPixel.h>
#include <RTClib.h>

// ESP32-C3 SuperMini wiring
constexpr uint8_t I2C_SDA_PIN = 0;
constexpr uint8_t I2C_SCL_PIN = 1;
constexpr uint8_t BUZZER_PIN = 3;
constexpr uint8_t SD_SCK_PIN = 4;
constexpr uint8_t SD_MISO_PIN = 5;
constexpr uint8_t SD_MOSI_PIN = 6;
constexpr uint8_t SD_CS_PIN = 7;
constexpr uint8_t NEOPIXEL_PIN = 10;
constexpr uint8_t MOTOR_PIN = 20;

constexpr int SCREEN_WIDTH = 128;
constexpr int SCREEN_HEIGHT = 64;
constexpr uint8_t OLED_ADDRESS = 0x3C;
constexpr float UV_ALERT_UVI = 3.0f;
constexpr float UV_HIGH_UVI = 6.0f;
constexpr uint32_t LOG_INTERVAL_MS = 60000UL;

Adafruit_LTR390 ltr;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_NeoPixel pixel(1, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);
RTC_DS3231 rtc;

bool sensorOk = false;
bool displayOk = false;
bool rtcOk = false;
bool sdOk = false;
bool haveUv = false;
bool haveAls = false;

enum SensorMode : uint8_t { MODE_UV, MODE_ALS };
SensorMode sensorMode = MODE_UV;
uint32_t sensorModeStarted = 0;
uint32_t uvRaw = 0;
uint32_t alsRaw = 0;
float uvIndexEstimate = 0.0f;
float luxEstimate = 0.0f;

int lastRenderedUviTenths = -999;
int lastRenderedLux = -999;
int lastRenderedCategory = -1;
int lastRenderedMinute = -1;
int lastLedCategory = -1;
uint32_t lastDisplayCheck = 0;
uint32_t lastLogAt = 0;
uint32_t lastAlertAt = 0;

bool buzzerPatternActive = false;
bool buzzerOn = false;
uint8_t beepCount = 0;
uint8_t beepTarget = 0;
uint32_t buzzerTransitionAt = 0;

int uvCategory(float value) {
  if (value < UV_ALERT_UVI) return 0;
  if (value < UV_HIGH_UVI) return 1;
  return 2;
}

void updatePixel() {
  if (!sensorOk || !haveUv) return;
  const int category = uvCategory(uvIndexEstimate);
  if (category == lastLedCategory) return;

  if (category == 0) {
    pixel.setPixelColor(0, pixel.Color(0, 0, 36));
  } else if (category == 1) {
    pixel.setPixelColor(0, pixel.Color(36, 22, 0));
  } else {
    pixel.setPixelColor(0, pixel.Color(40, 0, 0));
  }
  pixel.show();
  lastLedCategory = category;
}

void renderDashboard() {
  if (!displayOk) return;

  const int category = haveUv ? uvCategory(uvIndexEstimate) : 0;
  const int uviTenths = haveUv ? static_cast<int>(lroundf(uvIndexEstimate * 10.0f)) : -1;
  const int luxShown = haveAls ? static_cast<int>(lroundf(luxEstimate)) : -1;
  int currentMinute = -1;
  DateTime clockNow(2000, 1, 1, 0, 0, 0);
  if (rtcOk) {
    clockNow = rtc.now();
    currentMinute = clockNow.hour() * 60 + clockNow.minute();
  }

  if (uviTenths == lastRenderedUviTenths && luxShown == lastRenderedLux &&
      category == lastRenderedCategory && currentMinute == lastRenderedMinute) {
    return;
  }
  lastRenderedUviTenths = uviTenths;
  lastRenderedLux = luxShown;
  lastRenderedCategory = category;
  lastRenderedMinute = currentMinute;

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("UV ALERT WRISTBAND");
  display.setCursor(0, 14);
  display.print("UVI~ ");
  if (haveUv) display.print(uvIndexEstimate, 1);
  else display.print("--");
  display.setCursor(68, 14);
  display.print("Lux~ ");
  if (haveAls) display.print(luxShown);
  else display.print("--");
  display.setCursor(0, 30);
  if (!sensorOk) {
    display.print("UV sensor not found");
  } else if (category == 0) {
    display.print("UV: LOW");
  } else if (category == 1) {
    display.print("UV: MODERATE - cover up");
  } else {
    display.print("UV: HIGH - protect skin");
  }
  display.setCursor(0, 48);
  if (rtcOk) {
    display.print("Time ");
    if (clockNow.hour() < 10) display.print('0');
    display.print(clockNow.hour());
    display.print(':');
    if (clockNow.minute() < 10) display.print('0');
    display.print(clockNow.minute());
  } else {
    display.print("RTC unavailable");
  }
  display.setCursor(0, 58);
  display.print(sdOk ? "Log: SD ready" : "Log: SD unavailable");
  display.display();
}

void stopBuzzer() {
  if (buzzerOn) noTone(BUZZER_PIN);
  digitalWrite(MOTOR_PIN, LOW);
  buzzerOn = false;
  buzzerPatternActive = false;
}

void serviceBuzzer(uint32_t now) {
  if (!sensorOk || !haveUv || uvIndexEstimate < UV_ALERT_UVI) {
    stopBuzzer();
    return;
  }

  const int category = uvCategory(uvIndexEstimate);
  const uint32_t repeatMs = (category >= 2) ? 15000UL : 30000UL;
  if (!buzzerPatternActive && static_cast<uint32_t>(now - lastAlertAt) >= repeatMs) {
    lastAlertAt = now;
    buzzerPatternActive = true;
    buzzerOn = true;
    beepCount = 1;
    beepTarget = (category >= 2) ? 3 : 2;
    tone(BUZZER_PIN, 4000);
    digitalWrite(MOTOR_PIN, HIGH);
    buzzerTransitionAt = now + ((category >= 2) ? 240UL : 150UL);
  }

  if (!buzzerPatternActive || static_cast<int32_t>(now - buzzerTransitionAt) < 0) return;

  if (buzzerOn) {
    noTone(BUZZER_PIN);
    digitalWrite(MOTOR_PIN, LOW);
    buzzerOn = false;
    if (beepCount >= beepTarget) {
      buzzerPatternActive = false;
    } else {
      buzzerTransitionAt = now + 120UL;
    }
  } else {
    tone(BUZZER_PIN, 4000);
    digitalWrite(MOTOR_PIN, HIGH);
    buzzerOn = true;
    ++beepCount;
    buzzerTransitionAt = now + ((category >= 2) ? 240UL : 150UL);
  }
}

void serviceSensor(uint32_t now) {
  if (!sensorOk || static_cast<uint32_t>(now - sensorModeStarted) < 420UL) return;
  if (!ltr.newDataAvailable()) return;

  if (sensorMode == MODE_UV) {
    uvRaw = ltr.readUVS();
    // At 18x gain and 20-bit resolution, the LTR390 reference is about 2300 counts/UVI.
    // This is an estimate, not a calibrated medical or regulatory UV instrument.
    uvIndexEstimate = static_cast<float>(uvRaw) / 2300.0f;
    haveUv = true;
    ltr.setMode(LTR390_MODE_ALS);
    sensorMode = MODE_ALS;
  } else {
    alsRaw = ltr.readALS();
    // Approximate lux at 18x gain and 400 ms integration (20-bit resolution).
    luxEstimate = static_cast<float>(alsRaw) / 120.0f;
    haveAls = true;
    ltr.setMode(LTR390_MODE_UVS);
    sensorMode = MODE_UV;
  }
  sensorModeStarted = now;
  updatePixel();
}

void initializeCard() {
  SPI.begin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN, SD_CS_PIN);
  sdOk = SD.begin(SD_CS_PIN, SPI, 4000000);
  if (!sdOk) {
    Serial.println("microSD not ready; readings will not be logged.");
    return;
  }

  if (!SD.exists("/uv_alert.csv")) {
    File file = SD.open("/uv_alert.csv", FILE_WRITE);
    if (file) {
      file.println("timestamp,uv_raw,uvi_estimate,lux_estimate,alert_level");
      file.close();
    }
  }
}

void appendLog() {
  if (!sdOk || !haveUv || !haveAls) return;

  char timestamp[24];
  if (rtcOk) {
    const DateTime now = rtc.now();
    snprintf(timestamp, sizeof(timestamp), "%04d-%02d-%02d %02d:%02d:%02d",
             now.year(), now.month(), now.day(), now.hour(), now.minute(), now.second());
  } else {
    snprintf(timestamp, sizeof(timestamp), "NO_RTC");
  }

  const char *level = (uvCategory(uvIndexEstimate) == 0) ? "LOW" :
                      (uvCategory(uvIndexEstimate) == 1) ? "MODERATE" : "HIGH";
  char row[112];
  snprintf(row, sizeof(row), "%s,%lu,%.2f,%.1f,%s",
           timestamp, static_cast<unsigned long>(uvRaw), uvIndexEstimate, luxEstimate, level);
  File file = SD.open("/uv_alert.csv", FILE_APPEND);
  if (file) {
    file.println(row);
    file.close();
  } else {
    sdOk = false;
  }
}

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

  pinMode(MOTOR_PIN, OUTPUT);
  digitalWrite(MOTOR_PIN, LOW);

  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);

  pixel.begin();
  pixel.setBrightness(24);
  pixel.clear();
  pixel.show();

  displayOk = display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS);

  sensorOk = ltr.begin();
  if (sensorOk) {
    ltr.setGain(LTR390_GAIN_18);
    ltr.setResolution(LTR390_RESOLUTION_20BIT);
    ltr.setMode(LTR390_MODE_UVS);
    sensorMode = MODE_UV;
    sensorModeStarted = millis();
  } else {
    Serial.println("LTR390 not found.");
  }

  rtcOk = rtc.begin();
  if (rtcOk && rtc.lostPower()) {
    // Sets a reasonable starting time; insert the CR1220 so the clock keeps running when off.
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  if (!rtcOk) Serial.println("DS3231 not found.");

  initializeCard();
  lastLogAt = millis() - LOG_INTERVAL_MS;
  lastAlertAt = millis() - 30000UL;
  renderDashboard();
}

void loop() {
  const uint32_t now = millis();
  serviceSensor(now);
  serviceBuzzer(now);

  if (static_cast<uint32_t>(now - lastDisplayCheck) >= 500UL) {
    lastDisplayCheck = now;
    renderDashboard();
  }

  if (static_cast<uint32_t>(now - lastLogAt) >= LOG_INTERVAL_MS) {
    lastLogAt = now;
    appendLog();
  }

  delay(20);
}