diff --git a/dse/ncodec/examples/CMakeLists.txt b/dse/ncodec/examples/CMakeLists.txt index e1e58b5..9fe3f40 100644 --- a/dse/ncodec/examples/CMakeLists.txt +++ b/dse/ncodec/examples/CMakeLists.txt @@ -5,6 +5,7 @@ # Example Models. add_subdirectory(codec) +add_subdirectory(fmpy) # Code examples for documentation. #if(UNIX) diff --git a/dse/ncodec/examples/fmpy/CMakeLists.txt b/dse/ncodec/examples/fmpy/CMakeLists.txt new file mode 100644 index 0000000..73f8408 --- /dev/null +++ b/dse/ncodec/examples/fmpy/CMakeLists.txt @@ -0,0 +1,40 @@ +# Copyright 2025 Robert Bosch GmbH +# +# SPDX-License-Identifier: Apache-2.0 + +cmake_minimum_required(VERSION 3.21) +project(python_ncodec) + +set(EXAMPLE_PATH "examples/fmpy") +set(FLATCC_SOURCE_DIR ${DSE_NCODEC_SOURCE_DIR}/schema/abs/flatcc/src) +set(FLATCC_INCLUDE_DIR ${DSE_NCODEC_SOURCE_DIR}/schema/abs/flatcc/include) + +add_library(ncodec SHARED + ncodec.c + ${DSE_NCODEC_SOURCE_DIR}/stream/buffer.c + ${DSE_NCODEC_SOURCE_DIR}/codec/ab/codec.c + ${DSE_NCODEC_SOURCE_DIR}/codec/ab/frame_fbs.c + ${DSE_NCODEC_SOURCE_DIR}/codec/ab/pdu_fbs.c + ${DSE_NCODEC_SOURCE_DIR}/codec.c + ${FLATCC_SOURCE_DIR}/builder.c + ${FLATCC_SOURCE_DIR}/emitter.c + ${FLATCC_SOURCE_DIR}/refmap.c +) +target_include_directories(ncodec + PRIVATE + ${DSE_NCODEC_INCLUDE_DIR} + ${DSE_CLIB_INCLUDE_DIR} + ${FLATCC_INCLUDE_DIR} +) +install(TARGETS ncodec + LIBRARY DESTINATION + ${EXAMPLE_PATH}/lib + RUNTIME DESTINATION + ${EXAMPLE_PATH}/lib +) +install( + FILES + simulation.py + DESTINATION + ${EXAMPLE_PATH} +) diff --git a/dse/ncodec/examples/fmpy/README.md b/dse/ncodec/examples/fmpy/README.md new file mode 100644 index 0000000..8518d38 --- /dev/null +++ b/dse/ncodec/examples/fmpy/README.md @@ -0,0 +1,39 @@ + + +# DSE NCodec Example: FMPy Integration + + +```bash +# Clone and build the examples. +$ git clone https://github.com/boschglobal/dse.ncodec.git +$ cd dse.ncodec +$ make + +# Change to the FMPy example directory. +$ cd dse/ncodec/build/_out/examples/fmpy + +# Download the FMU. +$ export FMU_URL=https://github.com/boschglobal/dse.fmi/releases/download/v1.1.28/example-network-linux-amd64-fmi2.fmu +$ curl -fSL $FMU_URL --create-dirs --output fmu/example-network-fmi2.fmu +$ ls -1shR +.: +total 8.0K + 0 fmu/ + 0 lib/ +8.0K simulation.py* + +./fmu: +total 688K +688K example-network-fmi2.fmu* + +./lib: +total 500K +500K libncodec.so* + +# Run the simulation. +$ python simulation.py +``` diff --git a/dse/ncodec/examples/fmpy/ncodec.c b/dse/ncodec/examples/fmpy/ncodec.c new file mode 100644 index 0000000..7089e3f --- /dev/null +++ b/dse/ncodec/examples/fmpy/ncodec.c @@ -0,0 +1,77 @@ +// Copyright 2025 Robert Bosch GmbH +// +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include + + +DLL_PUBLIC void* ncodec_open_with_stream(const char* mime_type) +{ + NCODEC* nc = ncodec_create(mime_type); + if (nc) { + NCodecInstance* _nc = (NCodecInstance*)nc; + NCodecStreamVTable* stream = ncodec_buffer_stream_create(0); + _nc->stream = stream; + } + return (void*)nc; +} + +DLL_PUBLIC int64_t ncodec_write_pdu_msg( + void* nc, uint32_t id, uint8_t* payload, size_t payload_len) +{ + return ncodec_write(nc, &(struct NCodecPdu){ + .id = id, + .payload = payload, + .payload_len = payload_len + }); +} + +DLL_PUBLIC int64_t ncodec_read_pdu_msg(void* nc, + uint32_t* id, uint8_t** payload, size_t* payload_len) +{ + NCodecPdu msg = {}; + int64_t rc = ncodec_read(nc, &msg); + if (rc > 0) { + *id = msg.id; + *payload = malloc(msg.payload_len); + memcpy(*payload, msg.payload, msg.payload_len); + *payload_len = msg.payload_len; + } + return rc; +} + +DLL_PUBLIC int64_t ncodec_write_stream(void* nc, uint8_t* buffer, size_t len) +{ + NCodecInstance* _nc = (NCodecInstance*)nc; + if (_nc && _nc->stream && _nc->stream->write) { + ncodec_truncate(nc); + _nc->stream->write((NCODEC*)nc, buffer, len); + ncodec_seek(nc, 0, NCODEC_SEEK_SET); // Position for reading. + return len; + } else { + return -ENOSTR; + } +} + +DLL_PUBLIC size_t ncodec_read_stream(void* nc, uint8_t** buffer) +{ + NCodecInstance* _nc = (NCodecInstance*)nc; + if (_nc && _nc->stream && _nc->stream->read) { + size_t len = ncodec_flush(nc); + ncodec_seek(nc, 0, NCODEC_SEEK_SET); + *buffer = malloc(len); + return _nc->stream->read(nc, buffer, &len, NCODEC_POS_UPDATE); + } else { + return -ENOSTR; + } +} + +DLL_PUBLIC void ncodec_free(uint8_t* buffer) +{ + free(buffer); +} diff --git a/dse/ncodec/examples/fmpy/simulation.py b/dse/ncodec/examples/fmpy/simulation.py new file mode 100644 index 0000000..4072416 --- /dev/null +++ b/dse/ncodec/examples/fmpy/simulation.py @@ -0,0 +1,114 @@ +# Copyright 2025 Robert Bosch GmbH +# SPDX-License-Identifier: Apache-2.0 + +import base64 +import ctypes +from ctypes import * +from typing import List +from fmpy import simulate_fmu, read_model_description, extract +from fmpy.fmi2 import FMU2Slave +from ncodec.codec_interface import CodecFactory, ICodec +from ncodec.pdu import PduMessage + + +# Global objects: +fmu = None +nc = None +network_rx_ref = None +network_tx_ref = None +id : c_uint32 = 0 + + +def do_network(): + global nc + global id + + # Fetch the stream from FMU and write to NCodec: + stream = bytearray() + tx_message_hex = fmu.getString([network_tx_ref])[0] + if tx_message_hex is not None: + stream = base64.a85decode(tx_message_hex) + + # Read messages from the NCodec: + nc.Stream = stream + read_pdus : List[PduMessage] = nc.Read() + for pdus in read_pdus: + print(f' Received PDU from model: {pdus.id}') + + # Write messages to the NCodec: + message = PduMessage( + id, + bytes([0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x07]), + 0 + ) + id += 1 + + # Send the NCodec stream to FMU: + nc.Write([message]) + nc.Flush() + rx_message_hex = base64.a85encode(nc.Stream, adobe=False) + rx_message_hex = rx_message_hex.decode('utf-8') + fmu.setString([network_rx_ref], [rx_message_hex]) + nc.Truncate() + + +def simulation_setup(): + # Setup FMU: + global fmu + fmu_filename = r"fmu/example-network-fmi2.fmu" + unzipdir = extract(r"fmu/example-network-fmi2.fmu") + model_desc = read_model_description(fmu_filename) + fmu = FMU2Slave( + guid=model_desc.guid, + modelIdentifier=model_desc.coSimulation.modelIdentifier, + unzipDirectory=unzipdir, + instanceName="network" + ) + + # Locate network variables + global network_rx_ref + global network_tx_ref + network_rx_var = next((var for var in model_desc.modelVariables if var.name == "pdu_rx"), None) + network_tx_var = next((var for var in model_desc.modelVariables if var.name == "pdu_tx"), None) + if network_rx_var: + network_rx_ref = network_rx_var.valueReference + else: + raise ValueError("pdu_rx not found in the FMU.") + if network_tx_var: + network_tx_ref = network_tx_var.valueReference + else: + raise ValueError("pdu_tx not found in the FMU.") + + +def simulation_instantiate(): + global fmu + fmu.instantiate(loggingOn=True) + fmu.setupExperiment(startTime=0.0, stopTime=4.0, tolerance=None) + fmu.enterInitializationMode() + fmu.exitInitializationMode() + + global nc + nc = CodecFactory.create_codec("application/x-automotive-bus; interface=stream; type=pdu; schema=fbs; swc_id=1; ecu_id=7", bytearray(), "Test", 0.0) + + +def simulation_terminate(): + global fmu + fmu.terminate() + fmu.freeInstance() + + # global nc + # ncodecDLL.ncodec_close(nc) + + +# Run the simulation +simulation_setup() +simulation_instantiate() + +step_size = 0.0005 +current_time = 0.0 +while current_time < 4.0: + do_network() + fmu.doStep(currentCommunicationPoint=current_time, communicationStepSize=step_size) + current_time += step_size + +simulation_terminate() diff --git a/extra/python/.gitignore b/extra/python/.gitignore new file mode 100644 index 0000000..97a27e4 --- /dev/null +++ b/extra/python/.gitignore @@ -0,0 +1,5 @@ +__pycache__/ +.dist-info/ +build/ +*.pyc +.venv/ diff --git a/extra/python/README.md b/extra/python/README.md new file mode 100644 index 0000000..16a349c --- /dev/null +++ b/extra/python/README.md @@ -0,0 +1,41 @@ +# extra.python + +This directory contains the Python package for the `dse.ncodec` project. + +Layout +- `src/` — source packages (importable packages live under `src/`) +- `tests/` — unit tests (pytest) +- `pyproject.toml` — build metadata and packaging configuration +- `README.md` — this file + +Install + +Create a virtual environment and install the package in editable mode for development: + +```bash +cd dse.ncodec/extra/python +python -m venv .venv +source .venv/bin/activate +pip install -e .[test] +``` + +Quick usage + +```py + +``` + +Run tests + +```bash +pytest +``` + +Development notes + +- The package uses a src-layout so packaging tools find packages under `src/`. +- Follow the repository license in the top-level `LICENSE` file. + +Contact + +Please update `pyproject.toml` authors and metadata with the appropriate project contact information. diff --git a/extra/python/pyproject.toml b/extra/python/pyproject.toml new file mode 100644 index 0000000..58f390a --- /dev/null +++ b/extra/python/pyproject.toml @@ -0,0 +1,25 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "ncodec" +version = "0.0.1" +description = "Python implementation of the dse.ncodec project." +authors = [ + { name = "Your Name", email = "your.email@example.com" } +] +readme = "README.md" +requires-python = ">=3.8" +license = { file = "../LICENSE" } +classifiers = [ + "Programming Language :: Python :: 3", + "Operating System :: OS Independent", +] +keywords = ["ncodec", "codec", "bosch"] + +[project.optional-dependencies] +test = ["pytest>=6.0","flatbuffers==1.12"] + +[tool.setuptools.packages.find] +where = ["src"] diff --git a/extra/python/pytest.ini b/extra/python/pytest.ini new file mode 100644 index 0000000..b6efe94 --- /dev/null +++ b/extra/python/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +minversion = 6.0 +addopts = -q +testpaths = tests diff --git a/extra/python/src/AutomotiveBus/Register/Can/BufferDirection.py b/extra/python/src/AutomotiveBus/Register/Can/BufferDirection.py new file mode 100644 index 0000000..42a7e44 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/BufferDirection.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +class BufferDirection(object): + Tx = 0 + Rx = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Can/BufferStatus.py b/extra/python/src/AutomotiveBus/Register/Can/BufferStatus.py new file mode 100644 index 0000000..b58bd76 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/BufferStatus.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +class BufferStatus(object): + None_ = 0 + RxError = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Can/BusState.py b/extra/python/src/AutomotiveBus/Register/Can/BusState.py new file mode 100644 index 0000000..0185b4c --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/BusState.py @@ -0,0 +1,9 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +class BusState(object): + BusOff = 0 + Idle = 1 + Sync = 2 + diff --git a/extra/python/src/AutomotiveBus/Register/Can/CanStatus.py b/extra/python/src/AutomotiveBus/Register/Can/CanStatus.py new file mode 100644 index 0000000..2bca5e4 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/CanStatus.py @@ -0,0 +1,49 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CanStatus(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CanStatus() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCanStatus(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CanStatusBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x43\x41", size_prefixed=size_prefixed) + + # CanStatus + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CanStatus + def Sync(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 1 + +def Start(builder): builder.StartObject(1) +def CanStatusStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSync(builder, sync): builder.PrependInt8Slot(0, sync, 1) +def CanStatusAddSync(builder, sync): + """This method is deprecated. Please switch to AddSync.""" + return AddSync(builder, sync) +def End(builder): return builder.EndObject() +def CanStatusEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Can/Frame.py b/extra/python/src/AutomotiveBus/Register/Can/Frame.py new file mode 100644 index 0000000..ec9c09a --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/Frame.py @@ -0,0 +1,117 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Frame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Frame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x43\x41", size_prefixed=size_prefixed) + + # Frame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Frame + def FrameId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Frame + def Payload(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Frame + def PayloadAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Frame + def PayloadLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Frame + def PayloadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Frame + def Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Frame + def Rtr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # Frame + def FrameType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(5) +def FrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFrameId(builder, frameId): builder.PrependUint32Slot(0, frameId, 0) +def FrameAddFrameId(builder, frameId): + """This method is deprecated. Please switch to AddFrameId.""" + return AddFrameId(builder, frameId) +def AddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0) +def FrameAddPayload(builder, payload): + """This method is deprecated. Please switch to AddPayload.""" + return AddPayload(builder, payload) +def StartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def FrameStartPayloadVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartPayloadVector(builder, numElems) +def AddLength(builder, length): builder.PrependUint8Slot(2, length, 0) +def FrameAddLength(builder, length): + """This method is deprecated. Please switch to AddLength.""" + return AddLength(builder, length) +def AddRtr(builder, rtr): builder.PrependBoolSlot(3, rtr, 0) +def FrameAddRtr(builder, rtr): + """This method is deprecated. Please switch to AddRtr.""" + return AddRtr(builder, rtr) +def AddFrameType(builder, frameType): builder.PrependInt8Slot(4, frameType, 0) +def FrameAddFrameType(builder, frameType): + """This method is deprecated. Please switch to AddFrameType.""" + return AddFrameType(builder, frameType) +def End(builder): return builder.EndObject() +def FrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Can/FrameType.py b/extra/python/src/AutomotiveBus/Register/Can/FrameType.py new file mode 100644 index 0000000..36d76b7 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/FrameType.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +class FrameType(object): + StandardFrame = 0 + ExtendedFrame = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Can/MessageTiming.py b/extra/python/src/AutomotiveBus/Register/Can/MessageTiming.py new file mode 100644 index 0000000..be7f663 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/MessageTiming.py @@ -0,0 +1,44 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MessageTiming(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 24 + + # MessageTiming + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MessageTiming + def SendRequest(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 0) + return obj + + # MessageTiming + def Arbitration(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 8) + return obj + + # MessageTiming + def Reception(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 16) + return obj + + +def CreateMessageTiming(builder, send_request_psec10, arbitration_psec10, reception_psec10): + builder.Prep(8, 24) + builder.Prep(8, 8) + builder.PrependInt64(reception_psec10) + builder.Prep(8, 8) + builder.PrependInt64(arbitration_psec10) + builder.Prep(8, 8) + builder.PrependInt64(send_request_psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/Can/MetaFrame.py b/extra/python/src/AutomotiveBus/Register/Can/MetaFrame.py new file mode 100644 index 0000000..24c0361 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/MetaFrame.py @@ -0,0 +1,101 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MetaFrame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MetaFrame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsMetaFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MetaFrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x43\x41", size_prefixed=size_prefixed) + + # MetaFrame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MetaFrame + def Status(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def Direction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def CanFdEnabled(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # MetaFrame + def Frame(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from AutomotiveBus.Register.Can.Frame import Frame + obj = Frame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # MetaFrame + def Timing(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + x = o + self._tab.Pos + from AutomotiveBus.Register.Can.MessageTiming import MessageTiming + obj = MessageTiming() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def Start(builder): builder.StartObject(5) +def MetaFrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddStatus(builder, status): builder.PrependInt8Slot(0, status, 0) +def MetaFrameAddStatus(builder, status): + """This method is deprecated. Please switch to AddStatus.""" + return AddStatus(builder, status) +def AddDirection(builder, direction): builder.PrependInt8Slot(1, direction, 0) +def MetaFrameAddDirection(builder, direction): + """This method is deprecated. Please switch to AddDirection.""" + return AddDirection(builder, direction) +def AddCanFdEnabled(builder, canFdEnabled): builder.PrependBoolSlot(2, canFdEnabled, 0) +def MetaFrameAddCanFdEnabled(builder, canFdEnabled): + """This method is deprecated. Please switch to AddCanFdEnabled.""" + return AddCanFdEnabled(builder, canFdEnabled) +def AddFrame(builder, frame): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(frame), 0) +def MetaFrameAddFrame(builder, frame): + """This method is deprecated. Please switch to AddFrame.""" + return AddFrame(builder, frame) +def AddTiming(builder, timing): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(timing), 0) +def MetaFrameAddTiming(builder, timing): + """This method is deprecated. Please switch to AddTiming.""" + return AddTiming(builder, timing) +def End(builder): return builder.EndObject() +def MetaFrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Can/RegisterFile.py b/extra/python/src/AutomotiveBus/Register/Can/RegisterFile.py new file mode 100644 index 0000000..0ccc958 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/RegisterFile.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RegisterFile(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RegisterFile() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsRegisterFile(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RegisterFileBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x43\x41", size_prefixed=size_prefixed) + + # RegisterFile + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RegisterFile + def Buffer(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Register.Can.MetaFrame import MetaFrame + obj = MetaFrame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # RegisterFile + def BufferLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # RegisterFile + def BufferIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def RegisterFileStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddBuffer(builder, buffer): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(buffer), 0) +def RegisterFileAddBuffer(builder, buffer): + """This method is deprecated. Please switch to AddBuffer.""" + return AddBuffer(builder, buffer) +def StartBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def RegisterFileStartBufferVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartBufferVector(builder, numElems) +def End(builder): return builder.EndObject() +def RegisterFileEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Can/TimeSpec.py b/extra/python/src/AutomotiveBus/Register/Can/TimeSpec.py new file mode 100644 index 0000000..7f3670c --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Can/TimeSpec.py @@ -0,0 +1,26 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Can + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TimeSpec(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 8 + + # TimeSpec + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TimeSpec + def Psec10(self): return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0)) + +def CreateTimeSpec(builder, psec10): + builder.Prep(8, 8) + builder.PrependInt64(psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/Can/__init__.py b/extra/python/src/AutomotiveBus/Register/Can/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/BufferDirection.py b/extra/python/src/AutomotiveBus/Register/Ethernet/BufferDirection.py new file mode 100644 index 0000000..1f4f64a --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/BufferDirection.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +class BufferDirection(object): + Tx = 0 + Rx = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/BufferStatus.py b/extra/python/src/AutomotiveBus/Register/Ethernet/BufferStatus.py new file mode 100644 index 0000000..fc3ca35 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/BufferStatus.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +class BufferStatus(object): + None_ = 0 + RxError = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/BusSync.py b/extra/python/src/AutomotiveBus/Register/Ethernet/BusSync.py new file mode 100644 index 0000000..5fa5147 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/BusSync.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +class BusSync(object): + NoSync = 0 + Sync = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/EthernetStatus.py b/extra/python/src/AutomotiveBus/Register/Ethernet/EthernetStatus.py new file mode 100644 index 0000000..804c473 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/EthernetStatus.py @@ -0,0 +1,49 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class EthernetStatus(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = EthernetStatus() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsEthernetStatus(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def EthernetStatusBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x45\x4E", size_prefixed=size_prefixed) + + # EthernetStatus + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # EthernetStatus + def Sync(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(1) +def EthernetStatusStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSync(builder, sync): builder.PrependInt8Slot(0, sync, 0) +def EthernetStatusAddSync(builder, sync): + """This method is deprecated. Please switch to AddSync.""" + return AddSync(builder, sync) +def End(builder): return builder.EndObject() +def EthernetStatusEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/Frame.py b/extra/python/src/AutomotiveBus/Register/Ethernet/Frame.py new file mode 100644 index 0000000..2e1d7a1 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/Frame.py @@ -0,0 +1,176 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Frame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Frame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x45\x4E", size_prefixed=size_prefixed) + + # Frame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Frame + def DestMac(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Frame + def DestMacAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Frame + def DestMacLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Frame + def DestMacIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # Frame + def SrcMac(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Frame + def SrcMacAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Frame + def SrcMacLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Frame + def SrcMacIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Frame + def VlanTag(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 + + # Frame + def EtherType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # Frame + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Frame + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Frame + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Frame + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + + # Frame + def Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(6) +def FrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddDestMac(builder, destMac): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(destMac), 0) +def FrameAddDestMac(builder, destMac): + """This method is deprecated. Please switch to AddDestMac.""" + return AddDestMac(builder, destMac) +def StartDestMacVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def FrameStartDestMacVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDestMacVector(builder, numElems) +def AddSrcMac(builder, srcMac): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(srcMac), 0) +def FrameAddSrcMac(builder, srcMac): + """This method is deprecated. Please switch to AddSrcMac.""" + return AddSrcMac(builder, srcMac) +def StartSrcMacVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def FrameStartSrcMacVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartSrcMacVector(builder, numElems) +def AddVlanTag(builder, vlanTag): builder.PrependUint64Slot(2, vlanTag, 0) +def FrameAddVlanTag(builder, vlanTag): + """This method is deprecated. Please switch to AddVlanTag.""" + return AddVlanTag(builder, vlanTag) +def AddEtherType(builder, etherType): builder.PrependUint16Slot(3, etherType, 0) +def FrameAddEtherType(builder, etherType): + """This method is deprecated. Please switch to AddEtherType.""" + return AddEtherType(builder, etherType) +def AddData(builder, data): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def FrameAddData(builder, data): + """This method is deprecated. Please switch to AddData.""" + return AddData(builder, data) +def StartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def FrameStartDataVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDataVector(builder, numElems) +def AddLength(builder, length): builder.PrependUint16Slot(5, length, 0) +def FrameAddLength(builder, length): + """This method is deprecated. Please switch to AddLength.""" + return AddLength(builder, length) +def End(builder): return builder.EndObject() +def FrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/MessageTiming.py b/extra/python/src/AutomotiveBus/Register/Ethernet/MessageTiming.py new file mode 100644 index 0000000..69089a8 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/MessageTiming.py @@ -0,0 +1,44 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MessageTiming(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 24 + + # MessageTiming + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MessageTiming + def SendRequest(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 0) + return obj + + # MessageTiming + def Arbitration(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 8) + return obj + + # MessageTiming + def Reception(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 16) + return obj + + +def CreateMessageTiming(builder, send_request_psec10, arbitration_psec10, reception_psec10): + builder.Prep(8, 24) + builder.Prep(8, 8) + builder.PrependInt64(reception_psec10) + builder.Prep(8, 8) + builder.PrependInt64(arbitration_psec10) + builder.Prep(8, 8) + builder.PrependInt64(send_request_psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/MetaFrame.py b/extra/python/src/AutomotiveBus/Register/Ethernet/MetaFrame.py new file mode 100644 index 0000000..b39c424 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/MetaFrame.py @@ -0,0 +1,90 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MetaFrame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MetaFrame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsMetaFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MetaFrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x45\x4E", size_prefixed=size_prefixed) + + # MetaFrame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MetaFrame + def Status(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def Direction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def Frame(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from AutomotiveBus.Register.Ethernet.Frame import Frame + obj = Frame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # MetaFrame + def Timing(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + x = o + self._tab.Pos + from AutomotiveBus.Register.Ethernet.MessageTiming import MessageTiming + obj = MessageTiming() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def Start(builder): builder.StartObject(4) +def MetaFrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddStatus(builder, status): builder.PrependInt8Slot(0, status, 0) +def MetaFrameAddStatus(builder, status): + """This method is deprecated. Please switch to AddStatus.""" + return AddStatus(builder, status) +def AddDirection(builder, direction): builder.PrependInt8Slot(1, direction, 0) +def MetaFrameAddDirection(builder, direction): + """This method is deprecated. Please switch to AddDirection.""" + return AddDirection(builder, direction) +def AddFrame(builder, frame): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(frame), 0) +def MetaFrameAddFrame(builder, frame): + """This method is deprecated. Please switch to AddFrame.""" + return AddFrame(builder, frame) +def AddTiming(builder, timing): builder.PrependStructSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(timing), 0) +def MetaFrameAddTiming(builder, timing): + """This method is deprecated. Please switch to AddTiming.""" + return AddTiming(builder, timing) +def End(builder): return builder.EndObject() +def MetaFrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/RegisterFile.py b/extra/python/src/AutomotiveBus/Register/Ethernet/RegisterFile.py new file mode 100644 index 0000000..f0bc39d --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/RegisterFile.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RegisterFile(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RegisterFile() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsRegisterFile(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RegisterFileBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x45\x4E", size_prefixed=size_prefixed) + + # RegisterFile + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RegisterFile + def Buffer(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Register.Ethernet.MetaFrame import MetaFrame + obj = MetaFrame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # RegisterFile + def BufferLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # RegisterFile + def BufferIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def RegisterFileStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddBuffer(builder, buffer): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(buffer), 0) +def RegisterFileAddBuffer(builder, buffer): + """This method is deprecated. Please switch to AddBuffer.""" + return AddBuffer(builder, buffer) +def StartBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def RegisterFileStartBufferVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartBufferVector(builder, numElems) +def End(builder): return builder.EndObject() +def RegisterFileEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/TimeSpec.py b/extra/python/src/AutomotiveBus/Register/Ethernet/TimeSpec.py new file mode 100644 index 0000000..44641db --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/Ethernet/TimeSpec.py @@ -0,0 +1,26 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Ethernet + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TimeSpec(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 8 + + # TimeSpec + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TimeSpec + def Psec10(self): return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0)) + +def CreateTimeSpec(builder, psec10): + builder.Prep(8, 8) + builder.PrependInt64(psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/Ethernet/__init__.py b/extra/python/src/AutomotiveBus/Register/Ethernet/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/BufferDirection.py b/extra/python/src/AutomotiveBus/Register/FlexRay/BufferDirection.py new file mode 100644 index 0000000..975d5f5 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/BufferDirection.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +class BufferDirection(object): + Tx = 0 + Rx = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/BufferStatus.py b/extra/python/src/AutomotiveBus/Register/FlexRay/BufferStatus.py new file mode 100644 index 0000000..716cd06 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/BufferStatus.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +class BufferStatus(object): + None_ = 0 + RxError = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/BusSync.py b/extra/python/src/AutomotiveBus/Register/FlexRay/BusSync.py new file mode 100644 index 0000000..4433654 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/BusSync.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +class BusSync(object): + NoSync = 0 + Sync = 1 + diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/FlexrayStatus.py b/extra/python/src/AutomotiveBus/Register/FlexRay/FlexrayStatus.py new file mode 100644 index 0000000..5ea905c --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/FlexrayStatus.py @@ -0,0 +1,49 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FlexrayStatus(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FlexrayStatus() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFlexrayStatus(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FlexrayStatusBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x46\x52", size_prefixed=size_prefixed) + + # FlexrayStatus + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # FlexrayStatus + def Sync(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(1) +def FlexrayStatusStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSync(builder, sync): builder.PrependInt8Slot(0, sync, 0) +def FlexrayStatusAddSync(builder, sync): + """This method is deprecated. Please switch to AddSync.""" + return AddSync(builder, sync) +def End(builder): return builder.EndObject() +def FlexrayStatusEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/Frame.py b/extra/python/src/AutomotiveBus/Register/FlexRay/Frame.py new file mode 100644 index 0000000..21872d4 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/Frame.py @@ -0,0 +1,106 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Frame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Frame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x46\x52", size_prefixed=size_prefixed) + + # Frame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Frame + def FrameId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 1 + + # Frame + def Indicators(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 12 + + # Frame + def Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 1 + + # Frame + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Frame + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Frame + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Frame + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + +def Start(builder): builder.StartObject(4) +def FrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFrameId(builder, frameId): builder.PrependUint16Slot(0, frameId, 1) +def FrameAddFrameId(builder, frameId): + """This method is deprecated. Please switch to AddFrameId.""" + return AddFrameId(builder, frameId) +def AddIndicators(builder, indicators): builder.PrependUint8Slot(1, indicators, 12) +def FrameAddIndicators(builder, indicators): + """This method is deprecated. Please switch to AddIndicators.""" + return AddIndicators(builder, indicators) +def AddLength(builder, length): builder.PrependUint8Slot(2, length, 1) +def FrameAddLength(builder, length): + """This method is deprecated. Please switch to AddLength.""" + return AddLength(builder, length) +def AddData(builder, data): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def FrameAddData(builder, data): + """This method is deprecated. Please switch to AddData.""" + return AddData(builder, data) +def StartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def FrameStartDataVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDataVector(builder, numElems) +def End(builder): return builder.EndObject() +def FrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/FrameChannel.py b/extra/python/src/AutomotiveBus/Register/FlexRay/FrameChannel.py new file mode 100644 index 0000000..c1b1b51 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/FrameChannel.py @@ -0,0 +1,10 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +class FrameChannel(object): + None_ = 0 + ChA = 1 + ChB = 2 + Both = 3 + diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/FrameIndicatorBits.py b/extra/python/src/AutomotiveBus/Register/FlexRay/FrameIndicatorBits.py new file mode 100644 index 0000000..d3be839 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/FrameIndicatorBits.py @@ -0,0 +1,11 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +class FrameIndicatorBits(object): + Startup = 1 + Sync = 2 + NotNull = 4 + Payload = 8 + Reserved = 16 + diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/MessageTiming.py b/extra/python/src/AutomotiveBus/Register/FlexRay/MessageTiming.py new file mode 100644 index 0000000..f0ea9f3 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/MessageTiming.py @@ -0,0 +1,44 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MessageTiming(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 24 + + # MessageTiming + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MessageTiming + def SendRequest(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 0) + return obj + + # MessageTiming + def Arbitration(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 8) + return obj + + # MessageTiming + def Reception(self, obj): + obj.Init(self._tab.Bytes, self._tab.Pos + 16) + return obj + + +def CreateMessageTiming(builder, send_request_psec10, arbitration_psec10, reception_psec10): + builder.Prep(8, 24) + builder.Prep(8, 8) + builder.PrependInt64(reception_psec10) + builder.Prep(8, 8) + builder.PrependInt64(arbitration_psec10) + builder.Prep(8, 8) + builder.PrependInt64(send_request_psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/MetaFrame.py b/extra/python/src/AutomotiveBus/Register/FlexRay/MetaFrame.py new file mode 100644 index 0000000..9dc4f43 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/MetaFrame.py @@ -0,0 +1,123 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MetaFrame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MetaFrame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsMetaFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MetaFrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x46\x52", size_prefixed=size_prefixed) + + # MetaFrame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MetaFrame + def Status(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def Direction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def ChannelMask(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 1 + + # MetaFrame + def CyclePeriod(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 1 + + # MetaFrame + def CycleOffset(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # MetaFrame + def Frame(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from AutomotiveBus.Register.FlexRay.Frame import Frame + obj = Frame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # MetaFrame + def Timing(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + x = o + self._tab.Pos + from AutomotiveBus.Register.FlexRay.MessageTiming import MessageTiming + obj = MessageTiming() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def Start(builder): builder.StartObject(7) +def MetaFrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddStatus(builder, status): builder.PrependInt8Slot(0, status, 0) +def MetaFrameAddStatus(builder, status): + """This method is deprecated. Please switch to AddStatus.""" + return AddStatus(builder, status) +def AddDirection(builder, direction): builder.PrependInt8Slot(1, direction, 0) +def MetaFrameAddDirection(builder, direction): + """This method is deprecated. Please switch to AddDirection.""" + return AddDirection(builder, direction) +def AddChannelMask(builder, channelMask): builder.PrependUint8Slot(2, channelMask, 1) +def MetaFrameAddChannelMask(builder, channelMask): + """This method is deprecated. Please switch to AddChannelMask.""" + return AddChannelMask(builder, channelMask) +def AddCyclePeriod(builder, cyclePeriod): builder.PrependUint8Slot(3, cyclePeriod, 1) +def MetaFrameAddCyclePeriod(builder, cyclePeriod): + """This method is deprecated. Please switch to AddCyclePeriod.""" + return AddCyclePeriod(builder, cyclePeriod) +def AddCycleOffset(builder, cycleOffset): builder.PrependUint8Slot(4, cycleOffset, 0) +def MetaFrameAddCycleOffset(builder, cycleOffset): + """This method is deprecated. Please switch to AddCycleOffset.""" + return AddCycleOffset(builder, cycleOffset) +def AddFrame(builder, frame): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(frame), 0) +def MetaFrameAddFrame(builder, frame): + """This method is deprecated. Please switch to AddFrame.""" + return AddFrame(builder, frame) +def AddTiming(builder, timing): builder.PrependStructSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(timing), 0) +def MetaFrameAddTiming(builder, timing): + """This method is deprecated. Please switch to AddTiming.""" + return AddTiming(builder, timing) +def End(builder): return builder.EndObject() +def MetaFrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/RegisterFile.py b/extra/python/src/AutomotiveBus/Register/FlexRay/RegisterFile.py new file mode 100644 index 0000000..4183d79 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/RegisterFile.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RegisterFile(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RegisterFile() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsRegisterFile(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RegisterFileBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x49\x46\x52", size_prefixed=size_prefixed) + + # RegisterFile + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RegisterFile + def Buffer(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Register.FlexRay.MetaFrame import MetaFrame + obj = MetaFrame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # RegisterFile + def BufferLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # RegisterFile + def BufferIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def RegisterFileStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddBuffer(builder, buffer): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(buffer), 0) +def RegisterFileAddBuffer(builder, buffer): + """This method is deprecated. Please switch to AddBuffer.""" + return AddBuffer(builder, buffer) +def StartBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def RegisterFileStartBufferVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartBufferVector(builder, numElems) +def End(builder): return builder.EndObject() +def RegisterFileEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/TimeSpec.py b/extra/python/src/AutomotiveBus/Register/FlexRay/TimeSpec.py new file mode 100644 index 0000000..7fc318d --- /dev/null +++ b/extra/python/src/AutomotiveBus/Register/FlexRay/TimeSpec.py @@ -0,0 +1,26 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: FlexRay + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TimeSpec(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 8 + + # TimeSpec + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TimeSpec + def Psec10(self): return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0)) + +def CreateTimeSpec(builder, psec10): + builder.Prep(8, 8) + builder.PrependInt64(psec10) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Register/FlexRay/__init__.py b/extra/python/src/AutomotiveBus/Register/FlexRay/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Register/__init__.py b/extra/python/src/AutomotiveBus/Register/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/ChannelMessage.py b/extra/python/src/AutomotiveBus/Signal/Channel/ChannelMessage.py new file mode 100644 index 0000000..7f1388d --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/ChannelMessage.py @@ -0,0 +1,118 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ChannelMessage(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ChannelMessage() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsChannelMessage(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ChannelMessageBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # ChannelMessage + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ChannelMessage + def ModelUid(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # ChannelMessage + def MessageType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # ChannelMessage + def Message(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # ChannelMessage + def ControlCode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # ChannelMessage + def Token(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ChannelMessage + def Rc(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ChannelMessage + def Response(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def Start(builder): builder.StartObject(7) +def ChannelMessageStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddModelUid(builder, modelUid): builder.PrependUint32Slot(0, modelUid, 0) +def ChannelMessageAddModelUid(builder, modelUid): + """This method is deprecated. Please switch to AddModelUid.""" + return AddModelUid(builder, modelUid) +def AddMessageType(builder, messageType): builder.PrependUint8Slot(1, messageType, 0) +def ChannelMessageAddMessageType(builder, messageType): + """This method is deprecated. Please switch to AddMessageType.""" + return AddMessageType(builder, messageType) +def AddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) +def ChannelMessageAddMessage(builder, message): + """This method is deprecated. Please switch to AddMessage.""" + return AddMessage(builder, message) +def AddControlCode(builder, controlCode): builder.PrependUint32Slot(3, controlCode, 0) +def ChannelMessageAddControlCode(builder, controlCode): + """This method is deprecated. Please switch to AddControlCode.""" + return AddControlCode(builder, controlCode) +def AddToken(builder, token): builder.PrependInt32Slot(4, token, 0) +def ChannelMessageAddToken(builder, token): + """This method is deprecated. Please switch to AddToken.""" + return AddToken(builder, token) +def AddRc(builder, rc): builder.PrependInt32Slot(5, rc, 0) +def ChannelMessageAddRc(builder, rc): + """This method is deprecated. Please switch to AddRc.""" + return AddRc(builder, rc) +def AddResponse(builder, response): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0) +def ChannelMessageAddResponse(builder, response): + """This method is deprecated. Please switch to AddResponse.""" + return AddResponse(builder, response) +def End(builder): return builder.EndObject() +def ChannelMessageEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/MessageType.py b/extra/python/src/AutomotiveBus/Signal/Channel/MessageType.py new file mode 100644 index 0000000..47f47ea --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/MessageType.py @@ -0,0 +1,11 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +class MessageType(object): + NONE = 0 + SignalWrite = 1 + SignalRead = 2 + SignalValue = 3 + SignalIndex = 4 + diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/SignalIndex.py b/extra/python/src/AutomotiveBus/Signal/Channel/SignalIndex.py new file mode 100644 index 0000000..4c3eef0 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/SignalIndex.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignalIndex(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignalIndex() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSignalIndex(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SignalIndexBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # SignalIndex + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignalIndex + def Indexes(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Signal.Channel.SignalLookup import SignalLookup + obj = SignalLookup() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SignalIndex + def IndexesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignalIndex + def IndexesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def SignalIndexStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddIndexes(builder, indexes): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(indexes), 0) +def SignalIndexAddIndexes(builder, indexes): + """This method is deprecated. Please switch to AddIndexes.""" + return AddIndexes(builder, indexes) +def StartIndexesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SignalIndexStartIndexesVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartIndexesVector(builder, numElems) +def End(builder): return builder.EndObject() +def SignalIndexEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/SignalLookup.py b/extra/python/src/AutomotiveBus/Signal/Channel/SignalLookup.py new file mode 100644 index 0000000..fb38a20 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/SignalLookup.py @@ -0,0 +1,60 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignalLookup(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignalLookup() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSignalLookup(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SignalLookupBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # SignalLookup + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignalLookup + def SignalUid(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # SignalLookup + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def Start(builder): builder.StartObject(2) +def SignalLookupStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSignalUid(builder, signalUid): builder.PrependUint32Slot(0, signalUid, 0) +def SignalLookupAddSignalUid(builder, signalUid): + """This method is deprecated. Please switch to AddSignalUid.""" + return AddSignalUid(builder, signalUid) +def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def SignalLookupAddName(builder, name): + """This method is deprecated. Please switch to AddName.""" + return AddName(builder, name) +def End(builder): return builder.EndObject() +def SignalLookupEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/SignalRead.py b/extra/python/src/AutomotiveBus/Signal/Channel/SignalRead.py new file mode 100644 index 0000000..ddfa483 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/SignalRead.py @@ -0,0 +1,73 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignalRead(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignalRead() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSignalRead(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SignalReadBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # SignalRead + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignalRead + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # SignalRead + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # SignalRead + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignalRead + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def SignalReadStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def SignalReadAddData(builder, data): + """This method is deprecated. Please switch to AddData.""" + return AddData(builder, data) +def StartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def SignalReadStartDataVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDataVector(builder, numElems) +def End(builder): return builder.EndObject() +def SignalReadEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/SignalValue.py b/extra/python/src/AutomotiveBus/Signal/Channel/SignalValue.py new file mode 100644 index 0000000..0203a85 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/SignalValue.py @@ -0,0 +1,73 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignalValue(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignalValue() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSignalValue(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SignalValueBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # SignalValue + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignalValue + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # SignalValue + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # SignalValue + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignalValue + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def SignalValueStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def SignalValueAddData(builder, data): + """This method is deprecated. Please switch to AddData.""" + return AddData(builder, data) +def StartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def SignalValueStartDataVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDataVector(builder, numElems) +def End(builder): return builder.EndObject() +def SignalValueEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/SignalWrite.py b/extra/python/src/AutomotiveBus/Signal/Channel/SignalWrite.py new file mode 100644 index 0000000..5d64044 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Signal/Channel/SignalWrite.py @@ -0,0 +1,73 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Channel + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignalWrite(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignalWrite() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSignalWrite(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SignalWriteBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x49\x43\x48", size_prefixed=size_prefixed) + + # SignalWrite + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignalWrite + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # SignalWrite + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # SignalWrite + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignalWrite + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Start(builder): builder.StartObject(1) +def SignalWriteStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def SignalWriteAddData(builder, data): + """This method is deprecated. Please switch to AddData.""" + return AddData(builder, data) +def StartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def SignalWriteStartDataVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartDataVector(builder, numElems) +def End(builder): return builder.EndObject() +def SignalWriteEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Signal/Channel/__init__.py b/extra/python/src/AutomotiveBus/Signal/Channel/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Signal/__init__.py b/extra/python/src/AutomotiveBus/Signal/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/CanFrame.py b/extra/python/src/AutomotiveBus/Stream/Frame/CanFrame.py new file mode 100644 index 0000000..1e53724 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/CanFrame.py @@ -0,0 +1,143 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CanFrame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CanFrame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCanFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CanFrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x46\x52\x41", size_prefixed=size_prefixed) + + # CanFrame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CanFrame + def FrameId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # CanFrame + def Payload(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # CanFrame + def PayloadAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # CanFrame + def PayloadLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CanFrame + def PayloadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # CanFrame + def FrameType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # CanFrame + def BusId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # CanFrame + def NodeId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # CanFrame + def InterfaceId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # CanFrame + def Timing(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from AutomotiveBus.Stream.Frame.Timing import Timing + obj = Timing() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def Start(builder): builder.StartObject(7) +def CanFrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFrameId(builder, frameId): builder.PrependUint32Slot(0, frameId, 0) +def CanFrameAddFrameId(builder, frameId): + """This method is deprecated. Please switch to AddFrameId.""" + return AddFrameId(builder, frameId) +def AddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0) +def CanFrameAddPayload(builder, payload): + """This method is deprecated. Please switch to AddPayload.""" + return AddPayload(builder, payload) +def StartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def CanFrameStartPayloadVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartPayloadVector(builder, numElems) +def AddFrameType(builder, frameType): builder.PrependInt8Slot(2, frameType, 0) +def CanFrameAddFrameType(builder, frameType): + """This method is deprecated. Please switch to AddFrameType.""" + return AddFrameType(builder, frameType) +def AddBusId(builder, busId): builder.PrependUint8Slot(3, busId, 0) +def CanFrameAddBusId(builder, busId): + """This method is deprecated. Please switch to AddBusId.""" + return AddBusId(builder, busId) +def AddNodeId(builder, nodeId): builder.PrependUint8Slot(4, nodeId, 0) +def CanFrameAddNodeId(builder, nodeId): + """This method is deprecated. Please switch to AddNodeId.""" + return AddNodeId(builder, nodeId) +def AddInterfaceId(builder, interfaceId): builder.PrependUint8Slot(5, interfaceId, 0) +def CanFrameAddInterfaceId(builder, interfaceId): + """This method is deprecated. Please switch to AddInterfaceId.""" + return AddInterfaceId(builder, interfaceId) +def AddTiming(builder, timing): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(timing), 0) +def CanFrameAddTiming(builder, timing): + """This method is deprecated. Please switch to AddTiming.""" + return AddTiming(builder, timing) +def End(builder): return builder.EndObject() +def CanFrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/CanFrameType.py b/extra/python/src/AutomotiveBus/Stream/Frame/CanFrameType.py new file mode 100644 index 0000000..de4f231 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/CanFrameType.py @@ -0,0 +1,10 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +class CanFrameType(object): + BaseFrame = 0 + ExtendedFrame = 1 + FdBaseFrame = 2 + FdExtendedFrame = 3 + diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/Frame.py b/extra/python/src/AutomotiveBus/Stream/Frame/Frame.py new file mode 100644 index 0000000..1a0aa6f --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/Frame.py @@ -0,0 +1,63 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Frame(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Frame() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFrame(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FrameBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x46\x52\x41", size_prefixed=size_prefixed) + + # Frame + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Frame + def FType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Frame + def F(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + +def Start(builder): builder.StartObject(2) +def FrameStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFType(builder, fType): builder.PrependUint8Slot(0, fType, 0) +def FrameAddFType(builder, fType): + """This method is deprecated. Please switch to AddFType.""" + return AddFType(builder, fType) +def AddF(builder, f): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(f), 0) +def FrameAddF(builder, f): + """This method is deprecated. Please switch to AddF.""" + return AddF(builder, f) +def End(builder): return builder.EndObject() +def FrameEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/FrameTypes.py b/extra/python/src/AutomotiveBus/Stream/Frame/FrameTypes.py new file mode 100644 index 0000000..1b41ed4 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/FrameTypes.py @@ -0,0 +1,8 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +class FrameTypes(object): + NONE = 0 + CanFrame = 1 + diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/Stream.py b/extra/python/src/AutomotiveBus/Stream/Frame/Stream.py new file mode 100644 index 0000000..f02d4e2 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/Stream.py @@ -0,0 +1,82 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Stream(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Stream() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStream(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StreamBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x46\x52\x41", size_prefixed=size_prefixed) + + # Stream + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Stream + def Frames(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Stream.Frame.Frame import Frame + obj = Frame() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Stream + def FramesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Stream + def FramesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # Stream + def NodeUid(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(2) +def StreamStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFrames(builder, frames): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(frames), 0) +def StreamAddFrames(builder, frames): + """This method is deprecated. Please switch to AddFrames.""" + return AddFrames(builder, frames) +def StartFramesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StreamStartFramesVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartFramesVector(builder, numElems) +def AddNodeUid(builder, nodeUid): builder.PrependUint32Slot(1, nodeUid, 0) +def StreamAddNodeUid(builder, nodeUid): + """This method is deprecated. Please switch to AddNodeUid.""" + return AddNodeUid(builder, nodeUid) +def End(builder): return builder.EndObject() +def StreamEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/Timing.py b/extra/python/src/AutomotiveBus/Stream/Frame/Timing.py new file mode 100644 index 0000000..6d1ca90 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Frame/Timing.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Frame + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Timing(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Timing() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTiming(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TimingBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x46\x52\x41", size_prefixed=size_prefixed) + + # Timing + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Timing + def Send(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # Timing + def Arbitration(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # Timing + def Recv(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(3) +def TimingStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSend(builder, send): builder.PrependInt64Slot(0, send, 0) +def TimingAddSend(builder, send): + """This method is deprecated. Please switch to AddSend.""" + return AddSend(builder, send) +def AddArbitration(builder, arbitration): builder.PrependInt64Slot(1, arbitration, 0) +def TimingAddArbitration(builder, arbitration): + """This method is deprecated. Please switch to AddArbitration.""" + return AddArbitration(builder, arbitration) +def AddRecv(builder, recv): builder.PrependInt64Slot(2, recv, 0) +def TimingAddRecv(builder, recv): + """This method is deprecated. Please switch to AddRecv.""" + return AddRecv(builder, recv) +def End(builder): return builder.EndObject() +def TimingEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Frame/__init__.py b/extra/python/src/AutomotiveBus/Stream/Frame/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/CanFrameType.py b/extra/python/src/AutomotiveBus/Stream/Pdu/CanFrameType.py new file mode 100644 index 0000000..a71ee14 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/CanFrameType.py @@ -0,0 +1,14 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class CanFrameType(object): + # CAN Data Frame. + DataFrame = 0 + # CAN Remote Frame. + RemoteFrame = 1 + # CAN Error Frame. + ErrorFrame = 2 + # CAN Overload Frame. + OverloadFrame = 3 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageFormat.py b/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageFormat.py new file mode 100644 index 0000000..75dbb75 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageFormat.py @@ -0,0 +1,14 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class CanMessageFormat(object): + # CAN Base Format (pdu.id is 11-bits). + BaseFrameFormat = 0 + # CAN Extended Format (pdu.id is 29-bits). + ExtendedFrameFormat = 1 + # CAN FD Base Format (pdu.id is 11-bits). + FdBaseFrameFormat = 2 + # CAN FD Extended Format (pdu.id is 29-bits). + FdExtendedFrameFormat = 3 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageMetadata.py b/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageMetadata.py new file mode 100644 index 0000000..057ef52 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/CanMessageMetadata.py @@ -0,0 +1,86 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CanMessageMetadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CanMessageMetadata() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCanMessageMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CanMessageMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # CanMessageMetadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CAN: Message Format. + # CanMessageMetadata + def MessageFormat(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # CAN: Frame Type. + # CanMessageMetadata + def FrameType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # CAN: Interface ID of the Interface _sending_ this PDU. + # CanMessageMetadata + def InterfaceId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # CAN: Network ID of the network that _carries_ this PDU. + # CanMessageMetadata + def NetworkId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(4) +def CanMessageMetadataStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddMessageFormat(builder, messageFormat): builder.PrependInt8Slot(0, messageFormat, 0) +def CanMessageMetadataAddMessageFormat(builder, messageFormat): + """This method is deprecated. Please switch to AddMessageFormat.""" + return AddMessageFormat(builder, messageFormat) +def AddFrameType(builder, frameType): builder.PrependInt8Slot(1, frameType, 0) +def CanMessageMetadataAddFrameType(builder, frameType): + """This method is deprecated. Please switch to AddFrameType.""" + return AddFrameType(builder, frameType) +def AddInterfaceId(builder, interfaceId): builder.PrependUint32Slot(2, interfaceId, 0) +def CanMessageMetadataAddInterfaceId(builder, interfaceId): + """This method is deprecated. Please switch to AddInterfaceId.""" + return AddInterfaceId(builder, interfaceId) +def AddNetworkId(builder, networkId): builder.PrependUint32Slot(3, networkId, 0) +def CanMessageMetadataAddNetworkId(builder, networkId): + """This method is deprecated. Please switch to AddNetworkId.""" + return AddNetworkId(builder, networkId) +def End(builder): return builder.EndObject() +def CanMessageMetadataEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/DoIpMetadata.py b/extra/python/src/AutomotiveBus/Stream/Pdu/DoIpMetadata.py new file mode 100644 index 0000000..28206f9 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/DoIpMetadata.py @@ -0,0 +1,62 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class DoIpMetadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = DoIpMetadata() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsDoIpMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def DoIpMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # DoIpMetadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # DoIP: Protocol Version. + # DoIpMetadata + def ProtocolVersion(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # DoIP: Payload Type. + # DoIpMetadata + def PayloadType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(2) +def DoIpMetadataStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddProtocolVersion(builder, protocolVersion): builder.PrependUint8Slot(0, protocolVersion, 0) +def DoIpMetadataAddProtocolVersion(builder, protocolVersion): + """This method is deprecated. Please switch to AddProtocolVersion.""" + return AddProtocolVersion(builder, protocolVersion) +def AddPayloadType(builder, payloadType): builder.PrependUint16Slot(1, payloadType, 0) +def DoIpMetadataAddPayloadType(builder, payloadType): + """This method is deprecated. Please switch to AddPayloadType.""" + return AddPayloadType(builder, payloadType) +def End(builder): return builder.EndObject() +def DoIpMetadataEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddr.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddr.py new file mode 100644 index 0000000..d90cd9c --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddr.py @@ -0,0 +1,9 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class IpAddr(object): + NONE = 0 + v4 = 1 + v6 = 2 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddressV6.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddressV6.py new file mode 100644 index 0000000..0f210bb --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpAddressV6.py @@ -0,0 +1,47 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class IpAddressV6(object): + __slots__ = ['_tab'] + + @classmethod + def SizeOf(cls): + return 16 + + # IpAddressV6 + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # IpAddressV6 + def V0(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0)) + # IpAddressV6 + def V1(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2)) + # IpAddressV6 + def V2(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4)) + # IpAddressV6 + def V3(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(6)) + # IpAddressV6 + def V4(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8)) + # IpAddressV6 + def V5(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(10)) + # IpAddressV6 + def V6(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(12)) + # IpAddressV6 + def V7(self): return self._tab.Get(flatbuffers.number_types.Uint16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(14)) + +def CreateIpAddressV6(builder, v0, v1, v2, v3, v4, v5, v6, v7): + builder.Prep(2, 16) + builder.PrependUint16(v7) + builder.PrependUint16(v6) + builder.PrependUint16(v5) + builder.PrependUint16(v4) + builder.PrependUint16(v3) + builder.PrependUint16(v2) + builder.PrependUint16(v1) + builder.PrependUint16(v0) + return builder.Offset() diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpMessageMetadata.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpMessageMetadata.py new file mode 100644 index 0000000..bc6f916 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpMessageMetadata.py @@ -0,0 +1,199 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class IpMessageMetadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = IpMessageMetadata() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsIpMessageMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def IpMessageMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # IpMessageMetadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Ethernet: Destination MAC (stored in lower 48-bits, transmission order). + # example: uint64 := XX-XX-01-23-45-67-89-AB + # IpMessageMetadata + def EthDstMac(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 + + # Ethernet: Source MAC (stored in lower 48-bits, transmission order). + # example: uint64 := XX-XX-01-23-45-67-89-AB + # IpMessageMetadata + def EthSrcMac(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 + + # Ethernet: EtherType. + # IpMessageMetadata + def EthEthertype(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # Ethernet: TCI: Priority code point. + # IpMessageMetadata + def EthTciPcp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Ethernet: TCI: Drop eligible indicator. + # IpMessageMetadata + def EthTciDei(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Ethernet: TCI: VLAN identifier. + # IpMessageMetadata + def EthTciVid(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # IpMessageMetadata + def IpAddrType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # IP: Address. + # IpMessageMetadata + def IpAddr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # IP: Protocol Specifier. + # IpMessageMetadata + def IpProtocol(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # IP: TCP/UDP Source Port. + # IpMessageMetadata + def IpSrcPort(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # IP: TCP/UDP Destination Port. + # IpMessageMetadata + def IpDstPort(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # IpMessageMetadata + def AdapterType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # IpMessageMetadata + def Adapter(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + +def Start(builder): builder.StartObject(13) +def IpMessageMetadataStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddEthDstMac(builder, ethDstMac): builder.PrependUint64Slot(0, ethDstMac, 0) +def IpMessageMetadataAddEthDstMac(builder, ethDstMac): + """This method is deprecated. Please switch to AddEthDstMac.""" + return AddEthDstMac(builder, ethDstMac) +def AddEthSrcMac(builder, ethSrcMac): builder.PrependUint64Slot(1, ethSrcMac, 0) +def IpMessageMetadataAddEthSrcMac(builder, ethSrcMac): + """This method is deprecated. Please switch to AddEthSrcMac.""" + return AddEthSrcMac(builder, ethSrcMac) +def AddEthEthertype(builder, ethEthertype): builder.PrependUint16Slot(2, ethEthertype, 0) +def IpMessageMetadataAddEthEthertype(builder, ethEthertype): + """This method is deprecated. Please switch to AddEthEthertype.""" + return AddEthEthertype(builder, ethEthertype) +def AddEthTciPcp(builder, ethTciPcp): builder.PrependUint8Slot(3, ethTciPcp, 0) +def IpMessageMetadataAddEthTciPcp(builder, ethTciPcp): + """This method is deprecated. Please switch to AddEthTciPcp.""" + return AddEthTciPcp(builder, ethTciPcp) +def AddEthTciDei(builder, ethTciDei): builder.PrependUint8Slot(4, ethTciDei, 0) +def IpMessageMetadataAddEthTciDei(builder, ethTciDei): + """This method is deprecated. Please switch to AddEthTciDei.""" + return AddEthTciDei(builder, ethTciDei) +def AddEthTciVid(builder, ethTciVid): builder.PrependUint16Slot(5, ethTciVid, 0) +def IpMessageMetadataAddEthTciVid(builder, ethTciVid): + """This method is deprecated. Please switch to AddEthTciVid.""" + return AddEthTciVid(builder, ethTciVid) +def AddIpAddrType(builder, ipAddrType): builder.PrependUint8Slot(6, ipAddrType, 0) +def IpMessageMetadataAddIpAddrType(builder, ipAddrType): + """This method is deprecated. Please switch to AddIpAddrType.""" + return AddIpAddrType(builder, ipAddrType) +def AddIpAddr(builder, ipAddr): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(ipAddr), 0) +def IpMessageMetadataAddIpAddr(builder, ipAddr): + """This method is deprecated. Please switch to AddIpAddr.""" + return AddIpAddr(builder, ipAddr) +def AddIpProtocol(builder, ipProtocol): builder.PrependUint8Slot(8, ipProtocol, 0) +def IpMessageMetadataAddIpProtocol(builder, ipProtocol): + """This method is deprecated. Please switch to AddIpProtocol.""" + return AddIpProtocol(builder, ipProtocol) +def AddIpSrcPort(builder, ipSrcPort): builder.PrependUint16Slot(9, ipSrcPort, 0) +def IpMessageMetadataAddIpSrcPort(builder, ipSrcPort): + """This method is deprecated. Please switch to AddIpSrcPort.""" + return AddIpSrcPort(builder, ipSrcPort) +def AddIpDstPort(builder, ipDstPort): builder.PrependUint16Slot(10, ipDstPort, 0) +def IpMessageMetadataAddIpDstPort(builder, ipDstPort): + """This method is deprecated. Please switch to AddIpDstPort.""" + return AddIpDstPort(builder, ipDstPort) +def AddAdapterType(builder, adapterType): builder.PrependUint8Slot(11, adapterType, 0) +def IpMessageMetadataAddAdapterType(builder, adapterType): + """This method is deprecated. Please switch to AddAdapterType.""" + return AddAdapterType(builder, adapterType) +def AddAdapter(builder, adapter): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(adapter), 0) +def IpMessageMetadataAddAdapter(builder, adapter): + """This method is deprecated. Please switch to AddAdapter.""" + return AddAdapter(builder, adapter) +def End(builder): return builder.EndObject() +def IpMessageMetadataEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpProtocol.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpProtocol.py new file mode 100644 index 0000000..c939754 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpProtocol.py @@ -0,0 +1,9 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class IpProtocol(object): + None_ = 0 + Tcp = 6 + Udp = 17 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpV4.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpV4.py new file mode 100644 index 0000000..a17ed0f --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpV4.py @@ -0,0 +1,60 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class IpV4(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = IpV4() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsIpV4(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def IpV4BufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # IpV4 + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # IpV4 + def SrcAddr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # IpV4 + def DstAddr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(2) +def IpV4Start(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSrcAddr(builder, srcAddr): builder.PrependUint32Slot(0, srcAddr, 0) +def IpV4AddSrcAddr(builder, srcAddr): + """This method is deprecated. Please switch to AddSrcAddr.""" + return AddSrcAddr(builder, srcAddr) +def AddDstAddr(builder, dstAddr): builder.PrependUint32Slot(1, dstAddr, 0) +def IpV4AddDstAddr(builder, dstAddr): + """This method is deprecated. Please switch to AddDstAddr.""" + return AddDstAddr(builder, dstAddr) +def End(builder): return builder.EndObject() +def IpV4End(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/IpV6.py b/extra/python/src/AutomotiveBus/Stream/Pdu/IpV6.py new file mode 100644 index 0000000..ff15b4e --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/IpV6.py @@ -0,0 +1,68 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class IpV6(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = IpV6() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsIpV6(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def IpV6BufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # IpV6 + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # IpV6 + def SrcAddr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = o + self._tab.Pos + from AutomotiveBus.Stream.Pdu.IpAddressV6 import IpAddressV6 + obj = IpAddressV6() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # IpV6 + def DstAddr(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = o + self._tab.Pos + from AutomotiveBus.Stream.Pdu.IpAddressV6 import IpAddressV6 + obj = IpAddressV6() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def Start(builder): builder.StartObject(2) +def IpV6Start(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddSrcAddr(builder, srcAddr): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(srcAddr), 0) +def IpV6AddSrcAddr(builder, srcAddr): + """This method is deprecated. Please switch to AddSrcAddr.""" + return AddSrcAddr(builder, srcAddr) +def AddDstAddr(builder, dstAddr): builder.PrependStructSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(dstAddr), 0) +def IpV6AddDstAddr(builder, dstAddr): + """This method is deprecated. Please switch to AddDstAddr.""" + return AddDstAddr(builder, dstAddr) +def End(builder): return builder.EndObject() +def IpV6End(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/Pdu.py b/extra/python/src/AutomotiveBus/Stream/Pdu/Pdu.py new file mode 100644 index 0000000..f4e77e3 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/Pdu.py @@ -0,0 +1,136 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Pdu(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Pdu() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsPdu(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def PduBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # Pdu + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # PDU: Identifier. + # Pdu + def Id(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # PDU: Payload (DLC is vector length). + # Pdu + def Payload(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Pdu + def PayloadAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Pdu + def PayloadLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Pdu + def PayloadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Pdu + def TransportType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # PDU: Transport metadata relating to this PDU (optional). + # Pdu + def Transport(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # Identifier: SWC ID of _originating_ this PDU. + # Pdu + def SwcId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Identifier: ECU ID of ECU _originating_ this PDU. + # Pdu + def EcuId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(6) +def PduStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddId(builder, id): builder.PrependUint32Slot(0, id, 0) +def PduAddId(builder, id): + """This method is deprecated. Please switch to AddId.""" + return AddId(builder, id) +def AddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0) +def PduAddPayload(builder, payload): + """This method is deprecated. Please switch to AddPayload.""" + return AddPayload(builder, payload) +def StartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def PduStartPayloadVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartPayloadVector(builder, numElems) +def AddTransportType(builder, transportType): builder.PrependUint8Slot(2, transportType, 0) +def PduAddTransportType(builder, transportType): + """This method is deprecated. Please switch to AddTransportType.""" + return AddTransportType(builder, transportType) +def AddTransport(builder, transport): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(transport), 0) +def PduAddTransport(builder, transport): + """This method is deprecated. Please switch to AddTransport.""" + return AddTransport(builder, transport) +def AddSwcId(builder, swcId): builder.PrependUint32Slot(4, swcId, 0) +def PduAddSwcId(builder, swcId): + """This method is deprecated. Please switch to AddSwcId.""" + return AddSwcId(builder, swcId) +def AddEcuId(builder, ecuId): builder.PrependUint32Slot(5, ecuId, 0) +def PduAddEcuId(builder, ecuId): + """This method is deprecated. Please switch to AddEcuId.""" + return AddEcuId(builder, ecuId) +def End(builder): return builder.EndObject() +def PduEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/SocketAdapter.py b/extra/python/src/AutomotiveBus/Stream/Pdu/SocketAdapter.py new file mode 100644 index 0000000..5b2585e --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/SocketAdapter.py @@ -0,0 +1,11 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class SocketAdapter(object): + NONE = 0 + # DoIp: Diagnostic Communication over Internet Protocol. + do_ip = 1 + # Some/IP: Scalable service-Oriented Midedleware over IP. + some_ip = 2 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/SomeIpMetadata.py b/extra/python/src/AutomotiveBus/Stream/Pdu/SomeIpMetadata.py new file mode 100644 index 0000000..49326ce --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/SomeIpMetadata.py @@ -0,0 +1,122 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SomeIpMetadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SomeIpMetadata() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSomeIpMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SomeIpMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # SomeIpMetadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SOME/IP: Message ID. + # SomeIpMetadata + def MessageId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Message Length. + # SomeIpMetadata + def Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Request ID. + # SomeIpMetadata + def RequestId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Protocol Version. + # SomeIpMetadata + def ProtocolVersion(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Interface Version. + # SomeIpMetadata + def InterfaceVersion(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Message Type. + # SomeIpMetadata + def MessageType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # SOME/IP: Return code. + # SomeIpMetadata + def ReturnCode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(7) +def SomeIpMetadataStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddMessageId(builder, messageId): builder.PrependUint32Slot(0, messageId, 0) +def SomeIpMetadataAddMessageId(builder, messageId): + """This method is deprecated. Please switch to AddMessageId.""" + return AddMessageId(builder, messageId) +def AddLength(builder, length): builder.PrependUint32Slot(1, length, 0) +def SomeIpMetadataAddLength(builder, length): + """This method is deprecated. Please switch to AddLength.""" + return AddLength(builder, length) +def AddRequestId(builder, requestId): builder.PrependUint32Slot(2, requestId, 0) +def SomeIpMetadataAddRequestId(builder, requestId): + """This method is deprecated. Please switch to AddRequestId.""" + return AddRequestId(builder, requestId) +def AddProtocolVersion(builder, protocolVersion): builder.PrependUint8Slot(3, protocolVersion, 0) +def SomeIpMetadataAddProtocolVersion(builder, protocolVersion): + """This method is deprecated. Please switch to AddProtocolVersion.""" + return AddProtocolVersion(builder, protocolVersion) +def AddInterfaceVersion(builder, interfaceVersion): builder.PrependUint8Slot(4, interfaceVersion, 0) +def SomeIpMetadataAddInterfaceVersion(builder, interfaceVersion): + """This method is deprecated. Please switch to AddInterfaceVersion.""" + return AddInterfaceVersion(builder, interfaceVersion) +def AddMessageType(builder, messageType): builder.PrependUint8Slot(5, messageType, 0) +def SomeIpMetadataAddMessageType(builder, messageType): + """This method is deprecated. Please switch to AddMessageType.""" + return AddMessageType(builder, messageType) +def AddReturnCode(builder, returnCode): builder.PrependUint8Slot(6, returnCode, 0) +def SomeIpMetadataAddReturnCode(builder, returnCode): + """This method is deprecated. Please switch to AddReturnCode.""" + return AddReturnCode(builder, returnCode) +def End(builder): return builder.EndObject() +def SomeIpMetadataEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/Stream.py b/extra/python/src/AutomotiveBus/Stream/Pdu/Stream.py new file mode 100644 index 0000000..3da0084 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/Stream.py @@ -0,0 +1,87 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Stream(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Stream() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStream(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StreamBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x53\x50\x44\x55", size_prefixed=size_prefixed) + + # Stream + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # STREAM: PDU Vector. + # Stream + def Pdus(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from AutomotiveBus.Stream.Pdu.Pdu import Pdu + obj = Pdu() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Stream + def PdusLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Stream + def PdusIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # Metadata: Node UID of the Simulation (or System) node which is sending + # this stream object. Used by a Node to detect incomming stream objects + # which the Node had previously sent (i.e. an echo from the underlying + # implementation of the stream transport). + # Stream + def NodeUid(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def Start(builder): builder.StartObject(2) +def StreamStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddPdus(builder, pdus): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pdus), 0) +def StreamAddPdus(builder, pdus): + """This method is deprecated. Please switch to AddPdus.""" + return AddPdus(builder, pdus) +def StartPdusVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StreamStartPdusVector(builder, numElems): + """This method is deprecated. Please switch to Start.""" + return StartPdusVector(builder, numElems) +def AddNodeUid(builder, nodeUid): builder.PrependUint32Slot(1, nodeUid, 0) +def StreamAddNodeUid(builder, nodeUid): + """This method is deprecated. Please switch to AddNodeUid.""" + return AddNodeUid(builder, nodeUid) +def End(builder): return builder.EndObject() +def StreamEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) \ No newline at end of file diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/TransportMetadata.py b/extra/python/src/AutomotiveBus/Stream/Pdu/TransportMetadata.py new file mode 100644 index 0000000..dc47f38 --- /dev/null +++ b/extra/python/src/AutomotiveBus/Stream/Pdu/TransportMetadata.py @@ -0,0 +1,9 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Pdu + +class TransportMetadata(object): + NONE = 0 + Can = 1 + Ip = 2 + diff --git a/extra/python/src/AutomotiveBus/Stream/Pdu/__init__.py b/extra/python/src/AutomotiveBus/Stream/Pdu/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/Stream/__init__.py b/extra/python/src/AutomotiveBus/Stream/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/AutomotiveBus/__init__.py b/extra/python/src/AutomotiveBus/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/__init__.py b/extra/python/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/extra/python/src/ncodec/__init__.py b/extra/python/src/ncodec/__init__.py new file mode 100644 index 0000000..3314466 --- /dev/null +++ b/extra/python/src/ncodec/__init__.py @@ -0,0 +1,42 @@ +""" +AutomotiveBus Package + +This package provides automotive bus communication codecs and interfaces +for encoding and decoding various automotive protocols like CAN and PDU. +""" + +from .codec_interface import ( + ICodec, + CodecFactory, + MessageType +) + +from .pdu import PduCodec, PduMessage +from .can import CanCodec, CanMessage + +__all__ = [ + # Interfaces + 'ICodec', + 'CodecFactory', + 'MessageType', + + # Concrete implementations + 'PduCodec', + 'PduMessage', + 'CanCodec', + 'CanMessage', +] + +__version__ = "1.0.0" + +# Compatibility shims: re-export commonly-used flatbuffer enums/classes from the +# generated AutomotiveBus package so existing tests and examples that expect +# `AutomotiveBus`-style imports can access them through `ncodec`. +from AutomotiveBus.Stream.Pdu.TransportMetadata import TransportMetadata +from AutomotiveBus.Stream.Frame.CanFrameType import CanFrameType + +# Export compatibility names +__all__.extend([ + 'TransportMetadata', + 'CanFrameType', +]) \ No newline at end of file diff --git a/extra/python/src/ncodec/can.py b/extra/python/src/ncodec/can.py new file mode 100644 index 0000000..086a864 --- /dev/null +++ b/extra/python/src/ncodec/can.py @@ -0,0 +1,150 @@ +import flatbuffers +import re +from typing import Dict, List, Optional +from dataclasses import dataclass +import ctypes +from ncodec.codec_interface import ICodec +from ncodec.mimetype import decode_mime_type +from AutomotiveBus.Stream.Frame import ( + CanFrameType, + CanFrame, + Frame, + FrameTypes, + Stream, + Timing +) + +@dataclass +class CanSender: + bus_id: ctypes.c_uint8 + node_id: ctypes.c_uint8 + interface_id: ctypes.c_uint8 + +@dataclass +class CanTiming: + send: ctypes.c_uint64 + arb: ctypes.c_uint64 + recv: ctypes.c_uint64 + +@dataclass +class CanMessage: + frame_id: ctypes.c_uint32 + frame_type: CanFrameType.CanFrameType + Sender: CanSender + Timing: CanTiming + Payload: bytes + +class CanCodec(ICodec[CanMessage]): + def __init__(self, MimeMap: Dict[str, str] | str, Stream: bytearray, ModelName: str, SimulationTime: float): + # Accept MimeMap as dict, mime-type string, bytes, or None. + if isinstance(MimeMap, str): + # decode 'application/..; key=val' string into dict + MimeMap_ = decode_mime_type(MimeMap) + elif isinstance(MimeMap, Dict): + MimeMap_ = MimeMap + else: + raise ValueError("Invalid MimeMap type") + + super().__init__(MimeMap_, Stream, ModelName, SimulationTime) + self.builder = flatbuffers.Builder(1024) + self.Frames = [] + + def Write(self, msgs: List[CanMessage]): + if msgs is None or len(msgs) == 0: + return + + for msg in msgs: + payload = self.builder.CreateByteVector(msg.Payload) + + # Create CanFrame first + CanFrame.CanFrameStart(self.builder) + CanFrame.CanFrameAddFrameId(self.builder, msg.frame_id) + CanFrame.CanFrameAddFrameType(self.builder, msg.frame_type) + CanFrame.CanFrameAddPayload(self.builder, payload) + CanFrame.CanFrameAddBusId(self.builder, msg.Sender.bus_id) + CanFrame.CanFrameAddNodeId(self.builder, msg.Sender.node_id) + CanFrame.CanFrameAddInterfaceId(self.builder, msg.Sender.interface_id) + can_frame = CanFrame.CanFrameEnd(self.builder) + + # Now wrap it in a Frame + Frame.FrameStart(self.builder) + Frame.FrameAddFType(self.builder, FrameTypes.FrameTypes.CanFrame) + Frame.FrameAddF(self.builder, can_frame) + frame = Frame.FrameEnd(self.builder) + + self.Frames.append(frame) + + def StreamFinalize(self) -> bytearray: + Stream.StartFramesVector(self.builder, len(self.Frames)) + for i in reversed(range(len(self.Frames))): + self.builder.PrependUOffsetTRelative(self.Frames[i]) + frame_vec = self.builder.EndVector(len(self.Frames)) + + Stream.Start(self.builder) + Stream.AddFrames(self.builder, frame_vec) + stream = Stream.End(self.builder) + self.builder.FinishSizePrefixed(stream) + + # Return the finished bytes + return self.builder.Output() + + def Flush(self) -> None: + buf = self.StreamFinalize() + self.builder = flatbuffers.Builder(1024) + if not buf: + return + self.Stream = buf + + def getStreamFromBuffer(self) -> List[CanFrame.CanFrame]: + frame_list = [] + if self.Stream is None or len(self.Stream) == 0: + return [] + stream = Stream.Stream.GetRootAs(self.Stream, 4) + for i in range(stream.FramesLength()): + frame = stream.Frames(i) + if frame and frame.FType() == FrameTypes.FrameTypes.CanFrame: + table = frame.F() + can_frame = CanFrame.CanFrame() + can_frame.Init(table.Bytes, table.Pos) + frame_list.append(can_frame) + return frame_list + + def Read(self) -> List[CanMessage]: + msgs = [] + list_of_frames = self.getStreamFromBuffer() + for frame in list_of_frames: + node_id = 0 + node_id_str = self.Stat("Node_id") + if node_id_str: + node_id = int(node_id_str) + # Skip if Node_id matches frame_id (filtering logic) + if node_id != 0 and frame.FrameId() == node_id: + continue + msg = CanMessage( + frame_id=frame.FrameId(), + frame_type=frame.FrameType(), + Sender=CanSender( + bus_id=frame.BusId(), + node_id=frame.NodeId(), + interface_id=frame.InterfaceId() + ), + Timing=None, + Payload=bytes(frame.PayloadAsNumpy().tobytes()) + ) + msgs.append(msg) + return msgs + + def Truncate(self): + self.builder = flatbuffers.Builder(1024) + self.Stream.clear() + self.Frames.clear() + + def Stat(self, param: str, new_value: str = None) -> str: + if param in self.MimeMap: + if new_value is not None: + self.MimeMap[param] = new_value + return self.MimeMap[param] + elif new_value is not None: + self.MimeMap[param] = new_value + return self.MimeMap[param] + return "" \ No newline at end of file diff --git a/extra/python/src/ncodec/codec_interface.py b/extra/python/src/ncodec/codec_interface.py new file mode 100644 index 0000000..f99d004 --- /dev/null +++ b/extra/python/src/ncodec/codec_interface.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +""" +Codec Interface Module + +This module provides a common interface for automotive bus codecs +including PDU and CAN frame encoding/decoding operations. +""" + +from abc import ABC, abstractmethod +from ncodec.mimetype import decode_mime_type +from typing import List, TypeVar, Generic, Optional, Dict + +# Generic type for message types (CanMessage, PduMessage, etc.) +MessageType = TypeVar('MessageType') + +class ICodec(ABC, Generic[MessageType]): + + def __init__(self, MimeMap: Dict[str, str], Stream: bytearray, ModelName: str, SimulationTime: float): + self.MimeMap = MimeMap + self.Stream = Stream + self.ModelName = ModelName + self.SimulationTime = SimulationTime + + @abstractmethod + def Write(self, msgs: List[MessageType]) -> None: + pass + + @abstractmethod + def Read(self) -> List[MessageType]: + pass + + @abstractmethod + def Flush(self) -> None: + pass + + @abstractmethod + def Truncate(self) -> None: + pass + + @abstractmethod + def Stat(self, param: str, new_value: Optional[str] = None) -> str: + pass + + +class CodecFactory: + + @staticmethod + def create_pdu_codec(MimeMap: str, Stream: bytearray, ModelName: str, SimulationTime: float) -> ICodec: + from ncodec.pdu import PduCodec + return PduCodec(MimeMap, Stream, ModelName, SimulationTime) + + @staticmethod + def create_can_codec(MimeMap: str, Stream: bytearray, ModelName: str, SimulationTime: float) -> ICodec: + from ncodec.can import CanCodec + return CanCodec(MimeMap, Stream, ModelName, SimulationTime) + + @staticmethod + def create_codec(MimeType: str, Stream: bytearray, ModelName: str, SimulationTime: float) -> ICodec: + MimeMap = decode_mime_type(MimeType) + codec_type = MimeMap.get("type") + + if codec_type == "pdu": + return CodecFactory.create_pdu_codec(MimeMap, Stream, ModelName, SimulationTime) + elif codec_type == "can": + return CodecFactory.create_can_codec(MimeMap, Stream, ModelName, SimulationTime) + else: + raise ValueError(f"Unsupported codec type: {codec_type}") + + +# Export the main interfaces and factory +__all__ = [ + 'ICodec', + 'CodecFactory', + 'MessageType' +] diff --git a/extra/python/src/ncodec/mimetype.py b/extra/python/src/ncodec/mimetype.py new file mode 100644 index 0000000..0324bf9 --- /dev/null +++ b/extra/python/src/ncodec/mimetype.py @@ -0,0 +1,45 @@ +from typing import Dict +import re + +def decode_mime_type(mime_type: str) -> Dict[str, str]: + if not mime_type: + raise ValueError("MimeType is empty") + + mime_map = {} + + parts = [part.strip() for part in re.split(r'[;\s]+', mime_type) if part.strip()] + + for part in parts: + if '=' in part: + kv = part.split('=', 1) + if len(kv) == 2: + key = kv[0].strip() + value = kv[1].strip() + mime_map[key] = value + + # Required parameters + guard = ["interface", "type", "schema"] + for key in guard: + if key in mime_map: + param = mime_map[key] + if key == "type": + if param not in ["can", "pdu"]: + raise ValueError(f"unsupported type: {param}") + elif key == "interface": + if param != "stream": + raise ValueError(f"wrong interface: {param}") + elif key == "schema": + if param != "fbs": + raise ValueError(f"wrong schema: {param}") + else: + raise ValueError("missing required mimetype parameter") + + # All possible parameters + options = ["type", "schema", "interface", "bus", "bus_id", "node_id", + "interface_id", "swc_id", "ecu_id"] + + for key in mime_map: + if key not in options: + raise ValueError(f"unexpected mimetype parameter: {key}") + + return mime_map \ No newline at end of file diff --git a/extra/python/src/ncodec/pdu.py b/extra/python/src/ncodec/pdu.py new file mode 100644 index 0000000..c564d04 --- /dev/null +++ b/extra/python/src/ncodec/pdu.py @@ -0,0 +1,438 @@ +#!/usr/bin/env python3 +""" +Network Codec Module + +This module provides network encoding and decoding functionality +for automotive bus schema operations. +""" + +import flatbuffers +from typing import List, Optional, Dict +from dataclasses import dataclass +import ctypes +from ncodec.mimetype import decode_mime_type +from ncodec.codec_interface import ICodec +from AutomotiveBus.Stream.Pdu import ( + TransportMetadata, + IpProtocol, + IpAddr, + SocketAdapter, + CanFrameType, + CanMessageFormat, + IpV4, + IpV6, + IpAddressV6, + DoIpMetadata, + SomeIpMetadata, + IpMessageMetadata, + Pdu, + Stream, + CanMessageMetadata +) + +@dataclass +class NCodecPduCanMessageMetadata: + format: CanMessageFormat.CanMessageFormat + type: CanFrameType.CanFrameType + interface_id: ctypes.c_uint32 + network_id: ctypes.c_uint32 + +@dataclass +class NCodecPduIpAddrV4: + src_ip: ctypes.c_uint32 + dst_ip: ctypes.c_uint32 + +@dataclass +class NCodecPduIpAddrV6: + src_ip: List[ctypes.c_uint16] # 8 uint16 values + dst_ip: List[ctypes.c_uint16] # 8 uint16 values + +@dataclass +class NCodecIpAddr: + ip_v4: NCodecPduIpAddrV4 + ip_v6: NCodecPduIpAddrV6 + +@dataclass +class NCodecPduDoIpAdapter: + protocol_version: ctypes.c_uint8 + payload_type: ctypes.c_uint16 + +@dataclass +class NCodecPduSomeIpAdapter: + message_id: ctypes.c_uint32 + length: ctypes.c_uint32 + request_id: ctypes.c_uint32 + protocol_version: ctypes.c_uint8 + interface_version: ctypes.c_uint8 + message_type: ctypes.c_uint8 + return_code: ctypes.c_uint8 + +@dataclass +class NCodecPduSocketAdapter: + do_ip: NCodecPduDoIpAdapter + some_ip: NCodecPduSomeIpAdapter + +@dataclass +class NCodecIpCanMessageMetadata: + eth_dst_mac: ctypes.c_uint64 + eth_src_mac: ctypes.c_uint64 + eth_ethertype: ctypes.c_uint16 + eth_tci_pcp: ctypes.c_uint8 + eth_tci_dei: ctypes.c_uint8 + eth_tci_vid: ctypes.c_uint16 + ip_protocol: IpProtocol + ip_addr_type: IpAddr + ip_addr: NCodecIpAddr + ip_src_port: ctypes.c_uint16 + ip_dst_port: ctypes.c_uint16 + so_ad_type: SocketAdapter.SocketAdapter + so_ad: NCodecPduSocketAdapter + +@dataclass +class PduMessage: + id: ctypes.c_uint32 + payload: bytes + type: TransportMetadata.TransportMetadata + swc_id: ctypes.c_uint32 = 0 + ecu_id: ctypes.c_uint32 = 0 + can_metadata: NCodecPduCanMessageMetadata = None + ip_metadata: NCodecIpCanMessageMetadata = None + +class PduCodec(ICodec[PduMessage]): + def __init__(self, MimeMap: Dict[str, str] | str, Stream: bytearray, ModelName: str, SimulationTime: float): + # Accept MimeMap as dict, mime-type string, bytes, or None. + if isinstance(MimeMap, str): + # decode 'application/..; key=val' string into dict + MimeMap_ = decode_mime_type(MimeMap) + elif isinstance(MimeMap, Dict): + MimeMap_ = MimeMap + else: + raise ValueError("Invalid MimeMap type") + + super().__init__(MimeMap_, Stream, ModelName, SimulationTime) + self.builder = flatbuffers.Builder(1024) + self.Pdus = [] + + def emitIpAddrV4(self, msg: PduMessage) -> any: + IpV4.Start(self.builder) + IpV4.AddSrcAddr(self.builder, msg.ip_metadata.ip_addr.ip_v4.src_ip) + IpV4.AddDstAddr(self.builder, msg.ip_metadata.ip_addr.ip_v4.dst_ip) + return IpV4.End(self.builder) + + def emitIpAddrV6(self, msg: PduMessage) -> any: + addr = msg.ip_metadata.ip_addr.ip_v6 + IpV6.Start(self.builder) + src_addr = IpAddressV6.CreateIpAddressV6( + self.builder, + addr.src_ip[0], addr.src_ip[1], addr.src_ip[2], addr.src_ip[3], + addr.src_ip[4], addr.src_ip[5], addr.src_ip[6], addr.src_ip[7] + ) + IpV6.AddSrcAddr(self.builder, src_addr) + dst_addr = IpAddressV6.CreateIpAddressV6( + self.builder, + addr.dst_ip[0], addr.dst_ip[1], addr.dst_ip[2], addr.dst_ip[3], + addr.dst_ip[4], addr.dst_ip[5], addr.dst_ip[6], addr.dst_ip[7] + ) + IpV6.AddDstAddr(self.builder, dst_addr) + return IpV6.End(self.builder) + + def emitDoIpAdapter(self, msg: PduMessage) -> any: + adapter = msg.ip_metadata.so_ad.do_ip + DoIpMetadata.Start(self.builder) + DoIpMetadata.AddProtocolVersion(self.builder, adapter.protocol_version) + DoIpMetadata.AddPayloadType(self.builder, adapter.payload_type) + return DoIpMetadata.End(self.builder) + + def emitSomeIpAdapter(self, msg: PduMessage) -> any: + adapter = msg.ip_metadata.so_ad.some_ip + SomeIpMetadata.Start(self.builder) + SomeIpMetadata.AddMessageId(self.builder, adapter.message_id) + SomeIpMetadata.AddLength(self.builder, adapter.length) + SomeIpMetadata.AddRequestId(self.builder, adapter.request_id) + SomeIpMetadata.AddProtocolVersion(self.builder, adapter.protocol_version) + SomeIpMetadata.AddInterfaceVersion(self.builder, adapter.interface_version) + SomeIpMetadata.AddMessageType(self.builder, adapter.message_type) + SomeIpMetadata.AddReturnCode(self.builder, adapter.return_code) + return SomeIpMetadata.End(self.builder) + + def emitIpMessageMetdata(self, msg: PduMessage) -> any: + if msg.ip_metadata is None: + pass + + addr_type = None + match msg.ip_metadata.ip_addr_type: + case IpAddr.IpAddr.v4: + addr_type = self.emitIpAddrV4(msg) + case IpAddr.IpAddr.v6: + addr_type = self.emitIpAddrV6(msg) + case IpAddr.IpAddr.NONE: + pass + + socket_adapter = None + match msg.ip_metadata.so_ad_type: + case SocketAdapter.SocketAdapter.do_ip: + socket_adapter = self.emitDoIpAdapter(msg) + case SocketAdapter.SocketAdapter.some_ip: + socket_adapter = self.emitSomeIpAdapter(msg) + case _: + pass + + IpMessageMetadata.Start(self.builder) + IpMessageMetadata.AddEthDstMac(self.builder, msg.ip_metadata.eth_dst_mac) + IpMessageMetadata.AddEthSrcMac(self.builder, msg.ip_metadata.eth_src_mac) + IpMessageMetadata.AddEthEthertype(self.builder, msg.ip_metadata.eth_ethertype) + IpMessageMetadata.AddEthTciPcp(self.builder, msg.ip_metadata.eth_tci_pcp) + IpMessageMetadata.AddEthTciDei(self.builder, msg.ip_metadata.eth_tci_dei) + IpMessageMetadata.AddEthTciVid(self.builder, msg.ip_metadata.eth_tci_vid) + if addr_type is not None: + IpMessageMetadata.AddIpAddrType(self.builder, msg.ip_metadata.ip_addr_type) + IpMessageMetadata.AddIpAddr(self.builder, addr_type) + IpMessageMetadata.AddIpProtocol(self.builder, msg.ip_metadata.ip_protocol) + IpMessageMetadata.AddIpSrcPort(self.builder, msg.ip_metadata.ip_src_port) + IpMessageMetadata.AddIpDstPort(self.builder, msg.ip_metadata.ip_dst_port) + if socket_adapter is not None: + IpMessageMetadata.AddAdapterType(self.builder, msg.ip_metadata.so_ad_type) + IpMessageMetadata.AddAdapter(self.builder, socket_adapter) + + return IpMessageMetadata.End(self.builder) + + def emitCanMessageMetadata(self, msg: PduMessage) -> any: + CanMessageMetadata.Start(self.builder) + CanMessageMetadata.AddMessageFormat(self.builder, msg.can_metadata.format) + CanMessageMetadata.AddFrameType(self.builder, msg.can_metadata.type) + CanMessageMetadata.AddInterfaceId(self.builder, msg.can_metadata.interface_id) + CanMessageMetadata.AddNetworkId(self.builder, msg.can_metadata.network_id) + return CanMessageMetadata.End(self.builder) + + def Write(self, msgs: List[PduMessage]): + for msg in msgs: + transport = None + match msg.type: + case TransportMetadata.TransportMetadata.Can: + transport = self.emitCanMessageMetadata(msg) + case TransportMetadata.TransportMetadata.Ip: + transport = self.emitIpMessageMetdata(msg) + case TransportMetadata.TransportMetadata.NONE: + pass + case _: + raise ValueError(f"Unsupported transport metadata type: {msg.type}") + + payload = self.builder.CreateByteVector(msg.payload) + + # Match C code: compute final IDs upfront + swc_id = msg.swc_id if msg.swc_id != 0 else (int(self.MimeMap["swc_id"]) if "swc_id" in self.MimeMap else 0) + ecu_id = msg.ecu_id if msg.ecu_id != 0 else (int(self.MimeMap["ecu_id"]) if "ecu_id" in self.MimeMap else 0) + + Pdu.Start(self.builder) + Pdu.AddId(self.builder, msg.id) + Pdu.AddPayload(self.builder, payload) + Pdu.AddSwcId(self.builder, swc_id) + Pdu.AddEcuId(self.builder, ecu_id) + + Pdu.AddTransportType(self.builder, msg.type) + if transport is not None: + Pdu.AddTransport(self.builder, transport) + + pdu = Pdu.End(self.builder) + self.Pdus.append(pdu) + + def StreamFinalize(self) -> bytearray: + Stream.StartPdusVector(self.builder, len(self.Pdus)) + for i in reversed(range(len(self.Pdus))): + self.builder.PrependUOffsetTRelative(self.Pdus[i]) + pdus_vec = self.builder.EndVector(len(self.Pdus)) + + Stream.Start(self.builder) + Stream.AddPdus(self.builder, pdus_vec) + stream = Stream.End(self.builder) + # Finish with identifier like C code (this already includes size prefix) + self.builder.FinishSizePrefixed(stream, b"SPDU") + return self.builder.Output() + + def Flush(self) -> None: + buf = self.StreamFinalize() + if not buf: + return + self.Stream = bytearray(buf) + self.builder = flatbuffers.Builder(1024) + + def decodeIpAddr(self, transport: IpMessageMetadata.IpMessageMetadata, ip_metadata: NCodecIpCanMessageMetadata): + # Create a new table for the IP address + ip_table = transport.IpAddr() + # Get the IP address table from transport + if ip_table: + ip_metadata.ip_addr_type = transport.IpAddrType() + if ip_metadata.ip_addr_type == IpAddr.IpAddr.v4: + # Handle IPv4 address + ip_v4 = IpV4.IpV4() + ip_v4.Init(ip_table.Bytes, ip_table.Pos) + # Initialize the IPv4 address if not already done + if ip_metadata.ip_addr is None: + ip_metadata.ip_addr = NCodecIpAddr( + ip_v4=NCodecPduIpAddrV4(src_ip=0, dst_ip=0), + ip_v6=None + ) + # Update the IPv4 address in ip_metadata + ip_metadata.ip_addr.ip_v4.src_ip = ip_v4.SrcAddr() + ip_metadata.ip_addr.ip_v4.dst_ip = ip_v4.DstAddr() + elif ip_metadata.ip_addr_type == IpAddr.IpAddr.v6: + # Handle IPv6 address + ip_v6 = IpV6.IpV6() + ip_v6.Init(ip_table.Bytes, ip_table.Pos) + # Initialize the IPv6 address if not already done + if ip_metadata.ip_addr is None: + ip_metadata.ip_addr = NCodecIpAddr( + ip_v4=None, + ip_v6=NCodecPduIpAddrV6(src_ip=[0]*8, dst_ip=[0]*8) + ) + # Get source address + src_addr = ip_v6.SrcAddr() + ip_metadata.ip_addr.ip_v6.src_ip[0] = src_addr.V0() + ip_metadata.ip_addr.ip_v6.src_ip[1] = src_addr.V1() + ip_metadata.ip_addr.ip_v6.src_ip[2] = src_addr.V2() + ip_metadata.ip_addr.ip_v6.src_ip[3] = src_addr.V3() + ip_metadata.ip_addr.ip_v6.src_ip[4] = src_addr.V4() + ip_metadata.ip_addr.ip_v6.src_ip[5] = src_addr.V5() + ip_metadata.ip_addr.ip_v6.src_ip[6] = src_addr.V6() + ip_metadata.ip_addr.ip_v6.src_ip[7] = src_addr.V7() + # Get destination address + dst_addr = ip_v6.DstAddr() + ip_metadata.ip_addr.ip_v6.dst_ip[0] = dst_addr.V0() + ip_metadata.ip_addr.ip_v6.dst_ip[1] = dst_addr.V1() + ip_metadata.ip_addr.ip_v6.dst_ip[2] = dst_addr.V2() + ip_metadata.ip_addr.ip_v6.dst_ip[3] = dst_addr.V3() + ip_metadata.ip_addr.ip_v6.dst_ip[4] = dst_addr.V4() + ip_metadata.ip_addr.ip_v6.dst_ip[5] = dst_addr.V5() + ip_metadata.ip_addr.ip_v6.dst_ip[6] = dst_addr.V6() + ip_metadata.ip_addr.ip_v6.dst_ip[7] = dst_addr.V7() + + def decodeSoAd(self, transport: IpMessageMetadata.IpMessageMetadata, ip_metadata: NCodecIpCanMessageMetadata): + # Create a new table for the adapter + ad_table = transport.Adapter() + + # Get the adapter table from transport + if ad_table is not None: + ip_metadata.so_ad_type = transport.AdapterType() + if ip_metadata.so_ad_type == SocketAdapter.SocketAdapter.do_ip: + do_ip = DoIpMetadata.DoIpMetadata() + do_ip.Init(ad_table.Bytes, ad_table.Pos) + ip_metadata.so_ad = NCodecPduSocketAdapter( + do_ip=NCodecPduDoIpAdapter( + protocol_version = do_ip.ProtocolVersion(), + payload_type = do_ip.PayloadType() + + ), + some_ip=None + ) + elif ip_metadata.so_ad_type == SocketAdapter.SocketAdapter.some_ip: + # Handle SomeIP adapter + some_ip = SomeIpMetadata.SomeIpMetadata() + some_ip.Init(ad_table.Bytes, ad_table.Pos) + ip_metadata.so_ad = NCodecPduSocketAdapter( + do_ip=None, + some_ip=NCodecPduSomeIpAdapter( + message_id=some_ip.MessageId(), + length=some_ip.Length(), + request_id=some_ip.RequestId(), + protocol_version = some_ip.ProtocolVersion(), + interface_version = some_ip.InterfaceVersion(), + message_type = some_ip.MessageType(), + return_code = some_ip.ReturnCode() + ) + ) + + def decodeTransport(self, msg: PduMessage, pdu_obj: Pdu): + # Get the transport table from the PDU object + table = pdu_obj.Transport() + if table is not None: + transport_type = pdu_obj.TransportType() + if transport_type == TransportMetadata.TransportMetadata.Can: + # Decode CAN transport metadata + can_transport = CanMessageMetadata.CanMessageMetadata() + can_transport.Init(table.Bytes, table.Pos) + can_metadata = NCodecPduCanMessageMetadata( + format=can_transport.MessageFormat(), + type=can_transport.FrameType(), + interface_id=can_transport.InterfaceId(), + network_id=can_transport.NetworkId() + ) + msg.can_metadata = can_metadata + elif transport_type == TransportMetadata.TransportMetadata.Ip: + # Decode IP transport metadata + ip_transport = IpMessageMetadata.IpMessageMetadata() + ip_transport.Init(table.Bytes, table.Pos) + ip_metadata = NCodecIpCanMessageMetadata( + eth_dst_mac=ip_transport.EthDstMac(), + eth_src_mac=ip_transport.EthSrcMac(), + eth_ethertype=ip_transport.EthEthertype(), + eth_tci_pcp=ip_transport.EthTciPcp(), + eth_tci_dei=ip_transport.EthTciDei(), + eth_tci_vid=ip_transport.EthTciVid(), + ip_protocol=ip_transport.IpProtocol(), + ip_addr_type=ip_transport.IpAddrType(), + ip_addr=None, # Will be set below + ip_src_port=ip_transport.IpSrcPort(), + ip_dst_port=ip_transport.IpDstPort(), + so_ad_type=ip_transport.AdapterType(), + so_ad=None # Will be set below + ) + # Decode IP address + self.decodeIpAddr(ip_transport, ip_metadata) + # Decode Socket Adapter + self.decodeSoAd(ip_transport, ip_metadata) + msg.ip_metadata = ip_metadata + else: + # NOP for unsupported transport types + pass + + def getStreamFromBuffer(self) -> List[Pdu.Pdu]: + list_of_pdus = [] + if self.Stream is None or len(self.Stream) == 0: + return [] + stream = Stream.Stream.GetRootAs(self.Stream, 4) + for i in range(stream.PdusLength()): + Pdu = stream.Pdus(i) + if Pdu: + list_of_pdus.append(Pdu) + else: + break + return list_of_pdus + + + def Read(self) -> List[PduMessage]: + msgs = [] + list_of_pdus = self.getStreamFromBuffer() + swc_id = 0 + if "swc_id" in self.MimeMap: + swc_id = int(self.MimeMap["swc_id"]) + for pdu_obj in list_of_pdus: + if swc_id != 0 and pdu_obj.SwcId() == swc_id: + continue + msg = PduMessage( + id=pdu_obj.Id(), + payload=pdu_obj.PayloadAsNumpy().tobytes(), + swc_id=pdu_obj.SwcId(), + ecu_id=pdu_obj.EcuId(), + type=pdu_obj.TransportType() + ) + self.decodeTransport(msg, pdu_obj) + # If tracing is enabled + # if hasattr(self, "trace") and self.trace is not None: + # self.trace.TraceRX(msg) + msgs.append(msg) + return msgs + + def Truncate(self): + self.builder = flatbuffers.Builder(1024) + self.Stream.clear() + self.Pdus.clear() + + def Stat(self, param: str, new_value: str = None) -> str: + if param in self.MimeMap: + if new_value is not None: + self.MimeMap[param] = new_value + return self.MimeMap[param] + elif new_value is not None: + self.MimeMap[param] = new_value + return self.MimeMap[param] + return "" diff --git a/extra/python/tests/__init__.py b/extra/python/tests/__init__.py new file mode 100644 index 0000000..5e5ac3c --- /dev/null +++ b/extra/python/tests/__init__.py @@ -0,0 +1 @@ +# Tests for extra.python module diff --git a/extra/python/tests/test_can.py b/extra/python/tests/test_can.py new file mode 100644 index 0000000..ce365c9 --- /dev/null +++ b/extra/python/tests/test_can.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +""" +Test cases for PduCodec constructor +""" + +import unittest +from ncodec.can import CanCodec, CanMessage, CanSender +from ncodec import CanFrameType + + +class TestPduCodecConstructor(unittest.TestCase): + """Test cases for PduCodec constructor""" + + def test_pducodec_write(self): + codec = CanCodec("interface=stream;type=pdu;schema=fbs;swc_id=1;ecu_id=2", bytearray(), "MyModel", 0.0) + self.assertIsNotNone(codec) + self.assertEqual(len(codec.Stream), 0) + can_write_list = [ + CanMessage( + frame_id=1, + frame_type=CanFrameType.BaseFrame, + Sender=CanSender( + bus_id=1, + node_id=2, + interface_id=3 + ), + Timing=None, + Payload=b'Hello' + ) + ] + codec.Write(can_write_list) + codec.Flush() + self.assertGreater(len(codec.Stream), 0) + self.assertEqual(len(codec.Frames), 1) + saved_stream = bytes(codec.Stream) + codec.Truncate() + self.assertEqual(len(codec.Stream), 0) + self.assertEqual(len(codec.Frames), 0) + + codec.Stream = saved_stream + can_read_list = codec.Read() + self.assertIsNotNone(can_read_list) + self.assertEqual(len(can_read_list), 1) + for i, msg in enumerate(can_read_list): + self.assertIsInstance(msg, CanMessage) + self.assertEqual(msg.frame_id, can_write_list[i].frame_id) + self.assertEqual(msg.frame_type, can_write_list[i].frame_type) + self.assertEqual(msg.Payload, can_write_list[i].Payload) + self.assertEqual(msg.Sender.bus_id, can_write_list[i].Sender.bus_id) + self.assertEqual(msg.Sender.node_id, can_write_list[i].Sender.node_id) + self.assertEqual(msg.Sender.interface_id, can_write_list[i].Sender.interface_id) + +if __name__ == '__main__': + unittest.main() diff --git a/extra/python/tests/test_interface.py b/extra/python/tests/test_interface.py new file mode 100644 index 0000000..7b98f73 --- /dev/null +++ b/extra/python/tests/test_interface.py @@ -0,0 +1,463 @@ +#!/usr/bin/env python3 +""" +Test cases for the codec interface. + +This module contains comprehensive test cases for both PduCodec and CanCodec +implementations using the common interface. +""" + +import unittest +from typing import List +from ncodec.codec_interface import CodecFactory, ICodec +from ncodec.pdu import PduMessage, PduCodec +from ncodec.can import CanMessage, CanCodec, CanSender, CanTiming +# Note: Stream.Pdu and Stream.Frame modules are not present in the package; tests +# reference TransportMetadata and CanFrameType. If those live in another module, +# adjust imports accordingly. For now the tests use classes from ncodec modules. +from ncodec import TransportMetadata, CanFrameType + + +class TestCodecFactory(unittest.TestCase): + """Test cases for the CodecFactory.""" + + def test_create_pdu_codec(self): + """Test creating a PDU codec using factory.""" + mime_map = {"interface": "stream", "type": "pdu", "schema": "fbs", "swc_id": "1", "ecu_id": "2"} + + codec = CodecFactory.create_pdu_codec( + MimeMap=mime_map, + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + self.assertIsInstance(codec, PduCodec) + self.assertEqual(codec.MimeMap, mime_map) + self.assertEqual(codec.ModelName, "TestModel") + self.assertEqual(codec.SimulationTime, 0.0) + + def test_create_can_codec(self): + """Test creating a CAN codec using factory.""" + mime_map = {"interface": "stream", "type": "can", "schema": "fbs", "swc_id": "1", "ecu_id": "2"} + + codec = CodecFactory.create_can_codec( + MimeMap=mime_map, + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + self.assertIsInstance(codec, CanCodec) + self.assertEqual(codec.MimeMap, mime_map) + self.assertEqual(codec.ModelName, "TestModel") + self.assertEqual(codec.SimulationTime, 0.0) + + def test_create_codec_by_type_pdu(self): + """Test creating codec by type string - PDU.""" + mime_type = "interface=stream;type=pdu;schema=fbs;swc_id=1;ecu_id=2" + + codec = CodecFactory.create_codec( + MimeType=mime_type, + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + self.assertIsInstance(codec, PduCodec) + self.assertEqual(codec.MimeMap["type"], "pdu") + self.assertEqual(codec.MimeMap["swc_id"], "1") + + def test_create_codec_by_type_can(self): + """Test creating codec by type string - CAN.""" + mime_type = "interface=stream;type=can;schema=fbs;swc_id=1;ecu_id=2" + + codec = CodecFactory.create_codec( + MimeType=mime_type, + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + self.assertIsInstance(codec, CanCodec) + self.assertEqual(codec.MimeMap["type"], "can") + self.assertEqual(codec.MimeMap["swc_id"], "1") + + def test_create_codec_unsupported_type(self): + """Test creating codec with unsupported type raises ValueError.""" + mime_type = "interface=stream;type=invalid;schema=fbs" + + with self.assertRaises(ValueError) as context: + CodecFactory.create_codec( + MimeType=mime_type, + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + self.assertIn("unsupported type: invalid", str(context.exception)) + + +class TestInterfacePolymorphism(unittest.TestCase): + """Test cases for polymorphic usage through the interface.""" + + def setUp(self): + """Set up test fixtures.""" + self.pdu_codec = CodecFactory.create_pdu_codec( + {"interface": "stream", "type": "pdu", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "TestModel", + 0.0 + ) + + self.can_codec = CodecFactory.create_can_codec( + {"interface": "stream", "type": "can", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "TestModel", + 0.0 + ) + + self.codecs = [self.pdu_codec, self.can_codec] + + def test_common_interface_properties(self): + """Test that all codecs have common interface properties.""" + for codec in self.codecs: + self.assertIsInstance(codec.MimeMap, dict) + self.assertEqual(codec.ModelName, "TestModel") + self.assertEqual(codec.SimulationTime, 0.0) + self.assertIsInstance(codec.Stream, bytearray) + + def test_stat_method_polymorphism(self): + """Test Stat method works polymorphically across codecs.""" + for codec in self.codecs: + # Set a test parameter + codec.Stat("test_param", "test_value") + + # Get the parameter back + value = codec.Stat("test_param") + self.assertEqual(value, "test_value") + + def test_truncate_method_polymorphism(self): + """Test Truncate method works polymorphically across codecs.""" + for codec in self.codecs: + # Should not raise any exceptions + codec.Truncate() + + # Stream should be reset + self.assertEqual(len(codec.Stream), 0) + + +class TestPduOperations(unittest.TestCase): + """Test cases for PDU-specific operations.""" + + def setUp(self): + """Set up PDU codec for testing.""" + self.codec = PduCodec( + MimeMap={"interface": "stream", "type": "pdu", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + Stream=bytearray(), + ModelName="PDUModel", + SimulationTime=1.0 + ) + + self.test_message = PduMessage( + id=1, + payload=b"Hello PDU", + type=TransportMetadata.NONE, + swc_id=100, + ecu_id=200 + ) + + def test_write_single_message(self): + """Test writing a single PDU message.""" + initial_stream_size = len(self.codec.Stream) + + self.codec.Write([self.test_message]) + + # Stream size should not change until flush + self.assertEqual(len(self.codec.Stream), initial_stream_size) + + def test_write_and_flush(self): + """Test writing and flushing PDU messages.""" + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Stream should have data after flush + self.assertGreater(len(self.codec.Stream), 0) + + def test_write_flush_read_cycle(self): + """Test complete write-flush-read cycle for PDU.""" + # Write message + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Read back + decoded_messages = self.codec.Read() + + # Verify we got our message back + self.assertEqual(len(decoded_messages), 1) + decoded_msg = decoded_messages[0] + + self.assertEqual(decoded_msg.id, self.test_message.id) + self.assertEqual(decoded_msg.payload, self.test_message.payload) + self.assertEqual(decoded_msg.swc_id, self.test_message.swc_id) + self.assertEqual(decoded_msg.ecu_id, self.test_message.ecu_id) + + def test_write_multiple_messages(self): + """Test writing multiple PDU messages.""" + messages = [ + PduMessage(id=1, payload=b"Message 1", type=TransportMetadata.NONE), + PduMessage(id=2, payload=b"Message 2", type=TransportMetadata.NONE), + PduMessage(id=3, payload=b"Message 3", type=TransportMetadata.NONE) + ] + + self.codec.Write(messages) + self.codec.Flush() + + self.codec.Stat("swc_id", "2") + decoded_messages = self.codec.Read() + self.assertEqual(len(decoded_messages), 3) + + for i, decoded_msg in enumerate(decoded_messages): + self.assertEqual(decoded_msg.id, messages[i].id) + self.assertEqual(decoded_msg.payload, messages[i].payload) + + def test_stream_finalize(self): + """Test StreamFinalize method returns serialized data.""" + self.codec.Write([self.test_message]) + + stream_data = self.codec.StreamFinalize() + + self.assertIsInstance(stream_data, bytearray) + self.assertGreater(len(stream_data), 0) + + def test_truncate_clears_state(self): + """Test that Truncate clears codec state.""" + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Verify we have data + self.assertGreater(len(self.codec.Stream), 0) + + # Truncate + self.codec.Truncate() + + # Verify state is cleared + self.assertEqual(len(self.codec.Stream), 0) + + +class TestCanOperations(unittest.TestCase): + """Test cases for CAN-specific operations.""" + + def setUp(self): + """Set up CAN codec for testing.""" + self.codec = CanCodec( + MimeMap={"interface": "stream", "type": "can", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + Stream=bytearray(), + ModelName="CANModel", + SimulationTime=2.0 + ) + + self.test_message = CanMessage( + frame_id=0x123, + frame_type=CanFrameType.BaseFrame, + Sender=CanSender(bus_id=1, node_id=2, interface_id=3), + Timing=None, + Payload=b"Hello CAN" + ) + + def test_write_single_message(self): + """Test writing a single CAN message.""" + initial_stream_size = len(self.codec.Stream) + + self.codec.Write([self.test_message]) + + # Stream size should not change until flush + self.assertEqual(len(self.codec.Stream), initial_stream_size) + + def test_write_and_flush(self): + """Test writing and flushing CAN messages.""" + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Stream should have data after flush + self.assertGreater(len(self.codec.Stream), 0) + + def test_write_flush_read_cycle(self): + """Test complete write-flush-read cycle for CAN.""" + # Write message + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Read back + decoded_messages = self.codec.Read() + + # Verify we got our message back + self.assertEqual(len(decoded_messages), 1) + decoded_msg = decoded_messages[0] + + self.assertEqual(decoded_msg.frame_id, self.test_message.frame_id) + self.assertEqual(decoded_msg.frame_type, self.test_message.frame_type) + self.assertEqual(decoded_msg.Payload, self.test_message.Payload) + self.assertEqual(decoded_msg.Sender.bus_id, self.test_message.Sender.bus_id) + + def test_stream_finalize(self): + """Test StreamFinalize method returns serialized data.""" + self.codec.Write([self.test_message]) + + stream_data = self.codec.StreamFinalize() + + self.assertIsInstance(stream_data, bytearray) + self.assertGreater(len(stream_data), 0) + + def test_truncate_clears_state(self): + """Test that Truncate clears codec state.""" + self.codec.Write([self.test_message]) + self.codec.Flush() + + # Verify we have data + self.assertGreater(len(self.codec.Stream), 0) + + # Truncate + self.codec.Truncate() + + # Verify state is cleared + self.assertEqual(len(self.codec.Stream), 0) + + +class TestGenericOperations(unittest.TestCase): + """Test cases for generic operations using the interface.""" + + def generic_codec_test(self, codec: ICodec, test_message): + """Generic test function that works with any codec.""" + # Write message + codec.Write([test_message]) + + # Get finalized stream + stream_data = codec.StreamFinalize() + self.assertIsInstance(stream_data, bytearray) + self.assertGreater(len(stream_data), 0) + + # Flush to make data available + codec.Flush() + self.assertGreater(len(codec.Stream), 0) + + # Read back + codec.Stat("swc_id", "2") + decoded = codec.Read() + self.assertEqual(len(decoded), 1) + + # Truncate for cleanup + codec.Truncate() + self.assertEqual(len(codec.Stream), 0) + + def test_generic_pdu_operations(self): + """Test generic operations with PDU codec.""" + codec = CodecFactory.create_pdu_codec( + {"interface": "stream", "type": "pdu", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "GenericModel", + 0.0 + ) + + message = PduMessage( + id=42, + payload=b"Generic PDU", + type=TransportMetadata.NONE + ) + + self.generic_codec_test(codec, message) + + def test_generic_can_operations(self): + """Test generic operations with CAN codec.""" + codec = CodecFactory.create_can_codec( + {"interface": "stream", "type": "can", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "GenericModel", + 0.0 + ) + + message = CanMessage( + frame_id=0x456, + frame_type=CanFrameType.BaseFrame, + Sender=CanSender(bus_id=1, node_id=1, interface_id=1), + Timing=None, + Payload=b"Generic CAN" + ) + + self.generic_codec_test(codec, message) + + def test_batch_operations_multiple_codecs(self): + """Test batch operations across multiple codec types.""" + codecs = [ + CodecFactory.create_pdu_codec( + {"interface": "stream", "type": "pdu", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "BatchModel", + 0.0 + ), + CodecFactory.create_can_codec( + {"interface": "stream", "type": "can", "schema": "fbs", "swc_id": "1", "ecu_id": "2"}, + bytearray(), + "BatchModel", + 0.0 + ) + ] + + for i, codec in enumerate(codecs): + # Test that all codecs support the interface + self.assertIsInstance(codec, ICodec) + + # Test common properties + self.assertEqual(codec.ModelName, "BatchModel") + self.assertEqual(codec.SimulationTime, 0.0) + + # Test parameter setting + codec.Stat(f"test_param_{i}", f"test_value_{i}") + value = codec.Stat(f"test_param_{i}") + self.assertEqual(value, f"test_value_{i}") + + +class TestErrorHandling(unittest.TestCase): + """Test cases for error handling in the codec interface.""" + + def test_invalid_mime_type_format(self): + """Test handling of invalid MIME type format.""" + with self.assertRaises(ValueError): + CodecFactory.create_codec( + MimeType="invalid_format_no_equals", + Stream=bytearray(), + ModelName="TestModel", + SimulationTime=0.0 + ) + + def test_empty_message_list(self): + """Test handling of empty message lists.""" + codec = CodecFactory.create_pdu_codec( + {"interface": "stream", "type": "pdu", "schema": "fbs"}, + bytearray(), + "TestModel", + 0.0 + ) + + # Should not raise an exception + codec.Write([]) + codec.Flush() + + decoded = codec.Read() + self.assertEqual(len(decoded), 0) + + def test_read_without_write(self): + """Test reading without writing anything.""" + codec = CodecFactory.create_pdu_codec( + {"interface": "stream", "type": "pdu", "schema": "fbs"}, + bytearray(), + "TestModel", + 0.0 + ) + + decoded = codec.Read() + self.assertEqual(len(decoded), 0) + + +if __name__ == "__main__": + # Run all tests + unittest.main(verbosity=2) \ No newline at end of file diff --git a/extra/python/tests/test_pdu.py b/extra/python/tests/test_pdu.py new file mode 100644 index 0000000..771c574 --- /dev/null +++ b/extra/python/tests/test_pdu.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Test cases for PduCodec constructor +""" + +import unittest +from ncodec.pdu import PduCodec, PduMessage, NCodecIpCanMessageMetadata, NCodecIpAddr, NCodecPduIpAddrV6, NCodecPduIpAddrV4, NCodecPduSocketAdapter, NCodecPduSomeIpAdapter, NCodecPduDoIpAdapter +from ncodec import TransportMetadata +from AutomotiveBus.Stream.Pdu.IpProtocol import IpProtocol +from AutomotiveBus.Stream.Pdu.IpAddr import IpAddr +from AutomotiveBus.Stream.Pdu.SocketAdapter import SocketAdapter + + +class TestPduCodecConstructor(unittest.TestCase): + """Test cases for PduCodec constructor""" + + def test_pducodec_write(self): + MimeMap={"interface":"stream","type":"pdu","schema":"fbs","swc_id":"1","ecu_id":"2"} + codec = PduCodec(MimeMap, bytearray(), "MyModel", 0.0) + self.assertIsNotNone(codec) + self.assertEqual(len(codec.Stream), 0) + pdu_write_list = [PduMessage( + id=123, + payload=b"Hello World This is a test message for the test case", + swc_id=42, + ecu_id=99, + type=TransportMetadata.Ip, + ip_metadata=NCodecIpCanMessageMetadata( + eth_dst_mac=0x0000123456789ABC, + eth_src_mac=0x0000CBA987654321, + eth_ethertype=1, + eth_tci_pcp=2, + eth_tci_dei=3, + eth_tci_vid=4, + ip_protocol=IpProtocol.Tcp, + ip_addr_type=IpAddr.v6, + ip_addr=NCodecIpAddr( + ip_v4=None, + ip_v6=NCodecPduIpAddrV6( + src_ip=[0x2001, 0x0db8, 0xaaaa, 0x0001, 0x0000, 0x0000, 0x0000, 0x0001], # 2001:db8:aaaa:1::1 + dst_ip=[0x2001, 0x0db8, 0xaaaa, 0x0001, 0x0000, 0x0000, 0x0000, 0x00ff] # 2001:db8:aaaa:1::ff + ) + ), + ip_src_port=0, + ip_dst_port=0, + so_ad_type=SocketAdapter.some_ip, + so_ad=NCodecPduSocketAdapter( + do_ip=None, + some_ip=NCodecPduSomeIpAdapter( + message_id=0x1234, # Service ID + Method ID + length=16, # Payload length + 8 byte header + request_id=0x5678, # Client ID + Session ID + protocol_version=1, # SOME/IP version + interface_version=1, # Service interface version + message_type=0x00, # REQUEST + return_code=0x00 # E_OK + ) + ) + ) + ), + PduMessage( + id=124, + payload=b"Hello World This is a test message for the test case", + swc_id=42, + ecu_id=99, + type=TransportMetadata.Ip, + ip_metadata=NCodecIpCanMessageMetadata( + eth_dst_mac=0x0000123456789ABC, + eth_src_mac=0x0000CBA987654321, + eth_ethertype=1, + eth_tci_pcp=2, + eth_tci_dei=3, + eth_tci_vid=4, + ip_protocol=IpProtocol.Tcp, + ip_addr_type=IpAddr.v4, + ip_addr=NCodecIpAddr( + ip_v4=NCodecPduIpAddrV4( + src_ip=0xC0A80101, # 192.168.1.1 + dst_ip=0xC0A80102 # 192.168.1.2 + ), + ip_v6=None + ), + ip_src_port=0, + ip_dst_port=0, + so_ad_type=SocketAdapter.do_ip, + so_ad=NCodecPduSocketAdapter( + do_ip=NCodecPduDoIpAdapter( + protocol_version=1, + payload_type=2 + ), + some_ip=None + ) + ) + )] + codec.Write(pdu_write_list) + codec.Flush() + self.assertGreater(len(codec.Stream), 0) + self.assertEqual(len(codec.Pdus), 2) + saved_stream = bytes(codec.Stream) + codec.Truncate() + self.assertEqual(len(codec.Stream), 0) + self.assertEqual(len(codec.Pdus), 0) + + codec.Stream = saved_stream + pdu_read_list = codec.Read() + self.assertIsNotNone(pdu_read_list) + self.assertEqual(len(pdu_read_list), 2) + for i, msg in enumerate(pdu_read_list): + self.assertIsInstance(msg, PduMessage) + self.assertEqual(msg.ecu_id, pdu_write_list[i].ecu_id) + self.assertEqual(msg.swc_id, pdu_write_list[i].swc_id) + self.assertEqual(msg.id, pdu_write_list[i].id) + self.assertEqual(msg.type, pdu_write_list[i].type) + self.assertEqual(msg.payload, pdu_write_list[i].payload) + + self.assertEqual(msg.ip_metadata.eth_dst_mac, pdu_write_list[i].ip_metadata.eth_dst_mac) + self.assertEqual(msg.ip_metadata.eth_src_mac, pdu_write_list[i].ip_metadata.eth_src_mac) + self.assertEqual(msg.ip_metadata.eth_tci_pcp, pdu_write_list[i].ip_metadata.eth_tci_pcp) + self.assertEqual(msg.ip_metadata.eth_tci_vid, pdu_write_list[i].ip_metadata.eth_tci_vid) + self.assertEqual(msg.ip_metadata.ip_addr_type, pdu_write_list[i].ip_metadata.ip_addr_type) + self.assertEqual(msg.ip_metadata.ip_addr, pdu_write_list[i].ip_metadata.ip_addr) + self.assertEqual(msg.ip_metadata.ip_dst_port, pdu_write_list[i].ip_metadata.ip_dst_port) + self.assertEqual(msg.ip_metadata.ip_src_port, pdu_write_list[i].ip_metadata.ip_src_port) + self.assertEqual(msg.ip_metadata.ip_protocol, pdu_write_list[i].ip_metadata.ip_protocol) + + self.assertEqual(msg.ip_metadata.so_ad_type, pdu_write_list[i].ip_metadata.so_ad_type) + self.assertEqual(msg.ip_metadata.so_ad, pdu_write_list[i].ip_metadata.so_ad) + self.assertEqual(msg.can_metadata, pdu_write_list[i].can_metadata) + +if __name__ == '__main__': + unittest.main()