from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import typing # NOQA: F401
import six
from nixnet import _funcs
from nixnet import _props
from nixnet import constants
[docs]class Interface(object):
'''Interfaces associated with a physical hardware device.'''
def __init__(self, handle):
# type: (int) -> None
self._handle = handle
def __eq__(self, other):
if isinstance(other, self.__class__):
return self._handle == typing.cast(Interface, other)._handle
elif isinstance(other, six.string_types):
return self._name == typing.cast(typing.Text, other)
else:
return NotImplemented
def __ne__(self, other):
result = self.__eq__(other)
if result is NotImplemented:
return result
else:
return not result
def __hash__(self):
return hash(self._handle)
def __str__(self):
# type: () -> typing.Text
return self._name
def __repr__(self):
# type: () -> typing.Text
return '{}(handle={})'.format(type(self).__name__, self._handle)
# `dev_ref`: Intentionally not exposed to avoid circular imports
@property
def num(self):
# type: () -> int
'''int: The unique number associated with the XNET interface.
The XNET driver assigns each port connector in the system a unique
number XNET driver. This number, plus its protocol name, is the
interface name.
'''
return _props.get_interface_num(self._handle)
@property
def port_num(self):
# type: () -> int
'''int: Physical port number printed near the connector on the XNET device.
The port numbers on an XNET board are physically identified with
numbering. Use this property, along with the XNET Device Serial Number
property, to associate an XNET interface with a physical (XNET board
and port) combination.
'''
return _props.get_interface_port_num(self._handle)
@property
def protocol(self):
# type: () -> constants.Protocol
''':any:`nixnet._enums.Protocol`: Protocol supported by the interface.'''
return constants.Protocol(_props.get_interface_protocol(self._handle))
@property
def can_term_cap(self):
# type: () -> constants.CanTermCap
''':any:`nixnet._enums.CanTermCap`: Indicates whether the XNET interface can terminate the CAN bus.
Signal reflections on the CAN bus can cause communication failure. To
prevent reflections, termination can be present as external resistance
or resistance the XNET board applies internally. This property
determines whether the XNET board can add termination to the bus.
'''
return constants.CanTermCap(_props.get_interface_can_term_cap(self._handle))
@property
def can_tcvr_cap(self):
# type: () -> constants.CanTcvrCap
''':any:`nixnet._enums.CanTcvrCap`: Indicates the CAN bus physical transceiver support.'''
return constants.CanTcvrCap(_props.get_interface_can_tcvr_cap(self._handle))
@property
def dongle_state(self):
# type: () -> constants.DongleState
''':any:`nixnet._enums.DongleState`: Indicates the connected Transceiver Cable's state.
Some Transceiver Cable types require external power from the network
connector for operation. Refer to the hardware-specific manual for more
information.
'''
return constants.DongleState(_props.get_interface_dongle_state(self._handle))
@property
def dongle_id(self):
# type: () -> constants.DongleId
''':any:`nixnet._enums.DongleId`: Indicates the connected Transceiver Cable's type.
Dongle-Less Design indicates this interface is not a Transceiver Cable
but a regular XNET expansion card, cDAQ Module, and so on.
'''
return constants.DongleId(_props.get_interface_dongle_id(self._handle))
@property
def dongle_revision(self):
# type: () -> int
'''int: The connected Transceiver Cable's hardware revision number.'''
return _props.get_interface_dongle_revision(self._handle)
@property
def dongle_firmware_version(self):
# type: () -> int
'''int: The connected Transceiver Cable's firmware revision number.'''
return _props.get_interface_dongle_firmware_version(self._handle)
@property
def dongle_compatible_revision(self):
# type: () -> int
'''int: The oldest driver version compatible with the connected Transceiver Cable's hardware revision.
The number is relative to the first driver version that supported the
particular Transceiver Cable model, starting with 1 for the original
revision.
.. note:: A Transceiver Cable hardware revision might require a later
XNET driver than the version that introduced support for this model for
operation.
'''
return _props.get_interface_dongle_compatible_revision(self._handle)
@property
def dongle_compatible_firmware_version(self):
# type: () -> int
'''int: The oldest driver version compatible with the connected Transceiver Cable's firmware.
The number is relative to the first driver version that supported the
Transceiver Cable, starting with 1 for the original revision.
..note:: A Transceiver Cable running an updated firmware version may
require a later XNET driver than the version it shipped with for
operation.
'''
return _props.get_interface_dongle_compatible_firmware_version(self._handle)
[docs] def blink(self, modifier):
# type: (constants.BlinkMode) -> None
'''Blinks LEDs for the XNET interface to identify its physical port in the system.
Each XNET device contains one or two physical ports. Each port is
labeled on the hardware as Port 1 or Port 2. The XNET device also
provides two LEDs per port. For a two-port board, LEDs 1 and 2 are
assigned to Port 1, and LEDs 3 and 4 are assigned to physical Port 2.
When your application uses multiple XNET devices, this function helps
to identify each interface to associate its software behavior to its
hardware connection (port). Prior to running your XNET sessions, you
can call this function to blink the interface LEDs.
For example, if you have a system with three PCI CAN cards, each with
two ports, you can use this function to blink the LEDs for interface
CAN4, to identify it among the six CAN ports.
The LEDs of each port support two states:
Identification:
Blink LEDs to identify the physical port assigned to the interface.
In Use:
LED behavior that XNET sessions control.
**Identification LED State**
You can use the ``blink`` function only in the Identification state. If
you call this function while one or more XNET sessions for the
interface are open (created), it returns an error, because the port's
LEDs are in the In Use state.
**In Use LED State**
When you create an XNET session for the interface, the LEDs for that
physical port transition to the In Use state. If you called the ``blink``
function previously to enable blinking for identification, that LED
behavior no longer applies. The In Use LED state remains until all XNET
sessions are cleared. This typically occurs when the application
terminates. The patterns that appear on the LEDs while In Use are
documented in LEDs.
Args:
moodifier (:any:`nixnet._enums.BlinkMode`): Controls LED blinking
Both LEDs blink green (not red). The blinking rate is approximately
three times per second.
'''
_funcs.nx_blink(self._handle, modifier)
@property
def _name(self):
# type: () -> typing.Text
return _props.get_interface_name(self._handle)