MicroPython: RCWL-0516 Microwave Radar Sensor – Detect Motion with ESP32/ESP8266

This guide shows how to use the RCWL-0516 Microwave Radar Proximity sensor with the ESP32 and ESP8266 using MicroPython to detect motion. You’ll learn how to wire the sensor to the boards and how to program them using MicroPython firmware. The RCWL-0516 is a great alternative to the popular PIR motion sensor.

We have similar tutorials using Arduino IDE:

• ESP32 with RCWL-0516 Microwave Radar Proximity Sensor (Arduino IDE)
• ESP8266 NodeMCU with RCWL-0516 Microwave Radar Proximity Sensor (Arduino IDE)

Table of Contents:

Throughout this tutorial, we’ll cover the following contents:

• Introducing the RCWL-0516 Microwave Radar Proximity Sensor
• RCWL-0516 Microwave Radar Proximity Sensor Pinout
• Microwave Radar Proximity Sensor vs PIR Motion Sensor
• Wiring the RCWL-0516 sensor to the ESP32/ESP8266
• RCWL-0516 with ESP32 and ESP8266 MicroPython Code

Prerequisites

To follow this tutorial you need MicroPython firmware installed in your ESP32 or ESP8266 boards. You also need an IDE to write and upload the code to your board. We suggest using Thonny IDE or uPyCraft IDE:

• Thonny IDE:
  • Installing and getting started with Thonny IDE
  • Flashing MicroPython Firmware with esptool.py
• uPyCraft IDE:
  • Getting Started with uPyCraft IDE
  • Install uPyCraft IDE (Windows, Mac OS X, Linux)
  • Flash/Upload MicroPython Firmware to ESP32 and ESP8266

Learn more about MicroPython: MicroPython Programming with ESP32 and ESP8266

Introducing the RCWL-0516 Microwave Radar Proximity Sensor

The RCWL-0516 is a small, inexpensive sensor that uses microwave radar to detect the presence of moving objects. The sensor works by emitting a beam of microwaves and then detecting the Doppler shift in the reflected waves as objects move past.

Usually, these sensors are sold as a pack of five and don’t come with header pins. So, you may need to get header pins separately and then solder them yourself.

Where to Buy?

You can check the following link on Maker Advisor and compare the price in different stores.

• RCWL-0516 Microwave Radar Proximity Sensor

You can use the preceding links or go directly to MakerAdvisor.com/tools to find all the parts for your projects at the best price!

How does it work?

The RCWL-0516 sensor has a built-in oscillator that generates a microwave signal at a frequency of 3.18 GHz. The sensor then sends out this signal in a 360-degree pattern.

When an object moves within the sensor’s range, the reflected waves are picked up by the sensor’s receiver. The receiver then measures the frequency of the reflected waves and compares it to the frequency of the original signal. If the frequency of the reflected waves has changed, the sensor knows that an object has moved.

The RCWL-0516 sensor has a single output pin that goes HIGH when it detects movement. It outputs LOW when no motion is detected.

RCWL-0516 Sensor Features

The RCWL-0516 has a detection range of up to 7 meters and can detect objects moving at speeds of up to 2 meters per second. It also has a built-in adjustable delay time, which can be used to prevent the sensor from triggering repeatedly on the same object.

Note: even though it mentions a detection range of up to 7 meters, I couldn’t get those results with my setup. However, I got very good feedback from some of our readers about this sensor.

Here’s a summary of some of the key features of the RCWL-0516 sensor:

• Uses microwave radar to detect moving objects
• Detection range of up to 7 meters
• Can detect objects moving at speeds of up to 2 meters per second
• Built-in adjustable delay time
• Low power consumption
• Inexpensive

RCWL-0516 sensor specifications:

• Supply voltage: 4–28 VDC
• Operating frequency: 3.18 GHz
• Sensing distance: 5–7 m
• Output level: 3.4V High <0.7 Low
• Output drive: 100mA
• Output timing: 2 second retrigger with motion

You can get more information about the sensor on the following GitHub page:

• RCWL-0516 Github page

Optional Light Depend Resistor (LDR) Sensor

The sensor comes with the option to solder a light-depend resistor (light sensor) if you want your sensor to operate just in dark conditions, for example. You can get the output of the LDR sensor on the LDR pin. Alternatively, you can also connect the LDR to the CDS pin.

When the output of the LDR is bigger than 0.7V, the OUT pin will output a HIGH signal when motion is detected. If motion is detected but the output of the LDR is smaller than 0.7V, the output will be LOW. This means that when attaching an LDR, the sensor will only sense motion when it’s dark.

You can adjust the sensitivity of the LDR, by connecting a resistor on the R-CDS pads (see the following section), or by adding a pull-up resistor externally in parallel with the CDS pin.

In my case, I added a pull-up 22KOhm resistor to the LDR pin so that it could detect motion when there is low light. Without the resistor, not even in very dark conditions I had a positive output. You might need to try with different resistance values to see which one works best for your scenario.

Adjustment components

At the back of the sensor, there are three pads for additional SMD components (0805 dimensions):

The following information was taken from this GitHub page.

• C-TM: Regulate the repeat trigger time. The default (unpopulated) time is 2s. An SMD capacitor to extend the repeat trigger time. Pin 3 of the IC emits a frequency (f), and the trigger time in seconds is given by (1/f) * 32678.
• R-GN: The default detection range is 7m, adding a 1M resistor reduces it to 5m.
• R-CDS: Resistor in parallel with the 1M pullup. Without R-CDS, the lowest resistance of the LDR (i.e. highest light level) where the output is enabled is ~269kΩ (=0.7V). Adding resistance here decreases the LDR resistance of the enable/disable threshold. If the LDR resistance at the desired light level threshold is <269k then you could add an external resistor in series with the LDR.

RCWL-0516 Microwave Radar Proximity Sensor Pinout

The RCWL-0516 microwave radar proximity sensor has five pins:

• 3V3: this is the output from the voltage regulator (not the power pin)
• VIN: this is the power input pin. The sensor can be powered by a voltage range of 4-28V.
• GND: this is the ground pin.
• OUT: this is the output pin. The output pin goes HIGH when the sensor detects movement and remains LOW when it doesn’t.
• CDS: This pin is used to connect a light-dependent resistor (LDR). The LDR can be used to disable the sensor in bright light conditions.

The following table shows the pinout of the RCWL-0516 microwave radar proximity sensor:

3V3	3.3V power output (not to power the sensor)
GND	ground pin
OUT	output pin (goes HIGH when motion is detected)
VIN	input voltage to power the sensor (4V to 28V)
CDS	Light-dependent resistor output

Microwave Radar Proximity Sensor vs PIR Motion Sensor

The microwave radar proximity sensor is many times used as an alternative to the PIR motion sensor, depending on the project application. The following table compares both sensors:

	RCWL-0516 Microwave Radar	PIR Motion Sensor
How it works?	Active Sensor (emits microwave signals and detects reflections).	Passive Sensor (detects infrared radiation emitted by objects).
Detection Range	Longer range, typically up to 7+ meters.	Shorter range, typically a few meters, depending on the model.
Sensing Through Obstacles	Can sense through non-metallic materials.	Obstructed by certain materials (e.g., glass)
Sensitivity to Motion	Highly sensitive, may give false positives.	Not so sensitive, may miss subtle movements. Only detects living things that emit heat.
Coverage Area	Broad coverage with wide radar pattern.	Narrow field of view.

Connecting the RCWL-0516 Microwave Radar Proximity Sensor to the ESP32 and ESP8266

Follow the next table or schematic diagram to wire the RCWL-0516 microwave radar proximity sensor to the ESP32/ESP8266 (in this example, we won’t use the LDR):

RCWL-0516 Sensor	ESP32/ESP8266
3V3	don’t connect
GND	GND
OUT	GPIO12 (or any other GPIO of your choice)
VIN	VIN (or a voltage between 4 and 28V)
CDS	don’t connect

ESP32 with RCWL-0516 – Schematic Diagram

ESP8266 NodeMCU with RCWL-0516 – Schematic Diagram

MicroPython Script – RCWL-0516

Using the MicroPython IDE of your choice, copy the following code to the main.py file. This script reads the output of the sensor and lights up an LED and prints in the MicroPython Shell when motion is detected. The sensor outputs a HIGH signal when it detects motion and a LOW signal when idle.

# Complete project details: https://RandomNerdTutorials.com/micropython-rcwl-0516-esp32-esp8266/

from machine import Pin
import time

# Pin numbers for LED and sensor
led_pin = 2
sensor_pin = 12

# Set the LED pin as an output and the sensor pin as an input
led = Pin(led_pin, Pin.OUT)
sensor = Pin(sensor_pin, Pin.IN)

# Initialize state variables
state = 0
val = 0

while True:
    val = sensor.value()  # read sensor value

    if val == 1:  # check if the sensor is HIGH
        led.on()  # turn LED ON

        if state == 0:
            print("Motion detected!")
            state = 1  # update variable state to HIGH
    else:
        led.off()  # turn LED OFF

        if state == 1:
            print("Motion stopped!")
            state = 0  # update variable state to LOW

    # Add a small delay to avoid constant checking of the sensor
    time.sleep(0.1)

View raw code

Alternatively, you may also use interrupts to detect the state of the sensor. You can use the same code we use in the following tutorial (just make sure you adjust the GPIOs accordingly): MicroPython: Interrupts with ESP32 and ESP8266.

How the code works

Start by importing the required modules: machine module is used to interact with hardware components, and we are importing Pin from it to control GPIO pins. The time module is used to introduce delays and control the timing of the program.

# Import required libraries
from machine import Pin
import time

Next, define the pins for the LED and for the output pin of the sensor. To simplify we’re using the ESP32 and ESP8266 built-in LEDs that are connected to GPIO2 in both cases (it may change depending on the board model you’re using). Alternatively, you can connect a physical LED to any other GPIO, just change the code accordingly.

# Pin numbers for LED and sensor
led_pin = 2
sensor_pin = 12

Next, create two Pin objects, one to refer to the LED (led) and another to refer to the microwave radar sensor (sensor). The LED is defined as an output using Pin.OUT and the sensor as an input using Pin.IN.

# Set the LED pin as an output and the sensor pin as an input
led = Pin(led_pin, Pin.OUT)
sensor = Pin(sensor_pin, Pin.IN)

Then, create some variables to keep track of the state of the sensor. Basically, val is used to temporarily store the real-time output value of the sensor, while state is used to keep track of whether motion has been detected or not over time.

# Initialize state variables
state = 0
val = 0

The program enters an infinite loop (while True), meaning it will run indefinitely, repeatedly checking for motion.

while True:

We start by reading the value of the motion sensor using sensor.value(). The method returns 0 if no motion is detected and 1 if motion is detected. The result is stored in the val variable.

val = sensor.value()  # read sensor value

If the sensor’s output is 1 (motion detected), we turn on the LED.

if val == 1:  # check if the sensor is HIGH
    led.on()  # turn LED ON

Note: the ESP8266 built-in LED works with inverted logic, so you need to write .off() to turn it on and .on() to turn it off. If you’re using a regular LED connected to that GPIO, it works with the “regular” logic.

Then, we check if the previous status was 0. If so, it means the state has changed and that motion has been detected. We print a message in the shell and change the state variable to 1.

if state == 0:
    print("Motion detected!")
    state = 1  # update variable state to HIGH

If the sensor’s output is 0 (no motion detected), we turn the LED off.

else:
    led.off()  # turn LED OFF

If the previous state was 1 and, if now the current value of the sensor is 0, it means motion has stopped, and we can set the state variable to 0.

if state == 1:
    print("Motion stopped!")
    state = 0  # update variable state to LOW

The code will continue to loop indefinitely, repeatedly checking for motion and updating the LED status and the messages on the MicroPython shell accordingly.

Demonstration

Save the code to your board using Thonny IDE or any other MicroPython IDE of your choice. We’re using Thonny IDE.

1) Copy the code provided to a new file on Thonny IDE.

2) Upload the code to your board. If you’re using Thonny IDE, go to File > Save as… and then select MicroPython device.

3) Save your file as main.py so that it runs automatically when the ESP32/ESP8266 starts/resets. There should be a file called boot.py. That file is created by default when you burn MicroPython firmware.

4) Finally, click Ok to proceed.

5) Now, press the on-board RST/EN button so that the board restarts and starts running the code or press the green Run button on the IDE.

Wave your hand in front of the motion sensor. You should get a “Motion detected!” message followed by a “Motion stopped!” message after two seconds. Additionally, the on-board LED will light up when motion is detected.

If you have an LDR attached, you’ll need to decrease the luminosity to get positive results.

Wrapping Up

In this tutorial, you learned how to use the RCWL-0516 microwave radar proximity sensor to detect motion in your surroundings with the ESP32 and ESP8266 programmed with MicroPython. The RCWL-0516 might be a good alternative to the PIR motion sensor depending on your project requirements.

We hope you found this tutorial useful. If you want to try a PIR motion sensor instead, read this tutorial: ESP32 and ESP8266 with PIR Motion Sensor using MicroPython.

We have tutorials for more than different 20 sensors and modules with the ESP32 and ESP8266. Check out the following link:

• ESP32: 25 Free Guides for Sensors and Modules
• ESP8266 NodeMCU: 20 Free Guides for Sensors and Modules

Do you want to learn more about MicroPython with the ESP32 and ESP8266? Check out our Resources:

• MicroPython Programming with ESP32 and ESP8266 eBook
• ESP32/ESP8266 MicroPython Projects and Tutorials

Thanks for reading.