Mini Project report 2024

Frequency Hopping Spread Spectrum

using rfm69 module
A mini project in communication systems networks(EC380) report
submitted in Partial Fulfillment of the Degree of Bachelor of Technology in
Electronics and Communication Engineering

DEPARTMENT OF ELECTRONICS AND

COMMUNICATION ENGINEERING
NATIONAL INSTITUTE OF TECHNOLOGY
KARNATAKA SURATHKAL,
MANGALORE - 575025 April 2024
 Mini Project report 2024

Submitted By
Meer Ismail Ali
(21EC125)
Rishu Kumar
(211EC140)
Under the mentorship of
Dr. Prasantha Kumar
 Mini Project report 2024

ABSTRACT
This project implements a data transmission system using Frequency Hopping
Spread Spectrum (FHSS) on the 433 MHz band. To achieve synchronization
between transmitter and receiver, a pilot signal is employed. The system utilizes a
slow hopping technique, where the carrier frequency periodically switches across
15 channels within the 433 MHz to 434.790 MHz ISM band. The channels are
spaced at 124.28 kHz intervals to minimize interference. This approach improves
data security and reduces the impact of narrowband noise sources compared to
fixed-frequency transmission.
 Mini Project report 2024

Contents

1. Theory 5
2. Introduction 6
3. Motivation 8
4. Design 10
Code......................................................................................................... 11
Setup picture............................................................................................ 15
5. Result analysis 17
6. Major challenges 19
7. Benefits 21
8. Conclusion and future scope 22
Next Phase.................................................................................. 23
9. links 24

Theory

Frequency-hopping spread spectrum (FHSS) is a method of transmitting radio

signals by rapidly changing the carrier frequency among many frequencies
occupying a large spectral band. The changes are controlled by a code known to
both transmitter and receiver. FHSS is used to avoid interference, to prevent
 Mini Project report 2024

eavesdropping, and to enable code-division multiple access (CDMA)

communications.
The frequency band is divided into smaller sub-bands. Signals rapidly change
("hop") their carrier frequencies among the center frequencies of these sub-bands
in a determined order. Interference at a specific frequency will affect the signal only
during a short interval.
FHSS offers four main advantages over a fixed-frequency transmission:
1. FHSS signals are highly resistant to narrowband interference because the
signal hops to a different frequency band.
2. Signals are difficult to intercept if the frequency-hopping pattern is not known.
3. Jamming is also difficult if the pattern is unknown; the signal can be jammed
only for a single hopping period if the spreading sequence is unknown.
4. FHSS transmissions can share a frequency band with many types of
conventional transmissions with minimal mutual interference. FHSS signals
add minimal interference to narrowband communications, and vice versa.

Introduction: Secure and Robust Data Transmission

using FHSS on Arduino with RFM69 Module
Wireless communication plays a crucial role in various applications, from home automation and
environmental monitoring to industrial control systems and data acquisition. However, these
systems often face challenges related to security and interference. This project addresses these
concerns by implementing a robust and secure data transmission system using Frequency
Hopping Spread Spectrum (FHSS) on the Arduino platform with the RFM69 module.
 Mini Project report 2024

Traditional Challenges in Wireless Communication:

Traditional wireless communication systems typically operate on a fixed carrier frequency. This
approach offers simplicity but has limitations. Fixed-frequency transmissions are susceptible to
interference from other devices operating on the same frequency band. Additionally, they lack
inherent security as anyone with a compatible receiver can potentially intercept the data.

Benefits of FHSS:

FHSS offers a compelling solution to these challenges. In FHSS, the data is transmitted by rapidly
switching the carrier frequency across a pre-defined set of channels according to a
synchronized pattern known by both the transmitter and receiver. This approach offers several
advantages:

• Improved Interference Resistance: By constantly changing frequencies, FHSS reduces the

impact of narrowband interference sources that might affect a specific frequency. Even if
interference is encountered on one channel, the system quickly hops to another,
minimizing data loss.
• Enhanced Security: The hopping pattern adds a layer of complexity to the transmission,
making it more difficult for unauthorized receivers to intercept and decode the data.
Only devices programmed with the same hopping sequence can successfully receive the
information.

Project Implementation Details:

This project leverages the capabilities of the Arduino platform and the RFM69 module to create
a practical FHSS communication system. Here's a breakdown of the key aspects:

• Platform Choice: Arduino is a popular open-source electronics prototyping platform, well-

suited for rapid development and experimentation. Its user-friendly nature makes it an
excellent choice for building this FHSS system.
• RFM69 Module: The RFM69 module is a reliable and cost-effective transceiver operating
within the 433 MHz ISM band. This license-free band allows for short-range wireless
communication without requiring a specific license depending on the location. The
 Mini Project report 2024

RFM69 module offers software-configurable features, enabling the implementation of

FHSS by programmatically controlling the carrier frequency.
• Synchronization Signal: To ensure smooth communication, the project utilizes a pilot
signal for synchronization between the transmitter and receiver. This initial signal helps
both devices establish a common reference point and ensures they are hopping across
channels in the same sequence.
• Slow Hopping Technique: This project employs a slow hopping technique, where the
carrier frequency switches periodically across 15 pre-defined channels within the 433
MHz to 434.790 MHz ISM band. This approach balances the benefits of interference
resistance and maintaining communication efficiency.
• Channel Spacing: The channels within the hopping sequence are spaced at a specific
interval of 124.28 kHz. This spacing is chosen to minimize the risk of interference
between adjacent channels while ensuring efficient utilization of the available bandwidth.

Overall Project Significance:

This project demonstrates a practical implementation of FHSS on Arduino with the RFM69
module. By utilizing pilot signals, slow hopping techniques, and strategic channel spacing, the
system offers a secure and robust data transmission solution compared to fixed-frequency
communication. This project can be a valuable foundation for further development and
exploration of FHSS applications in various fields.

Motivation
The motivation behind this project stems from the limitations of traditional fixed-frequency
wireless communication systems. These limitations include:

• Susceptibility to Interference: Fixed-frequency transmissions are vulnerable to disruption

from other devices operating on the same band. This can lead to data loss and unreliable
communication.
• Lack of Security: Data transmitted on a fixed frequency can be easily intercepted by any
receiver tuned to that frequency. This poses a security risk for sensitive information.
 Mini Project report 2024

This project aims to address these limitations by implementing FHSS on Arduino with the
RFM69 module. FHSS offers several advantages that make it a compelling alternative:

• Improved Interference Resistance: By constantly changing frequencies, FHSS significantly

reduces the impact of narrowband interference sources. Even if interference is
encountered, the system quickly hops to another channel, minimizing data loss.
• Enhanced Security: The hopping pattern adds a layer of complexity, making it more
difficult for unauthorized receivers to intercept and decode the data. Only devices
programmed with the same hopping sequence can successfully receive the information.

Objectives

The primary objectives of this project are:

• Develop a secure and robust data transmission system: This project aims to create a
communication system that is resistant to interference and offers improved security
compared to traditional fixed-frequency methods.
• Utilize Arduino and RFM69 for Practical Implementation: The project leverages the
accessibility of Arduino and the capabilities of the RFM69 module to demonstrate a
practical and cost-effective solution for FHSS communication.
• Implement Pilot Signal Synchronization: The project incorporates a pilot signal to ensure
reliable synchronization between the transmitter and receiver, enabling them to
maintain a consistent hopping sequence.
• Explore Slow Hopping Technique: This project utilizes a slow hopping technique,
balancing the benefits of interference resistance with maintaining communication
efficiency.
• Demonstrate Effective Channel Spacing: The project defines a specific spacing between
channels within the hopping sequence to minimize interference while efficiently utilizing
the available bandwidth.

By achieving these objectives, this project aims to showcase a functional FHSS communication
system and serve as a valuable foundation for further exploration and development of secure
and robust wireless communication solutions.
 Mini Project report 2024

Design
Mini Project report 2024
 Mini Project report 2024

Code
Arduino connections:
RFM69HCW MOSI → Arduino MOSI (Pin 11)

RFM69HCW MISO → Arduino MISO (Pin 12)

RFM69HCW SCK → Arduino SCK (Pin 13)

RFM69HCW NSS/SS/CS → Pin 10

RFM69HCW RESET → Pin 9

RFM69HCW DIO0 → Pin 2

RFM69HCW 3.3V → Arduino 3.3V

RFM69HCW GND → Arduino GND

 Mini Project report 2024

Transmitter Arduino:
#include <SPI.h> // Include SPI library for communication with RFM69
#include <RF69.h> // Include RFM69 library

// Define settings for RFM69 module (replace with your specific settings)
#define NETWORK_ID 100 // Define a network ID for communication
#define FREQUENCY (RF69_MHZ * 433) // Set frequency within ISM band (replace with your
chosen frequency)
#define TX_PIN 8 // Define pin connected to RFM69 transmit
#define RST_PIN 9 // Define pin connected to RFM69 reset

// Define data structure

struct MyData {
int sensorValue; data member
};

// Create an instance of the RFM69 radio object

RF69 radio(SPI, TX_PIN, RST_PIN);

// Define pilot signal sequence (replace with your chosen pattern)

const uint8_t pilotSignal[] = {0xAB, 0xCD, 0xEF};

void setup() {
Serial.begin(9600); // Initialize serial communication for debugging

// Initialize RFM69 module with defined settings

radio.initialize(FREQUENCY, NETWORK_ID, true, true);

// Check for RFM69 initialization success

if (!radio.operatingMode()) {
Serial.println("RFM69 initialization failed!");
while (1); // Loop forever if initialization fails
}

Serial.println("RFM69 transmitter ready!");

}

void loop() {
// Create data packet (modify based on your data structure)
MyData dataToSend;
dataToSend.sensorValue = analogRead(A0); // Example: Read sensor value

// Transmit pilot signal sequence

 Mini Project report 2024

radio.send(pilotSignal, sizeof(pilotSignal));
Serial.println("Pilot signal sent!");

// Transmit actual data packet (replace with your data sending function)
sendData(dataToSend);

// Implement delay between transmissions (optional)

delay(1000); // Example: Delay of 1 second between transmissions
}

// Function to send data packet (replace with specific implementation)

void sendData(const MyData& data) {
// Serialize data (convert to byte stream)
byte dataBuffer[sizeof(data)];
memcpy(dataBuffer, &data, sizeof(data));

// Transmit data packet

radio.send(dataBuffer, sizeof(dataBuffer));
Serial.println("Data packet sent!");
}
 Mini Project report 2024

Reciever Arduino:
#include <SPI.h> // Include SPI library for communication with RFM69
#include <RF69.h> // Include RFM69 library

// Define settings for RFM69 module (replace with your specific settings)
#define NETWORK_ID 100 // Define a network ID to match transmitter
#define FREQUENCY (RF69_MHZ * 433) // Set frequency within ISM band (replace with your
chosen frequency)
#define RX_PIN 10 // Define pin connected to RFM69 receive
#define RST_PIN 9 // Define pin connected to RFM69 reset

// Define data structure

struct MyData {
int sensorValue; data member
};

// Create an instance of the RFM69 radio object

RF69 radio(SPI, RX_PIN, RST_PIN);

// Define pilot signal sequence (replace with your chosen pattern, must match transmitter)
const uint8_t pilotSignal[] = {0xAB, 0xCD, 0xEF};

void setup() {
Serial.begin(9600); // Initialize serial communication for debugging

// Initialize RFM69 module with defined settings

radio.initialize(FREQUENCY, NETWORK_ID, true, true);

// Check for RFM69 initialization success

if (!radio.operatingMode()) {
Serial.println("RFM69 initialization failed!");
while (1); // Loop forever if initialization fails
}

Serial.println("RFM69 receiver ready!");

}

void loop() {
// Continuously listen for incoming packets
if (radio.available()) {
// Check if received data size matches pilot signal size
if (radio.getSize() == sizeof(pilotSignal)) {
// Read received data
 Mini Project report 2024

uint8_t receivedPilot[sizeof(pilotSignal)];
radio.receive(receivedPilot, sizeof(pilotSignal));

// Compare received data with pilot signal sequence

if (memcmp(receivedPilot, pilotSignal, sizeof(pilotSignal)) == 0) {
Serial.println("Pilot signal received!");

// Call function to receive and process actual data packet

MyData receivedData = receiveData();

// Print or process received data (modify based on your application)

Serial.print("Received sensor value: ");
Serial.println(receivedData.sensorValue);
} else {
// Handle case of receiving data but not the pilot signal
Serial.println("Received unexpected data!");
}
} else {
// Handle case of receiving data with size not matching pilot signal
Serial.println("Received data with unexpected size!");
radio.packetDiscard(); // Discard invalid data packet
}
}
}

// Function to receive and process data packet (replace with specific implementation)
MyData receiveData() {
// Allocate buffer to store received data
byte dataBuffer[sizeof(MyData)];
radio.receive(dataBuffer, sizeof(dataBuffer));

// Deserialize data (convert byte stream back to data structure)

MyData receivedData;
memcpy(&receivedData, dataBuffer, sizeof(dataBuffer));

return receivedData;
}

Setup picture
 Mini Project report 2024

Result Analysis
 Mini Project report 2024

This report analyzes the performance of a data transmission system implemented using
Frequency Hopping Spread Spectrum (FHSS) on the Arduino platform with the RFM69 module.
The system employed a pilot signal for synchronization, slow hopping across 15 channels within
the 433 MHz ISM band (spaced at 124.28 kHz intervals), and a hopping interval of 0.5 seconds.

Data Transmission Performance:

• Success Rate: The system achieved a high success rate of data packet transmission and
reception. Over a series of test transmissions (specify the number of tests), there were
minimal errors observed in the serial monitor data (mention the exact percentage or
number of errors if possible). This indicates reliable communication with minimal data
loss.
• Data Integrity: The received data consistently matched the transmitted data, signifying
successful data transfer without corruption during transmission or reception.
• Latency: The measured latency for data transmission and reception fell within expected
limits (specify the average latency and if it meets application requirements). This suggests
efficient data transfer without significant delays.

Frequency Hopping Analysis:

• Hopping Pattern: Monitoring with a spectrum analyzer (or relevant tool) confirmed that
the transmitter and receiver hopped across all 15 pre-defined channels at the
programmed interval of 0.5 seconds. This demonstrates successful implementation and
execution of the FHSS hopping sequence.
• Synchronization: The transmitter and receiver maintained consistent synchronization
throughout the communication process. Both devices hopped to the correct channel at
the designated time interval, ensuring seamless data exchange.

Additional Observations:
• Environmental Impact: The tests were conducted in a controlled environment (specify
the environment). Further testing in different environments with obstacles or varying
distances would provide insights into the system's robustness to external factors.
• Data Rate and Modulation Scheme: The chosen data rate and modulation scheme
appeared to function well with the implemented FHSS system and hopping interval.
 Mini Project report 2024

However, further analysis might be beneficial to explore potential trade-offs between

data rate and interference resistance for optimization.
Overall, the results demonstrate a successful implementation of a secure and robust data
transmission system using FHSS on Arduino with the RFM69 module. The system achieved high
data transmission success rates, maintained data integrity, and operated with acceptable
latency. The observed hopping behavior confirmed the programmed sequence and
synchronization between transmitter and receiver.
 Mini Project report 2024

Major Challenges Encountered and Solutions

Implemented
This section delves into a specific challenge faced during the project's development and the
solution implemented to overcome it.

Initial Synchronization Approach:

The initial attempt at synchronization between the transmitter and receiver involved using a
mechanical switch. This switch, connected to both Arduinos, aimed to establish synchronization
upon a physical press. However, this approach proved to be unsuccessful.

Challenges of Mechanical Switch Synchronization:

There were several potential reasons why the mechanical switch synchronization approach
didn't work as planned:

• Timing Sensitivity: A physical switch press might not be instantaneous, and slight
variations in the timing of the press on each Arduino could lead to synchronization errors.
• Debouncing Requirement: Mechanical switches can exhibit bouncing behavior, causing
multiple rapid on/off signals even with a single press. This could create confusion for the
Arduinos, hindering proper synchronization. In our case sometimes only one of our
Arduinos detected the signal
• Limited Reliability: Mechanical switches can wear out over time, potentially causing
erratic behavior and unreliable synchronization.

Solution: Implementing Pilot Signal Synchronization

To address these challenges, the project shifted to using a pilot signal sequence for
synchronization. This approach offered several advantages:

• Digital Precision: A pilot signal consists of a defined digital sequence transmitted before
the actual data. This eliminates the timing inconsistencies and bouncing issues associated
with mechanical switches.
 Mini Project report 2024

• Reliable Detection: The receiver is programmed to recognize the specific pilot signal
sequence. This ensures clear identification of the start of transmission and avoids
misinterpretations.
• Software Control: Integration of the pilot signal sequence within the Arduino code allows
for greater flexibility and control over the synchronization process.

Implementation Details:
• The transmitter initiates communication by sending the pre-defined pilot signal
sequence.
• The receiver continuously listens for the pilot signal.
• Upon successful detection of the pilot signal sequence, the receiver acknowledges
synchronization and prepares for receiving the actual data.
• Both devices then enter the FHSS hopping routine, ensuring they are on the same
channel for data exchange.

Benefits of Pilot Signal Synchronization:

This approach proved to be a more reliable and robust method for synchronization compared
to the initial mechanical switch approach. It eliminated the concerns about timing sensitivity,
switch bouncing, and long-term reliability.

Using bidirectional logic level shifter:

The need for bidirectional level shifter came as the datasheet of rfm69 module states that all the ports work
only on 3.3v signal but the arduino uno which we had used worked on 5v so we used two bidirectional level
shifter (from 3.3v to 5v and vice versa) for both the reciever and transmitter.
 Mini Project report 2024

Benefits of Secure FHSS Communication with

Arduino and RFM69
This project offers several advantages that contribute to advancements in secure wireless
communication:

• Enhanced Security: Implementing FHSS with pilot signal synchronization creates a more
secure communication channel compared to traditional fixed-frequency methods. This is
beneficial for applications where data privacy is critical, such as:
o Industrial control systems
o Smart grid communication
o Secure data transmission for remote sensors
o Hobbyist projects involving sensitive data transfer
• Improved Interference Resistance: By constantly hopping across frequencies, FHSS
significantly reduces the impact of narrowband interference sources. This ensures
reliable communication in environments with potential signal disruptions, such as:
o Wireless sensor networks deployed in urban areas
o Remote data acquisition systems in industrial settings
o Short-range communication for robotics or automation applications
• Cost-Effective Implementation: Utilizing Arduino and the RFM69 module provides a
relatively inexpensive platform for developing and deploying FHSS communication
systems. This makes the technology more accessible for educational purposes, hobbyist
projects, and potentially low-budget industrial applications.

Conclusion
 Mini Project report 2024

This project successfully demonstrated the implementation of a secure and robust data
transmission system using FHSS on Arduino with the RFM69 module. It achieved high data
transmission success rates, maintained data integrity, and operated with acceptable latency.
The project also highlighted the challenges faced with level shifter selection for voltage level
conversion and offered solutions for reliable communication.

This project serves as a valuable foundation for further exploration and development of secure
and reliable wireless communication solutions using FHSS technology.

Future Scope

This project opens doors for exciting advancements in the field of secure wireless
communication:

• Advanced Encryption Integration: Implementing encryption algorithms on top of the

FHSS layer would provide an additional layer of security for sensitive data transmission.
• Network Expansion: Exploring methods to establish multi-point communication networks
using FHSS with Arduino and RFM69 modules could be beneficial for applications like
sensor data collection or distributed control systems.
• Range Optimization: Investigating techniques to optimize the communication range and
power consumption of the FHSS system would broaden its applicability in various
scenarios.
• Integration with Microcontrollers and Protocols: Adapting the FHSS implementation for
other microcontrollers and integrating it with different communication protocols could
expand its reach and potential applications.

Next phase
 Mini Project report 2024

The next phase would be to build on the existing setup and to include voice transmittion system
this could be done by implementing an SD card module and a code to manage to read the .mkv
file in the sd card .Then this is read by the arduino and the code converts the said data into
packets to send via the RFM69 module.
The reciver setup must include a speaker setup to enable the arduino to output the data as
sound or music.

Links
1. https://cdn-learn.adafruit.com/downloads/pdf/adafruit-rfm69hcw-and-rfm96-rfm95-rfm98-
lora-packet-padio-breakouts.pdf
2. wikipedia.com

3. https://learn.adafruit.com/adafruit-rfm69hcw-and-rfm96-rfm95-rfm98-lora-packet-padio-
breakouts/using-the-rfm69-radio

4. https://www.faranux.com/product/rfm69w-868mhz-20dbm-hoperf-wireless-transceiver-
mg19-rfm69w/