Overview of communication functions in distributed IOT systems and examples of implementation

Differences between device-to-device communication technologies used in distributed and centralized IoT systems

The following describes the characteristics of each system and the differences in the inter-device communication technologies used.

Distributed IoT Systems: In a distributed IoT system, each device functions relatively independently, with individual devices collecting, processing, and making decisions about data. This architecture is suitable when real-time performance and redundancy are important.

Differences in communication technologies:

• Mesh Networks: Distributed systems require that devices form a mesh network that allows them to send and receive data directly to each other. This allows for a robust network that is not dependent on a single central point.
• Bluetooth Mesh: Bluetooth Mesh is a technology for forming mesh networks between devices in short-range communications, allowing devices to connect to each other and distribute data and control information.

Centralized IoT Systems: In centralized IoT systems, devices send data to a central server or cloud, where the data is collected, processed, and controlled. This architecture is suitable when large amounts of data need to be collected, analyzed, and controlled in a unified manner.

Differences in communication technologies:

• Wi-Fi: Wi-Fi will be the communication technology widely used in centralized IoT systems. Devices connect to a wireless LAN and communicate with a central server or cloud via the Internet.
• Cellular (LTE/5G): Cellular networks enable communication with devices over a wide geographic area and are used for integrated management of mobile and remote devices.

Device-to-Device Communication Technologies for Distributed IoT Systems

In distributed IoT systems, inter-device communication technologies are important to improve the functionality and efficiency of the overall system. Below we describe the major inter-device communication technologies used in distributed IoT systems.

MQTT（Message Queuing Telemetry Transport）

<Overview>

MQTT is a lightweight and efficient messaging protocol particularly suited for constrained network environments and for communication between IoT devices MQTT provides a mechanism to send and receive messages between devices via a message broker and employs a publish/subscribe model. IoT devices publish messages by specifying topics (publish) and subscribe to topics of interest (subscribe). The main features and principles of operation of MQTT are described below.

Main features:

• Lightweight and efficient: MQTT has a small header size and works efficiently in bandwidth-constrained network environments. This feature makes it suitable for use in IoT devices and low-bandwidth networks.
• Publish/Subscribe Model: MQTT employs a publish (publish) and subscribe (subscribe) model. Data originators (publishers) publish messages on a particular topic, and interested recipients (subscribers) subscribe to that topic to receive messages.
• Quality of Service (QoS) Level: MQTT allows the user to choose the Quality of Service (QoS) level of the message. QoS 0 sends the message once and does not wait for confirmation; QoS 1 confirms receipt after the message is sent and retransmits the message if necessary; QoS 2 ensures that the QoS 2 guarantees message delivery and prevents duplicate transmissions.
• Topic-based messaging: MQTT uses topics to identify messages. Topics have a hierarchical structure and help associate messages with specific categories or themes.
• Persistent connections: MQTT clients establish persistent connections with brokers. This allows messages to be held for later processing even if the device goes offline or reconnects.
• Security support: MQTT supports security features such as username and password authentication, encryption using TLS/SSL, and access control.

HOW IT WORKS:

• Client: MQTT clients are responsible for publishing messages (publishers) and subscribing to topics (subscribers).
• Broker: The MQTT broker acts as an intermediary for messaging between clients. Messages issued by a client are delivered to other clients through the broker.
• Topic: A topic is a label that identifies a message category or subject. The topic structure is hierarchical, with hierarchical names separated by slashes (/).
• QoS Level: The client specifies the Quality of Service (QoS) level of the message; depending on the QoS level, the message is guaranteed to arrive reliably.

MQTT is widely used for communication between IoT devices and for sending and receiving real-time data, and its lightweight and efficiency will make it a technology of particular interest.

<Example of Implementation>

The following is a basic implementation of MQTT.

Example implementation of MQTT using Python:.

To implement an MQTT client using Python, it is common to use the library paho-mqtt. First, install the library.

Next, the following is an example Python script. This example shows how to connect to an MQTT broker to publish a message to a topic and subscribe to a message from a topic.

In this example, the on_connect callback is used to subscribe to a topic after connecting, and the on_message callback is used to process the received messages.

When this script is executed, it can connect to the specified MQTT broker and send and receive messages.

For actual use, the host name and port number of the broker must be properly configured, and for security reasons, security features such as authentication and TLS must also be properly considered in the actual system.

CoAP（Constrained Application Protocol）

<Overview>

CoAP will be a lightweight application protocol designed to work with constrained devices (resource-constrained IoT devices) and network environments. CoAP provides a RESTful communication model like HTTP and supports resource creation, read, update and delete (CRUD operations). The main features and working principles of CoAP are described below.

Main Features:

• Lightweight protocol: CoAP provides functions similar to the HTTP protocol while minimizing header size for efficient communication. This allows it to work efficiently on bandwidth-constrained networks and resource-constrained devices.
• RESTful architecture: CoAP is based on the Representational State Transfer (REST) architecture and adopts a resource-oriented approach. Devices and resources are represented by URIs and manipulated using methods such as GET, POST, PUT, and DELETE.
• Resource-oriented: In CoAP, devices and resources have their own URIs, each representing their state and function. Resources have their own attributes to help represent device state and operations.
• Low Power Consumption: CoAP is optimized for power efficient communication by IoT devices. It supports transitions from active to sleep mode and communication in low-power modes.
• Acknowledgement Mechanism: CoAP provides an acknowledgement mechanism for messages, which is used when reliable message delivery is required. This can address communication errors and packet loss.

HOW IT WORKS:

• Methods: CoAP supports operations similar to HTTP methods: the GET method can be used to retrieve the state of a resource, and the PUT method can be used to update the state of a resource.
• Resource Discovery: CoAP uses the URI of a resource to identify it. Browsing and resource discovery are the methods used to locate the resources that a device has.
• Communication: CoAP is a communication protocol based on UDP, but includes features such as an acknowledgement mechanism and block forwarding. This allows for reliable communication in small packets.
• Transaction: CoAP supports a transaction model, which associates a request for communication with a response. This improves message reliability.

CoAP is a protocol for efficiently communicating and concisely expressing the resources of IoT devices. It is suitable for communication in low-bandwidth and low-power environments, and is a method used by many IoT platforms and devices.

<Example Implementation>

As an example of CoAP implementation, we describe how to implement a CoAP client and server using Python. The following is an example using a Python library called aiocoap.

Example of CoAP client implementation using aiocoap:

First, install the aiocoap library.

The following is an example of a CoAP client.

import asyncio
from aiocoap import *

async def main():
    protocol = await Context.create_client_context()

    request = Message(code=GET)
    request.set_request_uri('coap://[::1]/hello')

    try:
        response = await protocol.request(request).response
        print('Response code:', response.code)
        print('Payload:', response.payload.decode('utf-8'))
    except Exception as e:
        print('Failed to fetch resource:', e)

if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(main())

This script sends a GET request to the /hello resource on [::1] (IPv6 localhost) and displays the response.

Example implementation of a CoAP server using aiocoap:

The following is an example of a CoAP server.

import asyncio
from aiocoap import *

class HelloWorldResource(resource.Resource):
    async def render_get(self, request):
        return Message(payload=b"Hello, CoAP!")

def main():
    # Create root resource
    root = resource.Site()
    root.add_resource(['hello'], HelloWorldResource())

    # Create server context
    asyncio.Task(Context.create_server_context(root, bind=('::1', 5683)))

    asyncio.get_event_loop().run_forever()

if __name__ == "__main__":
    main()

This script starts a CoAP server on [::1]:5683 (IPv6 localhost) and returns a “Hello, CoAP!” response to a GET request for the /hello resource.

DDS（Data Distribution Service）

<Overview>

DDS will be a communication protocol and middleware standard for distributed distribution and sharing of data in real-time. DDS provides advanced data publishing and subscribing, data quality control, security, and other functions, and is widely used especially in control systems, embedded systems, real-time DDS is designed for fast and reliable sharing of data between different devices and applications.

The following is a detailed description of the main features and operating principles of DDS.

Key Features:

• Producer-consumer model: DDS employs a model where data is exchanged between a producer (data sender) and a consumer (data receiver). Data is published to a channel called Topic, and consumers who subscribe to the Topic are the recipients of the data.
• Real-Time: DDS specializes in real-time data delivery and processing. Data is sent and received with low latency, ensuring that data reaches the recipient in an up-to-date state.
• Data-centric: DDS adopts a data-centric approach, where the structure and semantics of the data are defined and applications communicate based on the content of the data.
• Publisher-subscriber: DDS supports direct communication between producers and consumers, while using a producer-consumer model for asynchronous and distributed communication.
• Flexible Topologies: DDS supports flexible topologies involving multiple producers and consumers. Topologies such as peer-to-peer, publisher-subscriber, and relational are possible.
• Security: DDS provides security features and meets security requirements such as data encryption, authentication, and access control.

Principle of Operation:

The DDS architecture consists of the following elements: data producers, data consumers, brokers, and topics.

• Data Producer: A data producer generates data and publishes data to a topic.
  Data Consumer: A data consumer subscribes to a topic, receives data, and processes it.
• Broker: The DDS relays and routes data through a broker. While data producers and data consumers communicate directly, they can also pass data through brokers.
• Topic: A topic represents a category or theme of data and delivers data to a recipient.

DDS is supported by many middleware platforms and can be a communication method that facilitates data sharing and collaboration between different vendors and applications.

<Implementation>

DDS has been implemented by a variety of vendors and middleware platforms, each with different implementations. The following is an example implementation using Eclipse Cyclone DDS, an open source DDS implementation.

Example DDS implementation using Eclipse Cyclone DDS:

Eclipse Cyclone DDS is an open source implementation of DDS and is used for real-time data distribution and sharing. Follow the steps below to implement a simple Pub-Sub (publisher-subscriber) application using Cyclone DDS.

1. Installation of Cyclone DDS:

First, install Cyclone DDS. The Python wrapper library for Cyclone DDS can be installed using the following command

pip install pyDDS

2. Implementation of Pub-Sub applications:

The following is an example of a simple Pub-Sub application. In this example, one process publishes the message and the other process subscribes to the message.

This script implements a publisher and a subscriber using two threads. The publisher periodically sends messages and the subscriber receives and displays the messages.

Use in actual applications requires proper setup, data definition, error handling, and configuration. In addition, implementations other than Cyclone DDS exist, so it is important to choose one that fits the environment.

Bluetooth / Bluetooth LE

<Overview>

Bluetooth and Bluetooth Low Energy will be widely used short-range communication technologies. These technologies enable smart devices and sensors to communicate directly with each other and are used in smart homes and wearable devices.

Bluetooth and Bluetooth Low Energy (BLE) are wireless communication technologies and communication methods used to enable data communication and connectivity over short distances. These technologies allow smart devices and sensors to communicate directly with each other and are widely used in a variety of devices, including cell phones, smartphones, personal computers, wearable devices, and smart home devices. The main features of Bluetooth and Bluetooth LE are described below.

Bluetooth:

Bluetooth is a short-range wireless communication technology that enables data exchange and connections between devices. The main features are as follows

• Coverage: Bluetooth typically has a range of approximately 10 meters (Class 2 devices) to 100 meters (Class 1 devices). The range depends on the device class and environment.
• Data transfer rate: Bluetooth data transfer rates vary depending on the device version; the latest version of Bluetooth 5 supports data transfer rates of up to approximately 2 Mbps.
• Power Consumption: Power consumption is generally high when communicating, but power is conserved by turning off communication when the transfer is complete.
• Uses: Bluetooth is used for voice calls, music streaming, file transfers, keyboard and mouse connections, wireless headphones, and many other applications.

Bluetooth Low Energy (BLE):

BLE is a low-power communication technology introduced in Bluetooth version 4.0 and later, and is widely used in IoT devices and wearable devices, among others. The main features are as follows

• Communication range: BLE also has a communication range of about 10 meters in general, but the range can be adjusted to save power.
• Data transfer rate: BLE emphasizes low power consumption and has a relatively low data transfer rate. Typical data rates are less than 1 Mbps.
• Power consumption: BLE operates at very low power consumption and saves as much power as possible by allowing nodes to go to sleep. This makes it suitable for power-saving applications such as mobile devices and sensor networks.
• Applications: BLE is suitable for power-constrained applications such as sensor data transmission, wearable devices, beacons (location information transmission), health monitoring, and IoT devices.

Bluetooth is used for a wide range of communication applications, while BLE is particularly suited for power-saving IoT and sensor applications, making both short-range communication technologies the communication method of choice for many devices.

<Implementation>

Examples of Bluetooth and Bluetooth Low Energy (BLE) implementations are described below.

Bluetooth Implementation Example:

As an example of Bluetooth implementation, we show how to use Python to perform Bluetooth communication. The following example is a simple console application that sends and receives text messages between devices using Bluetooth communication.

import bluetooth

# Find your device
target_device = None
nearby_devices = bluetooth.discover_devices(lookup_names=True)
for addr, name in nearby_devices:
    if "Target_Device_Name" in name:
        target_device = addr
        break

if target_device:
    print(f"Found target device: {target_device}")
    port = 1  # communication port
    sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    sock.connect((target_device, port))
    
    while True:
        message = input("Enter a message to send (or 'exit' to quit): ")
        if message == 'exit':
            break
        sock.send(message)
        print("Message sent!")

    sock.close()
else:
    print("Target device not found.")

In this example, a Bluetooth device is searched for, and when the target device is found, the RFCOMM channel is used to send and receive messages.

Bluetooth LE Implementation Example:

As an example of BLE implementation, we show how to use Python to perform BLE communication. The following example is a simple console application that uses Bluetooth Low Energy to send and receive sensor data between devices. Here, the bluepy library is used for BLE communication.

First, install the bluepy library.

pip install bluepy

Next, the following is an example of BLE communication implementation.

from bluepy import btle

class MyDelegate(btle.DefaultDelegate):
    def __init__(self):
        btle.DefaultDelegate.__init__(self)

    def handleNotification(self, cHandle, data):
        print(f"Notification received: {data.decode()}")

peripheral = btle.Peripheral("Device_MAC_Address")
peripheral.setDelegate(MyDelegate())

try:
    service_uuid = btle.UUID("Service_UUID")
    characteristic_uuid = btle.UUID("Characteristic_UUID")
    
    service = peripheral.getServiceByUUID(service_uuid)
    characteristic = service.getCharacteristics(characteristic_uuid)[0]

    while True:
        user_input = input("Enter a message to send (or 'exit' to quit): ")
        if user_input == 'exit':
            break
        characteristic.write(user_input.encode())
        print("Message sent!")

    peripheral.disconnect()
except Exception as e:
    print(f"Error: {e}")
    peripheral.disconnect()

In this example, a BLE device is connected to send and receive messages using a specified service and a characteristic.

Zigbee

<Overview>

Zigbee is a low-power communication protocol and a communication method suitable for building wireless sensor networks, which enables device-to-device communication in smart homes and sensor networks for industrial applications.

Zigbee is a combination of communication technologies and protocols used for wireless communications such as wireless sensor networks and local area networks (LAN). It is primarily suited for Internet of Things (IoT) applications that require low power consumption, short-range communications, connections to a large number of devices, and the construction of mesh networks. The features of Zigbee are described below.

Key Features

• Low power consumption: Zigbee emphasizes energy-efficiency in devices and is suitable for battery-powered devices and sensors, supporting sleep mode and low-power communication.
• Short range communications: Zigbee offers short range communications, typically 10 to 100 meters, which makes it ideal for communications within a specific area.
• Mesh Networks: Zigbee allows for the creation of mesh networks. This is a feature that allows many devices to connect to the same network and relay data. Mesh networks are useful for covering large areas.
• Self-configuration: Zigbee devices will automatically work with other devices in the network to self-configure the network. If a device is added or removed, the network is automatically reconfigured.
• Security: Zigbee uses Advanced Encryption Standard (AES) encryption to ensure data security. It also supports authentication and data encryption between devices.

Application Area:

Zigbee is used in a variety of applications

• Smart Home: It allows devices such as lighting, temperature control, and security cameras to communicate with each other to create a smart home.
• Industrial Control: Used to monitor and control sensors, actuators, and equipment in factories.
• Healthcare: Medical devices and health monitoring devices are working together to transmit data to enable real-time healthcare.
• Environmental monitoring: Air quality sensors and weather monitoring devices work together to collect environmental data.

Zigbee is based on the IEEE 802.15.4 standard and can be customized for different profiles and application uses, making it a suitable communication method for a wide range of applications.

<Example Implementation>

As an example of Zigbee implementation, we show how to use Python to perform Zigbee communication. The following example is a simple console application that uses the Python library “PyZigbee” to send and receive messages between Zigbee devices.

First, install the PyZigbee library.

pip install pyzigbee

Next, the following is an example implementation of Zigbee communication.

from pyzigbee import Zigbee

def main():
    port = "/dev/ttyUSB0"  # Replace with the name of the serial port to be used
    baud_rate = 9600
    zigbee = Zigbee(port, baud_rate)
    
    try:
        while True:
            user_input = input("Enter a message to send (or 'exit' to quit): ")
            if user_input == 'exit':
                break
            zigbee.send_message(user_input)
            print("Message sent!")

            received_message = zigbee.receive_message()
            print("Received:", received_message)
    except KeyboardInterrupt:
        pass
    finally:
        zigbee.close()

if __name__ == "__main__":
    main()

In this example, a serial port is used to connect a Zigbee device to send and receive messages. Messages entered by the user into the console are displayed at the receiving end after transmission.

Use in actual applications requires detailed configuration of device settings, communication protocols, and security. In addition, when using actual Zigbee devices, communication must be performed according to the corresponding libraries and APIs.

LoRaWAN（Long Range Wide Area Network）

<Overview>

LoRaWAN (Long Range Wide Area Network) will be a wireless network technology that combines wireless communication technology and protocols to enable wide-area communication over long distances. Because of its low power consumption and long-distance communication, it is mainly suited for applications such as IoT (Internet of Things) devices and sensor networks for agriculture, urban monitoring, and environmental monitoring, and is characterized by its ability to achieve power-saving communication over a wide range.

The features of LoRaWAN are described below.

Main features:

• Long-range communications: LoRaWAN enables communications over a wide range of several kilometers to several tens of kilometers. This allows devices to communicate over a wide area, including farmland, urban areas, and industrial regions.
• Power savings: LoRaWAN is optimized to allow devices to transmit data without having to switch from dormant to communication mode. This makes it a suitable communication method for battery-powered devices and sensors.
• Mesh Networks: LoRaWAN has the ability to create mesh networks. Devices relay data to and from other devices, thus extending the communication range.
• Spectrum efficiency: LoRaWAN uses a modulation scheme called Chirp Spread Spectrum (CSS) to improve spectrum efficiency. This allows for efficient data transmission even in situations where multiple devices can communicate simultaneously.
• Security: LoRaWAN supports data encryption and authentication for enhanced security. This protects communications between devices and the network.

Architecture and Mechanisms:

The architecture of LoRaWAN consists of end devices, gateways, network servers, and application servers.

• End devices: These include devices such as sensors and actuators. They collect data and send it to the gateway.
• Gateway: The gateway relays communications between the end device and the network server. It receives data sent by the end device and forwards it to the network server.
• Network server: The network server performs data management, authentication, and encryption. It controls communication between the end device and the application server.
• Application servers: Application servers receive data sent from end devices and perform appropriate application processing. This includes data analysis and notification.

LoRaWAN devices are classified as end devices and gateways, and data is communicated according to the LoRaWAN architecture.

Application Areas:

LoRaWAN will be used in the following application areas

• Agriculture: field monitoring, irrigation management, environmental monitoring.
• Smart Cities: Trash can fullness monitoring, parking lot availability information, urban infrastructure management.
• Industrial: manufacturing process monitoring, asset tracking.
• Environmental: water quality monitoring, air quality monitoring.

<Implementation>

As an example of LoRaWAN implementation, we describe how to use an Arduino board for LoRaWAN communication. This example shows how to use an Arduino and a LoRa module to connect a device to a LoRaWAN network and transmit data.

Implementation instructions:

1. Preparing Hardware:
   • Arduino boards (e.g. Arduino Uno)
   • LoRa module (e.g. Dragino LoRa Shield)
   • Sensors and actuators (any device)
   • USB cable (for programming and powering the Arduino board)
2. Install libraries: Open the Arduino IDE and install the following libraries.
   • LMIC (LoRaWAN-MAC-in-C)
   • Arduino-LoRa (library for LoRa modules)
3. LoRaWAN application configuration: Create an account on the LoRaWAN network server and application server to obtain configuration information such as the device’s application key and device address.
4. Create an Arduino sketch: Using the Arduino IDE, create a sketch like the following

This sketch uses the LMIC library to connect the device to the LoRaWAN network and periodically send messages.

5. Programming and Testing:
   • Using the Arduino IDE, write the above sketch to the Arduino board.
   • Connect the device to the LoRaWAN network and send data to it.

The actual project will include setting up the LoRaWAN network, setting up the application server, and designing the device’s sensor data and communication protocol. In addition, it is important to refer to official documentation and tutorials, as specific implementation details vary depending on the hardware and libraries used.

5th Generation (5G) Network

<Overview>