Build and Debug a 433MHz Raspberry Pi RF Transmitter with SYN115

To build a reliable Raspberry Pi RF transmitter, skip the ubiquitous 5V FS1000A modules found in cheap kits. Instead, use a SYN115 433MHz ASK transmitter paired with a Raspberry Pi 4 Model B or Raspberry Pi 5. The SYN115 operates natively at 3.3V logic, matching the Pi’s GPIO tolerance, and uses a PLL-based crystal oscillator that prevents the frequency drift common in cheaper SAW-based transmitters. Because Linux is not a real-time OS, software-timed bit-banging will introduce jitter that breaks RF decoding. We solve this by using the pigpio library to leverage the Pi's hardware DMA for microsecond-accurate pulse generation.

Hardware BOM and Pin Mapping

Before wiring anything up, verify you have the correct module variant. The FS1000A requires 5V for usable range and will slowly degrade a Pi's 3.3V regulator if back-fed. The SYN115 is the correct choice for direct Pi GPIO connection.

Bill of Materials (2026 Pricing)

Pin Mapping Table

Wire the SYN115 to the Pi using BCM GPIO numbering. Do not use the physical pin numbers for the software configuration.

Software Setup and Compilable Python Code

The standard RPi.GPIO library is deprecated and suffers from severe timing jitter on multi-core Pis running modern Linux kernels. We use pigpio, which offloads pulse generation to the Pi's hardware DMA controller, guaranteeing microsecond precision required by OOK (On-Off Keying) receivers like the PT2262.

First, install the daemon and Python bindings. On Raspberry Pi OS Bookworm, use a virtual environment:

sudo apt update
sudo apt install pigpio python3-pigpio
sudo systemctl enable pigpiod
sudo systemctl start pigpiod
python3 -m venv ~/rf_env
source ~/rf_env/bin/activate
pip install pigpio

Below is the complete, production-ready Python script. It constructs a 24-bit RF waveform in hardware memory and transmits it without CPU jitter.

import pigpio
import sys
import time

# --- PIN DEFINITIONS & RF CONFIG ---
TX_PIN = 17          # BCM GPIO 17 (Physical Pin 11)
RF_CODE = 0xABCDEF   # 24-bit hex code to transmit
PULSE_LENGTH = 350   # Microseconds (syncs with standard PT2262 receivers)
BAUD_RATE = 2000     # Bits per second
BIT_DELAY = 1000000 // BAUD_RATE  # Microseconds per bit
TRANSMIT_REPEATS = 5 # Number of times to repeat the packet

def build_waveform(pi, code, bits=24):
    """Constructs a pigpio waveform for OOK transmission."""
    wf = []
    # Sync preamble (optional but recommended for AGC settling)
    wf.append(pigpio.pulse(1 << TX_PIN, 0, PULSE_LENGTH))
    wf.append(pigpio.pulse(0, 1 << TX_PIN, PULSE_LENGTH * 31))
    
    # Data bits
    for i in range(bits - 1, -1, -1):
        if (code >> i) & 1:
            # Logic 1: Long pulse, short gap
            wf.append(pigpio.pulse(1 << TX_PIN, 0, PULSE_LENGTH * 3))
            wf.append(pigpio.pulse(0, 1 << TX_PIN, PULSE_LENGTH))
        else:
            # Logic 0: Short pulse, long gap
            wf.append(pigpio.pulse(1 << TX_PIN, 0, PULSE_LENGTH))
            wf.append(pigpio.pulse(0, 1 << TX_PIN, PULSE_LENGTH * 3))
    
    pi.wave_clear()
    pi.wave_add_generic(wf)
    return pi.wave_create()

def main():
    # Initialize pigpio connection to the daemon
    pi = pigpio.pi()
    if not pi.connected:
        print("Error: Could not connect to pigpio daemon. Is 'pigpiod' running?")
        sys.exit(1)

    pi.set_mode(TX_PIN, pigpio.OUTPUT)
    pi.write(TX_PIN, 0) # Ensure TX is low before starting

    print(f"Building waveform for code: {hex(RF_CODE)}...")
    wave_id = build_waveform(pi, RF_CODE)

    if wave_id >= 0:
        print(f"Transmitting {TRANSMIT_REPEATS} times...")
        pi.wave_send_repeat(wave_id)
        
        # Wait for transmission to complete
        while pi.wave_tx_busy():
            time.sleep(0.1)
            
        pi.wave_tx_stop()
        pi.wave_delete(wave_id)
        print("Transmission complete.")
    else:
        print("Error: Failed to create waveform.")

    pi.stop()

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nTransmission aborted by user.")
        sys.exit(0)

Debugging: Exact Errors and the "First Three" Checks

RF debugging on Linux is notoriously frustrating because failures happen silently at the physical layer. Before rewriting your code, run through the First Three Checks:

1. Is the antenna exactly 17.3 cm? The SYN115 output impedance is matched to a quarter-wave monopole at 433.92 MHz. A coiled or missing wire drops effective radiated power (ERP) by over 90%, making it look like a software failure when the receiver simply isn't seeing the signal.
2. Is the pigpiod daemon actually running? The Python library is just a client. If the background service crashed or isn't enabled on boot, the hardware DMA never initializes.
3. Is the receiver's baud rate matched? If your receiver (e.g., an Arduino with the RCSwitch library) expects a 2000 bps signal and your Pi's pulse length drifts, the automatic gain control (AGC) on the receiver will reject the packet as noise.

Ranked Causes for Exact Error Strings

If the script crashes, match your terminal output to these exact strings:

Scaling Up: Extending or Simplifying the RF Link

Once you have basic 433MHz OOK transmission working, you will eventually hit the limits of ASK modulation: it is unidirectional, highly susceptible to noise, and limited to low baud rates. Here is how to adapt your architecture based on your end goal.

How to Simplify the Build

If you are struggling with Linux timing, daemon management, or Python virtual environments, offload the RF transmission to an ESP32. Use the Raspberry Pi as the high-level logic controller (running Home Assistant, Node-RED, or a web server) and send MQTT messages to an ESP32. The ESP32 runs a bare-metal RTOS that handles RF bit-banging flawlessly via the RCSwitch or ESP8266_RC_Switch libraries. This removes the Pi from the physical RF layer entirely.

How to Extend the Build (Protocol Comparison)

If you need bidirectional communication, encryption, or longer range, you must abandon ASK OOK modules. Below is a decision matrix for upgrading your Pi GPIO RF stack.

Migration Note: Moving from the SYN115 to an SPI-based module like the CC1101 requires shifting from pigpio bit-banging to the Pi's hardware SPI bus (/dev/spidev0.0). You will need to enable SPI via sudo raspi-config and use Python's spidev library alongside a hardware abstraction library like SmartRF or RadioLib (via C++ bindings). Ensure you use logic level shifters if you source 5V SPI modules; the Pi's SPI pins are strictly 3.3V tolerant.