`vspyx.Frames`

Subpackages

Package Contents

Classes

`Buffer`	Represents the functional basis of a transaction buffer consisting of zero or more frames
`BufferOpener`	Represents the function of reading recorded message frame buffer data
`BufferSource`	Represents the functional basis of time-varied frame buffer data hosting
`CANConfirmation`	Represents the completion of a pending CANFrame forward/transmit
`CANControllerState`	Enum where members are also (and must be) ints
`CANDriver`	Represents CAN driver function
`CANErrorCountsEvent`	Represents an event emitted onto the channel by a CAN Controller
`CANFrame`	Represents a CAN communication frame
`CANFrameBuilder`	Represents CAN frame construction support functionality
`Confirmation`	Represents the completion of a pending Frame forward/transmit
`Coremini`	Coremini
`Driver`	Represents the functional basis for a communication driver interface
`DriverIdentifier`	Represents the general classification of a driver identify
`EthernetConfirmation`	Represents the completion of a pending EthernetFrame forward/transmit
`EthernetDriver`	Rerepsents an Ethernet device driver
`EthernetFrame`	Represents an Ethernet message frame
`FileId`	FileId
`FlexRayCCConfiguration`	FlexRayCCConfiguration
`FlexRayCRCStatus`	Enum where members are also (and must be) ints
`FlexRayChannel`	Enum where members are also (and must be) ints
`FlexRayClusterConfiguration`	FlexRayClusterConfiguration
`FlexRayDriver`	Represents a Flexray driver
`FlexRayFrame`	Represents a Flexray frame
`FlexRayFrameBuilder`	FlexRayFrameBuilder
`FlexRayStrobePoint`	Enum where members are also (and must be) ints
`FlexRaySymbol`	Enum where members are also (and must be) ints
`FlexRayTransmitBufferUpdate`	Transmitted onto a FlexRayChannel when a Controller
`Frame`	Represents the basis of a physical communication frame
`FrameBuilder`	Represents the basis of a message frame builder
`FrameType`	Represents message frame type identification info
`Identifier`	Represents an identity associated with an object
`LINDriver`	Rerepsents an LIN device driver
`Module`	Represents the generic basis of frame modules
`NetworkEvent`	Represents an event that a controller would observe/create regarding a network.
`NetworkIdentifier`	Represents a network object identifier
`Predicate`	Represents a predicate handler used in comparison of message frame objects of various types
`Record`	Record
`SimResetEvent`	Represents an event propogating over the network when we know that a simulation
`Source`	Represents the basis of a message frame data source
`SourceFinder`	Resolves message data source handler objects
`SourceIdentifier`	Rerepesents the identification info for a data source object
`VSAFilesystem`	VSAFilesystem
`WritableBuffer`	Represents a writable output frame buffer
`WritableBufferOpener`	Represents the function of opening an output buffer for writing message frames

class vspyx.Frames.Buffer

Bases: vspyx.Core.ResolverObject

Inheritance diagram of vspyx.Frames.Buffer

Represents the functional basis of a transaction buffer consisting of zero or more frames

Duration :Any

FileName :str

Identifer :SourceIdentifier

NumberOfFrames :int

TypeString :str

IsPrepared(self) → bool

Prepare(self, task: vspyx.Core.TaskInterface) → Any

__getitem__(self, index: int) → NetworkEvent

class vspyx.Frames.BufferOpener

Bases: vspyx.Core.ResolverObject

Inheritance diagram of vspyx.Frames.BufferOpener

Represents the function of reading recorded message frame buffer data

TypeString :str

CanOpen(self, path: str) → bool

Open(self, path: str) → vspyx.Core.Task_0f35f34819

class vspyx.Frames.BufferSource

Bases: Source

Inheritance diagram of vspyx.Frames.BufferSource

Represents the functional basis of time-varied frame buffer data hosting

Buffer :Buffer

BufferEndEvent :vspyx.Core.Event

Loop :bool

LoopCount :int

OnLooped :vspyx.Core.Callback_634bd5c449

Paused :bool

Position :float

TimeMultiplier :float

TimeSkipDetectionThreshold :Any

Get/set the current threshold of elapsed time that indicates we were frozen (in a suspended VM, say).

If we detect we were frozen, we will skip the time in the buffer rather than attempting to catch up to where we would have been if all that time had elapsed.

This prevents us from entering a death spiral of processing in these cases.

The default threshold is one second, and it will not trigger if the Scheduler is in non-realtime mode.

This API is not guaranteed and should not be relied on long term, but it is provided in case the threshold is causing problems and a quick workaround is needed.

UseSimulationTime :bool

Used to select whether the timestamps of the buffer should be synchronized with the beginning of the simulation (true) or the beginning of the buffer (false).

This defaults to true when running realtime for correct synchronization with real hardware, and false when running non-realtime for accurate timestamps while processing.

Note that even when false, the buffer source creates timestamps after the final frame for buffer looping.

The value is latched during ComponentStart, so if the value is changed while running it will take effect the next time the source is started.

MakeSchedulerTicker(self) → vspyx.Runtime.SchedulerTicker

class vspyx.Frames.CANConfirmation

Bases: Confirmation

Inheritance diagram of vspyx.Frames.CANConfirmation

Represents the completion of a pending CANFrame forward/transmit

CANFrame :CANFrame

Status :CANDriver.TxStatus

static New(frame: CANFrame, status: CANDriver.TxStatus) → CANConfirmation

class vspyx.Frames.CANControllerState

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.CANControllerState

Enum where members are also (and must be) ints

BusOff = 2

ErrorActive = 0

ErrorPassive = 1

class vspyx.Frames.CANDriver

Bases: Driver

Inheritance diagram of vspyx.Frames.CANDriver

Represents CAN driver function

class TxStatus

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.CANDriver.TxStatus

Enum where members are also (and must be) ints

Aborted = 1

ArbitrationLost = 2

Transmitted = 0

FDBaudRate :Any

class vspyx.Frames.CANErrorCountsEvent

Bases: NetworkEvent

Inheritance diagram of vspyx.Frames.CANErrorCountsEvent

Represents an event emitted onto the channel by a CAN Controller when its error counts change. It does not represent an event that would occur on a physical CAN bus, but is propagated for display reasons.

BusOff :bool

ControllerState :CANControllerState: The error state of the CAN controller

CountsAsTraffic :bool

ErrorWarning :bool

Some CAN controllers have an “error warning” threshold when either counter goes above 95.

Since it is not a standardized error state, it is not reported as the controller state, but the value can be read here.

ReceiveErrorCount :int

TransmitErrorCount :int

static New(timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, tec: int, rec: int, busOff: bool) → CANErrorCountsEvent

class vspyx.Frames.CANFrame

Bases: Frame

Inheritance diagram of vspyx.Frames.CANFrame

Represents a CAN communication frame

ArbID :int

BaudrateSwitch :bool

DLC :int

IsCANFD :bool

IsExtended :bool

IsRemote :bool

class vspyx.Frames.CANFrameBuilder

Bases: CANFrame

Inheritance diagram of vspyx.Frames.CANFrameBuilder

Represents CAN frame construction support functionality

ArbID :int

ArbIDMask :int

Arbitrary :int

BaudrateSwitch :bool

BaudrateSwitchMask :bool

CANFDMask :bool

DLC :int

DLCMask :int

Data :vspyx.Core.BytesView

ExtendedMask :bool

IsCANFD :bool

IsExtended :bool

IsRemote :bool

Mask :vspyx.Core.BytesView

Network :NetworkIdentifier

RemoteMask :bool

Source :SourceIdentifier

Timestamp :vspyx.Runtime.Timestamp

Type :FrameType

ArbIDSet(self, set: int) → CANFrameBuilder
ArbIDSet(self, set: int, mask: int) → CANFrameBuilder

BaudrateSwitchSet(self, set: bool) → CANFrameBuilder
BaudrateSwitchSet(self, set: bool, mask: bool) → CANFrameBuilder

Byte(self, index: int, value: int) → CANFrameBuilder
Byte(self, index: int, value: int, mask: int) → CANFrameBuilder

CANFDSet(self, set: bool) → CANFrameBuilder
CANFDSet(self, set: bool, mask: bool) → CANFrameBuilder

static CAN_DLCToDL(dlc: int, fd: bool) → int

Convert a given CAN DLC nibble to a CAN data length.

If fd is false, only 0-8 are acceptable, throwing otherwise.

If `fd is true, then 0-64 are acceptable, throwing otherwise.

static CAN_DLToDLC(dataLength: int, fd: bool) → int

Convert a given CAN data length to a CAN DLC nibble.

If fd is false, only 0-8 are acceptable, throwing otherwise.

If `fd is true, then hex 0-F are acceptable, throwing otherwise.

Clone(self) → NetworkEvent

DLCAutosetFromDataSizeAndCANFDFlag(self) → CANFrameBuilder

Automatically set the DLC given the currently set Data.

Checks the current IsCANFD flag to enable the upper 4 DLC bits.

Throws std::runtime_error if the Data is too long for the current frame type (2.0 vs FD)

DLCSet(self, set: int) → CANFrameBuilder
DLCSet(self, set: int, mask: int) → CANFrameBuilder

DataSet(self, bytes: List[int]) → Any
DataSet(self, bytes: vspyx.Core.BytesView) → Any

ExtendedSet(self, set: bool) → CANFrameBuilder
ExtendedSet(self, set: bool, mask: bool) → CANFrameBuilder

RemoteSet(self, set: bool) → CANFrameBuilder
RemoteSet(self, set: bool, mask: bool) → CANFrameBuilder

class vspyx.Frames.Confirmation

Bases: NetworkEvent

Inheritance diagram of vspyx.Frames.Confirmation

Represents the completion of a pending Frame forward/transmit

CountsAsTraffic :bool

Frame :Frame

IsError :bool

Network :NetworkIdentifier

Source :SourceIdentifier

class vspyx.Frames.Coremini

Coremini

CollectionNames :List[str]

CreateTime :vspyx.Runtime.Timestamp

EncryptedSize :int

FirstLogSector :int

Hash :vspyx.Core.BytesView

PersistentLogDataOffset :int

PersistentLogDataSector :int

ReadBinSizeSectors :int

ReadBinStartSector :int

RootDirectorySector :int

RootDirectorySize :int

Version :int

GenerateBinary(self) → vspyx.Core.BytesView

static GetChecksum(bytes: List[int], filesize: int) → int

GetCollectionName(self, functionBlockIndex: int) → str

static GetCoreminiNetId(record: int) → int

static GetVersion(inputStream: vspyx.IO.FileInputStream) → int

HasEnhancedRootDirectory(self) → bool

assign(self, arg0: Coremini) → Coremini

class vspyx.Frames.Driver

Bases: vspyx.Core.Object

Inheritance diagram of vspyx.Frames.Driver

Represents the functional basis for a communication driver interface

class IngressResult

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.Driver.IngressResult

Enum where members are also (and must be) ints

Failed = 3

Nop = 0

Requested = 1

Successful = 2

BaudRate :int

Identifier :DriverIdentifier

OnEvent :vspyx.Core.Callback_316d8f46e9

Called when the driver reports an occurrence of a Network Event.

This could be a Frames::Frame or any other event that the Driver can detect.

SubmitEvent(self, event: NetworkEvent) → Driver.IngressResult

Submit an event to the driver.

For instance, the event may be a Frame, in which case we expect the Driver to Transmit the Frame.

class vspyx.Frames.DriverIdentifier

Bases: Identifier

Inheritance diagram of vspyx.Frames.DriverIdentifier

Represents the general classification of a driver identify

Description :str

class vspyx.Frames.EthernetConfirmation

Bases: Confirmation

Inheritance diagram of vspyx.Frames.EthernetConfirmation

Represents the completion of a pending EthernetFrame forward/transmit

EthernetFrame :EthernetFrame

Status :EthernetDriver.TxStatus

static New(frame: EthernetFrame, status: EthernetDriver.TxStatus) → EthernetConfirmation

class vspyx.Frames.EthernetDriver

Bases: Driver

Inheritance diagram of vspyx.Frames.EthernetDriver

Rerepsents an Ethernet device driver

class TxStatus

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.EthernetDriver.TxStatus

Enum where members are also (and must be) ints

Dropped = 1

Transmitted = 0

class vspyx.Frames.EthernetFrame

Bases: Frame

Inheritance diagram of vspyx.Frames.EthernetFrame

Represents an Ethernet message frame

IsFCSAvailable :bool

IsFrameTooShort :bool

IsNoPadding :bool

IsPreemptionEnabled :bool

PreemptionFlags :int

static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, arbitrary: int) → EthernetFrame

class vspyx.Frames.FileId

FileId

ID :str

StartSector :int

Timestamp :vspyx.Runtime.Timestamp

UnixTimestamp :int

assign(self, arg0: FileId) → FileId

class vspyx.Frames.FlexRayCCConfiguration

FlexRayCCConfiguration

AcceptStartupRangeMicroticks :int

AllowHaltDueToClock :bool

AllowPassiveToActiveCyclePairs :int

ChannelA :bool

ChannelB :bool

ClusterDriftDamping :int

DecodingCorrectionMicroticks :int

DelayCompensationAMicroticks :int

DelayCompensationBMicroticks :int

ExternOffsetCorrectionControl :int

ExternOffsetCorrectionMicroticks :int

ExternRateCorrectionControl :int

ExternRateCorrectionMicroticks :int

ExternalSync :bool

FallBackInternal :bool

GlobalConfiguration :FlexRayClusterConfiguration

KeySlotID :int

KeySlotOnlyEnabled :bool

KeySlotUsedForStartup :bool

KeySlotUsedForSync :bool

LatestTxMinislot :int

ListenTimeout :int

MTSOnA :bool

MTSOnB :bool

MacroInitialOffsetA :int

MacroInitialOffsetB :int

MaximumDynamicPayloadLengthWords :int

MicroInitialOffsetA :int

MicroInitialOffsetB :int

MicroPerCycle :int

MicrotickDurationSec :float

NMVectorEarlyUpdate :bool

OffsetCorrectionOutMicroticks :int

RateCorrectionOutMicroticks :int

SamplesPerMicrotick :int

SecondKeySlotID :int

TwoKeySlotMode :bool

UseExternalSync :bool

UseFallBackInternal :bool

UseMicrotickDurationSec :bool

UseNMVectorEarlyUpdate :bool

UseSamplesPerMicrotick :bool

WakeupOnChannelB :bool

WakeupPattern :int

class vspyx.Frames.FlexRayCRCStatus

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.FlexRayCRCStatus

Enum where members are also (and must be) ints

Error = 1

NoCRC = 2

OK = 0

class vspyx.Frames.FlexRayChannel

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.FlexRayChannel

Enum where members are also (and must be) ints

A = 0

AB = 2

B = 1

class vspyx.Frames.FlexRayClusterConfiguration

FlexRayClusterConfiguration

ActionPointOffset :int

BitTimeNS :int

CASRxLowMax :int

ColdStartAttempts :int

CycleCountMax :int

CycleDurationSec :float

DetectNITError :bool

DynamicSlotIdlePhaseMinislots :int

IgnoreAfterTx :int

ListenNoiseMacroticks :int

MacrotickDurationSec :float

MacroticksPerCycle :int

MaxWithoutClockCorrectionFatal :int

MaxWithoutClockCorrectionPassive :int

MinislotActionPointOffsetMacroticks :int

MinislotDurationMacroticks :int

NetworkIdleTimeMacroticks :int

NetworkManagementVectorLengthBytes :int

NumberOfMinislots :int

NumberOfStaticSlots :int

OffsetCorrectionStartMacroticks :int

PayloadLengthOfStaticSlotInWords :int

SafetyMarginMacroticks :int

SampleClockPeriodSec :float

StaticSlotMacroticks :int

SymbolWindowActionPointOffsetMacroticks :int

SymbolWindowMacroticks :int

SyncFrameIDCountMax :int

TransceiverStandbyDelaySec :float

TransmissionStartSequenceDurationBits :int

UseSampleClockPeriodSec :bool

UseTransceiverStandbyDelaySec :bool

WakeupRxIdleBits :int

WakeupRxLowBits :int

WakeupRxWindowBits :int

WakeupTxActiveBits :int

WakeupTxIdleBits :int

class vspyx.Frames.FlexRayDriver

Bases: Driver

Inheritance diagram of vspyx.Frames.FlexRayDriver

Represents a Flexray driver

GetAllowColdstart(self, idx: int) → bool

GetStartWhenGoingOnline(self, idx: int) → bool

GetWakeupBeforeStart(self, idx: int) → bool

Halt(self, idx: int) → Any

SetAllowColdstart(self, idx: int, enable: bool) → Any

SetCCConfiguration(self, idx: int, config: FlexRayCCConfiguration) → Any

SetStartWhenGoingOnline(self, idx: int, enable: bool) → Any

SetWakeupBeforeStart(self, idx: int, enable: bool) → Any

Start(self, idx: int) → Any

class vspyx.Frames.FlexRayFrame

Bases: Frame

Inheritance diagram of vspyx.Frames.FlexRayFrame

Represents a Flexray frame

CRCStatus :FlexRayCRCStatus

Channel :FlexRayChannel

Cycle :int

FrameCRC :int

FrameLen :float

HeaderCRC :int

HeaderCRCStatus :FlexRayCRCStatus

IsDynamicFrame :bool

IsNullFrame :bool

IsStartupFrame :bool

IsSyncFrame :bool

PayloadPreamble :bool

ReservedBit :bool

SlotID :int

Symbol :FlexRaySymbol

TSSLen :float

class vspyx.Frames.FlexRayFrameBuilder

Bases: FlexRayFrame

FlexRayFrameBuilder

Arbitrary :int

Data :vspyx.Core.BytesView

Network :NetworkIdentifier

Source :SourceIdentifier

Timestamp :vspyx.Runtime.Timestamp

Type :FrameType

Clone(self) → NetworkEvent

DataSet(self, bytes: List[int]) → Any
DataSet(self, bytes: vspyx.Core.BytesView) → Any

GetCRCStatus(self) → FlexRayCRCStatus

GetChannel(self) → FlexRayChannel

GetCycle(self) → int

GetFrameCRC(self) → int

GetFrameLen(self) → float

GetHeaderCRC(self) → int

GetHeaderCRCStatus(self) → FlexRayCRCStatus

GetIsDynamicFrame(self) → bool

GetIsNullFrame(self) → bool

GetIsStartupFrame(self) → bool

GetIsSyncFrame(self) → bool

GetPayloadPreamble(self) → bool

GetReservedBit(self) → bool

GetSlotID(self) → int

GetSymbol(self) → FlexRaySymbol

GetTSSLen(self) → float

SetCRCStatus(self, CRCStatus: FlexRayCRCStatus) → FlexRayFrameBuilder

SetChannel(self, channel: FlexRayChannel) → FlexRayFrameBuilder

SetCycle(self, cycle: int) → FlexRayFrameBuilder

SetFrameCRC(self, frameCRC: int) → FlexRayFrameBuilder

SetFrameLen(self, FrameLen: float) → FlexRayFrameBuilder

SetHeaderCRC(self, headerCRC: int) → FlexRayFrameBuilder

SetHeaderCRCStatus(self, headerCRCStatus: FlexRayCRCStatus) → FlexRayFrameBuilder

SetIsDynamicFrame(self, isDynamicFrame: bool) → FlexRayFrameBuilder

SetIsNullFrame(self, isNullFrame: bool) → FlexRayFrameBuilder

SetIsStartupFrame(self, isStartupFrame: bool) → FlexRayFrameBuilder

SetIsSyncFrame(self, isSyncFrame: bool) → FlexRayFrameBuilder

SetPayloadPreamble(self, payloadPreamble: bool) → FlexRayFrameBuilder

SetReservedBit(self, isReservedBit: bool) → FlexRayFrameBuilder

SetSlotID(self, slotID: int) → FlexRayFrameBuilder

SetSymbol(self, symbol: FlexRaySymbol) → FlexRayFrameBuilder

SetTSSLen(self, TSSLen: float) → FlexRayFrameBuilder

class vspyx.Frames.FlexRayStrobePoint

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.FlexRayStrobePoint

Enum where members are also (and must be) ints

SPP4 = 1

SPP5 = 0

SPP6 = 2

class vspyx.Frames.FlexRaySymbol

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.FlexRaySymbol

Enum where members are also (and must be) ints

CAS = 3

NONE = 0

Unknown = 1

Wakeup = 2

class vspyx.Frames.FlexRayTransmitBufferUpdate

Bases: NetworkEvent

Inheritance diagram of vspyx.Frames.FlexRayTransmitBufferUpdate

Transmitted onto a FlexRayChannel when a Controller updates its transmit buffer.

This way, any physical FrameSources can update their internal transmit buffers as necessary to create this traffic on the physical bus when the time comes.

class Mode

Bases: enum.IntEnum

Inheritance diagram of vspyx.Frames.FlexRayTransmitBufferUpdate.Mode

Enum where members are also (and must be) ints

Clear = 3

Continuous = 1

FIFO = 2

OneShot = 0

BaseCycle :int

Channel :FlexRayChannel

CountsAsTraffic :bool

CycleRepetition :int

Data :vspyx.Core.BytesView

IsDynamic :bool

IsKeySlot :bool

IsNMFrame :bool

IsStartup :bool

IsSync :bool

SlotID :int

GetMode(self) → FlexRayTransmitBufferUpdate.Mode

Matches(self, other: FlexRayTransmitBufferUpdate) → bool: Returns true if the given FlexRayTransmitBufferUpdate would use the same message buffer as the current FlexRayTransmitBufferUpdate would.

static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int) → FlexRayTransmitBufferUpdate
static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int, dynamic: bool) → FlexRayTransmitBufferUpdate
static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int, dynamic: bool, networkManagement: bool) → FlexRayTransmitBufferUpdate
static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int, dynamic: bool, networkManagement: bool, keySlot: bool) → FlexRayTransmitBufferUpdate
static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int, dynamic: bool, networkManagement: bool, keySlot: bool, sync: bool) → FlexRayTransmitBufferUpdate
static New(data: vspyx.Core.BytesView, timestamp: vspyx.Runtime.Timestamp, source: SourceIdentifier, network: NetworkIdentifier, baseCycle: int, cycleRepetition: int, mode: FlexRayTransmitBufferUpdate.Mode, channel: FlexRayChannel, slotId: int, dynamic: bool, networkManagement: bool, keySlot: bool, sync: bool, startup: bool) → FlexRayTransmitBufferUpdate

class vspyx.Frames.Frame

Bases: NetworkEvent

Inheritance diagram of vspyx.Frames.Frame

Represents the basis of a physical communication frame

Arbitrary :int

CountsAsTraffic :bool

Data :vspyx.Core.BytesView

Type :FrameType

class vspyx.Frames.FrameBuilder

Bases: Frame

Inheritance diagram of vspyx.Frames.FrameBuilder

Represents the basis of a message frame builder

Arbitrary :int

Data :vspyx.Core.BytesView

Timestamp :vspyx.Runtime.Timestamp

Clone(self) → NetworkEvent

DataSet(self, bytes: List[int]) → FrameBuilder

GetNetwork(self) → NetworkIdentifier

GetSource(self) → SourceIdentifier

GetType(self) → FrameType

SetNetwork(self, network: NetworkIdentifier) → FrameBuilder

SetSource(self, source: SourceIdentifier) → FrameBuilder

SetType(self, type: FrameType) → FrameBuilder

class vspyx.Frames.FrameType

Bases: vspyx.Core.Object

Inheritance diagram of vspyx.Frames.FrameType

Represents message frame type identification info

class Enum

Bases: enum.IntFlag

Inheritance diagram of vspyx.Frames.FrameType.Enum

Support for integer-based Flags

A2B = 11

CAN = 2

Ethernet = 6

FlexRay = 4

I2C = 10

ISO9141 = 9

LIN = 3

MOST = 5

Unknown = 65535

GetEnum(self) → FrameType.Enum

static TypeToString(e: FrameType.Enum) → int

__eq__(self, compare: FrameType.Enum) → bool: Return self==value.

__str__(self) → str: Return str(self).

assign(self, e: FrameType.Enum) → FrameType

class vspyx.Frames.Identifier

Bases: vspyx.Core.Object

Inheritance diagram of vspyx.Frames.Identifier

Represents an identity associated with an object

__eq__(self, rhs: Identifier) → bool: Return self==value.

__str__(self) → str: Return str(self).

class vspyx.Frames.LINDriver

Bases: Driver

Inheritance diagram of vspyx.Frames.LINDriver

Rerepsents an LIN device driver

class vspyx.Frames.Module

Bases: vspyx.Core.Module

Inheritance diagram of vspyx.Frames.Module

Represents the generic basis of frame modules

AddBufferOpener(self, opener: BufferOpener) → Any

AddSourceFinder(self, finder: SourceFinder) → Any

AddWritableBufferOpener(self, opener: WritableBufferOpener) → Any

CanOpenBuffer(self, path: str) → bool

CanWriteBuffer(self, path: str) → bool

DiscoverAllSources(self) → List[Source]

FindSourceByDescription(self, description: str) → List[Source]

NewSourceFromBuffer(self, buffer: Buffer) → BufferSource

OpenBuffer(self, path: str) → vspyx.Core.Task_0f35f34819

OpenWritableBuffer(self, path: str) → WritableBuffer

class vspyx.Frames.NetworkEvent

Bases: vspyx.Core.Object

Inheritance diagram of vspyx.Frames.NetworkEvent

Represents an event that a controller would observe/create regarding a network.

It is the basis for Frame, ACK, NAK, Error State Change, Link State Change, etc.

CountsAsTraffic :bool: Whether or not this NetworkEvent counts as “traffic” for the purposes of statistics reporting, i.e. for the Channel’s “total traffic” counter.

Network :NetworkIdentifier

Source :SourceIdentifier

Timestamp :vspyx.Runtime.Timestamp

Clone(self) → NetworkEvent

class vspyx.Frames.NetworkIdentifier

Bases: Identifier

Inheritance diagram of vspyx.Frames.NetworkIdentifier

Represents a network object identifier

Description :str

Type :FrameType

class vspyx.Frames.Predicate

Represents a predicate handler used in comparison of message frame objects of various types

Function :vspyx.Core.Function_9f3a3da547

class vspyx.Frames.Record

Record

Header :int

Timestamp :vspyx.Runtime.Timestamp

HasValidChecksum(self) → bool

IsValidRecordForPreTrigger(self, functionBlockId: int) → bool

MatchesCaptureMask(self, captureMask: int) → bool

UpdateCaptureMask(self, captureMask: int) → Any

assign(self, arg0: Record) → Record

class vspyx.Frames.SimResetEvent

Bases: NetworkEvent

Inheritance diagram of vspyx.Frames.SimResetEvent

Represents an event propogating over the network when we know that a simulation source has reset and closed its connections. While it is not always possible to know that a source has reset connections, we can send this when a buffer file simulation loops or a simulated ECU resets to make heuristic followers act in a more user-friendly way.