Build a Raspberry Pi Garage Door Opener with MQTT and Reed Switches

If you want to integrate your garage door into Home Assistant or a custom MQTT dashboard, bypassing proprietary cloud hubs is the most reliable path. The direct answer for a robust, local-only build: use a Raspberry Pi 4 Model B (4GB) paired with a 5V optocoupler-isolated relay module and a normally-open (NO) magnetic reed switch. The optocoupler is non-negotiable here; it protects the Pi’s 3.3V GPIO logic from the 5V and 12V transients generated by the garage door motor’s control board.

This guide walks through the exact hardware, wiring, and Python code to build a Raspberry Pi garage door opener that responds to MQTT commands and reports real-time door state, complete with the edge cases and debugging steps that generic tutorials skip.

Hardware Spec Sheet & Parts List

Before pulling wires, verify your components. Using a standard 5V relay without an optocoupler is the most common reason beginners fry their Pi’s GPIO bank when interfacing with motor controllers.

Wiring the Optocoupler and Reed Switches

Safety Callout: Garage door motors contain 120V/240V mains power in the main housing. Even though we are tapping into the low-voltage (12V/5V) logic terminals, you must unplug the main motor unit from the wall before opening the housing to expose the terminal block. Verify dead with a non-contact voltage tester.

Pin Mapping Table

Wiring Steps

1. Power the Pi: Wire the 12V output from the garage door motor’s accessory terminals to the input of the LM2596 buck converter. Adjust the potentiometer on the buck converter with a multimeter until the output reads exactly 5.1V. Connect this to the Pi’s 5V and GND GPIO pins (Pins 2 and 6).
2. Wire the Relay Input: Connect Pi GPIO 17 to the relay module’s IN pin. Connect Pi GND to the relay module’s GND. Do not connect the Pi’s 3.3V or 5V to the relay’s VCC; power the relay’s VCC from the buck converter’s 5V output to keep high-current switching noise off the Pi’s power rail.
3. Wire the Relay Output: On the garage door motor’s logic board, locate the two terminals labeled for the wall push-button. Connect the relay’s COM (Common) and NO (Normally Open) screw terminals to these two button wires. Polarity does not matter here.
4. Wire the Reed Switch: Mount the magnet on the moving door panel and the reed switch on the fixed track. Run the two reed switch wires to the Pi. Connect one wire to Pi 3.3V (Pin 1) and the other to GPIO 27 (Pin 13).

Python Control Script with MQTT

This script targets the Raspberry Pi 4 Model B running Raspberry Pi OS (Bookworm). It uses gpiozero for hardware abstraction (which natively supports the Bookworm lgpio backend) and paho-mqtt for broker communication. For deeper library documentation, refer to the official gpiozero docs and the Eclipse Paho Python client.

import time
import signal
import sys
import paho.mqtt.client as mqtt
from gpiozero import OutputDevice, Button

# --- PIN DEFINITIONS ---
RELAY_PIN = 17
REED_PIN = 27

# --- MQTT CONFIGURATION ---
BROKER_IP = "192.168.1.50"
BROKER_PORT = 1883
TOPIC_CMD = "garage/door/command"
TOPIC_STATE = "garage/door/state"

# --- HARDWARE INITIALIZATION ---
# active_high=False because standard optocoupler relays trigger on LOW
relay = OutputDevice(RELAY_PIN, active_high=False, initial_value=False)
# pull_up=True uses the Pi's internal 3.3V pull-up resistor
reed_switch = Button(REED_PIN, pull_up=True, bounce_time=0.1)

def get_door_state():
    """Returns 'closed' if magnet is near reed switch, else 'open'."""
    return "closed" if reed_switch.is_pressed else "open"

# --- MQTT CALLBACKS ---
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT Broker!")
        client.subscribe(TOPIC_CMD)
        # Publish initial state on connect
        client.publish(TOPIC_STATE, get_door_state(), retain=True)
    else:
        print(f"Failed to connect, return code {rc}")

def on_message(client, userdata, msg):
    payload = msg.payload.decode().strip().upper()
    print(f"Received command: {payload}")
    
    if payload in ["OPEN", "CLOSE", "TOGGLE"]:
        # Pulse the relay for 0.5 seconds to simulate a button press
        relay.on()
        time.sleep(0.5)
        relay.off()
        
        # Wait for door to start moving, then publish new state
        time.sleep(2)
        client.publish(TOPIC_STATE, get_door_state(), retain=True)

# --- MAIN EXECUTION ---
def main():
    client = mqtt.Client()
    client.on_connect = on_connect
    client.on_message = on_message
    
    try:
        client.connect(BROKER_IP, BROKER_PORT, 60)
        client.loop_start()
        
        # Keep script running and monitor for state changes
        last_state = get_door_state()
        while True:
            current_state = get_door_state()
            if current_state != last_state:
                print(f"Door state changed to: {current_state}")
                client.publish(TOPIC_STATE, current_state, retain=True)
                last_state = current_state
            time.sleep(1)
            
    except Exception as e:
        print(f"Fatal error: {e}")
    finally:
        client.loop_stop()
        client.disconnect()
        print("MQTT disconnected. GPIO cleaned up.")

if __name__ == "__main__":
    main()

Debugging: Exact Errors and Relay Chatter

When your Raspberry Pi garage door opener fails to trigger, the issue is almost always rooted in OS-level GPIO permissions or MQTT broker configurations. Here are the first three things to check, followed by the exact error strings you will see in the terminal.

Error 1: RuntimeError: No access to /dev/mem. Try running as root!

The Cause: You are likely using legacy code with the RPi.GPIO library on Raspberry Pi OS Bookworm. The newer OS restricts direct memory access to the GPIO registers for non-root users to improve security.

The Fix: Do not run the script with sudo. Instead, ensure you are using gpiozero (as shown in the script above), which automatically falls back to the lgpio backend. If you must use RPi.GPIO, install the compatibility shim: sudo apt install python3-rpi-lgpio.

Error 2: ConnectionRefusedError: [Errno 111] Connection refused

The Cause: The Python script cannot reach the MQTT broker. This usually happens because the Mosquitto broker on your server is configured to reject anonymous connections or isn't bound to the local network interface.

The Fix: SSH into your MQTT broker machine and edit the configuration file (sudo nano /etc/mosquitto/conf.d/default.conf). Add these two lines to allow local network traffic without passwords:

listener 1883
allow_anonymous true

Restart the service with sudo systemctl restart mosquitto.

Extending and Simplifying the Build

Not every project needs to be built from scratch, and sometimes you need more features than a basic relay provides.

How to Simplify: The Commercial Alternative

If stripping wires and managing buck converters feels like overkill, simplify the build by using a Shelly Plus 1 ($20). It is a dry-contact smart relay that natively supports MQTT and Home Assistant out of the box. You wire it directly to the 12V logic of the garage motor and the wall button, completely eliminating the need for the Raspberry Pi, the Python script, and the custom enclosure. Use the Pi for projects that require local compute, not just simple contact closure.

How to Extend: Adding Visual Verification

To extend this build, integrate a Raspberry Pi Camera Module 3. Modify the Python script to trigger a snapshot via the libcamera command-line tool whenever an MQTT OPEN command is received. Publish the resulting JPEG to an MQTT topic (garage/door/image) or save it to a local SMB share. This provides visual confirmation that the door actually opened and isn't just stuck on the safety sensors.

FAQ: Raspberry Pi Garage Door Opener

Can I use a Raspberry Pi Zero 2 W for a garage door opener?

Yes, the Raspberry Pi Zero 2 W has the exact same 40-pin GPIO layout and BCM numbering as the Pi 4, so the Python code and wiring diagram above will work without modification. However, the Zero 2 W only has 512MB of RAM. If you plan to run a local MQTT broker (like Mosquitto) on the same board alongside the control script, the Pi 4 is highly recommended. If the broker is hosted elsewhere (like on a Home Assistant server), the Zero 2 W is a perfect, low-power fit.

How do I power the Raspberry Pi garage door opener from the existing motor?

Most modern garage door motors (Chamberlain, LiftMaster, Genie) have a 12V DC accessory output or a 5V logic rail on the main control board. Never tap directly into the 120V/240V mains line to power a standard USB phone charger inside the housing; the electromagnetic interference (EMI) from the motor starting will cause the Pi to brownout and reboot. Instead, use an isolated DC-DC buck converter (like the LM2596 mentioned in the parts list) wired to the motor's low-voltage accessory terminals to step the voltage down to a clean 5.1V.

Is a Raspberry Pi garage door opener safe from hackers?

A local-only Raspberry Pi garage door opener is significantly safer than cloud-dependent commercial smart garage openers. Because this build uses a local MQTT broker over your private WiFi network, there is no external server that can be breached to open your door. To harden it further, configure your MQTT broker to require TLS encryption and username/password authentication, and ensure your home router's UPnP is disabled so the broker port is never accidentally exposed to the public internet.