openpilot v0.7.7 release

panda/python/__init__.py

@@ -1,6 +1,5 @@
 # python library to interface with panda
 import datetime
-import binascii
 import struct
 import hashlib
 import socket
@@ -30,25 +29,22 @@ def build_st(target, mkfile="Makefile", clean=True):
 
   clean_cmd = "make -f %s clean" % mkfile if clean else ":"
   cmd = 'cd %s && %s && make -f %s %s' % (os.path.join(BASEDIR, "board"), clean_cmd, mkfile, target)
-  try:
-    _ = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
-  except subprocess.CalledProcessError:
-    raise
+  _ = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
 
 def parse_can_buffer(dat):
   ret = []
   for j in range(0, len(dat), 0x10):
-    ddat = dat[j:j+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)]
+    dddat = ddat[8:8 + (f2 & 0xF)]
     if DEBUG:
-      print("  R %x: %s" % (address, binascii.hexlify(dddat)))
-    ret.append((address, f2>>16, dddat, (f2>>4)&0xFF))
+      print(f"  R 0x{address:x}: 0x{dddat.hex()}")
+    ret.append((address, f2 >> 16, dddat, (f2 >> 4) & 0xFF))
   return ret
 
 class PandaWifiStreaming(object):
@@ -67,7 +63,7 @@ class PandaWifiStreaming(object):
     ret = []
     while True:
       try:
-        dat, addr = self.sock.recvfrom(0x200*0x10)
+        dat, addr = self.sock.recvfrom(0x200 * 0x10)
         if addr == (self.ip, self.port):
           ret += parse_can_buffer(dat)
       except socket.error as e:
@@ -84,7 +80,7 @@ class WifiHandle(object):
   def __recv(self):
     ret = self.sock.recv(0x44)
     length = struct.unpack("I", ret[0:4])[0]
-    return ret[4:4+length]
+    return ret[4:4 + length]
 
   def controlWrite(self, request_type, request, value, index, data, timeout=0):
     # ignore data in reply, panda doesn't use it
@@ -97,7 +93,7 @@ class WifiHandle(object):
   def bulkWrite(self, endpoint, data, timeout=0):
     if len(data) > 0x10:
       raise ValueError("Data must not be longer than 0x10")
-    self.sock.send(struct.pack("HH", endpoint, len(data))+data)
+    self.sock.send(struct.pack("HH", endpoint, len(data)) + data)
     self.__recv()  # to /dev/null
 
   def bulkRead(self, endpoint, length, timeout=0):
@@ -132,6 +128,7 @@ class Panda(object):
   SAFETY_HONDA_BOSCH_HARNESS = 20
   SAFETY_VOLKSWAGEN_PQ = 21
   SAFETY_SUBARU_LEGACY = 22
+  SAFETY_HYUNDAI_LEGACY = 23
 
   SERIAL_DEBUG = 0
   SERIAL_ESP = 1
@@ -161,7 +158,7 @@ class Panda(object):
     self._handle = None
 
   def connect(self, claim=True, wait=False):
-    if self._handle != None:
+    if self._handle is not None:
       self.close()
 
     if self._serial == "WIFI":
@@ -176,7 +173,6 @@ class Panda(object):
       while 1:
         try:
           for device in context.getDeviceList(skip_on_error=True):
-            #print(device)
             if device.getVendorID() == 0xbbaa and device.getProductID() in [0xddcc, 0xddee]:
               try:
                 this_serial = device.getSerialNumber()
@@ -189,19 +185,19 @@ class Panda(object):
                 self.bootstub = device.getProductID() == 0xddee
                 self.legacy = (device.getbcdDevice() != 0x2300)
                 self._handle = device.open()
-                if not sys.platform in ["win32", "cygwin", "msys"]:
+                if sys.platform not in ["win32", "cygwin", "msys"]:
                   self._handle.setAutoDetachKernelDriver(True)
                 if claim:
                   self._handle.claimInterface(0)
-                  #self._handle.setInterfaceAltSetting(0, 0) #Issue in USB stack
+                  # self._handle.setInterfaceAltSetting(0, 0)  # Issue in USB stack
                 break
         except Exception as e:
           print("exception", e)
           traceback.print_exc()
-        if wait == False or self._handle != None:
+        if not wait or self._handle is not None:
           break
-        context = usb1.USBContext() #New context needed so new devices show up
-    assert(self._handle != None)
+        context = usb1.USBContext()  # New context needed so new devices show up
+    assert(self._handle is not None)
     print("connected")
 
   def reset(self, enter_bootstub=False, enter_bootloader=False):
@@ -230,7 +226,7 @@ class Panda(object):
         success = True
         break
       except Exception:
-        print("reconnecting is taking %d seconds..." % (i+1))
+        print("reconnecting is taking %d seconds..." % (i + 1))
         try:
           dfu = PandaDFU(PandaDFU.st_serial_to_dfu_serial(self._serial))
           dfu.recover()
@@ -259,7 +255,7 @@ class Panda(object):
     STEP = 0x10
     print("flash: flashing")
     for i in range(0, len(code), STEP):
-      handle.bulkWrite(2, code[i:i+STEP])
+      handle.bulkWrite(2, code[i:i + STEP])
 
     # reset
     print("flash: resetting")
@@ -321,14 +317,14 @@ class Panda(object):
   def flash_ota_st():
     ret = os.system("cd %s && make clean && make ota" % (os.path.join(BASEDIR, "board")))
     time.sleep(1)
-    return ret==0
+    return ret == 0
 
   @staticmethod
   def flash_ota_wifi(release=False):
     release_str = "RELEASE=1" if release else ""
-    ret = os.system("cd {} && make clean && {} make ota".format(os.path.join(BASEDIR, "boardesp"),release_str))
+    ret = os.system("cd {} && make clean && {} make ota".format(os.path.join(BASEDIR, "boardesp"), release_str))
     time.sleep(1)
-    return ret==0
+    return ret == 0
 
   @staticmethod
   def list():
@@ -344,7 +340,7 @@ class Panda(object):
     except Exception:
       pass
     # TODO: detect if this is real
-    #ret += ["WIFI"]
+    # ret += ["WIFI"]
     return ret
 
   def call_control_api(self, msg):
@@ -382,7 +378,6 @@ class Panda(object):
       self._handle.controlWrite(Panda.REQUEST_OUT, 0xd1, 0, 0, b'')
     except Exception as e:
       print(e)
-      pass
 
   def get_version(self):
     return self._handle.controlRead(Panda.REQUEST_IN, 0xd6, 0, 0, 0x40).decode('utf8')
@@ -420,7 +415,7 @@ class Panda(object):
     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")]
+    return [dat[0:0x10].decode("utf8"), dat[0x10:0x10 + 10].decode("utf8")]
 
   def get_secret(self):
     return self._handle.controlRead(Panda.REQUEST_IN, 0xd0, 1, 0, 0x10)
@@ -467,10 +462,10 @@ class Panda(object):
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xf4, int(bus_num), int(enable), b'')
 
   def set_can_speed_kbps(self, bus, speed):
-    self._handle.controlWrite(Panda.REQUEST_OUT, 0xde, bus, int(speed*10), b'')
+    self._handle.controlWrite(Panda.REQUEST_OUT, 0xde, bus, int(speed * 10), b'')
 
   def set_uart_baud(self, uart, rate):
-    self._handle.controlWrite(Panda.REQUEST_OUT, 0xe4, uart, int(rate/300), b'')
+    self._handle.controlWrite(Panda.REQUEST_OUT, 0xe4, uart, int(rate / 300), b'')
 
   def set_uart_parity(self, uart, parity):
     # parity, 0=off, 1=even, 2=odd
@@ -493,7 +488,7 @@ class Panda(object):
     for addr, _, dat, bus in arr:
       assert len(dat) <= 8
       if DEBUG:
-        print("  W %x: %s" % (addr, binascii.hexlify(dat)))
+        print(f"  W 0x{addr:x}: 0x{dat.hex()}")
       if addr >= 0x800:
         rir = (addr << 3) | transmit | extended
       else:
@@ -504,7 +499,6 @@ class Panda(object):
 
     while True:
       try:
-        #print("DAT: %s"%b''.join(snds).__repr__())
         if self.wifi:
           for s in snds:
             self._handle.bulkWrite(3, s)
@@ -521,7 +515,7 @@ class Panda(object):
     dat = bytearray()
     while True:
       try:
-        dat = self._handle.bulkRead(1, 0x10*256)
+        dat = self._handle.bulkRead(1, 0x10 * 256)
         break
       except (usb1.USBErrorIO, usb1.USBErrorOverflow):
         print("CAN: BAD RECV, RETRYING")
@@ -561,7 +555,7 @@ class Panda(object):
   def serial_write(self, port_number, ln):
     ret = 0
     for i in range(0, len(ln), 0x20):
-      ret += self._handle.bulkWrite(2, struct.pack("B", port_number) + ln[i:i+0x20])
+      ret += self._handle.bulkWrite(2, struct.pack("B", port_number) + ln[i:i + 0x20])
     return ret
 
   def serial_clear(self, port_number):
@@ -577,13 +571,22 @@ class Panda(object):
   # ******************* kline *******************
 
   # pulse low for wakeup
-  def kline_wakeup(self):
+  def kline_wakeup(self, k=True, l=True):
+    assert k or l, "must specify k-line, l-line, or both"
     if DEBUG:
       print("kline wakeup...")
-    self._handle.controlWrite(Panda.REQUEST_OUT, 0xf0, 0, 0, b'')
+    self._handle.controlWrite(Panda.REQUEST_OUT, 0xf0, 2 if k and l else int(l), 0, b'')
     if DEBUG:
       print("kline wakeup done")
 
+  def kline_5baud(self, addr, k=True, l=True):
+    assert k or l, "must specify k-line, l-line, or both"
+    if DEBUG:
+      print("kline 5 baud...")
+    self._handle.controlWrite(Panda.REQUEST_OUT, 0xf4, 2 if k and l else int(l), addr, b'')
+    if DEBUG:
+      print("kline 5 baud done")
+
   def kline_drain(self, bus=2):
     # drain buffer
     bret = bytearray()
@@ -592,44 +595,40 @@ class Panda(object):
       if len(ret) == 0:
         break
       elif DEBUG:
-        print("kline drain: " + binascii.hexlify(ret))
+        print(f"kline drain: 0x{ret.hex()}")
       bret += ret
     return bytes(bret)
 
   def kline_ll_recv(self, cnt, bus=2):
     echo = bytearray()
     while len(echo) != cnt:
-      ret = self._handle.controlRead(Panda.REQUEST_OUT, 0xe0, bus, 0, cnt-len(echo))
+      ret = self._handle.controlRead(Panda.REQUEST_OUT, 0xe0, bus, 0, cnt - len(echo))
       if DEBUG and len(ret) > 0:
-        print("kline recv: " + binascii.hexlify(ret))
+        print(f"kline recv: 0x{ret.hex()}")
       echo += ret
-    return str(echo)
+    return bytes(echo)
 
   def kline_send(self, x, bus=2, checksum=True):
-    def get_checksum(dat):
-      result = 0
-      result += sum(map(ord, dat)) if isinstance(b'dat', str) else sum(dat)
-      result = -result
-      return struct.pack("B", result % 0x100)
-
     self.kline_drain(bus=bus)
     if checksum:
-      x += get_checksum(x)
+      x += bytes([sum(x) % 0x100])
     for i in range(0, len(x), 0xf):
-      ts = x[i:i+0xf]
+      ts = x[i:i + 0xf]
       if DEBUG:
-        print("kline send: " + binascii.hexlify(ts))
+        print(f"kline send: 0x{ts.hex()}")
       self._handle.bulkWrite(2, bytes([bus]) + ts)
       echo = self.kline_ll_recv(len(ts), bus=bus)
       if echo != ts:
-        print("**** ECHO ERROR %d ****" % i)
-        print(binascii.hexlify(echo))
-        print(binascii.hexlify(ts))
+        print(f"**** ECHO ERROR {i} ****")
+        print(f"0x{echo.hex()}")
+        print(f"0x{ts.hex()}")
     assert echo == ts
 
-  def kline_recv(self, bus=2):
-    msg = self.kline_ll_recv(2, bus=bus)
-    msg += self.kline_ll_recv(ord(msg[1])-2, bus=bus)
+  def kline_recv(self, bus=2, header_len=4):
+    # read header (last byte is length)
+    msg = self.kline_ll_recv(header_len, bus=bus)
+    # read data (add one byte to length for checksum)
+    msg += self.kline_ll_recv(msg[-1]+1, bus=bus)
     return msg
 
   def send_heartbeat(self):
@@ -663,6 +662,6 @@ class Panda(object):
     a = struct.unpack("H", dat)
     return a[0]
 
-# ****************** Phone *****************
+  # ****************** Phone *****************
   def set_phone_power(self, enabled):
     self._handle.controlWrite(Panda.REQUEST_OUT, 0xb3, int(enabled), 0, b'')

panda/python/dfu.py

@@ -24,7 +24,7 @@ class PandaDFU(object):
           self._handle = device.open()
           self.legacy = "07*128Kg" in self._handle.getASCIIStringDescriptor(4)
           return
-    raise Exception("failed to open "+dfu_serial)
+    raise Exception("failed to open " + dfu_serial)
 
   @staticmethod
   def list():
@@ -43,9 +43,9 @@ class PandaDFU(object):
 
   @staticmethod
   def st_serial_to_dfu_serial(st):
-    if st == None or st == "none":
+    if st is None or st == "none":
       return None
-    uid_base = struct.unpack("H"*6, bytes.fromhex(st))
+    uid_base = struct.unpack("H" * 6, bytes.fromhex(st))
     return binascii.hexlify(struct.pack("!HHH", uid_base[1] + uid_base[5], uid_base[0] + uid_base[4] + 0xA, uid_base[3])).upper().decode("utf-8")
 
   def status(self):
@@ -69,7 +69,7 @@ class PandaDFU(object):
     self.status()
 
   def program(self, address, dat, block_size=None):
-    if block_size == None:
+    if block_size is None:
       block_size = len(dat)
 
     # Set Address Pointer
@@ -77,11 +77,11 @@ class PandaDFU(object):
     self.status()
 
     # Program
-    dat += b"\xFF"*((block_size-len(dat)) % block_size)
-    for i in range(0, len(dat)//block_size):
-      ldat = dat[i*block_size:(i+1)*block_size]
+    dat += b"\xFF" * ((block_size - len(dat)) % block_size)
+    for i in range(0, len(dat) // block_size):
+      ldat = dat[i * block_size:(i + 1) * block_size]
       print("programming %d with length %d" % (i, len(ldat)))
-      self._handle.controlWrite(0x21, DFU_DNLOAD, 2+i, 0, ldat)
+      self._handle.controlWrite(0x21, DFU_DNLOAD, 2 + i, 0, ldat)
       self.status()
 
   def program_bootstub(self, code_bootstub):

panda/python/esptool.py

@@ -18,6 +18,9 @@
 # this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
 # Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+# pylint: skip-file
+# flake8: noqa
+
 import argparse
 import hashlib
 import inspect

panda/python/flash_release.py

@@ -11,9 +11,9 @@ def flash_release(path=None, st_serial=None):
   from zipfile import ZipFile
 
   def status(x):
-    print("\033[1;32;40m"+x+"\033[00m")
+    print("\033[1;32;40m" + x + "\033[00m")
 
-  if st_serial == None:
+  if st_serial is not None:
     # look for Panda
     panda_list = Panda.list()
     if len(panda_list) == 0:
@@ -23,7 +23,7 @@ def flash_release(path=None, st_serial=None):
     st_serial = panda_list[0]
     print("Using panda with serial %s" % st_serial)
 
-  if path == None:
+  if path is not None:
     print("Fetching latest firmware from github.com/commaai/panda-artifacts")
     r = requests.get("https://raw.githubusercontent.com/commaai/panda-artifacts/master/latest.json")
     url = json.loads(r.text)['url']
@@ -35,7 +35,7 @@ def flash_release(path=None, st_serial=None):
   zf.printdir()
 
   version = zf.read("version")
-  status("0. Preparing to flash "+version)
+  status("0. Preparing to flash " + version)
 
   code_bootstub = zf.read("bootstub.panda.bin")
   code_panda = zf.read("panda.bin")
@@ -67,14 +67,17 @@ def flash_release(path=None, st_serial=None):
   # flashing ESP
   if panda.is_white():
     status("4. Flashing ESP (slow!)")
-    align = lambda x, sz=0x1000: x+"\xFF"*((sz-len(x)) % sz)
+
+    def align(x, sz=0x1000):
+      x + "\xFF" * ((sz - len(x)) % sz)
+
     esp = ESPROM(st_serial)
     esp.connect()
     flasher = CesantaFlasher(esp, 230400)
     flasher.flash_write(0x0, align(code_boot_15), True)
     flasher.flash_write(0x1000, align(code_user1), True)
     flasher.flash_write(0x81000, align(code_user2), True)
-    flasher.flash_write(0x3FE000, "\xFF"*0x1000)
+    flasher.flash_write(0x3FE000, "\xFF" * 0x1000)
     flasher.boot_fw()
     del flasher
     del esp
@@ -95,4 +98,3 @@ def flash_release(path=None, st_serial=None):
 
 if __name__ == "__main__":
   flash_release(*sys.argv[1:])
-

panda/python/isotp.py

@@ -1,4 +1,5 @@
 import binascii
+import time
 
 DEBUG = False
 
@@ -34,22 +35,22 @@ def isotp_recv_subaddr(panda, addr, bus, sendaddr, subaddr):
   # TODO: handle other subaddr also communicating
   assert msg[0] == subaddr
 
-  if msg[1]&0xf0 == 0x10:
+  if msg[1] & 0xf0 == 0x10:
     # first
     tlen = ((msg[1] & 0xf) << 8) | msg[2]
     dat = msg[3:]
 
     # 0 block size?
-    CONTINUE = bytes([subaddr]) + b"\x30" + b"\x00"*6
+    CONTINUE = bytes([subaddr]) + b"\x30" + b"\x00" * 6
     panda.can_send(sendaddr, CONTINUE, bus)
 
     idx = 1
-    for mm in recv(panda, (tlen-len(dat) + 5)//6, addr, bus):
+    for mm in recv(panda, (tlen - len(dat) + 5) // 6, addr, bus):
       assert mm[0] == subaddr
-      assert mm[1] == (0x20 | (idx&0xF))
+      assert mm[1] == (0x20 | (idx & 0xF))
       dat += mm[2:]
       idx += 1
-  elif msg[1]&0xf0 == 0x00:
+  elif msg[1] & 0xf0 == 0x00:
     # single
     tlen = msg[1] & 0xf
     dat = msg[2:]
@@ -61,9 +62,9 @@ def isotp_recv_subaddr(panda, addr, bus, sendaddr, subaddr):
 
 # **** import below this line ****
 
-def isotp_send(panda, x, addr, bus=0, recvaddr=None, subaddr=None):
+def isotp_send(panda, x, addr, bus=0, recvaddr=None, subaddr=None, rate=None):
   if recvaddr is None:
-    recvaddr = addr+8
+    recvaddr = addr + 8
 
   if len(x) <= 7 and subaddr is None:
     panda.can_send(addr, msg(x), bus)
@@ -96,11 +97,16 @@ def isotp_send(panda, x, addr, bus=0, recvaddr=None, subaddr=None):
         rr = recv(panda, 1, recvaddr, bus)[0]
       panda.can_send(addr, sends[-1], 0)
     else:
-      panda.can_send_many([(addr, None, s, 0) for s in sends])
+      if rate is None:
+        panda.can_send_many([(addr, None, s, bus) for s in sends])
+      else:
+        for dat in sends:
+          panda.can_send(addr, dat, bus)
+          time.sleep(rate)
 
 def isotp_recv(panda, addr, bus=0, sendaddr=None, subaddr=None):
   if sendaddr is None:
-    sendaddr = addr-8
+    sendaddr = addr - 8
 
   if subaddr is not None:
     dat = isotp_recv_subaddr(panda, addr, bus, sendaddr, subaddr)
@@ -113,13 +119,13 @@ def isotp_recv(panda, addr, bus=0, sendaddr=None, subaddr=None):
       dat = msg[2:]
 
       # 0 block size?
-      CONTINUE = b"\x30" + b"\x00"*7
+      CONTINUE = b"\x30" + b"\x00" * 7
 
       panda.can_send(sendaddr, CONTINUE, bus)
 
       idx = 1
-      for mm in recv(panda, (tlen-len(dat) + 6)//7, addr, bus):
-        assert mm[0] == (0x20 | (idx&0xF))
+      for mm in recv(panda, (tlen - len(dat) + 6) // 7, addr, bus):
+        assert mm[0] == (0x20 | (idx & 0xF))
         dat += mm[1:]
         idx += 1
     elif msg[0] & 0xf0 == 0x00:
@@ -134,4 +140,3 @@ def isotp_recv(panda, addr, bus=0, sendaddr=None, subaddr=None):
     print("R:", binascii.hexlify(dat))
 
   return dat
-

panda/python/serial.py

@@ -7,21 +7,16 @@ class PandaSerial(object):
     self.panda.set_uart_baud(self.port, baud)
     self.buf = b""
 
-  def read(self, l=1):
+  def read(self, l=1):  # noqa: E741
     tt = self.panda.serial_read(self.port)
     if len(tt) > 0:
-      #print "R: ", tt.encode("hex")
       self.buf += tt
     ret = self.buf[0:l]
     self.buf = self.buf[l:]
     return ret
 
   def write(self, dat):
-    #print "W: ", dat.encode("hex")
-    #print '  pigeon_send("' + ''.join(map(lambda x: "\\x%02X" % ord(x), dat)) + '");'
     return self.panda.serial_write(self.port, dat)
 
   def close(self):
     pass
-
-

panda/python/uds.py

@@ -6,31 +6,31 @@ from typing import Callable, NamedTuple, Tuple, List, Deque, Generator, Optional
 from enum import IntEnum
 
 class SERVICE_TYPE(IntEnum):
-  DIAGNOSTIC_SESSION_CONTROL         = 0x10
-  ECU_RESET                          = 0x11
-  SECURITY_ACCESS                    = 0x27
-  COMMUNICATION_CONTROL              = 0x28
-  TESTER_PRESENT                     = 0x3E
-  ACCESS_TIMING_PARAMETER            = 0x83
-  SECURED_DATA_TRANSMISSION          = 0x84
-  CONTROL_DTC_SETTING                = 0x85
-  RESPONSE_ON_EVENT                  = 0x86
-  LINK_CONTROL                       = 0x87
-  READ_DATA_BY_IDENTIFIER            = 0x22
-  READ_MEMORY_BY_ADDRESS             = 0x23
-  READ_SCALING_DATA_BY_IDENTIFIER    = 0x24
-  READ_DATA_BY_PERIODIC_IDENTIFIER   = 0x2A
+  DIAGNOSTIC_SESSION_CONTROL = 0x10
+  ECU_RESET = 0x11
+  SECURITY_ACCESS = 0x27
+  COMMUNICATION_CONTROL = 0x28
+  TESTER_PRESENT = 0x3E
+  ACCESS_TIMING_PARAMETER = 0x83
+  SECURED_DATA_TRANSMISSION = 0x84
+  CONTROL_DTC_SETTING = 0x85
+  RESPONSE_ON_EVENT = 0x86
+  LINK_CONTROL = 0x87
+  READ_DATA_BY_IDENTIFIER = 0x22
+  READ_MEMORY_BY_ADDRESS = 0x23
+  READ_SCALING_DATA_BY_IDENTIFIER = 0x24
+  READ_DATA_BY_PERIODIC_IDENTIFIER = 0x2A
   DYNAMICALLY_DEFINE_DATA_IDENTIFIER = 0x2C
-  WRITE_DATA_BY_IDENTIFIER           = 0x2E
-  WRITE_MEMORY_BY_ADDRESS            = 0x3D
-  CLEAR_DIAGNOSTIC_INFORMATION       = 0x14
-  READ_DTC_INFORMATION               = 0x19
+  WRITE_DATA_BY_IDENTIFIER = 0x2E
+  WRITE_MEMORY_BY_ADDRESS = 0x3D
+  CLEAR_DIAGNOSTIC_INFORMATION = 0x14
+  READ_DTC_INFORMATION = 0x19
   INPUT_OUTPUT_CONTROL_BY_IDENTIFIER = 0x2F
-  ROUTINE_CONTROL                    = 0x31
-  REQUEST_DOWNLOAD                   = 0x34
-  REQUEST_UPLOAD                     = 0x35
-  TRANSFER_DATA                      = 0x36
-  REQUEST_TRANSFER_EXIT              = 0x37
+  ROUTINE_CONTROL = 0x31
+  REQUEST_DOWNLOAD = 0x34
+  REQUEST_UPLOAD = 0x35
+  TRANSFER_DATA = 0x36
+  REQUEST_TRANSFER_EXIT = 0x37
 
 class SESSION_TYPE(IntEnum):
   DEFAULT = 1
@@ -271,7 +271,8 @@ _negative_response_codes = {
 
 
 class CanClient():
-  def __init__(self, can_send: Callable[[int, bytes, int], None], can_recv: Callable[[], List[Tuple[int, int, bytes, int]]], tx_addr: int, rx_addr: int, bus: int, sub_addr: int=None, debug: bool=False):
+  def __init__(self, can_send: Callable[[int, bytes, int], None], can_recv: Callable[[], List[Tuple[int, int, bytes, int]]],
+               tx_addr: int, rx_addr: int, bus: int, sub_addr: int = None, debug: bool = False):
     self.tx = can_send
     self.rx = can_recv
     self.tx_addr = tx_addr
@@ -286,30 +287,34 @@ class CanClient():
     if self.tx_addr == 0x7DF:
       is_response = addr >= 0x7E8 and addr <= 0x7EF
       if is_response:
-        if self.debug: print(f"switch to physical addr {hex(addr)}")
-        self.tx_addr = addr-8
+        if self.debug:
+          print(f"switch to physical addr {hex(addr)}")
+        self.tx_addr = addr - 8
         self.rx_addr = addr
       return is_response
     if self.tx_addr == 0x18DB33F1:
       is_response = addr >= 0x18DAF100 and addr <= 0x18DAF1FF
       if is_response:
-        if self.debug: print(f"switch to physical addr {hex(addr)}")
-        self.tx_addr = 0x18DA00F1 + (addr<<8 & 0xFF00)
+        if self.debug:
+          print(f"switch to physical addr {hex(addr)}")
+        self.tx_addr = 0x18DA00F1 + (addr << 8 & 0xFF00)
         self.rx_addr = addr
     return bus == self.bus and addr == self.rx_addr
 
-  def _recv_buffer(self, drain: bool=False) -> None:
+  def _recv_buffer(self, drain: bool = False) -> None:
     while True:
       msgs = self.rx()
       if drain:
-        if self.debug: print("CAN-RX: drain - {}".format(len(msgs)))
+        if self.debug:
+          print("CAN-RX: drain - {}".format(len(msgs)))
         self.rx_buff.clear()
       else:
-        for rx_addr, rx_ts, rx_data, rx_bus in msgs or []:
+        for rx_addr, _, rx_data, rx_bus in msgs or []:
           if self._recv_filter(rx_bus, rx_addr) and len(rx_data) > 0:
             rx_data = bytes(rx_data)  # convert bytearray to bytes
 
-            if self.debug: print(f"CAN-RX: {hex(rx_addr)} - 0x{bytes.hex(rx_data)}")
+            if self.debug:
+              print(f"CAN-RX: {hex(rx_addr)} - 0x{bytes.hex(rx_data)}")
 
             # Cut off sub addr in first byte
             if self.sub_addr is not None:
@@ -320,7 +325,7 @@ class CanClient():
       if len(msgs) < 254:
         return
 
-  def recv(self, drain: bool=False) -> Generator[bytes, None, None]:
+  def recv(self, drain: bool = False) -> Generator[bytes, None, None]:
     # buffer rx messages in case two response messages are received at once
     # (e.g. response pending and success/failure response)
     self._recv_buffer(drain)
@@ -328,18 +333,20 @@ class CanClient():
       while True:
         yield self.rx_buff.popleft()
     except IndexError:
-      pass # empty
+      pass  # empty
 
-  def send(self, msgs: List[bytes], delay: float=0) -> None:
+  def send(self, msgs: List[bytes], delay: float = 0) -> None:
     for i, msg in enumerate(msgs):
       if delay and i != 0:
-        if self.debug: print(f"CAN-TX: delay - {delay}")
+        if self.debug:
+          print(f"CAN-TX: delay - {delay}")
         time.sleep(delay)
 
       if self.sub_addr is not None:
         msg = bytes([self.sub_addr]) + msg
 
-      if self.debug: print(f"CAN-TX: {hex(self.tx_addr)} - 0x{bytes.hex(msg)}")
+      if self.debug:
+        print(f"CAN-TX: {hex(self.tx_addr)} - 0x{bytes.hex(msg)}")
       assert len(msg) <= 8
 
       self.tx(self.tx_addr, msg, self.bus)
@@ -348,7 +355,7 @@ class CanClient():
         self._recv_buffer()
 
 class IsoTpMessage():
-  def __init__(self, can_client: CanClient, timeout: float=1, debug: bool=False, max_len: int=8):
+  def __init__(self, can_client: CanClient, timeout: float = 1, debug: bool = False, max_len: int = 8):
     self._can_client = can_client
     self.timeout = timeout
     self.debug = debug
@@ -368,18 +375,21 @@ class IsoTpMessage():
     self.rx_idx = 0
     self.rx_done = False
 
-    if self.debug: print(f"ISO-TP: REQUEST - 0x{bytes.hex(self.tx_dat)}")
+    if self.debug:
+      print(f"ISO-TP: REQUEST - 0x{bytes.hex(self.tx_dat)}")
     self._tx_first_frame()
 
   def _tx_first_frame(self) -> None:
     if self.tx_len < self.max_len:
       # single frame (send all bytes)
-      if self.debug: print("ISO-TP: TX - single frame")
+      if self.debug:
+        print("ISO-TP: TX - single frame")
       msg = (bytes([self.tx_len]) + self.tx_dat).ljust(self.max_len, b"\x00")
       self.tx_done = True
     else:
       # first frame (send first 6 bytes)
-      if self.debug: print("ISO-TP: TX - first frame")
+      if self.debug:
+        print("ISO-TP: TX - first frame")
       msg = (struct.pack("!H", 0x1000 | self.tx_len) + self.tx_dat[:self.max_len - 2]).ljust(self.max_len - 2, b"\x00")
     self._can_client.send([msg])
 
@@ -397,16 +407,18 @@ class IsoTpMessage():
         if time.time() - start_time > self.timeout:
           raise MessageTimeoutError("timeout waiting for response")
     finally:
-      if self.debug and self.rx_dat: print(f"ISO-TP: RESPONSE - 0x{bytes.hex(self.rx_dat)}")
+      if self.debug and self.rx_dat:
+        print(f"ISO-TP: RESPONSE - 0x{bytes.hex(self.rx_dat)}")
 
   def _isotp_rx_next(self, rx_data: bytes) -> None:
     # single rx_frame
     if rx_data[0] >> 4 == 0x0:
       self.rx_len = rx_data[0] & 0xFF
-      self.rx_dat = rx_data[1:1+self.rx_len]
+      self.rx_dat = rx_data[1:1 + self.rx_len]
       self.rx_idx = 0
       self.rx_done = True
-      if self.debug: print(f"ISO-TP: RX - single frame - idx={self.rx_idx} done={self.rx_done}")
+      if self.debug:
+        print(f"ISO-TP: RX - single frame - idx={self.rx_idx} done={self.rx_done}")
       return
 
     # first rx_frame
@@ -415,8 +427,10 @@ class IsoTpMessage():
       self.rx_dat = rx_data[2:]
       self.rx_idx = 0
       self.rx_done = False
-      if self.debug: print(f"ISO-TP: RX - first frame - idx={self.rx_idx} done={self.rx_done}")
-      if self.debug: print("ISO-TP: TX - flow control continue")
+      if self.debug:
+        print(f"ISO-TP: RX - first frame - idx={self.rx_idx} done={self.rx_done}")
+      if self.debug:
+        print("ISO-TP: TX - flow control continue")
       # send flow control message (send all bytes)
       msg = b"\x30\x00\x00".ljust(self.max_len, b"\x00")
       self._can_client.send([msg])
@@ -424,23 +438,25 @@ class IsoTpMessage():
 
     # consecutive rx frame
     if rx_data[0] >> 4 == 0x2:
-      assert self.rx_done == False, "isotp - rx: consecutive frame with no active frame"
+      assert not self.rx_done, "isotp - rx: consecutive frame with no active frame"
       self.rx_idx += 1
       assert self.rx_idx & 0xF == rx_data[0] & 0xF, "isotp - rx: invalid consecutive frame index"
       rx_size = self.rx_len - len(self.rx_dat)
-      self.rx_dat += rx_data[1:1+rx_size]
+      self.rx_dat += rx_data[1:1 + rx_size]
       if self.rx_len == len(self.rx_dat):
         self.rx_done = True
-      if self.debug: print(f"ISO-TP: RX - consecutive frame - idx={self.rx_idx} done={self.rx_done}")
+      if self.debug:
+        print(f"ISO-TP: RX - consecutive frame - idx={self.rx_idx} done={self.rx_done}")
       return
 
     # flow control
     if rx_data[0] >> 4 == 0x3:
-      assert self.tx_done == False, "isotp - rx: flow control with no active frame"
+      assert not self.tx_done, "isotp - rx: flow control with no active frame"
       assert rx_data[0] != 0x32, "isotp - rx: flow-control overflow/abort"
       assert rx_data[0] == 0x30 or rx_data[0] == 0x31, "isotp - rx: flow-control transfer state indicator invalid"
       if rx_data[0] == 0x30:
-        if self.debug: print("ISO-TP: RX - flow control continue")
+        if self.debug:
+          print("ISO-TP: RX - flow control continue")
         delay_ts = rx_data[2] & 0x7F
         # scale is 1 milliseconds if first bit == 0, 100 micro seconds if first bit == 1
         delay_div = 1000. if rx_data[2] & 0x80 == 0 else 10000.
@@ -455,16 +471,18 @@ class IsoTpMessage():
         for i in range(start, end, num_bytes):
           self.tx_idx += 1
           # consecutive tx messages
-          msg = (bytes([0x20 | (self.tx_idx & 0xF)]) + self.tx_dat[i:i+num_bytes]).ljust(self.max_len, b"\x00")
+          msg = (bytes([0x20 | (self.tx_idx & 0xF)]) + self.tx_dat[i:i + num_bytes]).ljust(self.max_len, b"\x00")
           tx_msgs.append(msg)
         # send consecutive tx messages
         self._can_client.send(tx_msgs, delay=delay_sec)
         if end >= self.tx_len:
           self.tx_done = True
-        if self.debug: print(f"ISO-TP: TX - consecutive frame - idx={self.tx_idx} done={self.tx_done}")
+        if self.debug:
+          print(f"ISO-TP: TX - consecutive frame - idx={self.tx_idx} done={self.tx_done}")
       elif rx_data[0] == 0x31:
         # wait (do nothing until next flow control message)
-        if self.debug: print("ISO-TP: TX - flow control wait")
+        if self.debug:
+          print("ISO-TP: TX - flow control wait")
 
 FUNCTIONAL_ADDRS = [0x7DF, 0x18DB33F1]
 
@@ -478,13 +496,13 @@ def get_rx_addr_for_tx_addr(tx_addr):
 
   if tx_addr > 0x10000000 and tx_addr < 0xFFFFFFFF:
     # standard 29 bit response addr (flip last two bytes)
-    return (tx_addr & 0xFFFF0000) + (tx_addr<<8 & 0xFF00) + (tx_addr>>8 & 0xFF)
+    return (tx_addr & 0xFFFF0000) + (tx_addr << 8 & 0xFF00) + (tx_addr >> 8 & 0xFF)
 
   raise ValueError("invalid tx_addr: {}".format(tx_addr))
 
 
 class UdsClient():
-  def __init__(self, panda, tx_addr: int, rx_addr: int=None, bus: int=0, timeout: float=1, debug: bool=False):
+  def __init__(self, panda, tx_addr: int, rx_addr: int = None, bus: int = 0, timeout: float = 1, debug: bool = False):
     self.bus = bus
     self.tx_addr = tx_addr
     self.rx_addr = rx_addr if rx_addr is not None else get_rx_addr_for_tx_addr(tx_addr)
@@ -493,7 +511,7 @@ class UdsClient():
     self._can_client = CanClient(panda.can_send, panda.can_recv, self.tx_addr, self.rx_addr, self.bus, debug=self.debug)
 
   # generic uds request
-  def _uds_request(self, service_type: SERVICE_TYPE, subfunction: int=None, data: bytes=None) -> bytes:
+  def _uds_request(self, service_type: SERVICE_TYPE, subfunction: int = None, data: bytes = None) -> bytes:
     req = bytes([service_type])
     if subfunction is not None:
       req += bytes([subfunction])
@@ -525,12 +543,13 @@ class UdsClient():
           error_desc = resp[3:].hex()
         # wait for another message if response pending
         if error_code == 0x78:
-          if self.debug: print("UDS-RX: response pending")
+          if self.debug:
+            print("UDS-RX: response pending")
           continue
         raise NegativeResponseError('{} - {}'.format(service_desc, error_desc), service_id, error_code)
 
       # positive response
-      if service_type+0x40 != resp_sid:
+      if service_type + 0x40 != resp_sid:
         resp_sid_hex = hex(resp_sid) if resp_sid is not None else None
         raise InvalidServiceIdError('invalid response service id: {}'.format(resp_sid_hex))
 
@@ -554,7 +573,7 @@ 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 = None):
     request_seed = access_type % 2 != 0
     if request_seed and security_key is not None:
       raise ValueError('security_key not allowed')
@@ -572,12 +591,10 @@ class UdsClient():
   def tester_present(self, ):
     self._uds_request(SERVICE_TYPE.TESTER_PRESENT, subfunction=0x00)
 
-  def access_timing_parameter(self, timing_parameter_type: TIMING_PARAMETER_TYPE, parameter_values: bytes=None):
+  def access_timing_parameter(self, timing_parameter_type: TIMING_PARAMETER_TYPE, parameter_values: bytes = None):
     write_custom_values = timing_parameter_type == TIMING_PARAMETER_TYPE.SET_TO_GIVEN_VALUES
-    read_values = (
-      timing_parameter_type == TIMING_PARAMETER_TYPE.READ_CURRENTLY_ACTIVE or
-      timing_parameter_type == TIMING_PARAMETER_TYPE.READ_EXTENDED_SET
-    )
+    read_values = (timing_parameter_type == TIMING_PARAMETER_TYPE.READ_CURRENTLY_ACTIVE or
+                   timing_parameter_type == TIMING_PARAMETER_TYPE.READ_EXTENDED_SET)
     if not write_custom_values and parameter_values is not None:
       raise ValueError('parameter_values not allowed')
     if write_custom_values and parameter_values is None:
@@ -597,7 +614,8 @@ class UdsClient():
   def control_dtc_setting(self, dtc_setting_type: DTC_SETTING_TYPE):
     self._uds_request(SERVICE_TYPE.CONTROL_DTC_SETTING, subfunction=dtc_setting_type)
 
-  def response_on_event(self, response_event_type: RESPONSE_EVENT_TYPE, store_event: bool, window_time: int, event_type_record: int, service_response_record: int):
+  def response_on_event(self, response_event_type: RESPONSE_EVENT_TYPE, store_event: bool, window_time: int,
+                        event_type_record: int, service_response_record: int):
     if store_event:
       response_event_type |= 0x20  # type: ignore
     # TODO: split record parameters into arrays
@@ -607,17 +625,17 @@ class UdsClient():
     if response_event_type == RESPONSE_EVENT_TYPE.REPORT_ACTIVATED_EVENTS:
       return {
         "num_of_activated_events": resp[0],
-        "data": resp[1:], # TODO: parse the reset of response
+        "data": resp[1:],  # TODO: parse the reset of response
       }
 
     return {
       "num_of_identified_events": resp[0],
       "event_window_time": resp[1],
-      "data": resp[2:], # TODO: parse the reset of response
+      "data": resp[2:],  # TODO: parse the reset of response
     }
 
-  def link_control(self, link_control_type: LINK_CONTROL_TYPE, baud_rate_type: BAUD_RATE_TYPE=None):
-    data : Optional[bytes]
+  def link_control(self, link_control_type: LINK_CONTROL_TYPE, baud_rate_type: BAUD_RATE_TYPE = None):
+    data: Optional[bytes]
 
     if link_control_type == LINK_CONTROL_TYPE.VERIFY_BAUDRATE_TRANSITION_WITH_FIXED_BAUDRATE:
       # baud_rate_type = BAUD_RATE_TYPE
@@ -638,19 +656,19 @@ class UdsClient():
       raise ValueError('invalid response data identifier: {}'.format(hex(resp_id)))
     return resp[2:]
 
-  def read_memory_by_address(self, memory_address: int, memory_size: int, memory_address_bytes: int=4, memory_size_bytes: int=1):
+  def read_memory_by_address(self, memory_address: int, memory_size: int, memory_address_bytes: int = 4, memory_size_bytes: int = 1):
     if memory_address_bytes < 1 or memory_address_bytes > 4:
       raise ValueError('invalid memory_address_bytes: {}'.format(memory_address_bytes))
     if memory_size_bytes < 1 or memory_size_bytes > 4:
       raise ValueError('invalid memory_size_bytes: {}'.format(memory_size_bytes))
-    data = bytes([memory_size_bytes<<4 | memory_address_bytes])
+    data = bytes([memory_size_bytes << 4 | memory_address_bytes])
 
-    if memory_address >= 1<<(memory_address_bytes*8):
+    if memory_address >= 1 << (memory_address_bytes * 8):
       raise ValueError('invalid memory_address: {}'.format(memory_address))
-    data += struct.pack('!I', memory_address)[4-memory_address_bytes:]
-    if memory_size >= 1<<(memory_size_bytes*8):
+    data += struct.pack('!I', memory_address)[4 - memory_address_bytes:]
+    if memory_size >= 1 << (memory_size_bytes * 8):
       raise ValueError('invalid memory_size: {}'.format(memory_size))
-    data += struct.pack('!I', memory_size)[4-memory_size_bytes:]
+    data += struct.pack('!I', memory_size)[4 - memory_size_bytes:]
 
     resp = self._uds_request(SERVICE_TYPE.READ_MEMORY_BY_ADDRESS, subfunction=None, data=data)
     return resp
@@ -661,14 +679,15 @@ class UdsClient():
     resp_id = struct.unpack('!H', resp[0:2])[0] if len(resp) >= 2 else None
     if resp_id != data_identifier_type:
       raise ValueError('invalid response data identifier: {}'.format(hex(resp_id)))
-    return resp[2:] # TODO: parse the response
+    return resp[2:]  # TODO: parse the response
 
   def read_data_by_periodic_identifier(self, transmission_mode_type: TRANSMISSION_MODE_TYPE, periodic_data_identifier: int):
     # TODO: support list of identifiers
     data = bytes([transmission_mode_type, periodic_data_identifier])
     self._uds_request(SERVICE_TYPE.READ_DATA_BY_PERIODIC_IDENTIFIER, subfunction=None, data=data)
 
-  def dynamically_define_data_identifier(self, dynamic_definition_type: DYNAMIC_DEFINITION_TYPE, dynamic_data_identifier: int, source_definitions: List[DynamicSourceDefinition], memory_address_bytes: int=4, memory_size_bytes: int=1):
+  def dynamically_define_data_identifier(self, dynamic_definition_type: DYNAMIC_DEFINITION_TYPE, dynamic_data_identifier: int,
+                                         source_definitions: List[DynamicSourceDefinition], memory_address_bytes: int = 4, memory_size_bytes: int = 1):
     if memory_address_bytes < 1 or memory_address_bytes > 4:
       raise ValueError('invalid memory_address_bytes: {}'.format(memory_address_bytes))
     if memory_size_bytes < 1 or memory_size_bytes > 4:
@@ -679,14 +698,14 @@ class UdsClient():
       for s in source_definitions:
         data += struct.pack('!H', s.data_identifier) + bytes([s.position, s.memory_size])
     elif dynamic_definition_type == DYNAMIC_DEFINITION_TYPE.DEFINE_BY_MEMORY_ADDRESS:
-      data += bytes([memory_size_bytes<<4 | memory_address_bytes])
+      data += bytes([memory_size_bytes << 4 | memory_address_bytes])
       for s in source_definitions:
-        if s.memory_address >= 1<<(memory_address_bytes*8):
+        if s.memory_address >= 1 << (memory_address_bytes * 8):
           raise ValueError('invalid memory_address: {}'.format(s.memory_address))
-        data += struct.pack('!I', s.memory_address)[4-memory_address_bytes:]
-        if s.memory_size >= 1<<(memory_size_bytes*8):
+        data += struct.pack('!I', s.memory_address)[4 - memory_address_bytes:]
+        if s.memory_size >= 1 << (memory_size_bytes * 8):
           raise ValueError('invalid memory_size: {}'.format(s.memory_size))
-        data += struct.pack('!I', s.memory_size)[4-memory_size_bytes:]
+        data += struct.pack('!I', s.memory_size)[4 - memory_size_bytes:]
     elif dynamic_definition_type == DYNAMIC_DEFINITION_TYPE.CLEAR_DYNAMICALLY_DEFINED_DATA_IDENTIFIER:
       pass
     else:
@@ -700,64 +719,67 @@ class UdsClient():
     if resp_id != data_identifier_type:
       raise ValueError('invalid response data identifier: {}'.format(hex(resp_id)))
 
-  def write_memory_by_address(self, memory_address: int, memory_size: int, data_record: bytes, memory_address_bytes: int=4, memory_size_bytes: int=1):
+  def write_memory_by_address(self, memory_address: int, memory_size: int, data_record: bytes, memory_address_bytes: int = 4, memory_size_bytes: int = 1):
     if memory_address_bytes < 1 or memory_address_bytes > 4:
       raise ValueError('invalid memory_address_bytes: {}'.format(memory_address_bytes))
     if memory_size_bytes < 1 or memory_size_bytes > 4:
       raise ValueError('invalid memory_size_bytes: {}'.format(memory_size_bytes))
-    data = bytes([memory_size_bytes<<4 | memory_address_bytes])
+    data = bytes([memory_size_bytes << 4 | memory_address_bytes])
 
-    if memory_address >= 1<<(memory_address_bytes*8):
+    if memory_address >= 1 << (memory_address_bytes * 8):
       raise ValueError('invalid memory_address: {}'.format(memory_address))
-    data += struct.pack('!I', memory_address)[4-memory_address_bytes:]
-    if memory_size >= 1<<(memory_size_bytes*8):
+    data += struct.pack('!I', memory_address)[4 - memory_address_bytes:]
+    if memory_size >= 1 << (memory_size_bytes * 8):
       raise ValueError('invalid memory_size: {}'.format(memory_size))
-    data += struct.pack('!I', memory_size)[4-memory_size_bytes:]
+    data += struct.pack('!I', memory_size)[4 - memory_size_bytes:]
 
     data += data_record
     self._uds_request(SERVICE_TYPE.WRITE_MEMORY_BY_ADDRESS, subfunction=0x00, data=data)
 
   def clear_diagnostic_information(self, dtc_group_type: DTC_GROUP_TYPE):
-    data = struct.pack('!I', dtc_group_type)[1:] # 3 bytes
+    data = struct.pack('!I', dtc_group_type)[1:]  # 3 bytes
     self._uds_request(SERVICE_TYPE.CLEAR_DIAGNOSTIC_INFORMATION, subfunction=None, data=data)
 
-  def read_dtc_information(self, dtc_report_type: DTC_REPORT_TYPE, dtc_status_mask_type: DTC_STATUS_MASK_TYPE=DTC_STATUS_MASK_TYPE.ALL, dtc_severity_mask_type: DTC_SEVERITY_MASK_TYPE=DTC_SEVERITY_MASK_TYPE.ALL, dtc_mask_record: int=0xFFFFFF, dtc_snapshot_record_num: int=0xFF, dtc_extended_record_num: int=0xFF):
+  def read_dtc_information(self, dtc_report_type: DTC_REPORT_TYPE, dtc_status_mask_type: DTC_STATUS_MASK_TYPE = DTC_STATUS_MASK_TYPE.ALL,
+                           dtc_severity_mask_type: DTC_SEVERITY_MASK_TYPE = DTC_SEVERITY_MASK_TYPE.ALL, dtc_mask_record: int = 0xFFFFFF,
+                           dtc_snapshot_record_num: int = 0xFF, dtc_extended_record_num: int = 0xFF):
     data = b''
     # dtc_status_mask_type
     if dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_DTC_BY_STATUS_MASK or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_BY_STATUS_MASK or \
-      dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_BY_STATUS_MASK or \
-      dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_MIRROR_MEMORY_DTC_BY_STATUS_MASK or \
-      dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_EMISSIONS_RELATED_OBD_DTC_BY_STATUS_MASK or \
-      dtc_report_type == DTC_REPORT_TYPE.EMISSIONS_RELATED_OBD_DTC_BY_STATUS_MASK:
-      data += bytes([dtc_status_mask_type])
+       dtc_report_type == DTC_REPORT_TYPE.DTC_BY_STATUS_MASK or \
+       dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_BY_STATUS_MASK or \
+       dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_MIRROR_MEMORY_DTC_BY_STATUS_MASK or \
+       dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_EMISSIONS_RELATED_OBD_DTC_BY_STATUS_MASK or \
+       dtc_report_type == DTC_REPORT_TYPE.EMISSIONS_RELATED_OBD_DTC_BY_STATUS_MASK:
+       data += bytes([dtc_status_mask_type])
     # dtc_mask_record
     if dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_IDENTIFICATION or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
-      dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
-      dtc_report_type == DTC_REPORT_TYPE.SEVERITY_INFORMATION_OF_DTC:
-      data += struct.pack('!I', dtc_mask_record)[1:] # 3 bytes
+       dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \
+       dtc_report_type == DTC_REPORT_TYPE.DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
+       dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
+       dtc_report_type == DTC_REPORT_TYPE.SEVERITY_INFORMATION_OF_DTC:
+       data += struct.pack('!I', dtc_mask_record)[1:]  # 3 bytes
     # dtc_snapshot_record_num
     if dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_IDENTIFICATION or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_RECORD_NUMBER:
-      data += bytes([dtc_snapshot_record_num])
+       dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_DTC_NUMBER or \
+       dtc_report_type == DTC_REPORT_TYPE.DTC_SNAPSHOT_RECORD_BY_RECORD_NUMBER:
+       data += bytes([dtc_snapshot_record_num])
     # dtc_extended_record_num
     if dtc_report_type == DTC_REPORT_TYPE.DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER or \
-      dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER:
-      data += bytes([dtc_extended_record_num])
+       dtc_report_type == DTC_REPORT_TYPE.MIRROR_MEMORY_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER:
+       data += bytes([dtc_extended_record_num])
     # dtc_severity_mask_type
     if dtc_report_type == DTC_REPORT_TYPE.NUMBER_OF_DTC_BY_SEVERITY_MASK_RECORD or \
-      dtc_report_type == DTC_REPORT_TYPE.DTC_BY_SEVERITY_MASK_RECORD:
-      data += bytes([dtc_severity_mask_type, dtc_status_mask_type])
+       dtc_report_type == DTC_REPORT_TYPE.DTC_BY_SEVERITY_MASK_RECORD:
+       data += bytes([dtc_severity_mask_type, dtc_status_mask_type])
 
     resp = self._uds_request(SERVICE_TYPE.READ_DTC_INFORMATION, subfunction=dtc_report_type, data=data)
 
     # TODO: parse response
     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''):
+  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''):
     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
@@ -765,7 +787,7 @@ class UdsClient():
       raise ValueError('invalid response data identifier: {}'.format(hex(resp_id)))
     return resp[2:]
 
-  def routine_control(self, routine_control_type: ROUTINE_CONTROL_TYPE, routine_identifier_type: ROUTINE_IDENTIFIER_TYPE, routine_option_record: bytes=b''):
+  def routine_control(self, routine_control_type: ROUTINE_CONTROL_TYPE, routine_identifier_type: ROUTINE_IDENTIFIER_TYPE, routine_option_record: bytes = b''):
     data = struct.pack('!H', routine_identifier_type) + routine_option_record
     resp = self._uds_request(SERVICE_TYPE.ROUTINE_CONTROL, subfunction=routine_control_type, data=data)
     resp_id = struct.unpack('!H', resp[0:2])[0] if len(resp) >= 2 else None
@@ -773,57 +795,57 @@ class UdsClient():
       raise ValueError('invalid response routine identifier: {}'.format(hex(resp_id)))
     return resp[2:]
 
-  def request_download(self, memory_address: int, memory_size: int, memory_address_bytes: int=4, memory_size_bytes: int=4, data_format: int=0x00):
+  def request_download(self, memory_address: int, memory_size: int, memory_address_bytes: int = 4, memory_size_bytes: int = 4, data_format: int = 0x00):
     data = bytes([data_format])
 
     if memory_address_bytes < 1 or memory_address_bytes > 4:
       raise ValueError('invalid memory_address_bytes: {}'.format(memory_address_bytes))
     if memory_size_bytes < 1 or memory_size_bytes > 4:
       raise ValueError('invalid memory_size_bytes: {}'.format(memory_size_bytes))
-    data += bytes([memory_size_bytes<<4 | memory_address_bytes])
+    data += bytes([memory_size_bytes << 4 | memory_address_bytes])
 
-    if memory_address >= 1<<(memory_address_bytes*8):
+    if memory_address >= 1 << (memory_address_bytes * 8):
       raise ValueError('invalid memory_address: {}'.format(memory_address))
-    data += struct.pack('!I', memory_address)[4-memory_address_bytes:]
-    if memory_size >= 1<<(memory_size_bytes*8):
+    data += struct.pack('!I', memory_address)[4 - memory_address_bytes:]
+    if memory_size >= 1 << (memory_size_bytes * 8):
       raise ValueError('invalid memory_size: {}'.format(memory_size))
-    data += struct.pack('!I', memory_size)[4-memory_size_bytes:]
+    data += struct.pack('!I', memory_size)[4 - memory_size_bytes:]
 
     resp = self._uds_request(SERVICE_TYPE.REQUEST_DOWNLOAD, subfunction=None, data=data)
     max_num_bytes_len = resp[0] >> 4 if len(resp) > 0 else 0
     if max_num_bytes_len >= 1 and max_num_bytes_len <= 4:
-      max_num_bytes = struct.unpack('!I', (b"\x00"*(4-max_num_bytes_len))+resp[1:max_num_bytes_len+1])[0]
+      max_num_bytes = struct.unpack('!I', (b"\x00" * (4 - max_num_bytes_len)) + resp[1:max_num_bytes_len + 1])[0]
     else:
       raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len))
 
-    return max_num_bytes # max number of bytes per transfer data request
+    return max_num_bytes  # max number of bytes per transfer data request
 
-  def request_upload(self, memory_address: int, memory_size: int, memory_address_bytes: int=4, memory_size_bytes: int=4, data_format: int=0x00):
+  def request_upload(self, memory_address: int, memory_size: int, memory_address_bytes: int = 4, memory_size_bytes: int = 4, data_format: int = 0x00):
     data = bytes([data_format])
 
     if memory_address_bytes < 1 or memory_address_bytes > 4:
       raise ValueError('invalid memory_address_bytes: {}'.format(memory_address_bytes))
     if memory_size_bytes < 1 or memory_size_bytes > 4:
       raise ValueError('invalid memory_size_bytes: {}'.format(memory_size_bytes))
-    data += bytes([memory_size_bytes<<4 | memory_address_bytes])
+    data += bytes([memory_size_bytes << 4 | memory_address_bytes])
 
-    if memory_address >= 1<<(memory_address_bytes*8):
+    if memory_address >= 1 << (memory_address_bytes * 8):
       raise ValueError('invalid memory_address: {}'.format(memory_address))
-    data += struct.pack('!I', memory_address)[4-memory_address_bytes:]
-    if memory_size >= 1<<(memory_size_bytes*8):
+    data += struct.pack('!I', memory_address)[4 - memory_address_bytes:]
+    if memory_size >= 1 << (memory_size_bytes * 8):
       raise ValueError('invalid memory_size: {}'.format(memory_size))
-    data += struct.pack('!I', memory_size)[4-memory_size_bytes:]
+    data += struct.pack('!I', memory_size)[4 - memory_size_bytes:]
 
     resp = self._uds_request(SERVICE_TYPE.REQUEST_UPLOAD, subfunction=None, data=data)
     max_num_bytes_len = resp[0] >> 4 if len(resp) > 0 else 0
     if max_num_bytes_len >= 1 and max_num_bytes_len <= 4:
-      max_num_bytes = struct.unpack('!I', (b"\x00"*(4-max_num_bytes_len))+resp[1:max_num_bytes_len+1])[0]
+      max_num_bytes = struct.unpack('!I', (b"\x00" * (4 - max_num_bytes_len)) + resp[1:max_num_bytes_len + 1])[0]
     else:
       raise ValueError('invalid max_num_bytes_len: {}'.format(max_num_bytes_len))
 
-    return max_num_bytes # max number of bytes per transfer data request
+    return max_num_bytes  # max number of bytes per transfer data request
 
-  def transfer_data(self, block_sequence_count: int, data: bytes=b''):
+  def transfer_data(self, block_sequence_count: int, data: bytes = b''):
     data = bytes([block_sequence_count]) + data
     resp = self._uds_request(SERVICE_TYPE.TRANSFER_DATA, subfunction=None, data=data)
     resp_id = resp[0] if len(resp) > 0 else None

panda/python/update.py

@@ -42,4 +42,3 @@ def ensure_st_up_to_date():
 
 if __name__ == "__main__":
   ensure_st_up_to_date()
-