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()