SimpleComm library for Raspberry Pi PLC

How to install SimpleComm for Raspberry Pi PLC?

SimpleComm usage

To store data in a packet you can use the setData function, which supports a wide range of data types, including bool, char, unsigned char, int, unsigned int, long, unsigned long, double, string, and even custom data types. Additionally, the SimplePacket class includes "getter" functions designed to retrieve the data stored within the packet, catering to specific data types. If maximum length is specified, it returns the data length in bytes.

The SimpleComm singleton is the interface for sending and receiving packets through the desired data stream. The communication system is initiated and configured using the begin(address) function. This function not only activates the communication process but also establishes a unique identifier or address for each device. Each device has its own unique address, allowing it to selectively receive packets destined for its address, while disregarding packets meant for other devices. This address-based mechanism ensures secure and efficient data exchange within the system. 

The following methods can be used to send a packet to a destination:

	​SimpleComm.send(stream, packet, destination);

	SimpleComm.​send(stream, packet, destination, type);

The function also accepts a packet type, which serves the purpose of informing the receiver about how to interpret and read the contents of the packet accurately.

The receive function is responsible for fetching a packet from another device through the designated stream:

	SimpleComm.​r​eceive(stream, rxPacket);

If a packet is indeed received, the function returns true, indicating successful reception; otherwise, it returns false.

What is Stream class?

The Stream class is fundamental for communication in Arduino, as it is an abstraction that allows standardised handling of data streams across different communication interfaces. Because SimpleComm was designed for Arduino, it relies heavily on the Stream Class as its core communication abstraction. To make the library compatible with Linux and retain its functionality seamlessly, we focused on adapting the Stream class from the Arduino world into the Linux world.

Basically, the Stream class is an abstract class that implements three virtual functions:

• std::size_t write(const uint8_t* data, std::size_t count)

• int read(void)

• std::size_t available(void)

These functions have the same signature as the ones used by the Stream Class, so the SimpleComm library can use all the derived classes from it without any modifications.

FileStream: Elevating file communication with advanced stream capabilities  

The FileStream class is a specialized class that extends the capabilities of the Stream class, specifically designed to implement essential functions like "write()", "read()", and "available()" for C++ fstream objects. This adaptation enables users to use file-based communication methods, such as pipes (IPC) or other devices like UART and RS-485.

A FileStream object can be created using either a C-String or a String Object that contains the name of the file:

FileStream stream = FileStream("/dev/ttySC0");

// ...

// ...

uint8_t destination = 0;

SimpleComm.send(stream, packet, destination);

SockStream: Enhancing network communication with Stream class extension

SockStream is a specialized class that extends the Stream class to implement the "write()", "read()", and "available()" functions for C Sockets. This class makes possible using SimpleComm with sockets, like for example TCP/IP or UNIX sockets.

A SockStream object can only be created using the socket file descriptor:

int socket_desc = socket(AF_INET, SOCK_STREAM, 0);

// connect(...)

SockStream stream = SockStream(socket_desc);

// ..

uint8_t destination = 0;

SimpleComm.send(stream, packet, destination);

Compatibility between architectures

This library relies on standard C++ types (e.g., unsigned long, int), which can function correctly if the communicating architectures maintain consistent type sizes. However, problems may arise if you try to communicate different CPU architectures, such as ESP32 and Raspberry. The C++ types that are defined in each architecture have different sizes, which will cause communication errors.

To ensure proper communication between different architectures and to address potential type size issues, the library provides a solution through the "SimplePacketConfig.h" header file. This file allows users to customize the types used in the library, thereby fixing the size of the types for proper communication:

• If you uncomment "#define UNIVERSAL_CPP" the types used will be the minimum size according to the C++ standard.
• If you uncomment "#define CUSTOM_TYPES", the types used will be the size of what you define.