qt: Added support of async read/write from/to serial port and changed read chip ID to use async operations

Author: bbogush

qt/main_window.cpp

@@ -5,7 +5,6 @@
 
 #include "main_window.h"
 #include "ui_main_window.h"
-#include "programmer.h"
 #include "chip_db.h"
 #include <QDebug>
 #include <QFileDialog>
@@ -171,19 +170,19 @@ void MainWindow::slotProgConnect()
     }
 }
 
-void MainWindow::slotProgReadDeviceId()
+void MainWindow::readChipIdCb(ChipId id)
 {
-    ChipId id;
     QString idStr;
 
-    if (prog->readChipId(&id))
-        log(tr("Failed to read chip ID\n"));
-    else
-    {
-        idStr.sprintf("0x%02X 0x%02X 0x%02X 0x%02X", id.makerId, id.deviceId,
-            id.thirdId, id.fourthId);
-        ui->deviceValueLabel->setText(idStr);
-    }
+    idStr.sprintf("0x%02X 0x%02X 0x%02X 0x%02X", id.makerId, id.deviceId,
+        id.thirdId, id.fourthId);
+    ui->deviceValueLabel->setText(idStr);
+}
+
+void MainWindow::slotProgReadDeviceId()
+{
+    prog->readChipId(std::bind(&MainWindow::readChipIdCb, this,
+        std::placeholders::_1));
 }
 
 void MainWindow::slotProgErase()

qt/main_window.h

@@ -6,14 +6,13 @@
 #ifndef MAIN_WINDOW_H
 #define MAIN_WINDOW_H
 
+#include "programmer.h"
 #include <QMainWindow>
 
 namespace Ui {
 class MainWindow;
 }
 
-class Programmer;
-
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -29,6 +28,7 @@ class MainWindow : public QMainWindow
 
     void insertBufferRow(quint8 *readBuf, quint32 size, quint32 rowNum,
         quint32 address);
+    void readChipIdCb(ChipId id);
 
 public slots:
     void slotFileOpen();

qt/programmer.cpp

@@ -15,6 +15,8 @@
 
 Programmer::Programmer(QObject *parent) : QObject(parent)
 {
+    serialPortReader = new SerialPortReader(&serialPort, this);
+    serialPortWriter = new SerialPortWriter(&serialPort, this);
 }
 
 Programmer::~Programmer()
@@ -149,59 +151,59 @@ int Programmer::handleWrongResp(uint8_t code)
     return -1;
 }
 
-int Programmer::handleRespChipId(RespId *respId, ChipId *id)
+void Programmer::readRespChipIdCb(int status)
 {
-    qint64 ret;
+    uint size;
+    RespId *respId;
 
-    if (respId->header.info != sizeof(respId->nandId))
-    {
-        qCritical() << "Wrong chip ID responce length";
-        return -1;
-    }
+    if (status == SerialPortReader::READ_ERROR)
+        return;
 
-    serialPort.waitForReadyRead(1);
-    ret = serialPort.read((char *)&respId->nandId, sizeof(respId->nandId));
-    if (ret < 0)
+    size = readData.size();
+    if (size < sizeof(RespHeader))
     {
-        qCritical() << "Failed to read response data: " << serialPort.error()
-            << serialPort.errorString();
-        return -1;
+        qCritical() << "Header size of chip ID response is wrong:" << size;
+        return;
     }
 
-    if (ret != sizeof(respId->nandId))
+    respId = (RespId *)readData.data();
+    switch (respId->header.code)
     {
-        qCritical() << "Failed to read responce data: data was partially "
-            "received";
-        return -1;
+    case RESP_DATA:
+        if (size < sizeof(RespId))
+        {
+            qCritical() << "Size of chip ID response is wrong:" << size;
+            return;
+        }
+        readChipIdCb(respId->nandId);
+        break;
+    case RESP_STATUS:
+        handleStatus(&respId->header);
+        break;
+    default:
+        handleWrongResp(respId->header.code);
+        break;
     }
+}
 
-    *id = respId->nandId;
-
-    return 0;
+void Programmer::sendCmdCb(int status)
+{
+    if (status == SerialPortWriter::WRITE_ERROR)
+        return;
 }
 
-int Programmer::readChipId(ChipId *id)
+void Programmer::readChipId(std::function<void(ChipId)> callback)
 {
-    RespId respId;
     Cmd cmd = { .code = CMD_NAND_READ_ID };
 
-    if (sendCmd(&cmd, sizeof(cmd)))
-        return -1;
-
-    if (readRespHead(&respId.header))
-        return -1;
+    serialPortReader->read(std::bind(&Programmer::readRespChipIdCb, this,
+        std::placeholders::_1), &readData);
 
-    switch (respId.header.code)
-    {
-    case RESP_DATA:
-        return handleRespChipId(&respId, id);
-    case RESP_STATUS:
-        return handleStatus(&respId.header);
-     default:
-        return handleWrongResp(respId.header.code);
-    }
-
-    return 0;
+    readChipIdCb = callback;
+    writeData.clear();
+    writeData.append((const char *)&cmd, sizeof(cmd));
+    serialPortWriter->write(std::bind(&Programmer::sendCmdCb,
+        this, std::placeholders::_1), &writeData);
 }
 
 int Programmer::eraseChip(uint32_t addr, uint32_t len)

qt/programmer.h

@@ -8,7 +8,11 @@
 
 #include <QObject>
 #include <QtSerialPort/QSerialPort>
+#include <QByteArray>
 #include <cstdint>
+#include <functional>
+#include "serial_port_writer.h"
+#include "serial_port_reader.h"
 
 using namespace std;
 
@@ -111,22 +115,28 @@ class Programmer : public QObject
     Q_OBJECT
 
     QSerialPort serialPort;
-
     bool isConn;
+    std::function<void(ChipId)> readChipIdCb;
 
     int sendCmd(Cmd *cmd, size_t size);
+    void sendCmdCb(int status);
     int readRespHead(RespHeader *respHead);
     int readRespBadBlockAddress(RespBadBlock *badBlock);
+    void readRespChipIdCb(int status);
     int handleStatus(RespHeader *respHead);
     int handleWrongResp(uint8_t code);
-    int handleRespChipId(RespId *respId, ChipId *id);
 public:
+    QByteArray readData;
+    QByteArray writeData;
+    SerialPortWriter *serialPortWriter;
+    SerialPortReader *serialPortReader;
+
     explicit Programmer(QObject *parent = 0);
     ~Programmer();
     int connect();
     void disconnect();
     bool isConnected();
-    int readChipId(ChipId *id);
+    void readChipId(std::function<void(ChipId)> callback);
     int eraseChip(uint32_t addr, uint32_t len);
     int readChip(uint8_t *buf, uint32_t addr, uint32_t len);
     int writeChip(uint8_t *buf, uint32_t addr, uint32_t len);

qt/qt.pro

@@ -20,11 +20,15 @@ TEMPLATE = app
 SOURCES += main.cpp\
         main_window.cpp \
     programmer.cpp \
-    chip_db.cpp
+    chip_db.cpp \
+    serial_port_writer.cpp \
+    serial_port_reader.cpp
 
 HEADERS  += main_window.h \
     programmer.h \
-    chip_db.h
+    chip_db.h \
+    serial_port_writer.h \
+    serial_port_reader.h
 
 FORMS    += main_window.ui
 

qt/serial_port_reader.cpp

@@ -0,0 +1,76 @@
+/*  Copyright (C) 2017 Bogdan Bogush <[email protected]>
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 3.
+ */
+
+#include "serial_port_reader.h"
+#include <QDebug>
+#include <QString>
+
+#define READ_TIMEOUT_MS 100
+
+SerialPortReader::SerialPortReader(QSerialPort *serialPort, QObject *parent):
+    QObject(parent), serialPort(serialPort)
+{
+    timer.setSingleShot(true);
+}
+
+void SerialPortReader::signalConnect()
+{
+    connect(serialPort, SIGNAL(readyRead()), SLOT(handleReadyRead()));
+    connect(serialPort, SIGNAL(error(QSerialPort::SerialPortError)),
+        SLOT(handleError(QSerialPort::SerialPortError)));
+    connect(&timer, SIGNAL(timeout()), SLOT(handleTimeout()));
+}
+
+void SerialPortReader::signalDisconnect()
+{
+    disconnect(serialPort, SIGNAL(readyRead()), this, SLOT(handleReadyRead()));
+    disconnect(serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this,
+        SLOT(handleError(QSerialPort::SerialPortError)));
+    disconnect(&timer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
+}
+
+void SerialPortReader::read(std::function<void(int)> callback,
+    QByteArray *data)
+{
+    signalConnect();
+    readData = data;
+    this->callback = callback;
+    timer.start(READ_TIMEOUT_MS);
+}
+
+void SerialPortReader::readEnd(int status)
+{
+    callback(status);
+    signalDisconnect();
+    timer.stop();
+}
+
+void SerialPortReader::handleReadyRead()
+{
+    readData->append(serialPort->readAll());
+    timer.start(READ_TIMEOUT_MS);
+}
+
+void SerialPortReader::handleTimeout()
+{
+    if (readData->isEmpty())
+    {
+        qCritical() << QString("Timeout to read data from port %1\n")
+            .arg(serialPort->portName());
+        readEnd(READ_ERROR);
+        return;
+    }
+
+    readEnd(READ_OK);
+}
+
+void SerialPortReader::handleError(QSerialPort::SerialPortError /* error */)
+{
+    qCritical() << QString("Failed to read data from port %1, error: %2\n")
+        .arg(serialPort->portName()).arg(serialPort->errorString());
+
+    readEnd(READ_ERROR);
+}
+

qt/serial_port_reader.h

@@ -0,0 +1,46 @@
+/*  Copyright (C) 2017 Bogdan Bogush <[email protected]>
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 3.
+ */
+
+#ifndef SERIALPORTREADER_H
+#define SERIALPORTREADER_H
+
+#include <QtSerialPort/QSerialPort>
+#include <QTimer>
+#include <QByteArray>
+#include <QObject>
+#include <functional>
+
+class SerialPortReader: public QObject
+{
+    Q_OBJECT
+
+    QSerialPort *serialPort;
+    QByteArray *readData;
+    QTimer timer;
+    std::function<void(int)> callback;
+
+    void signalConnect();
+    void signalDisconnect();
+    void readEnd(int status);
+
+public:
+    enum
+    {
+        READ_ERROR = -1,
+        READ_OK = 0
+    };
+
+    explicit SerialPortReader(QSerialPort *serialPort,
+        QObject *parent = 0);
+
+    void read(std::function<void(int)> callback, QByteArray *data);
+
+public slots:
+    void handleReadyRead();
+    void handleTimeout();
+    void handleError(QSerialPort::SerialPortError error);
+};
+
+#endif // SERIALPORTREADER_H