sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

warm up kinda works

Browse Source
pull/30443/head
Shane Smiskol 1 year ago
parent 71be1698e9
commit 7fc77b07d5
1 changed files with 212 additions and 208 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 420
      selfdrive/car/tests/test_models.py

420
selfdrive/car/tests/test_models.py
Unescape View File

@ -175,131 +175,133 @@ class TestCarModelBase(unittest.TestCase):
self.assertEqual(0, set_status, f"failed to set safetyModel {cfg}") self.assertEqual(0, set_status, f"failed to set safetyModel {cfg}")
self.safety.init_tests() self.safety.init_tests()
def test_car_params(self): self.test_panda_safety_carstate()
if self.CP.dashcamOnly:
self.skipTest("no need to check carParams for dashcamOnly") # def test_car_params(self):
# if self.CP.dashcamOnly:
# make sure car params are within a valid range # self.skipTest("no need to check carParams for dashcamOnly")
self.assertGreater(self.CP.mass, 1) #
# # make sure car params are within a valid range
if self.CP.steerControlType != car.CarParams.SteerControlType.angle: # self.assertGreater(self.CP.mass, 1)
tuning = self.CP.lateralTuning.which() #
if tuning == 'pid': # if self.CP.steerControlType != car.CarParams.SteerControlType.angle:
self.assertTrue(len(self.CP.lateralTuning.pid.kpV)) # tuning = self.CP.lateralTuning.which()
elif tuning == 'torque': # if tuning == 'pid':
self.assertTrue(self.CP.lateralTuning.torque.kf > 0) # self.assertTrue(len(self.CP.lateralTuning.pid.kpV))
else: # elif tuning == 'torque':
raise Exception("unknown tuning") # self.assertTrue(self.CP.lateralTuning.torque.kf > 0)
# else:
def test_car_interface(self): # raise Exception("unknown tuning")
# TODO: also check for checksum violations from can parser #
can_invalid_cnt = 0 # def test_car_interface(self):
can_valid = False # # TODO: also check for checksum violations from can parser
CC = car.CarControl.new_message() # can_invalid_cnt = 0
# can_valid = False
for i, msg in enumerate(self.can_msgs): # CC = car.CarControl.new_message()
CS = self.CI.update(CC, (msg.as_builder().to_bytes(),)) #
self.CI.apply(CC, msg.logMonoTime) # for i, msg in enumerate(self.can_msgs):
# CS = self.CI.update(CC, (msg.as_builder().to_bytes(),))
if CS.canValid: # self.CI.apply(CC, msg.logMonoTime)
can_valid = True #
# if CS.canValid:
# wait max of 2s for low frequency msgs to be seen # can_valid = True
if i > 200 or can_valid: #
can_invalid_cnt += not CS.canValid # # wait max of 2s for low frequency msgs to be seen
# if i > 200 or can_valid:
self.assertEqual(can_invalid_cnt, 0) # can_invalid_cnt += not CS.canValid
#
def test_radar_interface(self): # self.assertEqual(can_invalid_cnt, 0)
os.environ['NO_RADAR_SLEEP'] = "1" #
RadarInterface = importlib.import_module(f'selfdrive.car.{self.CP.carName}.radar_interface').RadarInterface # def test_radar_interface(self):
RI = RadarInterface(self.CP) # os.environ['NO_RADAR_SLEEP'] = "1"
assert RI # RadarInterface = importlib.import_module(f'selfdrive.car.{self.CP.carName}.radar_interface').RadarInterface
# RI = RadarInterface(self.CP)
# Since OBD port is multiplexed to bus 1 (commonly radar bus) while fingerprinting, # assert RI
# start parsing CAN messages after we've left ELM mode and can expect CAN traffic #
error_cnt = 0 # # Since OBD port is multiplexed to bus 1 (commonly radar bus) while fingerprinting,
for i, msg in enumerate(self.can_msgs[self.elm_frame:]): # # start parsing CAN messages after we've left ELM mode and can expect CAN traffic
rr = RI.update((msg.as_builder().to_bytes(),)) # error_cnt = 0
if rr is not None and i > 50: # for i, msg in enumerate(self.can_msgs[self.elm_frame:]):
error_cnt += car.RadarData.Error.canError in rr.errors # rr = RI.update((msg.as_builder().to_bytes(),))
self.assertEqual(error_cnt, 0) # if rr is not None and i > 50:
# error_cnt += car.RadarData.Error.canError in rr.errors
def test_panda_safety_rx_checks(self): # self.assertEqual(error_cnt, 0)
if self.CP.dashcamOnly: #
self.skipTest("no need to check panda safety for dashcamOnly") # def test_panda_safety_rx_checks(self):
# if self.CP.dashcamOnly:
start_ts = self.can_msgs[0].logMonoTime # self.skipTest("no need to check panda safety for dashcamOnly")
#
failed_addrs = Counter() # start_ts = self.can_msgs[0].logMonoTime
for can in self.can_msgs: #
# update panda timer # failed_addrs = Counter()
t = (can.logMonoTime - start_ts) / 1e3 # for can in self.can_msgs:
self.safety.set_timer(int(t)) # # update panda timer
# t = (can.logMonoTime - start_ts) / 1e3
# run all msgs through the safety RX hook # self.safety.set_timer(int(t))
for msg in can.can: #
if msg.src >= 64: # # run all msgs through the safety RX hook
continue # for msg in can.can:
# if msg.src >= 64:
to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat) # continue
if self.safety.safety_rx_hook(to_send) != 1: #
failed_addrs[hex(msg.address)] += 1 # to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat)
# if self.safety.safety_rx_hook(to_send) != 1:
# ensure all msgs defined in the addr checks are valid # failed_addrs[hex(msg.address)] += 1
self.safety.safety_tick_current_safety_config() #
if t > 1e6: # # ensure all msgs defined in the addr checks are valid
self.assertTrue(self.safety.safety_config_valid()) # self.safety.safety_tick_current_safety_config()
# if t > 1e6:
# Don't check relay malfunction on disabled routes (relay closed), # self.assertTrue(self.safety.safety_config_valid())
# or before fingerprinting is done (elm327 and noOutput) #
if self.openpilot_enabled and t / 1e4 > self.car_safety_mode_frame: # # Don't check relay malfunction on disabled routes (relay closed),
self.assertFalse(self.safety.get_relay_malfunction()) # # or before fingerprinting is done (elm327 and noOutput)
else: # if self.openpilot_enabled and t / 1e4 > self.car_safety_mode_frame:
self.safety.set_relay_malfunction(False) # self.assertFalse(self.safety.get_relay_malfunction())
# else:
self.assertFalse(len(failed_addrs), f"panda safety RX check failed: {failed_addrs}") # self.safety.set_relay_malfunction(False)
#
# ensure RX checks go invalid after small time with no traffic # self.assertFalse(len(failed_addrs), f"panda safety RX check failed: {failed_addrs}")
self.safety.set_timer(int(t + (2*1e6))) #
self.safety.safety_tick_current_safety_config() # # ensure RX checks go invalid after small time with no traffic
self.assertFalse(self.safety.safety_config_valid()) # self.safety.set_timer(int(t + (2*1e6)))
# self.safety.safety_tick_current_safety_config()
def test_panda_safety_tx_cases(self, data=None): # self.assertFalse(self.safety.safety_config_valid())
"""Asserts we can tx common messages""" #
if self.CP.notCar: # def test_panda_safety_tx_cases(self, data=None):
self.skipTest("Skipping test for notCar") # """Asserts we can tx common messages"""
# if self.CP.notCar:
def test_car_controller(car_control): # self.skipTest("Skipping test for notCar")
now_nanos = 0 #
msgs_sent = 0 # def test_car_controller(car_control):
CI = self.CarInterface(self.CP, self.CarController, self.CarState) # now_nanos = 0
for _ in range(round(10.0 / DT_CTRL)): # make sure we hit the slowest messages # msgs_sent = 0
CI.update(car_control, []) # CI = self.CarInterface(self.CP, self.CarController, self.CarState)
_, sendcan = CI.apply(car_control, now_nanos) # for _ in range(round(10.0 / DT_CTRL)): # make sure we hit the slowest messages
# CI.update(car_control, [])
now_nanos += DT_CTRL * 1e9 # _, sendcan = CI.apply(car_control, now_nanos)
msgs_sent += len(sendcan) #
for addr, _, dat, bus in sendcan: # now_nanos += DT_CTRL * 1e9
to_send = libpanda_py.make_CANPacket(addr, bus % 4, dat) # msgs_sent += len(sendcan)
self.assertTrue(self.safety.safety_tx_hook(to_send), (addr, dat, bus)) # for addr, _, dat, bus in sendcan:
# to_send = libpanda_py.make_CANPacket(addr, bus % 4, dat)
# Make sure we attempted to send messages # self.assertTrue(self.safety.safety_tx_hook(to_send), (addr, dat, bus))
self.assertGreater(msgs_sent, 50) #
# # Make sure we attempted to send messages
# Make sure we can send all messages while inactive # self.assertGreater(msgs_sent, 50)
CC = car.CarControl.new_message() #
test_car_controller(CC) # # Make sure we can send all messages while inactive
# CC = car.CarControl.new_message()
# Test cancel + general messages (controls_allowed=False & cruise_engaged=True) # test_car_controller(CC)
self.safety.set_cruise_engaged_prev(True) #
CC = car.CarControl.new_message(cruiseControl={'cancel': True}) # # Test cancel + general messages (controls_allowed=False & cruise_engaged=True)
test_car_controller(CC) # self.safety.set_cruise_engaged_prev(True)
# CC = car.CarControl.new_message(cruiseControl={'cancel': True})
# Test resume + general messages (controls_allowed=True & cruise_engaged=True) # test_car_controller(CC)
self.safety.set_controls_allowed(True) #
CC = car.CarControl.new_message(cruiseControl={'resume': True}) # # Test resume + general messages (controls_allowed=True & cruise_engaged=True)
test_car_controller(CC) # self.safety.set_controls_allowed(True)
# CC = car.CarControl.new_message(cruiseControl={'resume': True})
# test_car_controller(CC)
@pytest.mark.nocapture @pytest.mark.nocapture
@settings(max_examples=MAX_EXAMPLES, deadline=None, @settings(max_examples=MAX_EXAMPLES, deadline=None,
@ -343,30 +345,31 @@ class TestCarModelBase(unittest.TestCase):
CC = car.CarControl.new_message() CC = car.CarControl.new_message()
CS = self.CI.update(CC, (can.to_bytes(),)) CS = self.CI.update(CC, (can.to_bytes(),))
if self.safety.get_gas_pressed_prev() != prev_panda_gas: # if self.safety.get_gas_pressed_prev() != prev_panda_gas:
self.assertEqual(CS.gasPressed, self.safety.get_gas_pressed_prev()) self.assertEqual(CS.gasPressed, self.safety.get_gas_pressed_prev())
if self.safety.get_brake_pressed_prev() != prev_panda_brake: # if self.safety.get_brake_pressed_prev() != prev_panda_brake:
brake_pressed = CS.brakePressed brake_pressed = CS.brakePressed
if CS.brakePressed and not self.safety.get_brake_pressed_prev(): if CS.brakePressed and not self.safety.get_brake_pressed_prev():
if self.CP.carFingerprint in (HONDA.PILOT, HONDA.RIDGELINE) and CS.brake > 0.05: if self.CP.carFingerprint in (HONDA.PILOT, HONDA.RIDGELINE) and CS.brake > 0.05:
brake_pressed = False brake_pressed = False
self.assertEqual(brake_pressed, self.safety.get_brake_pressed_prev()) self.assertEqual(brake_pressed, self.safety.get_brake_pressed_prev())
if self.safety.get_regen_braking_prev() != prev_panda_regen_braking: # if self.safety.get_regen_braking_prev() != prev_panda_regen_braking:
self.assertEqual(CS.regenBraking, self.safety.get_regen_braking_prev()) self.assertEqual(CS.regenBraking, self.safety.get_regen_braking_prev())
if self.safety.get_vehicle_moving() != prev_panda_vehicle_moving: # if self.safety.get_vehicle_moving() != prev_panda_vehicle_moving:
self.assertEqual(not CS.standstill, self.safety.get_vehicle_moving()) self.assertEqual(not CS.standstill, self.safety.get_vehicle_moving())
if not (self.CP.carName == "honda" and self.CP.carFingerprint not in HONDA_BOSCH): if self.CP.pcmCruise:
if self.safety.get_cruise_engaged_prev() != prev_panda_cruise_engaged: if not (self.CP.carName == "honda" and self.CP.carFingerprint not in HONDA_BOSCH):# and not self.CP.notCar:
# if self.safety.get_cruise_engaged_prev() != prev_panda_cruise_engaged:
self.assertEqual(CS.cruiseState.enabled, self.safety.get_cruise_engaged_prev()) self.assertEqual(CS.cruiseState.enabled, self.safety.get_cruise_engaged_prev())
if self.CP.carName == "honda": if self.CP.carName == "honda":
if self.safety.get_acc_main_on() != prev_panda_acc_main_on: # if self.safety.get_acc_main_on() != prev_panda_acc_main_on:
self.assertEqual(CS.cruiseState.available, self.safety.get_acc_main_on()) self.assertEqual(CS.cruiseState.available, self.safety.get_acc_main_on())
def test_panda_safety_carstate(self): def test_panda_safety_carstate(self):
""" """
@ -383,73 +386,74 @@ class TestCarModelBase(unittest.TestCase):
for msg in filter(lambda m: m.src in range(64), can.can): for msg in filter(lambda m: m.src in range(64), can.can):
to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat) to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat)
self.safety.safety_rx_hook(to_send) self.safety.safety_rx_hook(to_send)
return
controls_allowed_prev = False
CS_prev = car.CarState.new_message() # controls_allowed_prev = False
checks = defaultdict(lambda: 0) # CS_prev = car.CarState.new_message()
controlsd = Controls(CI=self.CI) # checks = defaultdict(lambda: 0)
controlsd.initialized = True # controlsd = Controls(CI=self.CI)
for idx, can in enumerate(self.can_msgs): # controlsd.initialized = True
CS = self.CI.update(CC, (can.as_builder().to_bytes(), )) # for idx, can in enumerate(self.can_msgs):
for msg in filter(lambda m: m.src in range(64), can.can): # CS = self.CI.update(CC, (can.as_builder().to_bytes(), ))
to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat) # for msg in filter(lambda m: m.src in range(64), can.can):
ret = self.safety.safety_rx_hook(to_send) # to_send = libpanda_py.make_CANPacket(msg.address, msg.src % 4, msg.dat)
self.assertEqual(1, ret, f"safety rx failed ({ret=}): {to_send}") # ret = self.safety.safety_rx_hook(to_send)
# self.assertEqual(1, ret, f"safety rx failed ({ret=}): {to_send}")
# Skip first frame so CS_prev is properly initialized #
if idx == 0: # # Skip first frame so CS_prev is properly initialized
CS_prev = CS # if idx == 0:
# Button may be left pressed in warm up period # CS_prev = CS
if not self.CP.pcmCruise: # # Button may be left pressed in warm up period
self.safety.set_controls_allowed(0) # if not self.CP.pcmCruise:
continue # self.safety.set_controls_allowed(0)
# continue
# TODO: check rest of panda's carstate (steering, ACC main on, etc.) #
# # TODO: check rest of panda's carstate (steering, ACC main on, etc.)
checks['gasPressed'] += CS.gasPressed != self.safety.get_gas_pressed_prev() #
checks['standstill'] += CS.standstill == self.safety.get_vehicle_moving() # checks['gasPressed'] += CS.gasPressed != self.safety.get_gas_pressed_prev()
# checks['standstill'] += CS.standstill == self.safety.get_vehicle_moving()
# TODO: remove this exception once this mismatch is resolved #
brake_pressed = CS.brakePressed # # TODO: remove this exception once this mismatch is resolved
if CS.brakePressed and not self.safety.get_brake_pressed_prev(): # brake_pressed = CS.brakePressed
if self.CP.carFingerprint in (HONDA.PILOT, HONDA.RIDGELINE) and CS.brake > 0.05: # if CS.brakePressed and not self.safety.get_brake_pressed_prev():
brake_pressed = False # if self.CP.carFingerprint in (HONDA.PILOT, HONDA.RIDGELINE) and CS.brake > 0.05:
checks['brakePressed'] += brake_pressed != self.safety.get_brake_pressed_prev() # brake_pressed = False
checks['regenBraking'] += CS.regenBraking != self.safety.get_regen_braking_prev() # checks['brakePressed'] += brake_pressed != self.safety.get_brake_pressed_prev()
# checks['regenBraking'] += CS.regenBraking != self.safety.get_regen_braking_prev()
if self.CP.pcmCruise: #
# On most pcmCruise cars, openpilot's state is always tied to the PCM's cruise state. # if self.CP.pcmCruise:
# On Honda Nidec, we always engage on the rising edge of the PCM cruise state, but # # On most pcmCruise cars, openpilot's state is always tied to the PCM's cruise state.
# openpilot brakes to zero even if the min ACC speed is non-zero (i.e. the PCM disengages). # # On Honda Nidec, we always engage on the rising edge of the PCM cruise state, but
if self.CP.carName == "honda" and self.CP.carFingerprint not in HONDA_BOSCH: # # openpilot brakes to zero even if the min ACC speed is non-zero (i.e. the PCM disengages).
# only the rising edges are expected to match # if self.CP.carName == "honda" and self.CP.carFingerprint not in HONDA_BOSCH:
if CS.cruiseState.enabled and not CS_prev.cruiseState.enabled: # # only the rising edges are expected to match
checks['controlsAllowed'] += not self.safety.get_controls_allowed() # if CS.cruiseState.enabled and not CS_prev.cruiseState.enabled:
else: # checks['controlsAllowed'] += not self.safety.get_controls_allowed()
checks['controlsAllowed'] += not CS.cruiseState.enabled and self.safety.get_controls_allowed() # else:
# checks['controlsAllowed'] += not CS.cruiseState.enabled and self.safety.get_controls_allowed()
# TODO: fix notCar mismatch #
if not self.CP.notCar: # # TODO: fix notCar mismatch
checks['cruiseState'] += CS.cruiseState.enabled != self.safety.get_cruise_engaged_prev() # if not self.CP.notCar:
else: # checks['cruiseState'] += CS.cruiseState.enabled != self.safety.get_cruise_engaged_prev()
# Check for enable events on rising edge of controls allowed # else:
controlsd.update_events(CS) # # Check for enable events on rising edge of controls allowed
controlsd.CS_prev = CS # controlsd.update_events(CS)
button_enable = (any(evt.enable for evt in CS.events) and # controlsd.CS_prev = CS
not any(evt == EventName.pedalPressed for evt in controlsd.events.names)) # button_enable = (any(evt.enable for evt in CS.events) and
mismatch = button_enable != (self.safety.get_controls_allowed() and not controls_allowed_prev) # not any(evt == EventName.pedalPressed for evt in controlsd.events.names))
checks['controlsAllowed'] += mismatch # mismatch = button_enable != (self.safety.get_controls_allowed() and not controls_allowed_prev)
controls_allowed_prev = self.safety.get_controls_allowed() # checks['controlsAllowed'] += mismatch
if button_enable and not mismatch: # controls_allowed_prev = self.safety.get_controls_allowed()
self.safety.set_controls_allowed(False) # if button_enable and not mismatch:
# self.safety.set_controls_allowed(False)
if self.CP.carName == "honda": #
checks['mainOn'] += CS.cruiseState.available != self.safety.get_acc_main_on() # if self.CP.carName == "honda":
# checks['mainOn'] += CS.cruiseState.available != self.safety.get_acc_main_on()
CS_prev = CS #
# CS_prev = CS
failed_checks = {k: v for k, v in checks.items() if v > 0} #
self.assertFalse(len(failed_checks), f"panda safety doesn't agree with openpilot: {failed_checks}") # failed_checks = {k: v for k, v in checks.items() if v > 0}
# self.assertFalse(len(failed_checks), f"panda safety doesn't agree with openpilot: {failed_checks}")
@parameterized_class(('car_model', 'test_route'), get_test_cases()) @parameterized_class(('car_model', 'test_route'), get_test_cases())

Write Preview
Loading…
Cancel
Save