LIN_Sporadic/main.cpp

Sporadic example

Schedule table contains only one sporadic frame.
The sporadic frame is associatted with unconditional frames 0x22, 0x23 and 0x24.

#include <array>
#include <iostream>
#include <thread>
#include <vector>
 
#define AGHAF_DYNAMIC_LIBRARY_INIT
#include <aghaf.h>
 
#include <iomanip>
#include <iostream>
 
void onLinMasterTx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "datalen: " << static_cast<int>(datalen) << std::endl;
  std::cout << "fid: " << static_cast<int>(fid) << std::endl;
  if (data != nullptr) {
    std::cout << "0x";
    for (uint8_t i = 0; i < datalen; ++i) {
      std::cout << std::hex << std::setw(2) << std::setfill('0')
                << static_cast<int>(data[i]);
    }
    std::cout << std::endl;
  } else {
    std::cout << "no data" << std::endl;
  }
}
 
void onLinMasterRx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "datalen: " << static_cast<int>(datalen) << std::endl;
  std::cout << "fid: " << static_cast<int>(fid) << std::endl;
  std::cout << "0x";
  for (uint8_t i = 0; i < datalen; ++i) {
    std::cout << std::hex << std::setw(2) << std::setfill('0')
              << static_cast<int>(data[i]);
  }
  std::cout << std::endl;
}
 
void onLinMasterError(uint64_t timestamp, AGHAF_LIN_Error error,
                      void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "error: " << static_cast<int>(error) << std::endl;
}
 
void onLinSlaveTx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                  uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "datalen: " << static_cast<int>(datalen) << std::endl;
  std::cout << "fid: " << static_cast<int>(fid) << std::endl;
  if (data != nullptr) {
    std::cout << "0x";
    for (uint8_t i = 0; i < datalen; ++i) {
      std::cout << std::hex << std::setw(2) << std::setfill('0')
                << static_cast<int>(data[i]);
    }
    std::cout << std::endl;
  } else {
    std::cout << "no data" << std::endl;
  }
}
 
void onLinSlaveRx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                  uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "datalen: " << static_cast<int>(datalen) << std::endl;
  std::cout << "fid: " << static_cast<int>(fid) << std::endl;
  std::cout << "0x";
  for (uint8_t i = 0; i < datalen; ++i) {
    std::cout << std::hex << std::setw(2) << std::setfill('0')
              << static_cast<int>(data[i]);
  }
  std::cout << std::endl;
}
 
void onLinSlaveError(uint64_t timestamp, AGHAF_LIN_Error error,
                     void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << std::endl;
  std::cout << "error: " << static_cast<int>(error) << std::endl;
}
 
int main() {
#ifdef _WIN32
  AGHAF_loadLibrary(AGHAF_DEFAULT_FILENAME);
#endif
 
  uint32_t count = AGHAF_getDeviceCount();
  if (count > 0) {
    AGHAF_DeviceInfo *devicesInfo = nullptr;
    uint32_t deviceInfoNumber = 0;
    AGHAF_getDeviceList(&devicesInfo, &deviceInfoNumber);
 
    if (deviceInfoNumber > 1) {
      AGHAF_Device deviceMaster = AGHAF_getDeviceBySN(devicesInfo[0].productNo,
                                                      devicesInfo[0].serialNo);
 
      AGHAF_Device deviceSlave = AGHAF_getDeviceBySN(devicesInfo[1].productNo,
                                                     devicesInfo[1].serialNo);
 
      AGHAF_openDevice(deviceMaster);
      AGHAF_openDevice(deviceSlave);
 
      uint8_t linCount1 = AGHAF_LIN_getCount(deviceMaster);
      uint8_t linCount2 = AGHAF_LIN_getCount(deviceSlave);
 
      if (linCount1 > 0 && linCount2 > 0) {
        AGHAF_LIN linMaster = AGHAF_LIN_get(deviceMaster, 0);
        AGHAF_LIN_setOnMessageRxCallback(linMaster, &onLinMasterRx, nullptr);
        AGHAF_LIN_setOnMessageTxCallback(linMaster, &onLinMasterTx, nullptr);
        AGHAF_LIN_setOnErrorCallback(linMaster, &onLinMasterError, nullptr);
        AGHAF_LIN_setParam(linMaster, AGHAF_LIN_PARAM_BAUDRATE, 19200);
        AGHAF_LIN_setParam(linMaster, AGHAF_LIN_PARAM_MODE,
                           AGHAF_LIN_MODE_MASTER);
 
        AGHAF_LIN linSlave = AGHAF_LIN_get(deviceSlave, 0);
        AGHAF_LIN_setOnMessageRxCallback(linSlave, &onLinSlaveRx, nullptr);
        AGHAF_LIN_setOnMessageTxCallback(linSlave, &onLinSlaveTx, nullptr);
        AGHAF_LIN_setOnErrorCallback(linSlave, &onLinSlaveError, nullptr);
        AGHAF_LIN_setParam(linSlave, AGHAF_LIN_PARAM_BAUDRATE, 19200);
        AGHAF_LIN_setParam(linSlave, AGHAF_LIN_PARAM_MODE,
                           AGHAF_LIN_MODE_SLAVE);
 
        std::array<uint8_t, 3> spos = {0x22, 0x23, 0x24};
        std::array<uint8_t, 4> spoFrame22 = {0x00, 0x01, 0x02, 0x03};
        std::array<uint8_t, 5> spoFrame23 = {0x00, 0x01, 0x02, 0x03, 0x04};
        std::array<uint8_t, 6> spoFrame24 = {0x00, 0x01, 0x02,
                                             0x03, 0x05, 0x06};
        AGHAF_LIN_SCHEDULE_addSporadic(
            linMaster, 0, 2, static_cast<uint8_t>(spos.size()), spos.data());
        AGHAF_LIN_SCHEDULE_configure(linMaster, 0,
                                     AGHAF_LIN_SCHEDULE_KIND_LOOP);
 
        AGHAF_LIN_configureFrame(linMaster, 0x22, AGHAF_LIN_FRAME_KIND_PUBLISH,
                                 0, static_cast<uint8_t>(spoFrame22.size()),
                                 spoFrame22.data());
 
        AGHAF_LIN_configureFrame(linSlave, 0x22, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                                 0, static_cast<uint8_t>(spoFrame22.size()),
                                 nullptr);
 
        AGHAF_LIN_configureFrame(linMaster, 0x23, AGHAF_LIN_FRAME_KIND_PUBLISH,
                                 0, static_cast<uint8_t>(spoFrame23.size()),
                                 spoFrame23.data());
 
        AGHAF_LIN_configureFrame(linSlave, 0x23, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                                 0, static_cast<uint8_t>(spoFrame23.size()),
                                 nullptr);
 
        AGHAF_LIN_configureFrame(linMaster, 0x24, AGHAF_LIN_FRAME_KIND_PUBLISH,
                                 0, static_cast<uint8_t>(spoFrame24.size()),
                                 spoFrame24.data());
 
        AGHAF_LIN_configureFrame(linSlave, 0x24, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                                 0, static_cast<uint8_t>(spoFrame24.size()),
                                 nullptr);
 
        AGHAF_LIN_activate(linMaster);
        AGHAF_LIN_activate(linSlave);
        AGHAF_LIN_SCHEDULE_start(linMaster, 0);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        spoFrame22[0] = 0x0A;
        AGHAF_LIN_updateFrame(linMaster, 0x22,
                              static_cast<uint8_t>(spoFrame22.size()),
                              spoFrame22.data());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        spoFrame23[1] = 0x0B;
        AGHAF_LIN_updateFrame(linMaster, 0x23,
                              static_cast<uint8_t>(spoFrame23.size()),
                              spoFrame23.data());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        spoFrame24[2] = 0x0C;
        AGHAF_LIN_updateFrame(linMaster, 0x24,
                              static_cast<uint8_t>(spoFrame24.size()),
                              spoFrame24.data());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        spoFrame22[3] = 0x0D;
        spoFrame23[3] = 0x0D;
        spoFrame24[3] = 0x0D;
        AGHAF_LIN_updateFrame(linMaster, 0x24,
                              static_cast<uint8_t>(spoFrame24.size()),
                              spoFrame24.data());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        AGHAF_LIN_updateFrame(linMaster, 0x22,
                              static_cast<uint8_t>(spoFrame22.size()),
                              spoFrame22.data());
        AGHAF_LIN_updateFrame(linMaster, 0x23,
                              static_cast<uint8_t>(spoFrame23.size()),
                              spoFrame23.data());
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        AGHAF_LIN_SCHEDULE_stop(linMaster);
        AGHAF_LIN_deactivate(linMaster);
        AGHAF_LIN_deactivate(linSlave);
      }
 
      AGHAF_closeDevice(deviceMaster);
      AGHAF_closeDevice(deviceSlave);
    }
 
    AGHAF_freeDeviceList(devicesInfo);
  }
 
#ifdef _WIN32
  AGHAF_unloadLibrary();
#endif
  return 0;
}