retropilot
/
panda
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

two spaces before inline comment

master
Adeeb Shihadeh 2020-05-31 14:07:01 -07:00
parent 49ffbe99f6
commit 9102c16118
14 changed files with 162 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
examples/tesla_tester.py
View File

@ -18,8 +18,8 @@ def tesla_tester():
print("WiFi connection timed out. Please make sure your Panda is connected and try again.") print("WiFi connection timed out. Please make sure your Panda is connected and try again.")
sys.exit(0) sys.exit(0)
body_bus_speed = 125 # Tesla Body busses (B, BF) are 125kbps, rest are 500kbps 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_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) 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 # 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() can_recv = p.can_recv()
for address, _, dat, src in can_recv: for address, _, dat, src in can_recv:
if src == body_bus_num: if src == body_bus_num:
if address == 1384: #0x568 is VIN if address == 1384: # 0x568 is VIN
vin_index = int(binascii.hexlify(dat)[:2]) #first byte is the index, 00, 01, 02 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_string = binascii.hexlify(dat)[2:] # rest of the string is the actual VIN data
vin[vin_index] = vin_string.decode("hex") vin[vin_index] = vin_string.decode("hex")
print("Got VIN index " + str(vin_index) + " data " + vin[vin_index]) 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 #if we have all 3 parts of the VIN, print it and break out of our while loop

2
python/__init__.py
View File

@ -200,7 +200,7 @@ class Panda(object):
traceback.print_exc() traceback.print_exc()
if wait == False or self._handle != None: if wait == False or self._handle != None:
break 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) assert(self._handle != None)
print("connected") print("connected")

16
python/uds.py
View File

@ -328,7 +328,7 @@ class CanClient():
while True: while True:
yield self.rx_buff.popleft() yield self.rx_buff.popleft()
except IndexError: except IndexError:
pass # empty pass # empty
def send(self, msgs: List[bytes], delay: float=0) -> None: def send(self, msgs: List[bytes], delay: float=0) -> None:
for i, msg in enumerate(msgs): for i, msg in enumerate(msgs):
@ -607,13 +607,13 @@ class UdsClient():
if response_event_type == RESPONSE_EVENT_TYPE.REPORT_ACTIVATED_EVENTS: if response_event_type == RESPONSE_EVENT_TYPE.REPORT_ACTIVATED_EVENTS:
return { return {
"num_of_activated_events": resp[0], "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 { return {
"num_of_identified_events": resp[0], "num_of_identified_events": resp[0],
"event_window_time": resp[1], "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): 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 resp_id = struct.unpack('!H', resp[0:2])[0] if len(resp) >= 2 else None
if resp_id != data_identifier_type: if resp_id != data_identifier_type:
raise ValueError('invalid response data identifier: {}'.format(hex(resp_id))) 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): def read_data_by_periodic_identifier(self, transmission_mode_type: TRANSMISSION_MODE_TYPE, periodic_data_identifier: int):
# TODO: support list of identifiers # TODO: support list of identifiers
@ -718,7 +718,7 @@ class UdsClient():
self._uds_request(SERVICE_TYPE.WRITE_MEMORY_BY_ADDRESS, subfunction=0x00, data=data) self._uds_request(SERVICE_TYPE.WRITE_MEMORY_BY_ADDRESS, subfunction=0x00, data=data)
def clear_diagnostic_information(self, dtc_group_type: DTC_GROUP_TYPE): 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) 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): 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.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.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
dtc_report_type == DTC_REPORT_TYPE.SEVERITY_INFORMATION_OF_DTC: 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 # dtc_snapshot_record_num
if dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_IDENTIFICATION or \ if dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_IDENTIFICATION or \
dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \ dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \
@ -796,7 +796,7 @@ class UdsClient():
else: else:
raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len)) 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): 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]) data = bytes([data_format])
@ -821,7 +821,7 @@ class UdsClient():
else: else:
raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len)) 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''): def transfer_data(self, block_sequence_count: int, data: bytes=b''):
data = bytes([block_sequence_count]) + data data = bytes([block_sequence_count]) + data

2
tests/automated/6_wifi_udp.py
View File

@ -41,7 +41,7 @@ def test_udp_doesnt_drop(serials=None):
sys.stdout.flush() sys.stdout.flush()
else: else:
print("UDP WIFI loopback %d messages at speed %d, comp speed is %.2f, percent %.2f" % (msg_count, speed, comp_kbps, saturation_pct)) 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) assert_less(saturation_pct, 100)
saturation_pcts.append(saturation_pct) saturation_pcts.append(saturation_pct)
if len(saturation_pcts) > 0: if len(saturation_pcts) > 0:

2
tests/debug_console.py
View File

@ -28,7 +28,7 @@ if __name__ == "__main__":
if os.getenv("BAUD") is not None: if os.getenv("BAUD") is not None:
for panda in pandas: 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: while True:
for i, panda in enumerate(pandas): for i, panda in enumerate(pandas):

2
tests/development/register_hashmap_spread.py
View File

@ -1,5 +1,5 @@
#!/usr/bin/env python3 #!/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 HASHING_PRIME = 23
REGISTER_MAP_SIZE = 0x3FF REGISTER_MAP_SIZE = 0x3FF

34
tests/elm_car_simulator.py
View File

@ -74,7 +74,7 @@ class ELMCarSimulator():
def __lin_monitor(self): def __lin_monitor(self):
print("STARTING LIN THREAD") print("STARTING LIN THREAD")
self.panda.set_uart_baud(2, 10400) 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() lin_buff = bytearray()
@ -85,7 +85,7 @@ class ELMCarSimulator():
lin_buff += lin_msg lin_buff += lin_msg
#print(" ** Buff", lin_buff) #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() lin_buff = bytearray()
self.__lin_active = True self.__lin_active = True
print("GOT LIN (KWP FAST) WAKEUP SIGNAL") print("GOT LIN (KWP FAST) WAKEUP SIGNAL")
@ -100,7 +100,7 @@ class ELMCarSimulator():
continue continue
if len(lin_buff) < msglen + 4: continue if len(lin_buff) < msglen + 4: continue
if lin_checksum(lin_buff[:-1]) != lin_buff[-1]: 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[1], lin_buff[2], lin_buff[3:-1])
lin_buff = bytearray() lin_buff = bytearray()
@ -168,7 +168,7 @@ class ELMCarSimulator():
def __can_monitor(self): def __can_monitor(self):
print("STARTING CAN THREAD") print("STARTING CAN THREAD")
self.panda.set_can_speed_kbps(0, self.__can_kbaud) 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: while not self.__stop:
for address, ts, data, src in self.panda.can_recv(): for address, ts, data, src in self.panda.can_recv():
@ -259,28 +259,28 @@ class ELMCarSimulator():
######################### #########################
def _process_obd(self, mode, pid): 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 if pid == 0x00: #List supported things
return b"\xff\xff\xff\xfe"#b"\xBE\x1F\xB8\x10" #Bitfield, random features return b"\xff\xff\xff\xfe" # b"\xBE\x1F\xB8\x10" #Bitfield, random features
elif pid == 0x01: # Monitor Status since DTC cleared elif pid == 0x01: # Monitor Status since DTC cleared
return b"\x00\x00\x00\x00" #Bitfield, random features return b"\x00\x00\x00\x00" # Bitfield, random features
elif pid == 0x04: # Calculated engine load elif pid == 0x04: # Calculated engine load
return b"\x2f" return b"\x2f"
elif pid == 0x05: # Engine coolant temperature elif pid == 0x05: # Engine coolant temperature
return b"\x3c" return b"\x3c"
elif pid == 0x0B: # Intake manifold absolute pressure elif pid == 0x0B: # Intake manifold absolute pressure
return b"\x90" return b"\x90"
elif pid == 0x0C: # Engine RPM elif pid == 0x0C: # Engine RPM
return b"\x1A\xF8" return b"\x1A\xF8"
elif pid == 0x0D: # Vehicle Speed elif pid == 0x0D: # Vehicle Speed
return b"\x53" return b"\x53"
elif pid == 0x10: # MAF air flow rate elif pid == 0x10: # MAF air flow rate
return b"\x01\xA0" return b"\x01\xA0"
elif pid == 0x11: # Throttle Position elif pid == 0x11: # Throttle Position
return b"\x90" return b"\x90"
elif pid == 0x33: # Absolute Barometric Pressure elif pid == 0x33: # Absolute Barometric Pressure
return b"\x90" return b"\x90"
elif mode == 0x09: # Mode: Request vehicle information elif mode == 0x09: # Mode: Request vehicle information
if pid == 0x02: # Show VIN if pid == 0x02: # Show VIN
return b"1D4GP00R55B123456" return b"1D4GP00R55B123456"
if pid == 0xFC: # test long multi message. Ligned up for LIN responses if pid == 0xFC: # test long multi message. Ligned up for LIN responses

222
tests/elm_wifi.py
View File

@ -35,7 +35,7 @@ def send_compare(s, dat, ret, timeout=4):
break; break;
res += s.recv(1000) res += s.recv(1000)
#print("final recv data: '%s'" % repr(res)) #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): def sync_reset(s):
s.send("ATZ\r") s.send("ATZ\r")
@ -63,7 +63,7 @@ def test_elm_cli():
#Test Echo Off #Test Echo Off
#Expected to be misimplimentation, but this is how the reference device behaved. #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'ATE0\r', b'OK\r\r>') #Should prob show this immediately
send_compare(s, b'ATI\r', b'ELM327 v1.5\r\r>') 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'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>')
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'\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 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 GZ\r', b'?\r\r>') # Test Invalid (Non hex chars) OBD command
finally: finally:
s.close() s.close()
@ -92,23 +92,23 @@ def test_elm_setget_protocol():
try: try:
sync_reset(s) 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'ATDP\r', b"AUTO\r\r>")
send_compare(s, b'ATDPN\r', b"A0\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'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'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'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'ATDPN\r', b"A6\r\r>")
send_compare(s, b'ATSP7\r', b"OK\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'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'ATSPD\r', b"?\r\r>")
send_compare(s, b'ATDP\r', b"ISO 15765-4 (CAN 29/500)\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>") send_compare(s, b'ATDPN\r', b"7\r\r>")
@ -120,7 +120,7 @@ def test_elm_protocol_failure():
try: try:
sync_reset(s) 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'ATSP0\r', b"OK\r\r>")
send_compare(s, b'0100\r', b"SEARCHING...\rUNABLE TO CONNECT\r\r>", timeout=10) 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(): def test_elm_protocol_autodetect_ISO14230_KWP_FAST():
s = elm_connect() s = elm_connect()
serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None 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() sim.start()
try: try:
sync_reset(s) 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'ATH0\r', b'OK\r\r>') # Headers ON 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'ATS0\r', b"OK\r\r>")
send_compare(s, b'ATSP0\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(): def test_elm_basic_send_lin():
s = elm_connect() s = elm_connect()
serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None 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() sim.start()
try: try:
sync_reset(s) 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'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'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'0100\r', b"4100FFFFFFFE\r\r>")
send_compare(s, b'010D\r', b"410D53\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'0100\r', b"86F1104100FFFFFFFEC3\r\r>")
send_compare(s, b'010D\r', b"83F110410D5325\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'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'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 # 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>") 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: try:
sync_reset(s) 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'ATSP5\r', b"OK\r\r>") # Set Proto 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"BUS INIT: OK\r"
b"49 02 01 00 00 00 31 \r" b"49 02 01 00 00 00 31 \r"
b"49 02 02 44 34 47 50 \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 04 35 42 31 32 \r"
b"49 02 05 33 34 35 36 \r\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'ATS0\r', b'OK\r\r>') # Spaces OFF
send_compare(s, b'0902\r', # Headers OFF, Spaces OFF send_compare(s, b'0902\r', # Headers OFF, Spaces OFF
b"49020100000031\r" b"49020100000031\r"
b"49020244344750\r" b"49020244344750\r"
b"49020330305235\r" b"49020330305235\r"
b"49020435423132\r" b"49020435423132\r"
b"49020533343536\r\r>") b"49020533343536\r\r>")
send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON 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'0902\r', # Headers ON, Spaces OFF
b"87F1104902010000003105\r" b"87F1104902010000003105\r"
b"87F11049020244344750E4\r" b"87F11049020244344750E4\r"
b"87F11049020330305235BD\r" b"87F11049020330305235BD\r"
b"87F11049020435423132B1\r" b"87F11049020435423132B1\r"
b"87F11049020533343536AA\r\r>") b"87F11049020533343536AA\r\r>")
send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON 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'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 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 02 44 34 47 50 E4 \r"
b"87 F1 10 49 02 03 30 30 52 35 BD \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: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces 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'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"BUS INIT: OK\r" +
b''.join((b'49FC' + hex(num+1)[2:].upper().zfill(2) + b''.join((b'49FC' + hex(num+1)[2:].upper().zfill(2) +
b'AAAA' + hex(num+1)[2:].upper().zfill(4) + b'\r' 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(): def test_elm_panda_safety_mode_KWPFast():
serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None 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.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
p_car.kline_drain() p_car.kline_drain()
@ -332,13 +332,13 @@ def test_elm_panda_safety_mode_KWPFast():
return False return False
return timed_recv_check(p_car, bus, msgout) 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'\x01\x0F', bus=3) # wrong bus
assert not did_send(0xC0, 0x33, 0xF1, b'') #wrong length 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(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, 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, 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(): def test_elm_lin_keepalive():
s = elm_connect() s = elm_connect()
@ -348,17 +348,17 @@ def test_elm_lin_keepalive():
try: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces 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'ATH0\r', b'OK\r\r>') # Headers OFF
send_compare(s, b'0100\r', b"BUS INIT: OK\r4100FFFFFFFE\r\r>") send_compare(s, b'0100\r', b"BUS INIT: OK\r4100FFFFFFFE\r\r>")
assert sim.lin_active assert sim.lin_active
time.sleep(6) time.sleep(6)
assert sim.lin_active 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 assert sim.lin_active
time.sleep(6) time.sleep(6)
assert not sim.lin_active assert not sim.lin_active
@ -377,8 +377,8 @@ def test_elm_protocol_autodetect_ISO15765():
try: try:
sync_reset(s) 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'ATH1\r', b'OK\r\r>') # Headers ON send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON
send_compare(s, b'ATS0\r', b"OK\r\r>") send_compare(s, b'ATS0\r', b"OK\r\r>")
sim.can_mode_11b() sim.can_mode_11b()
@ -415,25 +415,25 @@ def test_elm_basic_send_can():
try: try:
sync_reset(s) 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'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'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'0100\r', b"4100FFFFFFFE\r\r>")
send_compare(s, b'010D\r', b"410D53\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'0100\r', b"7E8064100FFFFFFFE\r\r>")
send_compare(s, b'010D\r', b"7E803410D53\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'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'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 # 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>") 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: try:
sync_reset(s) 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'ATS1\r', b'OK\r\r>') # Spaces 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'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)
sim.can_add_extra_noise(b'\x03\x41\x0D\xFA', addr=0x7E9)# Inject message into the stream sim.can_add_extra_noise(b'\x03\x41\x0D\xFA', addr=0x7E9) # Inject message into the stream
send_compare(s, b'010D\r', send_compare(s, b'010D\r',
b"7E8 03 41 0D 53 \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: finally:
sim.stop() sim.stop()
sim.join() sim.join()
@ -475,14 +475,14 @@ def test_elm_can_check_mode_pid():
try: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces 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'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) 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 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'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'0100\r', b"4100FFFFFFFE\r\r>") # Check it was ignored again.
finally: finally:
sim.stop() sim.stop()
sim.join() sim.join()
@ -496,30 +496,30 @@ def test_elm_send_can_multiline_msg():
try: try:
sync_reset(s) 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'0902\r', # headers OFF, Spaces ON send_compare(s, b'0902\r', # headers OFF, Spaces ON
b"014 \r" b"014 \r"
b"0: 49 02 01 31 44 34 \r" b"0: 49 02 01 31 44 34 \r"
b"1: 47 50 30 30 52 35 35 \r" b"1: 47 50 30 30 52 35 35 \r"
b"2: 42 31 32 33 34 35 36 \r\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'ATS0\r', b'OK\r\r>') # Spaces OFF
send_compare(s, b'0902\r', # Headers OFF, Spaces OFF send_compare(s, b'0902\r', # Headers OFF, Spaces OFF
b"014\r" b"014\r"
b"0:490201314434\r" b"0:490201314434\r"
b"1:47503030523535\r" b"1:47503030523535\r"
b"2:42313233343536\r\r>") b"2:42313233343536\r\r>")
send_compare(s, b'ATH1\r', b'OK\r\r>') # Headers ON 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'0902\r', # Headers ON, Spaces OFF
b"7E81014490201314434\r" b"7E81014490201314434\r"
b"7E82147503030523535\r" b"7E82147503030523535\r"
b"7E82242313233343536\r\r>") b"7E82242313233343536\r\r>")
send_compare(s, b'ATS1\r', b'OK\r\r>') # Spaces ON 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'0902\r', # Headers ON, Spaces ON
b"7E8 10 14 49 02 01 31 44 34 \r" b"7E8 10 14 49 02 01 31 44 34 \r"
b"7E8 21 47 50 30 30 52 35 35 \r" b"7E8 21 47 50 30 30 52 35 35 \r"
b"7E8 22 42 31 32 33 34 35 36 \r\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: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces 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'ATH1\r', b'OK\r\r>') # Headers ON
rows = 584 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" + ("7E8" + "1" + hex((rows*7)+6)[2:].upper().zfill(3) + "49FF01"+"AA0000\r" +
"".join( "".join(
("7E82"+hex((num+1)%0x10)[2:].upper()+("AA"*5) + ("7E82"+hex((num+1)%0x10)[2:].upper()+("AA"*5) +
@ -563,8 +563,8 @@ def test_elm_interrupted_obd_cmd_resets_state():
try: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces OFF send_compare(s, b'ATS0\r', b'OK\r\r>') # Spaces OFF
s.send(b"09fd\r") s.send(b"09fd\r")
ready = select.select([s], [], [], 4) ready = select.select([s], [], [], 4)
assert ready[0], "Socket did not receive data within the timeout duration." assert ready[0], "Socket did not receive data within the timeout duration."
@ -593,22 +593,22 @@ def test_elm_can_baud():
try: try:
sync_reset(s) 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'ATS0\r', b'OK\r\r>') # Spaces 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'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'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>") send_compare(s, b'0100\r', b"CAN ERROR\r\r>")
sim.change_can_baud(250) 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'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>") send_compare(s, b'0100\r', b"7E8064100FFFFFFFE\r\r>")
finally: finally:
sim.stop() sim.stop()
@ -618,7 +618,7 @@ def test_elm_can_baud():
def test_elm_panda_safety_mode_ISO15765(): def test_elm_panda_safety_mode_ISO15765():
s = elm_connect() s = elm_connect()
serial = os.getenv("CANSIMSERIAL") if os.getenv("CANSIMSERIAL") else None 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_can_speed_kbps(0, 500)
p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT) p_car.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
@ -640,28 +640,28 @@ def test_elm_panda_safety_mode_ISO15765():
return False return False
try: 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 #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\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, 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, 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, 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, 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, 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, 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, 0x18DA10F1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (phys response)
#11 bit #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\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, 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, 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, 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, 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, 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, 0x7E1, b'\x02\x01\x00\x00\x00\x00\x00\x00', 0) # good! (phys response)
finally: finally:
s.close() s.close()

2
tests/safety/common.py
View File

@ -253,7 +253,7 @@ class PandaSafetyTest(PandaSafetyTestBase):
GAS_PRESSED_THRESHOLD = 0 GAS_PRESSED_THRESHOLD = 0
RELAY_MALFUNCTION_ADDR: Optional[int] = None RELAY_MALFUNCTION_ADDR: Optional[int] = None
RELAY_MALFUNCTION_BUS: 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] = {} FWD_BUS_LOOKUP: Dict[int, int] = {}
@classmethod @classmethod

4
tests/safety/test_honda.py
View File

@ -20,8 +20,8 @@ HONDA_BH_HW = 2
class TestHondaSafety(common.PandaSafetyTest): class TestHondaSafety(common.PandaSafetyTest):
MAX_BRAKE: float = 255 MAX_BRAKE: float = 255
PT_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 STEER_BUS: Optional[int] = None # must be set when inherited
cnt_speed = 0 cnt_speed = 0
cnt_gas = 0 cnt_gas = 0

2
tests/safety/test_toyota.py
View File

@ -32,7 +32,7 @@ class TestToyotaSafety(common.PandaSafetyTest, common.InterceptorSafetyTest, \
MAX_RT_DELTA = 375 MAX_RT_DELTA = 375
RT_INTERVAL = 250000 RT_INTERVAL = 250000
MAX_TORQUE_ERROR = 350 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): def setUp(self):
self.packer = CANPackerPanda("toyota_prius_2017_pt_generated") self.packer = CANPackerPanda("toyota_prius_2017_pt_generated")

2
tests/safety_replay/helpers.py
View File

@ -46,7 +46,7 @@ def get_steer_torque(mode, to_send):
def set_desired_torque_last(safety, mode, torque): 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]: 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: elif mode == Panda.SAFETY_TOYOTA:
safety.set_toyota_desired_torque_last(torque) safety.set_toyota_desired_torque_last(torque)
elif mode == Panda.SAFETY_GM: elif mode == Panda.SAFETY_GM:

2
tests/safety_replay/replay_drive.py
View File

@ -65,7 +65,7 @@ def replay_drive(lr, safety_mode, param):
if __name__ == "__main__": if __name__ == "__main__":
from tools.lib.route import Route 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]) mode = int(sys.argv[2])
param = 0 if len(sys.argv) < 4 else int(sys.argv[3]) param = 0 if len(sys.argv) < 4 else int(sys.argv[3])

22
tests/safety_replay/test_safety_replay.py
View File

@ -11,16 +11,16 @@ BASE_URL = "https://commadataci.blob.core.windows.net/openpilotci/"
# (route, safety mode, param) # (route, safety mode, param)
logs = [ logs = [
("2425568437959f9d|2019-12-22--16-24-37.bz2", Panda.SAFETY_HONDA_NIDEC, 0), # HONDA.CIVIC (fcw presents: 0x1FA blocked as expected) ("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 ("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 ("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 ("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 ("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 ("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) ("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 ("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 ("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 ("5b7c365c50084530_2020-04-15--16-13-24--3--rlog.bz2", Panda.SAFETY_HYUNDAI, 0), # HYUNDAI.SONATA
] ]
if __name__ == "__main__": if __name__ == "__main__":
@ -37,6 +37,6 @@ if __name__ == "__main__":
if not replay_drive(lr, mode, int(param)): if not replay_drive(lr, mode, int(param)):
failed.append(route) failed.append(route)
for f in failed: # type: ignore for f in failed: # type: ignore
print(f"\n**** failed on {f} ****") print(f"\n**** failed on {f} ****")
assert len(failed) == 0, "\nfailed on %d logs" % len(failed) assert len(failed) == 0, "\nfailed on %d logs" % len(failed)