def __init__(self,
port="0",
datarate=1000000,
host_id=2,
module_id=1,
debug=False):
if not isinstance(port, str):
raise TypeError
if port not in _CHANNELS:
raise ValueError("Invalid port!")
TmclInterface.__init__(self, host_id, module_id, debug)
self._channel = port
self._bitrate = datarate
try:
if self._debug:
self._connection = can.Bus(interface="kvaser",
channel=self._channel,
bitrate=self._bitrate)
else:
self._connection = can.Bus(interface="kvaser",
channel=self._channel,
bitrate=self._bitrate,
can_filters=[{
"can_id": host_id,
"can_mask": 0x7F
}])
except CanError as e:
self._connection = None
raise ConnectionError("Failed to connect to Kvaser CAN bus") from e
if self._debug:
print("Opened bus on channel " + str(self._channel))
def test_open_buses(self):
with can.Bus(interface='virtual') as bus_send, can.Bus(interface='virtual') as bus_recv:
bus_send.send(self.msg_send)
msg_recv = bus_recv.recv()
# Receiving a frame with data should evaluate msg_recv to True
self.assertTrue(msg_recv)
def setUp(self):
self._send_bus = can.Bus(interface=self.INTERFACE_1,
channel=self.CHANNEL_1,
bitrate=self.BITRATE)
self._recv_bus = can.Bus(interface=self.INTERFACE_2,
channel=self.CHANNEL_2,
bitrate=self.BITRATE)
def test_use_closed_bus(self):
with can.Bus(interface='virtual') as bus_send, can.Bus(interface='virtual') as bus_recv:
bus_send.send(self.msg_send)
# Receiving a frame after bus has been closed should raise a CanException
self.assertRaises(can.CanError, bus_recv.recv)
self.assertRaises(can.CanError, bus_send.send, self.msg_send)
def openBus(self, bus, reactor, callback):
def cbAndTrack(message):
# print(message)
self._messagesProcessed += 1
callback(message)
#f platform == 'linux' and bus == 'vcan0':
if False:
canbus = pycan.Bus('vcan0', bustype='socketcan')
else:
canbus = pycan.Bus(0, bustype='kvaser', bitrate=250000)
# NMT
canopen_nmt_start = pycan.Message(arbitration_id=0x00,
data=[0x01, 0x00])
canbus.send(canopen_nmt_start)
decoder = PDODecoder()
def getMessages():
#for msg in canbus:
msg = canbus.recv()
message = decoder.decode_pdo(msg.arbitration_id, msg.data)
if message:
cbAndTrack(message)
if not self._stopped:
reactor.callLater(0.001, getMessages)
else:
canbus.shutdown()
return
reactor.callLater(0.001, getMessages)
def setUp(self):
transport = can.Bus("test", bustype="virtual")
self.slave_bus = can.Bus("test", bustype="virtual")
self.master = Master(transport, cro_id=0x7E1, dto_id=0x321)
self.master.ctr = 0x27
self.acknowledge = CommandReturnMessage(
arbitration_id=0x321,
return_code=ReturnCodes.ACKNOWLEDGE,
ctr=self.master.ctr,
)
def setUp(self):
self.cro_id = 0x7E1
self.dto_id = 0x321
self.master_bus = can.Bus("test", bustype="virtual", receive_own_messages=True)
self.slave_bus = can.Bus("test", bustype="virtual")
self.sorter = MessageSorter(self.dto_id, self.cro_id)
test_signal = Element(name="testSignal", size=4, address=0xDEADBEEF,)
self.test_odt = ObjectDescriptorTable(elements=[test_signal], number=2)
self.test_odt.register()
self.notifier = can.Notifier(self.master_bus, [self.sorter])
def setUp(self):
self.bus1 = can.Bus(channel=self.CHANNEL_1,
bustype=self.INTERFACE_1,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True)
self.bus2 = can.Bus(channel=self.CHANNEL_2,
bustype=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True)
def setUp(self):
socketcan_version = can.util.choose_socketcan_implementation()
print("testing python-can's socketcan version:", socketcan_version)
self.bus1 = can.Bus(channel="vcan0",
bustype=socketcan_version,
bitrate=250000,
fd=TEST_CAN_FD)
self.bus2 = can.Bus(channel="vcan0",
bustype=socketcan_version,
bitrate=250000,
fd=TEST_CAN_FD)
def test_bus_creation(self):
# channel must be >= 0
with self.assertRaises(ValueError):
can.Bus(interface="ixxat", fd=True, channel=-1)
# rx_fifo_size must be > 0
with self.assertRaises(ValueError):
can.Bus(interface="ixxat", fd=True, channel=0, rx_fifo_size=0)
# tx_fifo_size must be > 0
with self.assertRaises(ValueError):
can.Bus(interface="ixxat", fd=True, channel=0, tx_fifo_size=0)
def test_send_type(self, name, msg_type, expected_value) -> None:
with self.subTest(name):
(
is_extended_id,
is_remote_frame,
is_error_frame,
is_fd,
bitrate_switch,
error_state_indicator,
) = msg_type
self.mock_pcan.Write = Mock(return_value=PCAN_ERROR_OK)
self.bus = can.Bus(bustype="pcan")
msg = can.Message(
arbitration_id=0xC0FFEF,
data=[1, 2, 3, 4, 5, 6, 7, 8],
is_extended_id=is_extended_id,
is_remote_frame=is_remote_frame,
is_error_frame=is_error_frame,
bitrate_switch=bitrate_switch,
error_state_indicator=error_state_indicator,
is_fd=is_fd,
)
self.bus.send(msg)
# self.mock_m_objPCANBasic.Write.assert_called_once()
CANMsg = self.mock_pcan.Write.call_args_list[0][0][1]
self.assertEqual(CANMsg.MSGTYPE, expected_value.value)
def sendMessage(self, message, argument):
encoder = SDOEncoder()
msg = encoder.encode_sdo(message, argument)
if self._bus == None:
return
if self._bus.interface == 'socketcan':
if not self._writeHandle:
try:
self._writeHandle = can.Bus(bustype=self._bus.interface,
channel=self._bus.channel)
except Exception as e:
print("Problem setting bus")
raise e
elif self._bus.interface == 'kvaser':
if not self._writeHandle:
try:
self._writeHandle = can.interface.Bus(bustype='kvaser',
channel=0,
bitrate=250000)
except Exception as e:
print("Problem setting bus")
raise e
else:
print("Nobus, sending message " + msg.__str__())
return
try:
self._writeHandle.send(
can.Message(arbitration_id=msg.id,
data=msg.data,
extended_id=False))
except Exception as e:
print("Problem sending command")
raise e
def main(args):
"""Send some messages to itself and apply filtering."""
with can.Bus(bustype='socketcan', channel='can0', bitrate=500000, receive_own_messages=False) as bus:
can_filters = [{"can_id": 0x14ff0331, "can_mask": 0xF, "extended": True}]
bus.set_filters(can_filters)
# set to read-only, only supported on some interfaces
#bus.state = BusState.PASSIVE
# print all incoming messages, wich includes the ones sent,
# since we set receive_own_messages to True
# assign to some variable so it does not garbage collected
#notifier = can.Notifier(bus, [can.Printer()]) # pylint: disable=unused-variable
notifier = can.Notifier(bus, [can.Logger("logfile.asc"), can.Printer()]) #can.Logger("recorded.log")
#bus.send(can.Message(arbitration_id=1, is_extended_id=True))
#bus.send(can.Message(arbitration_id=2, is_extended_id=True))
#bus.send(can.Message(arbitration_id=1, is_extended_id=False))
try:
while True:
#msg = bus.recv(1)
#if msg is not None:
# print(msg)
time.sleep(1.0)
except KeyboardInterrupt:
logging.debug(f"KeyboardInterrupt")
except Exception as e:
logging.debug(f"other exception")
def test_transmit(self):
bus = can.Bus(channel=0, bustype="cantact", _testing=True)
msg = can.Message(arbitration_id=0xC0FFEF,
data=[1, 2, 3, 4, 5, 6, 7, 8],
is_extended_id=True)
bus.send(msg)
cantact.MockInterface.send.assert_called()
def setUp(self):
rospy.init_node('test_interface', anonymous=True)
# Message received
self.messages = []
self.interface_up = False
# Create a bus can
can.rc['interface'] = 'socketcan_ctypes'
self.bus = can.Bus("vcan0")
self.input_sub = rospy.Subscriber("/can_interface/in", CanData,
self.message_received)
self.output_pub = rospy.Publisher("/can_interface/out",
CanData,
queue_size=10)
self.devices = DeviceList.parse_file("can/devices.xml",
"interface_description")
self.frames = FrameList.parse_file("can/frames.xml",
"interface_description",
context={"devices": self.devices})
# Wait for a connection
poll_rate = rospy.Rate(100)
while self.output_pub.get_num_connections(
) == 0 and not rospy.is_shutdown():
poll_rate.sleep()
async def main():
"""The main function that runs in the loop."""
bus = can.Bus("vcan0", bustype="virtual", receive_own_messages=True)
reader = can.AsyncBufferedReader()
logger = can.Logger("logfile.asc")
listeners = [
print_message, # Callback function
reader, # AsyncBufferedReader() listener
logger, # Regular Listener object
]
# Create Notifier with an explicit loop to use for scheduling of callbacks
loop = asyncio.get_event_loop()
notifier = can.Notifier(bus, listeners, loop=loop)
# Start sending first message
bus.send(can.Message(arbitration_id=0))
print("Bouncing 10 messages...")
for _ in range(10):
# Wait for next message from AsyncBufferedReader
msg = await reader.get_message()
# Delay response
await asyncio.sleep(0.5)
msg.arbitration_id += 1
bus.send(msg)
# Wait for last message to arrive
await reader.get_message()
print("Done!")
# Clean-up
notifier.stop()
bus.shutdown()
def setUpClass(cls):
channel = guess_channel(bustype_hint=bustype)
can_bus: can.Bus = can.Bus(bustype=bustype, channel=channel)
iface: IFace = CAN(can_bus)
cls.tm = Tinymovr(node_id=1, iface=iface)
cls.tm.reset()
time.sleep(0.2)
def test_message_direction(self):
# Verify that own message received has is_rx set to False while message
# received on the other virtual interfaces have is_rx set to True
if self.INTERFACE_1 != "virtual":
raise unittest.SkipTest(
"Message direction not yet implemented for socketcan")
bus3 = can.Bus(
channel=self.CHANNEL_2,
bustype=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
receive_own_messages=True,
)
try:
msg = can.Message(is_extended_id=False,
arbitration_id=0x300,
data=[2, 1, 3])
bus3.send(msg)
recv_msg_bus1 = self.bus1.recv(self.TIMEOUT)
recv_msg_bus2 = self.bus2.recv(self.TIMEOUT)
self_recv_msg_bus3 = bus3.recv(self.TIMEOUT)
self.assertTrue(recv_msg_bus1.is_rx)
self.assertTrue(recv_msg_bus2.is_rx)
self.assertFalse(self_recv_msg_bus3.is_rx)
finally:
bus3.shutdown()
def test_bus_creation_bitrate(self) -> None:
self.bus = can.Bus(channel=0,
bustype="vector",
bitrate=200000,
_testing=True)
self.assertIsInstance(self.bus, canlib.VectorBus)
can.interfaces.vector.canlib.xldriver.xlOpenDriver.assert_called()
can.interfaces.vector.canlib.xldriver.xlGetApplConfig.assert_called()
can.interfaces.vector.canlib.xldriver.xlOpenPort.assert_called()
xlOpenPort_args = can.interfaces.vector.canlib.xldriver.xlOpenPort.call_args[
0]
self.assertEqual(
xlOpenPort_args[5],
xldefine.XL_InterfaceVersion.XL_INTERFACE_VERSION.value)
self.assertEqual(xlOpenPort_args[6],
xldefine.XL_BusTypes.XL_BUS_TYPE_CAN.value)
can.interfaces.vector.canlib.xldriver.xlCanFdSetConfiguration.assert_not_called(
)
can.interfaces.vector.canlib.xldriver.xlCanSetChannelBitrate.assert_called(
)
xlCanSetChannelBitrate_args = (can.interfaces.vector.canlib.xldriver.
xlCanSetChannelBitrate.call_args[0])
self.assertEqual(xlCanSetChannelBitrate_args[2], 200000)
def __init__(self,
port,
datarate=1000000,
hostID=2,
moduleID=1,
debug=False):
if type(port) != str:
raise TypeError
if not port in _CHANNELS:
raise ValueError("Invalid port")
tmcl_interface.__init__(self, hostID, moduleID, debug)
self.__debug = debug
self.__channel = port
self.__bitrate = datarate
try:
self.__connection = can.Bus(interface="pcan",
channel=self.__channel,
bitrate=self.__bitrate)
self.__connection.set_filters([{
"can_id": hostID,
"can_mask": 0xFFFFFFFF
}])
except PcanError as e:
self.__connection = None
raise ConnectionError("Failed to connect to PCAN bus") from e
if self.__debug:
print("Opened bus on channel " + self.__channel)
def test_unique_message_instances(self):
"""Verify that we have a different instances of message for each bus even with
`receive_own_messages=True`.
"""
bus3 = can.Bus(
channel=self.CHANNEL_2,
bustype=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True,
receive_own_messages=True,
)
try:
msg = can.Message(is_extended_id=False,
arbitration_id=0x300,
data=[2, 1, 3])
bus3.send(msg)
recv_msg_bus1 = self.bus1.recv(self.TIMEOUT)
recv_msg_bus2 = self.bus2.recv(self.TIMEOUT)
self_recv_msg_bus3 = bus3.recv(self.TIMEOUT)
self._check_received_message(recv_msg_bus1, recv_msg_bus2)
self._check_received_message(recv_msg_bus2, self_recv_msg_bus3)
recv_msg_bus1.data[0] = 4
self.assertNotEqual(recv_msg_bus1.data, recv_msg_bus2.data)
self.assertEqual(recv_msg_bus2.data, self_recv_msg_bus3.data)
finally:
bus3.shutdown()
def __init__(self,
comPort,
datarate=1000000,
hostID=2,
moduleID=1,
debug=True,
SerialBaudrate=115200):
if type(comPort) != str:
raise TypeError
tmcl_interface.__init__(self, hostID, moduleID, debug)
self.__debug = debug
self.__bitrate = datarate
self.__Port = comPort
self.__serialBaudrate = SerialBaudrate
try:
self.__connection = can.Bus(interface='slcan',
channel=self.__Port,
bitrate=self.__bitrate,
ttyBaudrate=self.__serialBaudrate)
self.__connection.set_filters([{
"can_id": hostID,
"can_mask": 0x7F
}])
except CanError as e:
self.__connection = None
raise ConnectionError("Failed to connect to CAN bus") from e
if self.__debug:
print("Opened slcan bus on channel " + self.__Port)
def test_set_timer_rate(self) -> None:
canlib.xldriver.xlSetTimerRate = Mock()
bus: canlib.VectorBus = can.Bus(
channel=0, bustype="vector", fd=True, _testing=True
)
bus.set_timer_rate(timer_rate_ms=1)
assert canlib.xldriver.xlSetTimerRate.called
def parse_net(net):
global default_net
if net == 'default':
net = default_net
else:
net = CAN_INTERFACES[int(net) - 1]
return can.Bus(net, bustype="socketcan")
def test_get_device_number(self, name, status, expected_result) -> None:
self.mock_pcan.GetValue = Mock(return_value=(status, 1))
self.bus = can.Bus(bustype="pcan", fd=True)
self.assertEqual(self.bus.get_device_number(), expected_result)
self.mock_pcan.GetValue.assert_called_once_with(
PCAN_USBBUS1, PCAN_DEVICE_NUMBER
)
def send_message(self, data):
bus = can.Bus(channel='0', bustype="kvaser", bitrate=500000)
# print(data)
for i in range(0, len(data)):
Data = self.pos2message(int(data[i]))
# set position value
msg = can.Message(arbitration_id=0x421 + i,
data=[
0x3F, 0x00,
int(Data[0:2], 16),
int(Data[2:4], 16),
int(Data[4:6], 16),
int(Data[6:8], 16)
],
is_extended_id=False)
bus.send(msg)
time.sleep(0.01)
# toggle new position
msg = can.Message(arbitration_id=0x421 + i,
data=[0x0F, 0x00, 0x00, 0x00, 0x00, 0x00],
is_extended_id=False)
bus.send(msg)
bus.shutdown()
return
def read_input():
bus = can.Bus(channel='0', bustype="kvaser", bitrate=500000)
RX_PDO = 0x1A1
pot_ratio = {1: 0.0415, 2: 0.0412, 3: 0.0418, 4: 0.0447, 5: 0.0413,
6: 0.0413} # ratio for converting current to position in meter for each potentiometer, identified manually
home_pos = np.array(
[61.59, 44.99, 66.84, 82.9, 73.8, 54.72]) # home position of motors in mm, identified manually
motor_pos = np.zeros((6,), dtype=float) # initializing an array containing motors' positions
msg = bus.recv()
while np.count_nonzero(motor_pos) != 6:
msg = bus.recv()
id = msg.arbitration_id - RX_PDO
motor_pos[id - 1] = float(pot_ratio[id] * int.from_bytes(msg.data, byteorder='little',
signed=False)) # convert received message into float and put it in its place in home_pos array
# disable motor if it is homed
if abs(home_pos[id - 1] - motor_pos[id - 1]) < 0.5:
msg = can.Message(arbitration_id=0x221 + id,
data=[0x00, 0x00],
is_extended_id=False)
bus.send(msg)
error = home_pos - motor_pos
bus.shutdown()
return error
def test_receive_fd(self) -> None:
can.interfaces.vector.canlib.xldriver.xlCanReceive = Mock(
side_effect=xlCanReceive)
self.bus = can.Bus(channel=0, bustype="vector", fd=True, _testing=True)
self.bus.recv(timeout=0.05)
can.interfaces.vector.canlib.xldriver.xlReceive.assert_not_called()
can.interfaces.vector.canlib.xldriver.xlCanReceive.assert_called()
def setUp(self):
stdscr = StdscrDummy()
config = {"interface": "virtual", "receive_own_messages": True}
bus = can.Bus(**config)
data_structs = None
patch_curs_set = patch("curses.curs_set")
patch_curs_set.start()
self.addCleanup(patch_curs_set.stop)
patch_use_default_colors = patch("curses.use_default_colors")
patch_use_default_colors.start()
self.addCleanup(patch_use_default_colors.stop)
patch_init_pair = patch("curses.init_pair")
patch_init_pair.start()
self.addCleanup(patch_init_pair.stop)
patch_color_pair = patch("curses.color_pair")
patch_color_pair.start()
self.addCleanup(patch_color_pair.stop)
patch_is_term_resized = patch("curses.is_term_resized")
mock_is_term_resized = patch_is_term_resized.start()
mock_is_term_resized.return_value = True if random.random(
) < 0.5 else False
self.addCleanup(patch_is_term_resized.stop)
if hasattr(curses, "resizeterm"):
patch_resizeterm = patch("curses.resizeterm")
patch_resizeterm.start()
self.addCleanup(patch_resizeterm.stop)
self.can_viewer = CanViewer(stdscr, bus, data_structs, testing=True)
def test_shutdown(self) -> None:
self.bus = can.Bus(channel=0, bustype="vector", _testing=True)
self.bus.shutdown()
can.interfaces.vector.canlib.xldriver.xlDeactivateChannel.assert_called(
)
can.interfaces.vector.canlib.xldriver.xlClosePort.assert_called()
can.interfaces.vector.canlib.xldriver.xlCloseDriver.assert_called()
