IntegratedTestBench/src/serialport.cpp

#include "serialport.h"
#include  <QtDebug>
#include <QSignalSpy>

SerialPort::SerialPort(QObject *parent) : QObject(parent)
{
    //m_serial = new QSerialPort;

    //connect(this,&SerialUi::sendConnect,mSerialPort,&SerialPort::receiveConnect);

    //  connect(this,&SerialPort::sendOk,this,&SerialPort::recieveData);
    // connect(m_serial,&QSerialPort::readyRead,this,&SerialPort::recieveData);

}
void SerialPort::receiveInit()
{
    m_serial = new QSerialPort;
}

void SerialPort::recieveData()
{
    //    qDebug()<<"recieveData";
    //    QByteArray responseData = m_serial->readAll();
    //    qDebug()<<responseData;
    //    emit sendReceiveData(responseData);

    //    //read response
    //    if (m_serial->waitForReadyRead(3000)) {
    //        qDebug()<<"have data";
    //        QByteArray responseData = m_serial->readAll();
    //        while (m_serial->waitForReadyRead(100))
    //            responseData += m_serial->readAll();
    //        qDebug()<<responseData;
    //        emit sendReceiveData(responseData);
    //    }

    //    else{
    //        qDebug()<<"timeout";
    //    }

}

void SerialPort::crcCheck(uint8_t *data, int length, uint8_t *crc_h, uint8_t *crc_l)
{
    int j;
    uint16_t reg_crc=0xFFFF;

    while(length--)
    {
        reg_crc ^= *data++;
        for(j=0;j<8;j++)
        {
            if(reg_crc & 0x01) /* LSB(b0)=1 */
                reg_crc=(reg_crc>>1) ^ 0xA001;
            else
                reg_crc=reg_crc >>1;
        }
    }
    *crc_h = (reg_crc>>8)&0x00ff;
    *crc_l = reg_crc&0x00ff;
}



SerialPort::~SerialPort()
{
    if(m_serial->isOpen())
    {
        m_serial->clear();
        m_serial->close();
    }
    m_serial->deleteLater();
}

bool SerialPort::serialConnect(QString port, QString baudrate, QString databits, QString parity, QString stopbits)
{
    m_serial->setPortName(port);
    if(!m_serial->open(QIODevice::ReadWrite))
    {
        qDebug()<<"Open" +port+" Error";
        return false;
    }

    switch (baudrate.toInt()) {
    case 4800:
        m_serial->setBaudRate(QSerialPort::Baud4800);
        break;
    case 9600:
        m_serial->setBaudRate(QSerialPort::Baud9600);
        break;
    case 115200:
        m_serial->setBaudRate(QSerialPort::Baud115200);
        break;
    default:
        qDebug("BaudRate Error");
        return false;
    }

    switch (databits.toInt()) {
    case 6:
        m_serial->setDataBits(QSerialPort::Data6);
        break;
    case 7:
        m_serial->setDataBits(QSerialPort::Data7);
        break;
    case 8:
        m_serial->setDataBits(QSerialPort::Data8);
        break;
    default:
        qDebug("DataBits Error");
        return 0;
    }
    //model: ["NONE","ODD","EVEN"]  0  1  2
    switch (parity.toInt()) {
    case 0:
        m_serial->setParity(QSerialPort::NoParity); //Check digit is set to 0
        qDebug("parity = NONE");
        break;
    case 2:
        m_serial->setParity(QSerialPort::EvenParity);
        qDebug("parity = EVEN");
        break;
    case 1:
        m_serial->setParity(QSerialPort::OddParity);
        qDebug("parity = ODD");
        break;
    default:
        qDebug("Parity Error");
        return 0;
    }

    switch (stopbits.toInt()) {
    case 1:
        m_serial->setStopBits(QSerialPort::OneStop); //Stop bit is set to 1
        break;
    case 2:
        m_serial->setStopBits(QSerialPort::TwoStop);
        break;
    case 3:
        m_serial->setStopBits(QSerialPort::OneAndHalfStop);
        break;
    default:
        printf("StopBits Error");
        return 0;
    }

    m_serial->setFlowControl(QSerialPort::NoFlowControl);//Set to no flow control

    return  true;
}

void SerialPort::closeConnect()
{
    if(m_serial->isOpen())
    {
        m_serial->clear();
        m_serial->close();
    }
    // m_serial->deleteLater();
}


bool SerialPort::serialWriteReponse(QString sendStr)
{

//    if(m_serial->isOpen() == false)
//        return false;

//    QByteArray responseData;
//    responseData.clear();

//    m_serial->readAll(); //clear buffer

//    QStringList strList = sendStr.split(" ");
//    strList.removeAll("");

//    if(strList.length() == 0)
//        return 0;

//    char *sendData  = (char *) malloc(128);

//    int cnt=0;
//    QStringListIterator strIterator(strList);
//    while (strIterator.hasNext()){
//        QString str = strIterator.next();
//        char value = str.toInt(nullptr, 16);
//        sendData[cnt++] = value;
//    }
//    uint8_t crc_h;
//    uint8_t crc_l;
//    crcCheck((uint8_t *)sendData, cnt, &crc_h, &crc_l);
//    sendData[cnt++] = crc_l;
//    sendData[cnt++] = crc_h;

//    m_serial->write(sendData,cnt);

//    QSignalSpy spy(m_serial, SIGNAL(readyRead()));
//    bool ret = spy.wait(500);
//    if(ret == true){
//        QByteArray responseData = m_serial->readAll();
//        while (spy.wait(10) == true){
//            responseData += m_serial->readAll();
//        }

//        if(responseData.length() > 2){
//            for(int i=0 ;i<responseData.length(); i++){
//                uint8_t value = responseData.at(i);
//                sendData[i] = value;
//            }
//            crcCheck((uint8_t *)sendData, responseData.length(), &crc_h, &crc_l);
//            if(crc_h !=0 || crc_l !=0  ){
//                qDebug()<<"crc  error";
//            }
//            else{
//                emit sendReceiveData(responseData);
//            }
//        }

//       // emit sendReceiveData(responseData);
//    }
//    else{
//        qDebug()<<"time out";
//    }

//    free(sendData);
    return 1;

}

QList<int> SerialPort::serialRead()
{
    return mData;
}

bool SerialPort::getOpenStatus()
{
    return m_serial->isOpen();
}

bool SerialPort::serialWrite(QString sendStr)
{

    m_serial->write(sendStr.toLatin1().data(),strlen(sendStr.toLatin1().data()));
    return 1;
}



void SerialPort::receiveConnect(QString port, QString baudrate, QString databits, QString parity, QString stopbits)
{
    bool  status =  serialConnect( port,  baudrate,  databits,  parity,  stopbits);
    emit sendPortStatus(status);
}

void SerialPort::receiveOnlyWrite(QString sendStr)
{
    //延时用 没其他意义 把队列内容 依次发出
    QSignalSpy spy(m_serial, SIGNAL(readChannelFinished()));
    spy.wait(300);
    if(m_serial->isOpen() == false){
        return  ;
    }

    qDebug()<<sendStr;
    QStringList strList = sendStr.split(" ");
    strList.removeAll("");
    char sendData[128];
    int cnt=0;
    QStringListIterator strIterator(strList);
    while (strIterator.hasNext()){
        QString str = strIterator.next();
        char value = str.toInt(nullptr, 16);
        sendData[cnt++] = value;
    }
    uint8_t crc_h;
    uint8_t crc_l;
    crcCheck((uint8_t *)sendData, cnt, &crc_h, &crc_l);
    sendData[cnt++] = crc_l;
    sendData[cnt++] = crc_h;

    int retryCnt=0;
 retry:
     m_serial->readAll();
     m_serial->write(sendData,cnt);
     m_serial->waitForBytesWritten(1000);

     QSignalSpy spy1(m_serial, SIGNAL(readyRead()));
     bool ret = spy1.wait(300);
     if(ret == true){
            qDebug()<<"get response";
            QByteArray responseData = m_serial->readAll();
            qDebug()<<responseData;
     }
     else{
         qDebug()<<"get timeout";
         QByteArray responseData = m_serial->readAll();
         qDebug()<<responseData;
         retryCnt++;
         if(retryCnt > 2)
             return;
         goto retry;
     }

}
void SerialPort::receiveWrite(QString sendStr)
{

   // qDebug() << QThread::currentThreadId() << "SerialPort";
   // QList<int> data;

    // qDebug()<<m_serial->portName()<<":";
    // qDebug()<<sendStr;

    mData.clear();
    QByteArray responseData;
    responseData.clear();

    if(m_serial->isOpen() == false){
        sendReceiveData();
        return  ;
    }


    QByteArray response = m_serial->readAll(); //clear buffer
    if(response.length() > 0){
        qDebug()<< "may be lost data";
    }

    QStringList strList = sendStr.split(" ");
    strList.removeAll("");

    if(strList.length() == 0){
        return ;
    }


    char sendData[128];
    char receivedData[128];

    int cnt=0;
    QStringListIterator strIterator(strList);
    while (strIterator.hasNext()){
        QString str = strIterator.next();
        char value = str.toInt(nullptr, 16);
        sendData[cnt++] = value;
    }

    uint8_t crc_h;
    uint8_t crc_l;
    crcCheck((uint8_t *)sendData, cnt, &crc_h, &crc_l);
    sendData[cnt++] = crc_l;
    sendData[cnt++] = crc_h;

    m_serial->write(sendData,cnt);
    m_serial->waitForBytesWritten(200);

    // QByteArray tx_buf;
    // tx_buf.append(sendData, cnt);
    // qDebug() << "receiveWrite tx_buf: " << tx_buf.toHex();

    QSignalSpy spy(m_serial, SIGNAL(readyRead()));
    bool ret = spy.wait(600);
    if(ret == true){
        QByteArray responseData = m_serial->readAll();
        while (spy.wait(30) == true){
            responseData += m_serial->readAll();
        }
        //qDebug() << "receiveWrite rxbuf: " << responseData.toHex();
        if(responseData.length() > 2){
            for(int i=0 ;i<responseData.length(); i++){
                uint8_t value = responseData.at(i);
                receivedData[i] = value;
                mData.append(value);
            }
            crcCheck((uint8_t *)receivedData, responseData.length(), &crc_h, &crc_l);

            if(crc_h !=0 || crc_l !=0  ){
                mData.clear();
                qDebug()<<"modbus crc error";
                emit sendCrcError();
            }
        }
    }
    else{
        qDebug()<<"modbus time out";
        emit sendTimeout();
    }

    sendReceiveData();

}

void SerialPort::reveiveClose()
{
    closeConnect();
}