串口demo2.0

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QSerialPort>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLineEdit>
#include <QDebug>
#include <QByteArray>
#include <QThread>
#include <QVector>
#include <array>
#include <QComboBox>
#include <QSerialPortInfo>
#include <QTextEdit>
#include <QLabel>
#include "packagebuild.h"
#include <QCheckBox>
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void creatGUI();
    void setPortName(QString name);
    void connectDevice(QString name,const int rate);
    void receiveInfo();
    void sandpack(QByteArray byteArray);
    QByteArray writeCommandByteArray(PackageBuild::Command cmd, const QByteArray &data) const;
    void setCollectionChannelSwitch(QString list);
    QString hexToString(char *in, int len);
    void setStimChannelSwitch(QString list);
    uint8_t stringToUint8(std::string string);
    void setPowerSwitch(bool on);
    void writeStimCurrentSize(int stimInde, float currentSize);
private:
    Ui::Widget *ui;
    uint8_t kZero = 0x00;
    QSerialPort *m_serialport =nullptr;
    QList<QSerialPortInfo> serialPortList;
    QComboBox *portNameBox;
    QLabel *connectTip;
    QTextEdit *sendTip;
    QTextEdit *reriviceTip;
    PackageBuild m_packageBuild;
};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    this->setFixedSize(1000,700);
    m_serialport = new QSerialPort();
    serialPortList = QSerialPortInfo::availablePorts();
    creatGUI();
}

Widget::~Widget()
{
    delete ui;
}

void Widget::creatGUI()
{
    QHBoxLayout *all = new QHBoxLayout();
    QVBoxLayout *left = new QVBoxLayout();
    QHBoxLayout *right = new QHBoxLayout();

    QHBoxLayout *first = new QHBoxLayout();
    QPushButton *portNameBtn = new QPushButton();
    portNameBtn->setFixedSize(100,30);
    portNameBtn->setText(tr("连接"));

    portNameBox =new QComboBox();
    portNameBox->setFixedSize(100,30);
    portNameBox->setStyleSheet("QAbstractItemView::item {height: 30px;font-size:20px}");

    for(int i=0;i < serialPortList.size();i++){
        portNameBox->addItem(serialPortList[i].portName());
    }
    portNameBox->addItem("no port");

    connectTip = new QLabel();
    connectTip->setFixedSize(100,30);
    QLineEdit *baudRateEdit = new QLineEdit();
    baudRateEdit->setFixedSize(100,30);

    QLabel *noUse = new QLabel();
    noUse->setFixedSize(100,30);

    first->setContentsMargins(0,0,0,0);
    first->addStretch();
    first->addWidget(portNameBtn);
    first->addSpacing(5);
    first->addWidget(portNameBox);
    first->addSpacing(5);
    first->addWidget(baudRateEdit);
    first->addStretch();

    connect(portNameBtn,&QPushButton::clicked,[this,baudRateEdit](){connectDevice(portNameBox->currentText(),baudRateEdit->text().toInt());});

    QHBoxLayout *second = new QHBoxLayout();
    QPushButton *portNumBtn = new QPushButton();
    portNumBtn->setFixedSize(100,30);
    portNumBtn->setText(tr("采集通道"));

    QLineEdit *portNumEdit = new QLineEdit();
    portNumEdit->setFixedSize(100,30);
    portNumEdit->setText("1");
    connect(portNumBtn,&QPushButton::clicked,[this,portNumEdit](){setCollectionChannelSwitch(portNumEdit->text());});

    sendTip = new QTextEdit();
    sendTip->setFixedSize(450,400);

    second->setContentsMargins(0,0,0,0);
    second->addStretch();
    second->addWidget(portNumBtn);
    second->addSpacing(5);
    second->addWidget(portNumEdit);
    second->addSpacing(5);
    second->addWidget(noUse);
    second->addStretch();

    QHBoxLayout *third = new QHBoxLayout();
    QPushButton *stimBtn = new QPushButton();
    stimBtn->setFixedSize(100,30);
    stimBtn->setText(tr("刺激通道"));

    QLineEdit *stimNumEdit = new QLineEdit();
    stimNumEdit->setFixedSize(100,30);
    stimNumEdit->setText("1");
    connect(stimBtn,&QPushButton::clicked,[this,stimNumEdit](){setStimChannelSwitch(stimNumEdit->text());});

    third->setContentsMargins(0,0,0,0);
    third->addStretch();
    third->addWidget(stimBtn);
    third->addSpacing(5);
    third->addWidget(stimNumEdit);
    third->addSpacing(5);
    third->addWidget(noUse);
    third->addStretch();

    QHBoxLayout *fourth = new QHBoxLayout();
    QPushButton *powerBtn = new QPushButton();
    powerBtn->setFixedSize(100,30);
    powerBtn->setText(tr("PowerSwitch"));

    QCheckBox *powerBox = new QCheckBox();
    powerBox->setFixedSize(100,30);
    connect(powerBtn,&QPushButton::clicked,[this,powerBox](){setPowerSwitch(powerBox->isChecked());});

    fourth->setContentsMargins(0,0,0,0);
    fourth->addStretch();
    fourth->addWidget(powerBtn);
    fourth->addSpacing(5);
    fourth->addWidget(powerBox);
    fourth->addSpacing(5);
    fourth->addWidget(noUse);
    fourth->addStretch();

    QHBoxLayout *fifth = new QHBoxLayout();
    QPushButton *stimCurrentBtn = new QPushButton();
    stimCurrentBtn->setFixedSize(100,30);
    stimCurrentBtn->setText(tr("StimCurrent"));
    QLineEdit *stimIndexEdit = new QLineEdit();
    stimIndexEdit->setFixedSize(100,30);
    QLineEdit *stimCurrentEdit = new QLineEdit();
    stimCurrentEdit->setFixedSize(100,30);
    connect(powerBtn,&QPushButton::clicked,[this,stimIndexEdit,stimCurrentEdit](){writeStimCurrentSize(stimIndexEdit->text().toInt(),stimCurrentEdit->text().toFloat());});

    fifth->setContentsMargins(0,0,0,0);
    fifth->addStretch();
    fifth->addWidget(stimCurrentBtn);
    fifth->addSpacing(5);
    fifth->addWidget(stimIndexEdit);
    fifth->addSpacing(5);
    fifth->addWidget(stimCurrentEdit);
    fifth->addStretch();

    left->setContentsMargins(0,0,0,0);
    left->addSpacing(20);
    left->addLayout(first);
    left->addLayout(fourth);
    left->addLayout(second);
    left->addLayout(third);
    left->addLayout(fifth);
    left->addWidget(sendTip);
    left->addStretch();

    reriviceTip = new QTextEdit();
    reriviceTip->setFixedSize(450,600);

    right->setContentsMargins(0,0,0,0);
    right->addSpacing(20);
    right->addWidget(reriviceTip);
    right->addStretch();

    all->setContentsMargins(0,0,0,0);
    all->addSpacing(0);
    all->addLayout(left);
    all->addStretch();
    all->addLayout(right);


    this->setLayout(all);
}

void Widget::connectDevice(QString name,const int rate)
{

    m_serialport->setPortName(name);
    m_serialport->setBaudRate(rate, QSerialPort::AllDirections);
    m_serialport->setDataBits(QSerialPort::Data8);
    m_serialport->setFlowControl(QSerialPort::NoFlowControl);
    m_serialport->setParity(QSerialPort::NoParity);
    m_serialport->setStopBits(QSerialPort::OneStop);

    connect(m_serialport, &QSerialPort::readyRead, this, &Widget::receiveInfo);

    if (m_serialport) {
        if (m_serialport->isOpen()) {
            m_serialport->close();
        }
        if (!m_serialport->open(QIODevice::ReadWrite)) {
            qDebug() << m_serialport << "open serial port faill!";
            connectTip->setText("fail");
        }else{
            connectTip->setText("success");
        }
    }

}

void Widget::receiveInfo()
{
    auto data = m_serialport->readAll();

    QString string = hexToString(data.data(),data.size());
    reriviceTip->append(string);
    //qDebug() << data;
}

void Widget::sandpack(QByteArray byteArray)
{
    if(connectTip->text() == "fail"){
        sendTip->append("open serial port faill! Please connect serial port!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
        return;
    }
    QString string = hexToString(byteArray.data(),byteArray.size());
    sendTip->append(string);
    m_serialport->write(byteArray);

    QThread::msleep(200);
}
QByteArray Widget::writeCommandByteArray(PackageBuild::Command cmd, const QByteArray& data) const
{
    int dataLength = data.size();
    QByteArray databig(reinterpret_cast<char*>(&dataLength), 2);
    std::reverse(databig.begin(), databig.end());
    QByteArray byteArray;
    byteArray.append(0xEB);
    byteArray.append(0x90);
    byteArray.append(databig);
    byteArray.append(2);
    byteArray.append(cmd);
    byteArray.append(kZero);
    byteArray.append(0x33);
    byteArray.append(0x33);

    QByteArray dataFlip(data, data.size());
    std::reverse(dataFlip.begin(), dataFlip.end());

    byteArray.append(dataFlip);

    uint16_t sum = 0;
    for (size_t i = 0; i < byteArray.size(); i++) {

        sum = sum + (uint8_t)byteArray.at(i);
    }
    QByteArray checkByteArray(reinterpret_cast<char*>(&sum), 2);
    std::reverse(checkByteArray.begin(), checkByteArray.end());
    byteArray.append(checkByteArray);
    return byteArray;
}
void Widget::setCollectionChannelSwitch(QString list)
{
    QByteArray byteArray;

    switch(list.toInt()){
    case 1:{
        byteArray.append(0x01);
        break;
    }
    case 2:{
        byteArray.append(0x03);
        break;
    }
    case 3:{
        byteArray.append(0x07);
        break;
    }
    case 4:{
        byteArray.append(0x0F);
        break;
    }
    case 5:{
        byteArray.append(0x1F);
        break;
    }
    case 6:{
        byteArray.append(0x3F);
        break;
    }
    case 7:{
        byteArray.append(0x7F);
        break;
    }
    case 8:{
        byteArray.append(0xff);
        break;
    }
    };
    sandpack(writeCommandByteArray(PackageBuild::COMMAND_COLLECT_CHANNEL_SWITCH,byteArray));
}
QString Widget::hexToString(char *in, int len)
{
    int i;
    unsigned char inChar,hi,lo;
    QString s;

    for (i=0; i<len; i++)
    {
        inChar = in[i];

        hi = (inChar & 0xF0) >> 4;
        if (hi > 9)
            hi = 'A' + (hi - 0x0A);
        else
            hi += 0x30;
        s.append(hi);

        lo = inChar & 0x0F;
        if (lo > 9)
            lo = 'A' + (lo - 0x0A);
        else
            lo += 0x30;
        s.append(lo);

        s.append(0x20);
    }

    return s;
}
void Widget::setStimChannelSwitch(QString list)
{
    std::array<bool, 2> stimChannelSwitchList;
    if(list.toInt() == 1){
        stimChannelSwitchList[0] = true;
        stimChannelSwitchList[0] = false;
    }else{
        stimChannelSwitchList[0] = true;
        stimChannelSwitchList[0] = true;
    }
    std::string kChannelSwitchlist;
    for (int i = 0; i <2; i++){
        if (stimChannelSwitchList[i]) {
            kChannelSwitchlist.append(std::to_string(1));
        } else {
            kChannelSwitchlist.append(std::to_string(0));
        }
    }
    sandpack(m_packageBuild.writeStimChannelSwitch(stringToUint8(kChannelSwitchlist)));
}
uint8_t Widget::stringToUint8(std::string string)
{
    int base = 0;
    for (size_t j = 0; j < 2; j++) {
        if (j >= string.size()) {
            base = (base << 1) +0;
        } else {
            int b = string[j] - '0';
            base = (base << 1) + b;
        }
    }
    return (uint8_t)base;
}

void Widget::setPowerSwitch(bool on)
{
    sandpack(m_packageBuild.writePowerSwitch(on));
}

void Widget::writeStimCurrentSize(int stimInde, float currentSize)
{

}

#ifndef PACKAGEBUILD_H
#define PACKAGEBUILD_H

#include <QObject>

class PackageBuild
{
public:
    PackageBuild();
    enum Command {
        COMMAND_POWER_SWITCH = 0xC0,
        COMMAND_COLLECT_CHANNEL_SWITCH = 0xC1,
        COMMAND_STIM_CHANNEL_SWITCH = 0xC2,
        COMMAND_STIM_CURRENT_SIZE = 0xC3,
        COMMAND_STIM_INTERVAL = 0xC4,
        COMMAND_PULSE_WIDTH = 0xC5,
        COMMAND_COLLECT_DATA = 0xC6,
        COMMAND_IMPENDENCE_CHECK = 0xC7,
        COMMAND_HEARTBEAT_CONTENT = 0xC8,
        COMMAND_RESTART_OR_UPGRADE = 0xA0,
        COMMAND_SET_SELF_TEST = 0xA3,
        COMMANDM_IMPEDANCE_CALIBRATION = 0xA7,
        COMMAND_READ_FRONT_SERIAL_NUMBER = 0xA9
    };
    QByteArray writePowerSwitch(bool on) const;
    QByteArray readPowerSwitch() const;

    QByteArray writeCollectionChannelSwitch(uint8_t data) const;
    QByteArray readCollectionChannelSwitch() const;

    QByteArray writeStimChannelSwitch(uint8_t data) const;
    QByteArray readStimChannelSwitch() const;

    QByteArray writeStimCurrentSize(int stimInde,float currentSize) const;
    QByteArray readStimCurrentSize() const;

    QByteArray writeStimIntervalSize(int stimIndex, std::chrono::milliseconds interval) const;
    QByteArray readStimIntervalSize() const;

    QByteArray writePulseWidth(int stimIndex, int pulseWidth) const;
    QByteArray readPulseWidth() const;

    QByteArray writeImpedanceDetectionEnable(bool on) const;
    QByteArray readImpedanceDetectionEnable() const;

    static QByteArray generateChecksum(const QByteArray& bytes, int size, int start = 0);

private:
    QByteArray writeCommandByteArray(Command cmd, const QByteArray& data) const;
    QByteArray readCommandByteArray(Command cmd, const QByteArray& data) const;
    uint8_t kZero = 0x00;
    const static int kFrameSize = 10;
};

#endif // PACKAGEBUILD_H

#include "packagebuild.h"

PackageBuild::PackageBuild()
{

}
QByteArray PackageBuild::writePowerSwitch(bool on) const
{
    uint8_t data = on ? 0x01 : 0x00;
    QByteArray byteArray;
    byteArray.append(data);
    return writeCommandByteArray(COMMAND_POWER_SWITCH, byteArray);
}

QByteArray PackageBuild::readPowerSwitch() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_POWER_SWITCH, byteArray);
}

QByteArray PackageBuild::writeCollectionChannelSwitch(uint8_t data) const
{
    QByteArray byteArray;
    byteArray.append(data);
    return writeCommandByteArray(COMMAND_COLLECT_CHANNEL_SWITCH, byteArray);
}

QByteArray PackageBuild::readCollectionChannelSwitch() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_COLLECT_CHANNEL_SWITCH, byteArray);
}

QByteArray PackageBuild::  writeStimChannelSwitch(uint8_t data) const
{
    QByteArray byteArray;
    byteArray.append(data);
    return writeCommandByteArray(COMMAND_STIM_CHANNEL_SWITCH, byteArray);
}

QByteArray PackageBuild::readStimChannelSwitch() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_STIM_CHANNEL_SWITCH, byteArray);
}

QByteArray PackageBuild::writeStimCurrentSize(int stimInde, float currentSize) const
{
    QByteArray byteArray;
    byteArray.append(stimInde);
    int current = currentSize;
    byteArray.append(reinterpret_cast<char*>(&current), 2);
    return writeCommandByteArray(COMMAND_STIM_CURRENT_SIZE, byteArray);
}

QByteArray PackageBuild::readStimCurrentSize() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_STIM_CURRENT_SIZE, byteArray);
}

QByteArray PackageBuild::writeStimIntervalSize(int stimIndex, std::chrono::milliseconds interval) const
{
    unsigned int kInterval = interval.count();
    QByteArray byteArray;
    byteArray.append(stimIndex);
    byteArray.append(reinterpret_cast<char*>(&kInterval), 2);
    return writeCommandByteArray(COMMAND_STIM_INTERVAL, byteArray);
}

QByteArray PackageBuild::readStimIntervalSize() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_STIM_INTERVAL, byteArray);
}

QByteArray PackageBuild::writePulseWidth(int stimIndex, int pulseWidth) const
{
    QByteArray byteArray;
    byteArray.append(stimIndex);
    byteArray.append(reinterpret_cast<char*>(&pulseWidth), 2);
    return writeCommandByteArray(COMMAND_PULSE_WIDTH, byteArray);
}

QByteArray PackageBuild::readPulseWidth() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_PULSE_WIDTH, byteArray);
}

QByteArray PackageBuild::writeImpedanceDetectionEnable(bool on) const
{
    uint8_t data = on ? 0x01 : 0x00;
    QByteArray byteArray;
    byteArray.append(data);
    return writeCommandByteArray(COMMAND_IMPENDENCE_CHECK, byteArray);
}

QByteArray PackageBuild::readImpedanceDetectionEnable() const
{
    QByteArray byteArray;
    byteArray.append(kZero);
    return readCommandByteArray(COMMAND_IMPENDENCE_CHECK, byteArray);
}

QByteArray PackageBuild::generateChecksum(const QByteArray& bytes, int size, int start)
{
    uint16_t sum = 0;
    QByteArray validByte = bytes.mid(start, size);
    for (size_t i = 0; i < validByte.size();i++) {
        sum = sum + (uint8_t)validByte.at(i);
    }
    QByteArray checkByteArray(reinterpret_cast<char*>(&sum), 2);
    std::reverse(checkByteArray.begin(), checkByteArray.end());
    return checkByteArray;
}

QByteArray PackageBuild::writeCommandByteArray(Command cmd, const QByteArray& data) const
{
    int dataLength = data.size();
    QByteArray databig(reinterpret_cast<char*>(&dataLength), 2);
    std::reverse(databig.begin(), databig.end());
    QByteArray byteArray;
    byteArray.append(0xEB);
    byteArray.append(0x90);
    byteArray.append(databig);
    byteArray.append(2);
    byteArray.append(cmd);
    byteArray.append(kZero);
    byteArray.append(0x33);
    byteArray.append(0x33);

    QByteArray dataFlip(data, data.size());
    std::reverse(dataFlip.begin(), dataFlip.end());

    byteArray.append(dataFlip);

    uint16_t sum = 0;
    for (size_t i = 0; i < byteArray.size(); i++) {

        sum = sum + (uint8_t)byteArray.at(i);
    }
    QByteArray checkByteArray(reinterpret_cast<char*>(&sum), 2);
    std::reverse(checkByteArray.begin(), checkByteArray.end());
    byteArray.append(checkByteArray);
    return byteArray;
}

QByteArray PackageBuild::readCommandByteArray(Command cmd, const QByteArray& data) const
{
    int dataLength = data.size();

    QByteArray databig;
    databig.append(reinterpret_cast<char*>(&dataLength), 2);
    std::reverse(databig.begin(), databig.end());
    QByteArray byteArray;
    byteArray.append(0xEB);
    byteArray.append(0x90);
    byteArray.append(databig);
    byteArray.append(1);
    byteArray.append(cmd);
    byteArray.append(kZero);
    byteArray.append(0x33);
    byteArray.append(0x33);

    QByteArray dataFlip(data, data.size());
    std::reverse(dataFlip.begin(), dataFlip.end());

    byteArray.append(dataFlip);

    uint16_t sum = 0;
    for (size_t i = 0; i < byteArray.size(); i++) {
        sum = sum + byteArray.at(i);
    }
    QByteArray checkByteArray(reinterpret_cast<char*>(&sum), 2);
    std::reverse(checkByteArray.begin(), checkByteArray.end());
    byteArray.append(checkByteArray);
    return byteArray;
}