LIN_EventTriggered/main.cpp

Event Triggered example

The event-triggered frame 0x10 is associatted with unconditional frames 0x11 from slave 1 and 0x12 from slave 2.
Schedule table contains event-triggered frame 0x10.
The collision resolving schedule table contains unconditionnal frames 0x11 and 0x12.

#include <vector>
#include <iostream>
#include <thread>
#include <array>
#include <string>
 
#define AGHAF_DYNAMIC_LIBRARY_INIT
#include <aghaf.h>
 
#include <iostream>
#include <iomanip>
 
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 onLinSlave1Tx(
        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 onLinSlave1Rx(
        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 onLinSlave1Error(
        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 onLinSlave2Tx(
        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 onLinSlave2Rx(
        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 onLinSlave2Error(
        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 > 2) {
            int serialNumber1 = std::stoi(devicesInfo[0].serialNo);
            int serialNumber2 = std::stoi(devicesInfo[1].serialNo);
            int serialNumber3 = std::stoi(devicesInfo[2].serialNo);
 
            AGHAF_Device deviceMaster;
            AGHAF_Device deviceSlave1;
            AGHAF_Device deviceSlave2;
 
            if (serialNumber1 > serialNumber2) {
                if (serialNumber1 > serialNumber3) {
                    deviceMaster = AGHAF_getDeviceBySN(
                                devicesInfo[0].productNo,
                            devicesInfo[0].serialNo);
 
                    deviceSlave1 = AGHAF_getDeviceBySN(
                                devicesInfo[1].productNo,
                            devicesInfo[1].serialNo);
                    deviceSlave2 = AGHAF_getDeviceBySN(
                                devicesInfo[2].productNo,
                            devicesInfo[2].serialNo);
                } else {
                    deviceMaster = AGHAF_getDeviceBySN(
                                devicesInfo[2].productNo,
                            devicesInfo[2].serialNo);
 
                    deviceSlave1 = AGHAF_getDeviceBySN(
                                devicesInfo[0].productNo,
                            devicesInfo[0].serialNo);
                    deviceSlave2 = AGHAF_getDeviceBySN(
                                devicesInfo[1].productNo,
                            devicesInfo[1].serialNo);
                }
            } else {
                if (serialNumber2 > serialNumber3) {
                    deviceMaster = AGHAF_getDeviceBySN(
                                devicesInfo[1].productNo,
                            devicesInfo[1].serialNo);
 
                    deviceSlave1 = AGHAF_getDeviceBySN(
                                devicesInfo[0].productNo,
                            devicesInfo[0].serialNo);
                    deviceSlave2 = AGHAF_getDeviceBySN(
                                devicesInfo[2].productNo,
                            devicesInfo[2].serialNo);
                } else {
                    deviceMaster = AGHAF_getDeviceBySN(
                                devicesInfo[2].productNo,
                            devicesInfo[2].serialNo);
 
                    deviceSlave1 = AGHAF_getDeviceBySN(
                                devicesInfo[0].productNo,
                            devicesInfo[0].serialNo);
                    deviceSlave2 = AGHAF_getDeviceBySN(
                                devicesInfo[1].productNo,
                            devicesInfo[1].serialNo);
                }
            }
 
            deviceMaster = AGHAF_getDeviceBySN(
                        devicesInfo[0].productNo,
                    devicesInfo[0].serialNo);
 
            deviceSlave1 = AGHAF_getDeviceBySN(
                        devicesInfo[1].productNo,
                    devicesInfo[1].serialNo);
 
            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);
 
                std::array<uint8_t, 1> event1 = { 0x12 };
                std::array<uint8_t, 2> frame1 = { 0x00, 0x85 };
 
                std::array<uint8_t, 1> event2 = { 0x11 };
                std::array<uint8_t, 2> frame2 = { 0x00, 0xF0 };
 
                AGHAF_LIN_SCHEDULE_addEventTriggered(linMaster, 0, 2, 0x10, 1);
                AGHAF_LIN_SCHEDULE_addUnconditional(linMaster, 1, 0x12, 2);
                AGHAF_LIN_SCHEDULE_addUnconditional(linMaster, 1, 0x11, 2);
                AGHAF_LIN_SCHEDULE_configure(linMaster, 0, AGHAF_LIN_SCHEDULE_KIND_LOOP);
                AGHAF_LIN_SCHEDULE_configure(linMaster, 1, AGHAF_LIN_SCHEDULE_KIND_ONCE);
 
                AGHAF_LIN_configureFrame(
                            linMaster,
                            0x10,
                            AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                            0,
                            static_cast<uint8_t>(frame2.size()),
                            nullptr);
                AGHAF_LIN_configureFrame(
                            linMaster,
                            0x11,
                            AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                            0,
                            static_cast<uint8_t>(frame2.size()),
                            nullptr);
                AGHAF_LIN_configureFrame(
                            linMaster,
                            0x12,
                            AGHAF_LIN_FRAME_KIND_SUBSCRIBE,
                            0,
                            static_cast<uint8_t>(frame1.size()),
                            nullptr);
 
                AGHAF_LIN_configureFrame(
                            linSlave1,
                            0x10,
                            AGHAF_LIN_FRAME_KIND_PUBLISH,
                            AGHAF_LIN_PUBLISH_EVT_TRIG,
                            static_cast<uint8_t>(event2.size()),
                            event2.data());
                AGHAF_LIN_configureFrame(
                            linSlave1,
                            0x11,
                            AGHAF_LIN_FRAME_KIND_PUBLISH,
                            AGHAF_LIN_PUBLISH_AUTO_PID,
                            static_cast<uint8_t>(frame2.size()),
                            frame2.data());
 
                AGHAF_LIN_configureFrame(
                            linSlave2,
                            0x10,
                            AGHAF_LIN_FRAME_KIND_PUBLISH,
                            AGHAF_LIN_PUBLISH_EVT_TRIG,
                            static_cast<uint8_t>(event1.size()),
                            event1.data());
                 AGHAF_LIN_configureFrame(
                            linSlave2,
                            0x12,
                            AGHAF_LIN_FRAME_KIND_PUBLISH,
                            AGHAF_LIN_PUBLISH_AUTO_PID,
                            static_cast<uint8_t>(frame1.size()),
                            frame1.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));
                frame1[1] = 0xC0;
                AGHAF_LIN_updateFrame(linSlave2, 0x12, static_cast<uint8_t>(frame1.size()), frame1.data());
                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);
            }
 
            AGHAF_closeDevice(deviceMaster);
            AGHAF_closeDevice(deviceSlave1);
            AGHAF_closeDevice(deviceSlave2);
        }
 
        AGHAF_freeDeviceList(devicesInfo);
    }
 
#ifdef _WIN32
    AGHAF_unloadLibrary();
#endif
    return 0;
}