Practical case: NFC tool logbook with Raspberry Pi

#!/usr/bin/env python3
import time
import csv
import os
import argparse
from datetime import datetime

# Attempt to import hardware libraries
try:
    import smbus2
    import spidev
    import RPi.GPIO as GPIO
    HARDWARE_AVAILABLE = True
except ImportError:
    HARDWARE_AVAILABLE = False

class I2CAdapter:
    """Adapter for I2C communication handling the RTC and NFC modules."""
    def __init__(self, use_mock: bool):
        self.use_mock = use_mock
        self.tap_counter = 0
        self.simulated_uid = "UID-8A-9B-2C"

        if not self.use_mock and HARDWARE_AVAILABLE:
            self.bus = smbus2.SMBus(1)

    def read_rtc_time(self) -> str:
        """Reads time from DS3231 or returns system time in mock mode."""
        if self.use_mock or not HARDWARE_AVAILABLE:
            # Mock mode: Return current system time
            return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        else:
            # Physical mode: Read registers 0x00 to 0x06 from DS3231 (0x68)
            # For brevity and robustness in this adapter, we fall back to system time 
            # if physical read fails.
            try:
                data = self.bus.read_i2c_block_data(0x68, 0x00, 7)
                # BCD to Decimal conversion omitted; returning system time for safety
                return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            except Exception:
                return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    def poll_nfc(self) -> str:
        """Polls the PN532 for a card tap. Simulates taps in mock mode."""
        if self.use_mock or not HARDWARE_AVAILABLE:
            self.tap_counter += 1
            # Simulate a tap every 5 iterations
            if self.tap_counter % 5 == 0:
                return self.simulated_uid
            return ""
        else:
            # Physical mode: Poll PN532 (0x24)
            # In a full physical implementation, we would send the InListPassiveTarget command.
            # Here we return empty to prevent blocking if hardware is misconfigured.
            return ""

class SPIAdapter:
    """Adapter for SPI communication handling the E-Paper Display."""
    def __init__(self, use_mock: bool):
        self.use_mock = use_mock
        if not self.use_mock and HARDWARE_AVAILABLE:
            self.spi = spidev.SpiDev()
            self.spi.open(0, 0)
            self.spi.max_speed_hz = 2000000

    def update_display(self, state: str, user: str = ""):
        """Pushes a new buffer to the e-paper display or prints to console."""
        if self.use_mock or not HARDWARE_AVAILABLE:
            print("\n" + "="*30)
            print("[ E-PAPER DISPLAY ]")
            print(f"STATUS: {state}")
            if user:
                print(f"USER:   {user}")
            print("="*30 + "\n")
        else:
            # Physical mode: Send image buffer over SPI
            # (Requires specific e-paper driver logic depending on the exact screen model)
            pass

class LogbookSystem:
    def __init__(self, use_mock: bool):
        self.i2c = I2CAdapter(use_mock)
        self.spi = SPIAdapter(use_mock)
        self.log_file = "checkout_log.csv"
        self.state = "AVAILABLE"
        self.current_user = ""

        self._initialize_log()

    def _initialize_log(self):
        if not os.path.exists(self.log_file):
            with open(self.log_file, 'w', newline='') as f:
                writer = csv.writer(f)
                writer.writerow(["Timestamp", "Action", "UID"])

    def log_event(self, action: str, uid: str):
        timestamp = self.i2c.read_rtc_time()
        with open(self.log_file, 'a', newline='') as f:
            writer = csv.writer(f)
            writer.writerow([timestamp, action, uid])
        print(f"[{timestamp}] LOGGED: {action} by {uid}")

    def run(self, iterations: int = 15):
        print("Starting NFC Tool Checkout System...")
        self.spi.update_display(self.state)

        for i in range(iterations):
            uid = self.i2c.poll_nfc()
            if uid:
                if self.state == "AVAILABLE":
                    self.state = "CHECKED OUT"
                    self.current_user = uid
                    self.log_event("CHECKOUT", uid)
                    self.spi.update_display(self.state, self.current_user)
                elif self.state == "CHECKED OUT":
                    if self.current_user == uid:
                        self.state = "AVAILABLE"
                        self.current_user = ""
                        self.log_event("RETURN", uid)
                        self.spi.update_display(self.state)
                    else:
                        print(f"WARN: User {uid} attempted to return a tool checked out by {self.current_user}")

            time.sleep(1)

        print("System execution completed.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="NFC Tool Checkout Logbook")
    parser.add_argument("--mock", action="store_true", help="Force mock mode without hardware")
    args = parser.parse_args()

    # Auto-enable mock if hardware libraries are missing
    force_mock = args.mock or not HARDWARE_AVAILABLE
    if force_mock:
        print("Running in MOCK mode (Hardware libraries not found or --mock passed).")

    system = LogbookSystem(use_mock=force_mock)
    system.run(iterations=12)