From 9102c16118171597abf6cb7b9dee99b557f7eee7 Mon Sep 17 00:00:00 2001 From: Adeeb Shihadeh Date: Sun, 31 May 2020 14:07:01 -0700 Subject: [PATCH] two spaces before inline comment --- examples/tesla_tester.py | 10 +- python/__init__.py | 2 +- python/uds.py | 16 +- tests/automated/6_wifi_udp.py | 2 +- tests/debug_console.py | 2 +- tests/development/register_hashmap_spread.py | 2 +- tests/elm_car_simulator.py | 34 +-- tests/elm_wifi.py | 222 +++++++++---------- tests/safety/common.py | 2 +- tests/safety/test_honda.py | 4 +- tests/safety/test_toyota.py | 2 +- tests/safety_replay/helpers.py | 2 +- tests/safety_replay/replay_drive.py | 2 +- tests/safety_replay/test_safety_replay.py | 22 +- 14 files changed, 162 insertions(+), 162 deletions(-) diff --git a/examples/tesla_tester.py b/examples/tesla_tester.py index 57079f5..d5b09e3 100644 --- a/examples/tesla_tester.py +++ b/examples/tesla_tester.py @@ -18,8 +18,8 @@ def tesla_tester(): print("WiFi connection timed out. Please make sure your Panda is connected and try again.") sys.exit(0) - body_bus_speed = 125 # Tesla Body busses (B, BF) are 125kbps, rest are 500kbps - body_bus_num = 1 # My TDC to OBD adapter has PT on bus0 BDY on bus1 and CH on bus2 + body_bus_speed = 125 # Tesla Body busses (B, BF) are 125kbps, rest are 500kbps + body_bus_num = 1 # My TDC to OBD adapter has PT on bus0 BDY on bus1 and CH on bus2 p.set_can_speed_kbps(body_bus_num, body_bus_speed) # Now set the panda from its default of SAFETY_SILENT (read only) to SAFETY_ALLOUTPUT @@ -47,9 +47,9 @@ def tesla_tester(): can_recv = p.can_recv() for address, _, dat, src in can_recv: if src == body_bus_num: - if address == 1384: #0x568 is VIN - vin_index = int(binascii.hexlify(dat)[:2]) #first byte is the index, 00, 01, 02 - vin_string = binascii.hexlify(dat)[2:] #rest of the string is the actual VIN data + if address == 1384: # 0x568 is VIN + vin_index = int(binascii.hexlify(dat)[:2]) # first byte is the index, 00, 01, 02 + vin_string = binascii.hexlify(dat)[2:] # rest of the string is the actual VIN data vin[vin_index] = vin_string.decode("hex") print("Got VIN index " + str(vin_index) + " data " + vin[vin_index]) #if we have all 3 parts of the VIN, print it and break out of our while loop diff --git a/python/__init__.py b/python/__init__.py index 2f70c87..e0b136a 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -200,7 +200,7 @@ class Panda(object): traceback.print_exc() if wait == False or self._handle != None: break - context = usb1.USBContext() #New context needed so new devices show up + context = usb1.USBContext() # New context needed so new devices show up assert(self._handle != None) print("connected") diff --git a/python/uds.py b/python/uds.py index 946afb7..d6c932d 100644 --- a/python/uds.py +++ b/python/uds.py @@ -328,7 +328,7 @@ class CanClient(): while True: yield self.rx_buff.popleft() except IndexError: - pass # empty + pass # empty def send(self, msgs: List[bytes], delay: float=0) -> None: for i, msg in enumerate(msgs): @@ -607,13 +607,13 @@ class UdsClient(): if response_event_type == RESPONSE_EVENT_TYPE.REPORT_ACTIVATED_EVENTS: return { "num_of_activated_events": resp[0], - "data": resp[1:], # TODO: parse the reset of response + "data": resp[1:], # TODO: parse the reset of response } return { "num_of_identified_events": resp[0], "event_window_time": resp[1], - "data": resp[2:], # TODO: parse the reset of response + "data": resp[2:], # TODO: parse the reset of response } def link_control(self, link_control_type: LINK_CONTROL_TYPE, baud_rate_type: BAUD_RATE_TYPE=None): @@ -661,7 +661,7 @@ class UdsClient(): resp_id = struct.unpack('!H', resp[0:2])[0] if len(resp) >= 2 else None if resp_id != data_identifier_type: raise ValueError('invalid response data identifier: {}'.format(hex(resp_id))) - return resp[2:] # TODO: parse the response + return resp[2:] # TODO: parse the response def read_data_by_periodic_identifier(self, transmission_mode_type: TRANSMISSION_MODE_TYPE, periodic_data_identifier: int): # TODO: support list of identifiers @@ -718,7 +718,7 @@ class UdsClient(): self._uds_request(SERVICE_TYPE.WRITE_MEMORY_BY_ADDRESS, subfunction=0x00, data=data) def clear_diagnostic_information(self, dtc_group_type: DTC_GROUP_TYPE): - data = struct.pack('!I', dtc_group_type)[1:] # 3 bytes + data = struct.pack('!I', dtc_group_type)[1:] # 3 bytes self._uds_request(SERVICE_TYPE.CLEAR_DIAGNOSTIC_INFORMATION, subfunction=None, data=data) def read_dtc_information(self, dtc_report_type: DTC_REPORT_TYPE, dtc_status_mask_type: DTC_STATUS_MASK_TYPE=DTC_STATUS_MASK_TYPE.ALL, dtc_severity_mask_type: DTC_SEVERITY_MASK_TYPE=DTC_SEVERITY_MASK_TYPE.ALL, dtc_mask_record: int=0xFFFFFF, dtc_snapshot_record_num: int=0xFF, dtc_extended_record_num: int=0xFF): @@ -737,7 +737,7 @@ class UdsClient(): dtc_report_type == DTC_REPORT_TYPE.DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \ dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \ dtc_report_type == DTC_REPORT_TYPE.SEVERITY_INFORMATION_OF_DTC: - data += struct.pack('!I', dtc_mask_record)[1:] # 3 bytes + data += struct.pack('!I', dtc_mask_record)[1:] # 3 bytes # dtc_snapshot_record_num if dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_IDENTIFICATION or \ dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \ @@ -796,7 +796,7 @@ class UdsClient(): else: raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len)) - return max_num_bytes # max number of bytes per transfer data request + return max_num_bytes # max number of bytes per transfer data request def request_upload(self, memory_address: int, memory_size: int, memory_address_bytes: int=4, memory_size_bytes: int=4, data_format: int=0x00): data = bytes([data_format]) @@ -821,7 +821,7 @@ class UdsClient(): else: raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len)) - return max_num_bytes # max number of bytes per transfer data request + return max_num_bytes # max number of bytes per transfer data request def transfer_data(self, block_sequence_count: int, data: bytes=b''): data = bytes([block_sequence_count]) + data diff --git a/tests/automated/6_wifi_udp.py b/tests/automated/6_wifi_udp.py index 197e4d4..5361ae5 100644 --- a/tests/automated/6_wifi_udp.py +++ b/tests/automated/6_wifi_udp.py @@ -41,7 +41,7 @@ def test_udp_doesnt_drop(serials=None): sys.stdout.flush() else: print("UDP WIFI loopback %d messages at speed %d, comp speed is %.2f, percent %.2f" % (msg_count, speed, comp_kbps, saturation_pct)) - assert_greater(saturation_pct, 20) #sometimes the wifi can be slow... + assert_greater(saturation_pct, 20) # sometimes the wifi can be slow... assert_less(saturation_pct, 100) saturation_pcts.append(saturation_pct) if len(saturation_pcts) > 0: diff --git a/tests/debug_console.py b/tests/debug_console.py index cf43b39..724e650 100755 --- a/tests/debug_console.py +++ b/tests/debug_console.py @@ -28,7 +28,7 @@ if __name__ == "__main__": if os.getenv("BAUD") is not None: for panda in pandas: - panda.set_uart_baud(port_number, int(os.getenv("BAUD"))) # type: ignore + panda.set_uart_baud(port_number, int(os.getenv("BAUD"))) # type: ignore while True: for i, panda in enumerate(pandas): diff --git a/tests/development/register_hashmap_spread.py b/tests/development/register_hashmap_spread.py index ba0a0eb..2894849 100755 --- a/tests/development/register_hashmap_spread.py +++ b/tests/development/register_hashmap_spread.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -import matplotlib.pyplot as plt # pylint: disable=import-error +import matplotlib.pyplot as plt # pylint: disable=import-error HASHING_PRIME = 23 REGISTER_MAP_SIZE = 0x3FF diff --git a/tests/elm_car_simulator.py b/tests/elm_car_simulator.py index c44def0..f9aba19 100755 --- a/tests/elm_car_simulator.py +++ b/tests/elm_car_simulator.py @@ -74,7 +74,7 @@ class ELMCarSimulator(): def __lin_monitor(self): print("STARTING LIN THREAD") self.panda.set_uart_baud(2, 10400) - self.panda.kline_drain() # Toss whatever was already there + self.panda.kline_drain() # Toss whatever was already there lin_buff = bytearray() @@ -85,7 +85,7 @@ class ELMCarSimulator(): lin_buff += lin_msg #print(" ** Buff", lin_buff) - if lin_buff.endswith(b'\x00\xc1\x33\xf1\x81\x66'): # Leading 0 is wakeup + if lin_buff.endswith(b'\x00\xc1\x33\xf1\x81\x66'): # Leading 0 is wakeup lin_buff = bytearray() self.__lin_active = True print("GOT LIN (KWP FAST) WAKEUP SIGNAL") @@ -100,7 +100,7 @@ class ELMCarSimulator(): continue if len(lin_buff) < msglen + 4: continue if lin_checksum(lin_buff[:-1]) != lin_buff[-1]: continue - self.__lin_process_msg(lin_buff[0] & 0xF8, #Priority + self.__lin_process_msg(lin_buff[0] & 0xF8, # Priority lin_buff[1], lin_buff[2], lin_buff[3:-1]) lin_buff = bytearray() @@ -168,7 +168,7 @@ class ELMCarSimulator(): def __can_monitor(self): print("STARTING CAN THREAD") self.panda.set_can_speed_kbps(0, self.__can_kbaud) - self.panda.can_recv() # Toss whatever was already there + self.panda.can_recv() # Toss whatever was already there while not self.__stop: for address, ts, data, src in self.panda.can_recv(): @@ -259,28 +259,28 @@ class ELMCarSimulator(): ######################### def _process_obd(self, mode, pid): - if mode == 0x01: # Mode: Show current data + if mode == 0x01: # Mode: Show current data if pid == 0x00: #List supported things - return b"\xff\xff\xff\xfe"#b"\xBE\x1F\xB8\x10" #Bitfield, random features - elif pid == 0x01: # Monitor Status since DTC cleared - return b"\x00\x00\x00\x00" #Bitfield, random features - elif pid == 0x04: # Calculated engine load + return b"\xff\xff\xff\xfe" # b"\xBE\x1F\xB8\x10" #Bitfield, random features + elif pid == 0x01: # Monitor Status since DTC cleared + return b"\x00\x00\x00\x00" # Bitfield, random features + elif pid == 0x04: # Calculated engine load return b"\x2f" - elif pid == 0x05: # Engine coolant temperature + elif pid == 0x05: # Engine coolant temperature return b"\x3c" - elif pid == 0x0B: # Intake manifold absolute pressure + elif pid == 0x0B: # Intake manifold absolute pressure return b"\x90" - elif pid == 0x0C: # Engine RPM + elif pid == 0x0C: # Engine RPM return b"\x1A\xF8" - elif pid == 0x0D: # Vehicle Speed + elif pid == 0x0D: # Vehicle Speed return b"\x53" - elif pid == 0x10: # MAF air flow rate + elif pid == 0x10: # MAF air flow rate return b"\x01\xA0" - elif pid == 0x11: # Throttle Position + elif pid == 0x11: # Throttle Position return b"\x90" - elif pid == 0x33: # Absolute Barometric Pressure + elif pid == 0x33: # Absolute Barometric Pressure return b"\x90" - elif mode == 0x09: # Mode: Request vehicle information + elif mode == 0x09: # Mode: Request vehicle information if pid == 0x02: # Show VIN return b"1D4GP00R55B123456" if pid == 0xFC: # test long multi message. Ligned up for LIN responses diff --git a/tests/elm_wifi.py b/tests/elm_wifi.py index b0645ea..6fad90d 100644 --- a/tests/elm_wifi.py +++ b/tests/elm_wifi.py @@ -35,7 +35,7 @@ def send_compare(s, dat, ret, timeout=4): break; res += s.recv(1000) #print("final recv data: '%s'" % repr(res)) - assert ret == res#, "Data does not agree (%s) (%s)"%(repr(ret), repr(res)) + assert ret == res # , "Data does not agree (%s) (%s)"%(repr(ret), repr(res)) def sync_reset(s): s.send("ATZ\r") @@ -63,7 +63,7 @@ def test_elm_cli(): #Test Echo Off #Expected to be misimplimentation, but this is how the reference device behaved. - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') #Here is the odd part + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Here is the odd part send_compare(s, b'ATE0\r', b'OK\r\r>') #Should prob show this immediately send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') @@ -73,17 +73,17 @@ def test_elm_cli(): send_compare(s, b'ATL0\r', b'OK\r\r>') send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') - send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') #Test repeat command no echo + send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') # Test repeat command no echo send_compare(s, b'\r', b'ELM327 v1.5\r\r>') - send_compare(s, b'aTi\r', b'ELM327 v1.5\r\r>') #Test different case + send_compare(s, b'aTi\r', b'ELM327 v1.5\r\r>') # Test different case - send_compare(s, b' a T i\r', b'ELM327 v1.5\r\r>') #Test with white space + send_compare(s, b' a T i\r', b'ELM327 v1.5\r\r>') # Test with white space - send_compare(s, b'ATCATHAT\r', b'?\r\r>') #Test Invalid AT command + send_compare(s, b'ATCATHAT\r', b'?\r\r>') # Test Invalid AT command - send_compare(s, b'01 00 00 00 00 00 00 00\r', b'?\r\r>') #Test Invalid (too long) OBD command - send_compare(s, b'01 GZ\r', b'?\r\r>') #Test Invalid (Non hex chars) OBD command + send_compare(s, b'01 00 00 00 00 00 00 00\r', b'?\r\r>') # Test Invalid (too long) OBD command + send_compare(s, b'01 GZ\r', b'?\r\r>') # Test Invalid (Non hex chars) OBD command finally: s.close() @@ -92,23 +92,23 @@ def test_elm_setget_protocol(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATSP0\r', b"OK\r\r>") # Set auto + send_compare(s, b'ATSP0\r', b"OK\r\r>") # Set auto send_compare(s, b'ATDP\r', b"AUTO\r\r>") send_compare(s, b'ATDPN\r', b"A0\r\r>") - send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set protocol + send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set protocol send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 11/500)\r\r>") send_compare(s, b'ATDPN\r', b"6\r\r>") - send_compare(s, b'ATSPA6\r', b"OK\r\r>") # Set auto with protocol default + send_compare(s, b'ATSPA6\r', b"OK\r\r>") # Set auto with protocol default send_compare(s, b'ATDP\r', b"AUTO, ISO 15765-4 (CAN 11/500)\r\r>") send_compare(s, b'ATDPN\r', b"A6\r\r>") send_compare(s, b'ATSP7\r', b"OK\r\r>") send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 29/500)\r\r>") - send_compare(s, b'ATDPN\r', b"7\r\r>") #Test Does not accept invalid protocols + send_compare(s, b'ATDPN\r', b"7\r\r>") # Test Does not accept invalid protocols send_compare(s, b'ATSPD\r', b"?\r\r>") send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 29/500)\r\r>") send_compare(s, b'ATDPN\r', b"7\r\r>") @@ -120,7 +120,7 @@ def test_elm_protocol_failure(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF send_compare(s, b'ATSP0\r', b"OK\r\r>") send_compare(s, b'0100\r', b"SEARCHING...\rUNABLE TO CONNECT\r\r>", timeout=10) @@ -166,13 +166,13 @@ def test_elm_protocol_failure(): def test_elm_protocol_autodetect_ISO14230_KWP_FAST(): s = elm_connect() serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None - sim = elm_car_simulator.ELMCarSimulator(serial, can=False)#, silent=True) + sim = elm_car_simulator.ELMCarSimulator(serial, can=False) # , silent=True) sim.start() try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers ON + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers ON send_compare(s, b'ATS0\r', b"OK\r\r>") send_compare(s, b'ATSP0\r', b"OK\r\r>") @@ -186,30 +186,30 @@ def test_elm_protocol_autodetect_ISO14230_KWP_FAST(): def test_elm_basic_send_lin(): s = elm_connect() serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None - sim = elm_car_simulator.ELMCarSimulator(serial, can=False)#, silent=True) + sim = elm_car_simulator.ELMCarSimulator(serial, can=False) # , silent=True) sim.start() try: sync_reset(s) - send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto + send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF send_compare(s, b'0100\r', b"BUS INIT: OK\r41 00 FF FF FF FE \r\r>") send_compare(s, b'010D\r', b"41 0D 53 \r\r>") - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>") send_compare(s, b'010D\r', b"410D53\r\r>") - send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On + send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On send_compare(s, b'0100\r', b"86F1104100FFFFFFFEC3\r\r>") send_compare(s, b'010D\r', b"83F110410D5325\r\r>") - send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On + send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On send_compare(s, b'0100\r', b"86 F1 10 41 00 FF FF FF FE C3 \r\r>") send_compare(s, b'010D\r', b"83 F1 10 41 0D 53 25 \r\r>") - send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response. + send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response. # Repeat last check to see if it still works after NO DATA was received send_compare(s, b'0100\r', b"86 F1 10 41 00 FF FF FF FE C3 \r\r>") @@ -227,10 +227,10 @@ def test_elm_send_lin_multiline_msg(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATSP5\r', b"OK\r\r>") # Set Proto + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATSP5\r', b"OK\r\r>") # Set Proto - send_compare(s, b'0902\r', # headers OFF, Spaces ON + send_compare(s, b'0902\r', # headers OFF, Spaces ON b"BUS INIT: OK\r" b"49 02 01 00 00 00 31 \r" b"49 02 02 44 34 47 50 \r" @@ -238,24 +238,24 @@ def test_elm_send_lin_multiline_msg(): b"49 02 04 35 42 31 32 \r" b"49 02 05 33 34 35 36 \r\r>") - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'0902\r', # Headers OFF, Spaces OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'0902\r', # Headers OFF, Spaces OFF b"49020100000031\r" b"49020244344750\r" b"49020330305235\r" b"49020435423132\r" b"49020533343536\r\r>") - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON - send_compare(s, b'0902\r', # Headers ON, Spaces OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'0902\r', # Headers ON, Spaces OFF b"87F1104902010000003105\r" b"87F11049020244344750E4\r" b"87F11049020330305235BD\r" b"87F11049020435423132B1\r" b"87F11049020533343536AA\r\r>") - send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON - send_compare(s, b'0902\r', # Headers ON, Spaces ON + send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON + send_compare(s, b'0902\r', # Headers ON, Spaces ON b"87 F1 10 49 02 01 00 00 00 31 05 \r" b"87 F1 10 49 02 02 44 34 47 50 E4 \r" b"87 F1 10 49 02 03 30 30 52 35 BD \r" @@ -274,12 +274,12 @@ def test_elm_send_lin_multiline_msg_throughput(): try: sync_reset(s) - send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF + send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF - send_compare(s, b'09fc\r', # headers OFF, Spaces OFF + send_compare(s, b'09fc\r', # headers OFF, Spaces OFF b"BUS INIT: OK\r" + b''.join((b'49FC' + hex(num+1)[2:].upper().zfill(2) + b'AAAA' + hex(num+1)[2:].upper().zfill(4) + b'\r' @@ -294,7 +294,7 @@ def test_elm_send_lin_multiline_msg_throughput(): def test_elm_panda_safety_mode_KWPFast(): serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None - p_car = Panda(serial) # Configure this so the messages will send + p_car = Panda(serial) # Configure this so the messages will send p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT) p_car.kline_drain() @@ -332,13 +332,13 @@ def test_elm_panda_safety_mode_KWPFast(): return False return timed_recv_check(p_car, bus, msgout) - assert not did_send(0xC0, 0x33, 0xF1, b'\x01\x0F', bus=3) #wrong bus - assert not did_send(0xC0, 0x33, 0xF1, b'') #wrong length - assert not did_send(0xB0, 0x33, 0xF1, b'\x01\x0E') #bad priority - assert not did_send(0xC0, 0x00, 0xF1, b'\x01\x0D') #bad addr - assert not did_send(0xC0, 0x33, 0x00, b'\x01\x0C') #bad addr + assert not did_send(0xC0, 0x33, 0xF1, b'\x01\x0F', bus=3) # wrong bus + assert not did_send(0xC0, 0x33, 0xF1, b'') # wrong length + assert not did_send(0xB0, 0x33, 0xF1, b'\x01\x0E') # bad priority + assert not did_send(0xC0, 0x00, 0xF1, b'\x01\x0D') # bad addr + assert not did_send(0xC0, 0x33, 0x00, b'\x01\x0C') # bad addr - assert did_send(0xC0, 0x33, 0xF1, b'\x01\x0B') #good! (obd func req) + assert did_send(0xC0, 0x33, 0xF1, b'\x01\x0B') # good! (obd func req) def test_elm_lin_keepalive(): s = elm_connect() @@ -348,17 +348,17 @@ def test_elm_lin_keepalive(): try: sync_reset(s) - send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF + send_compare(s, b'ATSP5\r', b"ATSP5\rOK\r\r>") # Set Proto + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF send_compare(s, b'0100\r', b"BUS INIT: OK\r4100FFFFFFFE\r\r>") assert sim.lin_active time.sleep(6) assert sim.lin_active - send_compare(s, b'ATPC\r', b"OK\r\r>") #STOP KEEPALIVE + send_compare(s, b'ATPC\r', b"OK\r\r>") # STOP KEEPALIVE assert sim.lin_active time.sleep(6) assert not sim.lin_active @@ -377,8 +377,8 @@ def test_elm_protocol_autodetect_ISO15765(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON send_compare(s, b'ATS0\r', b"OK\r\r>") sim.can_mode_11b() @@ -415,25 +415,25 @@ def test_elm_basic_send_can(): try: sync_reset(s) - send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto + send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF send_compare(s, b'0100\r', b"41 00 FF FF FF FE \r\r>") send_compare(s, b'010D\r', b"41 0D 53 \r\r>") - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces Off send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>") send_compare(s, b'010D\r', b"410D53\r\r>") - send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On + send_compare(s, b'ATH1\r', b'OK\r\r>') # Spaces Off Headers On send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>") send_compare(s, b'010D\r', b"7E803410D53\r\r>") - send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On + send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces On Headers On send_compare(s, b'0100\r', b"7E8 06 41 00 FF FF FF FE \r\r>") send_compare(s, b'010D\r', b"7E8 03 41 0D 53 \r\r>") - send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response. + send_compare(s, b'1F00\r', b"NO DATA\r\r>") # Unhandled msg, no response. # Repeat last check to see if it still works after NO DATA was received send_compare(s, b'0100\r', b"7E8 06 41 00 FF FF FF FE \r\r>") @@ -451,15 +451,15 @@ def test_elm_send_can_multimsg(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON - send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) - sim.can_add_extra_noise(b'\x03\x41\x0D\xFA', addr=0x7E9)# Inject message into the stream + send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) + sim.can_add_extra_noise(b'\x03\x41\x0D\xFA', addr=0x7E9) # Inject message into the stream send_compare(s, b'010D\r', b"7E8 03 41 0D 53 \r" - b"7E9 03 41 0D FA \r\r>") # Check it was ignored. + b"7E9 03 41 0D FA \r\r>") # Check it was ignored. finally: sim.stop() sim.join() @@ -475,14 +475,14 @@ def test_elm_can_check_mode_pid(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH0\r', b'OK\r\r>') # Headers OFF - send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) - sim.can_add_extra_noise(b'\x03\x41\x0E\xFA')# Inject message into the stream - send_compare(s, b'010D\r', b"410D53\r\r>") # Check it was ignored. - send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>") # Check it was ignored again. + send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) + sim.can_add_extra_noise(b'\x03\x41\x0E\xFA') # Inject message into the stream + send_compare(s, b'010D\r', b"410D53\r\r>") # Check it was ignored. + send_compare(s, b'0100\r', b"4100FFFFFFFE\r\r>") # Check it was ignored again. finally: sim.stop() sim.join() @@ -496,30 +496,30 @@ def test_elm_send_can_multiline_msg(): try: sync_reset(s) - send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'0902\r', # headers OFF, Spaces ON + send_compare(s, b'0902\r', # headers OFF, Spaces ON b"014 \r" b"0: 49 02 01 31 44 34 \r" b"1: 47 50 30 30 52 35 35 \r" b"2: 42 31 32 33 34 35 36 \r\r>") - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'0902\r', # Headers OFF, Spaces OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'0902\r', # Headers OFF, Spaces OFF b"014\r" b"0:490201314434\r" b"1:47503030523535\r" b"2:42313233343536\r\r>") - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON - send_compare(s, b'0902\r', # Headers ON, Spaces OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'0902\r', # Headers ON, Spaces OFF b"7E81014490201314434\r" b"7E82147503030523535\r" b"7E82242313233343536\r\r>") - send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON - send_compare(s, b'0902\r', # Headers ON, Spaces ON + send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON + send_compare(s, b'0902\r', # Headers ON, Spaces ON b"7E8 10 14 49 02 01 31 44 34 \r" b"7E8 21 47 50 30 30 52 35 35 \r" b"7E8 22 42 31 32 33 34 35 36 \r\r>") @@ -536,13 +536,13 @@ def test_elm_send_can_multiline_msg_throughput(): try: sync_reset(s) - send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'ATSP6\r', b"ATSP6\rOK\r\r>") # Set Proto + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON rows = 584 - send_compare(s, b'09ff\r', # headers ON, Spaces OFF + send_compare(s, b'09ff\r', # headers ON, Spaces OFF ("7E8" + "1" + hex((rows*7)+6)[2:].upper().zfill(3) + "49FF01"+"AA0000\r" + "".join( ("7E82"+hex((num+1)%0x10)[2:].upper()+("AA"*5) + @@ -563,8 +563,8 @@ def test_elm_interrupted_obd_cmd_resets_state(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF s.send(b"09fd\r") ready = select.select([s], [], [], 4) assert ready[0], "Socket did not receive data within the timeout duration." @@ -593,22 +593,22 @@ def test_elm_can_baud(): try: sync_reset(s) - send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF - send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF - send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON + send_compare(s, b'ATE0\r', b'ATE0\rOK\r\r>') # Echo OFF + send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF + send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON - send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) + send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>") - send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250) + send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250) send_compare(s, b'0100\r', b"CAN ERROR\r\r>") sim.change_can_baud(250) - send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) + send_compare(s, b'ATSP6\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/500) send_compare(s, b'0100\r', b"CAN ERROR\r\r>") - send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250) + send_compare(s, b'ATSP8\r', b"OK\r\r>") # Set Proto ISO 15765-4 (CAN 11/250) send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>") finally: sim.stop() @@ -618,7 +618,7 @@ def test_elm_can_baud(): def test_elm_panda_safety_mode_ISO15765(): s = elm_connect() serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None - p_car = Panda(serial) # Configure this so the messages will send + p_car = Panda(serial) # Configure this so the messages will send p_car.set_can_speed_kbps(0, 500) p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT) @@ -640,28 +640,28 @@ def test_elm_panda_safety_mode_ISO15765(): return False try: - sync_reset(s) # Reset elm (which requests the ELM327 safety mode) + sync_reset(s) # Reset elm (which requests the ELM327 safety mode) #29 bit - assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) #wrong canid - assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00', 0) #wrong length - assert not did_send(p_elm, 0x10000000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr - assert not did_send(p_elm, 0x18DAF133, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (phy addr) - assert not did_send(p_elm, 0x18DAF000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr - assert not did_send(p_elm, 0x18DAF1F3, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr! (phys rsp to elm) + assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) # wrong canid + assert not did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00', 0) # wrong length + assert not did_send(p_elm, 0x10000000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr + assert not did_send(p_elm, 0x18DAF133, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr (phy addr) + assert not did_send(p_elm, 0x18DAF000, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr + assert not did_send(p_elm, 0x18DAF1F3, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr! (phys rsp to elm) - assert did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (obd func req) - assert did_send(p_elm, 0x18DA10F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (phys response) + assert did_send(p_elm, 0x18DB33F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (obd func req) + assert did_send(p_elm, 0x18DA10F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (phys response) #11 bit - assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) #wrong canid - assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00', 0) #wrong length - assert not did_send(p_elm, 0xAA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr - assert not did_send(p_elm, 0x7DA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (phy addr) - assert not did_send(p_elm, 0x7E8, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #bad addr (sending 'response') + assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 1) # wrong canid + assert not did_send(p_elm, 0X7DF, b'\x02\x01\x00', 0) # wrong length + assert not did_send(p_elm, 0xAA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr + assert not did_send(p_elm, 0x7DA, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr (phy addr) + assert not did_send(p_elm, 0x7E8, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # bad addr (sending 'response') - assert did_send(p_elm, 0x7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (obd func req) - assert did_send(p_elm, 0x7E1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) #good! (phys response) + assert did_send(p_elm, 0x7DF, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (obd func req) + assert did_send(p_elm, 0x7E1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (phys response) finally: s.close() diff --git a/tests/safety/common.py b/tests/safety/common.py index 4ca7d09..e2a397e 100644 --- a/tests/safety/common.py +++ b/tests/safety/common.py @@ -253,7 +253,7 @@ class PandaSafetyTest(PandaSafetyTestBase): GAS_PRESSED_THRESHOLD = 0 RELAY_MALFUNCTION_ADDR: Optional[int] = None RELAY_MALFUNCTION_BUS: Optional[int] = None - FWD_BLACKLISTED_ADDRS: Dict[int, List[int]] = {} # {bus: [addr]} + FWD_BLACKLISTED_ADDRS: Dict[int, List[int]] = {} # {bus: [addr]} FWD_BUS_LOOKUP: Dict[int, int] = {} @classmethod diff --git a/tests/safety/test_honda.py b/tests/safety/test_honda.py index d322073..755c215 100755 --- a/tests/safety/test_honda.py +++ b/tests/safety/test_honda.py @@ -20,8 +20,8 @@ HONDA_BH_HW = 2 class TestHondaSafety(common.PandaSafetyTest): MAX_BRAKE: float = 255 - PT_BUS: Optional[int] = None # must be set when inherited - STEER_BUS: Optional[int] = None # must be set when inherited + PT_BUS: Optional[int] = None # must be set when inherited + STEER_BUS: Optional[int] = None # must be set when inherited cnt_speed = 0 cnt_gas = 0 diff --git a/tests/safety/test_toyota.py b/tests/safety/test_toyota.py index 8aee8e7..ebe9318 100755 --- a/tests/safety/test_toyota.py +++ b/tests/safety/test_toyota.py @@ -32,7 +32,7 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest, \ MAX_RT_DELTA = 375 RT_INTERVAL = 250000 MAX_TORQUE_ERROR = 350 - TORQUE_MEAS_TOLERANCE = 1 # toyota safety adds one to be conversative for rounding + TORQUE_MEAS_TOLERANCE = 1 # toyota safety adds one to be conversative for rounding def setUp(self): self.packer = CANPackerPanda("toyota_prius_2017_pt_generated") diff --git a/tests/safety_replay/helpers.py b/tests/safety_replay/helpers.py index b5fe1a0..ee29469 100644 --- a/tests/safety_replay/helpers.py +++ b/tests/safety_replay/helpers.py @@ -46,7 +46,7 @@ def get_steer_torque(mode, to_send): def set_desired_torque_last(safety, mode, torque): if mode in [Panda.SAFETY_HONDA_NIDEC, Panda.SAFETY_HONDA_BOSCH_GIRAFFE, Panda.SAFETY_HONDA_BOSCH_HARNESS]: - pass # honda safety mode doesn't enforce a rate on steering msgs + pass # honda safety mode doesn't enforce a rate on steering msgs elif mode == Panda.SAFETY_TOYOTA: safety.set_toyota_desired_torque_last(torque) elif mode == Panda.SAFETY_GM: diff --git a/tests/safety_replay/replay_drive.py b/tests/safety_replay/replay_drive.py index d6c806d..60a8a89 100755 --- a/tests/safety_replay/replay_drive.py +++ b/tests/safety_replay/replay_drive.py @@ -65,7 +65,7 @@ def replay_drive(lr, safety_mode, param): if __name__ == "__main__": from tools.lib.route import Route - from tools.lib.logreader import MultiLogIterator # pylint: disable=import-error + from tools.lib.logreader import MultiLogIterator # pylint: disable=import-error mode = int(sys.argv[2]) param = 0 if len(sys.argv) < 4 else int(sys.argv[3]) diff --git a/tests/safety_replay/test_safety_replay.py b/tests/safety_replay/test_safety_replay.py index 90913b1..8c4902a 100755 --- a/tests/safety_replay/test_safety_replay.py +++ b/tests/safety_replay/test_safety_replay.py @@ -11,16 +11,16 @@ BASE_URL = "https://commadataci.blob.core.windows.net/openpilotci/" # (route, safety mode, param) logs = [ - ("2425568437959f9d|2019-12-22--16-24-37.bz2", Panda.SAFETY_HONDA_NIDEC, 0), # HONDA.CIVIC (fcw presents: 0x1FA blocked as expected) - ("38bfd238edecbcd7|2019-06-07--10-15-25.bz2", Panda.SAFETY_TOYOTA, 66), # TOYOTA.PRIUS - ("f89c604cf653e2bf|2018-09-29--13-46-50.bz2", Panda.SAFETY_GM, 0), # GM.VOLT - ("0375fdf7b1ce594d|2019-05-21--20-10-33.bz2", Panda.SAFETY_HONDA_BOSCH_GIRAFFE, 1), # HONDA.ACCORD - ("6fb4948a7ebe670e|2019-11-12--00-35-53.bz2", Panda.SAFETY_CHRYSLER, 0), # CHRYSLER.PACIFICA_2018_HYBRID - ("791340bc01ed993d|2019-04-08--10-26-00.bz2", Panda.SAFETY_SUBARU, 0), # SUBARU.IMPREZA - ("76b83eb0245de90e|2020-03-05--19-16-05.bz2", Panda.SAFETY_VOLKSWAGEN_MQB, 0), # VOLKSWAGEN.GOLF (MK7) - ("d12cd943127f267b|2020-03-27--15-57-18.bz2", Panda.SAFETY_VOLKSWAGEN_PQ, 0), # 2009 VW Passat R36 (B6), supporting OP port not yet upstreamed - ("fbbfa6af821552b9|2020-03-03--08-09-43.bz2", Panda.SAFETY_NISSAN, 0), # NISSAN.XTRAIL - ("5b7c365c50084530_2020-04-15--16-13-24--3--rlog.bz2", Panda.SAFETY_HYUNDAI, 0), # HYUNDAI.SONATA + ("2425568437959f9d|2019-12-22--16-24-37.bz2", Panda.SAFETY_HONDA_NIDEC, 0), # HONDA.CIVIC (fcw presents: 0x1FA blocked as expected) + ("38bfd238edecbcd7|2019-06-07--10-15-25.bz2", Panda.SAFETY_TOYOTA, 66), # TOYOTA.PRIUS + ("f89c604cf653e2bf|2018-09-29--13-46-50.bz2", Panda.SAFETY_GM, 0), # GM.VOLT + ("0375fdf7b1ce594d|2019-05-21--20-10-33.bz2", Panda.SAFETY_HONDA_BOSCH_GIRAFFE, 1), # HONDA.ACCORD + ("6fb4948a7ebe670e|2019-11-12--00-35-53.bz2", Panda.SAFETY_CHRYSLER, 0), # CHRYSLER.PACIFICA_2018_HYBRID + ("791340bc01ed993d|2019-04-08--10-26-00.bz2", Panda.SAFETY_SUBARU, 0), # SUBARU.IMPREZA + ("76b83eb0245de90e|2020-03-05--19-16-05.bz2", Panda.SAFETY_VOLKSWAGEN_MQB, 0), # VOLKSWAGEN.GOLF (MK7) + ("d12cd943127f267b|2020-03-27--15-57-18.bz2", Panda.SAFETY_VOLKSWAGEN_PQ, 0), # 2009 VW Passat R36 (B6), supporting OP port not yet upstreamed + ("fbbfa6af821552b9|2020-03-03--08-09-43.bz2", Panda.SAFETY_NISSAN, 0), # NISSAN.XTRAIL + ("5b7c365c50084530_2020-04-15--16-13-24--3--rlog.bz2", Panda.SAFETY_HYUNDAI, 0), # HYUNDAI.SONATA ] if __name__ == "__main__": @@ -37,6 +37,6 @@ if __name__ == "__main__": if not replay_drive(lr, mode, int(param)): failed.append(route) - for f in failed: # type: ignore + for f in failed: # type: ignore print(f"\n**** failed on {f} ****") assert len(failed) == 0, "\nfailed on %d logs" % len(failed)