mirror of
https://github.com/sunnypilot/sunnypilot.git
synced 2026-02-27 01:33:59 +08:00
0b902a02c1
* complie boardd without python
* not good, but don't want to lose the file, because it works
* clean a bit
* update dbc
* should build on CI
* not good, but don't want to lose the file, because it works
* clean a bit
* should build on CI
* remove unneeded path
* reorder paths
* reduce diff
* and now it works?!
* ... should work in CI
* add kj, 30% chance to fix macos
* pydebug
* new way to find path
* fix :)
* tested
* sanity check
* repl. MacOS flags
* hope it works
* need more logs
* need more logs2
* test if it works
* should work on CI
* correct python file
* should not work
* cleanup
* real cleanup
* more removals
* 50% of file
* transformations
* fixed a hardcoded variable
* more logs
* simpl.
* kalman
* all donw if it passes tests
* cleanup
* reduce code by 20 lines if this works
* fix bugs
* cleanup
* SharedLibrary
* cleanup
* ...
* remove unused
* CI fix maybe?
* add more valid path
* more logs
* ...:
* fix webcam CI
* remove WError flag
* deprecated is not an error
* more Wno things
* reduce diff, add Wno to env
* don't import nonexistent stuff
* SharedLibrary v2
* less custom env
* renaming, remove SharedLibs
* pack libs in envCython
* experiment
* better docker caching
* whitespace
* more docker caching
* improvement
* improvements
Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
old-commit-hash: 9529764549
76 lines
2.0 KiB
Python
76 lines
2.0 KiB
Python
"""Utilities for reading real time clocks and keeping soft real time constraints."""
|
|
import gc
|
|
import os
|
|
import time
|
|
import multiprocessing
|
|
|
|
from common.hardware import PC
|
|
from common.clock import sec_since_boot # pylint: disable=no-name-in-module, import-error
|
|
|
|
|
|
# time step for each process
|
|
DT_CTRL = 0.01 # controlsd
|
|
DT_MDL = 0.05 # model
|
|
DT_DMON = 0.1 # driver monitoring
|
|
DT_TRML = 0.5 # thermald and manager
|
|
|
|
|
|
class Priority:
|
|
MIN_REALTIME = 52 # highest android process priority is 51
|
|
CTRL_LOW = MIN_REALTIME
|
|
CTRL_HIGH = MIN_REALTIME + 1
|
|
|
|
|
|
def set_realtime_priority(level):
|
|
if not PC:
|
|
os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(level))
|
|
|
|
|
|
def set_core_affinity(core):
|
|
if not PC:
|
|
os.sched_setaffinity(0, [core,])
|
|
|
|
|
|
def config_realtime_process(core, priority):
|
|
gc.disable()
|
|
set_realtime_priority(priority)
|
|
set_core_affinity(core)
|
|
|
|
|
|
class Ratekeeper():
|
|
def __init__(self, rate, print_delay_threshold=0.):
|
|
"""Rate in Hz for ratekeeping. print_delay_threshold must be nonnegative."""
|
|
self._interval = 1. / rate
|
|
self._next_frame_time = sec_since_boot() + self._interval
|
|
self._print_delay_threshold = print_delay_threshold
|
|
self._frame = 0
|
|
self._remaining = 0
|
|
self._process_name = multiprocessing.current_process().name
|
|
|
|
@property
|
|
def frame(self):
|
|
return self._frame
|
|
|
|
@property
|
|
def remaining(self):
|
|
return self._remaining
|
|
|
|
# Maintain loop rate by calling this at the end of each loop
|
|
def keep_time(self):
|
|
lagged = self.monitor_time()
|
|
if self._remaining > 0:
|
|
time.sleep(self._remaining)
|
|
return lagged
|
|
|
|
# this only monitor the cumulative lag, but does not enforce a rate
|
|
def monitor_time(self):
|
|
lagged = False
|
|
remaining = self._next_frame_time - sec_since_boot()
|
|
self._next_frame_time += self._interval
|
|
if self._print_delay_threshold is not None and remaining < -self._print_delay_threshold:
|
|
print("%s lagging by %.2f ms" % (self._process_name, -remaining * 1000))
|
|
lagged = True
|
|
self._frame += 1
|
|
self._remaining = remaining
|
|
return lagged
|