In this tutorial, I will build a small access control system using a Raspberry Pi Pico and several modules from the Elecrow Raspberry Pi Pico Advanced Kit. The system can read an RFID card, accept a PIN from a keypad, show messages on an LCD, control a solenoid lock through a relay, and respond to fire and tamper alarm inputs.

This is not meant to replace a real commercial access control panel, but it is a very good learning project if you want to understand how access control logic works at the microcontroller level.

Project Overview

The Raspberry Pi Pico will act as the main controller. It will accept access requests from two sources:

1. An RFID card scanned through the RC522 RFID module
2. A PIN entered through a membrane keypad

If the card UID or PIN is valid, the Pico activates a relay driver. The relay then powers a solenoid lock for a few seconds to simulate unlocking a door.

The system also monitors two alarm inputs:

1. Fire alarm input
2. Tamper alarm input

When the fire alarm is triggered, the door is released and the buzzer sounds. This simulates a real access control system where doors may be released during emergency conditions.

When the tamper alarm is triggered, the system keeps the door locked and sounds the buzzer. This simulates someone trying to force open or tamper with the door or panel.

About the Elecrow Raspberry Pi Pico Advanced Kit

For this project, I used modules from the Elecrow Raspberry Pi Pico Advanced Kit. The kit includes a Raspberry Pi Pico, breadboards, LEDs, an RGB module, sound sensor, PIR motion sensor, photoresistor module, passive buzzer, vibration sensor, magnetic spring module, soil moisture sensor, potentiometer, servo, joystick, RC522 RFID module, 4-digit display, traffic light module, rotary encoder, 1602 LCD, temperature and humidity sensor, raindrops module, flame sensor, OLED module, membrane keypad, smart car parts, ultrasonic sensor, infrared remote, and several other accessories.

For this access control project, I will use the parts that make sense for a small door controller:

• Raspberry Pi Pico
• RC522 RFID module
• Membrane keypad
• 1602 LCD module
•  Passive buzzer
• LEDs (traffic light module)
• Flame sensor or button for fire alarm simulation
• Vibration sensor for tamper detection

I will also use an external solenoid lock and relay driver. These are not driven directly by the Pico because a solenoid needs more current than a GPIO pin can provide.

How the System Works

Here is the basic block diagram of the project:

The Pico continuously checks the system inputs. In normal standby mode, the LCD asks the user to scan a card or enter a PIN.

If access is granted, the relay turns on and the solenoid unlocks for a short time. If access is denied, the buzzer gives an error sound and the red LED turns on.

The fire alarm and tamper alarm have higher priority than normal card or PIN access.

Features of This Project

This project includes the following features:

• RFID card access using the RC522 module
• PIN access using a membrane keypad
• LCD status messages
• Solenoid lock control using a relay driver
• Buzzer feedback
• LED status indicators
• Fire alarm input
• Tamper alarm input
• Optional door contact monitoring
• MicroPython code for beginners

Required Components

Most of the components used in this project are included in the Elecrow Raspberry Pi Pico Advanced Kit. I also added a solenoid lock and relay driver to make the project closer to a real access control setup.

You can also use a servo motor instead of a solenoid lock if you want a safer beginner version of the project. However, using a relay and solenoid makes the project feel closer to a real access control system.

Important Safety Note About Solenoid Locks

The Raspberry Pi Pico cannot directly drive a solenoid lock. A solenoid usually requires more voltage and current than a Pico GPIO pin can provide.

The correct setup is:

Pico GPIO → Relay Driver Input → Relay Contact → Solenoid Power

The Pico only controls the relay input. The solenoid must have its own power supply.

Also, make sure the Pico ground and relay module ground are connected together, unless you are using a fully isolated relay module.

If your relay board or solenoid driver does not already include flyback protection, you should add a diode across the solenoid coil to protect the circuit from voltage spikes.

For a real door access system, use proper certified hardware. This tutorial is only for learning and prototyping.

Pin Connections

The exact pins can be changed in the code, but I will use this pin assignment for the tutorial.

RC522 RFID Module to Raspberry Pi Pico

The RC522 uses SPI communication.

Do not connect the RC522 to 5V. The RC522 module works with 3.3V logic.

I2C LCD to Raspberry Pi Pico

This tutorial assumes that the 1602 LCD has an I2C backpack.

Most I2C LCD backpacks work at 5V, but the I2C pull-ups may also pull SDA and SCL to 5V. Many hobby modules work in practice, but the safer method is to use a level shifter or power the backpack in a way that keeps the I2C lines at 3.3V.

If your LCD has 16 pins instead of 4 pins, then it is probably a parallel LCD and will need different wiring and a different library.

Keypad to Raspberry Pi Pico

For a 4x4 membrane keypad:

If you are using a 4x3 keypad, you can modify the keypad map and remove one column.

Relay Driver and Solenoid Lock

The solenoid is connected through the relay contacts, not directly to the Pico.

A simple wiring idea is:

Solenoid Power +  → Relay COM
Relay NO          → Solenoid +
Solenoid -        → Solenoid Power -

When the relay turns on, the solenoid receives power and unlocks.

Some relay modules are active-low. This means the relay turns on when the Pico output is LOW instead of HIGH. I will make this configurable in the code.

Buzzer and LEDs

Use current-limiting resistors for the LEDs.

Alarm Inputs

For beginner testing, I recommend using push buttons first. Once the logic works, you can replace the buttons with the flame sensor and tamper sensor.

This is my setup on a breadboard. I didn't use the relay + solenoid lock yet; the red LED on the middle of the breadboard will serve as the indicator that the lock released or not.

Installing MicroPython on the Raspberry Pi Pico

Before uploading the code, install MicroPython on the Raspberry Pi Pico. You can download the latest UF2 file in the official MicroPython website.

1. Hold the BOOTSEL button on the Pico.
2. Connect the Pico to your computer using a USB cable.
3. Release the BOOTSEL button.
4. The Pico should appear as a USB drive.
5. Copy the MicroPython UF2 file to the Pico.
6. Open Thonny.
7. Select the MicroPython interpreter for Raspberry Pi Pico.

Once this is done, you can run MicroPython code on the Pico using Thonny.

Required MicroPython Libraries

This project needs libraries for:

• RC522 RFID module
• I2C LCD

For the RC522, you need a file named:

mfrc522.py

For the I2C LCD, you need files such as:

lcd_api.py
pico_i2c_lcd.py

You can find the mfrc522.py in this library, while the I2C LCD files are in this library.

Upload these files to the Raspberry Pi Pico using Thonny. You can place them directly on the Pico or inside a /lib folder.

Testing the RFID Reader First

Before combining all parts, it is better to test the RFID reader alone. This helps you get the UID of your RFID card.

A card UID may look something like this:

12 AB 34 CD

You will later place this UID inside the list of authorized cards.

In the final code, the authorized cards are stored here:

AUTHORIZED_CARDS = [
    z">"12 AB 34 CD",
    z">"A1 B2 C3 D4"
]

Replace these values with your actual card UID.

System Behavior

The system has several operating conditions.

Idle Mode

In idle mode, the LCD shows:

PICO ACCESS
SCAN CARD/PIN

The system waits for an RFID card or keypad input.

Access Granted

If the card or PIN is valid:

ACCESS GRANTED
DOOR UNLOCKED

The green LED turns on, the buzzer gives a short beep, and the relay unlocks the solenoid for a few seconds.

Access Denied

If the card or PIN is invalid:

ACCESS DENIED
TRY AGAIN

The red LED turns on and the buzzer gives an error sound.

Fire Alarm

If the fire alarm input is triggered:

FIRE ALARM!
DOOR RELEASED

The door unlocks and the buzzer sounds repeatedly.

This is done because many access control systems release doors during emergency conditions. Again, this project is only a simulation.

Tamper Alarm

If the tamper input is triggered:

TAMPER ALARM!
SYSTEM LOCKED

The system sounds the buzzer and flashes the red LED. The door remains locked.

Event Priority

The Pico should not treat all events equally. Alarm inputs should have higher priority than normal access requests.

For this project, I use this priority:

Fire alarm has the highest priority because it is a safety-related condition.

Final MicroPython Code

Upload the required libraries first, then save the following code as

main.py

on the Raspberry Pi Pico.

This code assumes:

• RC522 uses SPI0
• LCD uses I2C0
• Keypad is 4x4
• Relay output is active-high by default
• Fire and tamper inputs are active-low using pull-up resistors

If your relay module is active-low, change:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

Here is the complete code:

from machine import Pin, PWM, I2C, SPI
from time import sleep, ticks_ms, ticks_diff

# ------------------------------------------------------------
# Optional libraries
# ------------------------------------------------------------
# These imports depend on the library files you uploaded.
# If your library uses different class names, adjust these lines.

try:
    from mfrc522 import MFRC522
except ImportError:
    MFRC522 = None

try:
    from pico_i2c_lcd import I2cLcd
except ImportError:
    I2cLcd = None


# ------------------------------------------------------------
# User settings
# ------------------------------------------------------------

AUTHORIZED_CARDS = [
    "C3 A4 13 29",
    "12 AB 34 CD",
    "A1 B2 C3 D4"
]

AUTHORIZED_PIN = "1234"

ALARM_CHECK_INTERVAL_SECONDS = 5
UNLOCK_TIME_SECONDS = 3

RELAY_ACTIVE_HIGH = True

LCD_I2C_ADDR = 0x27
LCD_ROWS = 2
LCD_COLS = 16


# ------------------------------------------------------------
# Pin assignments
# ------------------------------------------------------------

# RFID RC522 SPI pins
RFID_SCK_PIN = 18
RFID_MOSI_PIN = 19
RFID_MISO_PIN = 16
RFID_CS_PIN = 17
RFID_RST_PIN = 20

# LCD I2C pins
LCD_SDA_PIN = 4
LCD_SCL_PIN = 5

# Keypad pins
ROW_PINS = [6, 7, 8, 9]
COL_PINS = [10, 11, 12, 13]

# Outputs
RELAY_PIN = 14
BUZZER_PIN = 15
GREEN_LED_PIN = 21
RED_LED_PIN = 22
YELLOW_LED_PIN = 26

# Inputs
FIRE_INPUT_PIN = 27
TAMPER_INPUT_PIN = 28
DOOR_CONTACT_PIN = 2


# ------------------------------------------------------------
# Hardware setup
# ------------------------------------------------------------

green_led = Pin(GREEN_LED_PIN, Pin.OUT)
red_led = Pin(RED_LED_PIN, Pin.OUT)
yellow_led = Pin(YELLOW_LED_PIN, Pin.OUT)

relay = Pin(RELAY_PIN, Pin.OUT)

buzzer = PWM(Pin(BUZZER_PIN))
buzzer.duty_u16(0)

fire_input = Pin(FIRE_INPUT_PIN, Pin.IN, Pin.PULL_UP)
tamper_input = Pin(TAMPER_INPUT_PIN, Pin.IN, Pin.PULL_UP)
door_contact = Pin(DOOR_CONTACT_PIN, Pin.IN, Pin.PULL_UP)

row_pins = [Pin(pin, Pin.OUT) for pin in ROW_PINS]
col_pins = [Pin(pin, Pin.IN, Pin.PULL_UP) for pin in COL_PINS]

key_map = [
    ["1", "2", "3", "A"],
    ["4", "5", "6", "B"],
    ["7", "8", "9", "C"],
    ["*", "0", "#", "D"]
]

# LCD setup
lcd = None

if I2cLcd is not None:
    try:
        i2c = I2C(0, sda=Pin(LCD_SDA_PIN), scl=Pin(LCD_SCL_PIN), freq=400000)
        lcd = I2cLcd(i2c, LCD_I2C_ADDR, LCD_ROWS, LCD_COLS)
    except Exception as e:
        print("LCD init failed:", e)
        lcd = None
else:
    print("LCD library not found. LCD output disabled.")

# RFID setup
rfid = None

if MFRC522 is not None:
    try:
        # This constructor may be different depending on your mfrc522.py library.
        # Some libraries use:
        # rfid = MFRC522(spi_id=0, sck=18, miso=16, mosi=19, cs=17, rst=20)
        #
        # If this line fails, check the documentation of your RC522 library.
        rfid = MFRC522(
            spi_id=0,
            sck=RFID_SCK_PIN,
            miso=RFID_MISO_PIN,
            mosi=RFID_MOSI_PIN,
            cs=RFID_CS_PIN,
            rst=RFID_RST_PIN
        )
    except Exception as e:
        print("RFID init failed:", e)
        rfid = None
else:
    print("MFRC522 library not found. RFID disabled.")


# ------------------------------------------------------------
# Helper functions
# ------------------------------------------------------------

def set_relay(active):
    if RELAY_ACTIVE_HIGH:
        relay.value(1 if active else 0)
    else:
        relay.value(0 if active else 1)


def lock_door():
    set_relay(False)


def unlock_door():
    set_relay(True)


def all_leds_off():
    green_led.off()
    red_led.off()
    yellow_led.off()

def pad_lcd_text(text, width=16):
    text = str(text)[:width]

    while len(text) < width:
        text += " "

    return text

last_lcd_line1 = None
last_lcd_line2 = None

def lcd_message(line1, line2=""):
    global last_lcd_line1, last_lcd_line2

    line1 = str(line1)[:16]
    line2 = str(line2)[:16]

    # Do not refresh the LCD if the message did not change
    if line1 == last_lcd_line1 and line2 == last_lcd_line2:
        return

    print(line1, line2)

    last_lcd_line1 = line1
    last_lcd_line2 = line2

    if lcd is None:
        return

    lcd.move_to(0, 0)
    lcd.putstr(pad_lcd_text(line1, 16))

    lcd.move_to(0, 1)
    lcd.putstr(pad_lcd_text(line2, 16))


def beep(freq=2000, duration=0.1):
    buzzer.freq(freq)
    buzzer.duty_u16(30000)
    sleep(duration)
    buzzer.duty_u16(0)


def beep_success():
    beep(1800, 0.08)
    sleep(0.05)
    beep(2200, 0.08)


def beep_error():
    for _ in range(3):
        beep(600, 0.12)
        sleep(0.08)


def beep_alarm():
    beep(1200, 0.15)
    sleep(0.08)


def is_fire_alarm_active():
    # Active-low input
    return fire_input.value() == 0


def is_tamper_active():
    # Active-low input
    return tamper_input.value() == 0


def is_door_open():
    # This depends on your magnetic switch module.
    # For this example, LOW means door open.
    return door_contact.value() == 0


# ------------------------------------------------------------
# Keypad functions
# ------------------------------------------------------------

def scan_keypad():
    for row_index, row in enumerate(row_pins):
        for r in row_pins:
            r.value(1)

        row.value(0)

        for col_index, col in enumerate(col_pins):
            if col.value() == 0:
                sleep(0.05)  # debounce

                if col.value() == 0:
                    key = key_map[row_index][col_index]

                    while col.value() == 0:
                        sleep(0.01)

                    return key

    return None


# ------------------------------------------------------------
# RFID functions
# ------------------------------------------------------------

def uid_to_string(uid):
    return " ".join("{:02X}".format(byte) for byte in uid)


def read_rfid_card():
    if rfid is None:
        return None

    try:
        (stat, tag_type) = rfid.request(rfid.REQIDL)

        if stat == rfid.OK:
            (stat, uid) = rfid.SelectTagSN()

            if stat == rfid.OK:
                return uid_to_string(uid)

    except Exception as e:
        print("RFID read error:", e)

    return None


# ------------------------------------------------------------
# Access control actions
# ------------------------------------------------------------

def grant_access(source):
    all_leds_off()
    green_led.on()

    lcd_message("ACCESS GRANTED", source)
    beep_success()

    unlock_door()
    sleep(UNLOCK_TIME_SECONDS)
    lock_door()

    green_led.off()
    lcd_message("DOOR LOCKED", "SCAN CARD/PIN")
    sleep(1)


def deny_access(reason):
    all_leds_off()
    red_led.on()

    lcd_message("ACCESS DENIED", reason)
    beep_error()

    red_led.off()
    sleep(1)

def sound_alarm_cycle(duration_seconds, fire_mode=False):
    start_time = ticks_ms()

    while ticks_diff(ticks_ms(), start_time) < duration_seconds * 1000:
        if fire_mode:
            red_led.toggle()
            yellow_led.toggle()
        else:
            red_led.toggle()
            yellow_led.off()

        beep_alarm()
        sleep(0.2)

    buzzer.duty_u16(0)

def handle_fire_alarm():
    all_leds_off()

    lcd_message("FIRE ALARM!", "DOOR RELEASED")
    unlock_door()

    while True:
        sound_alarm_cycle(ALARM_CHECK_INTERVAL_SECONDS, fire_mode=True)

        if not is_fire_alarm_active():
            break

        lcd_message("FIRE ALARM!", "STILL ACTIVE")

    all_leds_off()
    lock_door()
    lcd_message("FIRE CLEARED", "DOOR LOCKED")
    sleep(1)


def handle_tamper_alarm():
    all_leds_off()

    lcd_message("TAMPER ALARM!", "SYSTEM LOCKED")
    lock_door()

    while True:
        sound_alarm_cycle(ALARM_CHECK_INTERVAL_SECONDS, fire_mode=False)

        if not is_tamper_active():
            break

        lcd_message("TAMPER ALARM!", "STILL ACTIVE")

    all_leds_off()
    lcd_message("TAMPER CLEARED", "SCAN CARD/PIN")
    sleep(1)


def handle_forced_door():
    all_leds_off()
    red_led.on()

    lcd_message("DOOR FORCED!", "ALARM ACTIVE")
    lock_door()

    # Sound alarm for a few seconds
    start_time = ticks_ms()

    while ticks_diff(ticks_ms(), start_time) < 5000:
        red_led.toggle()
        beep_alarm()
        sleep(0.2)

    all_leds_off()
    lcd_message("SCAN CARD/PIN", "")
    sleep(1)


# ------------------------------------------------------------
# Main program
# ------------------------------------------------------------

def main():
    entered_pin = ""
    last_idle_update = 0

    lock_door()
    all_leds_off()

    lcd_message("PICO ACCESS", "SCAN CARD/PIN")
    yellow_led.on()

    door_was_unlocked_by_system = False

    while True:
        # Highest priority: fire alarm
        if is_fire_alarm_active():
            handle_fire_alarm()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # Second priority: tamper alarm
        if is_tamper_active():
            handle_tamper_alarm()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # Optional forced door detection
        # This is basic logic only. A real system needs better door timing rules.
        if is_door_open() and not door_was_unlocked_by_system:
            handle_forced_door()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # RFID access
        uid = read_rfid_card()

        if uid is not None:
            print("Card UID:", uid)

            if uid in AUTHORIZED_CARDS:
                yellow_led.off()
                door_was_unlocked_by_system = True
                grant_access("RFID CARD")
                door_was_unlocked_by_system = False
            else:
                yellow_led.off()
                deny_access("INVALID CARD")

            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            entered_pin = ""
            sleep(0.5)
            continue

        # Keypad access
        key = scan_keypad()

        if key is not None:
            print("Key:", key)

            if key == "*":
                entered_pin = ""
                lcd_message("ENTER PIN:", "")
                beep(1200, 0.05)

            elif key == "#":
                if entered_pin == AUTHORIZED_PIN:
                    yellow_led.off()
                    door_was_unlocked_by_system = True
                    grant_access("PIN ENTRY")
                    door_was_unlocked_by_system = False
                else:
                    yellow_led.off()
                    deny_access("WRONG PIN")

                entered_pin = ""
                lcd_message("PICO ACCESS", "SCAN CARD/PIN")
                yellow_led.on()

            elif key in "0123456789":
                if len(entered_pin) < 8: entered_pin += key lcd_message("ENTER PIN:", "*" * len(entered_pin)) beep(1500, 0.04) # Refresh idle display occasionally if ticks_diff(ticks_ms(), last_idle_update) > 3000 and entered_pin == "":
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            last_idle_update = ticks_ms()

        sleep(0.05)


main()

How the Code Works

The code starts by defining the authorized cards and PIN:

AUTHORIZED_CARDS = [
    "12 AB 34 CD",
    "A1 B2 C3 D4"
]

AUTHORIZED_PIN = "1234"

You need to replace the sample RFID UIDs with the actual UIDs of your cards.

The system also defines how long the door will unlock:

UNLOCK_TIME_SECONDS = 3

This means that when access is granted, the solenoid is released for 3 seconds.

There is also another delay for when the fire alarm or tamper alarm is triggered:

ALARM_CHECK_INTERVAL_SECONDS = 5

This means that the buzzer will stay in alarm mode for 5 seconds before checking the states of the sensor again.

Relay Control

The relay is controlled by this function:

def set_relay(active):
    if RELAY_ACTIVE_HIGH:
        relay.value(1 if active else 0)
    else:
        relay.value(0 if active else 1)

This is useful because some relay modules turn on when the input pin is HIGH, while others turn on when the input pin is LOW.

If your relay works backward, simply change this line:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

LCD Messages

The function below prints messages to both the LCD and the Thonny shell:

def lcd_message(line1, line2=z">""):
    print(line1, line2)

    if lcd is None:
        return

    lcd.clear()
    lcd.move_to(0, 0)
    lcd.putstr(line1[:16])

    lcd.move_to(0, 1)
    lcd.putstr(line2[:16])

The

[:16]

part makes sure that the message fits on a 16-column LCD.

Reading the Keypad

The keypad is scanned row by row. Each row is pulled LOW one at a time, and the Pico checks which column also becomes LOW.

def scan_keypad():
    for row_index, row in enumerate(row_pins):
        for r in row_pins:
            r.value(1)

        row.value(0)

        for col_index, col in enumerate(col_pins):
            if col.value() == 0:
                sleep(0.05)

                if col.value() == 0:
                    key = key_map[row_index][col_index]

                    while col.value() == 0:
                        sleep(0.01)

                    return key

    return None

The small delay is used for basic button debounce.

RFID Access Logic

The RFID function returns the UID of a scanned card:

uid = read_rfid_card()

Then the main loop checks whether the UID is in the list of authorized cards:

if uid in AUTHORIZED_CARDS:
    grant_access("RFID CARD")
else:
    deny_access("INVALID CARD")

This is the simplest way to handle RFID authorization in a beginner project.

PIN Access Logic

The keypad allows the user to enter a PIN. The

*

key clears the input, while the

#

key submits it.

if key == "*":
    entered_pin = ""

elif key == "#":
    if entered_pin == AUTHORIZED_PIN:
        grant_access("PIN ENTRY")
    else:
        deny_access("WRONG PIN")

This is similar to how many keypad-based access systems work.

Fire Alarm Logic

The fire alarm input has the highest priority. If it is active, the system immediately runs this function:

handle_fire_alarm()

Inside that function, the door is unlocked:

unlock_door()

Then the buzzer and LEDs continue until the fire alarm input clears.

This behavior simulates an emergency door release.

Tamper Alarm Logic

The tamper alarm works differently from the fire alarm. When tamper is detected, the system keeps the door locked:

lock_door()

Then it sounds the buzzer and flashes the red LED.

This simulates a forced access or panel tamper condition.

Door Contact Logic

The optional door contact can detect if the door was opened without a valid unlock command.

In this tutorial, the logic is simplified:

if is_door_open() and not door_was_unlocked_by_system:
    handle_forced_door()

In a real access control system, this part would usually include a delay timer. For example, after access is granted, the door is allowed to open for a few seconds. If it stays open too long, the controller may trigger a “door held open” alarm.

You can add this as an advanced improvement.

Video

Here's the project in action:

Again, I didn't include the relay and solenoid lock for this video. The red LED lighting up means the door is unlocked. Replacing the red LED with the relay module and solenoid lock combination opens the lock when the LED is on.

Testing the Project

Test the project in stages. Do not connect everything at once.

Step 1: Test the LCD

Upload a simple LCD test first and confirm that the LCD can display text.

Step 2: Test the Keypad

Print each key to the Thonny shell. Make sure every key is detected correctly.

Step 3: Test the RFID Reader

Scan your card and copy the UID from the shell.

Then place the UID inside:

AUTHORIZED_CARDS = [
    "YOUR CARD UID HERE"
]

Step 4: Test the Relay Without the Solenoid

Before connecting the solenoid, test the relay with only the relay module connected. You should hear the relay click when access is granted.

Step 5: Test the Solenoid Lock

Once the relay works, connect the solenoid to its external power supply through the relay contacts.

Do not power the solenoid from the Pico.

Step 6: Test Fire and Tamper Inputs

Use push buttons first. Once the logic works, replace the buttons with the flame sensor, magnetic sensor, or vibration sensor.

RFID Reader Not Detected

Check the SPI wiring carefully. The most common mistake is swapping MOSI and MISO.

Also make sure the RC522 is powered from 3.3V, not 5V.

LCD Shows Nothing

Try adjusting the contrast potentiometer on the I2C backpack.

If the LCD still does not work, scan for the I2C address. Some LCD backpacks use 0x27, while others use 0x3F.

Change this line if needed:

LCD_I2C_ADDR = 0x27

Relay Works Backward

Change:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

Buzzer Is Too Weak

The passive buzzer may need a transistor driver if you want it to be louder. For simple breadboard testing, direct GPIO control is usually enough.

Solenoid Resets the Pico

This usually means the solenoid is causing voltage drops or electrical noise.

Use a separate power supply for the solenoid, connect grounds properly, and add flyback protection if needed.

Improving the Project

There are many ways to improve this project.

You can add an enrollment mode where an admin card allows new cards to be registered. You can also save authorized cards in the Pico’s flash memory so they are not hardcoded in the program.

Another useful improvement is event logging. The Pico can record events such as:

ACCESS GRANTED - RFID
ACCESS DENIED - INVALID CARD
ACCESS GRANTED - PIN
FIRE ALARM
TAMPER ALARM
DOOR FORCED

If you use a Raspberry Pi Pico W instead of a regular Pico, you can add a simple web dashboard. This dashboard can show the latest access events and alarm status.

You can also add a real-time clock module to timestamp each event.

Final Thoughts

This Raspberry Pi Pico access control project combines several important embedded system concepts into one practical build. It uses SPI for RFID, GPIO scanning for the keypad, I2C for the LCD, PWM for the buzzer, and digital outputs for the relay and LEDs.

The best part is that the project behaves like a small version of a real access control controller. It accepts credentials, controls a lock, displays status messages, and responds to alarm inputs.

For beginners, MicroPython makes the project easier to understand because the code is readable and the system logic is clear. For a production access control device, I would normally use C or C++ for better structure, timing, and reliability. But for learning how the system works, MicroPython is a very good starting point.

The nice thing about using a kit like the Elecrow Raspberry Pi Pico Advanced Kit is that the project can be expanded easily. After getting the RFID and keypad access working, you can add more modules from the same kit, such as the OLED display, PIR motion sensor, vibration sensor, magnetic spring module, infrared receiver, or ultrasonic sensor.

This makes the project more than just a one-time RFID door lock demo. It becomes a small platform for learning how real embedded control systems handle inputs, outputs, alarms, and user feedback.

The post Raspberry Pi Pico Access Control System Using the Elecrow Pico Advanced Kit appeared first on Teach Me Microcontrollers!.

This tutorial will walk you through the hardware setup, coding the Raspberry Pi Pico to detect proximity, and integrating the proximity sensor data into a Windows app.

Components Required

1. Raspberry Pi Pico
2. HC-SR04 Ultrasonic Sensor (or any other proximity sensor)
3. Breadboard and Jumper Wires
4. USB Cable (for connecting Raspberry Pi Pico to your computer)
5. Windows PC with Visual Studio (for C# app development)

Wiring the Raspberry Pi Pico and the Proximity Sensor

We will use the HC-SR04 sensor to detect a person's presence. The sensor has four pins: VCC, GND, TRIG, and ECHO.

Wiring:

• VCC to Raspberry Pi Pico's 3.3V pin
• GND to Raspberry Pi Pico's GND pin
• TRIG to GPIO 15
• ECHO to GPIO 14

This setup allows the Pico to receive distance measurements from the sensor.

Programming the Raspberry Pi Pico

MicroPython Code for Proximity Detection

We will use MicroPython to program the Raspberry Pi Pico. The code will continuously check the distance from the sensor and send the proximity data over a serial connection to the Windows PC.

Install MicroPython on the Pico by following the official guide, then use Thonny IDE for programming.

from machine import Pin, time_pulse_us
import utime

# Initialize pins for sensor
trig = Pin(15, Pin.OUT)
echo = Pin(14, Pin.IN)

def measure_distance():
    # Send pulse
    trig.low()
    utime.sleep_us(2)
    trig.high()
    utime.sleep_us(10)
    trig.low()

    # Measure response time
    pulse_time = time_pulse_us(echo, 1)
    distance_cm = (pulse_time / 2) / 29.1 # Speed of sound = 29.1 us/cm
    return distance_cm

while True:
    distance = measure_distance()
    print(distance)
    utime.sleep(1)

This code calculates the distance using the ultrasonic sensor and prints the value over the serial interface.

Flashing the Code

1. Save the above code as main.py in Thonny IDE.
2. Connect the Raspberry Pi Pico to your computer via USB.
3. Run the script. You should see distance readings in the Thonny IDE’s console.

Creating the C# Application

Now that the Pico is sending distance data, we will create a C# application that listens to the serial port and responds by switching tabs or hiding apps when a person is detected.

Setting Up the C# Application

1. Open Visual Studio and create a new Windows Forms App (or WPF if preferred).
2. Add the following NuGet packages:
   • System.IO.Ports for handling serial communication

C# Code to Listen for Sensor Data

Here's the basic C# code that connects to the Pico via the serial port and changes tabs or minimizes applications based on the proximity data.

using System;
using System.IO.Ports;
using System.Runtime.InteropServices;
using System.Diagnostics;

class Program
{
    private static SerialPort _serialPort;

    // Import the necessary WinAPI functions
    [DllImport("user32.dll")]
    static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

    [DllImport("user32.dll")]
    static extern bool SetForegroundWindow(IntPtr hWnd);

    [DllImport("user32.dll")]
    static extern IntPtr GetForegroundWindow();

    [DllImport("user32.dll")]
    static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);

    // Constants for showing or hiding the window
    const int SW_HIDE = 0;
    const int SW_SHOW = 5;

    static void Main(string[] args)
    {
        Console.WriteLine("Starting the serial port listener...");

        // Configure SerialPort
        _serialPort = new SerialPort("COM3", 9600);
        _serialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
        _serialPort.Open();

        Console.WriteLine("Listening for data on COM3... Press any key to exit.");
        Console.ReadKey();

        //Close serial port before exiting
        if (_serialPort.IsOpen)
        {
            _serialPort.Close();
        }
    }

    private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
    {
        string data = _serialPort.ReadLine();
        if (double.TryParse(data, out double distance))
        {
            Console.WriteLine($"Distance received: {distance} cm");

            // If person is detected (e.g., distance less than 50 cm)
            if (distance < 50) { // Switch to the next window or minimize the current console SwitchTabsOrMinimize(); } } } private static void SwitchTabsOrMinimize() { IntPtr currentForegroundWindow = GetForegroundWindow(); // Get the title of the current window const int nChars = 256; System.Text.StringBuilder windowTitle = new System.Text.StringBuilder(nChars); GetWindowText(currentForegroundWindow, windowTitle, nChars); // Check if there is a current window by inspecting the length of the window title if (windowTitle.ToString().Length > 0)
        {
            // Hide the window
            ShowWindow(currentForegroundWindow, SW_HIDE);
            Console.WriteLine("Window is hidden.");

            // Find the next window to bring to the foreground
            IntPtr nextWindowHandle = GetNextWindowInTaskList();

            if (nextWindowHandle != IntPtr.Zero)
            {
                // Bring the next window to the foreground
                SetForegroundWindow(nextWindowHandle);
                Console.WriteLine("Switched to another application.");
            }
            else
            {
                Console.WriteLine("No other window found to switch to.");
            }
        }
        else
        {
            Console.WriteLine("The active window is not Chrome.");
        }
    }

    private static IntPtr GetNextWindowInTaskList()
    {
        IntPtr nextWindowHandle = IntPtr.Zero;

        // Simulate pressing Alt+Tab by finding the next process with a window
        Process[] processes = Process.GetProcesses();
        foreach (var process in processes)
        {
            if (process.MainWindowHandle != IntPtr.Zero && process.MainWindowHandle != GetForegroundWindow())
            {
                nextWindowHandle = process.MainWindowHandle;
                break;
            }
        }

        return nextWindowHandle;
    }
}

Explanation of Code

• The SerialPort is set up to listen on the COM port connected to the Pico.
• When data (the distance) is received from the Pico, the application checks if the value is below a threshold (e.g., 50 cm) to determine if someone is near the sensor.
• If a person is detected, the application switches tabs in a TabControl. If the last tab is reached, the app minimizes.

Running the C# Application

1. Compile and run the C# application in Visual Studio.
2. Place your hand near the sensor and observe the tabs switching or the application minimizing.

To use the Raspberry Pi Pico with C++ (Arduino), we need to install the Arduino core for the Pico, configure the sensor, and write the code in the Arduino IDE. Here's the conversion of the original MicroPython code to C++ using the Arduino framework.

Setting Up Arduino IDE for Raspberry Pi Pico

Before we write the C++ code, make sure the Raspberry Pi Pico is ready for Arduino development. Follow these steps:

1. Open the Arduino IDE.
2. Go to File > Preferences, and in the "Additional Boards Manager URLs" field, add:
   https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

3. Go to Tools > Board > Boards Manager, search for  Raspberry Pi Pico, and install the package by Earle Philhower.

After this, you'll be able to select the Raspberry Pi Pico as a board from Tools > Board > Raspberry Pi RP2040 > Raspberry Pi Pico.

 C++ Code for Proximity Detection

Here’s the Arduino C++ code for the Raspberry Pi Pico using an HC-SR04 ultrasonic sensor. This code will measure the distance and send the data over the serial port to the Windows PC.

#define TRIG_PIN 15  // GPIO 15 for Trigger
#define ECHO_PIN 14  // GPIO 14 for Echo

void setup() {
  Serial.begin(9600); // Initialize serial communication
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  long duration, distance_cm;

  // Clear the TRIG_PIN by setting it LOW
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);

  // Trigger the sensor by setting TRIG_PIN HIGH for 10 microseconds
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // Read the ECHO_PIN, returns the sound wave travel time in microseconds
  duration = pulseIn(ECHO_PIN, HIGH);

  // Calculate the distance in cm (Speed of sound = 343 m/s or 29.1 us/cm)
  distance_cm = (duration / 2) / 29.1;

  // Send the distance data over Serial to the PC
  Serial.println(distance_cm);

  // Delay for a bit before the next measurement
  delay(1000);
}

Explanation of the Code:

• TRIG_PIN is set to GPIO 15, and ECHO_PIN is set to GPIO 14. These pins connect to the sensor's TRIG and ECHO respectively.
• In the setup() the TRIG_PIN is set to OUTPUT and the ECHO_PIN to INPUT.
• The loop() function:
  • Sends a 10 microsecond pulse to the TRIG pin to trigger the sensor.
  • Uses pulseIn() to measure the time it takes for the echo to return.
  • The distance is calculated by dividing the duration by 2 (since the sound wave travels to the object and back) and dividing by 29.1 (speed of sound in microseconds per centimeter).
  • The calculated distance is printed via Serial.println() to send the data to the connected Windows PC.

Uploading the Code

1. In the Arduino IDE, select Tools > Board > Raspberry Pi RP2040 > Raspberry Pi Pico.
2. Select the correct COM port under Tools > Port.
3. Upload the code to the Raspberry Pi Pico by pressing the Upload button.

Testing the Proximity Detection

Once the code is uploaded, open the Serial Monitor in the Arduino IDE (Ctrl+Shift+M). Place an object in front of the sensor, and you should see the distance readings being displayed.

These readings can now be used in the C# app to switch tabs or perform other actions as discussed in the previous steps.

Further Testing and Adjustments

You can adjust the distance threshold for detecting presence based on your needs. If you want more advanced behavior, you could:

• Add conditions for hiding or locking sensitive applications when a person is detected.
• Use other types of proximity sensors for better accuracy.

You can also integrate other actions, like muting the system audio or triggering specific actions based on the proximity data.

Conclusion

Using a Raspberry Pi Pico with a proximity sensor and a simple C# application, you can automate the management of Windows apps, switching tabs or hiding applications based on proximity detection. This setup is perfect for privacy-conscious users or those looking to add some automation to their desktop environment.

The post How to Auto Hide Windows Apps Using Raspberry Pi Pico appeared first on Teach Me Microcontrollers!.

Meet SunFounder PiPower

 SunFounder PiPower is an ingenious solution crafted to ensure your Raspberry Pi projects never lose their pulse. The package comes complete with a 12V2A power adapter, a 12V to 5V converter, a 7.4V 2600mAh lithium battery, and a USB cable. This combination guarantees a steadfast power supply, even in the face of power outages.

 PiPower is a game-changer for projects that require constant power. Whether your project involves data collection, web servers, or scripts that don't automatically restart upon boot, integrating a UPS such as PiPower can immensely enhance your project's resilience and reliability.

PiPower: More than Just a UPS

Beyond providing uninterrupted power, PiPower also brings the gift of portability to your projects. It's the ideal companion for remote projects such as a weather station, compact robot, or remote camera system. PiPower allows you to monitor the battery's voltage, power, current, and remaining capacity, making it a go-to choice for portable projects.

Simplified Setup and Adaptability

 Getting your PiPower up and running with your Raspberry Pi is straightforward and hassle-free. The SunFounder PiPower is engineered for a smooth setup, so you can concentrate on what truly matters - creating and innovating.

Protect Your Projects with PiPower

 Every Raspberry Pi enthusiast knows the risk of power interruptions leading to data corruption, particularly if your project is writing on the SD card at the moment of power loss. With PiPower, you can put these worries aside, knowing your projects are shielded from such mishaps.

The Bottom Line

 In the vast universe of Raspberry Pi, where your creativity is your only limit, don't let power interruptions hinder your innovation. With SunFounder PiPower, power interruptions become a relic of the past. It's more than just a power supply; it's a trustworthy ally for your Raspberry Pi projects.

 Secure your projects' integrity, enhance their portability, and let your imagination soar. Choose SunFounder PiPower for your Raspberry Pi today! Ready to empower your projects? Get your SunFounder PiPower here!

_(Note: For detailed instructions or assistance with the SunFounder PiPower, consider reaching out to SunFounder's support or community forums.)_

*Disclaimer: This post aims to provide an overview of the SunFounder PiPower. It's not sponsored by or affiliated with SunFounder.*

The post Empower Your Raspberry Pi Projects with SunFounder PiPower appeared first on Teach Me Microcontrollers!.

Materials

I will be using the popular MFRC522 RFID module:

My module comes with a card and a tag plus some male headers. This module can be interfaced using UART, I2C, or SPI. I will be using SPI with Python for this project following this RFID Raspberry Pi tutorial.

Powering the project is a Raspberry Pi 2 B+. However, it's compatible with older and newer PIs as long as they are running the latest Raspbian Stretch (March 2018).  

Other necessary things needed for this project are female-to-female jumper wires and an internet connection.

Building Instructions

Enable SPI
As mentioned, I communicated with the RFID module through SPI. Since SPI is not enabled by default on the RPi, I needed to turn it on via raspi-config:

sudo raspi-config

In the raspi-config interface, I selected Interfacing Options and then selected SPI. After answering yes to the prompt, I rebooted the RPi to save changes.

sudo reboot

I needed to check if SPI is indeed enabled. This is done by opening config.txt

sudo /boot/config.txt

Then I searched for the line that says:

dtparam=spi=on

If this line is commented out, then SPI is now enabled. 

SPI for Python

There are a number of handy python libraries for using the SPI interface.  I used SPI-Py. To download this library, just enter the commands:

git clone https://github.com/lthiery/SPI-Py.git

Once downloaded, cd to the folder and run the included setup.py script

cd SPI-Py sudo python setup.py install

This installs the SPI-Py library and is now usable in the Python environment.

Installing the RFID Library

My Raspberry Pi is now SPI-ready! Next, I installed the RFID library by Mario Gomez.

git clone https://github.com/mxgxw/MFRC522-python.git

This library uses the following connection:

I've created a Fritzing diagram for those who prefer it:

To test if everything's working as expected, I ran the included Read.py script:

python Read.py

Tapping the included RFID card shows the UID, size, and data for a specific sector for that card. It looks like this:

Card read UID: 22,81,46,91 
Size: 8 
Sector 8 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

This library allows me to view sector 8 which has 16 bytes of free space. I can use this space to save data but for now, I will be only using the UID as a unique identifier for the card.

Installing MySQL to Save Data

To complete my login system, I need to install mySQL and modify the Read.py code so that the time and name of the user are saved to a database every time the card is tapped into the module.

Here's how I installed mySQL server:

sudo apt-get install mysql-server --fix-missing

Once installed, I needed to create a database with two tables: user and log. The user table records all RFID card uid and the corresponding user names. The log table records the time and date when a user taps a card. 

After the database and tables were created, I inserted dummy data into the user table.

| uid           | fname   | lname    |
|---------------|---------|----------|
| 22,81,46,91   | Reed    | William  |
| 189,202,5,139 | Bird    | Clarence |
| 144,99,134,21 | Johnson | Earl     |

To be able to access the mySQL database through Python, I installed python-mysqldb:

sudo apt-get install python-mysqldb

That's about it for the software prerequisites.  Since the system logs the current date and time, my Raspberry Pi must be synced with my local time. This is done automatically in newer Raspbian distributions. I followed these steps:

1. sudo raspi-config

2. Internationalization options

3. Change Time Zone

4. Select geographical area

5. Select city or region.

6. Reboot your pi.

Now, I just needed to edit Read.py to this:

#!/usr/bin/env python 
# -*- coding: utf8 -*- 
# # Copyright 2018 Roland Pelayo 
# # This file is based on Read.py from MFRC522-Python library by Mario Gomez 
# MFRC522-Python is a simple Python implementation for 
# the MFRC522 NFC Card Reader for the Raspberry Pi. 
import RPi.GPIO as GPIO 
import MFRC522 
import signal 
import MySQLdb 
from time import gmtime, strftime 
from datetime import date 
continue_reading = True

# String variables for names 
firstname = "" 
lastname = "" 

# Create DB object 
db = MySQLdb.connect("localhost","root", "", "rfiddb") 

# Capture SIGINT for cleanup when the script is aborted 
def end_read(signal,frame): 
     global continue_reading 
     print "Ctrl+C captured, ending read." 
     continue_reading = False 
     GPIO.cleanup() 

# Hook the SIGINT 
signal.signal(signal.SIGINT, end_read) 

# Create an object of the class MFRC522 
MIFAREReader = MFRC522.MFRC522() 

# Welcome message 
print "Welcome to the MFRC522 data read example" 
print "Press Ctrl-C to stop." 

# This loop keeps checking for chips. If one is near it will get the UID and authenticate 
while continue_reading: 
# Scan for cards 
     (status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL) 
# If a card is found 
     if status == MIFAREReader.MI_OK: 
        print "Card detected" 
pass 

# Get the UID of the card 
     (status,uid) = MIFAREReader.MFRC522_Anticoll()
# If we have the UID, continue 
     if status == MIFAREReader.MI_OK: 
# Print UID 
        _uid = str(uid[0]) + "," + str(uid[1]) + "," + str(uid[2]) + "," + str(uid[3]) print _uid 
# Create DB cursor 
        cur = db.cursor(); 
# Check if UID is in DB 
        cur.execute("SELECT * FROM users WHERE uid = %s" , (_uid,)) 
# Read data 
        for row in cur.fetchall(): 
           firstname = str(row[1]) 
           lastname = str(row[2])
# Read time and date 
           _currTime = strftime("%H:%M:%S",gmtime()) 
           _currDate = date.today().strftime("%Y-%m-%d") 
# Send out a greeting to print name and date 
           print "Hello " + firstname + " " + lastname print _currDate + " " + _currTime 
# Insert every login into database 
        try: 
          try: 
               cur.execute("INSERT INTO log (uid,fname,lname,_date,_time) VALUES (%s,%s,%s,%s,%s)", (_uid,firstname,lastname,_currDate,_currTime)) 
               db.commit() 
          except (db.Error, db.Warning) as e: 
               print(e) 
          finally: 
               print "Successful" 
               cur.close() 
# This is the default key for authentication 
        key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF] 
# Select the scanned tag 
        MIFAREReader.MFRC522_SelectTag(uid) 
# Authenticate 
        status = MIFAREReader.MFRC522_Auth(MIFAREReader.PICC_AUTHENT1A, 8, key, uid) 
# Check if authenticated 
        if status == MIFAREReader.MI_OK:
           MIFAREReader.MFRC522_Read(8) 
           MIFAREReader.MFRC522_StopCrypto1() 
        else:
           print "Authentication error" 
           db.close()

There are other things printed on the terminal that are not useful for this project. Thus, I decided to edit the MFRC522.py script. You can download my version of this script on my repository.

If you want to replicate this project, all the files are found here. Just follow all the steps here for the software requirements. Note that the edited Read.py is now named Login.Py. To run, just cd to the folder I linked to and run this command:

sudo python Login.py

I've created a video showing the steps for running the project. Note that it's assumed that you have already installed the software prerequisites as presented above.

The post RFID Login System with Raspberry Pi appeared first on Teach Me Microcontrollers!.