def __init__(self, dbc_name, CP, VM):
self.CP = CP
self.p = SteerLimitParams(CP)
self.packer = CANPacker(dbc_name)
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.steer_rate_limited = False
self.last_resume_frame = 0
self.last_lead_distance = 0
self.resume_cnt = 0
self.lkas11_cnt = 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()
self.SC = SpdctrlSlow()
self.traceCC = trace1.Loger("CarController")
def __init__(self, dbc_name, CP, VM):
self.apply_steer_last = 0
self.es_distance_cnt = -1
self.es_accel_cnt = -1
self.es_lkas_cnt = -1
self.fake_button_prev = 0
self.steer_rate_limited = False
self.throttle_cnt = -1
self.params = CarControllerParams()
self.packer = CANPacker(DBC[CP.carFingerprint]['pt'])
#SUBARU STOP AND GO flags and vars
self.prev_cruise_state = -1
self.cruise_state_change_time = -1
self.sng_throttle_tap_cnt = 0
self.sng_resume_acc = False
self.sng_has_recorded_distance = False
self.sng_distance_threshold = self.params.SNG_DISTANCE_LIMIT
#SUBARU STOP AND GO - Pre-Global only
self.prev_close_distance = -1
def __init__(self, dbc_name, CP, VM):
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.accel_steady = 0
self.apply_steer_last = 0
self.steer_rate_limited = False
self.lkas11_cnt = 0
self.scc12_cnt = 0
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.turning_signal_timer = 0
self.longcontrol = CP.openpilotLongitudinalControl
self.scc_live = not CP.radarOffCan
self.mad_mode_enabled = Params().get_bool('MadModeEnabled')
self.scc_smoother = SccSmoother(gas_gain=1.0,
brake_gain=1.0,
curvature_gain=1.0)
def __init__(self, dbc_name, CP, VM):
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.accel_steady = 0
self.apply_steer_last = 0
self.steer_rate_limited = False
self.lkas11_cnt = 0
self.scc12_cnt = 0
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.turning_signal_timer = 0
self.longcontrol = CP.openpilotLongitudinalControl
self.scc_live = not CP.radarOffCan
if CP.spasEnabled:
self.en_cnt = 0
self.apply_steer_ang = 0.0
self.en_spas = 3
self.mdps11_stat_last = 0
self.spas_always = False
def __init__(self, dbc_name, CP, VM):
self.last_steer = 0
self.accel_steady = 0.
self.alert_active = False
self.last_standstill = False
self.standstill_req = False
self.last_fault_frame = -200
self.steer_rate_limited = False
self.fake_ecus = set()
if CP.enableCamera: self.fake_ecus.add(Ecu.fwdCamera)
if CP.enableDsu: self.fake_ecus.add(Ecu.dsu)
self.packer = CANPacker(dbc_name)
# dp
self.dragon_enable_steering_on_signal = False
self.dragon_lat_ctrl = True
self.dragon_lane_departure_warning = True
self.dragon_toyota_sng_mod = False
self.dp_last_modified = None
self.lane_change_enabled = True
def __init__(self, dbc_name, CP, VM):
self.apply_steer_last = 0
self.packer_pt = CANPacker(DBC[CP.carFingerprint]['pt'])
self.acc_bus = CANBUS.pt if CP.networkLocation == NWL.fwdCamera else CANBUS.cam
if CP.safetyModel == car.CarParams.SafetyModel.volkswagen:
self.create_steering_control = volkswagencan.create_mqb_steering_control
self.create_acc_buttons_control = volkswagencan.create_mqb_acc_buttons_control
self.create_hud_control = volkswagencan.create_mqb_hud_control
elif CP.safetyModel == car.CarParams.SafetyModel.volkswagenPq:
self.create_steering_control = volkswagencan.create_pq_steering_control
self.create_acc_buttons_control = volkswagencan.create_pq_acc_buttons_control
self.create_hud_control = volkswagencan.create_pq_hud_control
self.hcaSameTorqueCount = 0
self.hcaEnabledFrameCount = 0
self.graButtonStatesToSend = None
self.graMsgSentCount = 0
self.graMsgStartFramePrev = 0
self.graMsgBusCounterPrev = 0
self.steer_rate_limited = False
def __init__(self, dbc_name, CP, VM):
self.last_steer = 0
self.accel_steady = 0.
self.alert_active = False
self.last_standstill = False
self.standstill_req = False
self.blindspot_blink_counter_left = 0
self.blindspot_blink_counter_right = 0
self.blindspot_debug_enabled_left = False
self.blindspot_debug_enabled_right = False
#self.sm = messaging.SubMaster(['pathPlan'])
#self.rightLaneDepart = False
#self.leftLaneDepart = False
self.last_fault_frame = -200
self.steer_rate_limited = False
self.fake_ecus = set()
if CP.enableCamera: self.fake_ecus.add(Ecu.fwdCamera)
if CP.enableDsu: self.fake_ecus.add(Ecu.dsu)
params = Params()
try:
cached_fingerprint = params.get('CachedFingerprint')
vin = params.get('CarVin')
finger = gen_empty_fingerprint()
cached_fingerprint = json.loads(cached_fingerprint)
finger[0] = {
int(key): value
for key, value in cached_fingerprint[2].items()
}
if 0x2FF in finger[0] and vin == b'JTMWRREV10D058569':
self.fake_ecus.add(Ecu.unknown)
except:
pass
self.packer = CANPacker(dbc_name)
def __init__(self,
dbc_name=None,
car_fingerprint="MIEV",
enable_camera=1,
enable_dsu=1,
enable_apg=1):
self.braking = False
# redundant safety check with the board
self.controls_allowed = True
self.last_steer = 0
self.last_angle = 0
self.accel_steady = 0.
self.car_fingerprint = car_fingerprint
self.alert_active = False
self.last_standstill = False
self.standstill_req = False
self.angle_control = False
self.steer_angle_enabled = False
self.last_fault_frame = -200
self.fake_ecus = set()
if enable_dsu: self.fake_ecus.add(ECU.DSU)
self.packer = CANPacker(dbc_name)
def __init__(self, dbc_name, CP, VM):
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.accel_steady = 0
self.apply_steer_last = 0
self.steer_rate_limited = False
self.lkas11_cnt = 0
self.scc12_cnt = 0
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.last_resume_frame = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above = False
self.driver_steering_torque_above_timer = 100
self.mode_change_timer = 0
self.need_brake = False
self.need_brake_timer = 0
self.params = Params()
self.mode_change_switch = int(
self.params.get('CruiseStatemodeSelInit'))
self.opkr_variablecruise = int(self.params.get('OpkrVariableCruise'))
self.opkr_autoresume = int(self.params.get('OpkrAutoResume'))
self.opkr_autoresumeoption = int(
self.params.get('OpkrAutoResumeOption'))
self.opkr_maxanglelimit = int(self.params.get('OpkrMaxAngleLimit'))
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.leadcar_status = ""
self.timer1 = tm.CTime1000("time")
self.SC = Spdctrl()
self.model_speed = 0
self.model_sum = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.dRel2 = 0
self.yRel2 = 0
self.vRel2 = 0
self.lead2_status = False
self.cut_in_detection = 0
self.target_map_speed = 0
self.target_map_speed_camera = 0
self.v_set_dis_prev = 180
self.cruise_gap = 0.0
self.cruise_gap_prev = 0
self.cruise_gap_set_init = 0
self.cruise_gap_switch_timer = 0
self.standstill_fault_reduce_timer = 0
self.cruise_gap_prev2 = 0
self.cruise_gap_switch_timer2 = 0
self.cruise_gap_switch_timer3 = 0
self.standstill_status = 0
self.standstill_status_timer = 0
self.res_switch_timer = 0
self.lkas_button_on = True
self.longcontrol = CP.openpilotLongitudinalControl
self.scc_live = not CP.radarOffCan
self.accActive = False
self.angle_differ_range = [0, 45]
self.steerMax_range = [
int(self.params.get('SteerMaxBaseAdj')), SteerLimitParams.STEER_MAX
]
self.steerDeltaUp_range = [int(self.params.get('SteerDeltaUpAdj')), 5]
self.steerDeltaDown_range = [
int(self.params.get('SteerDeltaDownAdj')), 10
]
self.steerMax = int(self.params.get('SteerMaxBaseAdj'))
self.steerDeltaUp = int(self.params.get('SteerDeltaUpAdj'))
self.steerDeltaDown = int(self.params.get('SteerDeltaDownAdj'))
self.steerMax_prev = int(self.params.get('SteerMaxBaseAdj'))
self.steerDeltaUp_prev = int(self.params.get('SteerDeltaUpAdj'))
self.steerDeltaDown_prev = int(self.params.get('SteerDeltaDownAdj'))
self.steerMax_timer = 0
self.steerDeltaUp_timer = 0
self.steerDeltaDown_timer = 0
if CP.lateralTuning.which() == 'pid':
self.str_log2 = 'T={:0.2f}/{:0.3f}/{:0.5f}'.format(
CP.lateralTuning.pid.kpV[1], CP.lateralTuning.pid.kiV[1],
CP.lateralTuning.pid.kf)
elif CP.lateralTuning.which() == 'indi':
self.str_log2 = 'T={:03.1f}/{:03.1f}/{:03.1f}/{:03.1f}'.format(
CP.lateralTuning.indi.innerLoopGain,
CP.lateralTuning.indi.outerLoopGain,
CP.lateralTuning.indi.timeConstant,
CP.lateralTuning.indi.actuatorEffectiveness)
elif CP.lateralTuning.which() == 'lqr':
self.str_log2 = 'T={:04.0f}/{:05.3f}/{:06.4f}'.format(
CP.lateralTuning.lqr.scale, CP.lateralTuning.lqr.ki,
CP.lateralTuning.lqr.dcGain)
if CP.spasEnabled:
self.en_cnt = 0
self.apply_steer_ang = 0.0
self.en_spas = 3
self.mdps11_stat_last = 0
self.spas_always = False
self.p = SteerLimitParams
def __init__(self, dbc_name, CP, VM):
self.fleet_speed_state = 0
self.cc_counter = 0
self.alcaStateData = None
self.icLeadsData = None
self.params = Params()
self.braking = False
self.brake_steady = 0.
self.brake_last = 0.
self.packer = CANPacker(dbc_name)
self.epas_disabled = True
self.last_angle = 0.
self.last_accel = 0.
self.blinker = Blinker()
self.ALCA = ALCAController(self, True,
True) # Enabled and SteerByAngle both True
self.ACC = ACCController(self)
self.PCC = PCCController(self)
self.HSO = HSOController(self)
self.GYRO = GYROController()
self.AHB = AHBController(self)
self.sent_DAS_bootID = False
self.speedlimit = None
self.trafficevents = messaging.sub_sock('trafficEvents', conflate=True)
self.pathPlan = messaging.sub_sock('pathPlan', conflate=True)
self.radarState = messaging.sub_sock('radarState', conflate=True)
self.icLeads = messaging.sub_sock('uiIcLeads', conflate=True)
self.icCarLR = messaging.sub_sock('uiIcCarLR', conflate=True)
self.alcaState = messaging.sub_sock('alcaState', conflate=True)
self.gpsLocationExternal = None
self.opState = 0 # 0-disabled, 1-enabled, 2-disabling, 3-unavailable, 5-warning
self.accPitch = 0.
self.accRoll = 0.
self.accYaw = 0.
self.magPitch = 0.
self.magRoll = 0.
self.magYaw = 0.
self.gyroPitch = 0.
self.gyroRoll = 0.
self.gyroYaw = 0.
self.set_speed_limit_active = False
self.speed_limit_offset = 0.
self.speed_limit_ms = 0.
# for warnings
self.warningCounter = 0
self.DAS_206_apUnavailable = 0
self.DAS_222_accCameraBlind = 0 #DAS_206 lkas not ebabled
self.DAS_219_lcTempUnavailableSpeed = 0
self.DAS_220_lcTempUnavailableRoad = 0
self.DAS_221_lcAborting = 0
self.DAS_211_accNoSeatBelt = 0
self.DAS_207_lkasUnavailable = 0 #use for manual steer?
self.DAS_208_rackDetected = 0 #use for low battery?
self.DAS_202_noisyEnvironment = 0 #use for planner error?
self.DAS_025_steeringOverride = 0 #another one to use for manual steer?
self.warningNeeded = 0
# items for IC integration for Lane and Lead Car
self.average_over_x_pathplan_values = 1
self.curv0Matrix = MovingAverage(self.average_over_x_pathplan_values)
self.curv1Matrix = MovingAverage(self.average_over_x_pathplan_values)
self.curv2Matrix = MovingAverage(self.average_over_x_pathplan_values)
self.curv3Matrix = MovingAverage(self.average_over_x_pathplan_values)
self.leadDxMatrix = MovingAverage(self.average_over_x_pathplan_values)
self.leadDyMatrix = MovingAverage(self.average_over_x_pathplan_values)
self.leadDx = 0.
self.leadDy = 0.
self.leadClass = 0
self.leadVx = 0.
self.leadId = 0
self.lead2Dx = 0.
self.lead2Dy = 0.
self.lead2Class = 0
self.lead2Vx = 0.
self.lead2Id = 0
self.lLine = 0
self.rLine = 0
self.curv0 = 0.
self.curv1 = 0.
self.curv2 = 0.
self.curv3 = 0.
self.visionCurvC0 = 0.
self.laneRange = 30 #max is 160m but OP has issues with precision beyond 50
self.laneWidth = 0.
self.stopSign_visible = False
self.stopSign_distance = 1000.
self.stopSign_action = 0
self.stopSign_resume = False
self.stopLight_visible = False
self.stopLight_distance = 1000.
self.stopLight_action = 0
self.stopLight_resume = False
self.stopLight_color = 0. #0-unknown, 1-red, 2-yellow, 3-green
self.stopSignWarning = 0
self.stopLightWarning = 0
self.stopSignWarning_last = 0
self.stopLightWarning_last = 0
self.roadSignType = 0xFF
self.roadSignStopDist = 1000.
self.roadSignColor = 0.
self.roadSignControlActive = 0
self.roadSignType_last = 0xFF
self.roadSignDistanceWarning = 50.
self.alca_enabled = False
self.ldwStatus = 0
self.prev_ldwStatus = 0
self.radarVin_idx = 0
self.LDW_ENABLE_SPEED = 16
self.should_ldw = False
self.ldw_numb_frame_end = 0
self.isMetric = (self.params.get("IsMetric") == "1")
self.ahbLead1 = None
def __init__(self, dbc_name, CP, VM):
self.packer = CANPacker(dbc_name)
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.steer_rate_limited = False
self.accel_steady = 0
self.lkas11_cnt = 0
self.scc12_cnt = 0
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.last_resume_frame = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above = False
self.driver_steering_torque_above_timer = 100
self.mode_change_timer = 0
self.need_brake = False
self.need_brake_timer = 0
self.params = Params()
self.mode_change_switch = int(self.params.get("CruiseStatemodeSelInit", encoding='utf8'))
self.opkr_variablecruise = self.params.get("OpkrVariableCruise", encoding='utf8') == "1"
self.opkr_autoresume = self.params.get("OpkrAutoResume", encoding='utf8') == "1"
self.opkr_turnsteeringdisable = self.params.get("OpkrTurnSteeringDisable", encoding='utf8') == "1"
self.opkr_maxanglelimit = float(int(self.params.get("OpkrMaxAngleLimit", encoding='utf8')))
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.leadcar_status = ""
self.timer1 = tm.CTime1000("time")
if self.params.get("OpkrVariableCruiseProfile", encoding='utf8') == "0":
self.SC = Spdctrl()
elif self.params.get("OpkrVariableCruiseProfile", encoding='utf8') == "1":
self.SC = SpdctrlRelaxed()
else:
self.SC = Spdctrl()
self.model_speed = 0
self.curve_speed = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.dRel2 = 0
self.yRel2 = 0
self.vRel2 = 0
self.lead2_status = False
self.cut_in_detection = 0
self.target_map_speed_camera = 0
self.v_set_dis_prev = 180
self.cruise_gap = 0.0
self.cruise_gap_prev = 0
self.cruise_gap_set_init = 0
self.cruise_gap_switch_timer = 0
self.standstill_fault_reduce_timer = 0
self.cruise_gap_prev2 = 0
self.cruise_gap_switch_timer2 = 0
self.cruise_gap_switch_timer3 = 0
self.standstill_status = 0
self.standstill_status_timer = 0
self.res_switch_timer = 0
self.lkas_button_on = True
self.longcontrol = CP.openpilotLongitudinalControl
self.scc_live = not CP.radarOffCan
self.accActive = False
self.safety_camera_timer = 0
self.model_speed_range = [30, 90, 255]
self.steerMax_range = [CarControllerParams.STEER_MAX, int(self.params.get("SteerMaxBaseAdj", encoding='utf8')), int(self.params.get("SteerMaxBaseAdj", encoding='utf8'))]
self.steerDeltaUp_range = [CarControllerParams.STEER_DELTA_UP, int(self.params.get("SteerDeltaUpBaseAdj", encoding='utf8')), int(self.params.get("SteerDeltaUpBaseAdj", encoding='utf8'))]
self.steerDeltaDown_range = [CarControllerParams.STEER_DELTA_DOWN, int(self.params.get("SteerDeltaDownBaseAdj", encoding='utf8')), int(self.params.get("SteerDeltaDownBaseAdj", encoding='utf8'))]
#self.model_speed_range = [0, 30, 255]
#self.steerMax_range = [int(self.params.get('SteerMaxBaseAdj')), int(self.params.get('SteerMaxBaseAdj')), CarControllerParams.STEER_MAX]
#self.steerDeltaUp_range = [int(self.params.get('SteerDeltaUpAdj')), int(self.params.get('SteerDeltaUpAdj')), 5]
#self.steerDeltaDown_range = [int(self.params.get('SteerDeltaDownAdj')), int(self.params.get('SteerDeltaDownAdj')), 10]
self.steerMax = int(self.params.get("SteerMaxBaseAdj", encoding='utf8'))
self.steerDeltaUp = int(self.params.get("SteerDeltaUpBaseAdj", encoding='utf8'))
self.steerDeltaDown = int(self.params.get("SteerDeltaDownBaseAdj", encoding='utf8'))
self.variable_steer_max = self.params.get('OpkrVariableSteerMax', encoding='utf8') == "1"
self.variable_steer_delta = self.params.get('OpkrVariableSteerDelta', encoding='utf8') == "1"
if CP.lateralTuning.which() == 'pid':
self.str_log2 = 'T={:0.2f}/{:0.3f}/{:0.2f}/{:0.5f}'.format(CP.lateralTuning.pid.kpV[1], CP.lateralTuning.pid.kiV[1], CP.lateralTuning.pid.kdV[0], CP.lateralTuning.pid.kf)
elif CP.lateralTuning.which() == 'indi':
self.str_log2 = 'T={:03.1f}/{:03.1f}/{:03.1f}/{:03.1f}'.format(CP.lateralTuning.indi.innerLoopGainV[1], CP.lateralTuning.indi.outerLoopGainV[1], CP.lateralTuning.indi.timeConstantV[1], CP.lateralTuning.indi.actuatorEffectivenessV[1])
elif CP.lateralTuning.which() == 'lqr':
self.str_log2 = 'T={:04.0f}/{:05.3f}/{:06.4f}'.format(CP.lateralTuning.lqr.scale, CP.lateralTuning.lqr.ki, CP.lateralTuning.lqr.dcGain)
if CP.spasEnabled:
self.en_cnt = 0
self.apply_steer_ang = 0.0
self.en_spas = 3
self.mdps11_stat_last = 0
self.spas_always = False
self.p = CarControllerParams
def __init__(self, dbc_name, CP, VM):
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.steer_rate_limited = False
self.last_resume_frame = 0
import crcmod
from opendbc.can.packer import CANPacker
hyundai_checksum = crcmod.mkCrcFun(0x11D, initCrc=0xFD, rev=False, xorOut=0xdf)
dbc_name = 'kia_forte_koup_2013'
packer = CANPacker(dbc_name)
values = {
"CF_Spas_Stat": 5,
"CF_Spas_TestMode": 0,
"CR_Spas_StrAngCmd": 18.5,
"CF_Spas_BeepAlarm": 0,
"CF_Spas_Mode_Seq": 2,
"CF_Spas_AliveCnt": 205,
"CF_Spas_Chksum": 0,
"CF_Spas_PasVol": 0
}
dat = packer.make_can_msg("SPAS11", 0, values)[2]
print(dat)
crc = hyundai_checksum(dat)
values["CF_Spas_Chksum"] = sum(dat[:6]) % 256
#dat = dat[:6]
cs6b = (sum(dat[:6]) % 256)
#cs7b = ((sum(dat[:6]) + dat[7]) % 256)
print(dat)
print(crc)
print(cs6b)
print(values["CF_Spas_Chksum"])
def __init__(self, dbc_name, CP, VM): self.apply_steer_last = 0 self.packer = CANPacker(dbc_name) self.steer_rate_limited = False
def __init__(self, dbc_name, CP, VM):
self.packer = CANPacker(dbc_name)
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.steer_rate_limited = False
self.steer_wind_down = 0
self.accel_steady = 0
self.accel_lim_prev = 0.
self.accel_lim = 0.
self.lastresumeframe = 0
self.fca11supcnt = self.fca11inc = self.fca11alivecnt = self.fca11cnt13 = self.scc11cnt = self.scc12cnt = 0
self.counter_init = False
self.fca11maxcnt = 0xD
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.last_resume_frame = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above = False
self.driver_steering_torque_above_timer = 100
self.mode_change_timer = 0
self.acc_standstill_timer = 0
self.acc_standstill = False
self.need_brake = False
self.need_brake_timer = 0
self.cancel_counter = 0
self.v_cruise_kph_auto_res = 0
self.params = Params()
self.mode_change_switch = int(
self.params.get("CruiseStatemodeSelInit", encoding="utf8"))
self.opkr_variablecruise = self.params.get_bool("OpkrVariableCruise")
self.opkr_autoresume = self.params.get_bool("OpkrAutoResume")
self.opkr_cruisegap_auto_adj = self.params.get_bool("CruiseGapAdjust")
self.opkr_cruise_auto_res = self.params.get_bool("CruiseAutoRes")
self.opkr_cruise_auto_res_option = int(
self.params.get("AutoResOption", encoding="utf8"))
self.opkr_turnsteeringdisable = self.params.get_bool(
"OpkrTurnSteeringDisable")
self.steer_wind_down_enabled = self.params.get_bool("SteerWindDown")
self.opkr_maxanglelimit = float(
int(self.params.get("OpkrMaxAngleLimit", encoding="utf8")))
self.mad_mode_enabled = self.params.get_bool("MadModeEnabled")
self.ldws_fix = self.params.get_bool("LdwsCarFix")
self.apks_enabled = self.params.get_bool("OpkrApksEnable")
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.leadcar_status = ""
self.longcontrol = CP.openpilotLongitudinalControl
#self.scc_live is true because CP.radarOffCan is False
self.scc_live = not CP.radarOffCan
self.timer1 = tm.CTime1000("time")
if int(self.params.get("OpkrVariableCruiseProfile",
encoding="utf8")) == 0 and not self.longcontrol:
self.SC = Spdctrl()
elif int(self.params.get(
"OpkrVariableCruiseProfile",
encoding="utf8")) == 1 and not self.longcontrol:
self.SC = SpdctrlRelaxed()
elif self.longcontrol:
self.SC = SpdctrlLong()
self.model_speed = 0
self.curve_speed = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.dRel2 = 0
self.yRel2 = 0
self.vRel2 = 0
self.lead2_status = False
self.cut_in_detection = 0
self.cruise_gap = 0.0
self.cruise_gap_prev = 0
self.cruise_gap_set_init = 0
self.cruise_gap_switch_timer = 0
self.standstill_fault_reduce_timer = 0
self.cruise_gap_prev2 = 0
self.cruise_gap_switch_timer2 = 0
self.cruise_gap_switch_timer3 = 0
self.standstill_status = 0
self.standstill_status_timer = 0
self.res_switch_timer = 0
self.auto_res_timer = 0
self.res_speed = 0
self.res_speed_timer = 0
self.steerMax_base = int(
self.params.get("SteerMaxBaseAdj", encoding="utf8"))
self.steerDeltaUp_base = int(
self.params.get("SteerDeltaUpBaseAdj", encoding="utf8"))
self.steerDeltaDown_base = int(
self.params.get("SteerDeltaDownBaseAdj", encoding="utf8"))
self.model_speed_range = [30, 100, 255]
self.steerMax_range = [
CarControllerParams.STEER_MAX, self.steerMax_base,
self.steerMax_base
]
self.steerDeltaUp_range = [
CarControllerParams.STEER_DELTA_UP, self.steerDeltaUp_base,
self.steerDeltaUp_base
]
self.steerDeltaDown_range = [
CarControllerParams.STEER_DELTA_DOWN, self.steerDeltaDown_base,
self.steerDeltaDown_base
]
self.steerMax = 0
self.steerDeltaUp = 0
self.steerDeltaDown = 0
self.variable_steer_max = self.params.get_bool("OpkrVariableSteerMax")
self.variable_steer_delta = self.params.get_bool(
"OpkrVariableSteerDelta")
if CP.lateralTuning.which() == 'pid':
self.str_log2 = 'T={:0.2f}/{:0.3f}/{:0.2f}/{:0.5f}'.format(
CP.lateralTuning.pid.kpV[1], CP.lateralTuning.pid.kiV[1],
CP.lateralTuning.pid.kdV[0], CP.lateralTuning.pid.kf)
elif CP.lateralTuning.which() == 'indi':
self.str_log2 = 'T={:03.1f}/{:03.1f}/{:03.1f}/{:03.1f}'.format(CP.lateralTuning.indi.innerLoopGainV[0], CP.lateralTuning.indi.outerLoopGainV[0], \
CP.lateralTuning.indi.timeConstantV[0], CP.lateralTuning.indi.actuatorEffectivenessV[0])
elif CP.lateralTuning.which() == 'lqr':
self.str_log2 = 'T={:04.0f}/{:05.3f}/{:06.4f}'.format(
CP.lateralTuning.lqr.scale, CP.lateralTuning.lqr.ki,
CP.lateralTuning.lqr.dcGain)
self.p = CarControllerParams
self.sm = messaging.SubMaster(['controlsState'])
def __init__(self, dbc_name, CP, VM):
self.car_fingerprint = CP.carFingerprint
self.packer = CANPacker(dbc_name)
self.accel_steady = 0
self.apply_steer_last = 0
self.steer_rate_limited = False
self.lkas11_cnt = 0
self.scc12_cnt = 0
self.resume_cnt = 0
self.last_lead_distance = 0
self.resume_wait_timer = 0
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above_timer = 0
self.mode_change_timer = 0
self.params = Params()
self.mode_change_switch = int(
self.params.get('CruiseStatemodeSelInit'))
self.opkr_variablecruise = int(self.params.get('OpkrVariableCruise'))
self.opkr_autoresume = int(self.params.get('OpkrAutoResume'))
self.steer_mode = ""
self.mdps_status = ""
self.lkas_switch = ""
self.timer1 = tm.CTime1000("time")
self.SC = Spdctrl()
self.model_speed = 0
self.model_sum = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.cruise_gap = 0.0
self.cruise_gap_prev = 0
self.cruise_gap_set_init = 0
self.cruise_gap_switch_timer = 0
self.lkas_button_on = True
self.longcontrol = CP.openpilotLongitudinalControl
self.scc_live = not CP.radarOffCan
if CP.lateralTuning.which() == 'pid':
self.str_log2 = 'TUNE={:0.2f}/{:0.3f}/{:0.5f}'.format(
CP.lateralTuning.pid.kpV[1], CP.lateralTuning.pid.kiV[1],
CP.lateralTuning.pid.kf)
elif CP.lateralTuning.which() == 'indi':
self.str_log2 = 'TUNE={:03.1f}/{:03.1f}/{:03.1f}/{:03.1f}'.format(
CP.lateralTuning.indi.innerLoopGain,
CP.lateralTuning.indi.outerLoopGain,
CP.lateralTuning.indi.timeConstant,
CP.lateralTuning.indi.actuatorEffectiveness)
elif CP.lateralTuning.which() == 'lqr':
self.str_log2 = 'TUNE={:04.0f}/{:05.3f}/{:06.4f}'.format(
CP.lateralTuning.lqr.scale, CP.lateralTuning.lqr.ki,
CP.lateralTuning.lqr.dcGain)
if CP.spasEnabled:
self.en_cnt = 0
self.apply_steer_ang = 0.0
self.en_spas = 3
self.mdps11_stat_last = 0
self.spas_always = False
("STEER_TORQUE_REQUEST", 0xe4, 0),
("COMPUTER_BRAKE", 0x1fa, 0),
("COMPUTER_BRAKE_REQUEST", 0x1fa, 0),
("GAS_COMMAND", 0x200, 0),
]
checks = [
(0xe4, 100),
(0x1fa, 50),
(0x200, 50),
]
return CANParser(dbc_f, signals, checks, 0)
cp = get_car_can_parser()
packer = CANPacker("honda_civic_touring_2016_can_generated")
rpacker = CANPacker("acura_ilx_2016_nidec")
SR = 7.5
def angle_to_sangle(angle):
return -math.degrees(angle) * SR
def can_function(pm, speed, angle, idx, cruise_button=0, is_engaged=0):
msg = []
msg.append(
packer.make_can_msg("ENGINE_DATA", 0, {"XMISSION_SPEED": speed}, idx))
msg.append(
packer.make_can_msg(
class CarController():
def __init__(self, dbc_name, CP, VW):
# state
self.acc_enabled_prev = 0
# steering related
self.angle_request_prev = 0
# Direction change statemachine
self.UNBLOCKED = 0
self.BLOCKED = 1
self.BLOCK_LEN = CCP.BLOCK_LEN # Block steer direction change for x samples
self.dir_state = 0
self.block_steering = 0
self.steer_direction_bf_block = 0
self.des_steer_direction_prev = 0
# SteerCommand
self.SteerCommand = SteerCommand
self.trq_fifo = deque([])
self.fault_frame = -200
# Diag
self.doDTCRequests = True # Turn on and off DTC requests
self.checkPN = False # Check partnumbers
self.clearDtcs = False # Set false to stop sending diagnostic requests
self.timeout = 0 # Set to 0 as init
self.diagRequest = {
"byte0": 0x03,
"byte1": 0x19,
"byte2": 0x02,
"byte3": 0x02,
}
self.flowControl = {
"byte0": 0x30,
"byte1": 0x00,
"byte2": 0x00,
"byte3": 0x00,
}
self.clearDTC = {
"byte0": 0x04,
"byte1": 0x14,
"byte2": 0xFF,
"byte3": 0xFF,
"byte4": 0xFF,
}
# Part number
self.cnt = 0 # Init at 0 always
self.sndNxtFrame = 0 # Init at low value
self.dictKeys = ["byte"+str(x) for x in range(8)]
startdid = 0xf1a1 # Start with this DID (Data IDentifier, read UDS Spec for more info)
self.dids = [x for x in range(startdid, startdid+9)]
# Setup detection helper. Routes commands to
# an appropriate CAN bus number.
self.CP = CP
self.packer = CANPacker(DBC[CP.carFingerprint]['pt'])
def max_angle_req(self, current_steer_angle, angle_request_prev, CCP):
"""
Calculate maximum angle request delta/offset from current steering angle.
This is just a helper function that calculates the boundary for min and max
steering angle request. It uses the parameters CCP.MAX_ACT_ANGLE_REQUEST_DIFF
and CCP.STEER_ANGLE_DELTA_REQ_DIFF. To calculate the max and min allowed delta/offset request.
The delta request is just a rate limiter. The request angle cant change more
than CCP.STEER_ANGLE_DELTA_REQ_DIFF per loop.
"""
# determine max and min allowed lka angle request
# based on delta per sample
max_delta_right = angle_request_prev-CCP.STEER_ANGLE_DELTA_REQ_DIFF
max_delta_left = angle_request_prev+CCP.STEER_ANGLE_DELTA_REQ_DIFF
# based on distance from actual steering angle
max_right = current_steer_angle-CCP.MAX_ACT_ANGLE_REQUEST_DIFF
max_left = current_steer_angle+CCP.MAX_ACT_ANGLE_REQUEST_DIFF
return max_right, max_left, max_delta_right, max_delta_left
def dir_change(self, steer_direction, error):
""" Filters out direction changes
Uses a simple state machine to determine if we should
block or allow the steer_direction bits to pass thru.
"""
dessd = steer_direction
dzError = 0 if abs(error) < CCP.DEADZONE else error
tState = -1
# Update prev with desired if just enabled.
self.des_steer_direction_prev = steer_direction if not self.acc_enabled_prev else self.des_steer_direction_prev
# Check conditions for state change
if self.dir_state == self.UNBLOCKED:
tState = self.BLOCKED if (steer_direction != self.des_steer_direction_prev and dzError != 0) else tState
elif self.dir_state == self.BLOCKED:
if (steer_direction == self.steer_direction_bf_block) or (self.block_steering <= 0) or (dzError == 0):
tState = self.UNBLOCKED
# State transition
if tState == self.UNBLOCKED:
self.dir_state = self.UNBLOCKED
elif tState == self.BLOCKED:
self.steer_direction_bf_block = self.des_steer_direction_prev
self.block_steering = self.BLOCK_LEN
self.dir_state = self.BLOCKED
# Run actions in state
if self.dir_state == self.UNBLOCKED:
if dzError == 0:
steer_direction = self.des_steer_direction_prev # Set old request when inside deadzone
if self.dir_state == self.BLOCKED:
self.block_steering -= 1
steer_direction = CCP.STEER_NO
#print("State:{} Sd:{} Sdp:{} Bs:{} Dz:{:.2f} Err:{:.2f}".format(self.dir_state, steer_direction, self.des_steer_direction_prev, self.block_steering, dzError, error))
return steer_direction
def update(self, enabled, CS, frame,
actuators,
visualAlert, leftLaneVisible,
rightLaneVisible, leadVisible,
leftLaneDepart, rightLaneDepart):
""" Controls thread """
# Send CAN commands.
can_sends = []
# run at 50hz
if (frame % 2 == 0):
fingerprint = self.CP.carFingerprint
if enabled and CS.out.vEgo > self.CP.minSteerSpeed:
current_steer_angle = CS.out.steeringAngleDeg
self.SteerCommand.angle_request = actuators.steeringAngleDeg # Desired value from pathplanner
# # windup slower
if self.angle_request_prev * self.SteerCommand.angle_request > 0. and abs(self.SteerCommand.angle_request) > abs(self.angle_request_prev):
angle_rate_lim = interp(CS.out.vEgo, CCP.ANGLE_DELTA_BP, CCP.ANGLE_DELTA_V)
else:
angle_rate_lim = interp(CS.out.vEgo, CCP.ANGLE_DELTA_BP, CCP.ANGLE_DELTA_VU)
self.SteerCommand.angle_request = clip(self.SteerCommand.angle_request, self.angle_request_prev - angle_rate_lim, self.angle_request_prev + angle_rate_lim)
# Create trqlim from angle request (before constraints)
self.SteerCommand.trqlim = 0
if fingerprint in PLATFORM.C1:
#self.SteerCommand.trqlim = -127 if current_steer_angle > self.SteerCommand.angle_request else 127
self.SteerCommand.steer_direction = CCP.STEER
elif fingerprint in PLATFORM.EUCD:
# MIGHT be needed for EUCD
self.SteerCommand.steer_direction = CCP.STEER_RIGHT if current_steer_angle > self.SteerCommand.angle_request else CCP.STEER_LEFT
self.SteerCommand.steer_direction = self.dir_change(self.SteerCommand.steer_direction, current_steer_angle-self.SteerCommand.angle_request) # Filter the direction change
else:
self.SteerCommand.steer_direction = CCP.STEER_NO
self.SteerCommand.trqlim = 0
if fingerprint in PLATFORM.C1:
self.SteerCommand.angle_request = clip(CS.out.steeringAngleDeg, -359.95, 359.90) # Cap values at max min values (Cap 2 steps from max min). Max=359.99445, Min=-360.0384
else:
self.SteerCommand.angle_request = 0
# Count no of consequtive samples of zero torque by lka.
# Try to recover, blocking steering request for 2 seconds.
if fingerprint in PLATFORM.C1:
if enabled and CS.out.vEgo > self.CP.minSteerSpeed:
self.trq_fifo.append(CS.PSCMInfo.LKATorque)
if len(self.trq_fifo) > CCP.N_ZERO_TRQ:
self.trq_fifo.popleft()
else:
self.trq_fifo.clear()
self.fault_frame = -200
if (self.trq_fifo.count(0) >= CCP.N_ZERO_TRQ) and (self.fault_frame == -200):
self.fault_frame = frame+100
if enabled and (frame < self.fault_frame):
self.SteerCommand.steer_direction = CCP.STEER_NO
if frame > self.fault_frame+8: # Ignore steerWarning for another 8 samples.
self.fault_frame = -200
# update stored values
self.acc_enabled_prev = enabled
self.angle_request_prev = self.SteerCommand.angle_request
if self.SteerCommand.steer_direction == CCP.STEER_RIGHT or self.SteerCommand.steer_direction == CCP.STEER_LEFT: # TODO: Move this inside dir_change, think it should work?
self.des_steer_direction_prev = self.SteerCommand.steer_direction # Used for dir_change function
# Manipulate data from servo to FSM
# Avoid fault codes, that will stop LKA
can_sends.append(volvocan.manipulateServo(self.packer, self.CP.carFingerprint, CS))
# send can, add to list.
can_sends.append(volvocan.create_steering_control(self.packer, frame, self.CP.carFingerprint, self.SteerCommand, CS.FSMInfo))
# Cancel ACC if engaged when OP is not.
if not enabled and CS.out.cruiseState.enabled:
can_sends.append(volvocan.cancelACC(self.packer, self.CP.carFingerprint, CS))
# Send diagnostic requests
if(self.doDTCRequests):
if(frame % 100 == 0) and (not self.clearDtcs):
# Request diagnostic codes, 2 Hz
can_sends.append(self.packer.make_can_msg("diagFSMReq", 2, self.diagRequest))
#can_sends.append(self.packer.make_can_msg("diagGlobalReq", 2, self.diagRequest))
can_sends.append(self.packer.make_can_msg("diagGlobalReq", 0, self.diagRequest))
#can_sends.append(self.packer.make_can_msg("diagPSCMReq", 0, self.diagRequest))
#can_sends.append(self.packer.make_can_msg("diagCEMReq", 0, self.diagRequest))
#can_sends.append(self.packer.make_can_msg("diagCVMReq", 0, self.diagRequest))
self.timeout = frame + 5 # Set wait time
# Handle flow control in case of many DTC
if frame > self.timeout and self.timeout > 0: # Wait fix time before sending flow control, otherwise just spamming...
self.timeout = 0
if (CS.diag.diagFSMResp & 0x10000000):
can_sends.append(self.packer.make_can_msg("diagFSMReq", 2, self.flowControl))
if (CS.diag.diagCEMResp & 0x10000000):
can_sends.append(self.packer.make_can_msg("diagCEMReq", 0, self.flowControl))
if (CS.diag.diagPSCMResp & 0x10000000):
can_sends.append(self.packer.make_can_msg("diagPSCMReq", 0, self.flowControl))
if (CS.diag.diagCVMResp & 0x10000000):
can_sends.append(self.packer.make_can_msg("diagCVMReq", 0, self.flowControl))
# Check part numbers
if self.checkPN and frame > 100 and frame > self.sndNxtFrame:
if self.cnt < len(self.dids):
did = [0x03, 0x22, (self.dids[self.cnt] & 0xff00)>>8, self.dids[self.cnt] & 0x00ff] # Create diagnostic command
did.extend([0]*(8-len(did)))
diagReq = dict(zip(self.dictKeys,did))
#can_sends.append(self.packer.make_can_msg("diagGlobalReq", 2, diagReq))
#can_sends.append(self.packer.make_can_msg("diagGlobalReq", 0, diagReq))
can_sends.append(self.packer.make_can_msg("diagFSMReq", 2, diagReq))
can_sends.append(self.packer.make_can_msg("diagCEMReq", 0, diagReq))
can_sends.append(self.packer.make_can_msg("diagPSCMReq", 0, diagReq))
can_sends.append(self.packer.make_can_msg("diagCVMReq", 0, diagReq))
self.cnt += 1
self.timeout = frame+5 # When to send flowControl
self.sndNxtFrame = self.timeout+5 # When to send next part number request
elif True: # Stop when list has been looped thru.
self.checkPN = False
# Clear DTCs in FSM on start
# TODO check for engine running before clearing dtc.
if(self.clearDtcs and (frame > 0) and (frame % 500 == 0)):
can_sends.append(self.packer.make_can_msg("diagGlobalReq", 0, self.clearDTC))
can_sends.append(self.packer.make_can_msg("diagFSMReq", 2, self.clearDTC))
#can_sends.append(self.packer.make_can_msg("diagPSCMReq", 0, self.clearDTC))
#can_sends.append(self.packer.make_can_msg("diagCEMReq", 0, self.clearDTC))
self.clearDtcs = False
return can_sends
from opendbc.can.parser import CANParser
SAFETY_MODE = 2
SAFETY_PARAM = 73
def get_car_can_parser():
dbc_f = 'toyota_highlander_2017_pt_generated'
signals = [
]
checks = [
]
return CANParser(dbc_f, signals, checks, 0)
cp = get_car_can_parser()
packer = CANPacker("toyota_highlander_2017_pt_generated")
rpacker = CANPacker("toyota_adas")
SR = 7.5
def angle_to_sangle(angle):
return - math.degrees(angle) * SR
def can_function(pm, speed, angle, idx, cruise_button=0, is_engaged=False):
msg = []
msg.append(packer.make_can_msg("PCM_CRUISE_2", 0, {"SET_SPEED": speed, "MAIN_ON": 1}, -1))
msg.append(packer.make_can_msg("WHEEL_SPEEDS", 0,
{"WHEEL_SPEED_FL": speed,
"WHEEL_SPEED_FR": speed,
"WHEEL_SPEED_RL": speed,
def __init__(self, dbc_name, CP, VM):
self.apply_steer_last = 0
self.car_fingerprint = CP.carFingerprint
self.cp_oplongcontrol = CP.openpilotLongitudinalControl
self.packer = CANPacker(dbc_name)
self.accel_steady = 0
self.accel_lim_prev = 0.
self.accel_lim = 0.
self.steer_rate_limited = False
self.apply_accel = 0
self.usestockscc = True
self.lead_visible = False
self.lead_debounce = 0
self.prev_gapButton = 0
self.current_veh_speed = 0
self.lfainFingerprint = CP.lfaAvailable
self.vdiff = 0
self.resumebuttoncnt = 0
self.lastresumeframe = 0
self.fca11supcnt = self.fca11inc = self.fca11alivecnt = self.fca11cnt13 = self.scc11cnt = self.scc12cnt = 0
self.counter_init = False
self.fca11maxcnt = 0xD
self.radarDisableActivated = False
self.radarDisableResetTimer = 0
self.radarDisableOverlapTimer = 0
self.sendaccmode = not CP.radarDisablePossible
self.enabled = False
self.sm = messaging.SubMaster(['controlsState'])
self.lanechange_manual_timer = 0
self.emergency_manual_timer = 0
self.driver_steering_torque_above = False
self.driver_steering_torque_above_timer = 100
self.acc_standstill_timer = 0
self.acc_standstill = False
self.params = Params()
self.gapsettingdance = int(self.params.get('OpkrCruiseGapSet'))
self.opkr_variablecruise = int(self.params.get('OpkrVariableCruise'))
self.opkr_autoresume = int(self.params.get('OpkrAutoResume'))
self.opkr_maxanglelimit = int(self.params.get('OpkrMaxAngleLimit'))
self.timer1 = tm.CTime1000("time")
if int(self.params.get('OpkrVariableCruiseProfile')) == 0:
self.SC = Spdctrl()
elif int(self.params.get('OpkrVariableCruiseProfile')) == 1:
self.SC = SpdctrlRelaxed()
else:
self.SC = Spdctrl()
self.model_speed = 0
self.model_sum = 0
self.dRel = 0
self.yRel = 0
self.vRel = 0
self.dRel2 = 0
self.yRel2 = 0
self.vRel2 = 0
self.lead2_status = False
self.cut_in_detection = 0
self.target_map_speed = 0
self.target_map_speed_camera = 0
self.v_set_dis_prev = 180
#self.model_speed_range = [30, 90, 255, 300]
#self.steerMax_range = [SteerLimitParams.STEER_MAX, int(self.params.get('SteerMaxBaseAdj')), int(self.params.get('SteerMaxBaseAdj')), 0]
#self.steerDeltaUp_range = [5, int(self.params.get('SteerDeltaUpAdj')), int(self.params.get('SteerDeltaUpAdj')), 0]
#self.steerDeltaDown_range = [10, int(self.params.get('SteerDeltaDownAdj')), int(self.params.get('SteerDeltaDownAdj')), 0]
self.angle_range = [0, 10, 15, 20, 30, 40, 60] # 호야님 버전 가변 적용
self.SMAX = SteerLimitParams.STEER_MAX # 약 510 이상(SteerMaxBaseAdj의 2배)으로 설정해야 아래 보간 로직이 맞음
self.steerMax_range = [
int(self.params.get('SteerMaxBaseAdj')), self.SMAX * 0.57,
self.SMAX * 0.66, self.SMAX * 0.75, self.SMAX * 0.85,
self.SMAX * 0.93, self.SMAX
]
self.steerDeltaUp_range = [
int(self.params.get('SteerDeltaUpAdj')), 3, 4, 4, 4, 5, 5
]
self.steerDeltaDown_range = [
int(self.params.get('SteerDeltaDownAdj')), 5, 6, 7, 8, 9, 10
]
self.steerMax = int(self.params.get('SteerMaxBaseAdj'))
self.steerDeltaUp = int(self.params.get('SteerDeltaUpAdj'))
self.steerDeltaDown = int(self.params.get('SteerDeltaDownAdj'))
self.variable_steer_max = int(
self.params.get('OpkrVariableSteerMax')) == 1
self.variable_steer_delta = int(
self.params.get('OpkrVariableSteerDelta')) == 1
if CP.lateralTuning.which() == 'pid':
self.str_log2 = 'T={:0.2f}/{:0.3f}/{:0.2f}/{:0.5f}'.format(
CP.lateralTuning.pid.kpV[1], CP.lateralTuning.pid.kiV[1],
CP.lateralTuning.pid.kdV[0], CP.lateralTuning.pid.kf)
elif CP.lateralTuning.which() == 'indi':
self.str_log2 = 'T={:03.1f}/{:03.1f}/{:03.1f}/{:03.1f}'.format(
CP.lateralTuning.indi.innerLoopGain,
CP.lateralTuning.indi.outerLoopGain,
CP.lateralTuning.indi.timeConstant,
CP.lateralTuning.indi.actuatorEffectiveness)
elif CP.lateralTuning.which() == 'lqr':
self.str_log2 = 'T={:04.0f}/{:05.3f}/{:06.4f}'.format(
CP.lateralTuning.lqr.scale, CP.lateralTuning.lqr.ki,
CP.lateralTuning.lqr.dcGain)
self.p = SteerLimitParams
def __init__(self, dbc_name, CP, VM): self.CP = CP self.last_angle = 0 self.packer = CANPacker(dbc_name) self.tesla_can = TeslaCAN(dbc_name, self.packer)
def test_command(self):
packer = CANPacker('chrysler_pacifica_2017_hybrid')
self.assertEqual([0x292, 0, b'\x14\x00\x00\x00\x10\x86', 0],
chryslercan.create_lkas_command(packer, 0, True, 1))
self.assertEqual([0x292, 0, b'\x04\x00\x00\x00\x80\x83', 0],
chryslercan.create_lkas_command(packer, 0, False, 8))
from opendbc.can.packer import CANPacker
max = 500 # increase this if u need more time to start car engine
dbc_name = 'toyota_nodsu_hybrid_pt_generated' # put you correct odbc here (search in values.py)
p = Panda()
p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
dumpsafety = p.health()
if dumpsafety['safety_mode'] == 0:
print(
'Sorry, u need change for some dev branch, if u deserv this copy and past this command:\n\n\necho -en "1" > /data/params/d/DisableUpdates; cd ..; rm -rf openpilot; git clone -b master --recurse-submodules https://github.com/commaai/openpilot; reboot'
)
exit(1)
packer = CANPacker(dbc_name)
values = {
"ACC_TYPE": 1,
}
data = packer.make_can_msg(
"ACC_CONTROL", 0,
values) # maybe u need change this ACC_CONTROL confirm in your odbc
def main():
for i in range(0, max):
print(f"PCM exploit :{data}")
print(
' __ __ .___\n/ \ / \ ____ ____ ____ ____ __| _/\n\ \/\/ // __ \ / \_/ __ \_/ __ \ / __ | \n \ /\ ___/ | | \ ___/\ ___// /_/ | \n \__/\ / \___ > |___| /\___ >\___ >____ | \n \/ \/ \/ \/ \/ \/ \n _________ ________ \n / _____/ ____ / _____/ \n \_____ \ / \/ \ ___ \n / \ | \ \_\ \\\n/_______ /___| /\______ /\n \/ \/ \/ \n'
)
