"""
# main.py - RackGuard IoT Sentinel for Wokwi Simulation
# Author: jessiqveen-dotcom
"""
import time
import json
import machine
from machine import Pin, PWM, I2C
import neopixel
import network
try:
import urequests as requests
except ImportError:
try:
import requests
except ImportError:
requests = None
try:
ticks_ms = time.ticks_ms
ticks_diff = time.ticks_diff
except AttributeError:
ticks_ms = lambda: int(time.time() * 1000)
ticks_diff = lambda t1, t2: t1 - t2
# =============================================================================
# 1. WOKWI-COMPATIBLE PCF8574 I2C LCD DRIVER (HD44780)
# =============================================================================
class LCD1602:
"""
Direct hardware driver for PCF8574 I2C backpack driving HD44780 LCD1602.
Ensures Backlight bit (0x08) is constantly held HIGH and pulse transitions
correctly latch commands and characters into Wokwi's wokwi-lcd1602 emulator.
"""
def __init__(self, i2c, address=0x27):
self.i2c = i2c
self.address = address
time.sleep_ms(60)
# 4-bit initialization sequence
for nibble in (0x30, 0x30, 0x30, 0x20):
self._pulse(nibble)
time.sleep_ms(5)
# Function set (2 lines, 5x8 font), Display off, Clear, Entry mode, Display on
for cmd in (0x28, 0x08, 0x01, 0x06, 0x0C):
self.command(cmd)
time.sleep_ms(2)
def _pulse(self, value):
# Latch cycle: Enable (P2=0x04) high then low, Backlight (P3=0x08) always ON
self.i2c.writeto(self.address, bytes([value | 0x08]))
self.i2c.writeto(self.address, bytes([value | 0x0C]))
time.sleep_us(2)
self.i2c.writeto(self.address, bytes([value | 0x08]))
time.sleep_us(50)
def _send(self, value, rs=0):
# Send upper nibble, then lower nibble
self._pulse((value & 0xF0) | rs)
self._pulse(((value << 4) & 0xF0) | rs)
def command(self, value):
self._send(value, rs=0)
if value in (1, 2):
time.sleep_ms(3)
def print(self, text):
for char in text:
self._send(ord(char), rs=1)
def set_cursor(self, row, col):
address = 0x80 if row == 0 else 0xC0
address += col
self.command(address)
def clear(self):
self.command(0x01)
time.sleep_ms(3)
# =============================================================================
# 2. LOGGING UTILITY
# =============================================================================
class Log:
@staticmethod
def i(msg):
print(f"[INFO] {msg}")
@staticmethod
def w(msg):
print(f"[WARN] {msg}")
@staticmethod
def e(msg):
print(f"[ERROR] {msg}")
# =============================================================================
# 3. HARDWARE PERIPHERALS
# =============================================================================
class LockActuator:
LOCKED_ANGLE = 0
UNLOCKED_ANGLE = 90
def __init__(self, pin: int = 16):
self._pin = pin
self._pwm = PWM(Pin(self._pin))
self._pwm.freq(50)
self.lock()
def set_angle(self, angle: int):
angle = max(0, min(180, angle))
duty = int((8000 - 1500) * float(angle) / 180.0) + 1500
self._pwm.duty_u16(duty)
def lock(self):
self.set_angle(self.LOCKED_ANGLE)
Log.i("LockActuator: Rack strike LOCKED (0°)")
def unlock(self):
self.set_angle(self.UNLOCKED_ANGLE)
Log.i("LockActuator: Rack strike UNLOCKED (90°)")
class PiezoBuzzer:
def __init__(self, pin: int = 12):
self._pin = pin
self._pwm = PWM(Pin(self._pin))
self.stop()
self._siren_active = False
self._siren_phase = 0
self._siren_last_toggle = 0
self._pattern_queue = []
self._active_step = None
self._step_start_ticks = 0
self._step_in_pause = False
def tone(self, freq: int, duty: int = 32768):
if freq > 0:
self._pwm.freq(freq)
self._pwm.duty_u16(duty)
def stop(self):
self._pwm.duty_u16(0)
def play_chime(self):
self.stop_siren()
self._pattern_queue = [
(523, 70, 20),
(659, 70, 20),
(784, 70, 20),
(1047, 140, 0),
]
self._active_step = None
def play_warning_double_beep(self):
self.stop_siren()
self._pattern_queue = [
(440, 90, 70),
(440, 90, 0),
]
self._active_step = None
def start_siren(self):
self._pattern_queue.clear()
self._active_step = None
self._siren_active = True
self._siren_phase = 0
self._siren_last_toggle = ticks_ms()
self.tone(900)
Log.i("PiezoBuzzer: TAMPER SIREN ACTIVE")
def stop_siren(self):
if self._siren_active:
self._siren_active = False
self.stop()
def update(self):
now = ticks_ms()
if self._siren_active:
if ticks_diff(now, self._siren_last_toggle) >= 140:
self._siren_phase = 1 - self._siren_phase
freq = 1500 if self._siren_phase == 1 else 900
self.tone(freq)
self._siren_last_toggle = now
return
if self._active_step is None and len(self._pattern_queue) > 0:
self._active_step = self._pattern_queue.pop(0)
self._step_start_ticks = now
self._step_in_pause = False
freq, duration, pause = self._active_step
self.tone(freq)
return
if self._active_step is not None:
freq, duration, pause = self._active_step
elapsed = ticks_diff(now, self._step_start_ticks)
if not self._step_in_pause:
if elapsed >= duration:
if pause > 0:
self.stop()
self._step_in_pause = True
self._step_start_ticks = now
else:
self.stop()
self._active_step = None
else:
if elapsed >= pause:
self._active_step = None
class StatusNeoPixel:
COLOR_STANDBY_BLUE = (0, 0, 200)
COLOR_STANDBY_AMBER = (255, 120, 0)
COLOR_GRANTED_GREEN = (0, 255, 0)
COLOR_LOCKOUT_RED = (255, 0, 0)
COLOR_OFF = (0, 0, 0)
def __init__(self, pin: int = 15, num_leds: int = 1):
self._num_leds = num_leds
self._np = neopixel.NeoPixel(Pin(pin, Pin.OUT), num_leds)
self._flashing = False
self._flash_state = False
self._last_flash_ticks = 0
self._flash_interval_ms = 180
self.set_standby()
def set_color(self, r: int, g: int, b: int):
for i in range(self._num_leds):
self._np[i] = (r, g, b)
self._np.write()
def set_standby(self, amber: bool = False):
self.stop_lockout_flashing()
self.set_color(*(self.COLOR_STANDBY_AMBER if amber else self.COLOR_STANDBY_BLUE))
def set_granted(self):
self.stop_lockout_flashing()
self.set_color(*self.COLOR_GRANTED_GREEN)
def set_denied(self):
self.stop_lockout_flashing()
self.set_color(*self.COLOR_LOCKOUT_RED)
def off(self):
self.set_color(*self.COLOR_OFF)
def start_lockout_flashing(self, interval_ms: int = 180):
self._flashing = True
self._flash_interval_ms = interval_ms
self._flash_state = True
self._last_flash_ticks = ticks_ms()
self.set_color(*self.COLOR_LOCKOUT_RED)
def stop_lockout_flashing(self):
if self._flashing:
self._flashing = False
self.off()
def update(self):
if not self._flashing:
return
now = ticks_ms()
if ticks_diff(now, self._last_flash_ticks) >= self._flash_interval_ms:
self._flash_state = not self._flash_state
if self._flash_state:
self.set_color(*self.COLOR_LOCKOUT_RED)
else:
self.off()
self._last_flash_ticks = now
class LCDDisplay:
def __init__(self, sda: int = 0, scl: int = 1):
self._sda = sda
self._scl = scl
self._lcd = None
self._line0 = ""
self._line1 = ""
try:
# Power-up delay for Wokwi I2C backpack
time.sleep_ms(100)
# Use 100kHz standard speed for PCF8574
self._i2c = I2C(0, sda=Pin(self._sda), scl=Pin(self._scl), freq=100000)
devs = self._i2c.scan()
addr = devs[0] if len(devs) > 0 else 0x27
Log.i(f"LCDDisplay: Connected at address 0x{addr:02X}")
self._lcd = LCD1602(self._i2c, address=addr)
self._lcd.clear()
except Exception as e:
Log.e(f"LCD init error: {e}")
def clear(self):
if self._lcd:
try:
self._lcd.clear()
except Exception:
pass
self._line0 = ""
self._line1 = ""
def show_text(self, line0: str, line1: str):
pad0 = f"{line0:<16}"[:16]
pad1 = f"{line1:<16}"[:16]
if pad0 != self._line0 or pad1 != self._line1:
self._line0 = pad0
self._line1 = pad1
if self._lcd:
try:
self._lcd.set_cursor(0, 0)
self._lcd.print(pad0)
self._lcd.set_cursor(1, 0)
self._lcd.print(pad1)
except Exception as e:
Log.e(f"LCD write error: {e}")
Log.i(f"LCD -> [{pad0}] | [{pad1}]")
def display_standby(self, terminal_id: str = "Data Center 01"):
self.show_text(terminal_id, "LOCKED-Enter PIN")
def display_pin(self, terminal_id: str = "Data Center 01", pin_len: int = 0):
self.show_text(terminal_id, f"PIN: {'*' * pin_len:<11}")
def display_granted(self, countdown_sec: int = 10):
self.show_text(" ACCESS GRANTED ", f"Relocking: {countdown_sec:2d}s..")
def display_invalid(self, attempts: int = 1, max_attempts: int = 3):
self.show_text(" ACCESS DENIED ", f"INVALID PIN ({attempts}/{max_attempts})")
def display_lockout(self, phase: int = 0):
if phase % 2 == 0:
self.show_text("!TAMPER LOCKOUT!", "*SECURITY ALERT*")
else:
self.show_text("ACCESS FORBIDDEN", "CALL SEC-OPS/DBA")
class MatrixKeypad:
DEFAULT_KEYS = [
['1', '2', '3', 'A'],
['4', '5', '6', 'B'],
['7', '8', '9', 'C'],
['*', '0', '#', 'D']
]
KEY_SUBMIT = "#"
KEY_CLEAR = "*"
def __init__(self, row_pins: list = None, col_pins: list = None, debounce_ms: int = 180):
self._row_pin_nums = row_pins or [2, 3, 4, 5]
self._col_pin_nums = col_pins or [6, 7, 8, 9]
self._debounce_ms = debounce_ms
self._row_pins = [Pin(r, Pin.OUT) for r in self._row_pin_nums]
for r in self._row_pins:
r.value(0)
self._col_pins = [Pin(c, Pin.IN, Pin.PULL_DOWN) for c in self._col_pin_nums]
self._last_key = None
self._last_press_ticks = 0
def scan(self) -> str:
for r_idx, r_pin in enumerate(self._row_pins):
r_pin.value(1)
for c_idx, c_pin in enumerate(self._col_pins):
if c_pin.value() == 1:
r_pin.value(0)
return self.DEFAULT_KEYS[r_idx][c_idx]
r_pin.value(0)
return None
def get_key(self) -> str:
now = ticks_ms()
raw_key = self.scan()
if raw_key is not None:
if raw_key != self._last_key and ticks_diff(now, self._last_press_ticks) > self._debounce_ms:
self._last_key = raw_key
self._last_press_ticks = now
Log.i(f"Keypad input: '{raw_key}'")
return raw_key
else:
if self._last_key is not None and ticks_diff(now, self._last_press_ticks) > 60:
self._last_key = None
return None
# =============================================================================
# 4. WI-FI & WEBHOOK TELEMETRY
# =============================================================================
class WiFiManager:
def __init__(self, ssid: str = "Wokwi-GUEST", password: str = ""):
self._ssid = ssid
self._password = password
self._sta = None
def connect(self, timeout_sec: int = 5) -> bool:
Log.i(f"Connecting to Wi-Fi '{self._ssid}'...")
try:
self._sta = network.WLAN(network.STA_IF)
self._sta.active(True)
self._sta.connect(self._ssid, self._password)
start = time.time()
while not self._sta.isconnected() and (time.time() - start) < timeout_sec:
time.sleep(0.5)
if self._sta.isconnected():
Log.i(f"Wi-Fi connected! IP: {self._sta.ifconfig()[0]}")
return True
except Exception as e:
Log.e(f"Wi-Fi error: {e}")
return False
def is_connected(self) -> bool:
return self._sta.isconnected() if self._sta else False
class WebhookClient:
def __init__(self, webhook_url: str = "https://httpbin.org/post",
terminal_id: str = "Data Center 01", wifi: WiFiManager = None):
self._webhook_url = webhook_url
self._terminal_id = terminal_id
self._wifi = wifi
def log_event(self, event_type: str, credential_status: str, details: str = "", user_id: str = ""):
payload = {
"timestamp": time.time(),
"terminal_id": self._terminal_id,
"event_type": event_type,
"credential_status": credential_status,
"user_id": user_id,
"details": details,
}
Log.i(f"TELEMETRY LOG -> {json.dumps(payload)}")
if requests and self._wifi and self._wifi.is_connected():
try:
res = requests.post(self._webhook_url, json=payload, headers={"Content-Type": "application/json"}, timeout=4)
if hasattr(res, "close"):
res.close()
Log.i("Webhook dispatch successful (HTTP 200)")
except Exception as e:
Log.e(f"Webhook dispatch failed: {e}")
# =============================================================================
# 5. RACKGUARD CONTROLLER
# =============================================================================
class RackGuardController:
STATE_INIT = "INIT"
STATE_LOCKED = "LOCKED"
STATE_VALIDATING = "VALIDATING"
STATE_UNLOCKED = "UNLOCKED"
STATE_TAMPER_LOCKOUT = "TAMPER_LOCKOUT"
DEFAULT_USERS = {
"1234": {"id": "TECH-101", "name": "Lead Technician", "role": "Technician"},
"5678": {"id": "DBA-204", "name": "Senior DBA", "role": "DBA"},
"9999": {"id": "SRE-309", "name": "Site Reliability Eng", "role": "SRE"},
"0000": {"id": "ADMIN-00", "name": "SecOps Supervisor", "role": "MasterAdmin"},
}
def __init__(self, terminal_id="Data Center 01", webhook_url="https://httpbin.org/post"):
self._terminal_id = terminal_id
self._webhook_url = webhook_url
self._state = self.STATE_INIT
self._current_pin = ""
self._override_pin = ""
self._failed_attempts = 0
self._max_failed_attempts = 3
self._unlock_duration_sec = 10
self._unlock_start_ticks = 0
self._last_countdown_sec = -1
self._cooldown_duration_sec = 30
self._lockout_start_ticks = 0
self._lockout_last_toggle = 0
self._lockout_phase = 0
self._invalid_banner_start = 0
self.actuator = LockActuator(pin=16)
self.buzzer = PiezoBuzzer(pin=12)
self.neopixel = StatusNeoPixel(pin=15, num_leds=1)
self.lcd = LCDDisplay(sda=0, scl=1)
self.keypad = MatrixKeypad(row_pins=[2, 3, 4, 5], col_pins=[6, 7, 8, 9])
self.wifi = WiFiManager()
self.webhook = WebhookClient(webhook_url=self._webhook_url, terminal_id=self._terminal_id, wifi=self.wifi)
def start(self):
self.lcd.show_text("RackGuard IoT", "System Init...")
self.neopixel.set_standby(amber=True)
self.actuator.lock()
self.wifi.connect(timeout_sec=4)
self.set_state(self.STATE_LOCKED)
def set_state(self, new_state: str, user: dict = None):
old_state = self._state
self._state = new_state
Log.i(f"State Transition: [{old_state}] -> [{new_state}]")
if new_state == self.STATE_LOCKED:
self._current_pin = ""
self._override_pin = ""
self._invalid_banner_start = 0
self.buzzer.stop_siren()
self.neopixel.stop_lockout_flashing()
self.neopixel.set_standby(amber=False)
self.actuator.lock()
self.lcd.display_standby(self._terminal_id)
elif new_state == self.STATE_UNLOCKED:
self.actuator.unlock()
self.neopixel.set_granted()
self.buzzer.play_chime()
self._unlock_start_ticks = ticks_ms()
self._last_countdown_sec = self._unlock_duration_sec
self.lcd.display_granted(self._unlock_duration_sec)
uid = user["id"] if user else "UNKNOWN"
self.webhook.log_event("ACCESS_GRANTED", "AUTHORIZED", f"Unlocked by {uid}", uid)
elif new_state == self.STATE_TAMPER_LOCKOUT:
self.actuator.lock()
self.neopixel.start_lockout_flashing(interval_ms=160)
self.buzzer.start_siren()
self._lockout_start_ticks = ticks_ms()
self._lockout_last_toggle = ticks_ms()
self._lockout_phase = 0
self._override_pin = ""
self.lcd.display_lockout(self._lockout_phase)
self.webhook.log_event("TAMPER_LOCKOUT", "MAX_ATTEMPTS_EXCEEDED", "Security Breach Alarm", "INTRUDER")
def tick(self):
self.buzzer.update()
self.neopixel.update()
key = self.keypad.get_key()
if self._state == self.STATE_LOCKED:
now = ticks_ms()
if self._invalid_banner_start > 0 and ticks_diff(now, self._invalid_banner_start) >= 1500:
self._invalid_banner_start = 0
self.lcd.display_standby(self._terminal_id)
self.neopixel.set_standby()
if key is not None:
if key in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D']:
self._invalid_banner_start = 0
self._current_pin += key
self.lcd.display_pin(self._terminal_id, len(self._current_pin))
self.buzzer.tone(1200, 1000)
time.sleep_ms(20)
self.buzzer.stop()
elif key == self.keypad.KEY_CLEAR:
self._current_pin = ""
self.lcd.display_standby(self._terminal_id)
elif key == self.keypad.KEY_SUBMIT:
if len(self._current_pin) > 0:
self.set_state(self.STATE_VALIDATING)
elif self._state == self.STATE_VALIDATING:
pin = self._current_pin
if pin in self.DEFAULT_USERS:
user = self.DEFAULT_USERS[pin]
self._failed_attempts = 0
self._current_pin = ""
self.set_state(self.STATE_UNLOCKED, user=user)
else:
self._failed_attempts += 1
attempts = self._failed_attempts
self._current_pin = ""
self.buzzer.play_warning_double_beep()
self.neopixel.set_denied()
self.lcd.display_invalid(attempts, self._max_failed_attempts)
self._invalid_banner_start = ticks_ms()
self.webhook.log_event("ACCESS_DENIED", "INVALID_CREDENTIAL", f"Attempt {attempts} of {self._max_failed_attempts}")
if attempts >= self._max_failed_attempts:
self.set_state(self.STATE_TAMPER_LOCKOUT)
else:
self._state = self.STATE_LOCKED
elif self._state == self.STATE_UNLOCKED:
now = ticks_ms()
elapsed_sec = ticks_diff(now, self._unlock_start_ticks) // 1000
remaining_sec = max(0, self._unlock_duration_sec - elapsed_sec)
if remaining_sec != self._last_countdown_sec:
self._last_countdown_sec = remaining_sec
self.lcd.display_granted(remaining_sec)
if elapsed_sec >= self._unlock_duration_sec or key in [self.keypad.KEY_SUBMIT, self.keypad.KEY_CLEAR]:
self.set_state(self.STATE_LOCKED)
elif self._state == self.STATE_TAMPER_LOCKOUT:
now = ticks_ms()
if ticks_diff(now, self._lockout_last_toggle) >= 1200:
self._lockout_phase = 1 - self._lockout_phase
self.lcd.display_lockout(self._lockout_phase)
self._lockout_last_toggle = now
if ticks_diff(now, self._lockout_start_ticks) // 1000 >= self._cooldown_duration_sec:
Log.i("Security cooldown expired; reset to standby")
self._failed_attempts = 0
self.webhook.log_event("COOLDOWN_RESET", "COOLDOWN_EXPIRED")
self.set_state(self.STATE_LOCKED)
return
if key is not None:
if key in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:
self._override_pin += key
elif key == self.keypad.KEY_CLEAR:
self._override_pin = ""
elif key == self.keypad.KEY_SUBMIT:
if self._override_pin == "0000":
Log.i("MASTER ADMIN OVERRIDE ACCEPTED!")
self._failed_attempts = 0
self.webhook.log_event("SECURITY_OVERRIDE", "ADMIN_OVERRIDE")
self.set_state(self.STATE_LOCKED)
else:
self._override_pin = ""
self.buzzer.play_warning_double_beep()
def run(self):
self.start()
Log.i("RackGuard Sentinel running. Press Ctrl+C to terminate.")
try:
while True:
self.tick()
time.sleep(0.015)
except KeyboardInterrupt:
self.stop()
def stop(self):
self.actuator.lock()
self.buzzer.stop()
self.buzzer.stop_siren()
self.neopixel.off()
self.lcd.clear()
Log.i("RackGuard Sentinel stopped.")
# =============================================================================
# 6. APPLICATION ENTRY POINT
# =============================================================================
if __name__ == "__main__":
sentinel = RackGuardController()
sentinel.run()Loading
pi-pico-w
pi-pico-w