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

Split pandaState into peripheralState and pandaState (#22385)

Browse Source 
* publish peripheralState from boardd

* refactor consumers

* rename thread

* peripheralState has panda type too

* add to process replay

* fix device build

* properly remove hardware unsupported alert

* latest peripheralState

* remove pandaState from thermal_monitor

* put that back

* add back harness check

* fix cloudlog

* needs pandaState

* Update selfdrive/thermald/tests/test_power_monitoring.py

Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>

* dont conflate

* Update selfdrive/thermald/tests/test_power_monitoring.py

Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>

* pigeon is peripheral

* cleanup

* less global

* comment

* move rtc to peripheral_control_thread

* better diff?

* whitespace

* get msg

* bump cereal

Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
pull/22425/head
Willem Melching 4 years ago committed by GitHub
parent 9c771b45fc
commit f4e2537b12
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 227 additions and 202 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. 2
      cereal
  2. 250
      selfdrive/boardd/boardd.cc
  3. 2
      selfdrive/boardd/panda.cc
  4. 2
      selfdrive/boardd/panda.h
  5. 6
      selfdrive/controls/controlsd.py
  6. 4
      selfdrive/controls/lib/alerts_offroad.json
  7. 2
      selfdrive/controls/lib/events.py
  8. 2
      selfdrive/test/process_replay/process_replay.py
  9. 1
      selfdrive/test/test_onroad.py
  10. 35
      selfdrive/thermald/power_monitoring.py
  11. 74
      selfdrive/thermald/tests/test_power_monitoring.py
  12. 49
      selfdrive/thermald/thermald.py

2
cereal

@ -1 +1 @@
Subproject commit ce5ef7a1e5d16b3f6c91f4ac6ca20cba9f4a255c Subproject commit 2881d47cea8b9ee0ba972f1515b13c13af0c0c57

250
selfdrive/boardd/boardd.cc
Unescape View File

@ -40,6 +40,7 @@ std::atomic<bool> ignition(false);
ExitHandler do_exit; ExitHandler do_exit;
std::string get_time_str(const struct tm &time) { std::string get_time_str(const struct tm &time) {
char s[30] = {'\0'}; char s[30] = {'\0'};
std::strftime(s, std::size(s), "%Y-%m-%d %H:%M:%S", &time); std::strftime(s, std::size(s), "%Y-%m-%d %H:%M:%S", &time);
@ -143,7 +144,7 @@ Panda *usb_connect() {
// power on charging, only the first time. Panda can also change mode and it causes a brief disconneciton // power on charging, only the first time. Panda can also change mode and it causes a brief disconneciton
#ifndef __x86_64__ #ifndef __x86_64__
static std::once_flag connected_once; static std::once_flag connected_once;
std::call_once(connected_once, &Panda::set_usb_power_mode, panda, cereal::PandaState::UsbPowerMode::CDP); std::call_once(connected_once, &Panda::set_usb_power_mode, panda, cereal::PeripheralState::UsbPowerMode::CDP);
#endif #endif
if (panda->has_rtc) { if (panda->has_rtc) {
@ -234,6 +235,13 @@ void can_recv_thread(Panda *panda) {
} }
} }
void send_empty_peripheral_state(PubMaster *pm) {
MessageBuilder msg;
auto peripheralState = msg.initEvent().initPeripheralState();
peripheralState.setPandaType(cereal::PandaState::PandaType::UNKNOWN);
pm->send("peripheralState", msg);
}
void send_empty_panda_state(PubMaster *pm) { void send_empty_panda_state(PubMaster *pm) {
MessageBuilder msg; MessageBuilder msg;
auto pandaState = msg.initEvent().initPandaState(); auto pandaState = msg.initEvent().initPandaState();
@ -241,44 +249,113 @@ void send_empty_panda_state(PubMaster *pm) {
pm->send("pandaState", msg); pm->send("pandaState", msg);
} }
void panda_state_thread(PubMaster *pm, Panda *panda, bool spoofing_started) { bool send_panda_state(PubMaster *pm, Panda *panda, bool spoofing_started) {
LOGD("start panda state thread"); health_t pandaState = panda->get_state();
uint32_t no_ignition_cnt = 0;
bool ignition_last = false;
Params params = Params();
// run at 2hz if (spoofing_started) {
while (!do_exit && panda->connected) { pandaState.ignition_line = 1;
health_t pandaState = panda->get_state(); }
if (spoofing_started) { // Make sure CAN buses are live: safety_setter_thread does not work if Panda CAN are silent and there is only one other CAN node
pandaState.ignition_line = 1; if (pandaState.safety_model == (uint8_t)(cereal::CarParams::SafetyModel::SILENT)) {
} panda->set_safety_model(cereal::CarParams::SafetyModel::NO_OUTPUT);
}
// Make sure CAN buses are live: safety_setter_thread does not work if Panda CAN are silent and there is only one other CAN node bool ignition = ((pandaState.ignition_line != 0) || (pandaState.ignition_can != 0));
if (pandaState.safety_model == (uint8_t)(cereal::CarParams::SafetyModel::SILENT)) {
panda->set_safety_model(cereal::CarParams::SafetyModel::NO_OUTPUT);
}
ignition = ((pandaState.ignition_line != 0) || (pandaState.ignition_can != 0)); #ifndef __x86_64__
bool power_save_desired = !ignition;
if (pandaState.power_save_enabled != power_save_desired) {
panda->set_power_saving(power_save_desired);
}
if (ignition) { // set safety mode to NO_OUTPUT when car is off. ELM327 is an alternative if we want to leverage athenad/connect
no_ignition_cnt = 0; if (!ignition && (pandaState.safety_model != (uint8_t)(cereal::CarParams::SafetyModel::NO_OUTPUT))) {
} else { panda->set_safety_model(cereal::CarParams::SafetyModel::NO_OUTPUT);
no_ignition_cnt += 1; }
} #endif
#ifndef __x86_64__ // build msg
bool power_save_desired = !ignition; MessageBuilder msg;
if (pandaState.power_save_enabled != power_save_desired) { auto evt = msg.initEvent();
panda->set_power_saving(power_save_desired); evt.setValid(panda->comms_healthy);
auto ps = evt.initPandaState();
ps.setUptime(pandaState.uptime);
ps.setIgnitionLine(pandaState.ignition_line);
ps.setIgnitionCan(pandaState.ignition_can);
ps.setControlsAllowed(pandaState.controls_allowed);
ps.setGasInterceptorDetected(pandaState.gas_interceptor_detected);
ps.setCanRxErrs(pandaState.can_rx_errs);
ps.setCanSendErrs(pandaState.can_send_errs);
ps.setCanFwdErrs(pandaState.can_fwd_errs);
ps.setGmlanSendErrs(pandaState.gmlan_send_errs);
ps.setPandaType(panda->hw_type);
ps.setSafetyModel(cereal::CarParams::SafetyModel(pandaState.safety_model));
ps.setSafetyParam(pandaState.safety_param);
ps.setFaultStatus(cereal::PandaState::FaultStatus(pandaState.fault_status));
ps.setPowerSaveEnabled((bool)(pandaState.power_save_enabled));
ps.setHeartbeatLost((bool)(pandaState.heartbeat_lost));
ps.setHarnessStatus(cereal::PandaState::HarnessStatus(pandaState.car_harness_status));
// Convert faults bitset to capnp list
std::bitset<sizeof(pandaState.faults) * 8> fault_bits(pandaState.faults);
auto faults = ps.initFaults(fault_bits.count());
size_t i = 0;
for (size_t f = size_t(cereal::PandaState::FaultType::RELAY_MALFUNCTION);
f <= size_t(cereal::PandaState::FaultType::INTERRUPT_RATE_TICK); f++) {
if (fault_bits.test(f)) {
faults.set(i, cereal::PandaState::FaultType(f));
i++;
} }
}
pm->send("pandaState", msg);
return ignition;
}
// set safety mode to NO_OUTPUT when car is off. ELM327 is an alternative if we want to leverage athenad/connect void send_peripheral_state(PubMaster *pm, Panda *panda) {
if (!ignition && (pandaState.safety_model != (uint8_t)(cereal::CarParams::SafetyModel::NO_OUTPUT))) { health_t pandaState = panda->get_state();
panda->set_safety_model(cereal::CarParams::SafetyModel::NO_OUTPUT);
// build msg
MessageBuilder msg;
auto evt = msg.initEvent();
evt.setValid(panda->comms_healthy);
auto ps = evt.initPeripheralState();
ps.setPandaType(panda->hw_type);
if (Hardware::TICI()) {
double read_time = millis_since_boot();
ps.setVoltage(std::atoi(util::read_file("/sys/class/hwmon/hwmon1/in1_input").c_str()));
ps.setCurrent(std::atoi(util::read_file("/sys/class/hwmon/hwmon1/curr1_input").c_str()));
read_time = millis_since_boot() - read_time;
if (read_time > 50) {
LOGW("reading hwmon took %lfms", read_time);
} }
#endif } else {
ps.setVoltage(pandaState.voltage);
ps.setCurrent(pandaState.current);
}
uint16_t fan_speed_rpm = panda->get_fan_speed();
ps.setUsbPowerMode(cereal::PeripheralState::UsbPowerMode(pandaState.usb_power_mode));
ps.setFanSpeedRpm(fan_speed_rpm);
pm->send("peripheralState", msg);
}
void panda_state_thread(PubMaster *pm, Panda * peripheral_panda, Panda *panda, bool spoofing_started) {
Params params;
bool ignition_last = false;
LOGD("start panda state thread");
// run at 2hz
while (!do_exit && panda->connected) {
send_peripheral_state(pm, peripheral_panda);
ignition = send_panda_state(pm, panda, spoofing_started);
// clear VIN, CarParams, and set new safety on car start // clear VIN, CarParams, and set new safety on car start
if (ignition && !ignition_last) { if (ignition && !ignition_last) {
@ -294,87 +371,16 @@ void panda_state_thread(PubMaster *pm, Panda *panda, bool spoofing_started) {
params.clearAll(CLEAR_ON_IGNITION_OFF); params.clearAll(CLEAR_ON_IGNITION_OFF);
} }
// Write to rtc once per minute when no ignition present
if ((panda->has_rtc) && !ignition && (no_ignition_cnt % 120 == 1)) {
// Write time to RTC if it looks reasonable
setenv("TZ","UTC",1);
struct tm sys_time = util::get_time();
if (util::time_valid(sys_time)) {
struct tm rtc_time = panda->get_rtc();
double seconds = difftime(mktime(&rtc_time), mktime(&sys_time));
if (std::abs(seconds) > 1.1) {
panda->set_rtc(sys_time);
LOGW("Updating panda RTC. dt = %.2f System: %s RTC: %s",
seconds, get_time_str(sys_time).c_str(), get_time_str(rtc_time).c_str());
}
}
}
ignition_last = ignition; ignition_last = ignition;
uint16_t fan_speed_rpm = panda->get_fan_speed();
// build msg
MessageBuilder msg;
auto evt = msg.initEvent();
evt.setValid(panda->comms_healthy);
auto ps = evt.initPandaState();
ps.setUptime(pandaState.uptime);
if (Hardware::TICI()) {
double read_time = millis_since_boot();
ps.setVoltage(std::atoi(util::read_file("/sys/class/hwmon/hwmon1/in1_input").c_str()));
ps.setCurrent(std::atoi(util::read_file("/sys/class/hwmon/hwmon1/curr1_input").c_str()));
read_time = millis_since_boot() - read_time;
if (read_time > 50) {
LOGW("reading hwmon took %lfms", read_time);
}
} else {
ps.setVoltage(pandaState.voltage);
ps.setCurrent(pandaState.current);
}
ps.setIgnitionLine(pandaState.ignition_line);
ps.setIgnitionCan(pandaState.ignition_can);
ps.setControlsAllowed(pandaState.controls_allowed);
ps.setGasInterceptorDetected(pandaState.gas_interceptor_detected);
ps.setHasGps(true);
ps.setCanRxErrs(pandaState.can_rx_errs);
ps.setCanSendErrs(pandaState.can_send_errs);
ps.setCanFwdErrs(pandaState.can_fwd_errs);
ps.setGmlanSendErrs(pandaState.gmlan_send_errs);
ps.setPandaType(panda->hw_type);
ps.setUsbPowerMode(cereal::PandaState::UsbPowerMode(pandaState.usb_power_mode));
ps.setSafetyModel(cereal::CarParams::SafetyModel(pandaState.safety_model));
ps.setSafetyParam(pandaState.safety_param);
ps.setFanSpeedRpm(fan_speed_rpm);
ps.setFaultStatus(cereal::PandaState::FaultStatus(pandaState.fault_status));
ps.setPowerSaveEnabled((bool)(pandaState.power_save_enabled));
ps.setHeartbeatLost((bool)(pandaState.heartbeat_lost));
ps.setHarnessStatus(cereal::PandaState::HarnessStatus(pandaState.car_harness_status));
// Convert faults bitset to capnp list
std::bitset<sizeof(pandaState.faults) * 8> fault_bits(pandaState.faults);
auto faults = ps.initFaults(fault_bits.count());
size_t i = 0;
for (size_t f = size_t(cereal::PandaState::FaultType::RELAY_MALFUNCTION);
f <= size_t(cereal::PandaState::FaultType::INTERRUPT_RATE_TICK); f++) {
if (fault_bits.test(f)) {
faults.set(i, cereal::PandaState::FaultType(f));
i++;
}
}
pm->send("pandaState", msg);
panda->send_heartbeat(); panda->send_heartbeat();
util::sleep_for(500); util::sleep_for(500);
} }
} }
void hardware_control_thread(Panda *panda) {
LOGD("start hardware control thread"); void peripheral_control_thread(Panda *panda) {
LOGD("start peripheral control thread");
SubMaster sm({"deviceState", "driverCameraState"}); SubMaster sm({"deviceState", "driverCameraState"});
uint64_t last_front_frame_t = 0; uint64_t last_front_frame_t = 0;
@ -395,10 +401,10 @@ void hardware_control_thread(Panda *panda) {
bool charging_disabled = sm["deviceState"].getDeviceState().getChargingDisabled(); bool charging_disabled = sm["deviceState"].getDeviceState().getChargingDisabled();
if (charging_disabled != prev_charging_disabled) { if (charging_disabled != prev_charging_disabled) {
if (charging_disabled) { if (charging_disabled) {
panda->set_usb_power_mode(cereal::PandaState::UsbPowerMode::CLIENT); panda->set_usb_power_mode(cereal::PeripheralState::UsbPowerMode::CLIENT);
LOGW("TURN OFF CHARGING!\n"); LOGW("TURN OFF CHARGING!\n");
} else { } else {
panda->set_usb_power_mode(cereal::PandaState::UsbPowerMode::CDP); panda->set_usb_power_mode(cereal::PeripheralState::UsbPowerMode::CDP);
LOGW("TURN ON CHARGING!\n"); LOGW("TURN ON CHARGING!\n");
} }
prev_charging_disabled = charging_disabled; prev_charging_disabled = charging_disabled;
@ -444,6 +450,23 @@ void hardware_control_thread(Panda *panda) {
prev_ir_pwr = ir_pwr; prev_ir_pwr = ir_pwr;
} }
// Write to rtc once per minute when no ignition present
if ((panda->has_rtc) && !ignition && (cnt % 120 == 1)) {
// Write time to RTC if it looks reasonable
setenv("TZ","UTC",1);
struct tm sys_time = util::get_time();
if (util::time_valid(sys_time)) {
struct tm rtc_time = panda->get_rtc();
double seconds = difftime(mktime(&rtc_time), mktime(&sys_time));
if (std::abs(seconds) > 1.1) {
panda->set_rtc(sys_time);
LOGW("Updating panda RTC. dt = %.2f System: %s RTC: %s",
seconds, get_time_str(sys_time).c_str(), get_time_str(rtc_time).c_str());
}
}
}
} }
} }
@ -538,14 +561,16 @@ int main() {
LOG("set affinity returns %d", err); LOG("set affinity returns %d", err);
LOGW("attempting to connect"); LOGW("attempting to connect");
PubMaster pm({"pandaState"}); PubMaster pm({"pandaState", "peripheralState"});
while (!do_exit) { while (!do_exit) {
Panda *panda = usb_connect(); Panda *panda = usb_connect();
Panda *peripheral_panda = panda;
// Send empty pandaState and try again // Send empty pandaState & peripheralState and try again
if (panda == nullptr) { if (panda == nullptr || peripheral_panda == nullptr) {
send_empty_panda_state(&pm); send_empty_panda_state(&pm);
send_empty_peripheral_state(&pm);
util::sleep_for(500); util::sleep_for(500);
continue; continue;
} }
@ -553,11 +578,12 @@ int main() {
LOGW("connected to board"); LOGW("connected to board");
std::vector<std::thread> threads; std::vector<std::thread> threads;
threads.emplace_back(panda_state_thread, &pm, panda, getenv("STARTED") != nullptr); threads.emplace_back(panda_state_thread, &pm, peripheral_panda, panda, getenv("STARTED") != nullptr);
threads.emplace_back(peripheral_control_thread, peripheral_panda);
threads.emplace_back(pigeon_thread, peripheral_panda);
threads.emplace_back(can_send_thread, panda, getenv("FAKESEND") != nullptr); threads.emplace_back(can_send_thread, panda, getenv("FAKESEND") != nullptr);
threads.emplace_back(can_recv_thread, panda); threads.emplace_back(can_recv_thread, panda);
threads.emplace_back(hardware_control_thread, panda);
threads.emplace_back(pigeon_thread, panda);
for (auto &t : threads) t.join(); for (auto &t : threads) t.join();

2
selfdrive/boardd/panda.cc
Unescape View File

@ -333,7 +333,7 @@ void Panda::set_power_saving(bool power_saving) {
usb_write(0xe7, power_saving, 0); usb_write(0xe7, power_saving, 0);
} }
void Panda::set_usb_power_mode(cereal::PandaState::UsbPowerMode power_mode) { void Panda::set_usb_power_mode(cereal::PeripheralState::UsbPowerMode power_mode) {
usb_write(0xe6, (uint16_t)power_mode, 0); usb_write(0xe6, (uint16_t)power_mode, 0);
} }

2
selfdrive/boardd/panda.h
Unescape View File

@ -81,7 +81,7 @@ class Panda {
std::optional<std::vector<uint8_t>> get_firmware_version(); std::optional<std::vector<uint8_t>> get_firmware_version();
std::optional<std::string> get_serial(); std::optional<std::string> get_serial();
void set_power_saving(bool power_saving); void set_power_saving(bool power_saving);
void set_usb_power_mode(cereal::PandaState::UsbPowerMode power_mode); void set_usb_power_mode(cereal::PeripheralState::UsbPowerMode power_mode);
void send_heartbeat(); void send_heartbeat();
void can_send(capnp::List<cereal::CanData>::Reader can_data_list); void can_send(capnp::List<cereal::CanData>::Reader can_data_list);
int can_receive(kj::Array<capnp::word>& out_buf); int can_receive(kj::Array<capnp::word>& out_buf);

6
selfdrive/controls/controlsd.py
Unescape View File

@ -72,7 +72,7 @@ class Controls:
self.sm = sm self.sm = sm
if self.sm is None: if self.sm is None:
ignore = ['driverCameraState', 'managerState'] if SIMULATION else None ignore = ['driverCameraState', 'managerState'] if SIMULATION else None
self.sm = messaging.SubMaster(['deviceState', 'pandaState', 'modelV2', 'liveCalibration', self.sm = messaging.SubMaster(['deviceState', 'pandaState', 'peripheralState', 'modelV2', 'liveCalibration',
'driverMonitoringState', 'longitudinalPlan', 'lateralPlan', 'liveLocationKalman', 'driverMonitoringState', 'longitudinalPlan', 'lateralPlan', 'liveLocationKalman',
'managerState', 'liveParameters', 'radarState'] + self.camera_packets + joystick_packet, 'managerState', 'liveParameters', 'radarState'] + self.camera_packets + joystick_packet,
ignore_alive=ignore, ignore_avg_freq=['radarState', 'longitudinalPlan']) ignore_alive=ignore, ignore_avg_freq=['radarState', 'longitudinalPlan'])
@ -207,8 +207,8 @@ class Controls:
self.events.add(EventName.highCpuUsage) self.events.add(EventName.highCpuUsage)
# Alert if fan isn't spinning for 5 seconds # Alert if fan isn't spinning for 5 seconds
if self.sm['pandaState'].pandaType in [PandaType.uno, PandaType.dos]: if self.sm['peripheralState'].pandaType in [PandaType.uno, PandaType.dos]:
if self.sm['pandaState'].fanSpeedRpm == 0 and self.sm['deviceState'].fanSpeedPercentDesired > 50: if self.sm['peripheralState'].fanSpeedRpm == 0 and self.sm['deviceState'].fanSpeedPercentDesired > 50:
if (self.sm.frame - self.last_functional_fan_frame) * DT_CTRL > 5.0: if (self.sm.frame - self.last_functional_fan_frame) * DT_CTRL > 5.0:
self.events.add(EventName.fanMalfunction) self.events.add(EventName.fanMalfunction)
else: else:

4
selfdrive/controls/lib/alerts_offroad.json
Unescape View File

@ -37,10 +37,6 @@
"text": "An update to your device's operating system is downloading in the background. You will be prompted to update when it's ready to install.", "text": "An update to your device's operating system is downloading in the background. You will be prompted to update when it's ready to install.",
"severity": 0 "severity": 0
}, },
"Offroad_HardwareUnsupported": {
"text": "White and grey panda are unsupported. Upgrade to comma two or black panda.",
"severity": 0
},
"Offroad_UnofficialHardware": { "Offroad_UnofficialHardware": {
"text": "Device failed to register. It will not connect to or upload to comma.ai servers, and receives no support from comma.ai. If this is an official device, contact support@comma.ai.", "text": "Device failed to register. It will not connect to or upload to comma.ai servers, and receives no support from comma.ai. If this is an official device, contact support@comma.ai.",
"severity": 1 "severity": 1

2
selfdrive/controls/lib/events.py
Unescape View File

@ -204,7 +204,7 @@ def calibration_incomplete_alert(CP: car.CarParams, sm: messaging.SubMaster, met
def no_gps_alert(CP: car.CarParams, sm: messaging.SubMaster, metric: bool) -> Alert: def no_gps_alert(CP: car.CarParams, sm: messaging.SubMaster, metric: bool) -> Alert:
gps_integrated = sm['pandaState'].pandaType in [log.PandaState.PandaType.uno, log.PandaState.PandaType.dos] gps_integrated = sm['peripheralState'].pandaType in [log.PandaState.PandaType.uno, log.PandaState.PandaType.dos]
return Alert( return Alert(
"Poor GPS reception", "Poor GPS reception",
"If sky is visible, contact support" if gps_integrated else "Check GPS antenna placement", "If sky is visible, contact support" if gps_integrated else "Check GPS antenna placement",

2
selfdrive/test/process_replay/process_replay.py
Unescape View File

@ -240,7 +240,7 @@ CONFIGS = [
proc_name="controlsd", proc_name="controlsd",
pub_sub={ pub_sub={
"can": ["controlsState", "carState", "carControl", "sendcan", "carEvents", "carParams"], "can": ["controlsState", "carState", "carControl", "sendcan", "carEvents", "carParams"],
"deviceState": [], "pandaState": [], "liveCalibration": [], "driverMonitoringState": [], "longitudinalPlan": [], "lateralPlan": [], "liveLocationKalman": [], "liveParameters": [], "radarState": [], "deviceState": [], "pandaState": [], "peripheralState": [], "liveCalibration": [], "driverMonitoringState": [], "longitudinalPlan": [], "lateralPlan": [], "liveLocationKalman": [], "liveParameters": [], "radarState": [],
"modelV2": [], "driverCameraState": [], "roadCameraState": [], "ubloxRaw": [], "managerState": [], "modelV2": [], "driverCameraState": [], "roadCameraState": [], "ubloxRaw": [], "managerState": [],
}, },
ignore=["logMonoTime", "valid", "controlsState.startMonoTime", "controlsState.cumLagMs"], ignore=["logMonoTime", "valid", "controlsState.startMonoTime", "controlsState.cumLagMs"],

1
selfdrive/test/test_onroad.py
Unescape View File

@ -66,6 +66,7 @@ TIMINGS = {
# rtols: max/min, rsd # rtols: max/min, rsd
"can": [2.5, 0.35], "can": [2.5, 0.35],
"pandaState": [2.5, 0.35], "pandaState": [2.5, 0.35],
"peripheralState": [2.5, 0.35],
"sendcan": [2.5, 0.35], "sendcan": [2.5, 0.35],
"carState": [2.5, 0.35], "carState": [2.5, 0.35],
"carControl": [2.5, 0.35], "carControl": [2.5, 0.35],

35
selfdrive/thermald/power_monitoring.py
Unescape View File

@ -28,8 +28,8 @@ class PowerMonitoring:
self.last_save_time = 0 # Used for saving current value in a param self.last_save_time = 0 # Used for saving current value in a param
self.power_used_uWh = 0 # Integrated power usage in uWh since going into offroad self.power_used_uWh = 0 # Integrated power usage in uWh since going into offroad
self.next_pulsed_measurement_time = None self.next_pulsed_measurement_time = None
self.car_voltage_mV = 12e3 # Low-passed version of pandaState voltage self.car_voltage_mV = 12e3 # Low-passed version of peripheralState voltage
self.car_voltage_instant_mV = 12e3 # Last value of pandaState voltage self.car_voltage_instant_mV = 12e3 # Last value of peripheralState voltage
self.integration_lock = threading.Lock() self.integration_lock = threading.Lock()
car_battery_capacity_uWh = self.params.get("CarBatteryCapacity") car_battery_capacity_uWh = self.params.get("CarBatteryCapacity")
@ -39,14 +39,13 @@ class PowerMonitoring:
# Reset capacity if it's low # Reset capacity if it's low
self.car_battery_capacity_uWh = max((CAR_BATTERY_CAPACITY_uWh / 10), int(car_battery_capacity_uWh)) self.car_battery_capacity_uWh = max((CAR_BATTERY_CAPACITY_uWh / 10), int(car_battery_capacity_uWh))
# Calculation tick # Calculation tick
def calculate(self, pandaState): def calculate(self, peripheralState, ignition):
try: try:
now = sec_since_boot() now = sec_since_boot()
# If pandaState is None, we're probably not in a car, so we don't care # If peripheralState is None, we're probably not in a car, so we don't care
if pandaState is None or pandaState.pandaState.pandaType == log.PandaState.PandaType.unknown: if peripheralState is None or peripheralState.pandaType == log.PandaState.PandaType.unknown:
with self.integration_lock: with self.integration_lock:
self.last_measurement_time = None self.last_measurement_time = None
self.next_pulsed_measurement_time = None self.next_pulsed_measurement_time = None
@ -54,8 +53,8 @@ class PowerMonitoring:
return return
# Low-pass battery voltage # Low-pass battery voltage
self.car_voltage_instant_mV = pandaState.pandaState.voltage self.car_voltage_instant_mV = peripheralState.voltage
self.car_voltage_mV = ((pandaState.pandaState.voltage * CAR_VOLTAGE_LOW_PASS_K) + (self.car_voltage_mV * (1 - CAR_VOLTAGE_LOW_PASS_K))) self.car_voltage_mV = ((peripheralState.voltage * CAR_VOLTAGE_LOW_PASS_K) + (self.car_voltage_mV * (1 - CAR_VOLTAGE_LOW_PASS_K)))
# Cap the car battery power and save it in a param every 10-ish seconds # Cap the car battery power and save it in a param every 10-ish seconds
self.car_battery_capacity_uWh = max(self.car_battery_capacity_uWh, 0) self.car_battery_capacity_uWh = max(self.car_battery_capacity_uWh, 0)
@ -70,7 +69,7 @@ class PowerMonitoring:
self.last_measurement_time = now self.last_measurement_time = now
return return
if (pandaState.pandaState.ignitionLine or pandaState.pandaState.ignitionCan): if ignition:
# If there is ignition, we integrate the charging rate of the car # If there is ignition, we integrate the charging rate of the car
with self.integration_lock: with self.integration_lock:
self.power_used_uWh = 0 self.power_used_uWh = 0
@ -81,7 +80,7 @@ class PowerMonitoring:
self.last_measurement_time = now self.last_measurement_time = now
else: else:
# No ignition, we integrate the offroad power used by the device # No ignition, we integrate the offroad power used by the device
is_uno = pandaState.pandaState.pandaType == log.PandaState.PandaType.uno is_uno = peripheralState.pandaType == log.PandaState.PandaType.uno
# Get current power draw somehow # Get current power draw somehow
current_power = HARDWARE.get_current_power_draw() # pylint: disable=assignment-from-none current_power = HARDWARE.get_current_power_draw() # pylint: disable=assignment-from-none
if current_power is not None: if current_power is not None:
@ -158,8 +157,8 @@ class PowerMonitoring:
return int(self.car_battery_capacity_uWh) return int(self.car_battery_capacity_uWh)
# See if we need to disable charging # See if we need to disable charging
def should_disable_charging(self, pandaState, offroad_timestamp): def should_disable_charging(self, ignition, in_car, offroad_timestamp):
if pandaState is None or offroad_timestamp is None: if offroad_timestamp is None:
return False return False
now = sec_since_boot() now = sec_since_boot()
@ -167,24 +166,24 @@ class PowerMonitoring:
disable_charging |= (now - offroad_timestamp) > MAX_TIME_OFFROAD_S disable_charging |= (now - offroad_timestamp) > MAX_TIME_OFFROAD_S
disable_charging |= (self.car_voltage_mV < (VBATT_PAUSE_CHARGING * 1e3)) and (self.car_voltage_instant_mV > (VBATT_INSTANT_PAUSE_CHARGING * 1e3)) disable_charging |= (self.car_voltage_mV < (VBATT_PAUSE_CHARGING * 1e3)) and (self.car_voltage_instant_mV > (VBATT_INSTANT_PAUSE_CHARGING * 1e3))
disable_charging |= (self.car_battery_capacity_uWh <= 0) disable_charging |= (self.car_battery_capacity_uWh <= 0)
disable_charging &= (not pandaState.pandaState.ignitionLine and not pandaState.pandaState.ignitionCan) disable_charging &= not ignition
disable_charging &= (not self.params.get_bool("DisablePowerDown")) disable_charging &= (not self.params.get_bool("DisablePowerDown"))
disable_charging &= (pandaState.pandaState.harnessStatus != log.PandaState.HarnessStatus.notConnected) disable_charging &= in_car
disable_charging |= self.params.get_bool("ForcePowerDown") disable_charging |= self.params.get_bool("ForcePowerDown")
return disable_charging return disable_charging
# See if we need to shutdown # See if we need to shutdown
def should_shutdown(self, pandaState, offroad_timestamp, started_seen): def should_shutdown(self, peripheralState, ignition, in_car, offroad_timestamp, started_seen):
if pandaState is None or offroad_timestamp is None: if offroad_timestamp is None:
return False return False
now = sec_since_boot() now = sec_since_boot()
panda_charging = (pandaState.pandaState.usbPowerMode != log.PandaState.UsbPowerMode.client) panda_charging = (peripheralState.usbPowerMode != log.PeripheralState.UsbPowerMode.client)
BATT_PERC_OFF = 10 BATT_PERC_OFF = 10
should_shutdown = False should_shutdown = False
# Wait until we have shut down charging before powering down # Wait until we have shut down charging before powering down
should_shutdown |= (not panda_charging and self.should_disable_charging(pandaState, offroad_timestamp)) should_shutdown |= (not panda_charging and self.should_disable_charging(ignition, in_car, offroad_timestamp))
should_shutdown |= ((HARDWARE.get_battery_capacity() < BATT_PERC_OFF) and (not HARDWARE.get_battery_charging()) and ((now - offroad_timestamp) > 60)) should_shutdown |= ((HARDWARE.get_battery_capacity() < BATT_PERC_OFF) and (not HARDWARE.get_battery_charging()) and ((now - offroad_timestamp) > 60))
should_shutdown &= started_seen or (now > MIN_ON_TIME_S) should_shutdown &= started_seen or (now > MIN_ON_TIME_S)
return should_shutdown return should_shutdown

74
selfdrive/thermald/tests/test_power_monitoring.py
Unescape View File

@ -37,20 +37,17 @@ class TestPowerMonitoring(unittest.TestCase):
params.delete("CarBatteryCapacity") params.delete("CarBatteryCapacity")
params.delete("DisablePowerDown") params.delete("DisablePowerDown")
def mock_pandaState(self, ignition, hw_type, car_voltage=12, harness_status=log.PandaState.HarnessStatus.normal): def mock_peripheralState(self, hw_type, car_voltage=12):
pandaState = messaging.new_message('pandaState') ps = messaging.new_message('peripheralState').peripheralState
pandaState.pandaState.pandaType = hw_type ps.pandaType = hw_type
pandaState.pandaState.voltage = car_voltage * 1e3 ps.voltage = car_voltage * 1e3
pandaState.pandaState.ignitionLine = ignition return ps
pandaState.pandaState.ignitionCan = False
pandaState.pandaState.harnessStatus = harness_status
return pandaState
# Test to see that it doesn't do anything when pandaState is None # Test to see that it doesn't do anything when pandaState is None
def test_pandaState_present(self): def test_pandaState_present(self):
pm = PowerMonitoring() pm = PowerMonitoring()
for _ in range(10): for _ in range(10):
pm.calculate(None) pm.calculate(None, None)
self.assertEqual(pm.get_power_used(), 0) self.assertEqual(pm.get_power_used(), 0)
self.assertEqual(pm.get_car_battery_capacity(), (CAR_BATTERY_CAPACITY_uWh / 10)) self.assertEqual(pm.get_car_battery_capacity(), (CAR_BATTERY_CAPACITY_uWh / 10))
@ -59,7 +56,7 @@ class TestPowerMonitoring(unittest.TestCase):
def test_offroad_ignition(self, hw_type): def test_offroad_ignition(self, hw_type):
pm = PowerMonitoring() pm = PowerMonitoring()
for _ in range(10): for _ in range(10):
pm.calculate(self.mock_pandaState(True, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), True)
self.assertEqual(pm.get_power_used(), 0) self.assertEqual(pm.get_power_used(), 0)
# Test to see that it integrates with discharging battery # Test to see that it integrates with discharging battery
@ -71,7 +68,7 @@ class TestPowerMonitoring(unittest.TestCase):
pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None): pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None):
pm = PowerMonitoring() pm = PowerMonitoring()
for _ in range(TEST_DURATION_S + 1): for _ in range(TEST_DURATION_S + 1):
pm.calculate(self.mock_pandaState(False, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), False)
expected_power_usage = ((TEST_DURATION_S/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6) expected_power_usage = ((TEST_DURATION_S/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6)
self.assertLess(abs(pm.get_power_used() - expected_power_usage), 10) self.assertLess(abs(pm.get_power_used() - expected_power_usage), 10)
@ -85,7 +82,7 @@ class TestPowerMonitoring(unittest.TestCase):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = 0 pm.car_battery_capacity_uWh = 0
for _ in range(TEST_DURATION_S + 1): for _ in range(TEST_DURATION_S + 1):
pm.calculate(self.mock_pandaState(True, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), True)
expected_capacity = ((TEST_DURATION_S/3600) * CAR_CHARGING_RATE_W * 1e6) expected_capacity = ((TEST_DURATION_S/3600) * CAR_CHARGING_RATE_W * 1e6)
self.assertLess(abs(pm.get_car_battery_capacity() - expected_capacity), 10) self.assertLess(abs(pm.get_car_battery_capacity() - expected_capacity), 10)
@ -99,7 +96,7 @@ class TestPowerMonitoring(unittest.TestCase):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh - 1000 pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh - 1000
for _ in range(TEST_DURATION_S + 1): for _ in range(TEST_DURATION_S + 1):
pm.calculate(self.mock_pandaState(True, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), True)
estimated_capacity = CAR_BATTERY_CAPACITY_uWh + (CAR_CHARGING_RATE_W / 3600 * 1e6) estimated_capacity = CAR_BATTERY_CAPACITY_uWh + (CAR_CHARGING_RATE_W / 3600 * 1e6)
self.assertLess(abs(pm.get_car_battery_capacity() - estimated_capacity), 10) self.assertLess(abs(pm.get_car_battery_capacity() - estimated_capacity), 10)
@ -113,7 +110,7 @@ class TestPowerMonitoring(unittest.TestCase):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
for _ in range(TEST_DURATION_S + 1): for _ in range(TEST_DURATION_S + 1):
pm.calculate(self.mock_pandaState(False, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), False)
expected_capacity = CAR_BATTERY_CAPACITY_uWh - ((TEST_DURATION_S/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6) expected_capacity = CAR_BATTERY_CAPACITY_uWh - ((TEST_DURATION_S/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6)
self.assertLess(abs(pm.get_car_battery_capacity() - expected_capacity), 10) self.assertLess(abs(pm.get_car_battery_capacity() - expected_capacity), 10)
@ -127,7 +124,7 @@ class TestPowerMonitoring(unittest.TestCase):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = 1000 pm.car_battery_capacity_uWh = 1000
for _ in range(TEST_DURATION_S + 1): for _ in range(TEST_DURATION_S + 1):
pm.calculate(self.mock_pandaState(False, hw_type)) pm.calculate(self.mock_peripheralState(hw_type), False)
estimated_capacity = 0 - ((1/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6) estimated_capacity = 0 - ((1/3600) * (BATT_VOLTAGE * BATT_CURRENT) * 1e6)
self.assertLess(abs(pm.get_car_battery_capacity() - estimated_capacity), 10) self.assertLess(abs(pm.get_car_battery_capacity() - estimated_capacity), 10)
@ -143,12 +140,13 @@ class TestPowerMonitoring(unittest.TestCase):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
start_time = ssb start_time = ssb
pandaState = self.mock_pandaState(False, hw_type) ignition = False
peripheralState = self.mock_peripheralState(hw_type)
while ssb <= start_time + MOCKED_MAX_OFFROAD_TIME: while ssb <= start_time + MOCKED_MAX_OFFROAD_TIME:
pm.calculate(pandaState) pm.calculate(peripheralState, ignition)
if (ssb - start_time) % 1000 == 0 and ssb < start_time + MOCKED_MAX_OFFROAD_TIME: if (ssb - start_time) % 1000 == 0 and ssb < start_time + MOCKED_MAX_OFFROAD_TIME:
self.assertFalse(pm.should_disable_charging(pandaState, start_time)) self.assertFalse(pm.should_disable_charging(ignition, True, start_time))
self.assertTrue(pm.should_disable_charging(pandaState, start_time)) self.assertTrue(pm.should_disable_charging(ignition, True, start_time))
# Test to check policy of stopping charging when the car voltage is too low # Test to check policy of stopping charging when the car voltage is too low
@parameterized.expand(ALL_PANDA_TYPES) @parameterized.expand(ALL_PANDA_TYPES)
@ -160,12 +158,13 @@ class TestPowerMonitoring(unittest.TestCase):
pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None): pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
pandaState = self.mock_pandaState(False, hw_type, car_voltage=(VBATT_PAUSE_CHARGING - 1)) ignition = False
peripheralState = self.mock_peripheralState(hw_type, car_voltage=(VBATT_PAUSE_CHARGING - 1))
for i in range(TEST_TIME): for i in range(TEST_TIME):
pm.calculate(pandaState) pm.calculate(peripheralState, ignition)
if i % 10 == 0: if i % 10 == 0:
self.assertEqual(pm.should_disable_charging(pandaState, ssb), (pm.car_voltage_mV < VBATT_PAUSE_CHARGING*1e3)) self.assertEqual(pm.should_disable_charging(ignition, True, ssb), (pm.car_voltage_mV < VBATT_PAUSE_CHARGING*1e3))
self.assertTrue(pm.should_disable_charging(pandaState, ssb)) self.assertTrue(pm.should_disable_charging(ignition, True, ssb))
# Test to check policy of not stopping charging when DisablePowerDown is set # Test to check policy of not stopping charging when DisablePowerDown is set
def test_disable_power_down(self): def test_disable_power_down(self):
@ -177,12 +176,13 @@ class TestPowerMonitoring(unittest.TestCase):
pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None): pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
pandaState = self.mock_pandaState(False, log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1)) ignition = False
peripheralState = self.mock_peripheralState(log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1))
for i in range(TEST_TIME): for i in range(TEST_TIME):
pm.calculate(pandaState) pm.calculate(peripheralState, ignition)
if i % 10 == 0: if i % 10 == 0:
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, True, ssb))
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, True, ssb))
# Test to check policy of not stopping charging when ignition # Test to check policy of not stopping charging when ignition
def test_ignition(self): def test_ignition(self):
@ -193,12 +193,13 @@ class TestPowerMonitoring(unittest.TestCase):
pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None): pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
pandaState = self.mock_pandaState(True, log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1)) ignition = True
peripheralState = self.mock_peripheralState(log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1))
for i in range(TEST_TIME): for i in range(TEST_TIME):
pm.calculate(pandaState) pm.calculate(peripheralState, ignition)
if i % 10 == 0: if i % 10 == 0:
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, True, ssb))
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, True, ssb))
# Test to check policy of not stopping charging when harness is not connected # Test to check policy of not stopping charging when harness is not connected
def test_harness_connection(self): def test_harness_connection(self):
@ -209,13 +210,14 @@ class TestPowerMonitoring(unittest.TestCase):
pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None): pm_patch("HARDWARE.get_battery_status", "Discharging"), pm_patch("HARDWARE.get_current_power_draw", None):
pm = PowerMonitoring() pm = PowerMonitoring()
pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh pm.car_battery_capacity_uWh = CAR_BATTERY_CAPACITY_uWh
pandaState = self.mock_pandaState(False, log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1),
harness_status=log.PandaState.HarnessStatus.notConnected) ignition = False
peripheralState = self.mock_peripheralState(log.PandaState.PandaType.uno, car_voltage=(VBATT_PAUSE_CHARGING - 1))
for i in range(TEST_TIME): for i in range(TEST_TIME):
pm.calculate(pandaState) pm.calculate(peripheralState, ignition)
if i % 10 == 0: if i % 10 == 0:
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, False,ssb))
self.assertFalse(pm.should_disable_charging(pandaState, ssb)) self.assertFalse(pm.should_disable_charging(ignition, False, ssb))
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

49
selfdrive/thermald/thermald.py
Unescape View File

@ -155,8 +155,7 @@ def thermald_thread():
pandaState_timeout = int(1000 * 2.5 * DT_TRML) # 2.5x the expected pandaState frequency pandaState_timeout = int(1000 * 2.5 * DT_TRML) # 2.5x the expected pandaState frequency
pandaState_sock = messaging.sub_sock('pandaState', timeout=pandaState_timeout) pandaState_sock = messaging.sub_sock('pandaState', timeout=pandaState_timeout)
location_sock = messaging.sub_sock('gpsLocationExternal') sm = messaging.SubMaster(["peripheralState", "gpsLocationExternal", "managerState"])
managerState_sock = messaging.sub_sock('managerState', conflate=True)
fan_speed = 0 fan_speed = 0
count = 0 count = 0
@ -184,6 +183,7 @@ def thermald_thread():
temp_filter = FirstOrderFilter(0., TEMP_TAU, DT_TRML) temp_filter = FirstOrderFilter(0., TEMP_TAU, DT_TRML)
pandaState_prev = None pandaState_prev = None
should_start_prev = False should_start_prev = False
in_car = False
handle_fan = None handle_fan = None
is_uno = False is_uno = False
ui_running_prev = False ui_running_prev = False
@ -202,15 +202,19 @@ def thermald_thread():
if params.get_bool("IsOnroad"): if params.get_bool("IsOnroad"):
params.put_bool("BootedOnroad", True) params.put_bool("BootedOnroad", True)
while 1: while True:
pandaState = messaging.recv_sock(pandaState_sock, wait=True) pandaState = messaging.recv_sock(pandaState_sock, wait=True)
sm.update(0)
peripheralState = sm['peripheralState']
msg = read_thermal(thermal_config) msg = read_thermal(thermal_config)
if pandaState is not None: if pandaState is not None:
usb_power = pandaState.pandaState.usbPowerMode != log.PandaState.UsbPowerMode.client pandaState = pandaState.pandaState
# If we lose connection to the panda, wait 5 seconds before going offroad # If we lose connection to the panda, wait 5 seconds before going offroad
if pandaState.pandaState.pandaType == log.PandaState.PandaType.unknown: if pandaState.pandaType == log.PandaState.PandaType.unknown:
no_panda_cnt += 1 no_panda_cnt += 1
if no_panda_cnt > DISCONNECT_TIMEOUT / DT_TRML: if no_panda_cnt > DISCONNECT_TIMEOUT / DT_TRML:
if startup_conditions["ignition"]: if startup_conditions["ignition"]:
@ -218,15 +222,14 @@ def thermald_thread():
startup_conditions["ignition"] = False startup_conditions["ignition"] = False
else: else:
no_panda_cnt = 0 no_panda_cnt = 0
startup_conditions["ignition"] = pandaState.pandaState.ignitionLine or pandaState.pandaState.ignitionCan startup_conditions["ignition"] = pandaState.ignitionLine or pandaState.ignitionCan
startup_conditions["hardware_supported"] = pandaState.pandaState.pandaType not in [log.PandaState.PandaType.whitePanda, in_car = pandaState.harnessStatus != log.PandaState.HarnessStatus.notConnected
log.PandaState.PandaType.greyPanda] usb_power = peripheralState.usbPowerMode != log.PeripheralState.UsbPowerMode.client
set_offroad_alert_if_changed("Offroad_HardwareUnsupported", not startup_conditions["hardware_supported"])
# Setup fan handler on first connect to panda # Setup fan handler on first connect to panda
if handle_fan is None and pandaState.pandaState.pandaType != log.PandaState.PandaType.unknown: if handle_fan is None and peripheralState.pandaType != log.PandaState.PandaType.unknown:
is_uno = pandaState.pandaState.pandaType == log.PandaState.PandaType.uno is_uno = peripheralState.pandaType == log.PandaState.PandaType.uno
if TICI: if TICI:
cloudlog.info("Setting up TICI fan handler") cloudlog.info("Setting up TICI fan handler")
@ -241,8 +244,8 @@ def thermald_thread():
# Handle disconnect # Handle disconnect
if pandaState_prev is not None: if pandaState_prev is not None:
if pandaState.pandaState.pandaType == log.PandaState.PandaType.unknown and \ if pandaState.pandaType == log.PandaState.PandaType.unknown and \
pandaState_prev.pandaState.pandaType != log.PandaState.PandaType.unknown: pandaState_prev.pandaType != log.PandaState.PandaType.unknown:
params.clear_all(ParamKeyType.CLEAR_ON_PANDA_DISCONNECT) params.clear_all(ParamKeyType.CLEAR_ON_PANDA_DISCONNECT)
pandaState_prev = pandaState pandaState_prev = pandaState
@ -399,27 +402,25 @@ def thermald_thread():
off_ts = sec_since_boot() off_ts = sec_since_boot()
# Offroad power monitoring # Offroad power monitoring
power_monitor.calculate(pandaState) power_monitor.calculate(peripheralState, startup_conditions["ignition"])
msg.deviceState.offroadPowerUsageUwh = power_monitor.get_power_used() msg.deviceState.offroadPowerUsageUwh = power_monitor.get_power_used()
msg.deviceState.carBatteryCapacityUwh = max(0, power_monitor.get_car_battery_capacity()) msg.deviceState.carBatteryCapacityUwh = max(0, power_monitor.get_car_battery_capacity())
# Check if we need to disable charging (handled by boardd) # Check if we need to disable charging (handled by boardd)
msg.deviceState.chargingDisabled = power_monitor.should_disable_charging(pandaState, off_ts) msg.deviceState.chargingDisabled = power_monitor.should_disable_charging(startup_conditions["ignition"], in_car, off_ts)
# Check if we need to shut down # Check if we need to shut down
if power_monitor.should_shutdown(pandaState, off_ts, started_seen): if power_monitor.should_shutdown(peripheralState, startup_conditions["ignition"], in_car, off_ts, started_seen):
cloudlog.info(f"shutting device down, offroad since {off_ts}") cloudlog.info(f"shutting device down, offroad since {off_ts}")
# TODO: add function for blocking cloudlog instead of sleep # TODO: add function for blocking cloudlog instead of sleep
time.sleep(10) time.sleep(10)
HARDWARE.shutdown() HARDWARE.shutdown()
# If UI has crashed, set the brightness to reasonable non-zero value # If UI has crashed, set the brightness to reasonable non-zero value
manager_state = messaging.recv_one_or_none(managerState_sock) ui_running = "ui" in (p.name for p in sm["managerState"].processes if p.running)
if manager_state is not None: if ui_running_prev and not ui_running:
ui_running = "ui" in (p.name for p in manager_state.managerState.processes if p.running) HARDWARE.set_screen_brightness(20)
if ui_running_prev and not ui_running: ui_running_prev = ui_running
HARDWARE.set_screen_brightness(20)
ui_running_prev = ui_running
msg.deviceState.chargingError = current_filter.x > 0. and msg.deviceState.batteryPercent < 90 # if current is positive, then battery is being discharged msg.deviceState.chargingError = current_filter.x > 0. and msg.deviceState.batteryPercent < 90 # if current is positive, then battery is being discharged
msg.deviceState.started = started_ts is not None msg.deviceState.started = started_ts is not None
@ -443,11 +444,11 @@ def thermald_thread():
if EON and started_ts is None and msg.deviceState.memoryUsagePercent > 40: if EON and started_ts is None and msg.deviceState.memoryUsagePercent > 40:
cloudlog.event("High offroad memory usage", mem=msg.deviceState.memoryUsagePercent) cloudlog.event("High offroad memory usage", mem=msg.deviceState.memoryUsagePercent)
location = messaging.recv_sock(location_sock)
cloudlog.event("STATUS_PACKET", cloudlog.event("STATUS_PACKET",
count=count, count=count,
pandaState=(strip_deprecated_keys(pandaState.to_dict()) if pandaState else None), pandaState=(strip_deprecated_keys(pandaState.to_dict()) if pandaState else None),
location=(strip_deprecated_keys(location.gpsLocationExternal.to_dict()) if location else None), peripheralState=strip_deprecated_keys(peripheralState.to_dict()),
location=(strip_deprecated_keys(sm["gpsLocationExternal"].to_dict()) if sm.alive["gpsLocationExternal"] else None),
deviceState=strip_deprecated_keys(msg.to_dict())) deviceState=strip_deprecated_keys(msg.to_dict()))
count += 1 count += 1

Write Preview
Loading…
Cancel
Save