openpilot v0.8.11 release

panda/python/__init__.py

@@ -8,6 +8,7 @@ import os
 import time
 import traceback
 import sys
+from functools import wraps
 from .dfu import PandaDFU, MCU_TYPE_F2, MCU_TYPE_F4, MCU_TYPE_H7  # pylint: disable=import-error
 from .flash_release import flash_release  # noqa pylint: disable=import-error
 from .update import ensure_st_up_to_date  # noqa pylint: disable=import-error
@@ -15,28 +16,105 @@ from .serial import PandaSerial  # noqa pylint: disable=import-error
 from .isotp import isotp_send, isotp_recv  # pylint: disable=import-error
 from .config import DEFAULT_FW_FN, DEFAULT_H7_FW_FN  # noqa pylint: disable=import-error
 
-__version__ = '0.0.9'
+__version__ = '0.0.10'
 
 BASEDIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../")
 
 DEBUG = os.getenv("PANDADEBUG") is not None
 
-def parse_can_buffer(dat):
-  ret = []
-  for j in range(0, len(dat), 0x10):
-    ddat = dat[j:j + 0x10]
-    f1, f2 = struct.unpack("II", ddat[0:8])
-    extended = 4
-    if f1 & extended:
-      address = f1 >> 3
-    else:
-      address = f1 >> 21
-    dddat = ddat[8:8 + (f2 & 0xF)]
+CANPACKET_HEAD_SIZE = 0x5
+DLC_TO_LEN = [0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64]
+LEN_TO_DLC = {length: dlc for (dlc, length) in enumerate(DLC_TO_LEN)}
+
+def pack_can_buffer(arr):
+  snds = [b'']
+  idx = 0
+  for address, _, dat, bus in arr:
+    assert len(dat) in LEN_TO_DLC
     if DEBUG:
-      print(f"  R 0x{address:x}: 0x{dddat.hex()}")
-    ret.append((address, f2 >> 16, dddat, (f2 >> 4) & 0xFF))
+      print(f"  W 0x{address:x}: 0x{dat.hex()}")
+    extended = 1 if address >= 0x800 else 0
+    data_len_code = LEN_TO_DLC[len(dat)]
+    header = bytearray(5)
+    word_4b = address << 3 | extended << 2
+    header[0] = (data_len_code << 4) | (bus << 1)
+    header[1] = word_4b & 0xFF
+    header[2] = (word_4b >> 8) & 0xFF
+    header[3] = (word_4b >> 16) & 0xFF
+    header[4] = (word_4b >> 24) & 0xFF
+    snds[idx] += header + dat
+    if len(snds[idx]) > 256: # Limit chunks to 256 bytes
+      snds.append(b'')
+      idx += 1
+
+  #Apply counter to each 64 byte packet
+  for idx in range(len(snds)):
+    tx = b''
+    counter = 0
+    for i in range (0, len(snds[idx]), 63):
+      tx += bytes([counter]) + snds[idx][i:i+63]
+      counter += 1
+    snds[idx] = tx
+  return snds
+
+def unpack_can_buffer(dat):
+  ret = []
+  counter = 0
+  tail = bytearray()
+  for i in range(0, len(dat), 64):
+    if counter != dat[i]:
+      print("CAN: LOST RECV PACKET COUNTER")
+      break
+    counter+=1
+    chunk = tail + dat[i+1:i+64]
+    tail = bytearray()
+    pos = 0
+    while pos<len(chunk):
+      data_len = DLC_TO_LEN[(chunk[pos]>>4)]
+      pckt_len = CANPACKET_HEAD_SIZE + data_len
+      if pckt_len <= len(chunk[pos:]):
+        header = chunk[pos:pos+CANPACKET_HEAD_SIZE]
+        if len(header) < 5:
+          print("CAN: MALFORMED USB RECV PACKET")
+          break
+        bus = (header[0] >> 1) & 0x7
+        address = (header[4] << 24 | header[3] << 16 | header[2] << 8 | header[1]) >> 3
+        returned = (header[1] >> 1) & 0x1
+        rejected = header[1] & 0x1
+        data = chunk[pos + CANPACKET_HEAD_SIZE:pos + CANPACKET_HEAD_SIZE + data_len]
+        if returned:
+          bus += 128
+        if rejected:
+          bus += 192
+        if DEBUG:
+          print(f"  R 0x{address:x}: 0x{data.hex()}")
+        ret.append((address, 0, data, bus))
+        pos += pckt_len
+      else:
+        tail = chunk[pos:]
+        break
   return ret
 
+def ensure_health_packet_version(fn):
+  @wraps(fn)
+  def wrapper(self, *args, **kwargs):
+    if self.health_version < self.HEALTH_PACKET_VERSION:
+      raise RuntimeError("Panda firmware has outdated health packet definition. Reflash panda firmware.")
+    elif self.health_version > self.HEALTH_PACKET_VERSION:
+      raise RuntimeError("Panda python library has outdated health packet definition. Update panda python library.")
+    return fn(self, *args, **kwargs)
+  return wrapper
+
+def ensure_can_packet_version(fn):
+  @wraps(fn)
+  def wrapper(self, *args, **kwargs):
+    if self.can_version < self.CAN_PACKET_VERSION:
+      raise RuntimeError("Panda firmware has outdated CAN packet definition. Reflash panda firmware.")
+    elif self.can_version > self.CAN_PACKET_VERSION:
+      raise RuntimeError("Panda python library has outdated CAN packet definition. Update panda python library.")
+    return fn(self, *args, **kwargs)
+  return wrapper
+
 class PandaWifiStreaming(object):
   def __init__(self, ip="192.168.0.10", port=1338):
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -55,7 +133,7 @@ class PandaWifiStreaming(object):
       try:
         dat, addr = self.sock.recvfrom(0x200 * 0x10)
         if addr == (self.ip, self.port):
-          ret += parse_can_buffer(dat)
+          ret += unpack_can_buffer(dat)
       except socket.error as e:
         if e.errno != 35 and e.errno != 11:
           traceback.print_exc()
@@ -140,6 +218,9 @@ class Panda(object):
   HW_TYPE_DOS = b'\x06'
   HW_TYPE_RED_PANDA = b'\x07'
 
+  CAN_PACKET_VERSION = 2
+  HEALTH_PACKET_VERSION = 1
+
   F2_DEVICES = [HW_TYPE_PEDAL]
   F4_DEVICES = [HW_TYPE_WHITE_PANDA, HW_TYPE_GREY_PANDA, HW_TYPE_BLACK_PANDA, HW_TYPE_UNO, HW_TYPE_DOS]
   H7_DEVICES = [HW_TYPE_RED_PANDA]
@@ -150,7 +231,13 @@ class Panda(object):
 
   FLAG_HONDA_ALT_BRAKE = 1
   FLAG_HONDA_BOSCH_LONG = 2
+  FLAG_HONDA_NIDEC_ALT = 4
+
+  FLAG_HYUNDAI_EV_GAS = 1
+  FLAG_HYUNDAI_HYBRID_GAS = 2
   FLAG_HYUNDAI_LONG = 4
+  FLAG_TESLA_POWERTRAIN = 1
+  FLAG_TESLA_LONG_CONTROL = 2
 
   def __init__(self, serial=None, claim=True):
     self._serial = serial
@@ -201,6 +288,7 @@ class Panda(object):
           break
         context = usb1.USBContext()  # New context needed so new devices show up
     assert(self._handle is not None)
+    self.health_version, self.can_version = self.get_packets_versions()
     print("connected")
 
   def reset(self, enter_bootstub=False, enter_bootloader=False):
@@ -239,6 +327,8 @@ class Panda(object):
     if not success:
       raise Exception("reconnect failed")
 
+
+
   @staticmethod
   def flash_static(handle, code):
     # confirm flasher is present
@@ -342,6 +432,7 @@ class Panda(object):
 
   # ******************* health *******************
 
+  @ensure_health_packet_version
   def health(self):
     dat = self._handle.controlRead(Panda.REQUEST_IN, 0xd2, 0, 0, 44)
     a = struct.unpack("<IIIIIIIIBBBBBBBHBBB", dat)
@@ -392,6 +483,15 @@ class Panda(object):
   def get_type(self):
     return self._handle.controlRead(Panda.REQUEST_IN, 0xc1, 0, 0, 0x40)
 
+  # Returns tuple with health packet version and CAN packet/USB packet version
+  def get_packets_versions(self):
+    dat = self._handle.controlRead(Panda.REQUEST_IN, 0xdd, 0, 0, 2)
+    if dat:
+      a = struct.unpack("BB", dat)
+      return (a[0], a[1])
+    else:
+      return (0, 0)
+
   def is_white(self):
     return self.get_type() == Panda.HW_TYPE_WHITE_PANDA
 
@@ -409,7 +509,7 @@ class Panda(object):
 
   def is_dos(self):
     return self.get_type() == Panda.HW_TYPE_DOS
-  
+
   def is_red(self):
     return self.get_type() == Panda.HW_TYPE_RED_PANDA
 
@@ -429,12 +529,18 @@ class Panda(object):
   def has_canfd(self):
     return self._mcu_type in Panda.H7_DEVICES
 
+  def is_internal(self):
+    return self.get_type() in [Panda.HW_TYPE_UNO, Panda.HW_TYPE_DOS]
+
   def get_serial(self):
     dat = self._handle.controlRead(Panda.REQUEST_IN, 0xd0, 0, 0, 0x20)
     hashsig, calc_hash = dat[0x1c:], hashlib.sha1(dat[0:0x1c]).digest()[0:4]
     assert(hashsig == calc_hash)
     return [dat[0:0x10].decode("utf8"), dat[0x10:0x10 + 10].decode("utf8")]
 
+  def get_usb_serial(self):
+    return self._serial
+
   def get_secret(self):
     return self._handle.controlRead(Panda.REQUEST_IN, 0xd0, 1, 0, 0x10)
 
@@ -459,10 +565,6 @@ class Panda(object):
       self.set_heartbeat_disabled()
       self.set_power_save(0)
 
-  def set_can_forwarding(self, from_bus, to_bus):
-    # TODO: This feature may not work correctly with saturated buses
-    self._handle.controlWrite(Panda.REQUEST_OUT, 0xdd, from_bus, to_bus, b'')
-
   def set_gmlan(self, bus=2):
     # TODO: check panda type
     if bus is None:
@@ -488,6 +590,15 @@ class Panda(object):
   def set_can_data_speed_kbps(self, bus, speed):
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xf9, bus, int(speed * 10), b'')
 
+    # CAN FD and BRS status
+  def get_canfd_status(self, bus):
+    dat = self._handle.controlRead(Panda.REQUEST_IN, 0xfa, bus, 0, 2)
+    if dat:
+      a = struct.unpack("BB", dat)
+      return (a[0], a[1])
+    else:
+      return (None, None)
+
   def set_uart_baud(self, uart, rate):
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xe4, uart, int(rate / 300), b'')
 
@@ -505,29 +616,22 @@ class Panda(object):
   # Timeout is in ms. If set to 0, the timeout is infinite.
   CAN_SEND_TIMEOUT_MS = 10
 
+  @ensure_can_packet_version
   def can_send_many(self, arr, timeout=CAN_SEND_TIMEOUT_MS):
-    snds = []
-    transmit = 1
-    extended = 4
-    for addr, _, dat, bus in arr:
-      assert len(dat) <= 8
-      if DEBUG:
-        print(f"  W 0x{addr:x}: 0x{dat.hex()}")
-      if addr >= 0x800:
-        rir = (addr << 3) | transmit | extended
-      else:
-        rir = (addr << 21) | transmit
-      snd = struct.pack("II", rir, len(dat) | (bus << 4)) + dat
-      snd = snd.ljust(0x10, b'\x00')
-      snds.append(snd)
-
+    snds = pack_can_buffer(arr)
     while True:
       try:
         if self.wifi:
           for s in snds:
             self._handle.bulkWrite(3, s)
         else:
-          self._handle.bulkWrite(3, b''.join(snds), timeout=timeout)
+          for tx in snds:
+            while True:
+              bs = self._handle.bulkWrite(3, tx, timeout=timeout)
+              tx = tx[bs:]
+              if len(tx) == 0:
+                break
+              print("CAN: PARTIAL SEND MANY, RETRYING")
         break
       except (usb1.USBErrorIO, usb1.USBErrorOverflow):
         print("CAN: BAD SEND MANY, RETRYING")
@@ -535,16 +639,17 @@ class Panda(object):
   def can_send(self, addr, dat, bus, timeout=CAN_SEND_TIMEOUT_MS):
     self.can_send_many([[addr, None, dat, bus]], timeout=timeout)
 
+  @ensure_can_packet_version
   def can_recv(self):
     dat = bytearray()
     while True:
       try:
-        dat = self._handle.bulkRead(1, 0x10 * 256)
+        dat = self._handle.bulkRead(1, 16384) # Max receive batch size + 2 extra reserve frames
         break
       except (usb1.USBErrorIO, usb1.USBErrorOverflow):
         print("CAN: BAD RECV, RETRYING")
         time.sleep(0.1)
-    return parse_can_buffer(dat)
+    return unpack_can_buffer(dat)
 
   def can_clear(self, bus):
     """Clears all messages from the specified internal CAN ringbuffer as

panda/python/ccp.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+import sys
+import time
+import struct
+from enum import IntEnum, Enum
+
+class COMMAND_CODE(IntEnum):
+  CONNECT = 0x01
+  SET_MTA = 0x02
+  DNLOAD = 0x03
+  UPLOAD = 0x04
+  TEST = 0x05
+  START_STOP = 0x06
+  DISCONNECT = 0x07
+  START_STOP_ALL = 0x08
+  GET_ACTIVE_CAL_PAGE = 0x09
+  SET_S_STATUS = 0x0C
+  GET_S_STATUS = 0x0D
+  BUILD_CHKSUM = 0x0E
+  SHORT_UP = 0x0F
+  CLEAR_MEMORY = 0x10
+  SELECT_CAL_PAGE = 0x11
+  GET_SEED = 0x12
+  UNLOCK = 0x13
+  GET_DAQ_SIZE = 0x14
+  SET_DAQ_PTR = 0x15
+  WRITE_DAQ = 0x16
+  EXCHANGE_ID = 0x17
+  PROGRAM = 0x18
+  MOVE = 0x19
+  GET_CCP_VERSION = 0x1B
+  DIAG_SERVICE = 0x20
+  ACTION_SERVICE = 0x21
+  PROGRAM_6 = 0x22
+  DNLOAD_6 = 0x23
+
+COMMAND_RETURN_CODES = {
+  0x00: "acknowledge / no error",
+  0x01: "DAQ processor overload",
+  0x10: "command processor busy",
+  0x11: "DAQ processor busy",
+  0x12: "internal timeout",
+  0x18: "key request",
+  0x19: "session status request",
+  0x20: "cold start request",
+  0x21: "cal. data init. request",
+  0x22: "DAQ list init. request",
+  0x23: "code update request",
+  0x30: "unknown command",
+  0x31: "command syntax",
+  0x32: "parameter(s) out of range",
+  0x33: "access denied",
+  0x34: "overload",
+  0x35: "access locked",
+  0x36: "resource/function not available",
+}
+
+class BYTE_ORDER(Enum):
+  LITTLE_ENDIAN = '<'
+  BIG_ENDIAN = '>'
+
+class CommandTimeoutError(Exception):
+  pass
+
+class CommandCounterError(Exception):
+  pass
+
+class CommandResponseError(Exception):
+  def __init__(self, message, return_code):
+    super().__init__()
+    self.message = message
+    self.return_code = return_code
+
+  def __str__(self):
+    return self.message
+
+class CcpClient():
+  def __init__(self, panda, tx_addr: int, rx_addr: int, bus: int=0, byte_order: BYTE_ORDER=BYTE_ORDER.BIG_ENDIAN, debug=False):
+    self.tx_addr = tx_addr
+    self.rx_addr = rx_addr
+    self.can_bus = bus
+    self.byte_order = byte_order
+    self.debug = debug
+    self._panda = panda
+    self._command_counter = -1
+
+  def _send_cro(self, cmd: int, dat: bytes = b"") -> None:
+    self._command_counter = (self._command_counter + 1) & 0xFF
+    tx_data = (bytes([cmd, self._command_counter]) + dat).ljust(8, b"\x00")
+    if self.debug:
+      print(f"CAN-TX: {hex(self.tx_addr)} - 0x{bytes.hex(tx_data)}")
+    assert len(tx_data) == 8, "data is not 8 bytes"
+    self._panda.can_clear(self.can_bus)
+    self._panda.can_clear(0xFFFF)
+    self._panda.can_send(self.tx_addr, tx_data, self.can_bus)
+
+  def _recv_dto(self, timeout: float) -> bytes:
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+      msgs = self._panda.can_recv() or []
+      if len(msgs) >= 256:
+        print("CAN RX buffer overflow!!!", file=sys.stderr)
+      for rx_addr, _, rx_data, rx_bus in msgs:
+        if rx_bus == self.can_bus and rx_addr == self.rx_addr:
+          rx_data = bytes(rx_data)  # convert bytearray to bytes
+          if self.debug:
+            print(f"CAN-RX: {hex(rx_addr)} - 0x{bytes.hex(rx_data)}")
+          assert len(rx_data) == 8, f"message length not 8: {len(rx_data)}"
+
+          pid = rx_data[0]
+          if pid == 0xFF or pid == 0xFE:
+            err = rx_data[1]
+            err_desc = COMMAND_RETURN_CODES.get(err, "unknown error")
+            ctr = rx_data[2]
+            dat = rx_data[3:]
+
+            if pid == 0xFF and self._command_counter != ctr:
+              raise CommandCounterError(f"counter invalid: {ctr} != {self._command_counter}")
+
+            if err >= 0x10 and err <= 0x12:
+              if self.debug:
+                print(f"CCP-WAIT: {hex(err)} - {err_desc}")
+              start_time = time.time()
+              continue
+
+            if err >= 0x30:
+              raise CommandResponseError(f"{hex(err)} - {err_desc}", err)
+          else:
+            dat = rx_data[1:]
+
+          return dat
+      time.sleep(0.001)
+
+    raise CommandTimeoutError("timeout waiting for response")
+
+  # commands
+  def connect(self, station_addr: int) -> None:
+    if station_addr > 65535:
+      raise ValueError("station address must be less than 65536")
+    # NOTE: station address is always little endian
+    self._send_cro(COMMAND_CODE.CONNECT, struct.pack("<H", station_addr))
+    self._recv_dto(0.025)
+
+  def exchange_station_ids(self, device_id_info: bytes = b"") -> dict:
+    self._send_cro(COMMAND_CODE.EXCHANGE_ID, device_id_info)
+    resp = self._recv_dto(0.025)
+    return { # TODO: define a type
+      "id_length": resp[0],
+      "data_type": resp[1],
+      "available": resp[2],
+      "protected": resp[3],
+    }
+
+  def get_seed(self, resource_mask: int) -> bytes:
+    if resource_mask > 255:
+      raise ValueError("resource mask must be less than 256")
+    self._send_cro(COMMAND_CODE.GET_SEED)
+    resp = self._recv_dto(0.025)
+    # protected = resp[0] == 0
+    seed = resp[1:]
+    return seed
+
+  def unlock(self, key: bytes) -> int:
+    if len(key) > 6:
+      raise ValueError("max key size is 6 bytes")
+    self._send_cro(COMMAND_CODE.UNLOCK, key)
+    resp = self._recv_dto(0.025)
+    status = resp[0]
+    return status
+
+  def set_memory_transfer_address(self, mta_num: int, addr_ext: int, addr: int) -> None:
+    if mta_num > 255:
+      raise ValueError("MTA number must be less than 256")
+    if addr_ext > 255:
+      raise ValueError("address extension must be less than 256")
+    self._send_cro(COMMAND_CODE.SET_MTA, bytes([mta_num, addr_ext]) + struct.pack(f"{self.byte_order.value}I", addr))
+    self._recv_dto(0.025)
+
+  def download(self, data: bytes) -> int:
+    if len(data) > 5:
+      raise ValueError("max data size is 5 bytes")
+    self._send_cro(COMMAND_CODE.DNLOAD, bytes([len(data)]) + data)
+    resp = self._recv_dto(0.025)
+    # mta_addr_ext = resp[0]
+    mta_addr = struct.unpack(f"{self.byte_order.value}I", resp[1:5])[0]
+    return mta_addr
+
+  def download_6_bytes(self, data: bytes) -> int:
+    if len(data) != 6:
+      raise ValueError("data size must be 6 bytes")
+    self._send_cro(COMMAND_CODE.DNLOAD_6, data)
+    resp = self._recv_dto(0.025)
+    # mta_addr_ext = resp[0]
+    mta_addr = struct.unpack(f"{self.byte_order.value}I", resp[1:5])[0]
+    return mta_addr
+
+  def upload(self, size: int) -> bytes:
+    if size > 5:
+      raise ValueError("size must be less than 6")
+    self._send_cro(COMMAND_CODE.UPLOAD, bytes([size]))
+    return self._recv_dto(0.025)
+
+  def short_upload(self, size: int, addr_ext: int, addr: int) -> bytes:
+    if size > 5:
+      raise ValueError("size must be less than 6")
+    if addr_ext > 255:
+      raise ValueError("address extension must be less than 256")
+    self._send_cro(COMMAND_CODE.SHORT_UP, bytes([size, addr_ext]) + struct.pack(f"{self.byte_order.value}I", addr))
+    return self._recv_dto(0.025)
+
+  def select_calibration_page(self) -> None:
+    self._send_cro(COMMAND_CODE.SELECT_CAL_PAGE)
+    self._recv_dto(0.025)
+
+  def get_daq_list_size(self, list_num: int, can_id: int = 0) -> dict:
+    if list_num > 255:
+      raise ValueError("list number must be less than 256")
+    self._send_cro(COMMAND_CODE.GET_DAQ_SIZE, bytes([list_num, 0]) + struct.pack(f"{self.byte_order.value}I", can_id))
+    resp = self._recv_dto(0.025)
+    return { # TODO: define a type
+      "list_size": resp[0],
+      "first_pid": resp[1],
+    }
+
+  def set_daq_list_pointer(self, list_num: int, odt_num: int, element_num: int) -> None:
+    if list_num > 255:
+      raise ValueError("list number must be less than 256")
+    if odt_num > 255:
+      raise ValueError("ODT number must be less than 256")
+    if element_num > 255:
+      raise ValueError("element number must be less than 256")
+    self._send_cro(COMMAND_CODE.SET_DAQ_PTR, bytes([list_num, odt_num, element_num]))
+    self._recv_dto(0.025)
+
+  def write_daq_list_entry(self, size: int, addr_ext: int, addr: int) -> None:
+    if size > 255:
+      raise ValueError("size must be less than 256")
+    if addr_ext > 255:
+      raise ValueError("address extension must be less than 256")
+    self._send_cro(COMMAND_CODE.WRITE_DAQ, bytes([size, addr_ext]) + struct.pack(f"{self.byte_order.value}I", addr))
+    self._recv_dto(0.025)
+
+  def start_stop_transmission(self, mode: int, list_num: int, odt_num: int, channel_num: int, rate_prescaler: int = 0) -> None:
+    if mode > 255:
+      raise ValueError("mode must be less than 256")
+    if list_num > 255:
+      raise ValueError("list number must be less than 256")
+    if odt_num > 255:
+      raise ValueError("ODT number must be less than 256")
+    if channel_num > 255:
+      raise ValueError("channel number must be less than 256")
+    if rate_prescaler > 65535:
+      raise ValueError("rate prescaler must be less than 65536")
+    self._send_cro(COMMAND_CODE.START_STOP, bytes([mode, list_num, odt_num, channel_num]) + struct.pack(f"{self.byte_order.value}H", rate_prescaler))
+    self._recv_dto(0.025)
+
+  def disconnect(self, station_addr: int, temporary: bool = False) -> None:
+    if station_addr > 65535:
+      raise ValueError("station address must be less than 65536")
+    # NOTE: station address is always little endian
+    self._send_cro(COMMAND_CODE.DISCONNECT, bytes([int(not temporary), 0x00]) + struct.pack("<H", station_addr))
+    self._recv_dto(0.025)
+
+  def set_session_status(self, status: int) -> None:
+    if status > 255:
+      raise ValueError("status must be less than 256")
+    self._send_cro(COMMAND_CODE.SET_S_STATUS, bytes([status]))
+    self._recv_dto(0.025)
+
+  def get_session_status(self) -> dict:
+    self._send_cro(COMMAND_CODE.GET_S_STATUS)
+    resp = self._recv_dto(0.025)
+    return { # TODO: define a type
+      "status": resp[0],
+      "info": resp[2] if resp[1] else None,
+    }
+
+  def build_checksum(self, size: int) -> bytes:
+    self._send_cro(COMMAND_CODE.BUILD_CHKSUM, struct.pack(f"{self.byte_order.value}I", size))
+    resp = self._recv_dto(30.0)
+    chksum_size = resp[0]
+    assert chksum_size <= 4, "checksum more than 4 bytes"
+    chksum = resp[1:1+chksum_size]
+    return chksum
+
+  def clear_memory(self, size: int) -> None:
+    self._send_cro(COMMAND_CODE.CLEAR_MEMORY, struct.pack(f"{self.byte_order.value}I", size))
+    self._recv_dto(30.0)
+
+  def program(self, size: int, data: bytes) -> int:
+    if size > 5:
+      raise ValueError("size must be less than 6")
+    if len(data) > 5:
+      raise ValueError("max data size is 5 bytes")
+    self._send_cro(COMMAND_CODE.PROGRAM, bytes([size]) + data)
+    resp = self._recv_dto(0.1)
+    # mta_addr_ext = resp[0]
+    mta_addr = struct.unpack(f"{self.byte_order.value}I", resp[1:5])[0]
+    return mta_addr
+
+  def program_6_bytes(self, data: bytes) -> int:
+    if len(data) != 6:
+      raise ValueError("data size must be 6 bytes")
+    self._send_cro(COMMAND_CODE.PROGRAM_6, data)
+    resp = self._recv_dto(0.1)
+    # mta_addr_ext = resp[0]
+    mta_addr = struct.unpack(f"{self.byte_order.value}I", resp[1:5])[0]
+    return mta_addr
+
+  def move_memory_block(self, size: int) -> None:
+    self._send_cro(COMMAND_CODE.MOVE, struct.pack(f"{self.byte_order.value}I", size))
+    self._recv_dto(0.025)
+
+  def diagnostic_service(self, service_num: int, data: bytes = b"") -> dict:
+    if service_num > 65535:
+      raise ValueError("service number must be less than 65536")
+    if len(data) > 4:
+      raise ValueError("max data size is 4 bytes")
+    self._send_cro(COMMAND_CODE.DIAG_SERVICE, struct.pack(f"{self.byte_order.value}H", service_num) + data)
+    resp = self._recv_dto(0.025)
+    return { # TODO: define a type
+      "length": resp[0],
+      "type": resp[1],
+    }
+
+  def action_service(self, service_num: int, data: bytes = b"") -> dict:
+    if service_num > 65535:
+      raise ValueError("service number must be less than 65536")
+    if len(data) > 4:
+      raise ValueError("max data size is 4 bytes")
+    self._send_cro(COMMAND_CODE.ACTION_SERVICE, struct.pack(f"{self.byte_order.value}H", service_num) + data)
+    resp = self._recv_dto(0.025)
+    return { # TODO: define a type
+      "length": resp[0],
+      "type": resp[1],
+    }
+
+  def test_availability(self, station_addr: int) -> None:
+    if station_addr > 65535:
+      raise ValueError("station address must be less than 65536")
+    # NOTE: station address is always little endian
+    self._send_cro(COMMAND_CODE.TEST, struct.pack("<H", station_addr))
+    self._recv_dto(0.025)
+
+  def start_stop_synchronised_transmission(self, mode: int) -> None:
+    if mode > 255:
+      raise ValueError("mode must be less than 256")
+    self._send_cro(COMMAND_CODE.START_STOP_ALL, bytes([mode]))
+    self._recv_dto(0.025)
+
+  def get_active_calibration_page(self):
+    self._send_cro(COMMAND_CODE.GET_ACTIVE_CAL_PAGE)
+    resp = self._recv_dto(0.025)
+    # cal_addr_ext = resp[0]
+    cal_addr = struct.unpack(f"{self.byte_order.value}I", resp[1:5])[0]
+    return cal_addr
+
+  def get_version(self, desired_version: float = 2.1) -> float:
+    major, minor = map(int, str(desired_version).split("."))
+    self._send_cro(COMMAND_CODE.GET_CCP_VERSION, bytes([major, minor]))
+    resp = self._recv_dto(0.025)
+    return float(f"{resp[0]}.{resp[1]}")

panda/python/uds.py

@@ -586,13 +586,16 @@ class UdsClient():
       power_down_time = resp[0]
       return power_down_time
 
-  def security_access(self, access_type: ACCESS_TYPE, security_key: bytes = None):
+  def security_access(self, access_type: ACCESS_TYPE, security_key: bytes = b'', data_record: bytes = b''):
     request_seed = access_type % 2 != 0
-    if request_seed and security_key is not None:
+    if request_seed and len(security_key) != 0:
       raise ValueError('security_key not allowed')
-    if not request_seed and security_key is None:
+    if not request_seed and len(security_key) == 0:
       raise ValueError('security_key is missing')
-    resp = self._uds_request(SERVICE_TYPE.SECURITY_ACCESS, subfunction=access_type, data=security_key)
+    if not request_seed and len(data_record) != 0:
+      raise ValueError('data_record not allowed')
+    data = security_key + data_record
+    resp = self._uds_request(SERVICE_TYPE.SECURITY_ACCESS, subfunction=access_type, data=data)
     if request_seed:
       security_seed = resp
       return security_seed
@@ -792,7 +795,7 @@ class UdsClient():
     return resp
 
   def input_output_control_by_identifier(self, data_identifier_type: DATA_IDENTIFIER_TYPE, control_parameter_type: CONTROL_PARAMETER_TYPE,
-                                         control_option_record: bytes, control_enable_mask_record: bytes = b''):
+                                         control_option_record: bytes = b'', control_enable_mask_record: bytes = b''):
     data = struct.pack('!H', data_identifier_type) + bytes([control_parameter_type]) + control_option_record + control_enable_mask_record
     resp = self._uds_request(SERVICE_TYPE.INPUT_OUTPUT_CONTROL_BY_IDENTIFIER, subfunction=None, data=data)
     resp_id = struct.unpack('!H', resp[0:2])[0] if len(resp) >= 2 else None