def __init__(self):
self.long_control_state = 0 # initialized to off
self.seq_step_debug = 0
self.long_curv_timer = 0
self.path_x = np.arange(192)
self.traceSC = trace1.Loger("SPD_CTRL")
self.wheelbase = 2.845
self.steerRatio = 12.5 # 12.5
self.v_model = 0
self.a_model = 0
self.v_cruise = 0
self.a_cruise = 0
self.l_poly = []
self.r_poly = []
self.movAvg = moveavg1.MoveAvg()
self.Timer1 = tm.CTime1000("SPD")
self.time_no_lean = 0
self.SC = trace1.Loger("spd")
def __init__(self, CP, CarController):
self.CP = CP
self.VM = VehicleModel(CP)
self.frame = 0
self.gas_pressed_prev = False
self.brake_pressed_prev = False
self.cruise_enabled_prev = False
self.low_speed_alert = False
self.blinker_status = 0
self.blinker_timer = 0
# *** init the major players ***
self.CS = CarState(CP)
self.cp = get_can_parser(CP)
self.cp2 = get_can2_parser(CP)
self.cp_cam = get_camera_parser(CP)
self.cp_AVM = get_AVM_parser(CP)
self.CC = None
if CarController is not None:
self.CC = CarController(self.cp.dbc_name, CP.carFingerprint)
self.traceLKA = trace1.Loger("LKA")
self.traceCLU = trace1.Loger("clu11")
self.traceSCC = trace1.Loger("scc12")
self.traceMDPS = trace1.Loger("mdps12")
self.traceCGW = trace1.Loger("CGW1")
self.params = Params()
def __init__(self, CP):
self.LP = LanePlanner()
self.last_cloudlog_t = 0
self.steer_rate_cost = CP.steerRateCost
self.steerRatio = CP.steerRatio
self.setup_mpc()
self.solution_invalid_cnt = 0
self.steerRatio_last = 0
self.params = Params()
# Lane change
self.lane_change_enabled = self.params.get('LaneChangeEnabled') == b'1'
self.lane_change_auto_delay = self.params.get_OpkrAutoLanechangedelay() #int( self.params.get('OpkrAutoLanechangedelay') )
self.lane_change_state = LaneChangeState.off
self.lane_change_direction = LaneChangeDirection.none
self.lane_change_run_timer = 0.0
self.lane_change_wait_timer = 0.0
self.lane_change_ll_prob = 1.0
self.prev_one_blinker = False
# atom
self.trPATH = trace1.Loger("path")
self.trLearner = trace1.Loger("Learner")
self.trpathPlan = trace1.Loger("pathPlan")
self.atom_timer_cnt = 0
self.atom_steer_ratio = None
self.atom_sr_boost_bp = [0., 0.]
self.atom_sr_boost_range = [0., 0.]
def __init__(self, CP=None):
self.long_control_state = 0 # initialized to off
self.seq_step_debug = ""
self.long_curv_timer = 0
self.path_x = np.arange(192)
self.traceSC = trace1.Loger("SPD_CTRL")
self.v_model = 0
self.a_model = 0
self.v_cruise = 0
self.a_cruise = 0
self.l_poly = []
self.r_poly = []
self.movAvg = moveavg1.MoveAvg()
self.Timer1 = tm.CTime1000("SPD")
self.time_no_lean = 0
self.wait_timer2 = 0
self.cruise_set_speed_kph = 0
self.curise_set_first = 0
self.curise_sw_check = 0
self.prev_clu_CruiseSwState = 0
self.prev_VSetDis = 0
self.sc_clu_speed = 0
self.btn_type = Buttons.NONE
self.active_time = 0
def __init__(self, CP):
self.LP = LanePlanner()
self.last_cloudlog_t = 0
self.steer_rate_cost = CP.steerRateCost
self.setup_mpc()
self.solution_invalid_cnt = 0
self.lane_change_enabled = Params().get('LaneChangeEnabled') == b'1'
if int(Params().get('OpkrAutoLaneChangeDelay')) == 0:
self.lane_change_auto_delay = 0.0
elif int(Params().get('OpkrAutoLaneChangeDelay')) == 1:
self.lane_change_auto_delay = 0.5
elif int(Params().get('OpkrAutoLaneChangeDelay')) == 2:
self.lane_change_auto_delay = 1.0
elif int(Params().get('OpkrAutoLaneChangeDelay')) == 3:
self.lane_change_auto_delay = 1.5
elif int(Params().get('OpkrAutoLaneChangeDelay')) == 4:
self.lane_change_auto_delay = 2.0
self.trRapidCurv = trace1.Loger("079_OPKR_RapidCurv")
self.lane_change_wait_timer = 0.0
self.lane_change_state = LaneChangeState.off
self.lane_change_direction = LaneChangeDirection.none
self.lane_change_timer = 0.0
self.lane_change_ll_prob = 1.0
self.prev_one_blinker = False
self.mpc_frame = 0
self.lane_change_adjust = [0.2, 1.3]
self.lane_change_adjust_vel = [16, 30]
self.lane_change_adjust_new = 0.0
self.new_steerRatio = CP.steerRatio
def __init__(self, CP):
self.trPID = trace1.Loger("pid")
self.angle_steers_des = 0.
self.deadzone = CP.lateralsRatom.deadzone
self.pid = PIController((CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV),
(CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV),
k_f=CP.lateralTuning.pid.kf, pos_limit=1.0, sat_limit=CP.steerLimitTimer)
def __init__(self, dbc_name, CP, VM):
self.CP = CP
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.steer_rate_limited = False
self.resume_cnt = 0
self.last_resume_frame = 0
self.last_lead_distance = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above_timer = 0
self.mode_change_timer = 0
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.lkas11_cnt = 0
self.nBlinker = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.timer1 = tm.CTime1000("time")
self.model_speed = 0
self.model_sum = 0
# hud
self.hud_timer_left = 0
self.hud_timer_right = 0
self.command_cnt = 0
self.command_load = 0
self.params = Params()
# param
self.param_preOpkrAccelProfile = -1
self.param_OpkrAccelProfile = 0
self.param_OpkrAutoResume = 0
self.param_OpkrEnableLearner = 0
self.SC = None
self.traceCC = trace1.Loger("CarController")
self.res_cnt = 7
self.res_delay = 0
kyd = kyd_conf()
self.driver_steering_torque_above = float(
kyd.conf['driverSteeringTorqueAbove'])
self.params = Params()
self.mode_change_switch = int(
self.params.get('CruiseStatemodeSelInit'))
def __init__(self, dbc_name, CP, VM):
self.CP = CP
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.steer_rate_limited = False
self.resume_cnt = 0
self.last_resume_frame = 0
self.last_lead_distance = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above_timer = 0
self.mode_change_timer = 0
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.lkas11_cnt = 0
self.nBlinker = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.timer1 = tm.CTime1000("time")
self.model_speed = 0
self.model_sum = 0
# hud
self.hud_timer_left = 0
self.hud_timer_right = 0
self.traceCC = trace1.Loger("CarController")
self.cruise_gap = 0
self.cruise_gap_prev = 0
self.cruise_gap_set_init = 0
self.cruise_gap_switch_timer = 0
self.params = Params()
self.mode_change_switch = int(
self.params.get('CruiseStatemodeSelInit'))
self.param_OpkrAccelProfile = int(self.params.get('OpkrAccelProfile'))
self.param_OpkrAutoResume = int(self.params.get('OpkrAutoResume'))
if self.param_OpkrAccelProfile == 1:
self.SC = SpdctrlSlow()
elif self.param_OpkrAccelProfile == 2:
self.SC = SpdctrlNormal()
else:
self.SC = SpdctrlFast()
def __init__(self, CP=None):
self.long_control_state = 0 # initialized to off
self.seq_step_debug = ""
self.long_curv_timer = 0
self.path_x = np.arange(192)
self.traceSC = trace1.Loger("SPD_CTRL")
self.wheelbase = 2.8
self.steerRatio = 13.5 # 13.5
self.v_model = 0
self.a_model = 0
self.v_cruise = 0
self.a_cruise = 0
self.l_poly = []
self.r_poly = []
self.movAvg = moveavg1.MoveAvg()
self.Timer1 = tm.CTime1000("SPD")
self.time_no_lean = 0
self.wait_timer2 = 0
self.cruise_set_speed_kph = 0
self.curise_set_first = 0
self.curise_sw_check = 0
self.prev_clu_CruiseSwState = 0
self.prev_VSetDis = 0
self.sc_clu_speed = 0
self.btn_type = Buttons.NONE
self.active_time = 0
self.old_model_speed = 0
self.old_model_init = 0
self.curve_speed = 0
self.curvature_gain = 1
self.params = Params()
self.cruise_set_mode = int(
self.params.get("CruiseStatemodeSelInit", encoding='utf8'))
self.map_spd_limit_offset = int(
self.params.get("OpkrSpeedLimitOffset", encoding='utf8'))
self.map_spd_enable = False
self.map_spd_camera = 0
def __init__(self, dbc_name, car_fingerprint):
self.packer = CANPacker(dbc_name)
self.car_fingerprint = car_fingerprint
self.accel_steady = 0
self.apply_steer_last = 0
self.steer_rate_limited = False
self.lkas11_cnt = 0
self.resume_cnt = 0
self.last_resume_frame = 0
self.last_lead_distance = 0
self.turning_signal_timer = 0
self.lkas_button = 1
self.longcontrol = 0 #TODO: make auto
self.low_speed_car = False
self.streer_angle_over = False
self.turning_indicator = 0
self.hud_timer_left = 0
self.hud_timer_right = 0
self.lkas_active_timer1 = 0
self.lkas_active_timer2 = 0
self.steer_timer = 0
self.steer_torque_over_timer = 0
self.steer_torque_over = False
kegman = kegman_conf()
self.steer_torque_over_max = float(kegman.conf['steerTorqueOver'])
self.timer_curvature = 0
self.SC = SpdController()
self.sc_wait_timer2 = 0
self.sc_active_timer2 = 0
self.sc_btn_type = Buttons.NONE
self.sc_clu_speed = 0
#self.model_speed = 255
self.traceCC = trace1.Loger("CarCtrl")
self.params = Params()
self.lane_change_enabled = self.params.get('LaneChangeEnabled') == b'1'
self.speed_control_enabled = self.params.get(
'SpeedControlEnabled') == b'1'
def __init__(self, dbc_name, CP, VM):
self.CP = CP
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.steer_rate_limited = False
self.resume_cnt = 0
self.lkas11_cnt = 0
self.last_resume_frame = 0
self.last_lead_distance = 0
self.nBlinker = 0
self.lane_change_torque_lower = 0
self.steer_torque_over_timer = 0
self.steer_torque_ratio = 1
self.steer_torque_ratio_dir = 1
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.timer1 = tm.CTime1000("time")
self.model_speed = 0
self.model_sum = 0
# hud
self.hud_timer_left = 0
self.hud_timer_right = 0
self.hud_sys_state = 0
self.command_cnt = 0
self.command_load = 0
self.params = Params()
# param
self.param_preOpkrAccelProfile = -1
self.param_OpkrAccelProfile = 0
self.param_OpkrAutoResume = 0
self.param_OpkrWhoisDriver = 0
self.SC = None
self.traceCC = trace1.Loger("CarController")
def __init__(self, CP):
self.trLQR = trace1.Loger("076_conan_LQR_ctrl")
self.scale = CP.lateralTuning.lqr.scale
self.ki = CP.lateralTuning.lqr.ki
self.A = np.array(CP.lateralTuning.lqr.a).reshape((2, 2))
self.B = np.array(CP.lateralTuning.lqr.b).reshape((2, 1))
self.C = np.array(CP.lateralTuning.lqr.c).reshape((1, 2))
self.K = np.array(CP.lateralTuning.lqr.k).reshape((1, 2))
self.L = np.array(CP.lateralTuning.lqr.l).reshape((2, 1))
self.dc_gain = CP.lateralTuning.lqr.dcGain
self.x_hat = np.array([[0], [0]])
self.i_unwind_rate = 0.3 * DT_CTRL
self.i_rate = 1.0 * DT_CTRL
self.sat_count_rate = 1.0 * DT_CTRL
self.sat_limit = CP.steerLimitTimer
self.reset()
def __init__(self, CP=None):
self.long_control_state = 0 # initialized to off
self.seq_step_debug = ""
self.long_curv_timer = 0
self.path_x = np.arange(192)
self.traceSC = trace1.Loger("SPD_CTRL")
self.wheelbase = 2.845
self.steerRatio = 12.5 # 12.5
self.v_model = 0
self.a_model = 0
self.v_cruise = 0
self.a_cruise = 0
self.l_poly = []
self.r_poly = []
self.movAvg = moveavg1.MoveAvg()
self.Timer1 = tm.CTime1000("SPD")
self.time_no_lean = 0
self.wait_timer2 = 0
self.cruise_set_speed_kph = 0
self.curise_set_first = 0
self.curise_sw_check = 0
self.prev_clu_CruiseSwState = 0
self.prev_VSetDis = 0
self.sc_clu_speed = 0
self.btn_type = Buttons.NONE
self.active_time = 0
self.params = Params()
self.param_OpkrAccelProfile = int(self.params.get('OpkrAccelProfile'))
self.cruise_set_mode = int(self.params.get('CruiseStatemodeSelInit'))
def __init__(self, CP):
self.PathPlan = trace1.Loger("077_R3_LQR_parhplan")
self.LP = LanePlanner()
self.last_cloudlog_t = 0
self.steer_rate_cost = CP.steerRateCost
self.setup_mpc()
self.solution_invalid_cnt = 0
self.params = Params()
# Lane change
self.lane_change_enabled = self.params.get('LaneChangeEnabled') == b'1'
self.lane_change_auto_delay = self.params.get_OpkrAutoLanechangedelay()
self.lane_change_state = LaneChangeState.off
self.lane_change_direction = LaneChangeDirection.none
self.lane_change_run_timer = 0.0
self.lane_change_wait_timer = 0.0
self.lane_change_ll_prob = 1.0
self.prev_one_blinker = False
def __init__(self, k_p, k_i, k_f=1., pos_limit=None, neg_limit=None, rate=100, sat_limit=0.8, convert=None):
self._k_p = k_p # proportional gain
self._k_i = k_i # integral gain
self._k_d = None
self.k_f = k_f # feedforward gain
self.time_cnt = 0
self.errorPrev = 0 # History: Previous error
self.prevInput = 0
self.pos_limit = pos_limit
self.neg_limit = neg_limit
self.sat_count_rate = 1.0 / rate
self.i_unwind_rate = 0.3 / rate
self.i_rate = 1.0 / rate
self.d_rate = 1.0 / rate
self.sat_limit = sat_limit
self.convert = convert
self.reset()
self.trPID = trace1.Loger("pid_ctrl")
from selfdrive.controls.lib.alertmanager import AlertManager
from selfdrive.controls.lib.vehicle_model import VehicleModel
from selfdrive.controls.lib.planner import LON_MPC_STEP
from selfdrive.locationd.calibration_helpers import Calibration, Filter
LANE_DEPARTURE_THRESHOLD = 0.1
ThermalStatus = log.ThermalData.ThermalStatus
State = log.ControlsState.OpenpilotState
HwType = log.HealthData.HwType
LaneChangeState = log.PathPlan.LaneChangeState
LaneChangeDirection = log.PathPlan.LaneChangeDirection
LaneChangeBSM = log.PathPlan.LaneChangeBSM
traceCS = trace1.Loger("control")
def add_lane_change_event(events, path_plan):
if path_plan.laneChangeState == LaneChangeState.preLaneChange:
if path_plan.laneChangeDirection == LaneChangeDirection.left:
events.append(create_event('preLaneChangeLeft', [ET.WARNING]))
else:
events.append(create_event('preLaneChangeRight', [ET.WARNING]))
elif path_plan.laneChangeState in [
LaneChangeState.laneChangeStarting,
LaneChangeState.laneChangeFinishing
]:
events.append(create_event('laneChange', [ET.WARNING]))
def __init__(self, sm=None, pm=None, can_sock=None):
gc.disable()
set_realtime_priority(3)
self.trace_log = trace1.Loger("controlsd")
# Setup sockets
self.pm = pm
if self.pm is None:
self.pm = messaging.PubMaster(['sendcan', 'controlsState', 'carState', \
'carControl', 'carEvents', 'carParams'])
self.sm = sm
if self.sm is None:
socks = [
'thermal', 'health', 'model', 'liveCalibration',
'dMonitoringState', 'plan', 'pathPlan', 'liveLocationKalman'
]
self.sm = messaging.SubMaster(socks,
ignore_alive=['dMonitoringState'])
#self.sm = messaging.SubMaster(['thermal', 'health', 'model', 'liveCalibration', \
# 'dMonitoringState', 'plan', 'pathPlan', 'liveLocationKalman'])
print(" start_Controls messages...1")
self.can_sock = can_sock
if can_sock is None:
can_timeout = None if os.environ.get('NO_CAN_TIMEOUT',
False) else 100
self.can_sock = messaging.sub_sock('can', timeout=can_timeout)
print(" start_Controls messages...2")
# wait for one health and one CAN packet
hw_type = messaging.recv_one(self.sm.sock['health']).health.hwType
has_relay = hw_type in [HwType.blackPanda, HwType.uno]
print("Waiting for CAN messages...")
messaging.get_one_can(self.can_sock)
self.CI, self.CP = get_car(self.can_sock, self.pm.sock['sendcan'],
has_relay)
# read params
params = Params()
self.is_metric = params.get("IsMetric", encoding='utf8') == "1"
self.is_ldw_enabled = params.get("IsLdwEnabled",
encoding='utf8') == "1"
internet_needed = params.get("Offroad_ConnectivityNeeded",
encoding='utf8') is not None
community_feature_toggle = params.get("CommunityFeaturesToggle",
encoding='utf8') == "1"
openpilot_enabled_toggle = params.get("OpenpilotEnabledToggle",
encoding='utf8') == "1"
passive = params.get("Passive", encoding='utf8') == "1" or \
internet_needed or not openpilot_enabled_toggle
# detect sound card presence and ensure successful init
sounds_available = not os.path.isfile('/EON') or (os.path.isfile('/proc/asound/card0/state') \
and open('/proc/asound/card0/state').read().strip() == 'ONLINE')
car_recognized = self.CP.carName != 'mock'
# If stock camera is disconnected, we loaded car controls and it's not dashcam mode
controller_available = self.CP.enableCamera and self.CI.CC is not None and not passive
community_feature_disallowed = self.CP.communityFeature and not community_feature_toggle
self.read_only = not car_recognized or not controller_available or \
self.CP.dashcamOnly or community_feature_disallowed
if self.read_only:
self.CP.safetyModel = car.CarParams.SafetyModel.noOutput
# Write CarParams for radard and boardd safety mode
cp_bytes = self.CP.to_bytes()
params.put("CarParams", cp_bytes)
put_nonblocking("CarParamsCache", cp_bytes)
put_nonblocking("LongitudinalControl",
"1" if self.CP.openpilotLongitudinalControl else "0")
self.CC = car.CarControl.new_message()
self.AM = AlertManager()
self.events = Events()
self.LoC = LongControl(self.CP, self.CI.compute_gb)
self.VM = VehicleModel(self.CP)
print('self.CP.lateralTuning.which()={}'.format(
self.CP.lateralTuning.which()))
if self.CP.lateralTuning.which() == 'pid':
self.LaC = LatControlPID(self.CP)
elif self.CP.lateralTuning.which() == 'indi':
self.LaC = LatControlINDI(self.CP)
elif self.CP.lateralTuning.which() == 'lqr':
self.LaC = LatControlLQR(self.CP)
self.state = State.disabled
self.enabled = False
self.active = False
self.can_rcv_error = False
self.soft_disable_timer = 0
self.v_cruise_kph = 255
self.v_cruise_kph_last = 0
self.mismatch_counter = 0
self.can_error_counter = 0
self.consecutive_can_error_count = 0
self.last_blinker_frame = 0
self.saturated_count = 0
self.events_prev = []
self.current_alert_types = []
self.sm['liveCalibration'].calStatus = Calibration.INVALID
self.sm['thermal'].freeSpace = 1.
self.sm['dMonitoringState'].events = []
self.sm['dMonitoringState'].awarenessStatus = 1.
self.sm['dMonitoringState'].faceDetected = False
self.startup_event = get_startup_event(car_recognized,
controller_available, hw_type)
if not sounds_available:
self.events.add(EventName.soundsUnavailable, static=True)
if internet_needed:
self.events.add(EventName.internetConnectivityNeeded, static=True)
if community_feature_disallowed:
self.events.add(EventName.communityFeatureDisallowed, static=True)
if self.read_only and not passive:
self.events.add(EventName.carUnrecognized, static=True)
# if hw_type == HwType.whitePanda:
# self.events.add(EventName.whitePandaUnsupported, static=True)
uname = subprocess.check_output(["uname", "-v"],
encoding='utf8').strip()
if uname == "#1 SMP PREEMPT Wed Jun 10 12:40:53 PDT 2020":
self.events.add(EventName.neosUpdateRequired, static=True)
# controlsd is driven by can recv, expected at 100Hz
self.rk = Ratekeeper(100, print_delay_threshold=None)
self.prof = Profiler(False) # off by default
self.hyundai_lkas = self.read_only #read_only
self.init_flag = True
def __init__(self, sm=None, pm=None, can_sock=None):
config_realtime_process(3, Priority.CTRL_HIGH)
self.trace_log = trace1.Loger("controlsd")
# Setup sockets
self.pm = pm
if self.pm is None:
self.pm = messaging.PubMaster([
'sendcan', 'controlsState', 'carState', 'carControl',
'carEvents', 'carParams'
])
self.sm = sm
if self.sm is None:
self.sm = messaging.SubMaster([
'thermal', 'health', 'model', 'liveCalibration', 'frontFrame',
'dMonitoringState', 'plan', 'pathPlan', 'liveLocationKalman'
])
self.can_sock = can_sock
if can_sock is None:
can_timeout = None if os.environ.get('NO_CAN_TIMEOUT',
False) else 100
self.can_sock = messaging.sub_sock('can', timeout=can_timeout)
# wait for one health and one CAN packet
print("Waiting for CAN messages...")
get_one_can(self.can_sock)
self.CI, self.CP = get_car(self.can_sock, self.pm.sock['sendcan'])
# read params
params = Params()
self.is_metric = params.get("IsMetric", encoding='utf8') == "1"
self.is_ldw_enabled = params.get("IsLdwEnabled",
encoding='utf8') == "1"
internet_needed = (params.get("Offroad_ConnectivityNeeded",
encoding='utf8') is not None) and (
params.get("DisableUpdates") != b"1")
community_feature_toggle = params.get("CommunityFeaturesToggle",
encoding='utf8') == "1"
openpilot_enabled_toggle = params.get("OpenpilotEnabledToggle",
encoding='utf8') == "1"
passive = params.get("Passive", encoding='utf8') == "1" or \
internet_needed or not openpilot_enabled_toggle
# detect sound card presence and ensure successful init
sounds_available = HARDWARE.get_sound_card_online()
car_recognized = self.CP.carName != 'mock'
# If stock camera is disconnected, we loaded car controls and it's not dashcam mode
controller_available = self.CP.enableCamera and self.CI.CC is not None and not passive and not self.CP.dashcamOnly
community_feature_disallowed = self.CP.communityFeature and not community_feature_toggle
self.read_only = not car_recognized or not controller_available or \
self.CP.dashcamOnly or community_feature_disallowed
if self.read_only:
self.CP.safetyModel = car.CarParams.SafetyModel.noOutput
# Write CarParams for radard and boardd safety mode
cp_bytes = self.CP.to_bytes()
params.put("CarParams", cp_bytes)
put_nonblocking("CarParamsCache", cp_bytes)
self.CC = car.CarControl.new_message()
self.AM = AlertManager()
self.events = Events()
self.LoC = LongControl(self.CP, self.CI.compute_gb)
self.VM = VehicleModel(self.CP)
if self.CP.lateralTuning.which() == 'pid':
self.LaC = LatControlPID(self.CP)
elif self.CP.lateralTuning.which() == 'indi':
self.LaC = LatControlINDI(self.CP)
elif self.CP.lateralTuning.which() == 'lqr':
self.LaC = LatControlLQR(self.CP)
self.model_sum = 0
self.state = State.disabled
self.enabled = False
self.active = False
self.can_rcv_error = False
self.soft_disable_timer = 0
self.v_cruise_kph = 255
self.v_cruise_kph_last = 0
self.mismatch_counter = 0
self.can_error_counter = 0
self.last_blinker_frame = 0
self.saturated_count = 0
self.distance_traveled = 0
self.last_functional_fan_frame = 0
self.events_prev = []
self.current_alert_types = [ET.PERMANENT]
self.sm['liveCalibration'].calStatus = Calibration.CALIBRATED
self.sm['thermal'].freeSpace = 1.
self.sm['dMonitoringState'].events = []
self.sm['dMonitoringState'].awarenessStatus = 1.
self.sm['dMonitoringState'].faceDetected = False
self.startup_event = get_startup_event(car_recognized,
controller_available)
if not sounds_available:
self.events.add(EventName.soundsUnavailable, static=True)
if internet_needed:
self.events.add(EventName.internetConnectivityNeeded, static=True)
if community_feature_disallowed:
self.events.add(EventName.communityFeatureDisallowed, static=True)
if not car_recognized:
self.events.add(EventName.carUnrecognized, static=True)
# controlsd is driven by can recv, expected at 100Hz
self.rk = Ratekeeper(100, print_delay_threshold=None)
self.prof = Profiler(False) # off by default
self.hyundai_lkas = self.read_only #read_only
self.init_flag = True
self.timer_alloowed = 1500
self.timer_start = 1500
