192 lines
12 KiB
C++
192 lines
12 KiB
C++
#include <pybind11/pybind11.h>
|
|
#include <pybind11/stl.h>
|
|
#include <pybind11/functional.h>
|
|
|
|
#include "icsneo/communication/message/flexray/flexraymessage.h"
|
|
#include "icsneo/device/extensions/flexray/symbol.h"
|
|
#include "icsneo/device/extensions/flexray/channel.h"
|
|
#include "icsneo/device/extensions/flexray/crcstatus.h"
|
|
#include "icsneo/device/extensions/flexray/controller.h"
|
|
|
|
namespace icsneo {
|
|
|
|
struct FlexRayNamespace {
|
|
using Symbol = icsneo::FlexRay::Symbol;
|
|
using CRCStatus = icsneo::FlexRay::CRCStatus;
|
|
using Channel = icsneo::FlexRay::Channel;
|
|
};
|
|
|
|
namespace FlexRay {
|
|
|
|
struct ClusterNamespace {
|
|
using SpeedType = icsneo::FlexRay::Cluster::SpeedType;
|
|
using SPPType = icsneo::FlexRay::Cluster::SPPType;
|
|
};
|
|
|
|
void init_extension(pybind11::class_<FlexRayNamespace>& c) {
|
|
pybind11::class_<MessageBuffer, std::shared_ptr<MessageBuffer>>(c, "MessageBuffer")
|
|
.def(pybind11::init())
|
|
.def_readwrite("is_dynamic", &MessageBuffer::isDynamic)
|
|
.def_readwrite("is_sync", &MessageBuffer::isSync)
|
|
.def_readwrite("is_startup", &MessageBuffer::isStartup)
|
|
.def_readwrite("is_network_management_frame", &MessageBuffer::isNetworkManagementFrame)
|
|
.def_readwrite("is_transmit", &MessageBuffer::isTransmit)
|
|
.def_readwrite("frame_id", &MessageBuffer::frameID)
|
|
.def_readwrite("channel_a", &MessageBuffer::channelA)
|
|
.def_readwrite("channel_b", &MessageBuffer::channelB)
|
|
.def_readwrite("frame_length_bytes", &MessageBuffer::frameLengthBytes)
|
|
.def_readwrite("base_cycle", &MessageBuffer::baseCycle)
|
|
.def_readwrite("cycle_repetition", &MessageBuffer::cycleRepetition)
|
|
.def_readwrite("continuous_mode", &MessageBuffer::continuousMode);
|
|
|
|
auto controller = pybind11::class_<Controller, std::shared_ptr<Controller>>(c, "Controller")
|
|
.def("get_network", &Controller::getNetwork)
|
|
.def("get_configuration", &Controller::getConfiguration)
|
|
.def("set_configuration", &Controller::setConfiguration)
|
|
.def("get_start_when_going_online", &Controller::getStartWhenGoingOnline)
|
|
.def("set_start_when_going_online", &Controller::setStartWhenGoingOnline)
|
|
.def("get_allow_coldstart", &Controller::getAllowColdstart)
|
|
.def("set_allow_coldstart", &Controller::setAllowColdstart)
|
|
.def("get_wakeup_before_start", &Controller::getWakeupBeforeStart)
|
|
.def("set_wakeup_before_start", &Controller::setWakeupBeforeStart)
|
|
.def("add_message_buffer", &Controller::addMessageBuffer)
|
|
.def("clear_message_buffers", &Controller::clearMessageBuffers)
|
|
.def("wakeup", &Controller::wakeup)
|
|
.def("configure", &Controller::getReady)
|
|
.def("start", &Controller::start)
|
|
.def("transmit", &Controller::transmit)
|
|
.def("halt", &Controller::halt)
|
|
.def("freeze", &Controller::freeze)
|
|
.def("trigger_mts", &Controller::triggerMTS);
|
|
|
|
pybind11::class_<Controller::Configuration>(controller, "Configuration")
|
|
.def(pybind11::init())
|
|
.def_readwrite("accept_startup_range_microticks", &Controller::Configuration::AcceptStartupRangeMicroticks)
|
|
.def_readwrite("allow_passive_to_active_cycle_pairs", &Controller::Configuration::AllowPassiveToActiveCyclePairs)
|
|
.def_readwrite("cluster_drift_damping", &Controller::Configuration::ClusterDriftDamping)
|
|
.def_readwrite("channel_a", &Controller::Configuration::ChannelA)
|
|
.def_readwrite("channel_b", &Controller::Configuration::ChannelB)
|
|
.def_readwrite("decoding_correction_microticks", &Controller::Configuration::DecodingCorrectionMicroticks)
|
|
.def_readwrite("delay_compensation_a_microticks", &Controller::Configuration::DelayCompensationAMicroticks)
|
|
.def_readwrite("delay_compensation_b_microticks", &Controller::Configuration::DelayCompensationBMicroticks)
|
|
.def_readwrite("extern_offset_correction_control", &Controller::Configuration::ExternOffsetCorrectionControl)
|
|
.def_readwrite("extern_rate_correction_control", &Controller::Configuration::ExternRateCorrectionControl)
|
|
.def_readwrite("extern_offset_correction_microticks", &Controller::Configuration::ExternOffsetCorrectionMicroticks)
|
|
.def_readwrite("extern_rate_correction_microticks", &Controller::Configuration::ExternRateCorrectionMicroticks)
|
|
.def_readwrite("key_slot_id", &Controller::Configuration::KeySlotID)
|
|
.def_readwrite("key_slot_used_for_startup", &Controller::Configuration::KeySlotUsedForStartup)
|
|
.def_readwrite("key_slot_used_for_sync", &Controller::Configuration::KeySlotUsedForSync)
|
|
.def_readwrite("latest_tx_minislot", &Controller::Configuration::LatestTxMinislot)
|
|
.def_readwrite("listen_timeout", &Controller::Configuration::ListenTimeout)
|
|
.def_readwrite("macro_initial_offset_a", &Controller::Configuration::MacroInitialOffsetA)
|
|
.def_readwrite("macro_initial_offset_b", &Controller::Configuration::MacroInitialOffsetB)
|
|
.def_readwrite("micro_initial_offset_a", &Controller::Configuration::MicroInitialOffsetA)
|
|
.def_readwrite("micro_initial_offset_b", &Controller::Configuration::MicroInitialOffsetB)
|
|
.def_readwrite("micro_per_cycle", &Controller::Configuration::MicroPerCycle)
|
|
.def_readwrite("mts_on_a", &Controller::Configuration::MTSOnA)
|
|
.def_readwrite("mts_on_b", &Controller::Configuration::MTSOnB)
|
|
.def_readwrite("offset_correction_out_microticks", &Controller::Configuration::OffsetCorrectionOutMicroticks)
|
|
.def_readwrite("rate_correction_out_microticks", &Controller::Configuration::RateCorrectionOutMicroticks)
|
|
.def_readwrite("second_key_slot_id", &Controller::Configuration::SecondKeySlotID)
|
|
.def_readwrite("two_key_slot_mode", &Controller::Configuration::TwoKeySlotMode)
|
|
.def_readwrite("wakeup_pattern", &Controller::Configuration::WakeupPattern)
|
|
.def_readwrite("wakeup_on_channel_b", &Controller::Configuration::WakeupOnChannelB);
|
|
|
|
// Dummy class for cluster namespace
|
|
pybind11::class_<ClusterNamespace> cluster(c, "Cluster");
|
|
|
|
pybind11::enum_<Cluster::SpeedType>(cluster, "SpeedType")
|
|
.value("FLEXRAY_BAUDRATE_10M", Cluster::SpeedType::FLEXRAY_BAUDRATE_10M)
|
|
.value("FLEXRAY_BAUDRATE_5M", Cluster::SpeedType::FLEXRAY_BAUDRATE_5M)
|
|
.value("FLEXRAY_BAUDRATE_2M5", Cluster::SpeedType::FLEXRAY_BAUDRATE_2M5)
|
|
.value("FLEXRAY_BAUDRATE_2M5_ALT", Cluster::SpeedType::FLEXRAY_BAUDRATE_2M5_ALT);
|
|
|
|
pybind11::enum_<Cluster::SPPType>(cluster, "SPPType")
|
|
.value("FLEXRAY_SPP_5", Cluster::SPPType::FLEXRAY_SPP_5)
|
|
.value("FLEXRAY_SPP_4", Cluster::SPPType::FLEXRAY_SPP_4)
|
|
.value("FLEXRAY_SPP_6", Cluster::SPPType::FLEXRAY_SPP_6)
|
|
.value("FLEXRAY_SPP_5_ALT", Cluster::SPPType::FLEXRAY_SPP_5_ALT);
|
|
|
|
pybind11::class_<Cluster::Configuration>(cluster, "Configuration")
|
|
.def(pybind11::init())
|
|
.def_readwrite("speed", &Cluster::Configuration::Speed)
|
|
.def_readwrite("strobe_point_position", &Cluster::Configuration::StrobePointPosition)
|
|
.def_readwrite("action_point_offset", &Cluster::Configuration::ActionPointOffset)
|
|
.def_readwrite("casr_x_low_max", &Cluster::Configuration::CASRxLowMax)
|
|
.def_readwrite("cold_start_attempts", &Cluster::Configuration::ColdStartAttempts)
|
|
.def_readwrite("dynamic_slot_idle_phase_minislots", &Cluster::Configuration::DynamicSlotIdlePhaseMinislots)
|
|
.def_readwrite("listen_noise_macroticks", &Cluster::Configuration::ListenNoiseMacroticks)
|
|
.def_readwrite("macroticks_per_cycle", &Cluster::Configuration::MacroticksPerCycle)
|
|
.def_readwrite("macrotick_duration_micro_sec", &Cluster::Configuration::MacrotickDurationMicroSec)
|
|
.def_readwrite("max_without_clock_correction_fatal", &Cluster::Configuration::MaxWithoutClockCorrectionFatal)
|
|
.def_readwrite("max_without_clock_correction_passive", &Cluster::Configuration::MaxWithoutClockCorrectionPassive)
|
|
.def_readwrite("minislot_action_point_offset_macroticks", &Cluster::Configuration::MinislotActionPointOffsetMacroticks)
|
|
.def_readwrite("minislot_duration_macroticks", &Cluster::Configuration::MinislotDurationMacroticks)
|
|
.def_readwrite("network_idle_time_macroticks", &Cluster::Configuration::NetworkIdleTimeMacroticks)
|
|
.def_readwrite("network_management_vector_length_bytes", &Cluster::Configuration::NetworkManagementVectorLengthBytes)
|
|
.def_readwrite("number_of_minislots", &Cluster::Configuration::NumberOfMinislots)
|
|
.def_readwrite("number_of_static_slots", &Cluster::Configuration::NumberOfStaticSlots)
|
|
.def_readwrite("offset_correction_start_macroticks", &Cluster::Configuration::OffsetCorrectionStartMacroticks)
|
|
.def_readwrite("payload_length_of_static_slot_in_words", &Cluster::Configuration::PayloadLengthOfStaticSlotInWords)
|
|
.def_readwrite("static_slot_macroticks", &Cluster::Configuration::StaticSlotMacroticks)
|
|
.def_readwrite("symbol_window_macroticks", &Cluster::Configuration::SymbolWindowMacroticks)
|
|
.def_readwrite("symbol_window_action_point_offset_macroticks", &Cluster::Configuration::SymbolWindowActionPointOffsetMacroticks)
|
|
.def_readwrite("sync_frame_id_count_max", &Cluster::Configuration::SyncFrameIDCountMax)
|
|
.def_readwrite("transmission_start_sequence_duration_bits", &Cluster::Configuration::TransmissionStartSequenceDurationBits)
|
|
.def_readwrite("wakeup_rx_idle_bits", &Cluster::Configuration::WakeupRxIdleBits)
|
|
.def_readwrite("wakeup_rx_low_bits", &Cluster::Configuration::WakeupRxLowBits)
|
|
.def_readwrite("wakeup_rx_window_bits", &Cluster::Configuration::WakeupRxWindowBits)
|
|
.def_readwrite("wakeup_tx_active_bits", &Cluster::Configuration::WakeupTxActiveBits)
|
|
.def_readwrite("wakeup_tx_idle_bits", &Cluster::Configuration::WakeupTxIdleBits);
|
|
}
|
|
|
|
} // namespace FlexRay
|
|
|
|
void init_flexraymessage(pybind11::module_& m) {
|
|
pybind11::class_<FlexRayMessage, std::shared_ptr<FlexRayMessage>, Frame>(m, "FlexRayMessage")
|
|
.def(pybind11::init())
|
|
.def_readwrite("slotid", &FlexRayMessage::slotid)
|
|
.def_readwrite("tsslen", &FlexRayMessage::tsslen)
|
|
.def_readwrite("framelen", &FlexRayMessage::framelen)
|
|
.def_readwrite("symbol", &FlexRayMessage::symbol)
|
|
.def_readwrite("header_crc_status", &FlexRayMessage::headerCRCStatus)
|
|
.def_readwrite("header_crc", &FlexRayMessage::headerCRC)
|
|
.def_readwrite("frame_crc_status", &FlexRayMessage::crcStatus)
|
|
.def_readwrite("frame_crc", &FlexRayMessage::frameCRC)
|
|
.def_readwrite("channel", &FlexRayMessage::channel)
|
|
.def_readwrite("null_frame", &FlexRayMessage::nullFrame)
|
|
.def_readwrite("payload_preamble", &FlexRayMessage::payloadPreamble)
|
|
.def_readwrite("sync_frame", &FlexRayMessage::sync)
|
|
.def_readwrite("startup_frame", &FlexRayMessage::startup)
|
|
.def_readwrite("dynamic_frame", &FlexRayMessage::dynamic)
|
|
.def_readwrite("cycle", &FlexRayMessage::cycle);
|
|
|
|
//// TODO: Eliminate FlexRayControlMessage class references in controller class and eliminate getStatus function in bindings
|
|
}
|
|
|
|
void init_flexray(pybind11::module_& m) {
|
|
// Dummy class to act as FlexRay namespace
|
|
pybind11::class_<FlexRayNamespace> flexray(m, "FlexRay");
|
|
|
|
pybind11::enum_<FlexRayNamespace::Symbol>(flexray, "Symbol")
|
|
.value("None", FlexRayNamespace::Symbol::None)
|
|
.value("Unknown", FlexRayNamespace::Symbol::Unknown)
|
|
.value("Wakeup", FlexRayNamespace::Symbol::Wakeup)
|
|
.value("CAS", FlexRayNamespace::Symbol::CAS);
|
|
pybind11::enum_<FlexRayNamespace::CRCStatus>(flexray, "CRCStatus")
|
|
.value("OK", FlexRayNamespace::CRCStatus::OK)
|
|
.value("Error", FlexRayNamespace::CRCStatus::Error)
|
|
.value("NoCRC", FlexRayNamespace::CRCStatus::NoCRC);
|
|
pybind11::enum_<FlexRayNamespace::Channel>(flexray, "Channel")
|
|
.value("None", FlexRayNamespace::Channel::None)
|
|
.value("A", FlexRayNamespace::Channel::A)
|
|
.value("B", FlexRayNamespace::Channel::B)
|
|
.value("AB", FlexRayNamespace::Channel::AB);
|
|
|
|
init_flexraymessage(m);
|
|
FlexRay::init_extension(flexray);
|
|
}
|
|
|
|
} // namespace icsneo
|
|
|