import  os 
 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								from  cereal  import  car 
 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								from  common . params  import  Params 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								from  system . hardware  import  PC ,  TICI 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								from  selfdrive . manager . process  import  PythonProcess ,  NativeProcess ,  DaemonProcess 
 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								WEBCAM  =  os . getenv ( " USE_WEBCAM " )  is  not  None 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								def  driverview ( started :  bool ,  params :  Params ,  CP :  car . CarParams )  - >  bool : 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  return  params . get_bool ( " IsDriverViewEnabled " )   # type: ignore 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								def  notcar ( started :  bool ,  params :  Params ,  CP :  car . CarParams )  - >  bool : 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  return  CP . notCar   # type: ignore 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								def  logging ( started ,  params ,  CP :  car . CarParams )  - >  bool : 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  run  =  ( not  CP . notCar )  or  not  params . get_bool ( " DisableLogging " ) 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  return  started  and  run 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								procs  =  [ 
 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  # due to qualcomm kernel bugs SIGKILLing camerad sometimes causes page table corruption 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  NativeProcess ( " camerad " ,  " system/camerad " ,  [ " ./camerad " ] ,  unkillable = True ,  callback = driverview ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " clocksd " ,  " system/clocksd " ,  [ " ./clocksd " ] ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  NativeProcess ( " logcatd " ,  " system/logcatd " ,  [ " ./logcatd " ] ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  NativeProcess ( " proclogd " ,  " system/proclogd " ,  [ " ./proclogd " ] ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " logmessaged " ,  " system.logmessaged " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " timezoned " ,  " system.timezoned " ,  enabled = not  PC ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  DaemonProcess ( " manage_athenad " ,  " selfdrive.athena.manage_athenad " ,  " AthenadPid " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " dmonitoringmodeld " ,  " selfdrive/modeld " ,  [ " ./dmonitoringmodeld " ] ,  enabled = ( not  PC  or  WEBCAM ) ,  callback = driverview ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " encoderd " ,  " selfdrive/loggerd " ,  [ " ./encoderd " ] ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " loggerd " ,  " selfdrive/loggerd " ,  [ " ./loggerd " ] ,  onroad = False ,  callback = logging ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  NativeProcess ( " modeld " ,  " selfdrive/modeld " ,  [ " ./modeld " ] ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " sensord " ,  " selfdrive/sensord " ,  [ " ./sensord " ] ,  enabled = not  PC ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " ubloxd " ,  " selfdrive/locationd " ,  [ " ./ubloxd " ] ,  enabled = ( not  PC  or  WEBCAM ) ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " ui " ,  " selfdrive/ui " ,  [ " ./ui " ] ,  offroad = True ,  watchdog_max_dt = ( 5  if  not  PC  else  None ) ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " soundd " ,  " selfdrive/ui/soundd " ,  [ " ./soundd " ] ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " locationd " ,  " selfdrive/locationd " ,  [ " ./locationd " ] ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " boardd " ,  " selfdrive/boardd " ,  [ " ./boardd " ] ,  enabled = False ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " calibrationd " ,  " selfdrive.locationd.calibrationd " ) , 
  
						 
					
						
							
								
									
										
											 
										
											
												Live torque (#25456)
* wip torqued
* add basic logic
* setup in manager
* check sanity and publish msg
* add first order filter to outputs
* wire up controlsd, and update gains
* rename intercept to offset
* add cloudlog, live values are not updated
* fix bugs, do not reset points for now
* fix crashes
* rename to main
* fix bugs, works offline
* fix float in cereal bug
* add latacc filter
* randomly choose points, approx for iid
* add variable decay
* local param to capnp instead of dict
* verify works in replay
* use torqued output in controlsd
* use in controlsd; use points from past routes
* controlsd bugfix
* filter before updating gains, needs to be replaced
* save all points to ensure smooth transition across routes, revert friction factor to 1.5
* add filters to prevent noisy low-speed data points; improve fit sanity
* add engaged buffer
* revert lat_acc thresh
* use paramsd realtime process config
* make latacc-to-torque generic, and overrideable
* move freq to 4Hz, avoid storing in np.array, don't publish points in the message
* float instead of np
* remove constant while storing pts
* rename slope, offset to lat_accet_factor, offset
* resolve issues
* use camelcase in all capnp params
* use camelcase everywhere
* reduce latacc threshold or sanity, add car_sane todo, save points properly
* add and check tag
* write param to disk at end of route
* remove args
* rebase op, cereal
* save on exit
* restore default handler
* cpu usage check
* add to process replay
* handle reset better, reduce unnecessary computation
* always publish raw values - useful for debug
* regen routes
* update refs
* checks on cache restore
* check tuning vals too
* clean that up
* reduce cpu usage
* reduce cpu usage by 75%
* cleanup
* optimize further
* handle reset condition better, don't put points in init, use only in corolla
* bump cereal after rebasing
* update refs
* Update common/params.cc
Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
* remove unnecessary checks
* Update RELEASES.md
Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
											 
										 
										
											3 years ago 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " torqued " ,  " selfdrive.locationd.torqued " ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " controlsd " ,  " selfdrive.controls.controlsd " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " deleter " ,  " selfdrive.loggerd.deleter " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " dmonitoringd " ,  " selfdrive.monitoring.dmonitoringd " ,  enabled = ( not  PC  or  WEBCAM ) ,  callback = driverview ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " laikad " ,  " selfdrive.locationd.laikad " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " rawgpsd " ,  " selfdrive.sensord.rawgps.rawgpsd " ,  enabled = TICI ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " navd " ,  " selfdrive.navd.navd " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " pandad " ,  " selfdrive.boardd.pandad " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " paramsd " ,  " selfdrive.locationd.paramsd " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " pigeond " ,  " selfdrive.sensord.pigeond " ,  enabled = TICI ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " plannerd " ,  " selfdrive.controls.plannerd " ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " radard " ,  " selfdrive.controls.radard " ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " thermald " ,  " selfdrive.thermald.thermald " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " tombstoned " ,  " selfdrive.tombstoned " ,  enabled = not  PC ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " updated " ,  " selfdrive.updated " ,  enabled = not  PC ,  onroad = False ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  PythonProcess ( " uploader " ,  " selfdrive.loggerd.uploader " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " statsd " ,  " selfdrive.statsd " ,  offroad = True ) , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  # debug procs 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  NativeProcess ( " bridge " ,  " cereal/messaging " ,  [ " ./bridge " ] ,  onroad = False ,  callback = notcar ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  PythonProcess ( " webjoystick " ,  " tools.joystick.web " ,  onroad = False ,  callback = notcar ) , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								] 
 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								managed_processes  =  { p . name :  p  for  p  in  procs }