#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()
{
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;
}
.getBusState = bus_state_callback,
.userData = nullptr };
}
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;
}
}
std::atomic_bool should_stop = false;
constexpr auto CAN_PORT_1 = 0;
constexpr auto CAN_PORT_2 = 1;
ct2klib_app::ct2klib_app()
{
_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(),
init_ports_config();
CT2KLibInitEx(&_input_parameters,
_ports_config.data(),
ct2klib_callbacks());
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);
CT2KLibInstallPGNTable(CAN_PORT_1, pgns.data(), pgns.size());
CT2KLibInstallPGNTable(CAN_PORT_2, pgns.data(), pgns.size());
register_pgn_callbacks();
setup_device_name();
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()
{
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));
std::signal(SIGINT, stop);
std::signal(SIGTERM, stop);
should_stop.wait(false);
return EXIT_SUCCESS;
}
void ct2klib_app::init_ports_config()
{
_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)
{
*field_one_error_code = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
*field_two_error_code = GROUP_FUNCTION_PARAMETER_ERROR_CODE_NoError;
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)
{
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) {
if (pgn.init_fn) {
pgn.init_fn();
}
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);
}
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()
{
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);
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;
}
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;
}
{
if (signal == SIGTERM || signal == SIGINT) {
fmt::print("Received signal {}. Stopping...\n", signal);
should_stop = true;
should_stop.notify_one();
}
}
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.