The Last Signal: a DIY Off-Grid Radio Pager

Long before smartphones, before Wi-Fi, before "send" meant a tap on a glass screen, there was the pager. In the 1980s and 90s, a small beep on your belt was how the world reached you — doctors got called into emergencies, parents were paged home, and entire cities ran on nothing more than short radio bursts and a blinking screen. No internet. No towers full of data. Just radio waves carrying a message from one person to another, direct and unbroken.

Then the internet arrived, and pagers quietly disappeared — replaced by phones that need cell towers, apps that need Wi-Fi, and networks that need someone else's infrastructure to keep running. We gained convenience, but we lost something too: the ability to talk to each other when all of that infrastructure goes dark.

There's real science underneath the nostalgia. Radio frequency communication relies on electromagnetic waves — the same physics that carried the earliest wireless messages over a century ago, long before "network coverage" was a phrase anyone needed. A transmitter takes your keystrokes, encodes them into a signal, and pushes them out through an antenna at a specific frequency. A receiver tuned to that same frequency picks the signal out of the air, decodes it back into readable text, and displays it — no server in between, no company routing your message, no bill at the end of the month. It's about as close to "self-sufficient communication" as electronics can get: two people, two devices, and a shared slice of the radio spectrum that belongs to no one and everyone.

That's the gap this project steps into.

Picture this: the power's out, cell towers are down, the nearest router is a dead black box on the wall. In a disaster, a remote village, or a weekend deep in the backcountry, the systems we take for granted simply stop existing — and most of us go silent right along with them.

So I went back to what worked before any of that existed. This is a pair of handheld pagers that talk to each other entirely over radio frequency — no towers, no routers, no subscriptions, no internet in between. Type a message on the keypad, hit send, and it shows up on the other unit's screen, whether your friend is in the next room or the next valley over.

It's an old idea, rebuilt for a new reason — proof that staying connected was never something we needed the grid for in the first place.

4×4 Matrix Keypad — ×2

Used to enter text messages and commands.

16×2 LCD Display — ×2

Used to display sent and received messages.

Arduino Nano — ×2

Acts as the main controller of each pager and processes the communication.

433 MHz RF Transmitter Module — ×2

Used to transmit messages wirelessly through radio waves.

433 MHz RF Receiver Module — ×2

Used to receive messages from the other pager.

Buzzer / Piezo Buzzer — ×2

Provides an audible alert when a new message is received.

3D-Printed Enclosure – Bottom/Body — ×2

Holds and protects the electronic components.

3D-Printed Enclosure – Lid — ×2

Covers the electronics and completes the pager enclosure.

USB Cable — ×2

Used to power and program the Arduino Nano.

Bambu Lab A1 mini 3D Printer — ×1

Used to 3D print the pager enclosure.

Soldering Iron — ×1

Used to create permanent electrical connections between components.

Glue / Superglue — As required

Used to secure components and assemble the 3D-printed enclosure.

I first assembled the Arduino Nano, 16×2 LCD, and 433 MHz RF module on a breadboard to test the basic communication system before moving to the final pager enclosure.

The transmitter and receiver were tested separately to verify data transmission, message reception, LCD display, and overall stability. During testing, I encountered issues such as messages not being received consistently and unreliable data transmission, so I debugged the wiring and code and refined the communication process to make it smoother and more reliable.

After achieving stable communication, I tested the RF range at different distances and checked how obstacles and antenna orientation affected the signal. I get the range around 600 meters.

For improving the range, I also tested an external antenna. At 433 MHz, a quarter-wave antenna is approximately 17.3 cm long, making it a practical starting point for the RF modules. The antenna can improve range, although the actual improvement depends on the module, antenna placement, transmitter power, receiver sensitivity, and surrounding interference.

During testing, I faced issues such as data not being received consistently and unstable transmission, so I debugged the wiring and communication code and tested the system repeatedly to make the data transmission smoother.

Communication Plan

The final goal is to make both pager nodes capable of transmitting and receiving data over 433 MHz.

Pager A ↔ 433 MHz RF ↔ Pager B

This means either pager can send a message, while the other receives it. The keypad will be used to enter the message, the RF transmitter will send it, the receiver will capture it, and the LCD will display the received message. This creates a simple two-way, independent communication system without Wi-Fi, cellular networks, or the internet.

Breadboard Connections

1. 433 MHz RF Transmitter → Arduino D12
2. 433 MHz RF Receiver → Arduino D11
3. 4×4 Matrix Keypad → Arduino D2–D9
4. Buzzer / Piezo Buzzer → Arduino D10

After completing the basic “HELLO” RF transmission test, I moved to the main messaging code. The provided code combines all the individual components into one complete two-way RF messaging system.

How the Main Code Works

The code uses four main libraries:

1. RadioHead (RH_ASK) – handles communication through the 433 MHz RF transmitter and receiver.
2. Keypad – reads input from the 4×4 matrix keypad.
3. LiquidCrystal_I2C – controls the 16×2 LCD.
4. SPI – supports the RF communication library.

The RF driver is configured as:

Here, D11 is the RF receiver pin and D12 is the RF transmitter pin, with a transmission speed of 2000 bits per second.

Keypad Operation

The 4×4 keypad is connected to D2–D9. The code implements a multi-tap typing system similar to old Nokia phones.

For example:

1. Press 2 → a
2. Press 2 again → b
3. Press 2 again → c
4. Press 2 again → 2

The special keys are also programmed:

1. A → Space
2. B → Backspace
3. C → Clear message
4. D → Send message

A 1.2-second timeout determines when a character is finalized.

Message Buffer

The code stores the typed message in a buffer with a maximum length of 16 characters:

This keeps the message within the practical display/transmission limit of the pager.

Sending a Message

When D (Send) is pressed, the sendMessage() function sends the message through the 433 MHz transmitter:

The LCD displays “Sending...”, and the buzzer gives a short confirmation after the transmission is completed.

Receiving a Message

The device continuously checks for incoming RF data:

When a message is successfully received:

1. The RF receiver captures the data.
2. The buzzer produces a double-beep alert.
3. The LCD displays “>> Received:”.
4. The received message is shown for approximately 3.5 seconds.
5. The display returns to the message-entry screen.

Two-Way Communication

The important part of this code is that both pager nodes use the same basic program.

Therefore:

Pager A → sends → Pager B

and

Pager B → sends → Pager A

The RF transmitter and receiver work together on each Nano, allowing both devices to function as transmitter and receiver, rather than having one dedicated transmitter and one dedicated receiver.

Uploading to the Arduino Nano

After understanding and testing the code, I connected each Arduino Nano to the computer through USB, selected the correct Nano board and COM port in the Arduino IDE, compiled the program, and uploaded it.

The same main program was uploaded to both pager nodes, creating the foundation for the final two-way, off-grid RF messaging system.

Uploading the Main Code to the Arduino Nano

After understanding the main code, I uploaded it to the Arduino Nano using the Arduino IDE.

Steps to Upload the Code

1. Connect the Arduino Nano
2. Connect the Nano to the computer using a USB cable.
3. The computer should detect the Arduino and assign a COM port.
4. Open Arduino IDE
5. Open the Arduino IDE on the computer.
6. Open the provided MessagingDevice.ino code.
7. Install the Required Libraries

Before compiling, make sure the required libraries are installed:

1. RadioHead
2. Keypad
3. LiquidCrystal I2C
4. Go to:

Sketch → Include Library → Manage Libraries

Search for and install the required libraries.

4.Select the Arduino Nano

Go to:

Tools → Board → Arduino AVR Boards → Arduino Nano

Select the Processor

Go to:

Tools → Processor → ATmega328P

If the upload fails, try:

Tools → Processor → ATmega328P (Old Bootloader)

This is common with some Arduino Nano clones.

Select the COM Port

Go to:

Tools → Port → COMx

Select the COM port corresponding to your connected Nano.

5.Compile the Code

Click the ✓ Verify button first. This checks the code and libraries for compilation errors before uploading.

6.Upload the Code

Once the code compiles successfully, click the → Upload button.

The IDE will compile the program and transfer it to the Arduino Nano.

7.Repeat for the Second Pager

After successfully uploading the code to the first Nano, connect the second Arduino Nano and repeat the same process.

Final Setup

Once the code is uploaded to both Nanos, each device becomes a two-way RF messaging node:

Pager A ⇄ 433 MHz RF ⇄ Pager B

The keypad allows the user to type a message, the Arduino processes it, the RF transmitter sends it, and the other pager's RF receiver receives and displays the message on the LCD.

After confirming that the circuit worked correctly on the breadboard, I moved on to making the connections permanent using solder. This makes the pager more compact, reliable, and suitable for installation inside the 3D-printed enclosure.

I first arranged the Arduino Nano, LCD, RF transmitter, RF receiver, keypad, and buzzer according to the tested circuit. The required wires were then soldered carefully to the corresponding pins.

The main connections were:

1. 4×4 Matrix Keypad → Arduino Nano D2–D9
2. Buzzer / Piezo Buzzer → Arduino Nano D10
3. RF Receiver → Arduino Nano D11
4. RF Transmitter → Arduino Nano D12
5. 16×2 LCD → Connected according to the tested LCD wiring
6. Power and GND → Connected to the appropriate supply and ground lines

After soldering, I checked every joint for loose connections, solder bridges, and incorrect wiring. I then powered the circuit and tested the keypad, LCD, buzzer, transmitter, and receiver again to ensure that the permanent connections worked as reliably as the breadboard prototype.

Once the electronics were tested and the connections were permanently soldered, I started designing the custom enclosure in Fusion 360. The enclosure was designed as two separate parts: a bottom/body and a lid.

I took the actual components and their dimensions into consideration while designing the enclosure. Instead of making a simple box, I designed it in a compact console-like form, with dedicated spaces so that each component could fit and sit securely in its correct position.

The enclosure includes dedicated spaces for the:

1. 4×4 Matrix Keypad
2. 16×2 LCD Display
3. Arduino Nano
4. 433 MHz RF Transmitter and Receiver
5. Buzzer
6. Soldered wiring and connections
7. RF antenna

I also provided dedicated antenna space so that it can be positioned without unnecessarily bending or interfering with the other electronics.

Snap-Fit Lid

One of the important design features is the snap-fit lid. Instead of using screws, glue, or any other adhesive, the lid is designed to click directly into the bottom section and stay securely attached.

This makes the enclosure:

1. 🔧 Easy to assemble
2. ♻️ Easy to open for maintenance
3. 🚫 No screws required
4. 🚫 No glue or adhesive required
5. 📦 Clean and compact

After completing the design, I virtually checked the component placement in Fusion 360 to make sure everything would fit properly before moving to 3D printing. The final goal was to transform the breadboard prototype into a compact, practical, and durable handheld off-grid pager.

After completing the enclosure design in Fusion 360, I exported the bottom/body and snap-fit lid as 3D-printable files and prepared them for printing using Bambu Studio with my Bambu Lab A1 mini.

Slicing and Print Settings

I imported the STL files into Bambu Studio and arranged the parts on the build plate. Since the enclosure was designed specifically for 3D printing, no support material was required, which reduced both printing time and material usage.

The main settings used for preparing the print were:

1. Printer: Bambu Lab A1 mini
2. Slicer: Bambu Studio
3. Material: PLA
4. Layer Height: 0.20 mm
5. Infill: 15–20%
6. Wall/Perimeter: 3 walls
7. Supports: Not required
8. Build Plate: Textured PEI plate
9. Print Speed: Standard/Normal profile
10. Adhesion: Normal build-plate adhesion

I sliced the bottom and lid separately and previewed the toolpath in Bambu Studio before starting the print. I also checked the orientation and dimensions to make sure the snap-fit mechanism, LCD opening, keypad opening, and antenna space would print correctly.

After slicing, the files were sent to the Bambu Lab A1 mini for printing. Once printed, I checked the parts for dimensional accuracy and tested the snap-fit lid before installing the electronics.

I have also attached the pager.3MF project file used for slicing the enclosure.

NOTE: Since I am currently building two pager devices, the pager.3mf file needs to be printed twice, producing two complete sets of the enclosure—one for each communication node.

After completing the 3D printing and soldering, I started assembling the electronics inside the 3D-printed enclosure. As shown in the attached images, the enclosure was designed around the actual components, giving the pager a compact console-like layout.

I first placed the 16×2 LCD display and 4×4 matrix keypad into their respective openings. For the keypad, I peeled off the sticker from the back and carefully pressed it into position so it could stick firmly to the enclosure.

Next, I routed the Arduino USB cable through the dedicated hole in the enclosure. Since the pager does not use an internal battery, the Arduino is powered externally using a USB power bank. This makes the device rechargeable simply by connecting the power bank and also keeps the enclosure compact.

I then installed the Arduino Nano, 433 MHz RF transmitter, RF receiver, and buzzer inside the bottom section. The soldered wires were arranged carefully to avoid interference with the components and the snap-fit lid.

📡 Attaching the Antenna

One important step is to remember to attach the RF antenna before closing the enclosure. The antenna wire should pass through the provided opening and remain outside the enclosure for better RF performance.

After positioning the antenna, it can be secured using a small amount of hot glue or superglue. Hot glue or superglue can also be used where necessary to secure loose wires and prevent soldered connections from moving or breaking.

Finally, I checked that:

1. The LCD and keypad were properly aligned.
2. The USB cable could be connected to the power bank.
3. The antenna was securely positioned outside the enclosure.
4. The RF modules and Arduino were safely positioned.
5. No wires were being pinched by the lid.
6. The snap-fit mechanism could close correctly.

The snap-fit lid was then attached without using screws or adhesive. The same assembly process was repeated for the second pager, resulting in two complete RF communication devices ready for final testing.

After completing the assembly, I powered on both pager devices to demonstrate the complete communication system. When both devices are switched on, they communicate through the 433 MHz RF connection, creating an independent communication link without Wi-Fi, cellular networks, or the internet.

⌨️ Nokia-Style Keypad

The keypad works similar to the classic Nokia phone keypad. The number keys 0–9 contain multiple letters, numbers, and special characters. Repeatedly pressing the same key cycles through the available characters.

The additional keys provide the following functions:

1. A → Space — inserts a space between words.
2. B → Backspace — deletes the previous character.
3. C → Clear — clears the current message/display.
4. D → Send — sends the completed message.
5. * and # → No function assigned in the current version.

🔊 Button and Message Feedback

Every time a keypad button is pressed, the buzzer provides a short haptic-like audible feedback tone, confirming that the key press has been detected.

The buzzer also uses different tunes for outgoing and incoming messages. A unique tone confirms that a message has been sent, while another tone alerts the user when a new message is received.

📡 Sending and Receiving Messages

The user can type a message on either pager and press D to send it. The Arduino processes the message and transmits it through the 433 MHz RF transmitter.

The other pager receives the message through its 433 MHz RF receiver and displays it on the LCD along with the incoming-message alert.

An important feature is that the received message remains visible on the other pager's screen. It stays displayed until another message is received or the user presses C (Clear).

This allows the user to read the message without needing to view it immediately when the alert sounds.

🔄 Two-Way Communication

Both devices can independently send and receive messages:

Pager A → 433 MHz RF → Pager B

Pager B → 433 MHz RF → Pager A

This creates a simple two-way, independent messaging system that does not rely on Wi-Fi, cellular networks, or the internet.

The Last Signal is more than just a simple RF pager—it is a starting point for building communication systems that can work independently when conventional networks are unavailable. The project demonstrates how affordable electronics and a custom 3D-printed enclosure can be combined to create a practical off-grid communication device.

The design can also be customized and developed for different situations. The enclosure can be printed in different colors, redesigned into different shapes, or modified for specific environments and users. The software can also be changed to introduce completely new functions.

🚀 Where Could It Be Used?

This type of device could be useful in:

1. 🏕️ Camping and trekking — communication between people in remote areas.
2. 🏔️ Hiking and expeditions — short-range communication where mobile coverage may be unavailable.
3. 🚨 Emergency situations — basic communication when cellular infrastructure is disrupted.
4. 🌾 Rural areas — simple communication where network coverage is limited.
5. 🏭 Worksites and warehouses — quick messaging between workers within RF range.
6. 🎪 Events and temporary setups — independent communication without creating a Wi-Fi network.
7. 🏠 Off-grid communities — a simple local communication system independent of the internet.

🔐 More Features Can Be Created Through Software

Because the pager is programmable, the Arduino code can be modified to create additional functions. For example, a secret button combination or special key sequence could trigger a predefined message.

Instead of typing a complete message, a user could enter a specific combination that sends something like:

“EMERGENCY — PLEASE CHECK MY LOCATION”

Other predefined messages could include “COME HERE,” “I NEED HELP,” “ALL OK,” “MEETING POINT,” or any other message chosen by the user.

This could make the pager much faster to operate when sending frequently used messages. The feature could also be protected by a secret key sequence, so the special message is only triggered intentionally.

🎨 Customize Your Own Pager

The enclosure is also completely customizable. Since it was designed in Fusion 360, makers can modify the shape, button layout, colors, labels, antenna position, or internal component arrangement and print their own version.

The project can therefore evolve from a simple two-device pager into a customizable off-grid communication platform, with future possibilities including rechargeable batteries, solar charging, improved antennas, encryption, multiple devices, message storage, and emergency communication modes.

💬 Share Your Thoughts!

Have you ever faced a situation where you had no internet or mobile network but still needed to communicate?

I’d love to hear your thoughts on The Last Signal! What features would you add, where do you think an off-grid pager like this could be useful, and how would you improve the design?

Share your ideas, suggestions, and feedback in the comments below! 🚀📡