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' )