Veethree D7 SDK
Loading...
Searching...
No Matches
CT2KLib compatibility library examples

Table of Contents

CLI CT2KLib application

The following class is an example of implementing a CLI application that:

  • Initializes CT2KLib using the compatibility library.
  • Registers PGNs with CT2KLib.
  • Registers handlers for various callbacks for the registered PGNs.

Note: The example code here is abbreviated to just the CT2KLib specific code. Please look in the SDK's installation folder for examples/ct2klib for the entire example.

CMakeLists.txt
cmake_minimum_required(VERSION 3.28)
project(
ct2klib-app
VERSION 0.1
LANGUAGES CXX)
# Set CC++ standard to 20
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_STANDARD 20)
# Find VSDK's CT2KLib compatibility package
# This links CT2KLib transparently
find_package(vsdk REQUIRED CONFIG COMPONENTS ct2klib_compat)
# Add executable and link against VSDK libraries
add_executable(cli-ct2klib-app
main.cpp
can_unique.cpp
ct2klib_app.cpp
configurations.h
J1939/J1939_D000_CL.cpp
J1939/J1939_FEE5_HOURS.cpp
J1939/test_FFFF_TEST.cpp
)
target_include_directories(cli-ct2klib-app PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(cli-ct2klib-app PRIVATE vsdk::ct2klib_compat)
target_link_libraries(cli-ct2klib-app PRIVATE vsdk::system)
target_link_libraries(cli-ct2klib-app PRIVATE vsdk::comms)
## Deploy to target from Qt Creator
include(GNUInstallDirs)
install(TARGETS ${APPNAME}
BUNDLE DESTINATION .
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
@ ct2klib
CT2KLib Compatibility module.
Definition log.h:42
Any entities that belong to the comms library.
Definition can_adapter.h:11
Functions necessary to initialize CT2KLib.
Definition ct2klib-compat.h:11
Any entities that belong to the Veethree SDK libraries.
Definition can_adapter.h:11
ct2klib_app.h
#ifndef CT2KLIB_APP_H
#define CT2KLIB_APP_H
#include <CT2KLib.h>
#include <array>
#include <memory>
#include <pgn_info.h>
#include <string>
#include <vector>
class ct2klib_app {
public:
// This class is a single to avoid initializing CT2KLib multiple times
static std::shared_ptr<ct2klib_app> instance();
~ct2klib_app() noexcept;
static std::string lib_version();
// Blocks the thread that calls this until signalled to stop by SIGTERM or SIGINT.
int run();
private:
using ct2klib = vsdk::ct2klib_compat::ct2klib;
struct config_info {
std::string field_one;
std::string field_two;
std::string field_three;
};
// The constructor makes all the necessary calls to initialize CT2KLib
ct2klib_app();
// CT2KLib initialization
void init_ports_config();
void init_configuration_info(CAN_PORT_T port, config_info config_lines);
void init_product_info();
void register_pgn_callbacks();
void setup_device_name();
// Product specific information
static uint32_t get_unique();
uint8_t get_device_instance(CAN_PORT_T port) const;
void set_device_instance(CAN_PORT_T port, uint8_t instance);
uint8_t get_system_instance(CAN_PORT_T port) const;
void set_system_instance(CAN_PORT_T port, uint8_t instance);
static void config_info_callback(const CAN_PORT_T port,
const CONFIGURATION_INFORMATION_STRING_T* field_one,
GROUP_FUNCTION_PARAMETER_ERROR_CODE_T* field_one_error_code,
const CONFIGURATION_INFORMATION_STRING_T* field_two,
GROUP_FUNCTION_PARAMETER_ERROR_CODE_T* field_two_error_code,
uintptr_t user_data);
static NAME_CHANGE_COMMAND_RESPONSE_T name_change_callback(CAN_PORT_T port,
DEVNAME name_info,
uintptr_t user_data);
INPUT_PARAMS_T _input_parameters{};
std::vector<pgn_info> _pgn_info;
std::array<CTLIB_PROD_INFO, ct2klib::NUM_CAN_PORTS> _product_info{};
std::array<PORTS_CONFIG_T, ct2klib::NUM_CAN_PORTS> _ports_config{};
std::array<config_info, ct2klib::NUM_CAN_PORTS> _config_info{};
std::array<std::pair<uint8_t, uint8_t>, ct2klib::NUM_CAN_PORTS> _device_and_system_instances{};
};
#endif // CT2KLIB_APP_H
CT2KLib compatibility library.
ct2kib_app.cpp
#include "ct2klib_app.h"
#include "can_unique.h"
#include <CT2KLibVersion.h>
#include <J1939/J1939_D000_CL.h>
#include <J1939/J1939_FEE5_HOURS.h>
#include <J1939/test_FFFF_TEST.h>
#include <atomic>
#include <configurations.h>
#include <csignal>
#include <exception>
namespace {
bool can_interfaces_virtual()
{
std::vector<std::string> interfaces = { "can0", "can1" };
for (const auto& interface : interfaces) {
std::string path = "/sys/devices/virtual/net/" + interface;
fmt::println("Testing path {}\n", path);
return true;
}
}
return false;
}
CAN_DRIVER_FUNCTIONS_T ct2klib_callbacks()
{
using namespace vsdk::ct2klib_compat;
auto real_bus_state_callback = ct2klib::can_get_bus_state;
auto mock_bus_state_callback = [](CAN_PORT_T physicalPort, void* userData) -> BUS_STATE_T {
return BUS_STATE_OK;
};
auto& bus_state_callback = real_bus_state_callback;
if (can_interfaces_virtual()) {
fmt::println("At least one CAN interface is virtual. Mocking bus_state\n");
bus_state_callback = mock_bus_state_callback;
}
return { .canOpen = ct2klib::can_open,
.canClose = ct2klib::can_close,
.getBusState = bus_state_callback,
.transmitFrame = ct2klib::can_transmit_frame,
.receiveFrameWait = ct2klib::can_select_wait,
.bitRateSet = ct2klib::can_set_bitrate,
.userData = nullptr };
}
// Assumes c_str is null-terminated
void copy_c_str(char* p_dest, const char* p_src, int dest_size)
{
memset(p_dest, 0xff, dest_size);
strcpy(p_dest, p_src);
}
std::vector<PGNDesc> pgn_descs(const std::vector<pgn_info>& pgn_info)
{
std::vector<PGNDesc> pgns;
pgns.reserve(pgn_info.size());
for (const auto& pgn : pgn_info) {
pgns.push_back(pgn.pgn_desc);
}
return pgns;
}
} // namespace
std::atomic_bool should_stop = false;
void stop(int signal);
using namespace vsdk::ct2klib_compat;
constexpr auto CAN_PORT_1 = 0;
constexpr auto CAN_PORT_2 = 1;
// Initializing CT2KLib
ct2klib_app::ct2klib_app()
{
// Setup the Input Parameters.
// See J1939/test_FFFF_TEST.h/.cpp for an example of handling a new PGN.
_pgn_info = { J1939_D000_CL::to_pgn_info(),
J1939_FEE5_HOURS::to_pgn_info(),
TEST_FFFF::to_pgn_info() };
const auto pgns = pgn_descs(_pgn_info);
_input_parameters = CT2KLibGetPGNTableRequiredMemorySize(pgns.data(),
pgns.size(),
// Setup the Port Configs
init_ports_config();
/*
* This is where you should pass the functions from the Compatibility Library
* to CT2KLib.
*/
CT2KLibInitEx(&_input_parameters,
_ports_config.data(),
// Compatibility Library functions
ct2klib_callbacks());
// Setup the Configuration Information
init_configuration_info(CAN_PORT_1,
config_info{
.field_one = CONFIGURATION_INFORMATION_1F016_126998_CAN1_Line_1,
.field_two = CONFIGURATION_INFORMATION_1F016_126998_CAN1_Line_2,
.field_three = CONFIGURATION_INFORMATION_1F016_126998_CAN1_Line_3,
});
init_configuration_info(CAN_PORT_2,
config_info{
.field_one = CONFIGURATION_INFORMATION_1F016_126998_CAN2_Line_1,
.field_two = CONFIGURATION_INFORMATION_1F016_126998_CAN2_Line_2,
.field_three = CONFIGURATION_INFORMATION_1F016_126998_CAN2_Line_3,
});
CT2KLibRegisterCommandedConfigurationInformationCallback(&config_info_callback,
(uintptr_t) nullptr);
// Register the Table(s)
CT2KLibInstallPGNTable(CAN_PORT_1, pgns.data(), pgns.size());
CT2KLibInstallPGNTable(CAN_PORT_2, pgns.data(), pgns.size());
// Register PGN callbacks
register_pgn_callbacks();
// Setup the Device Name for the Address Claim
setup_device_name();
// Setup the Product Information PGN
init_product_info();
}
ct2klib_app::~ct2klib_app() noexcept
{
CT2KLibStop();
CT2KLibDeinit();
}
std::shared_ptr<ct2klib_app> ct2klib_app::instance()
{
static auto app = std::shared_ptr<ct2klib_app>(new ct2klib_app);
return app;
}
std::string ct2klib_app::lib_version()
{
return fmt::format("{}.{}.{}.{}",
CT2KLIB_VERSION_MAJOR,
CT2KLIB_VERSION_MINOR,
CT2KLIB_VERSION_PATCH,
CT2KLIB_VERSION_BUILD);
}
int ct2klib_app::run()
{
// Start the Library
if (auto err = CT2KLibStart(); err != CTCR_OK) {
fmt::print("Failed to start CT2KLib. Error code {}", static_cast<uint8_t>(err));
return EXIT_FAILURE;
}
fmt::println("Port 1 address: {}", CT2KLibGetMyAddress(CAN_PORT_1));
fmt::println("Port 2 address: {}", CT2KLibGetMyAddress(CAN_PORT_2));
// Wait until SIGTERM or SIGINT
// CT2KLib starts 2 threads for each CAN port, 1 for reading and 1 for writing
// So it's safe to block this thread here.
std::signal(SIGINT, stop);
std::signal(SIGTERM, stop);
should_stop.wait(false);
return EXIT_SUCCESS;
}
void ct2klib_app::init_ports_config()
{
//
// Configure each port here
//
_ports_config[CAN_PORT_1].portNumber = CAN_PORT_1;
_ports_config[CAN_PORT_1].portSpeed = CANPORT_1_BITRATE;
_ports_config[CAN_PORT_1].portMode = PORT_MODE_NMEA2000;
_ports_config[CAN_PORT_1].doAddressClaim = true;
_ports_config[CAN_PORT_2].portNumber = CAN_PORT_2;
_ports_config[CAN_PORT_2].portSpeed = CANPORT_2_BITRATE;
_ports_config[CAN_PORT_2].portMode = PORT_MODE_NMEA2000;
_ports_config[CAN_PORT_2].doAddressClaim = true;
}
void ct2klib_app::init_configuration_info(CAN_PORT_T port, config_info config_lines)
{
CT2KLibSetConfigurationInformation_1F016(port,
config_lines.field_one.data(),
config_lines.field_one.length(),
config_lines.field_two.data(),
config_lines.field_two.length(),
config_lines.field_three.data(),
config_lines.field_three.length());
}
void ct2klib_app::config_info_callback(const CAN_PORT_T port,
const CONFIGURATION_INFORMATION_STRING_T* field_one,
GROUP_FUNCTION_PARAMETER_ERROR_CODE_T* field_one_error_code,
const CONFIGURATION_INFORMATION_STRING_T* field_two,
GROUP_FUNCTION_PARAMETER_ERROR_CODE_T* field_two_error_code,
[[maybe_unused]] uintptr_t user_data)
{
//
// Add logic here to decide whether the strings are acceptable
//
*field_one_error_code = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
*field_two_error_code = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
// In real applications, save field_one and field_two to non-volatile storage
// But only if they are acceptable
if (*field_one_error_code == GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError
&& *field_two_error_code == GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError) {
instance()->_config_info[port].field_one = std::string((char*) field_one->stringData,
field_one->stringSize);
instance()->_config_info[port].field_two = std::string((char*) field_two->stringData,
field_two->stringSize);
}
}
NAME_CHANGE_COMMAND_RESPONSE_T ct2klib_app::name_change_callback(CAN_PORT_T port,
DEVNAME name_info,
uintptr_t user_data)
{
//
// Add logic here to handle the name change command
//
NAME_CHANGE_COMMAND_RESPONSE_T return_response;
return_response.deviceInstanceErrorCode = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
return_response.systemInstanceErrorCode = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
instance()->set_system_instance(port, name_info.m_NameFields.m_i8DeviceClassInstance);
instance()->set_device_instance(port, name_info.m_NameFields.m_i8NMEAFunctionInstance);
return return_response;
}
void ct2klib_app::register_pgn_callbacks()
{
for (const auto& pgn : _pgn_info) {
// Initialize the PGN
if (pgn.init_fn) {
pgn.init_fn();
}
// Set the callbacks on both CAN ports
if (pgn.recv_callback != nullptr) {
CT2KSetPGNReceiveCallback(CAN_PORT_1, pgn.pgn_desc.i32PGN, pgn.recv_callback, 0);
CT2KSetPGNReceiveCallback(CAN_PORT_2, pgn.pgn_desc.i32PGN, pgn.recv_callback, 0);
}
// Set the ISO Request callbacks on both CAN ports
if (pgn.iso_callback != nullptr) {
CT2KSetPGNISORequestReceivedCallback(CAN_PORT_1,
pgn.pgn_desc.i32PGN,
pgn.iso_callback,
0);
CT2KSetPGNISORequestReceivedCallback(CAN_PORT_2,
pgn.pgn_desc.i32PGN,
pgn.iso_callback,
0);
}
}
}
void ct2klib_app::init_product_info()
{
// Product info for CAN 1
auto& info_can1 = _product_info[CAN_PORT_1];
info_can1.m_u16NMEAVersion = CTLIBGetNMEA2KLibVersion()->m_iProdInfoFormat;
info_can1.m_u16ProductCode = PRODUCT_CODE_CAN1;
copy_c_str(info_can1.m_c8MfgModelId, MODEL_ID_CAN1, sizeof(info_can1.m_c8MfgModelId));
copy_c_str(info_can1.m_c8MfgSoftwareVersion,
fmt::format("{}.{}.{}", SWVER_MAJOR, SWVER_MINOR, SWVER_PATCH).c_str(),
sizeof(info_can1.m_c8MfgSoftwareVersion));
copy_c_str(info_can1.m_c8MfgModelVersion,
MODEL_VERSION_CAN1,
sizeof(info_can1.m_c8MfgModelVersion));
copy_c_str(info_can1.m_c8MfgSerialNo,
fmt::format("{}", get_unique()).c_str(),
sizeof(info_can1.m_c8MfgSerialNo));
info_can1.m_u8CertLevel = 2;
info_can1.m_u8LoadEquivalency = 1;
CT2KLibSetAppProductInfo(CAN_PORT_1, &info_can1);
// Product info for CAN 2
auto& info_can2 = _product_info[CAN_PORT_2];
info_can2.m_u16NMEAVersion = CTLIBGetNMEA2KLibVersion()->m_iProdInfoFormat;
info_can2.m_u16ProductCode = PRODUCT_CODE_CAN2;
copy_c_str(info_can2.m_c8MfgModelId, MODEL_ID_CAN2, sizeof(info_can2.m_c8MfgModelId));
copy_c_str(info_can2.m_c8MfgSoftwareVersion,
fmt::format("{}.{}.{}", SWVER_MAJOR, SWVER_MINOR, SWVER_PATCH).c_str(),
sizeof(info_can2.m_c8MfgSoftwareVersion));
copy_c_str(info_can2.m_c8MfgModelVersion,
MODEL_VERSION_CAN2,
sizeof(info_can2.m_c8MfgModelVersion));
copy_c_str(info_can2.m_c8MfgSerialNo,
fmt::format("{}", get_unique()).c_str(),
sizeof(info_can2.m_c8MfgSerialNo));
info_can2.m_u8CertLevel = 2;
info_can2.m_u8LoadEquivalency = 1;
CT2KLibSetAppProductInfo(CAN_PORT_2, &info_can2);
}
uint32_t ct2klib_app::get_unique()
{
static auto code = can::get_unique();
return code;
}
void ct2klib_app::setup_device_name()
{
CT2KRegisterCallbackOnCommandedNameChange(CAN_PORT_1, &name_change_callback, 0);
CT2KRegisterCallbackOnCommandedNameChange(CAN_PORT_2, &name_change_callback, 0);
auto dev_name_can1 = DEVNAME{ .m_NameFields = {
.m_i32UniqueNumber = get_unique(),
.m_i16MfgCode = MANUFACTURER_CODE_CAN1,
.m_i8NMEAFunctionInstance = get_device_instance(CAN_PORT_1),
.m_i8DeviceFunction = DEVICE_FUNCTION_CAN1,
.m_i8Reserved = 0,
.m_i8DeviceClass = DEVICE_CLASS_CAN1,
.m_i8DeviceClassInstance = get_device_instance(CAN_PORT_1),
.m_i8IndustryGroup = INDUSTRY_GROUP_CAN1,
.m_i8SelfConfigurable = 1,
} };
auto dev_name_can2 = DEVNAME{ .m_NameFields = {
.m_i32UniqueNumber = get_unique() + 1,
.m_i16MfgCode = MANUFACTURER_CODE_CAN2,
.m_i8NMEAFunctionInstance = get_device_instance(CAN_PORT_2),
.m_i8DeviceFunction = DEVICE_FUNCTION_CAN2,
.m_i8Reserved = 0,
.m_i8DeviceClass = DEVICE_CLASS_CAN2,
.m_i8DeviceClassInstance = get_device_instance(CAN_PORT_2),
.m_i8IndustryGroup = INDUSTRY_GROUP_CAN2,
.m_i8SelfConfigurable = 1,
} };
CT2KLibSetAddress(CAN_PORT_1, &dev_name_can1, SEED_ADDRESS_CAN1);
CT2KLibSetAddress(CAN_PORT_2, &dev_name_can2, SEED_ADDRESS_CAN2);
}
uint8_t ct2klib_app::get_device_instance(CAN_PORT_T port) const
{
return _device_and_system_instances[port].first;
}
void ct2klib_app::set_device_instance(CAN_PORT_T port, uint8_t instance)
{
_device_and_system_instances[port].first = instance;
//
// Add logic here to save this to NV storage.
//
}
uint8_t ct2klib_app::get_system_instance(CAN_PORT_T port) const
{
return _device_and_system_instances[port].second;
}
void ct2klib_app::set_system_instance(CAN_PORT_T port, uint8_t instance)
{
_device_and_system_instances[port].second = instance;
//
// Add logic here to save this to NV storage.
//
}
void stop(int signal)
{
if (signal == SIGTERM || signal == SIGINT) {
fmt::print("Received signal {}. Stopping...\n", signal);
should_stop = true;
should_stop.notify_one();
}
}
CAN Adapter Interface.
static BUS_STATE_T can_get_bus_state(CAN_PORT_T can_port, void *user_data)
Get the CAN Bus state for a port.
static int32_t can_set_bitrate(CAN_PORT_T can_port, uint32_t bitrate, void *user_data)
Set the bitrate for a CAN port.
static int32_t can_select_wait(CAN_PORT_T *p_can_ports, uint32_t p_can_ports_length, CAN_FRAME_T *p_can_frame, CAN_PORT_T *p_can_from_port, uint32_t timeout_ms, void *user_data)
Wait to read one of multiple CAN ports.
static int32_t can_transmit_frame(CAN_PORT_T can_port, CAN_FRAME_T *p_frame, void *user_data)
Transmit a CAN frame on a specified port.
static constexpr int NUM_CAN_PORTS
Define the number of CAN ports.
Definition ct2klib-compat.h:58
static int32_t can_close(CAN_PORT_T port, void *user_data)
Close a CAN port.
static int32_t can_open(CAN_PORT_T port, void *user_data)
Open a CAN port.
Utilities for file manipulation.
Include this file to your file so you have access to fmtlib header-only implementation.
bool file_exists(const std::string &path)
Utility to check if a path exists. Same semantics as std::filesystem::exists, but won't do character ...
Definition file_utils.h:113
@ stop
stop operation failed
Definition io_error_codes.h:46
syscall wrapper interface.