Wemos 433 Mhz RF Receiver

Wemos 433 Mhz RF Receiver

I’ve been using RTL_433 with a SDR for a few years now with modest success. This setup will detect and identify a variety of 433Mhz sensor readings. The output is piped to a MQTT broker and from there the readings are presented graphically.

At first this was done on a Raspberry Pi running a bash script on startup, with the following one liner command.

rtl_433 -F json | mosquitto_pub -h <MQTT-Broker> -i RTL_433 -l -t RTL_433/SDR_FEED

Unpredictably, problems would arise when the process would hang and readings no longer were being received. This was addressed by placing the process under a supervisor task, details can be found in this post titled “Scheduled vs Supervised Tasks” https://www.cloudacm.com/?p=3956. Another issue discovered was that some sensors failed to be detected by the SDR. The standard antenna included with the SDR was replaced with a 433 Mhz tuned antenna, https://www.amazon.com/Zerone-433MHZ-Antenna-Signal-Amplifier/dp/B07DMXSX45. This improved coverage, but there were still some PIR sensors that were in dead spots. It was becoming clearer that the SDR had a hard limit and to get these dead spot sensors online, I would have to place some kind of bridging device closer to them.

I had seen demonstrations of 433 Mhz RF modules being used with microcontrollers in this post, https://randomnerdtutorials.com/decode-and-send-433-mhz-rf-signals-with-arduino/. However, many of the demonstrations I found online used the RF modules as a wireless link between two microcontrollers. I had a Sonoff RF bridge available and looked into using it for the purpose of receiving and processing sensors. However, that would require hardware modifications and following a rather lengthy setup process with a narrow range of supported sensors.

Along the way there were GitHub repos that caught my attention, https://github.com/sui77/rc-switch/ and https://github.com/ninjablocks/433Utils. It was this blog by Ray Wang that spelled out clearly what I was intending to do, https://rayshobby.net/reverse-engineer-wireless-temperature-humidity-rain-sensors-part-1/. This was further elaborated by Brad Hunting’s GitHub repo, https://github.com/bhunting/Acurite_00592TX_sniffer. From here out the pieces started to fall into place as I found more details on Brad’s blog, https://www.techspin.info/.

One of the key steps in getting the microcontroller to detect and decode the RF sensors was identifying the pattern. I used a logic analyzer to get the timings and sequences. From there I was able to display the sensor data with the microcontroller. This worked for my PIR motion sensors, temp/humidity sensors, door reed switch sensors, and key fob controllers.

I had some problems porting the code to work on the Wemos ESP8266. The code worked fine on the Arduino Uno, but the interrupts are handled differently on the ESP8266 microcontroller. The function called by attachInterrupt had to have ICACHE_RAM_ATTR defined. This video briefly explains some of the interrupt dependencies of the platform.

Another problem I had was with the 433 Mhz receiver hardware. It operates at 5 volts and was causing a brownout of the Wemos when the microcontroller was attempting to boot. A workaround for this was to control the power to the receiver from the Wemos using a logic level shifter. The level shifter was already in use to shift the 5 volt signal from the receiver to 3.3 volts on the Wemos. Using a level shifter as a power supply is not recommended, but the low current draw of the receiver allowed it just this time. Here is the wiring of the components.

Since this project was to detect dead spot PIR sensors, this is the code that was loaded on the Wemos. I liked that the library dependencies were minimal which made integrating functions from earlier code easier.



  Title: Wemos ESP8266 433Mhz RF PIR MQTT Bridge
  Version: 2
  Filename: Wemos-433_MQTT_PIR-Sensor_Display_ver2.ino

  Date: 12/10/2023
  Author: Patrick Gilfeather - CloudACM

  Base Code based on
  Convert RF signal into bits (PIR Sensor) 
  Written by : Ray Wang (Rayshobby LLC)
  For ESP8266-Wemos, use LOLIN(WEMOS) D1, R2, and mini 


// Libraries and Declarations
#include <Arduino.h>

#include <ESP8266WiFi.h>

#include <PubSubClient.h>
WiFiClient espClient;
PubSubClient MQTTclient(espClient);
long laststats = 0;
int programflag = 0;

// NTP Libraries, Declarations, and Variables
#include <NTPClient.h>
#include <WiFiUdp.h>
NTPClient timeClient(ntpUDP, "pool.ntp.org");
//Week Days
String weekDays[7]={"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
//Month names
String months[12]={"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};

// Variables

// MQTT Broker
const char* mqtt_server = "#########";     // Put your MQTT Broker here

// Your WiFi credentials
const char* ssid =     "#########";               // Put your SSID here
const char* password = "#########";           // Put your PASSWORD here

unsigned long lasttimeupdate = 0; // Time counter for periodic NTP time checks
unsigned long lasttimereboot = 0; // Time counter for periodic reboots to avoid millis rollover

ADC_MODE(ADC_VCC);  // See comment block below for more details
  see - http://arduino.esp8266.com/Arduino/versions/2.0.0-rc2/doc/libraries.html

  ESP.getVcc() may be used to measure supply voltage. ESP needs to reconfigure the ADC at 
  startup in order for this feature to be available. Add the following line to the top of 
  your sketch to use getVcc:


  TOUT pin has to be disconnected in this mode.

  Note that by default ADC is configured to read from TOUT pin using analogRead(A0), and 
  ESP.getVCC() is not available.


// ring buffer size has to be large enough to fit
// data between two successive sync signals
#define RING_BUFFER_SIZE  256

#define SYNC_LENGTH 12200
#define SYNC_RANGE  300  // Was hard coded to 400 but too much crosstalk

#define BIT1_HIGH  1200
#define BIT1_LOW   400
#define BIT0_HIGH  400
#define BIT0_LOW   1200
#define BIT_RANGE  100  

#define DATAPIN  2  // D2 is interrupt 1
#define CONTROLPIN  4  // D4 is used to control power to the 433Mhz reciever module
#define DELAYTIME 50  // 50 ms delay commonly used throughout code

unsigned long timings[RING_BUFFER_SIZE];
unsigned int syncIndex1 = 0;  // index of the first sync signal
unsigned int syncIndex2 = 0;  // index of the second sync signal
bool received = false;

// detect if a sync signal is present
bool isSync(unsigned int idx) {
  // check if we've received 4 squarewaves of matching timing
  int i;

  // check if there is a long sync period prior to the 4 squarewaves
  unsigned long t = timings[(idx+RING_BUFFER_SIZE-i)%RING_BUFFER_SIZE];
  // if(t<(SYNC_LENGTH-400) || t>(SYNC_LENGTH+400) ||
    digitalRead(DATAPIN) != HIGH) {
    return false;
  return true;

/* Interrupt 1 handler */
void ICACHE_RAM_ATTR handler() {
  static unsigned long duration = 0;
  static unsigned long lastTime = 0;
  static unsigned int ringIndex = 0;
  static unsigned int syncCount = 0;

  // ignore if we haven't processed the previous received signal
  if (received == true) {
  // calculating timing since last change
  long time = micros();
  duration = time - lastTime;
  lastTime = time;

  // store data in ring buffer
  ringIndex = (ringIndex + 1) % RING_BUFFER_SIZE;
  timings[ringIndex] = duration;

  // detect sync signal
  if (isSync(ringIndex)) {
    syncCount ++;
    // first time sync is seen, record buffer index
    if (syncCount == 1) {
      syncIndex1 = (ringIndex+1) % RING_BUFFER_SIZE;
    else if (syncCount == 2) {
      // second time sync is seen, start bit conversion
      syncCount = 0;
      syncIndex2 = (ringIndex+1) % RING_BUFFER_SIZE;
      unsigned int changeCount = (syncIndex2 < syncIndex1) ? (syncIndex2+RING_BUFFER_SIZE - syncIndex1) : (syncIndex2 - syncIndex1);
      // changeCount must be 50 -- 24 bits x 2 + 2 for sync
      if (changeCount != 50) {
        received = false;
        syncIndex1 = 0;
        syncIndex2 = 0;
      else {
        received = true;


// MQTT Functions

void callback(char* topic, byte* message, unsigned int length) {
  String messageTemp;
  for (int i = 0; i < length; i++) {
    messageTemp += (char)message[i];

  if (String(topic) == "Wemos-433/UpdateTime") {
    if(messageTemp == "CheckTime"){

  if (String(topic) == "Wemos-433/Reboot") {
    if(messageTemp == "Reboot"){

void reconnect() {
  // Loop until we're reconnected
  while (!MQTTclient.connected()) {
    // Attempt to connect
    if (MQTTclient.connect("Wemos-433")) {
      // Subscribe
      // Do you not subscribe to my methods?
      // Wemos-433/# for everything, or Wemos-433/Uptime for just the Uptime
    } else {
      // Wait 5 seconds before retrying

void UpdateStats() {
  long stats = millis();
  if (stats - laststats > 5000) {
    laststats = stats;

    MQTTclient.publish("Wemos-433/Firmware", "Wemos-433_MQTT_PIR-Sensor_Display_ver2");     
    String StringUptime = String(millis());
    MQTTclient.publish("Wemos-433/Uptime", StringUptime.c_str());
    String StringHWAddress = String(WiFi.macAddress());
    MQTTclient.publish("Wemos-433/HWAddress", StringHWAddress.c_str());   
    String StringWifiSignal = String(WiFi.RSSI());
    String StringFreeHeapSize = String(ESP.getFreeHeap());
    String StringHeapFragmentation = String(ESP.getHeapFragmentation());
    String StringMaxFreeBlockSize = String(ESP.getMaxFreeBlockSize());
    String StringSketchSize = String(ESP.getSketchSize());
    String StringFreeSketchSpace = String(ESP.getFreeSketchSpace());
    String StringCpuFreqMHz = String(ESP.getCpuFreqMHz());
    String StringChipId = String(ESP.getChipId());
    String StringVcc = String(ESP.getVcc());

    //Get a Time Structure
    String formattedTime = timeClient.getFormattedTime();
    String StringformattedTime = String(formattedTime);

    //Get a Date Structure
    time_t epochTime = timeClient.getEpochTime();
    struct tm *ptm = gmtime ((time_t *)&epochTime); 
    int monthDay = ptm->tm_mday;
    int currentMonth = ptm->tm_mon+1;
    String currentMonthName = months[currentMonth-1];
    int currentYear = ptm->tm_year+1900;
    //Publish complete date:
    String StringcurrentDate = String(currentMonth) + "/" + String(monthDay) + "/" + String(currentYear);
    //Publish Epoch:
    String StringEpochTime = String(timeClient.getEpochTime());


void setup() {
  digitalWrite(CONTROLPIN, LOW); 
  digitalWrite(CONTROLPIN, HIGH); 
  pinMode(DATAPIN, INPUT); 
  attachInterrupt(digitalPinToInterrupt(DATAPIN), handler, CHANGE);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
      // Just wait it out
  MQTTclient.setServer(mqtt_server, 1883);

  timeClient.begin(); // Initialize a NTPClient to get time
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT -7 = -25200 (see - https://time.gov/)


int t2b(unsigned int t0, unsigned int t1) {
  if (t0>(BIT1_HIGH-BIT_RANGE) && t0<(BIT1_HIGH+BIT_RANGE) &&
      t1>(BIT1_LOW-BIT_RANGE) && t1<(BIT1_LOW+BIT_RANGE)) {
    return 1;
  } else if (t0>(BIT0_HIGH-BIT_RANGE) && t0<(BIT0_HIGH+BIT_RANGE) &&
             t1>(BIT0_LOW-BIT_RANGE) && t1<(BIT0_LOW+BIT_RANGE)){
    return 0;
  return -1;  // undefined

void loop() {
  if (!MQTTclient.connected()) {

  // Update time from NTP source every 1 day (24 * 60 * 60 * 1000 = 86400000 milli-seconds)
  unsigned long timeupdate = millis();
  if (timeupdate - lasttimeupdate > 86400000) {
    lasttimeupdate = timeupdate;

  // Reboot microcontroller every 30 day to avoid millis() rollover (30 * 24 * 60 * 60 * 1000 = 2592000000 milli-seconds)
  unsigned long timereboot = millis();
  if (timereboot - lasttimereboot > 2592000000) {
      // Reboot command
  if (received == true) {
    // disable interrupt to avoid new data corrupting the buffer
    // detachInterrupt(1);

    // extract Device ID
    unsigned int startIndex, stopIndex;
    unsigned long deviceid = 0;
    bool fail = false;
    startIndex = (syncIndex1 + (0*8+0)*2) % RING_BUFFER_SIZE;
    stopIndex = (syncIndex1 + (1*8+8)*2) % RING_BUFFER_SIZE;

    for(int i=startIndex; i!=stopIndex; i=(i+2)%RING_BUFFER_SIZE) {
    int bit = t2b(timings[i], timings[(i+1)%RING_BUFFER_SIZE]);
    deviceid = (deviceid<<1) + bit;
    if (bit < 0) fail = true;

    if (fail) {  
        MQTTclient.publish("Wemos-433/DecodeError", "Decoding error.");     
    else {
    String StringDevID = String(deviceid);
    MQTTclient.publish("Wemos-433/DeviceID", StringDevID.c_str());


    // delay for 50 milli seconds to avoid repetitions
    received = false;
    syncIndex1 = 0;
    syncIndex2 = 0;

    // re-enable interrupt
    // attachInterrupt(1, handler, CHANGE);
    attachInterrupt(digitalPinToInterrupt(DATAPIN), handler, CHANGE);


The hardware build initially was in a box. The Wemos module had its mini USB port exposed so that a USB cable could provide power. It also had a cut piece of wire that is 70 cm long as the antenna. This setup was rather unsightly since the box and long wires looked out of place.


I finally settled on installing it in a Tripp Lite TLP664USBB surge protector that included USB ports, https://tripplite.eaton.com/6-outlet-surge-protector-with-4-usb-ports-6-foot-1800-joules-black~TLP664USBB. This allowed the Wemos to get its power directly from the 5 volt USB ports. The power strip is used for other purposes and none of it looks odd or attention getting. I had to loop the antenna around the inside of the power strip. This didn’t present any problems as I was careful to isolate the electronics by sealing it with silicon calk. The Wemos module was placed so that the mini USB port was still accessible, should any programming need to be done later.

This project will likely expand as time goes on, with the option to decode multiple sensors types from a single microcontroller. But for now, this will do what I need.

Comments are closed.