Aura Smart Hair Oil Dispenser

/*
  Thermistor + PTC Heater Controller — ATtiny1624 (megaTinyCore)

  ── Wiring ────────────────────────────────────────────────────────────────────
  Thermistor:       VCC → 4.7kΩ → PA6 → Thermistor → GND
  Heater MOSFET:    PA2 → gate
  12V sense:        12V → 15kΩ → PB0 → 5kΩ → GND  (3.0V when present)
  LED1:             PA4
  LED2:             PA1
  LED3:             PA3
  Vibration MOSFET: PB1 → gate (PWM via TCA WO1)
  Push button:      PA7 → GND  (internal pull-up enabled)

  ── Docked (12V present) ──────────────────────────────────────────────────────
  · Heater runs HEATING → MAINTAINING → COOLING cycle
  · LEDs show temperature climb (solid, no blinking):
      < 20 °C        → LED3 only
      20–60 °C       → LED2+3
      ≥ 60 °C        → LED1+2+3
      MAINTAINING    → LED1+2+3
      COOLING        → LED1+2+3
  · Vibration motor forced OFF, button ignored (except long press)

  ── Undocked (12V absent) ─────────────────────────────────────────────────────
  · Heater OFF
  · Thermistor read every loop — gates motor and LEDs
  · Temp < 40 °C:
      All three LEDs blink @ 400 ms
      Motor reset to OFF instantly, button short-press ignored
  · Temp ≥ 40 °C:
      LEDs solid per motor mode:
        Motor OFF  → all LEDs OFF
        Motor LOW  → LED3
        Motor MED  → LED2+3
        Motor HIGH → LED1+2+3
      Button short-press cycles: OFF → LOW (30%) → MED (60%) → HIGH (100%) → OFF

  ── Power / sleep ─────────────────────────────────────────────────────────────
  · Long press ≥ 2 s (any mode): heater OFF, motor OFF, LEDs OFF,
    3-flash confirmation, ATtiny enters deep power-down sleep (~0.1 µA)
  · Button press wakes device — fresh boot, state fully reset
*/

#include <math.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

// ── Pins ──────────────────────────────────────────────────────────────────────
#define THERM_PIN     PIN_PA6
#define HEATER_PIN    PIN_PA2
#define V12_SENSE_PIN PIN_PB0
#define LED1_PIN      PIN_PA4
#define LED2_PIN      PIN_PA1
#define LED3_PIN      PIN_PA3
#define MOTOR_PIN     PIN_PB1
#define BUTTON_PIN    PIN_PA7

// ── 12V sense threshold ───────────────────────────────────────────────────────
// 15kΩ + 5kΩ divider → 3.0V at PB0 when 12V present → ADC ≈ 614
// Threshold at 2.0V (ADC ≈ 409) gives solid noise margin
const int V12_THRESHOLD_ADC = 409;

// ── Circuit constants ─────────────────────────────────────────────────────────
const float VCC     = 5.0;
const float R_FIXED = 4700.0;

// ── Thermistor (Beta equation) ────────────────────────────────────────────────
const float BETA      = 3950.0;
const float T0_KELVIN = 298.15;
const float R0        = 100000.0;  // 100 kΩ at 25 °C

// ── ADC ───────────────────────────────────────────────────────────────────────
const int   NUM_SAMPLES = 16;
const float ADC_MAX     = 1023.0;

// ── Heater setpoint & hysteresis ─────────────────────────────────────────────
const float TARGET_TEMP = 60.0;
const float HYST_HIGH   = 60.5;
const float HYST_LOW    = 59.5;

// ── Hold duration ─────────────────────────────────────────────────────────────
const unsigned long HOLD_MS = 3UL * 60UL * 1000UL;  // 3 minutes

// ── Motor PWM levels (0–255) ──────────────────────────────────────────────────
const uint8_t MOTOR_OFF  =   0;
const uint8_t MOTOR_LOW  =  77;   // ~30%
const uint8_t MOTOR_MED  = 153;   // ~60%
const uint8_t MOTOR_HIGH = 255;   // 100%

// ── Timing ────────────────────────────────────────────────────────────────────
const unsigned long BLINK_WARNING_MS = 400;   // undocked temp < 40 °C
const unsigned long DEBOUNCE_MS      =  50;
const unsigned long LONG_PRESS_MS    = 2000;  // hold ≥ 2 s → sleep

// ── Heater state machine ──────────────────────────────────────────────────────
enum HeaterState { HEATING, MAINTAINING, COOLING };
HeaterState   state     = HEATING;
unsigned long holdStart = 0;

// ── Motor state ───────────────────────────────────────────────────────────────
enum MotorMode { MOTOR_MODE_OFF, MOTOR_MODE_LOW, MOTOR_MODE_MED, MOTOR_MODE_HIGH };
MotorMode motorMode = MOTOR_MODE_OFF;

// ── Blink state ───────────────────────────────────────────────────────────────
unsigned long lastBlinkTime = 0;
bool          blinkPhase    = false;

// ── Button state ──────────────────────────────────────────────────────────────
bool          lastButtonRaw    = HIGH;
bool          lastButtonStable = HIGH;
unsigned long lastDebounceTime = 0;
unsigned long buttonPressStart = 0;
bool          buttonHeld       = false;

// ─────────────────────────────────────────────────────────────────────────────
// Helpers
// ─────────────────────────────────────────────────────────────────────────────

bool detect12V() {
  return analogRead(V12_SENSE_PIN) >= V12_THRESHOLD_ADC;
}

void setLEDs(bool l1, bool l2, bool l3) {
  digitalWrite(LED1_PIN, l1 ? HIGH : LOW);
  digitalWrite(LED2_PIN, l2 ? HIGH : LOW);
  digitalWrite(LED3_PIN, l3 ? HIGH : LOW);
}

void allLEDsOff() { setLEDs(false, false, false); }

void setMotor(uint8_t pwmValue) { analogWrite(MOTOR_PIN, pwmValue); }

void stopMotor() {
  motorMode = MOTOR_MODE_OFF;
  setMotor(MOTOR_OFF);
}

// ─────────────────────────────────────────────────────────────────────────────
// ISR — wake from sleep only, no action needed
// ─────────────────────────────────────────────────────────────────────────────
ISR(PORTA_PORT_vect) {
  PORTA.INTFLAGS = PIN7_bm;
}

// ─────────────────────────────────────────────────────────────────────────────
// sleepConfirmFlash — 3 quick flashes on all LEDs before sleeping
// ─────────────────────────────────────────────────────────────────────────────
void sleepConfirmFlash() {
  for (uint8_t i = 0; i < 3; i++) {
    setLEDs(true, true, true);
    delay(80);
    allLEDsOff();
    delay(80);
  }
}

// ─────────────────────────────────────────────────────────────────────────────
// enterSleep — safe state, flash, then power-down sleep
// Wakes on PA7 falling edge (button press)
// ─────────────────────────────────────────────────────────────────────────────
void enterSleep() {
  Serial.println("INFO: Entering deep sleep — press button to wake");
  Serial.flush();

  digitalWrite(HEATER_PIN, LOW);
  stopMotor();
  allLEDsOff();
  sleepConfirmFlash();

  // Reset all runtime state — wake = fresh boot
  state         = HEATING;
  motorMode     = MOTOR_MODE_OFF;
  blinkPhase    = false;
  lastBlinkTime = 0;
  buttonHeld    = false;

  // Configure PA7 as falling-edge interrupt to wake from sleep
  PORTA.PIN7CTRL = PORT_PULLUPEN_bm | PORT_ISC_FALLING_gc;

  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  sei();
  sleep_cpu();        // execution pauses here until button pressed

  // Woke up
  sleep_disable();
  PORTA.PIN7CTRL = PORT_PULLUPEN_bm;  // restore normal input, no interrupt
  delay(200);                          // let button settle before re-entering loop
  Serial.println("INFO: Woke from sleep — fresh boot");
}

// ─────────────────────────────────────────────────────────────────────────────
// checkButton — returns 0=nothing  1=short press  2=long press
// ─────────────────────────────────────────────────────────────────────────────
uint8_t checkButton() {
  bool raw = digitalRead(BUTTON_PIN);

  if (raw != lastButtonRaw) {
    lastDebounceTime = millis();
    lastButtonRaw    = raw;
  }

  if ((millis() - lastDebounceTime) < DEBOUNCE_MS) return 0;

  if (raw != lastButtonStable) {
    lastButtonStable = raw;
    if (raw == LOW) {
      buttonPressStart = millis();
      buttonHeld       = true;
    } else {
      if (buttonHeld) {
        buttonHeld = false;
        if (millis() - buttonPressStart >= LONG_PRESS_MS) return 2;
        else return 1;
      }
    }
  }
  return 0;
}

// ─────────────────────────────────────────────────────────────────────────────
// updateLEDs_temperature — solid indicators, docked mode
// ─────────────────────────────────────────────────────────────────────────────
void updateLEDs_temperature(float tempC, HeaterState currentState) {
  if (tempC >= TARGET_TEMP        ||
      currentState == MAINTAINING ||
      currentState == COOLING) {
    setLEDs(true, true, true);
    return;
  }
  if (tempC < 20.0) setLEDs(false, false, true);   // LED3 only
  else              setLEDs(false, true,  true);    // LED2+3
}

// ─────────────────────────────────────────────────────────────────────────────
// updateLEDs_vibration — solid per motor mode, undocked + temp ≥ 40 °C
// ─────────────────────────────────────────────────────────────────────────────
void updateLEDs_vibration() {
  switch (motorMode) {
    case MOTOR_MODE_OFF:  setLEDs(false, false, false); break;
    case MOTOR_MODE_LOW:  setLEDs(false, false, true);  break;
    case MOTOR_MODE_MED:  setLEDs(false, true,  true);  break;
    case MOTOR_MODE_HIGH: setLEDs(true,  true,  true);  break;
  }
}

// ─────────────────────────────────────────────────────────────────────────────
// updateLEDs_warning — all three blink @ 400 ms, undocked + temp < 40 °C
// ─────────────────────────────────────────────────────────────────────────────
void updateLEDs_warning() {
  if (millis() - lastBlinkTime >= BLINK_WARNING_MS / 2) {
    blinkPhase    = !blinkPhase;
    lastBlinkTime = millis();
  }
  setLEDs(blinkPhase, blinkPhase, blinkPhase);
}

// ─────────────────────────────────────────────────────────────────────────────
// advanceMotorMode — OFF → LOW → MED → HIGH → OFF
// ─────────────────────────────────────────────────────────────────────────────
void advanceMotorMode() {
  switch (motorMode) {
    case MOTOR_MODE_OFF:
      motorMode = MOTOR_MODE_LOW;
      setMotor(MOTOR_LOW);
      Serial.println("[MOTOR] LOW  (30%)");
      break;
    case MOTOR_MODE_LOW:
      motorMode = MOTOR_MODE_MED;
      setMotor(MOTOR_MED);
      Serial.println("[MOTOR] MEDIUM  (60%)");
      break;
    case MOTOR_MODE_MED:
      motorMode = MOTOR_MODE_HIGH;
      setMotor(MOTOR_HIGH);
      Serial.println("[MOTOR] HIGH  (100%)");
      break;
    case MOTOR_MODE_HIGH:
      motorMode = MOTOR_MODE_OFF;
      setMotor(MOTOR_OFF);
      Serial.println("[MOTOR] OFF");
      break;
  }
}

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

  pinMode(HEATER_PIN,    OUTPUT);
  pinMode(V12_SENSE_PIN, INPUT);
  pinMode(LED1_PIN,      OUTPUT);
  pinMode(LED2_PIN,      OUTPUT);
  pinMode(LED3_PIN,      OUTPUT);
  pinMode(MOTOR_PIN,     OUTPUT);
  pinMode(BUTTON_PIN,    INPUT_PULLUP);

  digitalWrite(HEATER_PIN, LOW);
  setMotor(MOTOR_OFF);
  allLEDsOff();

  analogReference(VDD);
  analogReadResolution(10);

  delay(2000);
  Serial.println("Heater Controller — ATtiny1624");
  Serial.println("Target: 60 C  |  Hold: 3 min  |  12V interlock: ON");
  Serial.println("Long press 2 s: sleep  |  Press button to wake");
  Serial.println("---------------------------------------------------");
}

// ── ADC helpers ───────────────────────────────────────────────────────────────
float readVoltage() {
  long sum = 0;
  for (int i = 0; i < NUM_SAMPLES; i++) {
    sum += analogRead(THERM_PIN);
    delay(2);
  }
  return (sum / (float)NUM_SAMPLES / ADC_MAX) * VCC;
}

float voltageToResistance(float v) {
  if (v <= 0.0 || v >= VCC) return -1.0;
  return R_FIXED * v / (VCC - v);
}

float resistanceToCelsius(float r) {
  if (r <= 0) return NAN;
  float invT = (1.0 / T0_KELVIN) + (1.0 / BETA) * log(r / R0);
  return (1.0 / invT) - 273.15;
}

// ─────────────────────────────────────────────────────────────────────────────
void loop() {

  static bool v12WasAbsent   = false;
  static bool warningTracked = false;

  bool v12Now = detect12V();

  // ── Read temperature (always — gates both modes) ───────────────────────────
  float voltage    = readVoltage();
  float resistance = voltageToResistance(voltage);
  float tempC      = resistanceToCelsius(resistance);

  // ── Sensor fault — safe state ──────────────────────────────────────────────
  if (isnan(tempC) || resistance < 0) {
    digitalWrite(HEATER_PIN, LOW);
    stopMotor();
    allLEDsOff();
    Serial.println("ERROR: Sensor fault — heater and motor OFF");
    delay(1000);
    return;
  }

  // ── Button — checked every iteration in all modes ──────────────────────────
  uint8_t btn = checkButton();

  if (btn == 2) {
    enterSleep();
    v12WasAbsent   = false;
    warningTracked = false;
    return;
  }

  // ── 12V ABSENT — undocked ──────────────────────────────────────────────────
  if (!v12Now) {

    if (!v12WasAbsent) {
      Serial.println("WARNING: 12V absent — heater OFF, entering undocked mode");
      digitalWrite(HEATER_PIN, LOW);
      state         = HEATING;
      stopMotor();
      blinkPhase    = false;
      lastBlinkTime = millis();
      v12WasAbsent  = true;
    }

    if (tempC < 40.0) {
      stopMotor();                                    // reset instantly, one line
      updateLEDs_warning();
      if (!warningTracked) warningTracked = true;

    } else {
      if (warningTracked) {                           // just crossed above 40 °C
        blinkPhase     = false;
        lastBlinkTime  = millis();
        warningTracked = false;
      }
      if (btn == 1) advanceMotorMode();
      updateLEDs_vibration();
    }

    // Serial (undocked)
    Serial.print("Temp: ");
    Serial.print(tempC, 1);
    Serial.print(" C  |  Motor: ");
    switch (motorMode) {
      case MOTOR_MODE_OFF:  Serial.print("OFF    "); break;
      case MOTOR_MODE_LOW:  Serial.print("LOW    "); break;
      case MOTOR_MODE_MED:  Serial.print("MEDIUM "); break;
      case MOTOR_MODE_HIGH: Serial.print("HIGH   "); break;
    }
    Serial.print("  |  Gate: ");
    Serial.print(tempC < 40.0 ? "LOCKED (temp < 40 C)" : "OPEN");
    Serial.print("  |  LEDs: ");
    Serial.print(digitalRead(LED1_PIN) ? "1" : "-");
    Serial.print(digitalRead(LED2_PIN) ? "2" : "-");
    Serial.println(digitalRead(LED3_PIN) ? "3" : "-");

    delay(20);
    return;
  }

  // ── 12V PRESENT — docked ───────────────────────────────────────────────────
  if (v12WasAbsent) {
    Serial.println("INFO: 12V restored — stopping motor, resuming heating cycle");
    stopMotor();
    motorMode      = MOTOR_MODE_OFF;
    v12WasAbsent   = false;
    warningTracked = false;
    digitalWrite(HEATER_PIN, HIGH);
  }

  // ── Heater state machine ───────────────────────────────────────────────────
  switch (state) {

    case HEATING:
      digitalWrite(HEATER_PIN, HIGH);
      if (tempC >= TARGET_TEMP) {
        holdStart = millis();
        state     = MAINTAINING;
        Serial.println("[STATE] MAINTAINING");
      }
      break;

    case MAINTAINING:
      if (tempC >= HYST_HIGH)     digitalWrite(HEATER_PIN, LOW);
      else if (tempC <= HYST_LOW) digitalWrite(HEATER_PIN, HIGH);
      if (millis() - holdStart >= HOLD_MS) {
        digitalWrite(HEATER_PIN, LOW);
        state = COOLING;
        Serial.println("[STATE] COOLING — heater OFF");
      }
      break;

    case COOLING:
      digitalWrite(HEATER_PIN, LOW);
      break;
  }

  // ── LEDs show temperature climb ────────────────────────────────────────────
  updateLEDs_temperature(tempC, state);

  // ── Serial (docked) ────────────────────────────────────────────────────────
  Serial.print("Temp: ");
  Serial.print(tempC, 1);
  Serial.print(" C  |  R: ");
  Serial.print(resistance / 1000.0, 2);
  Serial.print(" kOhm  |  V: ");
  Serial.print(voltage, 3);
  Serial.print(" V  |  Heater: ");
  Serial.print(digitalRead(HEATER_PIN) ? "ON " : "OFF");
  Serial.print("  |  State: ");

  switch (state) {
    case HEATING:
      Serial.print("HEATING      ");
      break;
    case MAINTAINING: {
      unsigned long secs = (HOLD_MS - (millis() - holdStart)) / 1000;
      Serial.print("MAINTAINING  ");
      Serial.print(secs / 60); Serial.print("m ");
      Serial.print(secs % 60); Serial.print("s left  ");
      break;
    }
    case COOLING:
      Serial.print("COOLING      ");
      break;
  }

  Serial.print("  |  LEDs: ");
  Serial.print(digitalRead(LED1_PIN) ? "1" : "-");
  Serial.print(digitalRead(LED2_PIN) ? "2" : "-");
  Serial.println(digitalRead(LED3_PIN) ? "3" : "-");

  delay(1000);
}