138 lines
5.4 KiB
Python
138 lines
5.4 KiB
Python
"""Non-blocking port of Gui_Android's INITLOAD / LOAD / TFLASH workflow."""
|
|
from .qt_compat import QObject, QTimer, Signal
|
|
from .qt_compat import QSerialPort
|
|
|
|
from protocan import tms_firmware as wire
|
|
|
|
|
|
class TmsBootloader(QObject):
|
|
progress = Signal(int, str)
|
|
finished = Signal(bool, str)
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self._serial = QSerialPort(self)
|
|
self._serial.readyRead.connect(self._read)
|
|
self._serial.errorOccurred.connect(self._error)
|
|
self._timeout = QTimer(self)
|
|
self._timeout.setSingleShot(True)
|
|
self._timeout.timeout.connect(lambda: self._finish(False, f"Тайм-аут {self._stage}"))
|
|
self._settle = QTimer(self)
|
|
self._settle.setSingleShot(True)
|
|
self._settle.setInterval(100)
|
|
self._settle.timeout.connect(self._accept)
|
|
self._delay = QTimer(self)
|
|
self._delay.setSingleShot(True)
|
|
self._delay.setInterval(100)
|
|
self._delay.timeout.connect(self._advance)
|
|
self._active = False
|
|
self._waiting = False
|
|
self._rx = bytearray()
|
|
self._stage = ""
|
|
|
|
def start(self, image, port: str, baud: int, target: wire.TmsTarget):
|
|
if self._active:
|
|
return
|
|
try:
|
|
target.validate(len(image.data))
|
|
if not port or baud <= 0:
|
|
raise ValueError("Неверные настройки COM-порта")
|
|
except ValueError as error:
|
|
self.finished.emit(False, str(error))
|
|
return
|
|
self._image, self._target = image, target
|
|
self._active = True
|
|
self._serial.setPortName(port)
|
|
self._serial.setBaudRate(baud)
|
|
self._serial.setDataBits(QSerialPort.DataBits.Data8)
|
|
self._serial.setParity(QSerialPort.Parity.NoParity)
|
|
self._serial.setStopBits(QSerialPort.StopBits.OneStop)
|
|
self._serial.setFlowControl(QSerialPort.FlowControl.NoFlowControl)
|
|
if not self._serial.open(QSerialPort.OpenModeFlag.ReadWrite):
|
|
self._finish(False, self._serial.errorString())
|
|
return
|
|
self._response = None
|
|
self._steps = wire.programming_steps(image.data, target)
|
|
self._advance()
|
|
|
|
def _advance(self):
|
|
if not self._active:
|
|
return
|
|
try:
|
|
request, self._size, timeout, self._stage, percent = self._steps.send(self._response)
|
|
except StopIteration:
|
|
self._finish(True, "Образ загружен в RAM TMS" if self._target.load_only
|
|
else "Запись Spartan-6 подтверждена платой" if self._target.kind == "spartan6"
|
|
else "Прошивка завершена, записанные данные проверены")
|
|
return
|
|
except (ValueError, RuntimeError) as error:
|
|
self._finish(False, str(error))
|
|
return
|
|
self._command = request[1]
|
|
self._rx.clear()
|
|
self._waiting = True
|
|
self.progress.emit(percent, self._stage)
|
|
# LOAD is one continuous write, without pauses inside its packet.
|
|
if self._serial.write(request) != len(request):
|
|
self._finish(False, "Ошибка передачи " + self._stage)
|
|
return
|
|
if self._active:
|
|
self._timeout.start(timeout + int(len(request) * 10000 / self._serial.baudRate()))
|
|
|
|
def _read(self):
|
|
chunk = bytes(self._serial.readAll())
|
|
if not self._waiting:
|
|
return
|
|
self._rx.extend(chunk)
|
|
header = bytes((self._target.controller, self._command))
|
|
start = self._rx.find(header)
|
|
if start < 0:
|
|
self._rx[:] = self._rx[-1:]
|
|
return
|
|
del self._rx[:start]
|
|
# Some devices send an ACK before an UPLOAD data response.
|
|
if self._size > 6:
|
|
for ack_size in (6, 4):
|
|
if (self._rx[ack_size:ack_size + 2] == header
|
|
and wire.normalize_reply(bytes(self._rx[:ack_size]), *header, 6)):
|
|
del self._rx[:ack_size]
|
|
break
|
|
if len(self._rx) >= self._size:
|
|
self._accept()
|
|
else:
|
|
self._settle.start()
|
|
|
|
def _accept(self):
|
|
if not self._waiting:
|
|
return
|
|
reply = wire.normalize_reply(bytes(self._rx[:self._size]), self._target.controller, self._command, self._size)
|
|
if reply is None:
|
|
if len(self._rx) >= self._size:
|
|
self._finish(False, "Неверный CRC ответа " + self._stage)
|
|
return
|
|
self._timeout.stop()
|
|
self._settle.stop()
|
|
self._waiting = False
|
|
self._response = reply
|
|
self._delay.start()
|
|
|
|
def cancel(self):
|
|
if self._active:
|
|
self._finish(False, "Операция TMS отменена; запись Flash могла быть начата")
|
|
|
|
def _error(self, error):
|
|
if self._active and error not in (QSerialPort.SerialPortError.NoError, QSerialPort.SerialPortError.TimeoutError):
|
|
self._finish(False, self._serial.errorString())
|
|
|
|
def _finish(self, success, message):
|
|
if not self._active:
|
|
return
|
|
self._active = self._waiting = False
|
|
for timer in (self._timeout, self._settle, self._delay):
|
|
timer.stop()
|
|
if self._serial.isOpen():
|
|
self._serial.close()
|
|
if success:
|
|
self.progress.emit(100, message)
|
|
self.finished.emit(success, message)
|