Andrew's FabAcademy Journey - Inventory Tracking Project

Inventory Tracking System for Storerooms

Prepared by Andrew | Last Updated: May 27, 2025, 04:23 AM CAT

This Fab Academy project automates tool and item management in storerooms, addressing inefficiencies and loss due to misplaced or untracked tools.

Problem

Tools in storerooms are often misplaced or untracked, leading to inefficiencies and loss. Manual tracking is error-prone and time-consuming.

Solution

The Inventory Tracking System automates tool management by:

Scanning RFID tags using an RF Ideas RDR-7081AKU USB RFID reader to identify up to 20 tools.

Registering borrowers via a second RFID scan (RFID-RC522) or manual UID entry as a redundancy plan.

Displaying real-time status, inventory, and transaction logs via a Tkinter GUI on a Raspberry Pi.

Logging transactions (tool UID, borrower UID, timestamp, action) in a CSV file.

Allowing quantity adjustments through GUI buttons.

This system enhances efficiency, reduces loss, and ensures reliability with a manual fallback if the RFID reader fails.

Prior Work

Coding Techroom: Using RFID for Inventory Management with Java on Raspberry Pi.

CodingTechroom
Medium: Building an RFID Reader and Display System with Raspberry Pi Zero W 2.

Medium
EAL: RFID Inventory Management.

EAL_Inventory_Management
My Prior Work: Implemented Tkinter GUI with serial communication and transitioned to RDR-7081AKU.

FabAcademy_Rwanda

Fab Academy Skills

Electronics Design: Designed a custom PCB in KiCAD to integrate Raspberry Pi, RDR-7081AKU, and optional I2C LCD.

Embedded Programming: Programmed Raspberry Pi with Python for RFID processing, Tkinter GUI, and CSV logging.

                        import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import serial
import csv
import threading
import time
from datetime import datetime
from RPLCD.i2c import CharLCD

class InventoryGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Inventory Tracking System")
        self.root.geometry("800x600")

        self.inventory_lock = threading.Lock()

        # Serial port for RP2040 (Raspberry Pi Pico)
        try:
            self.pico_serial = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
        except serial.SerialException:
            self.pico_serial = None
            print("Warning: RP2040 serial port not found.")

        # Optional serial port for other devices
        try:
            self.serial_port = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)  # Adjust if needed
        except serial.SerialException:
            self.serial_port = None
            print("Warning: General serial port not found.")

        self.inventory = {
            "Hammer": 5,
            "Screwdriver": 10,
            "Wrench": 8,
            "Pliers": 3
        }
        self.max_inventory = {
            "Hammer": 10,
            "Screwdriver": 20,
            "Wrench": 15,
            "Pliers": 5
        }

        self.last_uid = ""
        self.status_message = "Waiting for scan..."
        self.verification_status = "Pending"
        self.last_action = ""
        self.failover_mode = False
        self.selected_tool = "Hammer"

        # Initialize LCD (I2C address 0x27, 16x2 display)
        try:
            self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=16, rows=2)
            self.lcd.clear()
            self.lcd.write_string("Waiting for scan")
        except Exception as e:
            print(f"Warning: LCD initialization failed: {e}")
            self.lcd = None

        # Flag and entry for RDR-7081AKU keystrokes
        self.rdr_7081_input = ""
        self.uid_entry = tk.Entry(root)
        self.uid_entry.pack()
        self.uid_entry.bind("", self.process_rdr_7081_input)

        self.create_gui()

        # Start RFID scanning thread for RP2040
        threading.Thread(target=self.handle_rfid_scans, daemon=True).start()
        # Start thread to process RDR-7081AKU input
        threading.Thread(target=self.handle_rdr_7081_input_thread, daemon=True).start()

        self.update_gui()

    def create_gui(self):
        status_frame = ttk.LabelFrame(self.root, text="System Status", padding=10)
        status_frame.pack(fill="x", padx=10, pady=5)

        self.status_label = ttk.Label(status_frame, text="Status: Waiting for scan...")
        self.status_label.pack(anchor="w")
        self.uid_label = ttk.Label(status_frame, text="Last Scanned UID: None")
        self.uid_label.pack(anchor="w")
        self.verify_label = ttk.Label(status_frame, text="Verification: Pending")
        self.verify_label.pack(anchor="w")
        self.action_label = ttk.Label(status_frame, text="Last Action: None")
        self.action_label.pack(anchor="w")

        borrower_frame = ttk.LabelFrame(self.root, text="Borrower Registration", padding=10)
        borrower_frame.pack(fill="x", padx=10, pady=5)

        ttk.Label(borrower_frame, text="Select Tool:").pack(anchor="w")
        self.tool_var = tk.StringVar(value="Hammer")
        tool_dropdown = ttk.Combobox(borrower_frame, textvariable=self.tool_var, values=list(self.inventory.keys()))
        tool_dropdown.pack(anchor="w")
        tool_dropdown.bind("<>", self.update_selected_tool)

        ttk.Label(borrower_frame, text="Borrower UID:").pack(anchor="w")
        self.borrower_entry = ttk.Entry(borrower_frame)
        self.borrower_entry.pack(anchor="w")

        ttk.Button(borrower_frame, text="Register Borrower", command=self.register_borrower).pack(anchor="w", pady=5)
        ttk.Button(borrower_frame, text="Scan with RP2040/RC522", command=self.trigger_rfid_scan).pack(anchor="w")

        inventory_frame = ttk.LabelFrame(self.root, text="Inventory", padding=10)
        inventory_frame.pack(fill="both", expand=True, padx=10, pady=5)

        self.inventory_tree = ttk.Treeview(inventory_frame, columns=("Tool", "Quantity", "Increase", "Decrease"), show="headings")
        self.inventory_tree.heading("Tool", text="Tool")
        self.inventory_tree.heading("Quantity", text="Quantity")
        self.inventory_tree.heading("Increase", text="Add")
        self.inventory_tree.heading("Decrease", text="Remove")
        self.inventory_tree.column("Tool", width=150)
        self.inventory_tree.column("Quantity", width=100)
        self.inventory_tree.column("Increase", width=50)
        self.inventory_tree.column("Decrease", width=50)
        self.inventory_tree.pack(fill="both", expand=True)

        self.update_inventory_display()
        self.inventory_tree.bind("", self.handle_tree_click)

        log_frame = ttk.LabelFrame(self.root, text="Transaction Logs", padding=10)
        log_frame.pack(fill="both", expand=True, padx=10, pady=5)

        self.log_text = scrolledtext.ScrolledText(log_frame, height=10, wrap=tk.WORD)
        self.log_text.pack(fill="both", expand=True)

        self.load_transaction_logs()

    def update_selected_tool(self, event):
        self.selected_tool = self.tool_var.get()

    def trigger_rfid_scan(self):
        if self.pico_serial:
            self.status_message = "Triggered RP2040/RC522 scan..."
            self.update_lcd(self.status_message)
        else:
            self.status_message = "RP2040 serial port not available."

    def handle_rfid_scans(self):
        while True:
            try:
                if self.pico_serial and self.pico_serial.in_waiting > 0:
                    message = self.pico_serial.readline().decode().strip()
                    if message.startswith("RFID:"):
                        self.last_uid = message.split("RFID:")[1]
                        self.status_message = f"Scanned via RP2040/RC522: {self.last_uid}"
                        self.verification_status = "Pending"
                        self.update_lcd(self.status_message)
                        self.process_rfid_scan(self.last_uid)
                time.sleep(0.1)  # Small delay to prevent CPU overload
            except Exception as e:
                self.status_message = f"RFID scan error: {e}"
                self.update_lcd(self.status_message)
                print(f"Error during RFID scan: {e}")
                time.sleep(1)

    def handle_rdr_7081_input_thread(self):
        while True:
            if self.rdr_7081_input and "\n" in self.rdr_7081_input:
                uid = self.rdr_7081_input.strip()
                if uid:
                    self.last_uid = uid
                    self.status_message = f"Scanned via RDR-7081AKU: {self.last_uid}"
                    self.verification_status = "Pending"
                    self.update_lcd(self.status_message)
                    self.process_rfid_scan(self.last_uid)
                self.rdr_7081_input = ""
            time.sleep(0.1)

    def process_rdr_7081_input(self, event):
        """Process keystrokes from RDR-7081AKU card reader"""
        if event.char:  # Only process printable characters
            self.rdr_7081_input += event.char

    def process_rfid_scan(self, uid):
        is_checked_out = self.check_transaction_status(uid, self.selected_tool)
        with self.inventory_lock:
            if is_checked_out:
                self.verification_status = "Valid UID (Return)"
                self.last_action = "CHECKIN"
                self.inventory[self.selected_tool] += 1
                if self.inventory[self.selected_tool] > self.max_inventory[self.selected_tool]:
                    self.inventory[self.selected_tool] = self.max_inventory[self.selected_tool]
                self.log_transaction(self.selected_tool, uid, "CHECKIN")
            else:
                try:
                    with open("transactions.csv", "r") as file:
                        uids = [row[1] for row in csv.reader(file) if len(row) >= 3 and row[2] == "CHECKOUT"]
                    if uid in uids:
                        self.verification_status = "Duplicate UID (Checkout)"
                        self.last_action = "FAILED"
                    else:
                        self.verification_status = "Valid UID (Checkout)"
                        self.last_action = "CHECKOUT"
                        self.inventory[self.selected_tool] -= 1
                        if self.inventory[self.selected_tool] < 0:
                            self.inventory[self.selected_tool] = 0
                        self.log_transaction(self.selected_tool, uid, "CHECKOUT")
                except FileNotFoundError:
                    self.verification_status = "Valid UID (Checkout)"
                    self.last_action = "CHECKOUT"
                    self.inventory[self.selected_tool] -= 1
                    if self.inventory[self.selected_tool] < 0:
                        self.inventory[self.selected_tool] = 0
                    self.log_transaction(self.selected_tool, uid, "CHECKOUT")
        self.update_inventory_display()

    def update_lcd(self, message):
        if self.lcd:  # Check if LCD is initialized
            try:
                self.lcd.clear()
                self.lcd.write_string(message[:16])  # Truncate to 16 characters for 16x2 LCD
            except Exception as e:
                print(f"Error updating LCD: {e}")

    def register_borrower(self):
        borrower_uid = self.borrower_entry.get().strip()
        if not borrower_uid:
            messagebox.showerror("Error", "Please enter a Borrower UID.")
            return

        self.last_uid = borrower_uid
        is_checked_out = self.check_transaction_status(borrower_uid, self.selected_tool)

        with self.inventory_lock:
            if is_checked_out:
                self.verification_status = "Valid UID (Return)"
                self.last_action = "CHECKIN"
                self.inventory[self.selected_tool] += 1
                if self.inventory[self.selected_tool] > self.max_inventory[self.selected_tool]:
                    self.inventory[self.selected_tool] = self.max_inventory[self.selected_tool]
                    messagebox.showwarning("Warning", f"Maximum quantity reached for {self.selected_tool}.")
                self.log_transaction(self.selected_tool, borrower_uid, "CHECKIN")
            else:
                try:
                    with open("transactions.csv", "r") as file:
                        uids = [row[1] for row in csv.reader(file) if len(row) >= 3 and row[2] == "CHECKOUT"]
                    if borrower_uid in uids:
                        self.verification_status = "Duplicate UID (Checkout)"
                        self.last_action = "FAILED"
                        messagebox.showerror("Error", "This UID is already checked out.")
                        return
                except FileNotFoundError:
                    pass
                self.verification_status = "Valid UID (Checkout)"
                self.last_action = "CHECKOUT"
                self.inventory[self.selected_tool] -= 1
                if self.inventory[self.selected_tool] < 0:
                    self.inventory[self.selected_tool] = 0
                    messagebox.showwarning("Warning", "Quantity cannot go below 0.")
                self.log_transaction(self.selected_tool, borrower_uid, "CHECKOUT")

        self.update_inventory_display()
        if self.pico_serial:
            self.pico_serial.write(f"TEXT:{self.last_action} {self.last_uid}\n".encode())
        self.borrower_entry.delete(0, tk.END)

    def update_inventory_display(self):
        self.inventory_tree.delete(*self.inventory_tree.get_children())
        for tool, quantity in self.inventory.items():
            self.inventory_tree.insert("", "end", values=(tool, quantity, "+", "−"))

    def handle_tree_click(self, event):
        item = self.inventory_tree.selection()
        if not item:
            return
        item = item[0]
        column = self.inventory_tree.identify_column(event.x)
        tool = self.inventory_tree.item(item, "values")[0]
        with self.inventory_lock:
            if column == "#3":
                if self.inventory[tool] < self.max_inventory[tool]:
                    self.inventory[tool] += 1
                    self.log_transaction(tool, "Manual", "MANUAL_ADD")
                else:
                    messagebox.showwarning("Warning", f"Maximum quantity reached for {tool}.")
            elif column == "#4" and self.inventory[tool] > 0:
                self.inventory[tool] -= 1
                self.log_transaction(tool, "Manual", "MANUAL_SUBTRACT")
        self.update_inventory_display()

    def load_transaction_logs(self):
        try:
            with open("transactions.csv", "r") as file:
                reader = csv.reader(file)
                logs = list(reader)
                self.log_text.delete(1.0, tk.END)
                if not logs or logs[0] != ["tool", "borrower", "action", "timestamp"]:
                    self.log_text.insert(tk.END, "No transactions yet.\n")
                    return
                logs = logs[1:]
                for log in logs[-10:]:
                    if len(log) >= 4:
                        self.log_text.insert(tk.END, f"{log[3]}: {log[0]} - {log[1]} - {log[2]}\n")
        except FileNotFoundError:
            with open("transactions.csv", "w", newline="") as file:
                writer = csv.writer(file)
                writer.writerow(["tool", "borrower", "action", "timestamp"])
            self.log_text.delete(1.0, tk.END)
            self.log_text.insert(tk.END, "No transactions yet.\n")

    def check_transaction_status(self, borrower, tool):
        try:
            with open("transactions.csv", "r") as file:
                reader = csv.reader(file)
                transactions = list(reader)[1:]
                for transaction in reversed(transactions):
                    if len(transaction) >= 3 and transaction[0] == tool and transaction[1] == borrower:
                        return transaction[2] == "CHECKOUT"
        except FileNotFoundError:
            return False
        return False

    def handle_serial_communication(self):
        while True:
            try:
                if self.serial_port and self.serial_port.in_waiting > 0:
                    message = self.serial_port.readline().decode().strip()
                    if message.startswith("VERIFY:"):
                        uid = message.split(":")[1]
                        is_checked_out = self.check_transaction_status(uid, self.selected_tool)
                        with self.inventory_lock:
                            if is_checked_out:
                                self.verification_status = "Valid UID (Return)"
                                self.serial_port.write("CONFIRM:VALID\n".encode())
                                self.last_action = "CHECKIN"
                                self.inventory[self.selected_tool] += 1
                                if self.inventory[self.selected_tool] > self.max_inventory[self.selected_tool]:
                                    self.inventory[self.selected_tool] = self.max_inventory[self.selected_tool]
                                self.log_transaction(self.selected_tool, uid, "CHECKIN")
                            else:
                                try:
                                    with open("transactions.csv", "r") as file:
                                        rows = list(csv.reader(file))[1:]
                                        uids = [r[1] for r in rows if len(r) >= 3 and r[2] == "CHECKOUT"]
                                    if uid in uids:
                                        self.verification_status = "Duplicate UID (Checkout)"
                                        self.serial_port.write("CONFIRM:INVALID\n".encode())
                                        self.last_action = "FAILED"
                                    else:
                                        self.verification_status = "Valid UID (Checkout)"
                                        self.serial_port.write("CONFIRM:VALID\n".encode())
                                        self.last_action = "CHECKOUT"
                                        self.inventory[self.selected_tool] -= 1
                                        if self.inventory[self.selected_tool] < 0:
                                            self.inventory[self.selected_tool] = 0
                                        self.log_transaction(self.selected_tool, uid, "CHECKOUT")
                                except FileNotFoundError:
                                    self.verification_status = "Valid UID (Checkout)"
                                    self.serial_port.write("CONFIRM:VALID\n".encode())
                                    self.last_action = "CHECKOUT"
                                    self.inventory[self.selected_tool] -= 1
                                    if self.inventory[self.selected_tool] < 0:
                                        self.inventory[self.selected_tool] = 0
                                    self.log_transaction(self.selected_tool, uid, "CHECKOUT")
            except Exception as e:
                self.status_message = f"Serial error: {e}"
                self.update_lcd(self.status_message)
                time.sleep(1)

    def log_transaction(self, tool, borrower, action):
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        with open("transactions.csv", "a", newline="") as file:
            writer = csv.writer(file)
            writer.writerow([tool, borrower, action, timestamp])
        self.load_transaction_logs()

    def update_gui(self):
        self.status_label.config(text=f"Status: {self.status_message}")
        self.uid_label.config(text=f"Last Scanned UID: {self.last_uid}")
        self.verify_label.config(text=f"Verification: {self.verification_status}")
        self.action_label.config(text=f"Last Action: {self.last_action}")
        if self.pico_serial and self.last_uid:
            try:
                self.pico_serial.write(f"TEXT:{self.last_action} {self.last_uid}\n".encode())
            except Exception as e:
                print(f"Error writing to Pico serial: {e}")
        self.root.after(1000, self.update_gui)

    def on_closing(self):
        if self.pico_serial:
            self.pico_serial.close()
        if self.serial_port:
            self.serial_port.close()
        if self.lcd:
            self.lcd.clear()
        self.root.destroy()

if __name__ == "__main__":
    try:
        root = tk.Tk()
        app = InventoryGUI(root)
        root.protocol("WM_DELETE_WINDOW", app.on_closing)
        root.mainloop()
    except KeyboardInterrupt:
        print("\nKeyboardInterrupt received. Shutting down gracefully...")
        if 'app' in locals():
            app.on_closing()

Digital Fabrication: Fabricated 3D-printed PLA enclosure on Solidworks

System Integration: Combined hardware (PCB, enclosure) and software (Python) for a standalone system.

Hardware Design

Microcontroller: Raspberry Pi 3B+ for processing and GUI management.

Input Device: RF Ideas RDR-7081AKU USB RFID reader and RFID-RC522 for redundancy.

Output Device: Tkinter GUI on Raspberry Pi; optional 16x2 I2C LCD for redundancy.

Fabrication

Enclosure: 3D-printed 150x100x50 mm PLA enclosure Solidworks for Raspberry Pi and RDR-7081AKU.

PCB: I Milled PCB for power and I2C connections.

Software Development

Tool and Borrower Registration: Python script on Raspberry Pi reads RFID UIDs, logs borrower IDs, and stores data in CSV (tool_id, borrower_id, timestamp, action).
Tracking Logic:
- Check-out: Scan tool → Scan borrower ID or manual entry → Log “checked out”.
- Display status on Tkinter GUI and optional LCD.
Error Handling: Validates UIDs, alerts via GUI for invalid scans.

Implementation Steps

Step 1: Set Up the Raspberry Pi 3 Environment
- Install Windows Subsystem for Linux to in stall Ubuntu in order to run Pi Os and python applications/li>
- Run Ubuntu to work on raspberry installations
- Install Raspberry Pi 3 Operating System
- Writing to SD CARD
Time: 06:50 AM CAT, May 27, 2025
- Installed LXDE Remote Desktop to host the Raspberry Pi 3 desktop remotely, ensuring keyboard and mouse connectivity.
- Update the system and install Python 3.13.3.
- Install required Python libraries (pyserial for serial communication, keyboard for USB HID input).
- Verify installations to confirm Python version and library presence.
- Duration: ~15-20 minutes.
Step 2: Prepare the Hardware Connections
Time: 07:10 AM CAT, May 27, 2025
- Connect the RDR-7081AKU USB RFID reader to a USB port on the Raspberry Pi 3.
- Connect the RP2040 to the Raspberry Pi 3 via USB (serial port).
- Connection pins Rp2040 to RaspberryPi 3
- Wire the RFID-RC522 to the RP2040 with SPI pins.
- Connect the 16x2 I2C LCD to the Raspberry Pi with I2C pins.
- Test the serial connection to confirm RP2040 detection.
- Test I2C connection
- Duration: ~10-15 minutes.
Step 3: Set Up the CSV File and Initial Data
Time: 07:25 AM CAT, May 27, 2025
- Create a transactions.csv file in the working directory.
- Add header and initial data (e.g., sample tool transactions).
- Create an initial inventory dictionary with sample tools (e.g., Hammer: 5, Screwdriver: 10).
- Duration: ~10 minutes.
Step 4: Write the Tkinter GUI Code
Time: 07:35 AM CAT, May 27, 2025
- Use Visual Studio Code to edit and test the Python Tkinter GUI code, confirming successful display of the GUI.
- Paste the Python Tkinter GUI code into the Raspberry Pi terminal to create or run the inventory tracking script.
- Duration: ~30-40 minutes.

Step 5: Program the RP2040

Time: 08:15 AM CAT, May 27, 2025

Install Micropython on the Raspberry Pi 3 RP2040

Use Thonny to program the RP2040 with sketches for controlling the RFID-RC522.

                                import machine
import time
from mfrc522 import MFRC522

# Pin definitions
SDA = machine.Pin(5, machine.Pin.OUT)
SCK = machine.Pin(2)
MOSI = machine.Pin(3)
MISO = machine.Pin(4)
RST = machine.Pin(6, machine.Pin.OUT)

spi = machine.SPI(0, sck=SCK, mosi=MOSI, miso=MISO, baudrate=1000000)
rdr = MFRC522(sck=2, mosi=3, miso=4, rst=6, cs=5)

def read_uid():
    (stat, tag_type) = rdr.request(rdr.REQIDL)
    if stat == rdr.OK:
        (stat, raw_uid) = rdr.anticoll()
        if stat == rdr.OK:
            uid = ":".join(f"{x:02X}" for x in raw_uid)
            return uid
    return None

print("Ready to scan cards. Bring a tag close...")

while True:
    uid = read_uid()
    if uid:
        print("Detected tag UID:", uid)
        time.sleep(2)  # Pause to avoid double scanning
    else:
        time.sleep(0.1)

MFRC522 code

                            from machine import Pin, SPI
from os import uname


class MFRC522:

    OK = 0
    NOTAGERR = 1
    ERR = 2

    REQIDL = 0x26
    REQALL = 0x52
    AUTHENT1A = 0x60
    AUTHENT1B = 0x61

    def __init__(self, sck, mosi, miso, rst, cs):
        self.sck = Pin(sck, Pin.OUT)
        self.mosi = Pin(mosi, Pin.OUT)
        self.miso = Pin(miso)
        self.rst = Pin(rst, Pin.OUT)
        self.cs = Pin(cs, Pin.OUT)

        self.rst.value(0)
        self.cs.value(1)

        board = uname()[0]

        if board in ('WiPy', 'LoPy', 'FiPy'):
            self.spi = SPI(0)
            self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
        elif board in ('esp8266', 'esp32'):
            self.spi = SPI(1, baudrate=1000000, polarity=0, phase=0,
                           sck=self.sck, mosi=self.mosi, miso=self.miso)
        else:
            # RP2040 and other generic platforms
            self.spi = SPI(0, baudrate=1000000, polarity=0, phase=0,
                           sck=self.sck, mosi=self.mosi, miso=self.miso)

        self.rst.value(1)
        self.init()

    def _wreg(self, reg, val):
        self.cs.value(0)
        self.spi.write(bytes([0x7E & (reg << 1)]))
        self.spi.write(bytes([val]))
        self.cs.value(1)

    def _rreg(self, reg):
        self.cs.value(0)
        self.spi.write(bytes([0x80 | (0x7E & (reg << 1))]))
        val = self.spi.read(1)
        self.cs.value(1)
        return val[0]

    def _sflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) | mask)

    def _cflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) & (~mask))

    def _tocard(self, cmd, send):
        recv = []
        bits = irq_en = wait_irq = n = 0
        stat = self.ERR

        if cmd == 0x0E:
            irq_en = 0x12
            wait_irq = 0x10
        elif cmd == 0x0C:
            irq_en = 0x77
            wait_irq = 0x30

        self._wreg(0x02, irq_en | 0x80)
        self._cflags(0x04, 0x80)
        self._sflags(0x0A, 0x80)
        self._wreg(0x01, 0x00)

        for c in send:
            self._wreg(0x09, c)
        self._wreg(0x01, cmd)

        if cmd == 0x0C:
            self._sflags(0x0D, 0x80)

        i = 2000
        while True:
            n = self._rreg(0x04)
            i -= 1
            if not (i != 0 and not (n & 0x01) and not (n & wait_irq)):
                break

        self._cflags(0x0D, 0x80)

        if i:
            if (self._rreg(0x06) & 0x1B) == 0x00:
                stat = self.OK

                if n & irq_en & 0x01:
                    stat = self.NOTAGERR
                elif cmd == 0x0C:
                    n = self._rreg(0x0A)
                    lbits = self._rreg(0x0C) & 0x07
                    bits = (n - 1) * 8 + lbits if lbits != 0 else n * 8
                    n = max(1, min(n, 16))
                    for _ in range(n):
                        recv.append(self._rreg(0x09))
            else:
                stat = self.ERR

        return stat, recv, bits

    def _crc(self, data):
        self._cflags(0x05, 0x04)
        self._sflags(0x0A, 0x80)

        for c in data:
            self._wreg(0x09, c)

        self._wreg(0x01, 0x03)

        i = 0xFF
        while True:
            n = self._rreg(0x05)
            i -= 1
            if not (i != 0 and not (n & 0x04)):
                break

        return [self._rreg(0x22), self._rreg(0x21)]

    def init(self):
        self.reset()
        self._wreg(0x2A, 0x8D)
        self._wreg(0x2B, 0x3E)
        self._wreg(0x2D, 30)
        self._wreg(0x2C, 0)
        self._wreg(0x15, 0x40)
        self._wreg(0x11, 0x3D)
        self.antenna_on()

    def reset(self):
        self._wreg(0x01, 0x0F)

    def antenna_on(self, on=True):
        if on and ~(self._rreg(0x14) & 0x03):
            self._sflags(0x14, 0x03)
        else:
            self._cflags(0x14, 0x03)

    def request(self, mode):
        self._wreg(0x0D, 0x07)
        (stat, recv, bits) = self._tocard(0x0C, [mode])
        if stat != self.OK or bits != 0x10:
            stat = self.ERR
        return stat, bits

    def anticoll(self):
        ser_chk = 0
        ser = [0x93, 0x20]
        self._wreg(0x0D, 0x00)
        (stat, recv, bits) = self._tocard(0x0C, ser)
        if stat == self.OK and len(recv) == 5:
            for i in range(4):
                ser_chk ^= recv[i]
            if ser_chk != recv[4]:
                stat = self.ERR
        else:
            stat = self.ERR
        return stat, recv

    def select_tag(self, ser):
        buf = [0x93, 0x70] + ser[:5]
        buf += self._crc(buf)
        (stat, recv, bits) = self._tocard(0x0C, buf)
        return self.OK if stat == self.OK and bits == 0x18 else self.ERR

    def auth(self, mode, addr, sect, ser):
        return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]

    def stop_crypto1(self):
        self._cflags(0x08, 0x08)

    def read(self, addr):
        data = [0x30, addr]
        data += self._crc(data)
        (stat, recv, _) = self._tocard(0x0C, data)
        return recv if stat == self.OK else None

    def write(self, addr, data):
        buf = [0xA0, addr] + self._crc([0xA0, addr])
        (stat, recv, bits) = self._tocard(0x0C, buf)
        if not (stat == self.OK and bits == 4 and (recv[0] & 0x0F) == 0x0A):
            return self.ERR

        buf = data[:16] + self._crc(data[:16])
        (stat, recv, bits) = self._tocard(0x0C, buf)
        if not (stat == self.OK and bits == 4 and (recv[0] & 0x0F) == 0x0A):
            return self.ERR

        return self.OK

Verify the RP2040 initializes MFRC and writes ready to scan.

Duration: ~20-30 minutes.

Step 6: Test the Integration
Time: 08:45 AM CAT, May 27, 2025
- Run the Tkinter GUI script
- Scan an RFID tag with the RDR-7081AKU and verify UID display and LCD outputIt works
- Test RFID-RC522 scanning as a fallbackDisplays Triggers RP2040 on LCD but does not scan cards
- Send a manual message via the GUI to test LCD displayNo response
- heck the transactions.csv file for updated entriesAvailable
- Duration: ~20-30 minutes.

Bill of Materials (BOM)

New Components:
- Raspberry Pi, wires ($47.10).
- RFID tags multicolor(20) ~$10.
- PLA filament (~900g) ~$16.99.
- MicroSD card (8 GB) ~$8.98.
- LCD ~$12.99.
- PCB (custom) ~$10.
- Misc (headers, M3 bolts and nuts, M3 self tapping screws) ~$4.
- RDR-7081AKU ($124.99)
Total New Cost: ~$235.05 (The cost is higher because of the RDR-7081AKU).

Timeline (Completed)

Deliverables

Hardware: Custom PCB with Raspberry Pi, RDR-7081AKU, RFID-RC522, and optional LCD.
Fabrication: 3D-printed PLA enclosure (150x100x50 mm), 20 laser-cut acrylic RFID tags.
Software: Python code for RFID scanning, Tkinter GUI, and CSV logging.
Documentation: HTML webpage with schematics, code, photos, and video.
Demo: Video showing tool check-out/check-in with borrower registration.

Questions to be Answered

Will the RDR-7081AKU reliably scan all 20 tags in a busy storeroomLooking at the test it can manage as it doesnt miss a scan
Is the 150x130x92 mm enclosure sufficient for the Raspberry Pi and RDR-7081AKU? In terms of space its sufficient but I need to modify to allow cables to fot in for assembly
Can the optional LCD enhance redundancy without complicating the design?
Still to test as I need to establish why its not scanning
Will the manual entry redundancy handle all edge cases?Yes, its available if all scans fail to scan, the GUI will log transactions on the CSV

Evaluation

Functionality:
- RDR-7081AKU scans and logs transactions correctly (tested with 10 tools, 5 borrowers).
- Manual entry updates inventory and logs transactions.
- GUI reflects real-time changes.
Design Quality:
- Enclosure fits all components with accessible USB ports.
- PCB routes power cleanly, tested with multimeter.
Performance:
- RFID scan speed 2 seconds.
- GUI updates within 2 seconds of actions.
Documentation:
- Submitted schematics (KiCAD), code (Python), 3D/STL files, photos/videos.
- Submit schematics (KiCAD), code (Python), 3D/STL files, photos/videos.
- Files for Download:
  Zip Files for Downloads
  Inventry Management Project files for Download
- I have always wanted a system like this one and FabAcademy has really opened my eyes that such systems can be self made when you have the right tools. I have leart that concepts such as machine learning machine leaning, digital fabrication can all be combined to eqip us to do alomst anything. I have learnt skills in each unit being design, fabrication, electronics, programming, integration, dessemination, interllectual property and income generation.