hexfilereader.cpp

#include "hexfilereader.h"

#include <QDebug>
#include <QThread>

HexFileReader::HexFileReader(QObject *parent) : QObject(parent)
{
    QThread *thread = new QThread();
    this->moveToThread(thread);
    thread->start();

//    auto a = 0b10101010;
//    auto b = 0b11111111;

//    qDebug() << "binary";
//    qDebug() << "binary:" << QString::number(a ^ b, 2);
}

int HexFileReader::burnProgram(QString comName, QString fileName)
{
    int ret = -1;

    // 解析文件
    ret = readFile(fileName);
    if(ret != 0)
    {
        return -1;
    }

    // 打开串口
    QSerialPort serialPort;
    serialPort.setPortName(comName);
    serialPort.setBaudRate(115200);
    serialPort.setDataBits(QSerialPort::Data8);
    serialPort.setParity(QSerialPort::EvenParity);
    serialPort.setStopBits(QSerialPort::OneStop);
    if(serialPort.open(QSerialPort::ReadWrite) == false)
    {
        return -2;
    }

    // 进入isp模式
    enterBootLoader(&serialPort);

    QThread::msleep(100);

    // 发送一个起始位
    uchar data[2] = {0x7f};
    serialPort.write((char*)data, 1);

    // 然后stm32返回ACK(0x79),并进入等待命令模式
    serialPort.waitForReadyRead();
    QByteArray response = serialPort.readAll();
    qDebug() << "response:" << response.toHex();
    if(((uchar)response[0]) == NACK)
    {
        return -3;
    }

    // 此时，单片机已经进入等待命令状态了

    // 擦除
    eraseAll(&serialPort);

    // 将数据一点一点写给单片机（当然，也可以先汇总小于等于256字节的数据，再写入）
    for(int i = 0; i < mDataList.length(); i++)
    {
        DataFrame df = mDataList[i];

        int ret = writeData(&serialPort, df.addr, df.data);
        qDebug() << "burn data:" << QString::number(df.addr, 16) << ret;
        if(ret != 0)
        {
            return -4;
        }

        emit progressChanged(mDataList.length(), i + 1);
    }

    QThread::msleep(1000);

    // 进入正常模式
    qDebug() << "进入正常模式";
    enterFlash(&serialPort);

    return 0;
}

int HexFileReader::readFile(QString filePath)
{
    qDebug() << filePath;

    mDataList.clear();

    QFile file(filePath);
    if(file.open(QFile::ReadOnly))
    {
        quint16 addrBase = 0x0000;

        while (file.atEnd() == false) {
            QString str = file.readLine().trimmed();

            if(str == "")
            {
                continue;
            }

            DataFrame df;
            int ret = decodeData(str, df);
            if(ret != 0)
            {
                return ret;
            }
            if(df.type == 4) // 地址变更
            {
                addrBase = hexToUInt(df.data) & 0xffff;
                continue;
            }
            if(df.type == 5) // 地址变更
            {
                addrBase = df.addr;
                // 据说这个不用写  https://blog.csdn.net/weixin_44057803/article/details/128729894
                continue;
            }
            else if(df.type == 0)
            {
                df.addr += (((addrBase << 16) & 0xffffffff));
            }
            else if(df.type == 1) // 到达末尾
            {
                continue;
            }

//            qDebug() << "data:" << df.type << QString::number(df.addr, 16);

            mDataList.push_back(df);
        }
    }

    return 0;
}

int HexFileReader::writeData(QSerialPort *port, quint32 addr, QByteArray data)
{
    // write memory 命令
    uchar header[] = {0x31, 0xce};
    port->write((char*)header, 2);

//    port->waitForBytesWritten();
    // 等待单片机返回 ACK(0x79) 或者 NACK(0x1F)
    port->waitForReadyRead();
    QByteArray ret = port->readAll();
    if(((uchar)ret[0]) == NACK)
    {
        return -1;
    }

    // 发送地址，从高位到低位
    uchar addrArray[] = {(uchar)((addr >> 24) & 0xff),
                         (uchar)((addr >> 16) & 0xff),
                         (uchar)((addr >> 8)  & 0xff),
                         (uchar)((addr >> 0)  & 0xff)
                        };

    QByteArray cmd((char*)addrArray, 4);
    uchar checkSum = getXorSum(cmd);
    cmd.append(checkSum);

    port->write(cmd);

    // 等待单片机返回 ACK(0x79) 或者 NACK(0x1F)
    port->waitForReadyRead();
    ret = port->readAll();
    if(((uchar)ret[0]) == NACK)
    {
        return -2;
    }

    // 发送数据
    cmd.clear();
    cmd.append(data.length() - 1); // 数据长度
    cmd.append(data); // 数据本身

    checkSum = getXorSum(cmd);
    cmd.append(checkSum);

//    qDebug() << "cmd:" << cmd.toHex();
    port->write(cmd);

    // 等待单片机返回 ACK(0x79) 或者 NACK(0x1F)
    port->waitForReadyRead();
    ret = port->readAll();
    if(((uchar)ret[0]) == NACK)
    {
        return -3;
    }

    return 0;
}

int HexFileReader::eraseAll(QSerialPort *port)
{
    // erase memory 命令
    uchar header[] = {0x43, 0xbc};
    port->write((char*)header, 2);

    // 等待单片机返回 ACK(0x79) 或者 NACK(0x1F)
    port->waitForReadyRead();
    QByteArray ret = port->readAll();
    if(((uchar)ret[0]) == NACK)
    {
        return -1;
    }

    uchar data[] = {0xff, 0x00};
    port->write((char*)data, 2);

    // 等待单片机返回 ACK(0x79) 或者 NACK(0x1F)
    port->waitForReadyRead();
    ret = port->readAll();
    if(((uchar)ret[0]) == NACK)
    {
        return -2;
    }

    return 0;
}

//进入ISP模式
void HexFileReader::enterBootLoader(QSerialPort *port)
{
    //boot0 为1
    //NRST  为0 进入复位
    port->setRequestToSend(true);
    port->setDataTerminalReady(false);

    QThread::msleep(100);

    //boot0 为1
    //NRST  为1 从复位中恢复，并且进入ISP模式
    port->setDataTerminalReady(true);
}

//进入正常模式
void HexFileReader::enterFlash(QSerialPort *port)
{
    //boot0 为1 主要目的是电路上的导通
    //NRST  为0 进入复位
    port->setRequestToSend(true);
    port->setDataTerminalReady(false);

    //boot0 为0; 由于电路上的设计 ，此时实际上除了boot0发生改变之外，NRST也发生了变化
    port->setRequestToSend(false);
//    //NRST 为1 取消复位；此时这个可要可不要
    //    mPort->setDataTerminalReady(true);
}

QList<DataFrame> &HexFileReader::dataList()
{
    return mDataList;
}

quint16 HexFileReader::hexToUInt(QByteArray data)
{
    return (uchar)data[0] << 8 | (uchar)data[1];
}

quint8 HexFileReader::getCheckSum(QByteArray data)
{
    quint8 sum = data[0];

    for(int i = 1; i < data.length(); i++)
    {
        sum += data[i];
    }

    sum = 0x100 - sum;

    return sum;
}

quint8 HexFileReader::getXorSum(QByteArray data)
{
    uchar checkSum = 0x00; //0跟任何数字异或结果是任何数字本身
    for(int i = 0; i < data.length(); i++)
    {
        checkSum ^= data[i];
    }

    return checkSum;
}

int HexFileReader::decodeData(QString dataStr, DataFrame &df)
{
    //先进行字符转16进制
    dataStr = dataStr.replace(":", "");

    auto hexData = QByteArray::fromHex(dataStr.toLatin1());
//    qDebug() << hexData;

    df.length = hexData[0];
    if(hexData.length() != df.length + 5)
    {
        return -1; // 数据长度不对
    }

    df.addr     = hexToUInt(hexData.mid(1, 2));
    df.type     = hexData[3];
    df.data     = hexData.mid(4, df.length);
    df.checkSum = hexData[hexData.length() - 1];

    // 计算校验值是否匹配
    if(df.checkSum != getCheckSum(hexData.left(hexData.length() - 1)))
    {
        return -2;
    }

//    qDebug() << df.length << df.addr << df.checkSum << getCheckSum(hexData.left(hexData.length() - 1));

    return 0;
}