selfdrive.car package

Subpackages

Submodules

selfdrive.car.car_helpers module

selfdrive.car.car_helpers.can_fingerprint(next_can: Callable) → tuple[str | None, dict[int, dict]][source]

selfdrive.car.car_helpers.fingerprint(logcan, sendcan, num_pandas)[source]

selfdrive.car.car_helpers.get_car(logcan, sendcan, experimental_long_allowed, num_pandas=1)[source]

selfdrive.car.car_helpers.get_car_interface(CP)[source]

selfdrive.car.car_helpers.get_demo_car_params()[source]

selfdrive.car.car_helpers.get_one_can(logcan)[source]

selfdrive.car.car_helpers.get_startup_event(car_recognized, controller_available, fw_seen)[source]

selfdrive.car.car_helpers.load_interfaces(brand_names)[source]

selfdrive.car.car_helpers.write_car_param(platform=<CAR.MOCK>)[source]

selfdrive.car.card module

class selfdrive.car.card.CarD(CI=None)[source]

Bases: object

CI: CarInterfaceBase

CS: <capnp.lib.capnp._StructModule object at 0x7f3810d50590>

controls_update(CC: <capnp.lib.capnp._StructModule object at 0x7f3810d52b50>)[source]: control update loop, driven by carControl

initialize()[source]: Initialize CarInterface, once controls are ready

state_publish()[source]: carState and carParams publish loop

state_update()[source]: carState update loop, driven by can

selfdrive.car.disable_ecu module

selfdrive.car.disable_ecu.disable_ecu(logcan, sendcan, bus=0, addr=2000, sub_addr=None, com_cont_req=b'(\x83\x01', timeout=0.1, retry=10, debug=False)[source]

Silence an ECU by disabling sending and receiving messages using UDS 0x28. The ECU will stay silent as long as openpilot keeps sending Tester Present.

This is used to disable the radar in some cars. Openpilot will emulate the radar. WARNING: THIS DISABLES AEB!

selfdrive.car.docs module

selfdrive.car.docs.generate_cars_md(all_car_docs: list[CarDocs], template_fn: str) → str[source]

selfdrive.car.docs.get_all_car_docs() → list[CarDocs][source]

selfdrive.car.docs.get_all_footnotes() → dict[Enum, int][source]

selfdrive.car.docs.group_by_make(all_car_docs: list[CarDocs]) → dict[str, list[CarDocs]][source]

selfdrive.car.docs_definitions module

class selfdrive.car.docs_definitions.Accessory(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

comma_power_v2 = BasePart(name='comma power v2', parts=[])

harness_box = BasePart(name='harness box', parts=[])

class selfdrive.car.docs_definitions.BaseCarHarness(name: str, parts: list[enum.Enum] = <factory>, has_connector: bool = True)[source]

Bases: BasePart

has_connector: bool = True

parts: list[Enum]

class selfdrive.car.docs_definitions.BasePart(name: str, parts: list[enum.Enum] = <factory>)[source]

Bases: object

all_parts()[source]

name: str

parts: list[Enum]

class selfdrive.car.docs_definitions.Cable(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

long_obdc_cable = BasePart(name='long OBD-C cable', parts=[])

obd_c_cable_1_5ft = BasePart(name='OBD-C cable (1.5 ft)', parts=[])

right_angle_obd_c_cable_1_5ft = BasePart(name='right angle OBD-C cable (1.5 ft)', parts=[])

rj45_cable_7ft = BasePart(name='RJ45 cable (7 ft)', parts=[])

usb_a_2_a_cable = BasePart(name='USB A-A cable', parts=[])

usbc_coupler = BasePart(name='USB-C coupler', parts=[])

usbc_otg_cable = BasePart(name='USB C OTG cable', parts=[])

class selfdrive.car.docs_definitions.CarDocs(name: str, package: str, requirements: str | None = None, video_link: str | None = None, footnotes: list[enum.Enum] = <factory>, min_steer_speed: float | None = None, min_enable_speed: float | None = None, auto_resume: bool | None = None, car_parts: selfdrive.car.docs_definitions.CarParts = <factory>)[source]

Bases: object

auto_resume: bool | None = None

car_parts: CarParts

footnotes: list[Enum]

get_column(column: Column, star_icon: str, video_icon: str, footnote_tag: str) → str[source]

get_detail_sentence(CP)[source]

init(CP: <capnp.lib.capnp._StructModule object at 0x7f3810d53d10>, all_footnotes: dict[~enum.Enum, int])[source]

init_make(CP: <capnp.lib.capnp._StructModule object at 0x7f3810d53d10>)[source]: CarDocs subclasses can add make-specific logic for harness selection, footnotes, etc.

min_enable_speed: float | None = None

min_steer_speed: float | None = None

name: str

package: str

requirements: str | None = None

video_link: str | None = None

class selfdrive.car.docs_definitions.CarFootnote(text, column, docs_only, shop_footnote)

Bases: tuple

column: Alias for field number 1

docs_only: Alias for field number 2

shop_footnote: Alias for field number 3

text: Alias for field number 0

class selfdrive.car.docs_definitions.CarHarness(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

bosch_a = BaseCarHarness(name='Honda Bosch A connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

bosch_b = BaseCarHarness(name='Honda Bosch B connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

custom = BaseCarHarness(name='Developer connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

fca = BaseCarHarness(name='FCA connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

ford_q3 = BaseCarHarness(name='Ford Q3 connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

ford_q4 = BaseCarHarness(name='Ford Q4 connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>, <Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>, <Cable.usbc_coupler: BasePart(name='USB-C coupler', parts=[])>], has_connector=True)

gm = BaseCarHarness(name='GM connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>], has_connector=True)

hyundai_a = BaseCarHarness(name='Hyundai A connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_b = BaseCarHarness(name='Hyundai B connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_c = BaseCarHarness(name='Hyundai C connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_d = BaseCarHarness(name='Hyundai D connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_e = BaseCarHarness(name='Hyundai E connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_f = BaseCarHarness(name='Hyundai F connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_g = BaseCarHarness(name='Hyundai G connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_h = BaseCarHarness(name='Hyundai H connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_i = BaseCarHarness(name='Hyundai I connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_j = BaseCarHarness(name='Hyundai J connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_k = BaseCarHarness(name='Hyundai K connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_l = BaseCarHarness(name='Hyundai L connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_m = BaseCarHarness(name='Hyundai M connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_n = BaseCarHarness(name='Hyundai N connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_o = BaseCarHarness(name='Hyundai O connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_p = BaseCarHarness(name='Hyundai P connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_q = BaseCarHarness(name='Hyundai Q connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

hyundai_r = BaseCarHarness(name='Hyundai R connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

j533 = BaseCarHarness(name='J533 connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>, <Cable.usbc_coupler: BasePart(name='USB-C coupler', parts=[])>], has_connector=True)

mazda = BaseCarHarness(name='Mazda connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

nidec = BaseCarHarness(name='Honda Nidec connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

nissan_a = BaseCarHarness(name='Nissan A connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>, <Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>, <Cable.usbc_coupler: BasePart(name='USB-C coupler', parts=[])>], has_connector=True)

nissan_b = BaseCarHarness(name='Nissan B connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>, <Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>, <Cable.usbc_coupler: BasePart(name='USB-C coupler', parts=[])>], has_connector=True)

obd_ii = BaseCarHarness(name='OBD-II connector', parts=[<Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>, <Cable.long_obdc_cable: BasePart(name='long OBD-C cable', parts=[])>], has_connector=False)

ram = BaseCarHarness(name='Ram connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

subaru_a = BaseCarHarness(name='Subaru A connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

subaru_b = BaseCarHarness(name='Subaru B connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

subaru_c = BaseCarHarness(name='Subaru C connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

subaru_d = BaseCarHarness(name='Subaru D connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

toyota_a = BaseCarHarness(name='Toyota A connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

toyota_b = BaseCarHarness(name='Toyota B connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

vw = BaseCarHarness(name='VW connector', parts=[<Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Accessory.comma_power_v2: BasePart(name='comma power v2', parts=[])>, <Cable.rj45_cable_7ft: BasePart(name='RJ45 cable (7 ft)', parts=[])>], has_connector=True)

class selfdrive.car.docs_definitions.CarParts(parts: list[selfdrive.car.docs_definitions.EnumBase] = <factory>)[source]

Bases: object

all_parts()[source]

classmethod common(add: list[EnumBase] = None, remove: list[EnumBase] = None)[source]

parts: list[EnumBase]

class selfdrive.car.docs_definitions.Column(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

AUTO_RESUME = 'Resume from stop'

FSR_LONGITUDINAL = 'No ACC accel below'

FSR_STEERING = 'No ALC below'

HARDWARE = 'Hardware Needed'

LONGITUDINAL = 'ACC'

MAKE = 'Make'

MODEL = 'Model'

PACKAGE = 'Supported Package'

STEERING_TORQUE = 'Steering Torque'

VIDEO = 'Video'

class selfdrive.car.docs_definitions.CommonFootnote(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

EXP_LONG_AVAIL = ('openpilot Longitudinal Control (Alpha) is available behind a toggle; the toggle is only available in non-release branches such as `devel` or `master-ci`.', Column.LONGITUDINAL, True, False)

EXP_LONG_DSU = ('By default, this car will use the stock Adaptive Cruise Control (ACC) for longitudinal control. If the Driver Support Unit (DSU) is disconnected, openpilot ACC will replace stock ACC. <b><i>NOTE: disconnecting the DSU disables Automatic Emergency Braking (AEB).</i></b>', Column.LONGITUDINAL, False, False)

class selfdrive.car.docs_definitions.Device(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

red_panda = BasePart(name='red panda', parts=[])

threex = BasePart(name='comma 3X', parts=[<Mount.mount: BasePart(name='mount', parts=[])>, <Cable.right_angle_obd_c_cable_1_5ft: BasePart(name='right angle OBD-C cable (1.5 ft)', parts=[])>])

threex_angled_mount = BasePart(name='comma 3X', parts=[<Mount.angled_mount_8_degrees: BasePart(name='angled mount (8 degrees)', parts=[])>, <Cable.right_angle_obd_c_cable_1_5ft: BasePart(name='right angle OBD-C cable (1.5 ft)', parts=[])>])

class selfdrive.car.docs_definitions.EnumBase(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

property part_type

class selfdrive.car.docs_definitions.Kit(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

red_panda_kit = BasePart(name='CAN FD panda kit', parts=[<Device.red_panda: BasePart(name='red panda', parts=[])>, <Accessory.harness_box: BasePart(name='harness box', parts=[])>, <Cable.usb_a_2_a_cable: BasePart(name='USB A-A cable', parts=[])>, <Cable.usbc_otg_cable: BasePart(name='USB C OTG cable', parts=[])>, <Cable.obd_c_cable_1_5ft: BasePart(name='OBD-C cable (1.5 ft)', parts=[])>])

class selfdrive.car.docs_definitions.Mount(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

angled_mount_8_degrees = BasePart(name='angled mount (8 degrees)', parts=[])

mount = BasePart(name='mount', parts=[])

class selfdrive.car.docs_definitions.PartType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

accessory = <enum 'Accessory'>

cable = <enum 'Cable'>

connector = <enum 'CarHarness'>

device = <enum 'Device'>

kit = <enum 'Kit'>

mount = <enum 'Mount'>

tool = <enum 'Tool'>

class selfdrive.car.docs_definitions.Star(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

EMPTY = 'empty'

FULL = 'full'

HALF = 'half'

class selfdrive.car.docs_definitions.Tool(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: EnumBase

pry_tool = BasePart(name='Pry Tool', parts=[])

socket_8mm_deep = BasePart(name='Socket Wrench 8mm or 5/16" (deep)', parts=[])

selfdrive.car.docs_definitions.get_footnotes(footnotes: list[Enum], column: Column) → list[Enum][source]

selfdrive.car.docs_definitions.get_year_list(years)[source]

selfdrive.car.docs_definitions.split_name(name: str) → tuple[str, str, str][source]

selfdrive.car.ecu_addrs module

selfdrive.car.ecu_addrs.get_all_ecu_addrs(logcan: SubSocket, sendcan: PubSocket, bus: int, timeout: float = 1, debug: bool = True) → set[tuple[int, int | None, int]][source]

selfdrive.car.ecu_addrs.get_ecu_addrs(logcan: SubSocket, sendcan: PubSocket, queries: set[tuple[int, int | None, int]], responses: set[tuple[int, int | None, int]], timeout: float = 1, debug: bool = False) → set[tuple[int, int | None, int]][source]

selfdrive.car.ecu_addrs.is_tester_present_response(msg: _DynamicStructReader, subaddr: int = None) → bool[source]

selfdrive.car.ecu_addrs.make_tester_present_msg(addr, bus, subaddr=None)[source]

selfdrive.car.fingerprints module

selfdrive.car.fingerprints.all_known_cars()[source]: Returns a list of all known car strings.

selfdrive.car.fingerprints.all_legacy_fingerprint_cars()[source]: Returns a list of all known car strings, FPv1 only.

selfdrive.car.fingerprints.eliminate_incompatible_cars(msg, candidate_cars)[source]

Removes cars that could not have sent msg.

Inputs:: msg: A cereal/log CanData message from the car. candidate_cars: A list of cars to consider.
Returns:: A list containing the subset of candidate_cars that could have sent msg.

selfdrive.car.fingerprints.is_valid_for_fingerprint(msg, car_fingerprint: dict[int, int])[source]

selfdrive.car.fw_query_definitions module

class selfdrive.car.fw_query_definitions.FwQueryConfig(requests: list[selfdrive.car.fw_query_definitions.Request], non_essential_ecus: dict[capnp.lib.capnp._EnumModule, list[str]] = <factory>, extra_ecus: list[tuple[capnp.lib.capnp._EnumModule, int, int | None]] = <factory>, match_fw_to_car_fuzzy: collections.abc.Callable[[dict[tuple[int, int | None], set[bytes]], str, dict[str, dict[tuple[int, int, int | None], list[bytes]]]], set[str]] | None = None)[source]

Bases: object

extra_ecus: list[tuple[_EnumModule, int, int | None]]

get_all_ecus(offline_fw_versions: dict[str, dict[tuple[int, int, int | None], list[bytes]]], include_extra_ecus: bool = True) → set[tuple[int, int, int | None]][source]

match_fw_to_car_fuzzy: Callable[[dict[tuple[int, int | None], set[bytes]], str, dict[str, dict[tuple[int, int, int | None], list[bytes]]]], set[str]] | None = None

non_essential_ecus: dict[_EnumModule, list[str]]

requests: list[Request]

class selfdrive.car.fw_query_definitions.Request(request: list[bytes], response: list[bytes], whitelist_ecus: list[int] = <factory>, rx_offset: int = 8, bus: int = 1, auxiliary: bool = False, logging: bool = False, obd_multiplexing: bool = True)[source]

Bases: object

auxiliary: bool = False

bus: int = 1

logging: bool = False

obd_multiplexing: bool = True

request: list[bytes]

response: list[bytes]

rx_offset: int = 8

whitelist_ecus: list[int]

class selfdrive.car.fw_query_definitions.StdQueries[source]

Bases: object

DEFAULT_DIAGNOSTIC_REQUEST = b'\x10\x01'

DEFAULT_DIAGNOSTIC_RESPONSE = b'P\x01\x002\x01\xf4'

EXTENDED_DIAGNOSTIC_REQUEST = b'\x10\x03'

EXTENDED_DIAGNOSTIC_RESPONSE = b'P\x03\x002\x01\xf4'

GM_VIN_REQUEST = b'\x1a\x90'

GM_VIN_RESPONSE = b'Z\x90'

KWP_VIN_REQUEST = b'!\x81'

KWP_VIN_RESPONSE = b'a\x81'

MANUFACTURER_SOFTWARE_VERSION_REQUEST = b'"\xf1\x88'

MANUFACTURER_SOFTWARE_VERSION_RESPONSE = b'b\xf1\x88'

OBD_VERSION_REQUEST = b'\t\x04'

OBD_VERSION_RESPONSE = b'I\x04'

OBD_VIN_REQUEST = b'\t\x02'

OBD_VIN_RESPONSE = b'I\x02\x01'

SHORT_TESTER_PRESENT_REQUEST = b'>'

SHORT_TESTER_PRESENT_RESPONSE = b'~'

SUPPLIER_SOFTWARE_VERSION_REQUEST = b'"\xf1\x95'

SUPPLIER_SOFTWARE_VERSION_RESPONSE = b'b\xf1\x95'

TESTER_PRESENT_REQUEST = b'>\x00'

TESTER_PRESENT_RESPONSE = b'~\x00'

UDS_VERSION_REQUEST = b'"\xf1\x81'

UDS_VERSION_RESPONSE = b'b\xf1\x81'

UDS_VIN_REQUEST = b'"\xf1\x90'

UDS_VIN_RESPONSE = b'b\xf1\x90'

selfdrive.car.fw_query_definitions.p16(val)[source]

selfdrive.car.fw_versions module

class selfdrive.car.fw_versions.MatchFwToCar(*args, **kwargs)[source]: Bases: Protocol

selfdrive.car.fw_versions.build_fw_dict(fw_versions: list[_DynamicStructBuilder], filter_brand: str = None) → dict[tuple[int, int | None], set[bytes]][source]

selfdrive.car.fw_versions.chunks(l: list[T], n: int = 128) → Iterator[list[T]][source]

selfdrive.car.fw_versions.get_brand_ecu_matches(ecu_rx_addrs: set[tuple[int, int | None, int]]) → dict[str, set[tuple[int, int | None]]][source]: Returns dictionary of brands and matches with ECUs in their FW versions

selfdrive.car.fw_versions.get_fw_versions(logcan, sendcan, query_brand: str = None, extra: dict[str, dict[tuple[int, int, int | None], list[bytes]]] = None, timeout: float = 0.1, num_pandas: int = 1, debug: bool = False, progress: bool = False) → list[_DynamicStructBuilder][source]

selfdrive.car.fw_versions.get_fw_versions_ordered(logcan, sendcan, vin: str, ecu_rx_addrs: set[tuple[int, int | None, int]], timeout: float = 0.1, num_pandas: int = 1, debug: bool = False, progress: bool = False) → list[_DynamicStructBuilder][source]: Queries for FW versions ordering brands by likelihood, breaks when exact match is found

selfdrive.car.fw_versions.get_present_ecus(logcan, sendcan, num_pandas: int = 1) → set[tuple[int, int | None, int]][source]

selfdrive.car.fw_versions.is_brand(brand: str, filter_brand: str | None) → bool[source]: Returns if brand matches filter_brand or no brand filter is specified

selfdrive.car.fw_versions.match_fw_to_car(fw_versions: list[_DynamicStructBuilder], vin: str, allow_exact: bool = True, allow_fuzzy: bool = True, log: bool = True) → tuple[bool, set[str]][source]

selfdrive.car.fw_versions.match_fw_to_car_exact(live_fw_versions: dict[tuple[int, int | None], set[bytes]], match_brand: str = None, log: bool = True, extra_fw_versions: dict = None) → set[str][source]: Do an exact FW match. Returns all cars that match the given FW versions for a list of “essential” ECUs. If an ECU is not considered essential the FW version can be missing to get a fingerprint, but if it’s present it needs to match the database.

selfdrive.car.fw_versions.match_fw_to_car_fuzzy(live_fw_versions: dict[tuple[int, int | None], set[bytes]], match_brand: str = None, log: bool = True, exclude: str = None) → set[str][source]: Do a fuzzy FW match. This function will return a match, and the number of firmware version that were matched uniquely to that specific car. If multiple ECUs uniquely match to different cars the match is rejected.

selfdrive.car.fw_versions.set_obd_multiplexing(params: Params, obd_multiplexing: bool)[source]

selfdrive.car.interfaces module

class selfdrive.car.interfaces.CarControllerBase(dbc_name: str, CP, VM)[source]

Bases: ABC

abstract update(CC: <capnp.lib.capnp._StructModule object at 0x7f3810d52dd0>, CS: <capnp.lib.capnp._StructModule object at 0x7f3810d50590>, now_nanos: int) → tuple[<capnp.lib.capnp._StructModule object at 0x7f3810d52dd0>, list[tuple[int, int, bytes, int]]][source]

class selfdrive.car.interfaces.CarInterfaceBase(CP, CarController, CarState)[source]

Bases: ABC

apply(c: <capnp.lib.capnp._StructModule object at 0x7f3810d52b50>, now_nanos: int) → tuple[<capnp.lib.capnp._StructModule object at 0x7f3810d52dd0>, list[tuple[int, int, bytes, int]]][source]

static configure_torque_tune(candidate, tune, steering_angle_deadzone_deg=0.0, use_steering_angle=True)[source]

create_common_events(cs_out, extra_gears=None, pcm_enable=True, allow_enable=True, enable_buttons=(3, 4))[source]

classmethod get_non_essential_params(candidate: str)[source]: Parameters essential to controlling the car may be incomplete or wrong without FW versions or fingerprints.

classmethod get_params(candidate: str, fingerprint: dict[int, dict[int, int]], car_fw: list[<capnp.lib.capnp._StructModule object at 0x7f3810d69d50>], experimental_long: bool, docs: bool)[source]

static get_pid_accel_limits(CP, current_speed, cruise_speed)[source]

static get_std_params(candidate)[source]

static get_steer_feedforward_default(desired_angle, v_ego)[source]

get_steer_feedforward_function()[source]

static init(CP, logcan, sendcan)[source]

torque_from_lateral_accel() → _StructModule object at 0x7f3810d68a90>, float, float, bool, bool], float][source]

torque_from_lateral_accel_linear(latcontrol_inputs: ~selfdrive.car.interfaces.LatControlInputs, torque_params: <capnp.lib.capnp._StructModule object at 0x7f3810d68a90>, lateral_accel_error: float, lateral_accel_deadzone: float, friction_compensation: bool, gravity_adjusted: bool) → float[source]

update(c: <capnp.lib.capnp._StructModule object at 0x7f3810d52b50>, can_strings: list[bytes]) → <capnp.lib.capnp._StructModule object at 0x7f3810d50590>[source]

class selfdrive.car.interfaces.CarStateBase(CP)[source]

Bases: ABC

static get_adas_can_parser(CP)[source]

static get_body_can_parser(CP)[source]

static get_cam_can_parser(CP)[source]

static get_can_parser(CP)[source]

static get_loopback_can_parser(CP)[source]

get_wheel_speeds(fl, fr, rl, rr, unit=0.2777777777777778)[source]

static parse_gear_shifter(gear: str | None) → <capnp.lib.capnp._EnumModule object at 0x7f3810d51c90>[source]

update_blinker_from_lamp(blinker_time: int, left_blinker_lamp: bool, right_blinker_lamp: bool)[source]: Update blinkers from lights. Enable output when light was seen within the last blinker_time iterations

update_blinker_from_stalk(blinker_time: int, left_blinker_stalk: bool, right_blinker_stalk: bool)[source]: Update blinkers from stalk position. When stalk is seen the blinker will be on for at least blinker_time, or until the stalk is turned off, whichever is longer. If the opposite stalk direction is seen the blinker is forced to the other side. On a rising edge of the stalk the timeout is reset.

update_speed_kf(v_ego_raw)[source]

update_steering_pressed(steering_pressed, steering_pressed_min_count)[source]: Applies filtering on steering pressed for noisy driver torque signals.

class selfdrive.car.interfaces.LatControlInputs(lateral_acceleration, roll_compensation, vego, aego)[source]

Bases: NamedTuple

aego: float: Alias for field number 3

lateral_acceleration: float: Alias for field number 0

roll_compensation: float: Alias for field number 1

vego: float: Alias for field number 2

class selfdrive.car.interfaces.NanoFFModel(weights_loc: str, platform: str)[source]

Bases: object

forward(x: ndarray)[source]

load_weights(platform: str)[source]

predict(x: list[float], do_sample: bool = False)[source]

relu(x: ndarray)[source]

class selfdrive.car.interfaces.RadarInterfaceBase(CP)[source]

Bases: ABC

update(can_strings)[source]

selfdrive.car.interfaces.get_interface_attr(attr: str, combine_brands: bool = False, ignore_none: bool = False) → dict[str | StrEnum, Any][source]

selfdrive.car.interfaces.get_torque_params(candidate)[source]

selfdrive.car.isotp_parallel_query module

class selfdrive.car.isotp_parallel_query.IsoTpParallelQuery(sendcan: PubSocket, logcan: SubSocket, bus: int, addrs: list[int] | list[tuple[int, int | None]], request: list[bytes], response: list[bytes], response_offset: int = 8, functional_addrs: list[int] = None, debug: bool = False, response_pending_timeout: float = 10)[source]

Bases: object

get_data(timeout: float, total_timeout: float = 60.0) → dict[tuple[int, int | None], bytes][source]

rx()[source]: Drain can socket and sort messages into buffers based on address

selfdrive.car.values module

selfdrive.car.vin module

selfdrive.car.vin.get_vin(logcan, sendcan, buses, timeout=0.1, retry=2, debug=False)[source]

selfdrive.car.vin.is_valid_vin(vin: str)[source]

Module contents

class selfdrive.car.AngleRateLimit(speed_bp, angle_v)

Bases: tuple

angle_v: Alias for field number 1

speed_bp: Alias for field number 0

class selfdrive.car.CanBusBase(CP, fingerprint: dict[int, dict[int, int]] | None)[source]

Bases: object

offset: int

class selfdrive.car.CanSignalRateCalculator(frequency)[source]

Bases: object

Calculates the instantaneous rate of a CAN signal by using the counter variable and the known frequency of the CAN message that contains it.

update(current_value, current_counter)[source]

class selfdrive.car.CarSpecs(*, mass: float, wheelbase: float, steerRatio: float, centerToFrontRatio: float = 0.5, minSteerSpeed: float = 0.0, minEnableSpeed: float = -1.0, tireStiffnessFactor: float = 1.0)[source]

Bases: object

centerToFrontRatio: float = 0.5

mass: float

minEnableSpeed: float = -1.0

minSteerSpeed: float = 0.0

override(**kwargs)[source]

steerRatio: float

tireStiffnessFactor: float = 1.0

wheelbase: float

class selfdrive.car.PlatformConfig(car_docs: list[openpilot.selfdrive.car.docs_definitions.CarDocs], specs: selfdrive.car.CarSpecs, dbc_dict: dict[str, str], flags: int = 0, platform_str: str | None = None)[source]

Bases: Freezable

car_docs: list[CarDocs]

dbc_dict: dict[str, str]

flags: int = 0

init()[source]

override(**kwargs)[source]

platform_str: str | None = None

specs: CarSpecs

class selfdrive.car.Platforms(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: str, ReprEnum

config: PlatformConfig

classmethod create_dbc_map() → dict[str, dict[str, str]][source]

classmethod print_debug(flags)[source]

classmethod with_flags(flags: IntFlag) → set[Platforms][source]

classmethod without_flags(flags: IntFlag) → set[Platforms][source]

class selfdrive.car.PlatformsType(cls, bases, classdict, *, boundary=None, _simple=False, **kwds)[source]: Bases: EnumType

class selfdrive.car.VehicleDynamicsParams[source]

Bases: object

CENTER_TO_FRONT = 1.08

CENTER_TO_REAR = 1.62

MASS = 1462.0

ROTATIONAL_INERTIA = 2500

TIRE_STIFFNESS_FRONT = 192150

TIRE_STIFFNESS_REAR = 202500

WHEELBASE = 2.7

selfdrive.car.apply_dist_to_meas_limits(val, val_last, val_meas, STEER_DELTA_UP, STEER_DELTA_DOWN, STEER_ERROR_MAX, STEER_MAX)[source]

selfdrive.car.apply_driver_steer_torque_limits(apply_torque, apply_torque_last, driver_torque, LIMITS)[source]

selfdrive.car.apply_hysteresis(val: float, val_steady: float, hyst_gap: float) → float[source]

selfdrive.car.apply_meas_steer_torque_limits(apply_torque, apply_torque_last, motor_torque, LIMITS)[source]

selfdrive.car.apply_std_steer_angle_limits(apply_angle, apply_angle_last, v_ego, LIMITS)[source]

selfdrive.car.common_fault_avoidance(fault_condition: bool, request: bool, above_limit_frames: int, max_above_limit_frames: int, max_mismatching_frames: int = 1)[source]: Several cars have the ability to work around their EPS limits by cutting the request bit of their LKAS message after a certain number of frames above the limit.

selfdrive.car.create_button_events(cur_btn: int, prev_btn: int, buttons_dict: dict[int, _EnumModule], unpressed_btn: int = 0) → list[_DynamicStructBuilder][source]

selfdrive.car.dbc_dict(pt_dbc, radar_dbc, chassis_dbc=None, body_dbc=None) → dict[str, str][source]

selfdrive.car.gen_empty_fingerprint()[source]

selfdrive.car.get_safety_config(safety_model, safety_param=None)[source]

selfdrive.car.make_can_msg(addr, dat, bus)[source]

selfdrive.car.scale_rot_inertia(mass, wheelbase)[source]

selfdrive.car.scale_tire_stiffness(mass, wheelbase, center_to_front, tire_stiffness_factor)[source]