A door that nags

/*
  Door Sensor - a door that nags                        TK107 / /p/tk107

  Wiring, the same as the first read. Count from the square pad on
  the TinkerBlock board, parts up, header at the bottom:

    GND    -> GND
    3V3    -> 3V3 on an ESP32, ESP32-S3 or Pico; 5V on an Uno.
              Your board's logic voltage: this pin powers nothing,
              it is the level a closed sensor puts on SIGNAL.
    NC     -> nothing   (unconnected on the board)
    SIGNAL -> GPIO 4 on an ESP32-S3, GPIO 25 on an ESP32,
              D2 on an Uno, GP15 on a Raspberry Pi Pico

  The sensor: its two wires go under the two screws of the terminal
  block. Either way round; the sensor is a plain switch.

  What it does: counts openings, and once the door has been open
  longer than OPEN_TOO_LONG_S it prints a reminder every
  OPEN_TOO_LONG_S seconds until the door closes. No delay(), so
  nothing else is blocked while it waits.

  Arduino IDE
    Tools > Board                 your board, e.g. ESP32S3 Dev Module
    Tools > Port                  the one that appears when you plug in
    Tools > USB CDC On Boot       Enabled   (ESP32-S3 only)
    No library needed.
*/

// The pin SIGNAL is wired to.
// Uno: 2. ESP32: 25. ESP32-S3: 4. Pico: 15.
const int DOOR_PIN = 4;

// A change counts once it has held this long: longer than a contact
// bounces, shorter than a real door.
const unsigned long DEBOUNCE_MS = 50;

// Open for longer than this and it nags, then nags again this often.
const unsigned long OPEN_TOO_LONG_S = 10;

int raw;                       // the latest reading
int steady;                    // the debounced state: HIGH = closed
unsigned long rawSince;        // when raw last changed
unsigned long openedAt;        // when the door was last seen to open
unsigned long lastNag;         // when it last nagged
unsigned int openings = 0;

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

  // The board has no pull-down and no pull-up. While the sensor is
  // open, SIGNAL is connected to nothing and floats; a closed sensor
  // puts VCC on it. So the pin must pull itself LOW: INPUT_PULLDOWN.
  // INPUT_PULLUP would be wrong: open would read HIGH, closed would
  // read HIGH, and the two could never be told apart.
#ifdef INPUT_PULLDOWN
  pinMode(DOOR_PIN, INPUT_PULLDOWN);
#else
  // An Uno or Nano has no internal pull-down. Fit a 10 kOhm resistor
  // from SIGNAL to GND, or this pin will read noise while open.
  pinMode(DOOR_PIN, INPUT);
#endif

  // Report the state at power-up, so the first line is never a change.
  raw = digitalRead(DOOR_PIN);
  steady = raw;
  rawSince = millis();
  openedAt = millis();
  lastNag = millis();
  Serial.println(steady == HIGH ? "door closed (magnet near)"
                                : "door open");
}

void loop() {
  unsigned long now = millis();

  int level = digitalRead(DOOR_PIN);
  if (level != raw) {          // a bounce, or a real change starting
    raw = level;
    rawSince = now;
  }

  // Believe a change only once it has held for DEBOUNCE_MS.
  if (raw != steady && now - rawSince >= DEBOUNCE_MS) {
    steady = raw;
    if (steady == HIGH) {
      Serial.println("door closed");
    } else {
      openings++;
      openedAt = now;
      lastNag = now;
      Serial.print("door opened (opening ");
      Serial.print(openings);
      Serial.println(")");
    }
  }

  // Still open after OPEN_TOO_LONG_S: say so, then again every
  // OPEN_TOO_LONG_S seconds.
  if (steady == LOW && now - lastNag >= OPEN_TOO_LONG_S * 1000UL) {
    lastNag = now;
    Serial.print("door has been open for ");
    Serial.print((now - openedAt) / 1000UL);
    Serial.println(" s");
  }
}

"""
  Door Sensor - a door that nags, MicroPython           TK107 / /p/tk107

  Wiring, the same as the first read. Count from the square pad on
  the TinkerBlock board, parts up, header at the bottom:

    GND    -> GND
    3V3    -> 3V3   (your board's logic voltage: this pin powers
                     nothing, it is the level a closed sensor puts
                     on SIGNAL)
    NC     -> nothing   (unconnected on the board)
    SIGNAL -> GPIO 4 on an ESP32-S3, GPIO 25 on an ESP32,
              GP15 on a Raspberry Pi Pico

  The sensor: its two wires go under the two screws of the terminal
  block. Either way round; the sensor is a plain switch.

  What it does: counts openings, and once the door has been open
  longer than OPEN_TOO_LONG_S it prints a reminder every
  OPEN_TOO_LONG_S seconds until the door closes.

  Thonny
    Run > Configure interpreter   MicroPython (ESP32) or
                                  MicroPython (Raspberry Pi Pico)
    Save it to the board as main.py to run it on every power-up.
"""

from machine import Pin
import time

# ESP32: 25. ESP32-S3: 4. Pico: 15.
DOOR_PIN = 4

# A change counts once it has held this long: longer than a contact
# bounces, shorter than a real door.
DEBOUNCE_MS = 50

# Open for longer than this and it nags, then nags again this often.
OPEN_TOO_LONG_S = 10

# The board has no pull-down and no pull-up. While the sensor is
# open, SIGNAL floats; a closed sensor puts VCC on it. So the pin
# must pull itself LOW: Pin.PULL_DOWN. Pin.PULL_UP would make open
# and closed both read 1.
door = Pin(DOOR_PIN, Pin.IN, Pin.PULL_DOWN)

# Report the state at power-up, so the first line is never a change.
raw = door.value()
steady = raw                      # 1 = closed, 0 = open
raw_since = time.ticks_ms()
opened_at = time.ticks_ms()
last_nag = time.ticks_ms()
openings = 0
print("door closed (magnet near)" if steady else "door open")

while True:
    now = time.ticks_ms()

    level = door.value()
    if level != raw:              # a bounce, or a real change starting
        raw = level
        raw_since = now

    # Believe a change only once it has held for DEBOUNCE_MS.
    if raw != steady and time.ticks_diff(now, raw_since) >= DEBOUNCE_MS:
        steady = raw
        if steady:
            print("door closed")
        else:
            openings += 1
            opened_at = now
            last_nag = now
            print(f"door opened (opening {openings})")

    # Still open after OPEN_TOO_LONG_S: say so, then again every
    # OPEN_TOO_LONG_S seconds.
    if not steady and time.ticks_diff(now, last_nag) >= OPEN_TOO_LONG_S * 1000:
        last_nag = now
        secs = time.ticks_diff(now, opened_at) // 1000
        print(f"door has been open for {secs} s")

    time.sleep_ms(10)