How 433MHz RF Tx-Rx Modules Work & Interface With Arduino

Want to make your next Arduino project wireless for about the same price as a cup of coffee? Then consider using 433MHz RF Transmitter and Receiver Modules!

These modules are available online for less than two dollars, making them one of the most affordable options for wireless data communication. What makes them even more practical is their tiny size – they’re so small that you can easily incorporate them into almost any project. The 433MHz frequency they use is part of the radio spectrum that’s set aside for short-range devices, which means you don’t need any special license to use them. Interestingly, these modules can transmit data over distances of up to 50 meters (depending on the conditions, of course).

So why not grab your Arduino and these RF modules, and start exploring the world of wireless communication in your next project!

Hardware Overview

Let’s take a closer look at the 433MHz RF Transmitter and Receiver Modules.

The Transmitter

First up, we have the transmitter module.

The heart of this module is a SAW resonator, which stands for “Surface Acoustic Wave” resonator. This special component is tuned to operate at 433.xx MHz. This module also contains a switching transistor and several passive components that work together.

When you send a HIGH signal to the DATA input, the oscillator produces a continuous radio wave at 433.xx MHz. However, when the DATA input is LOW, the oscillator stops working, which creates what’s called an amplitude-modulated wave. This method of changing the signal’s strength to represent data is called Amplitude Shift Keying, which we’ll explore more later.

The Receiver

Now, let’s move on to the receiver module.

This module contains an RF tuned circuit that works like a filter, blocking out unwanted signals that aren’t in the 433MHz range. It also has several operational amplifiers (OP Amps) that increase the strength of the received radio waves before processing them.

After amplification, the signal goes through a PLL (Phase Lock Loop) circuit. The PLL helps the decoder lock onto the stream of digital bits, which results in a cleaner output signal with better resistance to noise and interference.

ASK – Amplitude Shift Keying

Let’s explore how these modules transmit digital data using a technique called Amplitude Shift Keying, or ASK. This is a type of digital modulation that’s both simple and effective for sending information wirelessly. Here’s how it works:

In Amplitude Shift Keying, a high-frequency carrier wave is used for sending data. This carrier wave is a continuous sine wave with a constant frequency (in our case, 433 MHz). To send digital information, the wave is modified in a way that represents our binary data.

When we want to send a binary ‘1’, the carrier wave is transmitted at full strength. When we want to send a binary ‘0’, the carrier wave isn’t transmitted at all. This is similar to how you might use a flashlight to send Morse code by turning it on and off.

The visual below illustrates the binary data, the carrier wave, and the resulting ASK-modulated wave, where the amplitude of the carrier wave changes to represent binary ‘1’s and ‘0’s.

As you’d see in this illustration, the amplitude of the signal “shifts” between two levels depending on whether a ‘1’ or ‘0’ is being transmitted. Since there are only these two possible levels (on or off), this technique is sometimes called Binary Amplitude Shift Keying.

Advantages

ASK has several advantages that make it popular for simple wireless devices:

First, it’s wonderfully simple to implement. You don’t need complicated hardware to create or detect ASK signals, which makes these modules affordable and accessible for many projects.

Second, ASK uses less bandwidth compared to some other modulation techniques like Frequency Shift Keying (FSK).

Limitations

However, ASK does have some limitations. Since it relies solely on changes in signal amplitude, it can be affected by background noise or interference from other radio devices, making it less reliable in noisy environments.

Another limitation is that maintaining a consistent signal strength makes ASK less power-efficient, especially when sending data over longer distances. This is why these modules work best for short-range applications like remote controls, weather stations, or simple home automation.

Despite these limitations, if you keep the data transmission speed relatively slow, ASK can still work reliably in most environments. This makes it perfect for simple projects where cost and simplicity are more important than blazing speed or extreme range.

433MHz RF Transmitter & Receiver Pinout

Let’s take a look at the pinout of 433MHz RF Transmitter and Receiver Modules.

DATA is the data input pin. This is where you feed in the digital data that you want to transmit.

VCC is for the power supply. You can use any positive DC voltage between 3.5V and 12V. Keep in mind that the RF output strength is directly related to the supply voltage—the higher the voltage, the greater the transmission range.

GND is the ground pin.

Antenna is used to connect an external antenna. For optimal range and performance, it’s recommended to connect a 17.3 cm long solid wire to this pin. You might be wondering why this specific length—don’t worry, we’ll explain that later!

VCC is the power supply pin. Unlike the transmitter, the receiver specifically needs a 5V supply voltage to work properly.

DATA pins output the digital data received from the transmitter. Both pins are internally connected to each other, so you can use either one to receive the data.

GND is the ground pin.

Antenna connects to an external antenna, just like with the transmitter. Again, for the optimal range and performance, a 17.3 cm long solid wire should be connected to this pin.

Wiring the 433MHz RF Transmitter and Receiver Modules to the Arduino

Now that we’ve developed a good understanding of these modules, let’s roll up our sleeves and get them connected to our Arduino boards!

For this project, you’ll need two separate Arduino setups because we’ll be sending data from one Arduino to another. So you’ll need two Arduino boards, two breadboards, a 433 MHz transmitter module, a 433 MHz receiver module, and several jumper wires to make all the connections.

Setting Up the Transmitter

Connecting the transmitter module is quite straightforward since it only has three pins that need to be connected.

Connect the VCC pin on the module to the Arduino’s 5V pin and the GND pin to Ground.

Finally, connect the Data-in pin to digital pin #12 on the Arduino. We recommend using digital pin #12 for a specific reason – the library we’ll be using later is already set up to work with this pin by default, saving us extra programming steps.

Here’s a quick reference table for the pin connections:

Transmitter	Arduino
VCC	5V
Data	12
GND	GND

You can see the wiring in the image below.

Setting Up the Receiver

Now let’s wire up the receiver module on your second Arduino. The process is very similar to the transmitter setup.

Connect the VCC pin on the receiver module to the Arduino’s 5V pin and the GND pin to Ground. Then, connect one of the middle Data-out pins to digital pin #11 on the Arduino.

You might notice that the receiver has two data pins in the middle that look identical. Don’t worry about which one you choose – they’re actually connected to each other inside the module, so either one will work perfectly fine.

Here’s a quick reference table for the pin connections:

Receiver	Arduino
VCC	5V
Data	11
GND	GND

The wiring for the receiver is shown in the image below.

RadioHead Library

Unlike more advanced RF modules, such as the nRF24L01, the 433MHz RF module is quite basic. It does not have built-in error detection for data transmission. This means that if data gets corrupted during transmission, there’s no automatic way to detect or fix it. To make sure our data arrives correctly, we need to add our own error detection system .

This is where the RadioHead library becomes really useful. This library handles error detection for you by using something called CRC (Cyclic Redundancy Check). The great thing about the RadioHead library is that it works with almost any RF module, not just the 433MHz ones.

Here’s how it works

On the transmitter side, the library takes the data you want to send and packages it into a structured data packet, known as a RadioHead Packet. This packet includes a CRC checksum, along with a preamble and a header, to ensure smooth communication. Once the packet is properly structured, it is transmitted wirelessly to the receiving Arduino.

Here’s what the structure of a RadioHead packet looks like:

On the receiver side, the RadioHead library continuously listens for incoming packets. When a packet is received, the library recalculates the CRC checksum to verify whether the data has arrived correctly. If the CRC check passes, the receiving Arduino is notified that new data is available for processing. However, if the CRC check fails, meaning the data was corrupted during transmission, the packet is automatically discarded to prevent corrupted data from being used.

Installing the Library

To install the library:

1. First open your Arduino IDE program. Then click on the Library Manager icon on the left sidebar.
2. Type “radiohead” in the search box to filter your results.
3. Look for the “RadioHead” library created by Mike McCauley.
4. Click the Install button to add it to your Arduino IDE.

Arduino Example Code

Let’s try to send a short text message from a transmitter to a receiver using 433 MHz RF modules with Arduino. This basic exercise will help you understand these modules and can serve as a foundation for more advanced projects.

Code for the Transmitter

Here’s the sketch for the transmitter:

// Include RadioHead Amplitude Shift Keying Library #include <RH_ASK.h> // Include dependant SPI Library #include <SPI.h> // Create Amplitude Shift Keying Object RH_ASK rf_driver; void setup() { // Initialize ASK Object rf_driver.init(); } void loop() { const char *msg = "Hello World"; rf_driver.send((uint8_t *)msg, strlen(msg)); rf_driver.waitPacketSent(); delay(1000); }

Code Explanation:

Even though this sketch is short, it has everything needed to send a wireless message.

The sketch begins by including the required libraries. The RadioHead ASK library is necessary for handling Amplitude Shift Keying (ASK) modulation, while the SPI library is required because RadioHead depends on it to communicate with the hardware properly.

#include <RH_ASK.h> #include <SPI.h>

Next, We create an ASK object called rf_driver. This object provides all the functions we need to send messages wirelessly.

// Create Amplitude Shift Keying Object RH_ASK rf_driver;

In the setup function, we get the RF transmitter ready to use by initializing it. The init() function sets up all the necessary settings so our transmitter can work correctly. This only needs to happen once when the Arduino first powers on.

// Initialize ASK Object rf_driver.init();

Now, in the loop function, we create a message “Hello World” to be sent and store it in a variable called msg. Remember that you can modify the message to be anything you want, but for best results, keep it under 27 characters. In our example, we have 11 characters including the space.

// Preparing a message const char *msg = "Hello World";

We then send the message using the send() function, which requires two parameters: our message and its length. The strange part (uint8_t *) just converts our message into a format the radio can understand. The strlen(msg) tells the function exactly how many characters are in our message.

Right after sending the message, we use the waitPacketSent() function. This function makes sure the Arduino waits until the whole message is sent before moving on. This is important because we don’t want to interrupt the transmission halfway through.

Finally, the delay(1000) pauses the program for one second between messages. This gives the receiver time to process what it received and get ready for the next message. Without this pause, messages might come too quickly for the receiver to handle properly.

rf_driver.send((uint8_t *)msg, strlen(msg)); rf_driver.waitPacketSent(); delay(1000);

This code repeats every second, continuously sending “Hello World” through the air to any receiver that’s listening on the same frequency!

Code for the Receiver

Here’s the sketch for the receiver:

// Include RadioHead Amplitude Shift Keying Library #include <RH_ASK.h> // Include dependant SPI Library #include <SPI.h> // Create Amplitude Shift Keying Object RH_ASK rf_driver; void setup() { // Initialize ASK Object rf_driver.init(); // Setup Serial Monitor Serial.begin(9600); } void loop() { // Set buffer to size of expected message uint8_t buf[11]; uint8_t buflen = sizeof(buf); // Check if received packet is correct size if (rf_driver.recv(buf, &buflen)) { // Message received with valid checksum Serial.print("Message Received: "); Serial.println((char*)buf); } }

Once you’ve loaded this sketch onto your receiver Arduino, open the Serial Monitor. If everything is set up correctly, you should see the “Hello World” message displayed there.

Code Explanation:

The receiver code begins just like the transmitter code by loading both the RadioHead and SPI libraries. We also create an ASK object called rf_driver that will handle the communication with our receiver module.

#include <RH_ASK.h> #include <SPI.h> RH_ASK rf_driver;

In the setup function, we do two important things. First, we initialize the ASK object with rf_driver.init(), which prepares the receiver to start listening for messages. Second, we start the Serial communication with Serial.begin(9600). This allows our Arduino to send information to our computer so we can see the received messages in the Serial Monitor.

rf_driver.init(); Serial.begin(9600);

Moving to the loop function, we first create a special storage area called a buffer to hold our incoming message. We set its size to 11 bytes because that’s exactly how many characters are in “Hello World” (including the space). If your message is a different length, you’ll need to change this number to match. Every character counts, including spaces and punctuation.

We then create a variable called buflen that holds the size of our buffer. This will be used by the receiver to know how much data to expect.

uint8_t buf[11]; uint8_t buflen = sizeof(buf);

Next comes the most important part – we call the recv() function which activates the receiver. This function waits for an incoming message that matches our expectations. When it receives a valid message, it copies that message into our buffer and returns true to let us know something was received.

The if statement checks whether recv() returned true. If it did, that means we received a good message with a valid checksum (a special code that helps verify the message wasn’t corrupted during transmission). Inside the if block, we print “Message Received: ” followed by the actual message we received. The (char*)buf part converts our buffer data back into readable text.

if (rf_driver.recv(buf, &buflen)) { Serial.print("Message Received: "); Serial.println((char*)buf); }

After displaying the message, the code returns to the beginning of the loop and starts listening for another message.

This continuous cycle of listening and displaying messages completes our wireless communication system. The transmitter sends “Hello World” every second, and whenever the receiver successfully picks up that signal, it displays the message on the Serial Monitor.

Improving 433MHz RF module range with an antenna

Did you know that choosing the right antenna can make a huge difference in how far your RF modules can talk to each other? It’s true! Without any antenna at all, your devices might only communicate across your desk – maybe a meter at most. But add the right antenna, and suddenly they can chat from one end of your house to the other – up to 50 meters away!

The good news is that you don’t need anything fancy for an antenna. A simple piece of single-core wire works great for both your transmitter and receiver. Super easy to find and use!

Ideally, the most effective antenna would be exactly the same length as the wavelength of your transmission frequency. However, this can be impractical for everyday projects. Fortunately, using half or even just a quarter of that wavelength often works nearly as well, while being much more manageable in size.

To understand what length we need, we can calculate the wavelength using a simple formula:

Wavelength of frequency =	Speed of the transmission (v)
	Transmission frequency (f)

Since radio waves travel at the speed of light ( which is precisely 299,792,458 meters per second), we can calculate the ideal length for a 433 MHz antenna like this:

Wavelength of frequency =	299,792,458 m/s
433,000,000 Hz
=	0.6924 meters
=	69.24 cm

As you can see, a full-wavelength antenna would be almost 70 cm long. This would be awkward to incorporate into most projects. That’s why a quarter-wavelength antenna is commonly used instead, which is just 17.3 cm long. Much more manageable!

One important tip

You might think you could save space by coiling or folding your antenna wire, but this would be a mistake! When you coil an antenna, the electromagnetic waves interfere with each other, dramatically reducing your transmission range. A straight antenna is always the best choice!