SerialDataLink

SerialDataLink is a half-duplex serial - "variables transfer" library for Arduino, designed for efficient and reliable, automatic transmission of int16 variables between controllers. It uses a non-blocking, polling-based approach, suitable for scenarios that require continuous monitoring and variable data transfer.

Features

Half-Duplex Communication: Allows half duplex bidirectional data transfer.
Non-Blocking Operation: Uses a polling mechanism for data handling.
Error Checking: Incorporates transmission and reception CRC16 data and framing error checks.
Flexible Data Handling: Transmits only the variables which values have change or reached update time..

Example

#include <SerialDataLink.h>

HardwareSerial Serial2(PA3, PA2); // RX, TX
HardwareSerial Serial3(PB11, PB10); // RX, TX


#define PRIMARY_VARS_SEND     20
#define SECONDARY_VARS_SEND   5

#define PRIMARY_VARS_RECV     SECONDARY_VARS_SEND
#define SECONDARY_VARS_RCV    PRIMARY_VARS_SEND

//                                              /*     Sending Vars       Receiving Vars */
// Create two instances of SerialDataLink
SerialDataLink dataLinkPrimary(Serial2, 0x01 ,0 ,    PRIMARY_VARS_SEND ,  PRIMARY_VARS_RECV);
SerialDataLink dataLinkSecondary (Serial3, 0,  0x01, SECONDARY_VARS_SEND ,SECONDARY_VARS_RCV);

#define LED   PC13

void setup() {
  Serial.begin(115200);    // Start the Serial Monitor
  Serial2.begin(9600); // Initialize Serial2 for transmission
  Serial3.begin(9600); // Initialize Serial3 for reception

  pinMode(LED,OUTPUT);



  // Initialize data to be sent
  for (uint8_t i = 0; i < PRIMARY_VARS_SEND; i++) {
    dataLinkPrimary.updateData(i, 3+i*3 ); // Example initial values
  }
  for (uint8_t i = 0; i < SECONDARY_VARS_SEND; i++) {
    dataLinkSecondary.updateData(i, 10 + i*5 ); // Example initial values
  }
}


void loop() {
  // Update data every second
  
  static unsigned long lastUpdate = 0;
  static unsigned long lastCycle = 0;

  
  if (millis() - lastUpdate >= 3000) 
  {
    digitalToggle(LED);
    Serial.println("Hello from stm32F105");
    lastUpdate = millis();
    for (uint8_t i = 0; i < PRIMARY_VARS_SEND; i++) {
      dataLinkPrimary.updateData(i,i*20 /*random(100)*/); // Update with random values
    }
    for (uint8_t i = 0; i < SECONDARY_VARS_SEND; i++) {
      dataLinkSecondary.updateData(i,100+i*50 /*random(100)*/); // Update with random values
    }
  }

  // Run transmit and receive methods every millisecond
  
  static unsigned long lastMillis = 0;
  static unsigned long last100Millis = 0;
  
  if (millis() != lastMillis ) 
  {
    lastMillis = millis();
    /*
    *    run() should be polled at about the serial bit rate 
    */
    dataLinkPrimary.run();
    dataLinkSecondary.run();
  }  

  if (millis() - last100Millis >= 100) 
  {
    last100Millis = millis();
    bool sendError = dataLinkPrimary.checkTransmissionError(true);
    if (sendError) Serial.println("SEND error - Primary");
    bool readError = dataLinkSecondary.checkReadError(true);
    if (readError) Serial.println("read error - Secondary");

    sendError = dataLinkSecondary.checkTransmissionError(true);
    if (sendError) Serial.println("SEND error - Secondary");
    readError = dataLinkPrimary.checkReadError(true);
    if (readError) Serial.println("read error - Primary");
  }

   //Check for received data
  if (dataLinkSecondary.checkNewData(true)) 
  {
    Serial.println("New data received: Secondary");
    for (uint8_t i = 0; i < SECONDARY_VARS_RCV; i++) 
    {
      Serial.print("Index ");
      Serial.print(i);
      Serial.print(": ");
      Serial.println(dataLinkSecondary.getReceivedData(i));
    }
  }
  if (dataLinkPrimary.checkNewData(true)) 
  {
    Serial.println("New data received: Primary");
    for (uint8_t i = 0; i < PRIMARY_VARS_RECV; i++) 
    {
      Serial.print("Index ");
      Serial.print(i);
      Serial.print(": ");
      Serial.println(dataLinkPrimary.getReceivedData(i));
    }
  }
}

Constructor

`SerialDataLink(Stream &serial, uint8_t transmitID, uint8_t receiveID, uint8_t maxIndexTX, uint8_t maxIndexRX, bool enableRetransmit)`

This is the constructor for the SerialDataLink class. It initializes the communication parameters with the following details:

serial: The serial stream used for communication.
transmitID: The identifier used for transmission.
receiveID: The identifier used for receiving data.
maxIndexTX: The maximum index that can be used for transmitting data.
maxIndexRX: The maximum index that can be used for receiving data.
enableRetransmit: A boolean flag that enables retransmission if set to true.

Public Methods

Method	Description and Parameters
`void run()`	Main method for data transmission and reception.
`void updateData(uint8_t index, int16_t value)`	Updates data to be transmitted. - `index`: Data position index. - `value`: Data value to send.
`int16_t getReceivedData(uint8_t index)`	Retrieves received data. - `index`: Index of data to retrieve.
`bool checkNewData(bool resetFlag)`	Checks if new data is received. - `resetFlag`: Clears new data flag if true.
`bool checkTransmissionError(bool resetFlag)`	Checks for transmission errors. - `resetFlag`: Resets error flag if true.
`int getLastAcknowledge(bool resetFlag)`	Gets the status of the last acknowledgment. - `resetFlag`: Resets acknowledgment status if true.
`bool checkReadError(bool resetFlag)`	Checks for read errors. - `resetFlag`: Resets error flag if true.
`void setUpdateInterval(unsigned long interval)`	Sets the data update interval. - `interval`: Time in milliseconds.
`void setAckTimeout(unsigned long timeout)`	Sets the acknowledgment timeout. - `timeout`: Timeout duration in milliseconds.
`void setPacketTimeout(unsigned long timeout)`	Sets the packet reception timeout. - `timeout`: Timeout period in milliseconds.
`void muteACK(bool mute)`	Mutes or unmutes acknowledgment messages. - `mute`: Mute flag.
`void setHeaderChar(char header)`	Sets the start-of-packet character. - `header`: Character for packet start.
`void setEOTChar(char eot)`	Sets the end-of-transmission character. - `eot`: Character for end of transmission.

License

This project is licensed under the MIT License - see the LICENSE file for details.

mackelec / SerialDataLink