def _test_receive_extended_29bits(self): self.wait_socket_ready() addr = isotp.Address(isotp.AddressingMode.Extended_29bits, txid=self.stack_txid, rxid=self.stack_rxid, source_address=0x99, target_address=0x88) self.stack.set_address(addr) frame = self.process_stack_receive() self.assertEqual(frame, b'a'*100)
def _test_transmit_extended_29bits(self): self.wait_socket_ready() addr = isotp.Address(isotp.AddressingMode.Extended_29bits, txid=self.stack_txid, rxid=self.stack_rxid, source_address=0x99, target_address=0x88) self.stack.set_address(addr) self.stack.send(b'b'*100) self.process_stack_send()
import isotp s = isotp.socket(timeout=10) s2 = isotp.socket(timeout=10) s.set_fc_opts(stmin=5, bs=10) try: while True: s.bind("can1", isotp.Address(rxid=0x789, txid=0x56)) s2.bind("can1", isotp.Address(rxid=0x56, txid=0x789)) print(s.recv()) except KeyboardInterrupt: print('\n\rKeyboard interrtupt')
import isotp import socket # Create the ISOTP socket to act as Car s = isotp.socket() s.bind("vcan0", isotp.Address(rxid=0x7DF, txid=0x7E8)) # Respond to requests as if you where a Car. while (True): request = s.recv() if (request): if (request == b"\x03"): # DTCs s.send(b"\x00\x11\x22\xDE\xAD\xBE\xEF\xAA\xBB\xCC\xDD\xEE\xFF") if (request == b"\x01\x0C"): # RPM s.send(b"\x01\x0C\x0F\x0F") if (request == b"\x01\x00"): # PIDS s.send(b"\x01\x00\xFF\xFF\xFF\xFF") if (request == b"\x01\x0D"): # SPEED s.send(b"\x01\x0D\x00")
def test_11bits_extended_through_layer(self): functional = isotp.TargetAddressType.Functional physical = isotp.TargetAddressType.Physical txid = 0x123 rxid = 0x456 sa = 0x55 ta = 0xAA address = isotp.Address(isotp.AddressingMode.Extended_11bits, txid=txid, rxid=rxid, source_address=sa, target_address=ta) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address, params={'stmin':0, 'blocksize':0}) # Receive Single frame - Physical / Functional self.simulate_rx_msg(Message(arbitration_id = rxid, data=bytearray([sa, 0x03, 0x01, 0x02, 0x03]), extended_id=False)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03') # Receive multiframe - Physical layer.reset() self.simulate_rx_msg(Message(arbitration_id = rxid, data=bytearray([sa, 0x10, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05]), extended_id=False)) layer.process() self.assert_sent_flow_control(prefix=[ta], stmin=0, blocksize=0) self.simulate_rx_msg(Message(arbitration_id = rxid, data=bytearray([sa, 0x21, 0x06, 0x07, 0x08]), extended_id=False)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03\x04\x05\x06\x07\x08') #Transmit single frame - Physical layer.reset() layer.send(b'\x04\x05\x06', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([ta, 0x03, 0x04, 0x05, 0x06])) self.assertFalse(msg.is_extended_id) #Transmit single frame - Functional layer.reset() layer.send(b'\x04\x05\x06', functional) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([ta, 0x03, 0x04, 0x05, 0x06])) self.assertFalse(msg.is_extended_id) #Transmit single frame - Functional; txdl=32 layer.reset() layer.params.set('tx_data_length', 32) layer.send(b'\x55' * 29, functional) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([ta, 0x00, 29] + [0x55]*29)) self.assertFalse(msg.is_extended_id) #Transmit single frame - Functional; txdl=32 with self.assertRaises(ValueError): layer.reset() layer.params.set('tx_data_length', 32) layer.send(b'\x55' * 30, functional) layer.params.set('tx_data_length', 8) # Transmit multiframe - Physical layer.reset() layer.send(b'\x04\x05\x06\x07\x08\x09\x0A\x0B', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([ta, 0x10, 0x08, 0x04, 0x05, 0x06, 0x07, 0x08])) self.assertFalse(msg.is_extended_id) self.simulate_rx_msg(Message(arbitration_id=rxid, data=self.make_flow_control_data(flow_status=0, stmin=0, blocksize=0, prefix=[sa]), extended_id=False)) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([ta, 0x21, 0x09, 0x0A, 0x0B])) self.assertFalse(msg.is_extended_id)
s3 = isotp.socket() s4 = isotp.socket() s3.set_fc_opts(stmin=5, bs=10) s5 = isotp.socket() s6 = isotp.socket() s6.set_fc_opts(stmin=5, bs=10) print('Ready') #time1 = [] count = 0 try: while True: count += 1 s.bind("can1", isotp.Address(rxid=0x123, txid=0x45)) s2.bind("can1", isotp.Address(rxid=0x45, txid=0x123)) if s.recv() == b'start': start = time.time() continue s5.bind("can0", isotp.Address(rxid=0x123, txid=0x47)) s6.bind("can0", isotp.Address(rxid=0x47, txid=0x123)) if s5.recv() == b'end': end = time.time() break s3.bind("can0", isotp.Address(rxid=0x123, txid=0x46)) s4.bind("can0", isotp.Address(rxid=0x46, txid=0x123)) print(" The received message is :", s3.recv()) #print(' {}\n'.format(c+s)) except KeyboardInterrupt:
def test_29bits_mixed(self): ta = 0x55 sa = 0xAA ae = 0x99 rxid_physical = 0x18CEAA55 rxid_functional = 0x18CDAA55 txid_physical = 0x18CE55AA txid_functional = 0x18CD55AA address = isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=sa, target_address=ta, address_extension=ae) self.assertFalse( address.is_for_me(Message(rxid_physical, extended_id=True))) # No data self.assertFalse( address.is_for_me(Message(rxid_functional, extended_id=True))) # No data self.assertFalse( address.is_for_me(Message(txid_physical, extended_id=True))) # No data self.assertFalse( address.is_for_me(Message(txid_functional, extended_id=True))) # No data self.assertTrue( address.is_for_me( Message(rxid_physical, data=bytearray([ae]), extended_id=True))) self.assertFalse( address.is_for_me( Message(rxid_physical, data=bytearray([ae]), extended_id=False))) self.assertTrue( address.is_for_me( Message(rxid_functional, data=bytearray([ae]), extended_id=True))) self.assertFalse( address.is_for_me( Message(rxid_functional, data=bytearray([ae]), extended_id=False))) self.assertFalse( address.is_for_me( Message(txid_physical, data=bytearray([ae]), extended_id=True))) self.assertFalse( address.is_for_me( Message(txid_functional, data=bytearray([ae]), extended_id=True))) self.assertEqual( address.get_tx_arbitraton_id(isotp.TargetAddressType.Physical), txid_physical) self.assertEqual( address.get_tx_arbitraton_id(isotp.TargetAddressType.Functional), txid_functional) self.assertEqual( address.get_rx_arbitraton_id(isotp.TargetAddressType.Physical), rxid_physical) self.assertEqual( address.get_rx_arbitraton_id(isotp.TargetAddressType.Functional), rxid_functional)
def create_socket(rxid, txid): socket = isotp.socket() socket.set_opts(socket.flags.LISTEN_MODE) socket.bind(CAN_INTERFACE, isotp.Address(rxid=rxid, txid=txid)) return socket
def test_29bits_normal_through_layer(self): functional = isotp.TargetAddressType.Functional physical = isotp.TargetAddressType.Physical rxid = 0x123456 txid = 0x789ABC address = isotp.Address(isotp.AddressingMode.Normal_29bits, txid=txid, rxid=rxid) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address, params={ 'stmin': 0, 'blocksize': 0 }) # Receive Single frame - Physical self.simulate_rx_msg( Message(arbitration_id=rxid, data=bytearray([0x03, 0x01, 0x02, 0x03]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03') # Receive Single frame - Functional layer.reset() self.simulate_rx_msg( Message(arbitration_id=rxid, data=bytearray([0x03, 0x01, 0x02, 0x03]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03') # Receive multiframe - Physical layer.reset() self.simulate_rx_msg( Message(arbitration_id=rxid, data=bytearray( [0x10, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06]), extended_id=True)) layer.process() self.assert_sent_flow_control(stmin=0, blocksize=0) self.simulate_rx_msg( Message(arbitration_id=rxid, data=bytearray([0x21, 0x07, 0x08]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03\x04\x05\x06\x07\x08') #Transmit single frame - Physical / Functional layer.reset() layer.send(b'\x04\x05\x06', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([0x03, 0x04, 0x05, 0x06])) self.assertTrue(msg.is_extended_id) # Transmit multiframe - Physical layer.reset() layer.send(b'\x04\x05\x06\x07\x08\x09\x0A\x0B', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual( msg.data, bytearray([0x10, 0x08, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09])) self.assertTrue(msg.is_extended_id) self.simulate_rx_msg( Message(arbitration_id=rxid, data=self.make_flow_control_data(flow_status=0, stmin=0, blocksize=0), extended_id=True)) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid) self.assertEqual(msg.data, bytearray([0x21, 0x0A, 0x0B])) self.assertTrue(msg.is_extended_id)
def test_single_frame_only_function_tatype(self): tatype = isotp.TargetAddressType.Functional address = isotp.Address(isotp.AddressingMode.Normal_11bits, txid=1, rxid=2) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(7), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(8), tatype) address = isotp.Address(isotp.AddressingMode.Normal_29bits, txid=1, rxid=2) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(7), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(8), tatype) address = isotp.Address(isotp.AddressingMode.NormalFixed_29bits, source_address=1, target_address=2) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(7), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(8), tatype) address = isotp.Address(isotp.AddressingMode.Extended_11bits, txid=1, rxid=2, target_address=3) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(6), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(7), tatype) address = isotp.Address(isotp.AddressingMode.Extended_29bits, txid=1, rxid=2, target_address=3) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(6), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(7), tatype) address = isotp.Address(isotp.AddressingMode.Mixed_11bits, txid=1, rxid=2, address_extension=3) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(6), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(7), tatype) address = isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=1, target_address=2, address_extension=3) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address) layer.send(self.make_payload(6), tatype) with self.assertRaises(ValueError): layer.send(self.make_payload(7), tatype)
def find_services( self, skip_response_only_service_ids=False, scan_only_known_uds_services=True, payload_extra_byte=b'\x00', add_extra_payload_byte=False, ): list_of_known_uds_services = [ 0x10, 0x11, 0x27, 0x28, 0x3E, 0x83, 0x84, 0x85, 0x86, 0x87, 0x22, 0x23, 0x24, 0x2A, 0x2C, 0x2E, 0x3D, 0x14, 0x19, 0x2F, 0x34, 0x35, 0x36, 0x37 ] if self._diagnostic_services_scan_complete: return self.diagnostic_services import isotp import time isotp_socket = isotp.socket() isotp_socket.set_opts(txpad=0x00, rxpad=0x00) address = isotp.Address(0, rxid=self.response_id, txid=self.physical_request_id) isotp_socket.bind(self.socket_can_interface, address) if not (0 <= self.start_service_id <= 0xFF): self.start_service_id = 0 if not (0 <= self.end_service_id <= 0xFF): self.end_service_id = 0xFF self.end_service_id = self.end_service_id & 0xFF self.start_service_id = self.start_service_id & 0xFF if self.end_service_id > self.start_service_id: increment_direction = 1 else: increment_direction = -1 for service_id in range(self.start_service_id, self.end_service_id, increment_direction): if skip_response_only_service_ids and ( 0x3E < service_id < 0x4F or 0x7E < service_id < 0x83 or 0xBE < service_id < 0xFF): continue if scan_only_known_uds_services and not ( service_id in list_of_known_uds_services): continue payload = service_id # fix to correct for the payload length if payload >= 0x10: payload_length = (len(hex(payload)) - 2) >> 1 else: payload_length = 1 payload_bytes = payload.to_bytes(payload_length, 'big') if add_extra_payload_byte: payload_bytes += b'\x00' # Some services only work with Extra Data isotp_socket.send(payload_bytes + payload_extra_byte) recv = isotp_socket.recv() current_time = time.time() while recv is None: loop_time = time.time() recv = isotp_socket.recv() if current_time + self.can_scan_timeout < loop_time: break if recv is not None: response_service_id = recv[0] if response_service_id == 0x7F: nrc = recv[2] '''if nrc == 0x7F or nrc == 0x80: isotp_socket.send(b'\x10' + self.enhanced_mode_session_byte) recv = isotp_socket.recv() time.sleep(0.1) isotp_socket.send(b_payload + (payload_extra_byte if add_extra_payload_byte else b'')) continue''' if nrc == 0x11: self.unsupported_service.add(service_id) else: self.supported_services.add(service_id) else: self.supported_services.add(service_id) self.diagnostic_services = self.supported_services self._diagnostic_services_scan_complete = True return self.supported_services
2, # Not specified in standard. 2 bytes matches other services format. 'server_address_format': None, # 8,16,24,32,40 'server_memorysize_format': None, # 8,16,24,32,40 'data_identifiers': { 0x0200: MyCustomCodecThatShiftBy4, 0xD500: MyCustomCodecHex, 0xFE01: MyCustomCodecHex, 0xDF00: MyCustomCodecHex, 0xd472: MyCustomCodecHex }, 'input_output': {} } bus = VectorBus(channel=1, bitrate=500000) # Link Layer (CAN protocol) tp_addr = isotp.Address(isotp.AddressingMode.Normal_11bits, txid=0x7e1, rxid=0x782) # Network layer addressing scheme stack = isotp.CanStack( bus=bus, address=tp_addr, params=isotp_params) # Network/Transport layer (IsoTP protocol) conn = PythonIsoTpConnection( stack) # interface between Application and Transport layer with Client( conn, request_timeout=1, config=client_config) as client: # Application layer (UDS protocol) client.change_session(3) response = client.request_seed(1) #client.send_key(2, b'0001') response = client.read_data_by_identifier(0x0200) print(response) client.clear_dtc(0xffffff)
def setUp(self): self.vcan0_bus = self.make_bus() addr = isotp.Address(isotp.AddressingMode.Normal_11bits, rxid=self.stack_rxid, txid=self.stack_txid) self.conn = PythonIsoTpConnection(isotp.CanStack(bus=self.vcan0_bus, address=addr), name='unittest') self.conn.open()
def _test_receive_mixed_29bits(self): self.wait_socket_ready() addr = isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=0x99, target_address=0x88, address_extension=0xDD) self.stack.set_address(addr) frame = self.process_stack_receive() self.assertEqual(frame, b'c'*100)
def create_isotp_socket(receiver_address, target_address): socket = isotp.socket() socket.bind(CAN_INTERFACE, isotp.Address(rxid=receiver_address, txid=target_address)) return socket
def _test_transmit_mixed_29bits(self): self.wait_socket_ready() addr = isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=0x99, target_address=0x88, address_extension=0xEE) self.stack.set_address(addr) self.stack.send(b'd'*100) self.process_stack_send()
################################################################ ################################################################ #initialize CAN ISOTP ################################################################ #CAN ISOTP is a higher level protocol used to transfer larger amounts of data than the base CAN allows #this creates its own separate socket to the CAN bus on the same single wire can interface from the #other standard can messaging that occurs in this script SWCAN_ISOTP = isotp.socket() #default recv timeout is 0.1 seconds SWCAN_ISOTP.set_fc_opts( stmin=5, bs=10 ) #see https://can-isotp.readthedocs.io/en/latest/isotp/socket.html#socket.set_fc_opts SWCAN_ISOTP.bind(SWCANname, isotp.Address(rxid=1997, txid=1996)) class ReceiveInvoices(threading.Thread): #this class holds the InvoiceQueue object, receives invoices, operates in another thread in daemon mode, and will shutdown if the .stop() method is used. #not sure if the socket should be opened and closed from within here or not. to be re-visited at a later time. #not sure if socket needs to be re-created every time SWCAN comes up. #see also: # https://stackoverflow.com/questions/47912701/python-how-can-i-implement-a-stoppable-thread # https://stackoverflow.com/questions/40382332/example-usages-of-the-stoppablethread-subclass-of-pythons-threading-thread # https://github.com/python/cpython/blob/2.7/Lib/threading.py#L743 # https://stackoverflow.com/questions/27102881/python-threading-self-stop-event-object-is-not-callable def __init__(self, *args, **kwargs): super(ReceiveInvoices, self).__init__(*args, **kwargs) self._stop_event = threading.Event()
def test_29bits_mixed_through_layer(self): functional = isotp.TargetAddressType.Functional physical = isotp.TargetAddressType.Physical ta = 0x55 sa = 0xAA ae = 0x99 rxid_physical = 0x18CEAA55 rxid_functional = 0x18CDAA55 txid_physical = 0x18CE55AA txid_functional = 0x18CD55AA address = isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=sa, target_address=ta, address_extension=ae) layer = isotp.TransportLayer(txfn=self.stack_txfn, rxfn=self.stack_rxfn, address=address, params={ 'stmin': 0, 'blocksize': 0 }) # Receive Single frame - Physical self.simulate_rx_msg( Message(arbitration_id=rxid_physical, data=bytearray([ae, 0x03, 0x01, 0x02, 0x03]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03') # Receive Single frame - Functional layer.reset() self.simulate_rx_msg( Message(arbitration_id=rxid_functional, data=bytearray([ae, 0x03, 0x01, 0x02, 0x03]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03') # Receive multiframe - Physical layer.reset() self.simulate_rx_msg( Message(arbitration_id=rxid_physical, data=bytearray( [ae, 0x10, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05]), extended_id=True)) layer.process() self.assert_sent_flow_control(prefix=[ae], stmin=0, blocksize=0) self.simulate_rx_msg( Message(arbitration_id=rxid_physical, data=bytearray([ae, 0x21, 0x06, 0x07, 0x08]), extended_id=True)) layer.process() frame = layer.recv() self.assertIsNotNone(frame) self.assertEqual(frame, b'\x01\x02\x03\x04\x05\x06\x07\x08') #Transmit single frame - Physical layer.reset() layer.send(b'\x04\x05\x06', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid_physical) self.assertEqual(msg.data, bytearray([ae, 0x03, 0x04, 0x05, 0x06])) self.assertTrue(msg.is_extended_id) #Transmit single frame - Functional layer.reset() layer.send(b'\x04\x05\x06', functional) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid_functional) self.assertEqual(msg.data, bytearray([ae, 0x03, 0x04, 0x05, 0x06])) self.assertTrue(msg.is_extended_id) # Transmit multiframe - Physical layer.reset() layer.send(b'\x04\x05\x06\x07\x08\x09\x0A\x0B', physical) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid_physical) self.assertEqual( msg.data, bytearray([ae, 0x10, 0x08, 0x04, 0x05, 0x06, 0x07, 0x08])) self.assertTrue(msg.is_extended_id) self.simulate_rx_msg( Message(arbitration_id=rxid_physical, data=self.make_flow_control_data(flow_status=0, stmin=0, blocksize=0, prefix=[ae]), extended_id=True)) layer.process() msg = self.get_tx_can_msg() self.assertIsNotNone(msg) self.assertEqual(msg.arbitration_id, txid_physical) self.assertEqual(msg.data, bytearray([ae, 0x21, 0x09, 0x0A, 0x0B])) self.assertTrue(msg.is_extended_id)
import isotp from Crypto.Cipher import DES3 s = isotp.socket() s2 = isotp.socket() # Configuring the sockets. s.set_fc_opts(stmin=5, bs=10) #s.set_general_opts(...) #s.set_ll_opts(...) text = b'varun123' key = "sixteen byte key" print("The Triple DES key value :", key) cipher = DES3.new(key, DES3.MODE_ECB) encrypted_data = cipher.encrypt(text) s.bind("can0", isotp.Address(rxid=0x123, txid=0x45)) s2.bind("can0", isotp.Address(rxid=0x45, txid=0x123)) s2.send(encrypted_data) print(s.recv())