nixnet.constants

class nixnet._enums.AppProtocol

Bases: enum.Enum

Application Protocol.

Values:

NONE:

The default application protocol.

J1939:

Indicates J1939 clusters. The value enables the following features:

• Sending/receiving long frames as the SAE J1939 specification specifies, using the J1939 transport protocol.
• Using a special notation for J1939 identifiers.
• Using J1939 address claiming.

class nixnet._enums.BlinkMode

Bases: enum.Enum

Interface blink mode.

Values:

DISABLE:

Disable blinking for identification. This option turns off both LEDs for the port.

ENABLE:

Enable blinking for identification. Both LEDs of the interface’s physical port turn on and off. The hardware blinks the LEDs automatically until you disable.

class nixnet._enums.CanCommState

Bases: enum.Enum

CAN Comm State.

Values:

ERROR_ACTIVE:

This state reflects normal communication, with few errors detected. The CAN interface remains in this state as long as receive error counter and transmit error counter are both below 128.

ERROR_PASSIVE:

If either the receive error counter or transmit error counter increment above 127, the CAN interface transitions into this state. Although communication proceeds, the CAN device generally is assumed to have problems with receiving frames.

When a CAN interface is in error passive state, acknowledgement errors do not increment the transmit error counter. Therefore, if the CAN interface transmits a frame with no other device (ECU) connected, it eventually enters error passive state due to retransmissions, but does not enter bus off state.

BUS_OFF:

If the transmit error counter increments above 255, the CAN interface transitions into this state. Communication immediately stops under the assumption that the CAN interface must be isolated from other devices.

When a CAN interface transitions to the bus off state, communication stops for the interface. All NI-XNET sessions for the interface no longer receive or transmit frame values. To restart the CAN interface and all its sessions, call nixnet._session.base.SessionBase.start.

INIT:

This is the CAN interface initial state on power-up. The interface is essentially off, in that it is not attempting to communicate with other nodes (ECUs).

When the start trigger occurs for the CAN interface, it transitions from the Init state to the Error Active state. When the interface stops due to a call to nixnet._session.base.SessionBase.stop., the CAN interface transitions from either Error Active or Error Passive to the Init state. When the interface stops due to the Bus Off state, it remains in that state until you restart.

class nixnet._enums.CanFdIsoMode

Bases: enum.Enum

CAN FD ISO MODE.

Values:

ISO:

ISO CAN FD standard (ISO standard 11898-1:2015)

In ISO CAN FD mode, for every transmitted frame, you can specify in the database or frame header whether a frame must be sent in CAN 2.0, CAN FD, or CAN FD+BRS mode. In the frame type field of the frame header, received frames indicate whether they have been sent with CAN 2.0, CAN FD, or CAN FD+BRS. You cannot use the Interface:CAN:Transmit I/O Mode property in ISO CAN FD mode, as the frame defines the transmit mode.

NON_ISO:

non-ISO CAN FD standard (Bosch CAN FD 1.0 specification)

In Non-ISO CAN FD mode, CAN data frames are received at CAN data typed frames, which is either CAN 2.0, CAN FD, or CAN FD+BRS, but you cannot distinguish the standard in which the frame has been transmitted.

ISO_LEGACY:

You also can set the mode to Legacy ISO mode. In this mode, the behavior is the same as in Non-ISO CAN FD mode (Interface:CAN:Transmit I/O Mode is working, and received frames have the CAN data type). But the interface is working in ISO CAN FD mode, so you can communicate with other ISO CAN FD devices. Use this mode only for compatibility with existing applications.

class nixnet._enums.CanIoMode

Bases: enum.Enum

CAN I/O Mode.

Values:

CAN:

This is the default CAN 2.0 A/B standard I/O mode as defined in ISO 11898-1:2003. A fixed baud rate is used for transfer, and the payload length is limited to 8 bytes.

CAN_FD:

This is the CAN FD mode as specified in the CAN with Flexible Data-Rate specification, version 1.0. Payload lengths up to 64 are allowed, but they are transmitted at a single fixed baud rate (defined by Cluster.can_fd_baud_rate or Interface.can_fd_baud_rate).

CAN_FD_BRS:

This is the CAN FD as specified in the CAN with Flexible Data-Rate specification, version 1.0, with the optional Baud Rate Switching enabled. The same payload lengths as CAN FD mode are allowed; additionally, the data portion of the CAN frame is transferred at a different (higher) baud rate (defined by Cluster.can_fd_baud_rate or Interface.can_fd_baud_rate).

class nixnet._enums.CanLastErr

Bases: enum.Enum

CAN Last Error

Values:

NONE:

The last receive or transmit was successful.

STUFF:

More than 5 equal bits have occurred in sequence, which the CAN specification does not allow.

FORM:

A fixed format part of the received frame used the wrong format.

ACK:

Another node (ECU) did not acknowledge the frame transmit.

If you call the appropriate write function and do not have a cable connected, or the cable is connected to a node that is not communicating, you see this error repeatedly. The CAN communication state eventually transitions to Error Passive, and the frame transmit retries indefinitely.

BIT1:

During a frame transmit (with the exception of the arbitration ID field), the interface wanted to send a recessive bit (logical 1), but the monitored bus value was dominant (logical 0).

BIT0:

During a frame transmit (with the exception of the arbitration ID field), the interface wanted to send a dominant bit (logical 0), but the monitored bus value was recessive (logical 1).

CRC:

The CRC contained within a received frame does not match the CRC calculated for the incoming bits.

class nixnet._enums.CanPendTxOrder

Bases: enum.Enum

Can Pending Transmit Order.

Values:

AS_SUBMITTED:

Frames are transmitted in the order that they were submitted into the queue. There is no reordering of any frames, and a higher priority frame may be delayed due to the transmission or retransmission of a previously submitted frame. However, this mode has the highest performance.

BY_IDENTIFIER:

Frames with the highest priority identifier (lower CAN ID value) transmit first. The frames are stored in a priority queue sorted by ID. If a frame currently being transmitted requires retransmission (for example, it lost arbitration or failed with a bus error), and a higher priority frame is queued in the meantime, the lower priority frame is not immediately retried, but the higher priority frame is transmitted instead. In this mode, you can emulate multiple ECUs and still see a behavior similar to a real bus in that the highest priority message is transmitted on the bus. This mode may be slower in performance (possible delays between transmissions as the queue is re-evaluated), and lower priority messages may be delayed indefinitely due to frequent high-priority messages.

class nixnet._enums.CanTcvrCap

Bases: enum.Enum

CAN bus phusical transceivers support.

Values:

HS:

High-Speed / Flexible Data-Rate (HS/FD).

LS:

Low-Speed / Fault-Tolerant (LS//FT)

XS:

XS (HS//FD, LS/FT, SW, or External)

XSHSLS:

XS (HS//FD, LS/FT)

class nixnet._enums.CanTcvrState

Bases: enum.Enum

CAN Transceiver State.

Values:

NORMAL:

This state sets the transceiver to normal communication mode. If the transceiver is in the Sleep mode, this performs a local wakeup of the transceiver and CAN controller chip.

SLEEP:

This state sets the transceiver and CAN controller chip to Sleep (or standby) mode. You can set the interface to Sleep mode only while the interface is communicating. If the interface has not been started, setting the transceiver to Sleep mode returns an error.

Before going to sleep, all pending transmissions are transmitted onto the CAN bus. Once all pending frames have been transmitted, the interface and transceiver go into Sleep (or standby) mode. Once the interface enters Sleep mode, further communication is not possible until a wakeup occurs. The transceiver and CAN controller wake from Sleep mode when either a local wakeup or remote wakeup occurs.

A local wakeup occurs when the application sets the transceiver state to either Normal or Single Wire Wakeup.

A remote wakeup occurs when a remote node transmits a CAN frame (referred to as the wakeup frame). The wakeup frame wakes up the NI-XNET interface transceiver and CAN controller chip. The CAN controller chip does not receive or acknowledge the wakeup frame. After detecting the wakeup frame and idle bus, the CAN interface enters Normal mode.

When the local or remote wakeup occurs, frame transmissions resume from the point at which the original Sleep mode was set.

SW_WAKEUP:

For a remote wakeup to occur for Single Wire transceivers, the node that transmits the wakeup frame first must place the network into the Single Wire Wakeup Transmission mode by asserting a higher voltage.

This state sets a Single Wire transceiver into the Single Wire Wakeup Transmission mode, which forces the Single Wire transceiver to drive a higher voltage level on the network to wake up all sleeping nodes. Other than this higher voltage, this mode is similar to Normal mode. CAN frames can be received and transmitted normally.

If you are not using a Single Wire transceiver, setting this state returns an error. If your current mode is Single Wire High-Speed, setting this mode returns an error because you are not allowed to wake up the bus in high-speed mode.

The application controls the timing of how long the wakeup voltage is driven. The application typically changes to Single Wire Wakeup mode, transmits a single wakeup frame, and then returns to Normal mode.

SW_HIGH_SPEED:

This state sets a Single Wire transceiver into Single Wire High-Speed Communication mode. If you are not using a Single Wire transceiver, setting this state returns an error.

Single Wire High-Speed Communication mode disables the transceiver’s internal waveshaping function, allowing the SAE J2411 High-Speed baud rate of 83.333 kbytes/s to be used. The disadvantage versus Single Wire Normal Communication mode, which allows only the SAE J2411 baud rate of 33.333 kbytes/s, is degraded EMC performance. Other than the disabled waveshaping, this mode is similar to Normal mode. CAN frames can be received and transmitted normally.

This mode has no relationship to High-Speed transceivers. It is merely a higher speed mode of the Single Wire transceiver, typically used to download data when the onboard network is attached to an offboard tester ECU.

The Single Wire transceiver does not support use of this mode in conjunction with Sleep mode. For example, a remote wakeup cannot transition from sleep to this Single Wire High-Speed mode. Therefore, setting the mode to Sleep from Single Wire High-Speed mode returns an error.

class nixnet._enums.CanTcvrType

Bases: enum.Enum

CAN Transceiver Type

Values:

High-Speed (HS):

This configuration enables the High-Speed transceiver. This transceiver supports baud rates of 40 kbaud to 1 Mbaud. When using a High-Speed transceiver, you also can communicate with a CAN FD bus. Refer to NI-XNET Hardware Overview to determine which CAN FD baud rates are supported.

Low-Speed/Fault-Tolerant (LS):

This configuration enables the Low-Speed/Fault-Tolerant transceiver. This transceiver supports baud rates of 40-125 kbaud.

Single Wire (SW):

This configuration enables the Single Wire transceiver. This transceiver supports baud rates of 33.333 kbaud and 83.333 kbaud.

External (EXT):

This configuration allows you to use an external transceiver to connect to your CAN bus. Refer to the XNET Session Interface:CAN:External Transceiver Config property for more information.

Disconnect (DISC):

This configuration allows you to disconnect the CAN controller chip from the connector. You can use this value when you physically change the external transceiver.

class nixnet._enums.CanTerm

Bases: enum.Enum

CAN Termination.

Different CAN hardware has different termination requirements, and the OFF and ON values have different meanings.

High-Speed CAN

High-Speed CAN networks are typically terminated on the bus itself instead of within a node. However, NI-XNET allows you to configure termination within the node to simplify testing. If your bus already has the correct amount of termination, leave this property in the default state of Off. However, if you require termination, set this property to On.

Values:

OFF:

Termination is disabled.

On:

Termination (120 Ohms) is enabled.

Low-Speed/Fault-Tolerant CAN

Every node on a Low-Speed CAN network requires termination for each CAN data line (CAN_H and CAN_L). This configuration allows the Low-Speed/Fault-Tolerant CAN port to provide fault detection and recovery. Refer to Termination for more information about low-speed termination. In general, if the existing network has an overall network termination of 125 Ohms or less, turn on termination to enable the 4.99 kOhms option. Otherwise, you should select the default 1.11 kOhms option.

Values:

OFF:

Termination is set to 1.11 kOhms.

ON:

Termination is set to 4.99 kOhms.

Single-Wire CAN

The ISO standard requires Single-Wire transceivers to have a 9.09 kOhms resistor, and no additional configuration is supported.

class nixnet._enums.CanTermCap

Bases: enum.Enum

CAN Termination Capability.

Values:

NO YES

class nixnet._enums.ClstFlexRaySampClkPer

Bases: enum.Enum

An enumeration.

class nixnet._enums.Condition

Bases: enum.Enum

An enumeration.

class nixnet._enums.CreateSessionMode

Bases: enum.Enum

Create Session Mode.

The session mode specifies the data type (signals or frames), direction (input or output), and how data is transferred between your application and the network.

Values:

SIGNAL_IN_SINGLE_POINT:

Reads the most recent value received for each signal. This mode typically is used for control or simulation applications, such as Hardware In the Loop (HIL).

SIGNAL_IN_WAVEFORM:

Using the time when the signal frame is received, resamples the signal data to a waveform with a fixed sample rate. This mode typically is used for synchronizing XNET data with DAQmx analog/digital input channels.

SIGNAL_IN_XY:

For each frame received, provides its signals as a value/timestamp pair. This is the recommended mode for reading a sequence of all signal values.

SIGNAL_OUT_SINGLE_POINT:

Writes signal values for the next frame transmit. This mode typically is used for control or simulation applications, such as Hardware In the Loop (HIL).

SIGNAL_OUT_WAVEFORM:

Using the time when the signal frame is transmitted according to the database, resamples the signal data from a waveform with a fixed sample rate. This mode typically is used for synchronizing XNET data with DAQmx analog/digital output channels.

SIGNAL_OUT_XY:

Provides a sequence of signal values for transmit using each frame’s timing as the database specifies. This is the recommended mode for writing a sequence of all signal values.

FRAME_IN_STREAM:

Reads all frames received from the network using a single stream. This mode typically is used for analyzing and/or logging all frame traffic in the network.

FRAME_IN_QUEUED:

Reads data from a dedicated queue per frame. This mode enables your application to read a sequence of data specific to a frame (for example, CAN identifier).

FRAME_IN_SINGLE_POINT:

Reads the most recent value received for each frame. This mode typically is used for control or simulation applications that require lower level access to frames (not signals).

FRAME_OUT_STREAM:

Transmits an arbitrary sequence of frame values using a single stream. The values are not limited to a single frame in the database, but can transmit any frame.

FRAME_OUT_QUEUED:

Provides a sequence of values for a single frame, for transmit using that frame’s timing as the database specifies.

FRAME_OUT_SINGLE_POINT:

Writes frame values for the next transmit. This mode typically is used for control or simulation applications that require lower level access to frames (not signals).

SIGNAL_CONVERSION_SINGLE_POINT:

This mode does not use any hardware. It is used to convert data between the signal representation and frame representation.

class nixnet._enums.DevForm

Bases: enum.Enum

Device physical form factor.

Values:

C_SERIES PCI PCIE PXI PXIE USB

class nixnet._enums.DongleId

Bases: enum.Enum

Dongle ID

Values:

HSCAN:

CAN High Speed

XSCAN:

CAN Software-Selectable

LIN:

LIN

DONGLE_LESS:

Dongle-Less Design

class nixnet._enums.DongleState

Bases: enum.Enum

Dongle State.

Values:

NO_DONGLE_NO_EXT_POWER:

No dongle, no external power.

NO_DONGLE_EXT_POWER:

No dongle, has external power.

DONGLE_NO_EXT_POWER:

Has dongle, no external power.

READY:

Ready.

BUSY:

Busy.

COMM_ERROR:

Comm Error.

OVERCURRENT:

Overcurrent.

class nixnet._enums.Err

Bases: enum.Enum

Error codes returned by NI-XNET.

class nixnet._enums.FlexRayPocState

Bases: enum.Enum

An enumeration.

class nixnet._enums.FlexRaySleep

Bases: enum.Enum

An enumeration.

class nixnet._enums.FlexRayTerm

Bases: enum.Enum

An enumeration.

class nixnet._enums.FrameType

Bases: enum.Enum

Frame format type.

class nixnet._enums.FrmCanTiming

Bases: enum.Enum

CAN Frame Timing

Values:

CYCLIC_DATA:

The transmitting ECU transmits the CAN data frame in a cyclic (periodic) manner. The Frame.can_tx_time property defines the time between cycles. The transmitting ECU ignores CAN remote frames received for this frame.

EVENT_DATA:

The transmitting ECU transmits the CAN data frame in an event-driven manner. The Frame.can_tx_time property defines the minimum interval. For NI-XNET, the event occurs when you write data to a session. The transmitting ECU ignores CAN remote frames received for this frame.

CYCLIC_REMOTE:

The receiving ECU transmits the CAN remote frame in a cyclic (periodic) manner. The Frame.can_tx_time property defines the time between cycles. The transmitting ECU responds to each CAN remote frame by transmitting the associated CAN data frame.

EVENT_REMOTE:

The receiving ECU transmits the CAN remote frame in an event-driven manner. The Frame.can_tx_time property defines the minimum interval. For NI-XNET, the event occurs when you write a frame to a session. The transmitting ECU responds to each CAN remote frame by transmitting the associated CAN data frame.

CYCLIC_EVENT:

This timing type is a combination of the cyclic and event timing. The frame is transmitted when you write to a session, but also periodically sending the last recent values written. The Frame.can_tx_time property defines the cycle period. There is no minimum interval time defined in this mode, so be careful not to write too frequently to avoid creating a high busload.

class nixnet._enums.FrmFlexRayChAssign

Bases: enum.Enum

An enumeration.

class nixnet._enums.FrmFlexRayTiming

Bases: enum.Enum

An enumeration.

class nixnet._enums.FrmLinChecksum

Bases: enum.Enum

LIN Frame Transmitted Checksum

Values:

CLASSIC:

Classic checksum.

ENHANCED:

Enhanced checksum.

class nixnet._enums.GetDbcAttributeMode

Bases: enum.Enum

An enumeration.

class nixnet._enums.LinCommState

Bases: enum.Enum

LIN Comm State

Values:

IDLE:

This is the LIN interface initial state on power-up. The interface is essentially off, in that it is not attempting to communicate with other nodes (ECUs). When the start trigger occurs for the LIN interface, it transitions from the Idle state to the Active state. When the interface stops due to a call to XNET Stop, the LIN interface transitions from either Active or Inactive to the Idle state.

ACTIVE:

This state reflects normal communication. The LIN interface remains in this state as long as bus activity is detected (frame headers received or transmitted).

INACTIVE:

This state indicates that no bus activity has been detected in the past four seconds.

Regardless of whether the interface acts as a master or slave, it transitions to this state after four seconds of bus inactivity. As soon as bus activity is detected (break or frame header), the interface transitions to the Active state.

The LIN interface does not go to sleep automatically when it transitions to Inactive. To place the interface into sleep mode, set the XNET Session Interface:LIN:Sleep property when you detect the Inactive state.

class nixnet._enums.LinDiagnosticSchedule

Bases: enum.Enum

LIN Diagnostic Schedule

Values:

NULL:

The master does not execute any diagnostic schedule. No master request or slave response headers are transmitted on the LIN.

MASTER_REQ:

The master executes a diagnostic master request schedule (transmits a master request header onto the LIN) if it can. First, a master request schedule must be defined for the LIN cluster in the imported or in-memory database. Otherwise, error ‘nixnet._enums.Err.DIAGNOSTIC_SCHEDULE_NOT_DEFINED’ is returned when attempting to set this value. Second, the master must have a frame output queued session created for the master request frame, and there must be one or more new master request frames pending in the queue. If no new frames are pending in the output queue, no master request header is transmitted. This allows the timing of master request header transmission to be controlled by the timing of master request frame writes to the output queue.

If there are no normal schedules pending, the master is effectively in diagnostics-only mode, and master request headers are transmitted at a rate determined by the slot delay defined for the master request frame slot in the master request schedule or the nixnet._session.intf.Interface.lin_diag_s_tmin property time, whichever is greater, and the state of the master request frame output queue as described above.

If there are normal schedules pending, the master is effectively in diagnostics-interleaved mode, and a master request header transmission is inserted between each complete execution of a run-once or run-continuous schedule, as long as the nixnet._session.intf.Interface.lin_diag_s_tmin property time has been met, and there are one or more new master request frames pending in the master request frame output queue.

SLAVE_RESP:

The master executes a diagnostic slave response schedule (transmits a slave response header onto the LIN) if it is able to. A slave response schedule must be defined for the LIN cluster in the imported or in-memory database. Otherwise, error ‘nixnet._enums.Err.DIAGNOSTIC_SCHEDULE_NOT_DEFINED’ is returned when attempting to set this value.

If there are no normal schedules pending, the master is effectively in diagnostics-only mode, and slave response headers are transmitted at the rate of the slot delay defined for the slave response frame slot in the slave response schedule. The addressed slave may or may not respond to each header, depending on its specified P2min and STmin timings.

If there are normal schedules pending, the master is effectively in diagnostics-interleaved mode, and a slave response header transmission is inserted between each complete execution of a run-once or run-continuous schedule. Here again, the addressed slave may or may not respond to each header, depending on its specified P2min and STmin timings.

class nixnet._enums.LinLastErr

Bases: enum.Enum

LIN Comm Last Error Code

Values:

NONE:

No bus error has occurred since the previous communication state read.

UNKNOWN_ID:

Received a frame identifier that is not valid.

FORM:

The form of a received frame is incorrect. For example, the database specifies 8 bytes of payload, but you receive only 4 bytes.

FRAMING:

The byte framing is incorrect (for example, a missing stop bit).

READBACK:

The interface transmitted a byte, but the value read back from the transceiver was different. This often is caused by a cabling problem, such as noise.

TIMEOUT:

Receiving the frame took longer than the LIN-specified timeout.

CRC:

The received checksum was different than the expected checksum.

class nixnet._enums.LinProtocolVer

Bases: enum.Enum

LIN Protocol Version

Values:

VER_1_2:

Version 1.2

VER_1_3:

Version 1.3

VER_2_0:

Version 2.0

VER_2_1:

Version 2.1

VER_2_2:

Version 2.2

class nixnet._enums.LinSchedEntryType

Bases: enum.Enum

LIN Schedule Entry Type.

Values:

UNCONDITIONAL:

A single frame transfers in this slot.

SPORADIC:

The master transmits in this slot. The master can select from multiple frames to transmit. Only updated frames are transmitted. When more than one frame is updated, the master decides by priority which frame to send. The other updated frame remains pending and can be sent when this schedule entry is processed the following time. The order of unconditional frames in LinSchedEntry.frames (the first frame has the highest priority) determines the frame priority.

EVENT_TRIGGERED:

Multiple slaves can transmit an unconditional frame in this slot. The slave transmits the frame only if at least one frame signal has been updated. When a collision occurs (multiple slaves try to transmit in the same slot), this is detected and resolved using a different schedule specified in the LinSchedEntry.collision_res_sched property. The resolving schedule runs once, starting in the subsequent slot after the collision, and automatically returns to the previous schedule at the subsequent position where the collision occurred.

NODE_CONFIG_SERVICE:

The schedule entry contains a node configuration service. The node configuration service is defined as raw data bytes in LinSchedEntry.nc_ff_data_bytes.

class nixnet._enums.LinSchedRunMode

Bases: enum.Enum

LIN Schedule Run Mode.

Values:

CONTINUOUS:

The master runs the schedule continuously. When the last entry executes, the schedule starts again with the first entry.

ONCE:

The master runs the schedule once (all entries), then returns to the previously running continuous schedule (or NULL). If requests are submitted for multiple run-once schedules, each run-once executes in succession based on its LinSched.priority, then the master returns to the continuous schedule (or NULL).

NULL:

All communication stops immediately. A schedule with this run mode is called a null schedule.

class nixnet._enums.LinSleep

Bases: enum.Enum

LIN interface sleep/awake state

Values:

REMOTE_SLEEP:

Set interface to sleep locally and transmit sleep requests to remote node.

REMOTE_WAKE:

Set interface to awake locally and transmit wakeup requests to remote nodes.

LOCAL_SLEEP:

Set interface to sleep locally and not to interact with the network.

LOCAL_WAKE:

Set interface to awake locally and not to interact with the network.

class nixnet._enums.LinTerm

Bases: enum.Enum

LIN Termination

class nixnet._enums.Merge

Bases: enum.Enum

Cluster Merge Behavior

Values:

COPY_USE_SOURCE:

The target object with all dependent child objects is removed from the target cluster and replaced by the source objects.

COPY_USE_TARGET:

The source object is ignored (the target cluster object with child objects remains unchanged).

MERGE_USE_SOURCE:

This adds child objects from the source object to child objects from the destination object. If target object contains a child object with the same name, the child object from the source frame replaces it. The source object properties (for example, payload length of the frame) replace the target properties.

MERGE_USE_TARGET:

This adds child objects from the source object to child objects from the destination object. If the target object contains a child object with the same name, it remains unchanged. The target object properties remain unchanged (for example, payload length).

class nixnet._enums.ObjectClass

Bases: enum.Enum

An enumeration.

class nixnet._enums.OutStrmTimng

Bases: enum.Enum

Output Stream Timing

Values:

IMMEDIATE:

Frames are dequeued from the queue and transmitted immediately to the bus. The hardware transmits all frames in the queue as fast as possible. There are no restrictions on frames that you use in other sessions.

For replay modes, the hardware is placed into a Replay mode. In this mode, the hardware evaluates the frame timestamps and attempts to maintain the original transmission times as the timestamp stored in the frame indicates. The actual transmission time is based on the relative time difference between the first dequeued frame and the time contained in the dequeued frame.

REPLAY_EXCLUSIVE:

The hardware transmits only frames that do not appear in the list. You cannot create any other output sessions. Attempting to create an output session returns an error. Input sessions have no restrictions.

This can be used to test an ECU when the output stream list contains the frames the ECU transmits. You can replay all frames in this mode if the output stream list is unset.

REPLAY_INCLUSIVE:

The hardware transmits only frames that appear in the list. You can create output sessions that use frames that do not appear in the Interface:Output Stream List property. Attempting to create an output session that uses a frame from the Interface:Output Stream List property results in an error. Input sessions have no restrictions.

This can be used to emulate an ECU when the output stream list contains the frames the ECU transmits.

class nixnet._enums.Phase

Bases: enum.Enum

Version Phase.

Values:

RELEASE

class nixnet._enums.Protocol

Bases: enum.Enum

Protocol.

Values:

UNKNOWN:

Unknown protocol,

CAN:

CAN protocol.

FLEX_RAY:

FlexRay protocol.

LIN:

LIN protocol.

class nixnet._enums.ReadState

Bases: enum.Enum

An enumeration.

class nixnet._enums.SessionInfoState

Bases: enum.Enum

State of running session.

Values:

STOPPED:

All frames in the session are stopped.

STARTED:

All frames in the session are started.

MIX:

Some frames in the session are started while other frames are stopped. This state may occur when using start or stop with StartStopScope.SESSION_ONLY.

class nixnet._enums.SigByteOrdr

Bases: enum.Enum

Signal Byte Order

Values:

Little Endian:

Higher significant signal bits are placed on higher byte addresses. In NI-CAN, this was called Intel Byte Order.

Little Endian Signal with Start Bit 12

Big Endian:

Higher significant signal bits are placed on lower byte addresses. In NI-CAN, this was called Motorola Byte Order.

Big Endian Signal with Start Bit 12

class nixnet._enums.SigDataType

Bases: enum.Enum

Signal Data Type

Values:

SIGNED:

Signed integer with positive and negative values.

UNSIGNED:

Unsigned integer with no negative values.

IEEE_FLOAT:

Float value with 7 or 15 significant decimal digits (32 bit or 64 bit).

class nixnet._enums.StartStopScope

Bases: enum.Enum

Start/Stop Scope enum.

Values:

NORMAL:

The session is started followed by starting the interface. This is equivalent to calling nixnet._session.base.SessionBase.start with the Session Only Scope followed by calling nixnet._session.base.SessionBase.start with the Interface Only Scope.

SESSION_ONLY:

The session is placed into the Started state (refer to State Models). If the interface is in the Stopped state before this function runs, the interface remains in the Stopped state, and no communication occurs with the bus. To have multiple sessions start at exactly the same time, start each session with the Session Only Scope. When you are ready for all sessions to start communicating on the associated interface, call nixnet._session.base.SessionBase.start with the Interface Only scope. Starting a previously started session is considered a no-op. This operation sends the command to start the session, but does not wait for the session to be started. It is ideal for a real-time application where performance is critical.

INTERFACE_ONLY:

If the underlying interface is not previously started, the interface is placed into the Started state (refer to State Models). After the interface starts communicating, all previously started sessions can transfer data to and from the bus. Starting a previously started interface is considered a no-op.

SESSION_ONLY_BLOCKING:

The session is placed in the Started state (refer to State Models). If the interface is in the Stopped state before this function runs, the interface remains in the Stopped state, and no communication occurs with the bus. To have multiple sessions start at exactly the same time, start each session with the Session Only Scope. When you are ready for all sessions to start communicating on the associated interface, call nxStart with the Interface Only Scope. Starting a previously started session is considered a no-op. This operation waits for the session to start before completing.

class nixnet._enums.Warn

Bases: enum.Enum

Warning codes returned by NI-XNET.

class nixnet._enums.WriteState

Bases: enum.Enum

An enumeration.