Build a Smart Raspberry Pi Lamp with PWM Dimming and MQTT Control

Project Overview and Hardware Reality Check

Building a raspberry pi lamp seems straightforward until you look at the GPIO current limits. The Raspberry Pi 4 and 5 can only source about 16mA per GPIO pin, with a strict 50mA total bank limit. A standard 12V LED lamp strip draws between 1.5A and 4A. If you wire an LED strip directly to the Pi, you will instantly fry the GPIO trace and potentially kill the SoC.

To build this safely and achieve flicker-free dimming, we use a logic-level MOSFET driven by the Pi's hardware PWM (Pulse Width Modulation) pin. This guide targets the Raspberry Pi 4 Model B (4GB) and the Raspberry Pi 5, running Raspberry Pi OS (Bookworm or newer). We will use the pigpio library instead of the standard RPi.GPIO because software PWM causes visible flickering on camera sensors and to the human eye at low duty cycles. Hardware PWM pushes a clean 1kHz+ signal to the MOSFET gate.

Parts List and Component Specifications

Do not substitute the MOSFET blindly. The most common beginner mistake is using an IRF520 module. The IRF520 requires 10V on the gate to fully open; the Pi only outputs 3.3V. This leaves the MOSFET in its linear (resistive) region, causing it to overheat and drop voltage to your lamp. You must use a logic-level MOSFET with a low Vgs(th) threshold.

Pin Mapping and Wiring Procedure

The wiring relies on a common ground between the 12V power supply and the Raspberry Pi. Without this shared reference, the 3.3V GPIO signal cannot trigger the MOSFET gate.

Numbered Wiring Steps

1. Prepare the Gate Circuit: Solder the 100Ω resistor to the middle pin (Gate) of the IRLB8721 MOSFET. Solder the 10kΩ resistor between the Gate and the left pin (Source).
2. Connect Pi GPIO: Run a jumper wire from Pi BCM 18 (Physical Pin 12) to the free end of the 100Ω gate resistor.
3. Establish Common Ground: Connect Pi GND (Physical Pin 6) to the MOSFET Source pin (where the 10kΩ pull-down is attached). Also connect this node to the negative (-) terminal of your 12V power supply.
4. Wire the Load: Connect the negative (-) pad of the 12V LED strip to the MOSFET Drain pin (right pin). Connect the positive (+) pad of the LED strip to the positive (+) terminal of the 12V power supply.
5. Verify: Use a multimeter to check for shorts between the 12V positive rail and the Pi's 3.3V/5V rails. There should be infinite resistance.

Python PWM Control Code

This script uses the pigpio library to access the Pi's hardware PWM peripheral. Before running this code, install the daemon and Python bindings via your terminal:

sudo apt update
sudo apt install pigpio python3-pigpio
sudo systemctl enable pigpiod
sudo systemctl start pigpiod

Save the following code as pi_lamp_control.py:

import pigpio
import time
import sys

# --- Pin Definitions ---
# BCM 18 is used because it is tied to Hardware PWM0
LED_PIN = 18  
PWM_FREQ = 1000  # 1kHz frequency prevents camera/eye flicker
PWM_RANGE = 100  # Allows duty cycle to be set from 0 to 100

def initialize_hardware():
    """Connect to the pigpio daemon and configure hardware PWM."""
    pi = pigpio.pi()
    if not pi.connected:
        print("[FATAL] Cannot connect to pigpio daemon. Is it running?")
        sys.exit(1)
    
    pi.set_PWM_frequency(LED_PIN, PWM_FREQ)
    pi.set_PWM_range(LED_PIN, PWM_RANGE)
    pi.set_PWM_dutycycle(LED_PIN, 0) # Ensure lamp is off at start
    return pi

def run_lamp_sequence(pi):
    """Executes a smooth fade-in, hold, and fade-out sequence."""
    print("Starting Raspberry Pi Lamp sequence...")
    
    # Fade In (0% to 100%)
    for duty in range(101):
        pi.set_PWM_dutycycle(LED_PIN, duty)
        time.sleep(0.02)
    
    # Hold at 100% brightness
    print("Lamp at 100% brightness. Holding for 3 seconds.")
    time.sleep(3)
    
    # Fade Out (100% to 0%)
    for duty in range(100, -1, -1):
        pi.set_PWM_dutycycle(LED_PIN, duty)
        time.sleep(0.02)
    
    print("Sequence complete. Lamp off.")

if __name__ == '__main__':
    pi_instance = None
    try:
        pi_instance = initialize_hardware()
        run_lamp_sequence(pi_instance)
    except KeyboardInterrupt:
        print("\n[INFO] Interrupted by user. Safely shutting down.")
    except Exception as e:
        print(f"[ERROR] Unexpected failure: {e}")
    finally:
        # Cleanup: Always turn off the PWM and disconnect to prevent ghost loads
        if pi_instance and pi_instance.connected:
            pi_instance.set_PWM_dutycycle(LED_PIN, 0)
            pi_instance.stop()
            print("GPIO cleaned up successfully.")

Debugging: When Your Raspberry Pi Lamp Fails

Embedded hardware rarely works perfectly on the first boot. If your lamp doesn't light up, do not start randomly changing code. Follow this diagnostic path.

The First Three Things to Check

1. Common Ground: Measure the voltage between the Pi's GND pin and the 12V PSU's negative terminal. It must read < 0.05V. If it reads higher, your ground wire is broken or too thin.
2. 12V Power Delivery: Disconnect the LED strip from the MOSFET. Measure the voltage at the strip's pads. You should read between 11.8V and 12.2V. If it reads 0V, your PSU or wiring is at fault, not the Pi.
3. Daemon Status: Run systemctl status pigpiod in the terminal. If it is not 'active (running)', the Python script will fail immediately.

Ranked Causes for Common Error Strings

Error 1: socket.error: [Errno 111] Connection refused

• Cause: The pigpiod background service is not running, or the Python script is executing before the daemon has fully initialized on boot.
• Fix: Run sudo systemctl start pigpiod. If running on boot via rc.local or a systemd service, add a 5-second sleep delay to your startup script.

Error 2: Can't lock /var/run/pigpio.pid

• Cause: A previous instance of the daemon crashed or was force-killed, leaving a stale lock file, or you accidentally started two instances of pigpiod.
• Fix: Run sudo killall pigpiod, then sudo rm /var/run/pigpio.pid, and restart the service.

Error 3: Lamp turns on but strobes/flickers heavily at low brightness

• Cause: You are using software PWM (like standard gpiozero.PWMLED or RPi.GPIO) which is interrupted by Linux OS background tasks, causing timing jitter.
• Fix: Ensure you are using BCM 18 (or BCM 12/13/19) and the pigpio hardware PWM implementation as shown in the code above.

Extending and Simplifying the Build

Depending on your end goal, you can scale this raspberry pi lamp project up for home automation or down for a simple desk toy.

How to Simplify (The 5V USB Route)

If you don't want to deal with a 12V power supply and raw MOSFETs, buy a 5V USB-powered LED strip (like the Adafruit NeoPixel or standard 5V analog strips drawing < 500mA). You can power the strip directly from the Pi's 5V and GND pins, and use a simple 2N2222 NPN transistor instead of a MOSFET to switch the ground path. Note: Never exceed 500mA total draw on the Pi's 5V rail when doing this.

How to Extend (MQTT and Home Assistant)

To integrate this lamp into a smart home, install the Mosquitto MQTT broker on the Pi. Modify the Python script to subscribe to an MQTT topic (e.g., home/office/lamp/set). When a payload of 50 arrives, the script updates the pigpio duty cycle to 50. This allows you to control the lamp via Home Assistant dashboards or physical smart switches without polling an API.

Frequently Asked Questions

Can I power a raspberry pi lamp directly from the GPIO pins?

No. The Raspberry Pi GPIO pins operate at 3.3V and are limited to 16mA per pin. A typical lamp requires 12V and over 1000mA. Connecting a lamp directly to the GPIO will result in a dim, underpowered light at best, and a melted SoC trace or dead Raspberry Pi at worst. You must always use a transistor, MOSFET, or relay as a switch to isolate the high-power load from the Pi's logic circuits.

Why does my raspberry pi lamp flicker when dimming at low levels?

Flickering at low brightness is almost always caused by software PWM. Standard Linux is not a real-time operating system; background tasks interrupt the CPU, causing the GPIO pin to stay HIGH or LOW slightly longer than intended. This timing jitter translates to visible flicker. To fix this, you must use hardware PWM (available on specific pins like BCM 18) via a library like pigpio, which offloads the timing to a dedicated peripheral chip on the Pi.

How do I make a raspberry pi lamp turn on automatically at sunset?

You can achieve this by integrating the astral Python library, which calculates local sunrise and sunset times based on your GPS coordinates. Alternatively, for a more robust smart-home approach, leave the Python script listening to an MQTT broker, and use Home Assistant's built-in Sun integration to publish an MQTT 'ON' message to your Pi precisely at local sunset. This prevents the Pi from needing an active internet connection to check weather APIs.