Sync python/ and scripts/ from upstream

Author: edsammy

python/__init__.py

@@ -112,28 +112,22 @@ class Panda:
 
   # from https://github.com/commaai/openpilot/blob/103b4df18cbc38f4129555ab8b15824d1a672bdf/cereal/log.capnp#L648
   HW_TYPE_UNKNOWN = b'\x00'
-  HW_TYPE_WHITE = b'\x01'
-  HW_TYPE_BLACK = b'\x03'
   HW_TYPE_RED_PANDA = b'\x07'
   HW_TYPE_TRES = b'\x09'
   HW_TYPE_CUATRO = b'\x0a'
+  HW_TYPE_BODY = b'\xb1'
 
   CAN_PACKET_VERSION = 4
   HEALTH_PACKET_VERSION = 17
   CAN_HEALTH_PACKET_VERSION = 5
   HEALTH_STRUCT = struct.Struct("<IIIIIIIIBBBBBHBBBHfBBHHHB")
   CAN_HEALTH_STRUCT = struct.Struct("<BIBBBBBBBBIIIIIIIHHBBBIIII")
 
-  H7_DEVICES = [HW_TYPE_RED_PANDA, HW_TYPE_TRES, HW_TYPE_CUATRO]
+  H7_DEVICES = [HW_TYPE_RED_PANDA, HW_TYPE_TRES, HW_TYPE_CUATRO, HW_TYPE_BODY]
   SUPPORTED_DEVICES = H7_DEVICES
 
   INTERNAL_DEVICES = (HW_TYPE_TRES, HW_TYPE_CUATRO)
 
-  MAX_FAN_RPMs = {
-    HW_TYPE_TRES: 6600,
-    HW_TYPE_CUATRO: 5000,
-  }
-
   HARNESS_STATUS_NC = 0
   HARNESS_STATUS_NORMAL = 1
   HARNESS_STATUS_FLIPPED = 2
@@ -147,11 +141,10 @@ def __init__(self, serial: str | None = None, claim: bool = True, disable_checks
     self._can_speed_kbps = can_speed_kbps
 
     if cli and serial is None:
-        self._connect_serial = self._cli_select_panda()
+      self._connect_serial = self._cli_select_panda()
     else:
-        self._connect_serial = serial
+      self._connect_serial = serial
 
-    # connect and set mcu type
     self.connect(claim)
 
   def _cli_select_panda(self):
@@ -208,14 +201,9 @@ def connect(self, claim=True, wait=False):
     self._serial = serial
     self._connect_serial = serial
     self._handle_open = True
-    self._mcu_type = self.get_mcu_type()
     self.health_version, self.can_version, self.can_health_version = self.get_packets_versions()
     logger.debug("connected")
 
-    hw_type = self.get_type()
-    if hw_type not in self.SUPPORTED_DEVICES:
-      print("WARNING: Using deprecated HW")
-
     # disable openpilot's heartbeat checks
     if self._disable_checks:
       self.set_heartbeat_disabled()
@@ -286,7 +274,7 @@ def usb_connect(cls, serial, claim=True, no_error=False):
             handle = device.open()
             if sys.platform not in ("win32", "cygwin", "msys", "darwin"):
               handle.setAutoDetachKernelDriver(True)
-            if claim:
+            if claim or sys.platform == "darwin":
               handle.claimInterface(0)
               # handle.setInterfaceAltSetting(0, 0)  # Issue in USB stack
 
@@ -342,6 +330,9 @@ def spi_list(cls):
     return []
 
   def reset(self, enter_bootstub=False, enter_bootloader=False, reconnect=True):
+    if enter_bootstub or enter_bootloader:
+      assert (hw_type := self.get_type()) in self.SUPPORTED_DEVICES, f"Unknown HW: {hw_type}"
+
     # no response is expected since it resets right away
     timeout = 5000 if isinstance(self._handle, PandaSpiHandle) else 15000
     try:
@@ -371,7 +362,7 @@ def reconnect(self):
     # wait up to 15 seconds
     for _ in range(15*10):
       try:
-        self.connect(wait=True)
+        self.connect(claim=False, wait=True)
         success = True
         break
       except Exception:
@@ -421,16 +412,14 @@ def flash_static(handle, code, mcu_type):
       pass
 
   def flash(self, fn=None, code=None, reconnect=True):
+    assert (hw_type := self.get_type()) in self.SUPPORTED_DEVICES, f"Unknown HW: {hw_type}"
+
     if self.up_to_date(fn=fn):
       logger.info("flash: already up to date")
       return
 
-    hw_type = self.get_type()
-    if hw_type not in self.SUPPORTED_DEVICES:
-      raise RuntimeError(f"HW type {hw_type.hex()} is deprecated and can no longer be flashed.")
-
     if not fn:
-      fn = os.path.join(FW_PATH, self._mcu_type.config.app_fn)
+      fn = os.path.join(FW_PATH, McuType.H7.config.app_fn)
     assert os.path.isfile(fn)
     logger.debug("flash: main version is %s", self.get_version())
     if not self.bootstub:
@@ -445,7 +434,7 @@ def flash(self, fn=None, code=None, reconnect=True):
     logger.debug("flash: bootstub version is %s", self.get_version())
 
     # do flash
-    Panda.flash_static(self._handle, code, mcu_type=self._mcu_type)
+    Panda.flash_static(self._handle, code, mcu_type=McuType.H7)
 
     # reconnect
     if reconnect:
@@ -496,7 +485,7 @@ def wait_for_panda(cls, serial: str | None, timeout: int) -> bool:
   def up_to_date(self, fn=None) -> bool:
     current = self.get_signature()
     if fn is None:
-      fn = os.path.join(FW_PATH, self.get_mcu_type().config.app_fn)
+      fn = os.path.join(FW_PATH, McuType.H7.config.app_fn)
     expected = Panda.get_signature_from_firmware(fn)
     return (current == expected)
 
@@ -608,12 +597,6 @@ def get_packets_versions(self):
     else:
       return (0, 0, 0)
 
-  def get_mcu_type(self) -> McuType:
-    hw_type = self.get_type()
-    if hw_type in Panda.H7_DEVICES:
-      return McuType.H7
-    raise ValueError(f"unknown HW type: {hw_type}")
-
   def is_internal(self):
     return self.get_type() in Panda.INTERNAL_DEVICES
 
@@ -634,7 +617,7 @@ def get_usb_serial(self):
     return self._serial
 
   def get_dfu_serial(self):
-    return PandaDFU.st_serial_to_dfu_serial(self._serial, self._mcu_type)
+    return PandaDFU.st_serial_to_dfu_serial(self._serial, McuType.H7)
 
   def get_uid(self):
     """
@@ -694,10 +677,6 @@ def set_uart_parity(self, uart, parity):
   def set_uart_callback(self, uart, install):
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xe3, uart, int(install), b'')
 
-  # LED stuff
-  def set_led(self, led, state):
-    self._handle.controlWrite(Panda.REQUEST_OUT, 0xe9, led, state, b'')
-
   # ******************* can *******************
 
   # The panda will NAK CAN writes when there is CAN congestion.
@@ -742,15 +721,6 @@ def can_clear(self, bus):
 
     """
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xf1, bus, 0, b'')
-  
-  def get_can_rx_slots(self):
-    """Returns the number of empty RX slots in the internal CAN ringbuffer.
-
-    Returns:
-      int: number of empty RX slots.
-    """
-    dat = self._handle.controlRead(Panda.REQUEST_IN, 0xc7, 0, 0, 2)
-    return struct.unpack("H", dat)[0]
 
   # ******************* serial *******************
 

python/socketpanda.py

@@ -1,5 +1,6 @@
 import socket
 import struct
+import time
 
 # /**
 #  * struct canfd_frame - CAN flexible data rate frame structure
@@ -23,6 +24,9 @@
 CAN_MAX_DLEN = 8
 CANFD_MAX_DLEN = 64
 
+CAN_CONFIRM_FLAG = 0x800
+CAN_EFF_FLAG = 0x80000000
+
 CANFD_BRS = 0x01 # bit rate switch (second bitrate for payload data)
 CANFD_FDF = 0x04 # mark CAN FD for dual use of struct canfd_frame
 
@@ -32,11 +36,12 @@
 
 import typing
 @typing.no_type_check # mypy struggles with macOS here...
-def create_socketcan(interface:str, recv_buffer_size:int, fd:bool) -> socket.socket:
+def create_socketcan(interface:str, recv_buffer_size:int) -> socket.socket:
   # settings mostly from https://github.com/linux-can/can-utils/blob/master/candump.c
   socketcan = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
-  if fd:
-    socketcan.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FD_FRAMES, 1)
+  socketcan.setblocking(False)
+  socketcan.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FD_FRAMES, 1)
+  socketcan.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_RECV_OWN_MSGS, 1)
   socketcan.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, recv_buffer_size)
   # TODO: why is it always 2x the requested size?
   assert socketcan.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF) == recv_buffer_size * 2
@@ -47,50 +52,72 @@ def create_socketcan(interface:str, recv_buffer_size:int, fd:bool) -> socket.soc
 
 # Panda class substitute for socketcan device (to support using the uds/iso-tp/xcp/ccp library)
 class SocketPanda():
-  def __init__(self, interface:str="can0", bus:int=0, fd:bool=False, recv_buffer_size:int=212992) -> None:
+  def __init__(self, interface:str="can0", recv_buffer_size:int=212992) -> None:
     self.interface = interface
-    self.bus = bus
-    self.fd = fd
-    self.flags = CANFD_BRS | CANFD_FDF if fd else 0
-    self.data_len = CANFD_MAX_DLEN if fd else CAN_MAX_DLEN
     self.recv_buffer_size = recv_buffer_size
-    self.socket = create_socketcan(interface, recv_buffer_size, fd)
+    self.socket = create_socketcan(interface, recv_buffer_size)
 
   def __del__(self):
     self.socket.close()
 
   def get_serial(self) -> tuple[int, int]:
-    return (0, 0) # TODO: implemented in panda socketcan driver
+    return (0, 0)
 
   def get_version(self) -> int:
-    return 0 # TODO: implemented in panda socketcan driver
+    return 0
 
   def can_clear(self, bus:int) -> None:
-    # TODO: implemented in panda socketcan driver
     self.socket.close()
-    self.socket = create_socketcan(self.interface, self.recv_buffer_size, self.fd)
+    self.socket = create_socketcan(self.interface, self.recv_buffer_size)
 
   def set_safety_mode(self, mode:int, param=0) -> None:
-    pass # TODO: implemented in panda socketcan driver
+    pass
 
-  def has_obd(self) -> bool:
-    return False # TODO: implemented in panda socketcan driver
+  def can_send_many(self, arr, *, fd=False, timeout=0) -> None:
+    for msg in arr:
+      self.can_send(*msg, fd=fd, timeout=timeout)
 
-  def can_send(self, addr, dat, bus=0, timeout=0) -> None:
+  def can_send(self, addr, dat, bus, *, fd=False, timeout=0) -> None:
+    # Even if the CANFD_FDF flag is not set, the data still must be 8 bytes for classic CAN frames.
+    data_len = CANFD_MAX_DLEN if fd else CAN_MAX_DLEN
     msg_len = len(dat)
-    msg_dat = dat.ljust(self.data_len, b'\x00')
-    can_frame = struct.pack(CAN_HEADER_FMT, addr, msg_len, self.flags) + msg_dat
-    self.socket.sendto(can_frame, (self.interface,))
+    msg_dat = dat.ljust(data_len, b'\x00')
+
+    # Set extended ID flag
+    if addr > 0x7ff:
+      addr |= CAN_EFF_FLAG
+
+    # Set FD flags
+    flags = CANFD_BRS | CANFD_FDF if fd else 0
+
+    can_frame = struct.pack(CAN_HEADER_FMT, addr, msg_len, flags) + msg_dat
+
+    # Try to send until timeout. sendto might block if the TX buffer is full.
+    # TX buffer size can also be adjusted through `ip link set can0 txqueuelen <size>` if needed
+    start_t = time.monotonic()
+    while (time.monotonic() - start_t < (timeout / 1000)) or (timeout == 0):
+      try:
+        self.socket.sendto(can_frame, (self.interface,))
+        break
+      except (BlockingIOError, OSError):
+        continue
+    else:
+      raise TimeoutError
+
 
   def can_recv(self) -> list[tuple[int, bytes, int]]:
     msgs = list()
     while True:
       try:
-        dat, _ = self.socket.recvfrom(self.recv_buffer_size, socket.MSG_DONTWAIT)
-        assert len(dat) == CAN_HEADER_LEN + self.data_len, f"ERROR: received {len(dat)} bytes"
+        dat, _, msg_flags, _ = self.socket.recvmsg(self.recv_buffer_size)
+        assert len(dat) >= CAN_HEADER_LEN, f"ERROR: received {len(dat)} bytes"
+
         can_id, msg_len, _ = struct.unpack(CAN_HEADER_FMT, dat[:CAN_HEADER_LEN])
+        assert len(dat) >= CAN_HEADER_LEN + msg_len, f"ERROR: received {len(dat)} bytes, expected at least {CAN_HEADER_LEN + msg_len} bytes"
+
         msg_dat = dat[CAN_HEADER_LEN:CAN_HEADER_LEN+msg_len]
-        msgs.append((can_id, msg_dat, self.bus))
+        bus = 128 if (msg_flags & CAN_CONFIRM_FLAG) else 0
+        msgs.append((can_id, msg_dat, bus))
       except BlockingIOError:
         break # buffered data exhausted
     return msgs

python/spi.py

@@ -117,6 +117,7 @@ class PandaSpiHandle(BaseHandle):
 
   def __init__(self) -> None:
     self.dev = SpiDevice()
+    self.no_retry = "NO_RETRY" in os.environ
 
   # helpers
   def _calc_checksum(self, data: bytes) -> int:
@@ -193,6 +194,8 @@ def _transfer(self, endpoint: int, data, timeout: int, max_rx_len: int = 1000, e
         except PandaSpiException as e:
           exc = e
           logger.debug("SPI transfer failed, retrying", exc_info=True)
+          if self.no_retry:
+            break
 
           # ensure slave is in a consistent state and ready for the next transfer
           # (e.g. slave TX buffer isn't stuck full)

scripts/can_health.py

@@ -2,27 +2,10 @@
 import time
 import re
 from panda import Panda
-from prettytable import PrettyTable
 
 RED = '\033[91m'
 GREEN = '\033[92m'
 
-def make_table(health1, health2, health3):
-  table = PrettyTable()
-  table.field_names = ["Key", "Bus 0", "Bus 1", "Bus 2"]
-  for key1, value1 in health1.items():
-    value2 = health2[key1]
-    value3 = health3[key1]
-    # Normalize float values
-    if type(value1) is float:
-      value1 = f"{value1:.4f}"
-      value2 = f"{value2:.4f}"
-      value3 = f"{value3:.4f}"
-    table.add_row([key1, colorize_errors(value1), colorize_errors(value2), colorize_errors(value3)])
-
-  table.align["Key"] = "l"
-  return table
-
 def colorize_errors(value):
   if isinstance(value, str):
     if re.search(r'(?i)No error', value):
@@ -37,9 +20,10 @@ def colorize_errors(value):
   while True:
     print(chr(27) + "[2J") # clear screen
     print("Connected to " + ("internal panda" if panda.is_internal() else "External panda") + f" id: {panda.get_serial()[0]}: {panda.get_version()}")
-    health1 = panda.can_health(0)
-    health2 = panda.can_health(1)
-    health3 = panda.can_health(2)
-    table = make_table(health1, health2, health3)
-    print(table)
+    for bus in range(3):
+      print(f"\nBus {bus}:")
+      health = panda.can_health(bus)
+      for key, value in health.items():
+        print(f"{key}: {colorize_errors(value)}  ", end=" ")
+    print()
     time.sleep(1)

scripts/can_printer.py

@@ -36,7 +36,7 @@ def can_printer():
 
     if sec_since_boot() - lp > 0.1:
       dd = chr(27) + "[2J"
-      dd += "Uptime: %5.2f - Count: %d\n" % (sec_since_boot() - start, len(all_msgs))
+      dd += "%5.2f\n" % (sec_since_boot() - start)
       for (addr, bus), dat_log in sorted(all_msgs.items()):
         dd += "%d: %s(%6d): %s\n" % (bus, "%04X(%4d)" % (addr, addr), len(dat_log), binascii.hexlify(dat_log[-1]).decode())
       print(dd)

scripts/check_fw_size.py

@@ -78,9 +78,12 @@ def check_space(file, mcu):
 
 
 if __name__ == "__main__":
-  # red panda
-  check_space("../board/obj/bootstub.panda_h7.elf", "H7")
-  check_space("../board/obj/panda_h7.elf", "H7")
+  # panda
+  check_space("../board/obj/panda_h7/bootstub.elf", "H7")
+  check_space("../board/obj/panda_h7/main.elf", "H7")
   # jungle v2
-  check_space("../board/jungle/obj/bootstub.panda_jungle_h7.elf", "H7")
-  check_space("../board/jungle/obj/panda_jungle_h7.elf", "H7")
+  check_space("../board/obj/panda_jungle_h7/bootstub.elf", "H7")
+  check_space("../board/obj/panda_jungle_h7/main.elf", "H7")
+  # body
+  check_space("../board/obj/body_h7/bootstub.elf", "H7")
+  check_space("../board/obj/body_h7/main.elf", "H7")

scripts/fan/fan_test.py

@@ -9,6 +9,6 @@
   while True:
     p.set_fan_power(power)
     time.sleep(5)
-    print("Power: ", power, "RPM:", str(p.get_fan_rpm()), "Expected:", int(6500 * power / 100))
+    print("Power: ", power, "RPM:", str(p.get_fan_rpm()))
     power += 10
     power %= 110