robinkrens.nl - git repository - renesas-ra-flasher/blob - src/RAConnect.py

   1 import sys
   2 import time
   3 import usb.core
   4 import usb.util
   5
   6 MAX_TRANSFER_SIZE = 2048 + 6 # include header and footer
   7
   8 class RAConnect:
   9     def __init__(self, vendor_id, product_id):
  10         self.vendor_id = vendor_id
  11         self.product_id = product_id
  12         self.ep_in = 0x81
  13         self.ep_out = 0x02
  14         self.max_tries = 20
  15         self.timeout_ms = 100
  16         self.dev = None
  17         self.rx_ep = None
  18         self.tx_ep = None
  19         self.find_device()
  20
  21     def find_device(self):
  22         self.dev = usb.core.find(idVendor=self.vendor_id, idProduct=self.product_id)
  23         if self.dev is None:
  24             raise ValueError(f"Device {self.vendor_id}:{self.product_id} not found\nAre you sure it is connected?")
  25
  26         for config in self.dev:
  27             intf = config[(1,0)]
  28             print(f'Found usb device {self.vendor_id}:{self.product_id}')
  29             if self.dev.is_kernel_driver_active(intf.bInterfaceNumber):
  30                 print("Found kernel driver, detaching ... ")
  31                 self.dev.detach_kernel_driver(intf.bInterfaceNumber)
  32             for ep in intf:
  33                 if (ep.bmAttributes == 0x02):
  34                     if ep.bEndpointAddress == self.ep_in:
  35                         self.rx_ep = ep
  36                     elif ep.bEndpointAddress == self.ep_out:
  37                         self.tx_ep = ep
  38             return True
  39
  40         raise ValueError("Device does not have a serial interface")
  41
  42     def establish_connection(self):
  43         for i in range(self.max_tries):
  44             try:
  45                 self.tx_ep.write(bytes([0x00]), self.timeout_ms)
  46                 ret = self.rx_ep.read(1, self.timeout_ms)
  47                 if ret[0] == 0x00:
  48                     print("Reply ACK received (0x00)")
  49                     return True
  50             except usb.core.USBError as e:
  51                 print(f"Timeout: retry #{i}", e)
  52         return False
  53
  54     def confirm_connection(self):
  55         for i in range(self.max_tries):
  56             try:
  57                 self.tx_ep.write(bytes([0x55]), self.timeout_ms)
  58                 ret = self.rx_ep.read(1, self.timeout_ms)
  59                 if ret[0] == 0xC3:
  60                     print("Reply received (0xC3)")
  61                     return True
  62             except usb.core.USBError as e:
  63                 print(f"Timeout: retry #{i}", e)
  64         return False
  65
  66     def authenticate_connection(self):
  67         raise Exception("Not implemented")
  68
  69     def send_data(self, packed_data):
  70         if (self.tx_ep == None):
  71             return False
  72         try:
  73             self.tx_ep.write(packed_data, self.timeout_ms)
  74         except usb.core.USBError as e:
  75             print(f"Timeout: error", e)
  76             return False
  77         return True
  78
  79     def recv_data(self, exp_len):
  80         msg = bytearray(b'')
  81         if (exp_len > MAX_TRANSFER_SIZE):
  82             raise ValueError(f"length package {exp_len} over max transfer size")
  83         if (self.rx_ep == None):
  84             return False
  85         try:
  86             received = 0
  87             while received != exp_len:
  88                 buf = self.rx_ep.read(exp_len, self.timeout_ms)
  89                 msg += buf
  90                 received += len(buf)
  91                 if received == exp_len:
  92                     return msg
  93         except usb.core.USBError as e:
  94             print(f"Timeout: error", e)
  95         return msg