GFCI concept demo (not a real GFCI) on an Arduino Uno

// GFCI concept demo: a teaching model of ground-fault detection on a 12 V DC
// lamp. THIS IS NOT A REAL GFCI. A real GFCI trips at 4 to 6 mA of imbalance
// within about 25 ms. The ACS712 cannot see milliamps (one converter step is
// 26 mA, and its noise is a few steps), so this stand-in trips at a much
// larger imbalance: 60 mA. A hobby board is never a substitute for a listed
// GFCI device, and nothing here is safe to connect to mains or to a person.
//
//   A0      ACS712 "hot" sensor OUT   (VCC on 5 V, GND on GND)
//   A1      ACS712 "neutral" sensor OUT
//   pin 7   relay module IN (high = contacts closed, lamp on)
//   pin 2   TEST button to GND (chip pull-up)
//   pin 3   RESET button to GND (chip pull-up)
//   pin 13  the Uno's own LED: lit while tripped
//
// The load circuit (12 V, never touches the Uno):
//   supply plus -> hot sensor -> relay COM, NO -> lamp -> neutral sensor -> supply minus
// The leak switch adds a 100 ohm path from the lamp's hot side straight to
// ground. That current passes through the hot sensor but never comes back
// through the neutral sensor, like current going through a person or a damp
// wire to ground instead of home on the neutral.
//
// Why it works: with no fault, the current out on the hot wire equals the
// current back on the neutral, so hot minus neutral is zero. Any current that
// finds another way home shows up as the difference. A real GFCI does the
// subtraction inside one toroid coil; this model does it with two sensors.
//
// Both sensors are zeroed at power on, while the relay is still open and no
// current flows. Each reading is an average of 32 samples. Two windows in a
// row over the limit (under 25 ms in the simulator) trip the relay, and it stays open
// (latched) until RESET. TEST adds a 100 mA make-believe imbalance while held,
// like a real GFCI's TEST button. With the contacts open nothing flows, so the
// sensors cannot see a leak: RESET closes the relay for a short trial and
// opens it again at once if the imbalance is still there.

const int HOT_PIN = A0;
const int NEUTRAL_PIN = A1;
const int RELAY_PIN = 7;
const int TEST_PIN = 2;
const int RESET_PIN = 3;
const int TRIPPED_LED = 13;

const float TRIP_MA = 60.0;           // imbalance that trips (a real GFCI: 4 to 6 mA)
const float TEST_INJECT_MA = 100.0;   // the make-believe imbalance while TEST is held
const float MA_PER_COUNT = 26.42;     // ACS712-05B: 5000 mV / 1023 / 0.185 V per A
const int WINDOW_SAMPLES = 32;        // readings averaged per sensor per window
const int WINDOWS_TO_TRIP = 2;        // windows in a row over the limit
const unsigned long REPORT_MS = 500;
const unsigned long TRIAL_SETTLE_MS = 25;  // relay pull-in time before a RESET trial reads

float hotZero = 512;
float neutralZero = 512;
bool tripped = false;
int over = 0;
float hotMa = 0;
float neutralMa = 0;
bool lastReset = false;
unsigned long lastReport = 0;

void relayClosed(bool closed) {
  digitalWrite(RELAY_PIN, closed ? HIGH : LOW);
}

bool testHeld() {
  return digitalRead(TEST_PIN) == LOW;
}

// One window: average both sensors together and return hot minus neutral in mA.
float measure() {
  long hot = 0;
  long neutral = 0;
  for (int i = 0; i < WINDOW_SAMPLES; i++) {
    hot += analogRead(HOT_PIN);
    neutral += analogRead(NEUTRAL_PIN);
  }
  hotMa = (hot / (float)WINDOW_SAMPLES - hotZero) * MA_PER_COUNT;
  neutralMa = (neutral / (float)WINDOW_SAMPLES - neutralZero) * MA_PER_COUNT;
  float diff = hotMa - neutralMa;
  if (testHeld()) diff += TEST_INJECT_MA;
  return diff;
}

void zeroSensors() {
  long hot = 0;
  long neutral = 0;
  for (int i = 0; i < 256; i++) {
    hot += analogRead(HOT_PIN);
    neutral += analogRead(NEUTRAL_PIN);
  }
  hotZero = hot / 256.0;
  neutralZero = neutral / 256.0;
}

void trip(float diff) {
  relayClosed(false);
  tripped = true;
  over = 0;
  digitalWrite(TRIPPED_LED, HIGH);
  Serial.print(testHeld() ? "TRIP (TEST button): imbalance " : "TRIP: imbalance ");
  Serial.print((int)diff);
  Serial.print(" mA over the ");
  Serial.print((int)TRIP_MA);
  Serial.println(" mA limit, relay open, latched");
}

void tryReset() {
  if (!tripped) {
    Serial.println("RESET: nothing to reset");
    return;
  }
  if (testHeld()) {
    Serial.println("RESET refused: release TEST first");
    return;
  }
  // Trial: close the relay, let it settle, then look for the imbalance.
  relayClosed(true);
  unsigned long began = millis();
  while (millis() - began < TRIAL_SETTLE_MS) {
  }
  float first = measure();
  float second = measure();
  if (first > TRIP_MA && second > TRIP_MA) {
    relayClosed(false);
    Serial.print("RESET refused: leak still present, imbalance ");
    Serial.print((int)second);
    Serial.println(" mA, relay open");
    return;
  }
  tripped = false;
  over = 0;
  digitalWrite(TRIPPED_LED, LOW);
  Serial.println("RESET accepted: relay closed, lamp on");
}

void setup() {
  Serial.begin(115200);
  Serial.println("Mokxi Arduino Uno: GFCI concept demo, NOT a real GFCI");
  Serial.println("A real GFCI trips at 4 to 6 mA within about 25 ms.");
  Serial.println("The ACS712 cannot see milliamps, so this stand-in trips at 60 mA.");
  Serial.println("Never a substitute for a listed GFCI device.");
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(TRIPPED_LED, OUTPUT);
  pinMode(TEST_PIN, INPUT_PULLUP);
  pinMode(RESET_PIN, INPUT_PULLUP);
  relayClosed(false);
  zeroSensors();
  Serial.println("Sensors zeroed with the relay open");
  relayClosed(true);
  Serial.println("Relay closed, lamp on");
}

void loop() {
  float diff = measure();
  if (!tripped) {
    if (diff > TRIP_MA) {
      over++;
      if (over >= WINDOWS_TO_TRIP) trip(diff);
    } else {
      over = 0;
    }
  }

  bool reset = digitalRead(RESET_PIN) == LOW;
  if (reset && !lastReset) tryReset();
  lastReset = reset;

  if (millis() - lastReport >= REPORT_MS) {
    lastReport = millis();
    Serial.print("hot ");
    Serial.print((int)hotMa);
    Serial.print(" mA, neutral ");
    Serial.print((int)neutralMa);
    Serial.print(" mA, diff ");
    Serial.print((int)diff);
    Serial.print(" mA, ");
    Serial.println(tripped ? "TRIPPED" : "ON");
  }
}