Release 260111

opendbc_repo/opendbc/car/body/bodycan.py

@@ -0,0 +1,20 @@
+def create_control(packer, torque_l, torque_r):
+  values = {
+    "TORQUE_L": torque_l,
+    "TORQUE_R": torque_r,
+  }
+
+  return packer.make_can_msg("TORQUE_CMD", 0, values)
+
+
+def body_checksum(address: int, sig, d: bytearray) -> int:
+  crc = 0xFF
+  poly = 0xD5
+  for i in range(len(d) - 2, -1, -1):
+    crc ^= d[i]
+    for _ in range(8):
+      if crc & 0x80:
+        crc = ((crc << 1) ^ poly) & 0xFF
+      else:
+        crc = (crc << 1) & 0xFF
+  return crc

opendbc_repo/opendbc/car/body/carcontroller.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+from opendbc.can import CANPacker
+from opendbc.car import Bus, DT_CTRL
+from opendbc.car.common.pid import PIDController
+from opendbc.car.body import bodycan
+from opendbc.car.body.values import SPEED_FROM_RPM
+from opendbc.car.interfaces import CarControllerBase
+
+MAX_TORQUE = 500
+MAX_TORQUE_RATE = 50
+MAX_ANGLE_ERROR = np.radians(7)
+MAX_POS_INTEGRATOR = 0.2   # meters
+MAX_TURN_INTEGRATOR = 0.1  # meters
+
+
+class CarController(CarControllerBase):
+  def __init__(self, dbc_names, CP):
+    super().__init__(dbc_names, CP)
+    self.packer = CANPacker(dbc_names[Bus.main])
+
+    # PIDs
+    self.turn_pid = PIDController(110, k_i=11.5, rate=1 / DT_CTRL)
+    self.wheeled_speed_pid = PIDController(110, k_i=11.5, rate=1 / DT_CTRL)
+
+    self.torque_r_filtered = 0.
+    self.torque_l_filtered = 0.
+
+  @staticmethod
+  def deadband_filter(torque, deadband):
+    if torque > 0:
+      torque += deadband
+    else:
+      torque -= deadband
+    return torque
+
+  def update(self, CC, CS, now_nanos):
+
+    torque_l = 0
+    torque_r = 0
+
+    if CC.enabled:
+      # Read these from the joystick
+      # TODO: this isn't acceleration, okay?
+      speed_desired = CC.actuators.accel / 5.
+      speed_diff_desired = -CC.actuators.torque / 2.
+
+      speed_measured = SPEED_FROM_RPM * (CS.out.wheelSpeeds.fl + CS.out.wheelSpeeds.fr) / 2.
+      speed_error = speed_desired - speed_measured
+
+      torque = self.wheeled_speed_pid.update(speed_error, freeze_integrator=False)
+
+      speed_diff_measured = SPEED_FROM_RPM * (CS.out.wheelSpeeds.fl - CS.out.wheelSpeeds.fr)
+      turn_error = speed_diff_measured - speed_diff_desired
+      freeze_integrator = ((turn_error < 0 and self.turn_pid.error_integral <= -MAX_TURN_INTEGRATOR) or
+                           (turn_error > 0 and self.turn_pid.error_integral >= MAX_TURN_INTEGRATOR))
+      torque_diff = self.turn_pid.update(turn_error, freeze_integrator=freeze_integrator)
+
+      # Combine 2 PIDs outputs
+      torque_r = torque + torque_diff
+      torque_l = torque - torque_diff
+
+      # Torque rate limits
+      self.torque_r_filtered = np.clip(self.deadband_filter(torque_r, 10),
+                                       self.torque_r_filtered - MAX_TORQUE_RATE,
+                                       self.torque_r_filtered + MAX_TORQUE_RATE)
+      self.torque_l_filtered = np.clip(self.deadband_filter(torque_l, 10),
+                                       self.torque_l_filtered - MAX_TORQUE_RATE,
+                                       self.torque_l_filtered + MAX_TORQUE_RATE)
+      torque_r = int(np.clip(self.torque_r_filtered, -MAX_TORQUE, MAX_TORQUE))
+      torque_l = int(np.clip(self.torque_l_filtered, -MAX_TORQUE, MAX_TORQUE))
+
+    can_sends = []
+    can_sends.append(bodycan.create_control(self.packer, torque_l, torque_r))
+
+    new_actuators = CC.actuators.as_builder()
+    new_actuators.accel = torque_l
+    new_actuators.torque = torque_r
+    new_actuators.torqueOutputCan = torque_r
+
+    self.frame += 1
+    return new_actuators, can_sends

opendbc_repo/opendbc/car/body/carstate.py

@@ -0,0 +1,35 @@
+from opendbc.can import CANParser
+from opendbc.car import Bus, structs
+from opendbc.car.interfaces import CarStateBase
+from opendbc.car.body.values import DBC
+
+
+class CarState(CarStateBase):
+  def update(self, can_parsers) -> structs.CarState:
+    cp = can_parsers[Bus.main]
+    ret = structs.CarState()
+
+    ret.wheelSpeeds.fl = cp.vl['MOTORS_DATA']['SPEED_L']
+    ret.wheelSpeeds.fr = cp.vl['MOTORS_DATA']['SPEED_R']
+
+    ret.vEgoRaw = ((ret.wheelSpeeds.fl + ret.wheelSpeeds.fr) / 2.) * self.CP.wheelSpeedFactor
+
+    ret.vEgo, ret.aEgo = self.update_speed_kf(ret.vEgoRaw)
+    ret.standstill = False
+
+    ret.steerFaultPermanent = any([cp.vl['VAR_VALUES']['MOTOR_ERR_L'], cp.vl['VAR_VALUES']['MOTOR_ERR_R'],
+                                   cp.vl['VAR_VALUES']['FAULT']])
+
+    ret.charging = cp.vl["BODY_DATA"]["CHARGER_CONNECTED"] == 1
+    ret.fuelGauge = cp.vl["BODY_DATA"]["BATT_PERCENTAGE"] / 100
+
+    # irrelevant for non-car
+    ret.gearShifter = structs.CarState.GearShifter.drive
+    ret.cruiseState.enabled = True
+    ret.cruiseState.available = True
+
+    return ret
+
+  @staticmethod
+  def get_can_parsers(CP):
+    return {Bus.main: CANParser(DBC[CP.carFingerprint][Bus.main], [], 0)}

opendbc_repo/opendbc/car/body/fingerprints.py

@@ -0,0 +1,28 @@
+""" AUTO-FORMATTED USING opendbc/car/debug/format_fingerprints.py, EDIT STRUCTURE THERE."""
+from opendbc.car.structs import CarParams
+from opendbc.car.body.values import CAR
+
+Ecu = CarParams.Ecu
+
+# debug ecu fw version is the git hash of the firmware
+
+
+FINGERPRINTS = {
+  CAR.COMMA_BODY: [{
+    513: 8, 516: 8, 514: 3, 515: 4
+  }],
+}
+
+FW_VERSIONS = {
+  CAR.COMMA_BODY: {
+    (Ecu.engine, 0x720, None): [
+      b'0.0.01',
+      b'0.3.00a',
+      b'02/27/2022',
+    ],
+    (Ecu.debug, 0x721, None): [
+      b'166bd860',
+      b'dc780f85',
+    ],
+  },
+}

opendbc_repo/opendbc/car/body/interface.py

@@ -0,0 +1,30 @@
+import math
+from opendbc.car import get_safety_config, structs
+from opendbc.car.body.carcontroller import CarController
+from opendbc.car.body.carstate import CarState
+from opendbc.car.body.values import SPEED_FROM_RPM
+from opendbc.car.interfaces import CarInterfaceBase
+
+
+class CarInterface(CarInterfaceBase):
+  CarState = CarState
+  CarController = CarController
+
+  @staticmethod
+  def _get_params(ret: structs.CarParams, candidate, fingerprint, car_fw, alpha_long, is_release, docs) -> structs.CarParams:
+    ret.notCar = True
+    ret.brand = "body"
+    ret.safetyConfigs = [get_safety_config(structs.CarParams.SafetyModel.body)]
+
+    ret.minSteerSpeed = -math.inf
+    ret.maxLateralAccel = math.inf  # TODO: set to a reasonable value
+    ret.steerLimitTimer = 1.0
+    ret.steerActuatorDelay = 0.
+
+    ret.wheelSpeedFactor = SPEED_FROM_RPM
+
+    ret.radarUnavailable = True
+    ret.openpilotLongitudinalControl = True
+    ret.steerControlType = structs.CarParams.SteerControlType.angle
+
+    return ret

opendbc_repo/opendbc/car/body/values.py

@@ -0,0 +1,40 @@
+from opendbc.car import Bus, CarSpecs, PlatformConfig, Platforms
+from opendbc.car.structs import CarParams
+from opendbc.car.docs_definitions import CarDocs
+from opendbc.car.fw_query_definitions import FwQueryConfig, Request, StdQueries
+
+Ecu = CarParams.Ecu
+
+SPEED_FROM_RPM = 0.008587
+
+
+class CarControllerParams:
+  ANGLE_DELTA_BP = [0., 5., 15.]
+  ANGLE_DELTA_V = [5., .8, .15]     # windup limit
+  ANGLE_DELTA_VU = [5., 3.5, 0.4]   # unwind limit
+  LKAS_MAX_TORQUE = 1               # A value of 1 is easy to overpower
+  STEER_THRESHOLD = 1.0
+
+  def __init__(self, CP):
+    pass
+
+
+class CAR(Platforms):
+  COMMA_BODY = PlatformConfig(
+    [CarDocs("comma body", package="All")],
+    CarSpecs(mass=9, wheelbase=0.406, steerRatio=0.5, centerToFrontRatio=0.44),
+    {Bus.main: 'comma_body'},
+  )
+
+
+FW_QUERY_CONFIG = FwQueryConfig(
+  requests=[
+    Request(
+      [StdQueries.TESTER_PRESENT_REQUEST, StdQueries.UDS_VERSION_REQUEST],
+      [StdQueries.TESTER_PRESENT_RESPONSE, StdQueries.UDS_VERSION_RESPONSE],
+      bus=0,
+    ),
+  ],
+)
+
+DBC = CAR.create_dbc_map()