Arduino RF Receiver Using RH-ASK
1. Introduction
This Arduino program receives wireless messages using a radio-frequency (RF) receiver supported by the RadioHead RH_ASK library. It initializes the receiver, checks for incoming messages, and prints received text to the Serial Monitor.
RH_ASK is commonly used with low-cost ASK/OOK radio modules. The actual RF frequency (for example, 315 MHz or 433 MHz) depends on the transmitter and receiver hardware. The code itself does not specify a frequency.
2. Objectives
- Understand basic wireless RF communication.
- Learn the purpose of the RadioHead RH_ASK library.
- Initialize an RF receiver.
- Receive a message without waiting continuously for a packet.
- Display received text in the Serial Monitor.
3. Required Components
| Component | Quantity | Purpose |
|---|---|---|
| Arduino Uno or compatible board | 1 | Runs the receiver program |
| ASK/OOK RF receiver module | 1 | Receives wireless data |
| Compatible RF transmitter | 1 | Sends wireless data |
| Jumper wires | As needed | Connect the receiver |
| USB cable | 1 | Uploads code and powers Arduino |
| Computer with Arduino IDE | 1 | Programs and monitors Arduino |
Important: The transmitter and receiver must use compatible RF frequency, modulation, data rate, and encoding settings. A receiver alone cannot generate a message; a compatible transmitter is needed.
4. Library Required
This program uses the RadioHead library, specifically its RH_ASK driver.
Installation Steps
- Open the Arduino IDE.
- Select Sketch → Include Library → Manage Libraries.
- Search for RadioHead.
- Install the RadioHead library.
- Restart or reopen the Arduino IDE if the library is not detected.
- Compile the sketch.
The SPI.h header is included in the supplied code because the library example commonly includes it. The comment in the code notes that SPI is not directly used by this ASK receiver sketch.
5. Basic Connection Guide
The exact pin connections depend on the RF receiver board and Arduino board. For a common 4-pin ASK receiver module, the connections are often:
| RF receiver module | Arduino Uno example |
|---|---|
| VCC | Supply voltage supported by the module (check its datasheet) |
| GND | GND |
| DATA | Digital pin 11 (common RH_ASK default receive pin) |
| ANT | Suitable antenna, if required by the module |
Pin note: The supplied sketch creates an RH_ASK driver without specifying custom pins. The RadioHead RH_ASK driver's default receive pin on a typical Arduino Uno configuration is digital pin 11. Confirm the defaults for your board and library version. If your wiring uses another pin, configure the driver with the appropriate constructor arguments and ensure the transmitter uses compatible settings.
Do not assume every RF module accepts 5 V. Check the module's operating-voltage specification before connecting VCC.
6. Important Concepts
6.1 Header Files
#include <RH_ASK.h> #include <SPI.h>
RH_ASK.hprovides the RadioHead ASK driver.SPI.his included in this example for library/build compatibility, although this simple ASK data path does not directly use the SPI bus.
6.2 Creating the Driver
RH_ASK driver;
Creates an RH_ASK driver object. It manages the ASK/OOK radio packet transmission and reception.
6.3 Serial Communication
Serial.begin(9600);
Starts serial communication at 9600 baud so the Arduino can display debugging information and received messages on the computer.
6.4 Initializing the Receiver
if (!driver.init()) Serial.println("init failed");
driver.init() initializes the RH_ASK driver. If initialization fails, the program prints init failed.
6.5 Byte Array
uint8_t buf[12];
Creates a buffer that can hold up to 12 bytes of received data. uint8_t is an unsigned 8-bit integer type.
6.6 Buffer Length
uint8_t buflen = sizeof(buf);
Sets the maximum buffer length to the size of the array, which is 12 bytes.
6.7 Receiving a Message
if (driver.recv(buf, &buflen))
Checks whether a valid message has been received. The call is non-blocking: it checks for a received packet and returns rather than waiting indefinitely for one.
6.8 Printing Received Data
Serial.print("Message: "); Serial.println((char*)buf);
Prints a label and then treats the received buffer as text. This is appropriate only when the received payload is a null-terminated text string, or when the code safely adds a terminator first.
The supplied code does not explicitly add a null terminator, so printing it as a C string can read beyond the received message.
7. Complete Supplied Arduino Code
#include <RH_ASK.h> #include <SPI.h> // Not actually used directly, but included by this example RH_ASK driver; void setup() { Serial.begin(9600); // Debugging only if (!driver.init()) Serial.println("init failed"); } void loop() { uint8_t buf[12]; uint8_t buflen = sizeof(buf); if (driver.recv(buf, &buflen)) // Non-blocking receive { int i; // A message with a valid checksum has been received. Serial.print("Message: "); Serial.println((char*)buf); } }
This version preserves the logic of the supplied sketch and formats it for readability. The variable i is declared but never used.
8. Safer Text-Receiving Version
The original code prints the byte buffer as a C string without ensuring that it ends with '\0'. The following version safely reserves one extra byte and adds a null terminator after a received message:
#include <RH_ASK.h> #include <SPI.h> RH_ASK driver; void setup() { Serial.begin(9600); if (!driver.init()) { Serial.println("init failed"); } else { Serial.println("RF receiver ready"); } } void loop() { uint8_t buf[12]; uint8_t buflen = sizeof(buf); if (driver.recv(buf, &buflen)) { // RH_ASK updates buflen to the received payload length. // Keep one byte available for the string terminator. if (buflen < sizeof(buf)) { buf[buflen] = '\0'; Serial.print("Message: "); Serial.println((char*)buf); } else { Serial.println("Received data is too long for text display."); } } }
This example is intended for text payloads of at most 11 bytes in the 12-byte buffer. For arbitrary binary payloads, print each byte using a loop instead of treating the buffer as a string. The sender must also transmit text in a compatible format.
9. Line-by-Line Explanation
| Code | Explanation |
|---|---|
#include <RH_ASK.h> | Includes the RadioHead ASK library. |
#include <SPI.h> | Includes the SPI header used by the example/library setup. |
RH_ASK driver; | Creates the RF driver object with default settings. |
void setup() | Runs once when Arduino starts or resets. |
Serial.begin(9600); | Starts serial communication. |
driver.init() | Initializes the RF receiver driver. |
Serial.println("init failed"); | Displays an error if initialization fails. |
void loop() | Repeats continuously. |
uint8_t buf[12]; | Creates a 12-byte receive buffer. |
sizeof(buf) | Returns the buffer size in bytes. |
driver.recv(buf, &buflen) | Checks for a received packet and stores its payload in the buffer. |
Serial.print("Message: "); | Prints a message label. |
Serial.println((char*)buf); | Displays the buffer as text; this requires safe string termination. |
10. Working Process
- Arduino starts and executes
setup(). - Serial communication starts at 9600 baud.
- The RH_ASK driver is initialized.
- If initialization fails, an error is printed.
- The
loop()function creates a receive buffer. - The program checks for a received RF packet.
- If a valid packet is received, its payload is stored in the buffer.
- The received message is displayed in the Serial Monitor.
- The program continues checking for more packets.
11. Block Diagram
RF Transmitter | | Wireless ASK/OOK signal v RF Receiver Module | | DATA output v Arduino Board | RH_ASK Library | Receive Packet | v Byte Buffer | v Serial Monitor Displays Message
12. Program Flowchart
START | v Start Serial at 9600 | v Initialize RH_ASK | v Did initialization succeed? / \ NO YES | | v v Print init Enter loop() failed | v Prepare buffer | v Check for packet | v Packet received? / \ NO YES | | | v | Read payload | | | v | Display message | | +-----<-----+ Repeat
13. Expected Serial Monitor Output
If initialization succeeds and the transmitter sends the text HELLO, the receiver may display:
Message: HELLO
If initialization fails, the program displays:
init failed
The exact received text depends on what the compatible transmitter sends. Select 9600 baud in the Serial Monitor.
14. Applications
- Wireless sensor data reception.
- Simple remote-control prototypes.
- Wireless door or motion alert systems.
- Low-cost telemetry demonstrations.
- Short-range wireless communication experiments.
- Arduino-to-Arduino data transfer.
The range and reliability depend on the radio modules, antennas, environment, interference, and regulatory limits.
15. Common Errors and Troubleshooting
| Problem | Possible reason | Solution |
|---|---|---|
RH_ASK.h: No such file or directory | RadioHead library is not installed | Install RadioHead using Library Manager. |
init failed appears | Driver or pin/timer configuration issue | Check board compatibility, library setup, and pin configuration. |
| No message is received | Transmitter and receiver settings differ | Check frequency, modulation, data rate, and wiring. |
| Garbled text appears | Incorrect payload interpretation or interference | Verify sender data format and use a suitable antenna. |
| Receiver works only at short distance | Weak signal, poor antenna, or interference | Check antenna, supply, and placement. |
| Serial Monitor is blank | Wrong baud rate or wrong serial port | Select 9600 baud and the correct port. |
| Text contains extra characters | Buffer is not null-terminated | Add a terminator safely or print using the received length. |
16. Precautions
- Use transmitter and receiver modules with matching specifications.
- Check the receiver's supply-voltage requirements.
- Connect DATA, VCC, and GND correctly.
- Use the correct antenna for the module and frequency.
- Keep the received payload length within the buffer capacity.
- Do not assume binary data is a printable text string.
- Follow local radio-frequency regulations and use permitted modules and power levels.
17. Viva Questions and Answers
Q1. What is RF communication?
RF communication sends information wirelessly using radio-frequency electromagnetic waves.
Q2. What is the purpose of this program?
It receives wireless data using an RF receiver and displays the message in the Serial Monitor.
Q3. What is the RH_ASK library?
It is a RadioHead library driver for ASK/OOK radio communication.
Q4. What does ASK stand for?
Amplitude Shift Keying.
Q5. What does OOK stand for?
On-Off Keying.
Q6. Why is RH_ASK driver; used?
It creates an object that manages RF packet reception.
Q7. What does driver.init() do?
It initializes the RH_ASK driver.
Q8. Why is Serial.begin(9600) used?
It starts serial communication at 9600 baud.
Q9. What is uint8_t?
It is an unsigned 8-bit integer data type.
Q10. What is the purpose of buf[12]?
It provides a 12-byte buffer for received data.
Q11. What does sizeof(buf) return?
It returns the size of the buffer in bytes.
Q12. What does driver.recv() do?
It checks for a received packet and copies its payload into the buffer.
Q13. What does non-blocking mean?
The program checks for a packet without waiting indefinitely for one to arrive.
Q14. Why should a null terminator be added before printing a byte buffer as text?
A C string must end with '\0'; without it, printing may read beyond the received data.
Q15. Does this receiver sketch transmit messages?
No. It only receives messages. A compatible RF transmitter is required to send them.
18. Conclusion
This project demonstrates wireless message reception using an Arduino and the RadioHead RH_ASK library. The program initializes the RF driver, checks for incoming packets, and prints received data in the Serial Monitor. It introduces important concepts such as RF communication, libraries, byte buffers, non-blocking reception, and serial output.
For reliable text display, the received buffer must be safely terminated or printed using its actual length.
19. Document Information
| Item | Details |
|---|---|
| Document title | Arduino RF Receiver Using RH_ASK Library |
| Programming language | Arduino C/C++ |
| Example board | Arduino Uno |
| Library | RadioHead (RH_ASK) |
| Serial baud rate | 9600 |
| Receive buffer | 12 bytes in supplied sketch |
| File format | Markdown (.md) |