How to Use AI Classification to Build More Efficient Apps
Karran Besen | Sep 05, 2024
In the world of Internet of Things (IoT) development, projects involve intricate interactions between hardware devices and software applications. These projects range from simple devices with basic functionality to complex systems with advanced features.
Effective communication protocols ensure seamless interaction between these components, facilitate data exchange, and enable devices to perform their intended functions.
To better understand how different communication protocols work, we’ll explore two distinct IoT projects(A and B):
- Project A is more straightforward, focusing on tasks like turning on/off target devices and monitoring battery levels.
- Project B is more complex, involving sophisticated communication between devices and applications.
In this post, we’ll look at the specific challenges each project presented and examine the communication protocols the Cheesecake Labs team used to overcome these challenges.
This post primarily focuses on analyzing the best approach to sharing data between devices by a predefined protocol after establishing a Bluetooth connection between the mobile application and the device.
We hope this will provide a deeper understanding of the nuances of selecting and implementing communication protocols in IoT projects.
Understanding why communication protocols are so important in IoT projects
Understanding the importance of communication protocols is essential in the IoT realm. These protocols form the backbone of communication, ensuring data is transmitted, interpreted, and acted upon reliably and efficiently.
Robust communication protocols guarantee IoT systems run smoothly and stay secure — both essential for effectiveness and success.
Here’s how things played out in both projects.
Project A: Simple protocols presented challenges
Project A focused on a device with basic functions using Bluetooth connectivity. This included things like turning on/off the target device and battery monitoring.
Its communication protocol was straightforward, with data transmitted in a simple format: a list of integers. This simplicity made the protocol easy to implement and understand because the data could be parsed quickly.
Plus, this kind of simple communication protocol is helpful when dealing with Bluetooth Low Energy (BLE) devices that communicate with a Satellite modem or LORA. The packet size for these devices is very limited, just a few bytes, so having simple protocols that send as few bytes as possible is a benefit.
However, this simplicity also posed challenges. Since all information was encapsulated in a single list of integers, adding new features or accommodating different data types became complicated.
Plus, in the case of communication errors, identifying the source of the problem was challenging. Diagnosing errors and pinpointing their origins became cumbersome with only the list of values received. This limitation highlighted the need for a more robust error-handling mechanism to enhance the protocol’s reliability and effectiveness.
The absence of over-the-air (OTA) updates also posed significant challenges. With the firmware embedded in the device, software updates became impractical without creating entirely new devices with newer versions.
This limitation not only slowed the project’s agility but also raised concerns regarding security vulnerabilities. Without the ability to patch vulnerabilities promptly, the project became susceptible to potential security breaches. The inability to introduce new features or adapt to evolving requirements also limited the project’s scalability and longevity.
While the simplicity of the hardware in Project A may lead to lower initial costs, it’s essential to consider the potential need to generate new hardware versions in the future due to the absence of over-the-air (OTA) updates.
This consideration highlights the importance of evaluating the trade-offs between hardware costs and the project’s long-term adaptability and sustainability.
Project B: Complex communication protocols made for easy functionality
In contrast, Project B had a more complex setup. It featured a predefined communication protocol, where each data packet adhered to a specific format.
The packets are made of a header and a payload. The information in the header is used by networking hardware to direct the packet to its destination, where the payload is extracted and used by an operating system and application software.
The protocol payload included an operation field named “OP” to denote the type of operation being executed, with the remaining packet subject to alteration based on the “OP” value. This structure facilitated future improvements and the addition of new features.
For example, introducing new functionality only required adding more cases to the “OP” field, making the protocol inherently scalable and adaptable to evolve as the project needs.
Plus, Project B employed a specific response code for error handling. For each data packet sent with the operation field by the mobile application, the device would return an object with the “OP” corresponding to the response type and a value indicating whether the operation was successful or failed.
This approach to error handling ensured robust and reliable communication between the mobile application and the device, enhancing the overall functionality and usability of the system.
One remarkable aspect of Project B was its capability for OTA updates. Through the Bluetooth connection, we could send network credentials to the device, enabling it to connect to the internet.
Then, we could transmit a URL via Bluetooth from which the device would download the latest software version, allowing for easy and efficient updates without the need for physical intervention or creating new hardware.
Including a checksum for data integrity
To ensure data integrity, each packet was accompanied by a checksum, which validated the transmission message. The checksum serves as a mechanism for ensuring the integrity of transmitted data rather than as a means of security or authentication. It is used solely for file integrity purposes.
In Project B the checksum calculation function is implemented to calculate the checksum for a 32-bit integer by summing up the individual bytes.
The function computes the overall checksum for the dataset by iterating through its elements, converting strings to bytes, and applying the appropriate calculation based on the data type.
The checksum calculation function operates by iterating through the bytes of the dataset. It starts by initializing a result variable with a value of 0 and then sums the bytes sequentially.
or each byte, it shifts the bits to isolate the relevant bits and applies a bitwise AND operation to ensure that only the 8 least significant bits are considered.
Finally, it returns a result modulo 256 to ensure the checksum fits in a single byte, giving a value between 0 and 255, and when the value is a string, the function converts that string into bytes, sums those bytes, and returns the result of the sum. This helps verify whether the data has been transmitted correctly and remains intact.
This systematic approach ensures data integrity by creating a unique checksum value for each dataset, allowing for easy verification of data integrity during transmission and reception.
By summing up the bytes, the function captures the essence of the dataset’s contents and creates a compact representation that can be verified.
Checksum examples:
int generateChecksum(Map<String, dynamic> dataset) {
int total = 0;
dataset.forEach((key, value) {
if (value is String) {
List<int> bytes = utf8.encode(value);
total =
total + bytes.fold(0, (previous, current) => previous + current);
} else {
int result = 0;
result += (32bitNumber >> 24) & 0xFF;
result += (32bitNumber >> 16) & 0xFF;
result += (32bitNumber >> 8) & 0xFF;
result += 32bitNumber & 0xFF;
total = total + result;
}
});
return total % 256;
}
{
"OP": 1,
"field_1": 2,
"field_2": 0,
"field_3": 0,
"field_4": 2,
"field_5": 0,
"field_6": 2,
"field_7": 222,
"checksum": 229
}
{
"OP": 11,
"field_8": "{'field_A': 1, 'field_B': '1997-12-26T00:00:00.000000'}",
"field_9": "some_string_value",
"checksum": 105
}Code language: Dart (dart)Project A vs. Project B: Simplicity vs. complexity
While Project A underscored the importance of error handling and flexibility in data transmission, Project B showcased the benefits of a predefined protocol with scalability and reliability.
For example, in Project A, where data arrived in a single list of integers, the simplicity of the protocol facilitated initial development. However, this simplicity also led to challenges in accommodating new features or handling different data types.
Consider a scenario where the project requires the addition of a new sensor that provides data in different formats.
Without a flexible protocol, integrating this sensor would require significant restructuring of the existing codebase, potentially leading to delays and compatibility issues. This process can lead to additional manufacturing costs and logistical complexities.
For example, if the device needed a critical firmware update to address a security vulnerability, the entire production line would need to be retooled to accommodate the new version, leading to potential delays and increased expenses.
In contrast, Project B’s predefined protocol offered scalability and reliability. For example, imagine a scenario where Project B needs to integrate a new device with different functionalities.
Despite potentially higher initial hardware costs due to the inclusion of additional components such as BLE and WiFi antennas, the ability to update the firmware over the air provides significant advantages.
With OTA updates, the firmware could be easily modified and deployed to devices already in the field, minimizing downtime and reducing the need for costly hardware replacements.
For example, if a firmware update was required to introduce new features or address security vulnerabilities, it could be seamlessly distributed to all devices, ensuring consistent performance and enhancing overall reliability.
These examples prove that choosing the right communication protocol is essential for success in IoT projects.
Finding the right communication protocols for your IoT projects
Both projects underscored the critical role of communication protocols in facilitating seamless interaction between devices and applications.
While Project A was all about simplicity in data transmission, it also showed the importance of error-handling mechanisms for enhanced efficiency.
On the other hand, Project B showcased the necessity of predefined protocols and data validation techniques for complex projects, emphasizing data integrity and reliability.
The flexibility of Project B’s protocol made it easier to adapt to future improvements and new features, demonstrating the importance of well-designed communication protocols in addressing technological innovation challenges.
This adaptability ensures the project can evolve along with changing requirements and technological advancements, staying relevant and competitive in the market.
It’s also worth noting that the teams responsible for developing IoT mobile applications and the teams responsible for developing IoT devices need to communicate effectively.
Seamless collaboration ensures that the communication protocols align with the project requirements and that any issues are addressed promptly, ultimately contributing to the solution’s successful development and deployment.
As technology evolves rapidly, it’s key to remain vigilant and proactive in planning project structures. Anticipating future needs and potential challenges allows teams to create robust and scalable solutions that can withstand the test of time.
Plus, staying up-to-date on emerging technologies and industry trends enables teams to leverage new opportunities for innovation and improvement.
Understanding and adapting communication protocols remain essential to overcoming project challenges and delivering innovative solutions in the ever-evolving technology landscape.
Projects can thrive in an increasingly dynamic and competitive environment by prioritizing effective communication, flexibility, and forward-thinking planning.
How to ensure your IoT communication protocols lead to success
As developers navigate the complexities of IoT development, it’s essential to continually evaluate and refine our communication protocols to ensure optimal performance, scalability, and reliability.
Whether you’re embarking on a new IoT project or refining an existing one, consider the following actions:
- Assess your communication protocols: Take stock of the communication protocols used in your IoT project. Are they flexible enough to accommodate future changes? Do they provide the necessary reliability and security?
- Explore OTA update capabilities: Investigate the possibility of implementing OTA updates in your project. While initial hardware costs may be higher, the long-term benefits of OTA updates (specifically flexibility and cost savings) can outweigh the initial investment.
- Collaborate across teams: Foster collaboration between hardware and software development teams to ensure communication protocols align with project requirements and goals. By working together, teams can identify potential challenges early on and develop practical solutions.
- Stay informed: Stay updated on the latest developments and best practices in IoT communication protocols. Attend industry conferences, participate in forums, and engage with peers to exchange ideas and insights. You can dive deeper into IoT development and communication protocols with these great resources:
Learn more about how we tackle development challenges
At Cheesecake Labs, we’re always looking for ways to improve the development process. If you’re interested in learning more about how we approach development challenges, be sure to check out our other posts on the Cheesecake Labs blog.
About the author.
