LIN_UnconditionalFrame/main.cpp

Unconditional Frame example

Schedule table contains three unconditionnal frames 0x30, 0x31 and 0x32.

#include <array>
#include <iostream>
#include <thread>
 
#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__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
  } else {
    std::cout << "no data" << '\n';
  }
}
 
void onLinMasterRx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
}
 
void onLinMasterError(uint64_t timestamp, AGHAF_LIN_Error error,
                      void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "error: " << static_cast<int>(error) << '\n';
}
 
void onLinSlave1Tx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
  } else {
    std::cout << "no data" << '\n';
  }
}
 
void onLinSlave1Rx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
}
 
void onLinSlave1Error(uint64_t timestamp, AGHAF_LIN_Error error,
                      void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "error: " << static_cast<int>(error) << '\n';
}
 
void onLinSlave2Tx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
  } else {
    std::cout << "no data" << '\n';
  }
}
 
void onLinSlave2Rx(uint64_t timestamp, uint8_t fid, uint8_t datalen,
                   uint8_t const *data, void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "datalen: " << static_cast<int>(datalen) << '\n';
  std::cout << "fid: " << static_cast<int>(fid) << '\n';
  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 << '\n';
}
 
void onLinSlave2Error(uint64_t timestamp, AGHAF_LIN_Error error,
                      void *userContext) {
  (void)timestamp;
  (void)userContext;
  std::cout << __FUNCTION__ << '\n';
  std::cout << "error: " << static_cast<int>(error) << '\n';
}
 
int main() {
#ifdef _WIN32
  AGHAF_loadLibrary(AGHAF_DEFAULT_FILENAME);
#endif
 
  AGHAF_DeviceInfo *devicesInfo = nullptr;
  uint32_t deviceInfoNumber = 0;
  AGHAF_getDeviceList(&devicesInfo, &deviceInfoNumber);
 
  if (deviceInfoNumber > 2) {
    AGHAF_Device deviceMaster =
        AGHAF_getDeviceBySN(devicesInfo[0].productNo, devicesInfo[0].serialNo);
    AGHAF_Device deviceSlave1 =
        AGHAF_getDeviceBySN(devicesInfo[1].productNo, devicesInfo[1].serialNo);
 
    AGHAF_Device deviceSlave2 =
        AGHAF_getDeviceBySN(devicesInfo[2].productNo, devicesInfo[2].serialNo);
 
    AGHAF_openDevice(deviceMaster);
    AGHAF_openDevice(deviceSlave1);
    AGHAF_openDevice(deviceSlave2);
 
    uint8_t linCount1 = AGHAF_LIN_getCount(deviceMaster);
    uint8_t linCount2 = AGHAF_LIN_getCount(deviceSlave1);
    uint8_t linCount3 = AGHAF_LIN_getCount(deviceSlave2);
 
    if (linCount1 > 0 && linCount2 > 0 && linCount3 > 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 linSlave1 = AGHAF_LIN_get(deviceSlave1, 0);
      AGHAF_LIN_setOnMessageRxCallback(linSlave1, &onLinSlave1Rx, nullptr);
      AGHAF_LIN_setOnMessageTxCallback(linSlave1, &onLinSlave1Tx, nullptr);
      AGHAF_LIN_setOnErrorCallback(linSlave1, &onLinSlave1Error, nullptr);
      AGHAF_LIN_setParam(linSlave1, AGHAF_LIN_PARAM_BAUDRATE, 19200);
      AGHAF_LIN_setParam(linSlave1, AGHAF_LIN_PARAM_MODE, AGHAF_LIN_MODE_SLAVE);
 
      AGHAF_LIN linSlave2 = AGHAF_LIN_get(deviceSlave2, 0);
      AGHAF_LIN_setOnMessageRxCallback(linSlave2, &onLinSlave2Rx, nullptr);
      AGHAF_LIN_setOnMessageTxCallback(linSlave2, &onLinSlave2Tx, nullptr);
      AGHAF_LIN_setOnErrorCallback(linSlave2, &onLinSlave2Error, nullptr);
      AGHAF_LIN_setParam(linSlave2, AGHAF_LIN_PARAM_BAUDRATE, 19200);
      AGHAF_LIN_setParam(linSlave2, AGHAF_LIN_PARAM_MODE, AGHAF_LIN_MODE_SLAVE);
 
      AGHAF_LIN_SCHEDULE_addUnconditional(linMaster, 0, 0x30, 2);
      AGHAF_LIN_SCHEDULE_addUnconditional(linMaster, 0, 0x31, 2);
      AGHAF_LIN_SCHEDULE_addUnconditional(linMaster, 0, 0x32, 2);
      AGHAF_LIN_SCHEDULE_configure(linMaster, 0, AGHAF_LIN_SCHEDULE_KIND_LOOP);
 
      std::array<uint8_t, 1> frame30 = {0x0A};
      AGHAF_LIN_configureFrame(linMaster, 0x30, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                               0, static_cast<uint8_t>(frame30.size()),
                               nullptr);
      AGHAF_LIN_configureFrame(linSlave1, 0x30, AGHAF_LIN_FRAME_KIND_PUBLISH, 0,
                               static_cast<uint8_t>(frame30.size()),
                               frame30.data());
 
      std::array<uint8_t, 1> frame31 = {0x0B};
      AGHAF_LIN_configureFrame(linMaster, 0x31, AGHAF_LIN_FRAME_KIND_PUBLISH, 0,
                               static_cast<uint8_t>(frame31.size()),
                               frame31.data());
 
      AGHAF_LIN_configureFrame(linSlave1, 0x31, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                               0, static_cast<uint8_t>(frame31.size()),
                               nullptr);
 
      AGHAF_LIN_configureFrame(linSlave2, 0x31, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                               0, static_cast<uint8_t>(frame31.size()),
                               nullptr);
 
      std::array<uint8_t, 1> frame32 = {0x0C};
      AGHAF_LIN_configureFrame(linMaster, 0x32, AGHAF_LIN_FRAME_KIND_IGNORE, 0,
                               static_cast<uint8_t>(frame32.size()), nullptr);
 
      AGHAF_LIN_configureFrame(linSlave1, 0x32, AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                               0, static_cast<uint8_t>(frame32.size()),
                               nullptr);
 
      AGHAF_LIN_configureFrame(linSlave2, 0x32, AGHAF_LIN_FRAME_KIND_PUBLISH, 0,
                               static_cast<uint8_t>(frame32.size()),
                               frame32.data());
 
      AGHAF_LIN_activate(linMaster);
      AGHAF_LIN_activate(linSlave1);
      AGHAF_LIN_activate(linSlave2);
      AGHAF_LIN_SCHEDULE_start(linMaster, 0);
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      AGHAF_LIN_SCHEDULE_stop(linMaster);
      AGHAF_LIN_deactivate(linSlave2);
      AGHAF_LIN_deactivate(linSlave1);
      AGHAF_LIN_deactivate(linMaster);
    } else {
      std::cerr << "one or more devices do not have any LIN" << '\n';
    }
 
    AGHAF_closeDevice(deviceMaster);
    AGHAF_closeDevice(deviceSlave1);
    AGHAF_closeDevice(deviceSlave2);
  } else {
    std::cerr << "2 exxotest devices are required" << '\n';
  }
 
  AGHAF_freeDeviceList(devicesInfo);
 
#ifdef _WIN32
  AGHAF_unloadLibrary();
#endif
  return 0;
}