11/25

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/selectcomport.cpp

@@ -0,0 +1,92 @@
+#include "selectcomport.h"
+
+selectComPort::selectComPort(QObject *parent,int iDiBaudRate,int iMNBaudRate) : QThread(parent)
+{
+    this->diBaudRate=iDiBaudRate;
+    this->mnBaudRate=iMNBaudRate;
+    this->isFinish=false;
+}
+
+selectComPort::selectComPort(int iDiBaudRate, int iMNBaudRate) :QThread()
+{
+    this->diBaudRate=iDiBaudRate;
+    this->mnBaudRate=iMNBaudRate;
+    this->isFinish=false;
+}
+void selectComPort::run()
+{
+    QList<QString> comList=SerialEquipment::getAllPorts();
+    QString strComDi;
+    QString strComMN;
+    for (int i=0;i<comList.length();i++) {
+        qDebug()<<comList.at(i);
+        XYCKDigitalBoard testDI(comList.at(i),static_cast<QSerialPort::BaudRate>(this->diBaudRate));
+        if(testDI.connectPort()){
+            //testDI.startTest();
+            int j=10;
+            while(j>0){
+                testDI.startTest();
+                if(testDI.getTestConnectSuccess()){
+                    strComDi=comList.at(i);
+                    QThread::msleep(500);
+                    testDI.reqPowOn(ModeState::ModeOut);
+                    QThread::msleep(500);
+                    testDI.reqPowOn(ModeState::ModeIn);
+                    QThread::msleep(500);
+                    break;
+                }
+                else{
+                    QThread::msleep(10);
+                }
+                j--;
+            }
+            testDI.closePort();
+            if(!strComDi.isEmpty()){
+                break;
+            }
+        }
+    }
+    for (int i=0;i<comList.count();i++) {
+        if(comList.at(i)==strComDi){
+            continue;
+        }
+        XYCKAnalogBoard testMN(comList.at(i),static_cast<QSerialPort::BaudRate>(this->mnBaudRate));
+
+        qDebug()<<comList.at(i);
+        if(testMN.connectPort()){
+            //  testMN.startTest();
+            int j=10;
+            while(j>0){
+                testMN.startTest();
+                if(testMN.getTestConnectSuccess()){
+                    strComMN=comList.at(i);
+                    break;
+                }
+                else{
+                    QThread::msleep(10);
+                }
+                j--;
+            }
+            testMN.closePort();
+            if(!strComMN.isEmpty()){
+                break;
+            }
+        }
+    }
+    if(!strComDi.isEmpty()){
+        XYCKDigitalBoard testDI1(strComDi,static_cast<QSerialPort::BaudRate>(this->diBaudRate));
+        if(testDI1.connectPort()){
+            QThread::msleep(1000);
+            testDI1.reqPowOn(ModeState::ModeOut);
+            testDI1.closePort();
+        }
+    }
+    qDebug()<<"数字板："<<strComDi;
+    qDebug()<<"模拟板："<<strComMN;
+    this->diPort=strComDi;
+    this->mnPort=strComMN;
+    isFinish=true;
+    emit comPortSelected(strComDi,strComMN);
+
+
+}

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/selectcomport.h

@@ -0,0 +1,42 @@
+#ifndef SELECTCOMPORT_H
+#define SELECTCOMPORT_H
+#include <QObject>
+#include <QThread>
+#include <QString>
+#include <QList>
+#include <QDebug>
+#include "equipmentLib/XY-CK-SerialPort/xyckanalogboard.h"
+#include "equipmentLib/XY-CK-SerialPort/xyckdigitalboard.h"
+#include "XYComFunc_global.h"
+
+
+class XYCOMFUNC_EXPORT selectComPort : public QThread
+{
+    Q_OBJECT
+public:
+    selectComPort(QObject *parent = nullptr,int iDiBaudRate=115200,int iMNBaudRate=115200);
+    selectComPort(int iDiBaudRate=115200,int iMNBaudRate=115200);
+
+signals:
+
+    void comPortSelected(QString comDi,QString comMN);
+
+protected:
+    virtual void run();
+
+public:
+
+    bool isFinish;
+    QString diPort;
+    QString mnPort;
+
+public slots:
+
+private:
+    int diBaudRate;
+    int mnBaudRate;
+};
+
+
+
+#endif // SELECTCOMPORT_H

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/xyckanalogboard.cpp

@@ -0,0 +1,362 @@
+#include "xyckanalogboard.h"
+
+
+XYCKAnalogBoard::XYCKAnalogBoard()
+    : SerialEquipment()
+{
+    initCodec();
+}
+
+XYCKAnalogBoard::XYCKAnalogBoard(QString portName, QSerialPort::BaudRate baunRate, QSerialPort::DataBits dataBits, QSerialPort::Parity parity, QSerialPort::StopBits stopBits, int readBufferSize)
+    : SerialEquipment(portName,baunRate,dataBits,parity,stopBits,readBufferSize)
+{
+    initCodec();
+}
+
+XYCKAnalogBoard::XYCKAnalogBoard(QString portName)
+    : SerialEquipment(portName)
+{
+    initCodec();
+}
+
+XYCKAnalogBoard::XYCKAnalogBoard(QString portName, QSerialPort::BaudRate baunRate)
+    : SerialEquipment(portName,baunRate)
+{
+    initCodec();
+}
+
+bool XYCKAnalogBoard::reqSetting(int iChannel, AnalogSetting setting)
+{
+    return sendMsg(_codec->reqSetting(iChannel,setting));
+}
+
+bool XYCKAnalogBoard::reqChannalControl(ChannelState ch1, ChannelState ch2, ChannelState ch3, ChannelState ch4)
+{
+    return   sendMsg(_codec->reqChannalControl(ch1,ch2,ch3,ch4));
+}
+
+bool XYCKAnalogBoard::reqChannalControl(int ch1, int ch2, int ch3, int ch4)
+{
+    //qDebug()<<"reqChannalControl";
+    return   sendMsg(_codec->reqChannalControl((ChannelState)ch1,(ChannelState)ch2,(ChannelState)ch3,(ChannelState)ch4));
+}
+
+qreal XYCKAnalogBoard::getIniInfo(int Channel, QString strValueType)
+{
+    QSettings configIni("config.ini",QSettings::IniFormat);
+    return configIni.value("/"+QString::number(Channel)+"/"+strValueType).toDouble();
+}
+
+void XYCKAnalogBoard::setIniInfo(int Channel, QString strValueType, qreal rValue)
+{
+    QSettings configIni("config.ini",QSettings::IniFormat);
+    configIni.setValue("/"+QString::number(Channel)+"/"+strValueType,rValue);
+    return;
+}
+
+void XYCKAnalogBoard::clearList()
+{
+    _codec->clearList();
+}
+
+QString XYCKAnalogBoard::getCountLog()
+{
+    if(this->testJDCount==0){
+        bTestDebug=true;
+    }
+    else {
+        bTestDebug=false;
+    }
+    QString strLog="JDCount:"+QString::number(this->testJDCount)+"Total:"+QString::number(this->testTotalCount);
+    this->testJDCount=0;
+    this->testTotalCount=0;
+    return strLog;
+}
+
+
+
+bool XYCKAnalogBoard::reqSetCurrent(int iChannel, int iCurrent)
+{
+    //qDebug()<<"set MN A CHannl:"<<QString::number(iChannel)<<",A Value:"<<QString::number(iCurrent);
+    return sendMsg(_codec->reqSetCurrent(iChannel,iCurrent));
+}
+
+bool XYCKAnalogBoard::reqDataChange(int iChannel, DataMode datamode)
+{
+    return  sendMsg(_codec->reqDataChange(iChannel,datamode));
+}
+
+bool XYCKAnalogBoard::reqDataChange(int iChannel, int datamode)
+{
+    return  sendMsg(_codec->reqDataChange(iChannel,(DataMode)datamode));
+}
+
+
+bool XYCKAnalogBoard::reqSetGain(int iChannel, GainMode gainmode)
+{
+    return sendMsg(_codec->reqSetGain(iChannel,gainmode));
+}
+
+bool XYCKAnalogBoard::reqSetGain(int iChannel, int gainmode)
+{
+    return sendMsg(_codec->reqSetGain(iChannel,(GainMode)gainmode));
+}
+
+bool XYCKAnalogBoard::reqSetCollect(int iChannel, ChannelState channelstate)
+{
+    return  sendMsg(_codec->reqSetCollect(iChannel,channelstate));
+}
+
+bool XYCKAnalogBoard::reqSetCollect(int iChannel, int channelstate)
+{
+    return  sendMsg(_codec->reqSetCollect(iChannel,(ChannelState)channelstate));
+}
+
+bool XYCKAnalogBoard::reqSetStimulate(int iChannel, ChannelState channelstate)
+{
+    return  sendMsg(_codec->reqSetStimulate(iChannel,channelstate));
+}
+
+bool XYCKAnalogBoard::reqSetStimulate(int iChannel, int channelstate)
+{
+    return  sendMsg(_codec->reqSetStimulate(iChannel,(ChannelState)channelstate));
+}
+
+bool XYCKAnalogBoard::reqGetState()
+{
+    return  sendMsg(_codec->reqGetState());
+}
+
+int XYCKAnalogBoard::getInfo()
+{
+    return 11;
+}
+
+void XYCKAnalogBoard::setInfo(QString portName, int baunRate)
+{
+    this->setSerialInfo(portName,(QSerialPort::BaudRate)baunRate);
+}
+
+//void XYCKAnalogBoard::setInfo(QString portName)
+//{
+
+//    this->setSerialInfo(portName,QSerialPort::Baud1152000);
+//}
+
+
+bool XYCKAnalogBoard::connectPort()
+{
+    if(this->getPortState())
+    {
+        return true;
+    }
+    else
+    {
+        return this->openPort();
+    }
+}
+
+bool XYCKAnalogBoard::disConnectPort()
+{
+    if(this->getPortState())
+    {
+        return this->closePort();
+    }
+    else
+    {
+        return true;
+    }
+}
+
+bool XYCKAnalogBoard::getConnectState()
+{
+    return this->getPortState();
+}
+
+bool XYCKAnalogBoard::reqSetting(int iChannel, int workMode, int samplerate, qreal frequency, int pulseWidth, qreal risingtime,int breaktime,qreal fallingtime,int holdingtime)
+{
+    AnalogSetting tempSetting;
+    tempSetting.workmode=(WorkMode)workMode;
+    tempSetting.samplerate=(SampleRate)samplerate;
+    tempSetting.frequency=frequency;
+    tempSetting.pulseWidth=pulseWidth;
+    tempSetting.risingTime=risingtime;
+    tempSetting.breakTime=breaktime;
+    tempSetting.fallingTime=fallingtime;
+    tempSetting.holdingTime=holdingtime;
+    //qDebug()<<"send";
+    return reqSetting(iChannel,tempSetting);
+
+}
+
+
+
+QList<MyoelectricData> *XYCKAnalogBoard::getMyoelectricData(int iStep)
+{
+    return _codec->GetMyoelectricData(iStep);
+}
+
+QVariantList XYCKAnalogBoard::getMyoelectricDataQml(int iStep)
+{
+    QList<MyoelectricData> *list=getMyoelectricData(iStep);
+
+    QVariantList returnList;
+    if(list==nullptr)
+    {
+        return returnList;
+    }
+
+    for(int i=0;i<list->length();i++)
+    {
+        returnList.append(list->at(i).ch1);
+        returnList.append(list->at(i).ch2);
+        returnList.append(list->at(i).ch3);
+        returnList.append(list->at(i).ch4);
+    }
+    delete list;
+    list=nullptr;
+    return returnList;
+}
+
+//QList<int> XYCKAnalogBoard::GetMyoelectricDataIntArray()
+//{
+//    QList<int> array;
+//    for(int i=0;i<0;i++)
+//    {
+//        array.append(i);
+//    }
+//    return array;
+
+//}
+
+//QList<int> XYCKAnalogBoard::m_info()
+//{
+//    QList<int> array;
+//    for(int i=0;i<0;i++)
+//    {
+//        array.append(i);
+//    }
+
+//    return array;
+//}
+
+//QQmlListProperty<MyoelectricData> XYCKAnalogBoard::datalist()
+//{
+//    m_dataList.clear();
+//    MyoelectricData* test=new MyoelectricData();
+//    test->ch1=1;
+//    test->ch2=2;
+//    test->ch3=3;
+//    test->ch4=4;
+//    return QQmlListProperty<MyoelectricData>(this,m_dataList);
+//}
+
+
+
+void XYCKAnalogBoard::OnCommandSendErrorRev(int iChannel, ErrorCode errorcode, int iFunctionCode)
+{
+    emit commandSendError(iChannel,errorcode,iFunctionCode);
+}
+
+
+void XYCKAnalogBoard::OnAnalogSettingRev(int iChannel, AnalogSetting *analogsetting)
+{
+    emit analogSettingRev(iChannel,analogsetting);
+}
+
+void XYCKAnalogBoard::OnChannalControlRev(ChannelState ch1, ChannelState ch2, ChannelState ch3, ChannelState ch4)
+{
+    emit channalControlRev(ch1,ch2,ch3,ch4);
+}
+
+void XYCKAnalogBoard::OnCurrentRev(int iChannel, int iCurrent)
+{
+    emit currentRev(iChannel,iCurrent);
+}
+
+void XYCKAnalogBoard::OnDataChangeRev(int iChannel, DataMode datamode)
+{
+    emit dataChangeRev(iChannel,datamode);
+}
+
+void XYCKAnalogBoard::OnGainRev(int iChannel, GainMode gainmode)
+{
+    emit gainRev(iChannel,gainmode);
+}
+
+void XYCKAnalogBoard::OnCollectRev(int iChannel, ChannelState channelstate)
+{
+    emit collectRev(iChannel,channelstate);
+}
+
+void XYCKAnalogBoard::OnStimulateRev(int iChannel, ChannelState channelstate)
+{
+    emit stimulateRev(iChannel,channelstate);
+}
+
+void XYCKAnalogBoard::OnStateInfoRev(AnalogState *analogstate)
+{
+    //qDebug()<<"received";
+    if(this->testStart){
+        this->testConnectSuccess=true;
+    }
+    QVariantMap stateMap;
+    stateMap.insert("resetState",analogstate->resetState);
+    stateMap.insert("electrodeStateA",analogstate->electrodeStateA);
+    stateMap.insert("electrodeStateB",analogstate->electrodeStateB);
+    stateMap.insert("electrodeStateC",analogstate->electrodeStateC);
+    stateMap.insert("electrodeStateD",analogstate->electrodeStateD);
+    stateMap.insert("channelWorkStateA",analogstate->channelWorkStateA);
+    stateMap.insert("channelWorkStateB",analogstate->channelWorkStateB);
+    stateMap.insert("channelWorkStateC",analogstate->channelWorkStateC);
+    stateMap.insert("channelWorkStateD",analogstate->channelWorkStateD);
+    stateMap.insert("AValueA",analogstate->AValueA);
+    stateMap.insert("AValueB",analogstate->AValueB);
+    stateMap.insert("AValueC",analogstate->AValueC);
+    stateMap.insert("AValueD",analogstate->AValueD);
+    emit stateInfoRev(stateMap);
+}
+
+void XYCKAnalogBoard::initCodec()
+{
+    _codec=new CODECXyckAnalog();
+    connect(_codec,&CODECXyckAnalog::analogSettingRev,this,&XYCKAnalogBoard::OnAnalogSettingRev);
+    connect(_codec,&CODECXyckAnalog::channalControlRev,this,&XYCKAnalogBoard::OnChannalControlRev);
+    connect(_codec,&CODECXyckAnalog::currentRev,this,&XYCKAnalogBoard::OnCurrentRev);
+    connect(_codec,&CODECXyckAnalog::dataChangeRev,this,&XYCKAnalogBoard::OnDataChangeRev);
+    connect(_codec,&CODECXyckAnalog::gainRev,this,&XYCKAnalogBoard::OnGainRev);
+    connect(_codec,&CODECXyckAnalog::collectRev,this,&XYCKAnalogBoard::OnCollectRev);
+    connect(_codec,&CODECXyckAnalog::stimulateRev,this,&XYCKAnalogBoard::OnStimulateRev);
+    connect(_codec,&CODECXyckAnalog::stateInfoRev,this,&XYCKAnalogBoard::OnStateInfoRev);
+    connect(_codec,&CODECXyckAnalog::commandSendError,this,&XYCKAnalogBoard::OnCommandSendErrorRev);
+    this->_frameHead.clear();
+    this->_frameHead.append(static_cast<char>(0xaa));
+    this->_frameTail.clear();
+    this->_frameTail.append(0x55);
+    setLogInfo(true);
+    this->testStart=true;
+    this->testConnectSuccess=false;
+}
+
+bool XYCKAnalogBoard::getTestConnectSuccess() const
+{
+    return testConnectSuccess;
+}
+
+void XYCKAnalogBoard::startTest()
+{
+    this->testConnectSuccess=false;
+    this->testStart=true;
+    this->reqGetState();
+}
+
+void XYCKAnalogBoard::dealDate(QByteArray buffer)
+{
+    _codec->dealFrame(buffer);
+}
+
+
+
+
+
+

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/xyckanalogboard.h

@@ -0,0 +1,100 @@
+#ifndef XYCKANALOGBOARD_H
+#define XYCKANALOGBOARD_H
+
+
+#include <QObject>
+#include <QList>
+#include <QVariant>
+#include <QVariantMap>
+#include <QVariantList>
+#include <QtQml/QQmlListProperty>
+#include <QSettings>
+#include <QSerialPort>
+#include "serialequipment.h"
+#include "XYComFunc_global.h"
+#include "CODEC/codecxyckanalog.h"
+
+class XYCOMFUNC_EXPORT XYCKAnalogBoard : public SerialEquipment
+{
+    Q_OBJECT
+    //    Q_PROPERTY(QList<int> m_info READ m_info)
+    //    Q_PROPERTY(QQmlListProperty<MyoelectricData>datalist READ datalist )
+
+public:
+    explicit XYCKAnalogBoard();
+
+    explicit XYCKAnalogBoard(QString portName,QSerialPort::BaudRate baunRate,QSerialPort::DataBits dataBits,QSerialPort::Parity parity,QSerialPort::StopBits stopBits,int readBufferSize);
+
+    explicit XYCKAnalogBoard(QString portName);
+    explicit XYCKAnalogBoard(QString portName,QSerialPort::BaudRate baunRate);
+
+    bool reqSetting(int iChannel ,AnalogSetting setting);
+    Q_INVOKABLE bool reqSetting(int iChannel, int workMode, int samplerate, qreal frequency, int pulseWidth, qreal risingtime,int breaktime,qreal fallingtime,int holdingtime);
+    bool reqChannalControl(ChannelState ch1,ChannelState ch2,ChannelState ch3,ChannelState ch4);
+    Q_INVOKABLE bool reqChannalControl(int ch1,int ch2,int ch3,int ch4);
+    Q_INVOKABLE bool reqSetCurrent(int iChannel,int iCurrent);
+    bool reqDataChange(int iChannel,DataMode datamode);
+    Q_INVOKABLE bool reqDataChange(int iChannel,int datamode);
+    bool reqSetGain(int iChannel,GainMode gainmode);
+    Q_INVOKABLE bool reqSetGain(int iChannel,int gainmode);
+    bool reqSetCollect(int iChannel,ChannelState channelstate);
+    Q_INVOKABLE bool reqSetCollect(int iChannel,int channelstate);
+    bool reqSetStimulate(int iChannel,ChannelState channelstate);
+    Q_INVOKABLE bool reqSetStimulate(int iChannel,int channelstate);
+    //Q_INVOKABLE void setInfo(QString portName);
+    Q_INVOKABLE bool reqGetState();
+    int getInfo();
+    Q_INVOKABLE void setInfo(QString portName, int baunRate);
+    Q_INVOKABLE bool connectPort();
+    Q_INVOKABLE bool disConnectPort();
+    Q_INVOKABLE bool getConnectState();
+
+    QList<MyoelectricData> *getMyoelectricData(int iStep=0);
+    Q_INVOKABLE QVariantList getMyoelectricDataQml(int iStep=0);
+    Q_INVOKABLE qreal getIniInfo(int Channel,QString strValueType);
+    Q_INVOKABLE void setIniInfo(int Channel,QString strValueType,qreal rValue);
+    Q_INVOKABLE void clearList();
+    Q_INVOKABLE QString getCountLog();
+    //QList<int> GetMyoelectricDataIntArray();
+    //QList<int> m_info();
+    //QQmlListProperty<MyoelectricData> datalist();
+
+    bool getTestConnectSuccess() const;
+    void startTest();
+
+signals:
+    void commandSendError(int iChannel,ErrorCode errorcode,int iFunctionCode);
+    void analogSettingRev(int iChannel,AnalogSetting *analogsetting);
+    void channalControlRev(ChannelState ch1,ChannelState ch2,ChannelState ch3,ChannelState ch4);
+    void currentRev(int iChannel,int iCurrent);
+    void dataChangeRev(int iChannel,DataMode datamode);
+    void gainRev(int iChannel,GainMode gainmode);
+    void collectRev(int iChannel,ChannelState channelstate);
+    void stimulateRev(int iChannel,ChannelState channelstate);
+    void stateInfoRev(QVariantMap stateMap);
+
+private slots:
+    void OnCommandSendErrorRev(int iChannel,ErrorCode errorcode,int iFunctionCode);
+    void OnAnalogSettingRev(int iChannel,AnalogSetting *analogsetting);
+    void OnChannalControlRev(ChannelState ch1,ChannelState ch2,ChannelState ch3,ChannelState ch4);
+    void OnCurrentRev(int iChannel,int iCurrent);
+    void OnDataChangeRev(int iChannel,DataMode datamode);
+    void OnGainRev(int iChannel,GainMode gainmode);
+    void OnCollectRev(int iChannel,ChannelState channelstate);
+    void OnStimulateRev(int iChannel,ChannelState channelstate);
+    void OnStateInfoRev(AnalogState *analogstate);
+
+private:
+    void initCodec();
+
+
+private:
+    CODECXyckAnalog *_codec;
+    bool testConnectSuccess;
+    bool testStart;
+    QList<MyoelectricData *> m_dataList;
+protected:
+    void dealDate(QByteArray buffer) override;
+};
+
+#endif // XYCKANALOGBOARD_H

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/xyckdigitalboard.cpp

@@ -0,0 +1,216 @@
+#include "xyckdigitalboard.h"
+
+XYCKDigitalBoard::XYCKDigitalBoard()
+    : SerialEquipment()
+{
+    initCodec();
+}
+
+XYCKDigitalBoard::XYCKDigitalBoard(QString portName, QSerialPort::BaudRate baunRate, QSerialPort::DataBits dataBits, QSerialPort::Parity parity, QSerialPort::StopBits stopBits, int readBufferSize)
+    :SerialEquipment(portName,baunRate,dataBits,parity,stopBits,readBufferSize)
+{
+    initCodec();
+}
+
+XYCKDigitalBoard::XYCKDigitalBoard(QString portName)
+    :SerialEquipment(portName)
+{
+    initCodec();
+}
+
+XYCKDigitalBoard::XYCKDigitalBoard(QString portName, QSerialPort::BaudRate baunRate)
+    :SerialEquipment(portName,baunRate)
+{
+    initCodec();
+}
+
+void XYCKDigitalBoard::setInfo(QString portName)
+{
+    this->setSerialInfo(portName,QSerialPort::Baud115200);
+}
+
+void XYCKDigitalBoard::setInfo(QString portName, int baunRate)
+{
+    this->setSerialInfo(portName,(QSerialPort::BaudRate)baunRate);
+}
+
+bool XYCKDigitalBoard::reqGetInfo()
+{
+    return sendMsg(_codec->reqGetInfo());
+}
+
+bool XYCKDigitalBoard::reqControl(int iChannel, LightState lightstate)
+{
+    return  sendMsg(_codec->reqControl(iChannel,lightstate));
+}
+
+bool XYCKDigitalBoard::reqControl(int iChannel, int lightstate)
+{
+    //qDebug()<<"lightControl channel:"+QString::number(iChannel)+"---"+QString::number(lightstate);
+    return  sendMsg(_codec->reqControl(iChannel, (LightState)lightstate));
+}
+
+bool XYCKDigitalBoard::reqPreconditioning(int iChannel, ModeState modestate)
+{
+    if(iChannel<1||iChannel>4)
+    {
+        return false;
+    }
+    return  sendMsg(_codec->reqPreconditioning(iChannel,modestate));
+}
+
+bool XYCKDigitalBoard::reqPreconditioning(int iChannel, int modestate)
+{
+    if(iChannel<1||iChannel>4)
+    {
+        return false;
+    }
+    return  sendMsg(_codec->reqPreconditioning(iChannel,(ModeState)modestate));
+}
+
+bool XYCKDigitalBoard::reqUpdateA(int iChannel, int AValue)
+{
+
+    //qDebug()<<"set DI A CHannl:"<<QString::number(iChannel)<<",A Value:"<<QString::number(AValue);
+    return  sendMsg(_codec->reqUpdateA(iChannel,AValue));
+}
+
+bool XYCKDigitalBoard::reqPowOn(ModeState state)
+{
+    return  sendMsg(_codec->reqPowOn(state));
+}
+
+bool XYCKDigitalBoard::reqPowOn(int state)
+{
+    return  sendMsg(_codec->reqPowOn((ModeState)state));
+}
+
+bool XYCKDigitalBoard::resqPowoff(PowState powstate)
+{
+    return  sendMsg(_codec->resqPowoff(powstate));
+}
+
+bool XYCKDigitalBoard::resqPowoff(int powstate)
+{
+    return  sendMsg(_codec->resqPowoff((PowState)powstate));
+}
+
+bool XYCKDigitalBoard::connectPort()
+{
+    if(this->getPortState())
+    {
+        return true;
+    }
+    else
+    {
+        return this->openPort();
+    }
+}
+
+bool XYCKDigitalBoard::disConnectPort()
+{
+    if(this->getPortState())
+    {
+        return this->closePort();
+    }
+    else
+    {
+        return true;
+    }
+}
+
+bool XYCKDigitalBoard::getConnectState()
+{
+    return this->getPortState();
+}
+
+
+
+void XYCKDigitalBoard::dealDate(QByteArray buffer)
+{
+    _codec->dealFrame(buffer);
+}
+
+bool XYCKDigitalBoard::getTestConnectSuccess() const
+{
+    return testConnectSuccess;
+}
+
+void XYCKDigitalBoard::startTest()
+{
+    this->testConnectSuccess=false;
+    this->testStart=true;
+    this->reqGetInfo();
+}
+
+void XYCKDigitalBoard::initCodec()
+{
+    _codec=new CODECXyckDigital();
+    connect(_codec,&CODECXyckDigital::commandSendError,this,&XYCKDigitalBoard::OnCommandSendErrorRev);
+    connect(_codec,&CODECXyckDigital::frameError,this,&XYCKDigitalBoard::OnFrameErrorRev);
+    connect(_codec,&CODECXyckDigital::digitalInfoRev,this,&XYCKDigitalBoard::OnDigitalInfoRev);
+    connect(_codec,&CODECXyckDigital::powOffCommandRev,this,&XYCKDigitalBoard::OnPowOffCommandRev);
+    connect(_codec,&CODECXyckDigital::controlRespond,this,&XYCKDigitalBoard::OnControlRespondRev);
+    connect(_codec,&CODECXyckDigital::preconditioningRespond,this,&XYCKDigitalBoard::OnPreconditioningRespondRev);
+    connect(_codec,&CODECXyckDigital::AUpdated,this,&XYCKDigitalBoard::OnAUpdated);
+    connect(_codec,&CODECXyckDigital::PowOn,this,&XYCKDigitalBoard::OnPowOn);
+    this->_frameHead.clear();
+    this->_frameHead.append(static_cast<char>(0xaa));
+    this->_frameTail.clear();
+    this->_frameTail.append(0x55);
+    this->testStart=false;
+}
+
+void XYCKDigitalBoard::OnCommandSendErrorRev(int iChannel, ErrorCode errorcode, int iFunctionCode)
+{
+    emit commandSendError(iChannel,errorcode,iFunctionCode);
+}
+
+void XYCKDigitalBoard::OnFrameErrorRev(ErrorCode errorcode, QByteArray errBuffer)
+{
+    emit frameError(errorcode,errBuffer);
+}
+
+void XYCKDigitalBoard::OnDigitalInfoRev(DigitalInfo *di)
+{
+    if(this->testStart){
+        this->testConnectSuccess=true;
+    }
+    QVariantMap result;
+    result.insert("reset",di->reset);
+    result.insert("AChannelA",di->AChannelA);
+    result.insert("AChannelB",di->AChannelB);
+    result.insert("AChannelC",di->AChannelC);
+    result.insert("AChannelD",di->AChannelD);
+    result.insert("adapterState",di->adapterState);
+    result.insert("batteryState",di->batteryState);
+    emit digitalInfoRev(result);
+}
+
+void XYCKDigitalBoard::OnPowOffCommandRev()
+{
+    emit powOffCommandRev();
+}
+
+void XYCKDigitalBoard::OnControlRespondRev(int iChannel, LightState lightstate)
+{
+    emit controlRespond(iChannel,lightstate);
+}
+
+void XYCKDigitalBoard::OnPreconditioningRespondRev(int iChannel, ModeState modestate)
+{
+    emit preconditioningRespond(iChannel,modestate);
+}
+
+void XYCKDigitalBoard::OnAUpdated(int iChannel, int AValue)
+{
+    emit AUpdated(iChannel,AValue);
+}
+
+void XYCKDigitalBoard::OnPowOn(ModeState powOnState)
+{
+    emit PowOn(powOnState);
+}
+
+
+

ZBD_IIIDL_S_Project/DependFile/DependLib/equipmentLib/XY-CK-SerialPort/xyckdigitalboard.h

@@ -0,0 +1,152 @@
+#ifndef XYCKDIGITALBOARD_H
+#define XYCKDIGITALBOARD_H
+
+#include <QObject>
+#include <QVariantMap>
+#include "XYComFunc_global.h"
+#include "equipmentLib/serialequipment.h"
+#include "equipmentLib/CODEC/codecxyckdigital.h"
+#include "commonStruct.h"
+
+class XYCOMFUNC_EXPORT XYCKDigitalBoard :public SerialEquipment
+{
+    Q_OBJECT
+public:
+    explicit XYCKDigitalBoard();
+
+
+    explicit XYCKDigitalBoard(QString portName,QSerialPort::BaudRate baunRate,QSerialPort::DataBits dataBits,QSerialPort::Parity parity,QSerialPort::StopBits stopBits,int readBufferSize);
+
+    explicit XYCKDigitalBoard(QString portName);
+
+    explicit XYCKDigitalBoard(QString portName,QSerialPort::BaudRate baunRate);
+
+    Q_INVOKABLE void setInfo(QString portName);
+
+    Q_INVOKABLE void setInfo(QString portName,int baunRate);
+
+
+    /**
+     * @brief 轮询请求
+     * @return
+     */
+    Q_INVOKABLE bool reqGetInfo();
+
+    /**
+     * @brief 控制请求，控制灯亮状态
+     * @return
+     */
+    Q_INVOKABLE bool reqControl(int iChannel,LightState lightstate);
+    Q_INVOKABLE bool reqControl(int iChannel,int lightstate);
+    /**
+     * @brief 预调节请求
+     * @return
+     */
+    bool reqPreconditioning(int iChannel,ModeState modestate);
+
+    Q_INVOKABLE bool reqPreconditioning(int iChannel,int modestate);
+    Q_INVOKABLE bool reqUpdateA(int iChannel,int AValue);
+    Q_INVOKABLE bool reqPowOn(ModeState state);
+
+    Q_INVOKABLE bool reqPowOn(int state);
+    /**
+     * @brief 关机指令响应
+     * @param powstate
+     * @return
+     */
+    bool resqPowoff(PowState powstate);
+    Q_INVOKABLE bool resqPowoff(int powstate);
+    Q_INVOKABLE bool connectPort();
+    Q_INVOKABLE bool disConnectPort();
+    Q_INVOKABLE bool getConnectState();
+
+    bool getTestConnectSuccess() const;
+    void startTest();
+
+signals:
+    void commandSendError(int iChannel,ErrorCode errorcode,int iFunctionCode);
+    /**
+     * @brief 帧数据解析异常
+     * @param errorcode
+     * @param errBuffer
+     */
+    void frameError(ErrorCode errorcode,QByteArray errBuffer=nullptr);
+    /**
+     * @brief 数字板信息接收信号
+     * @param di
+     */
+    void digitalInfoRev(QVariantMap digitalInfo);
+    /**
+     * @brief 关机指令接收信号
+     */
+    void powOffCommandRev();
+    /**
+     * @brief 控制响应接收信号
+     * @param iChannel
+     * @param lightstate
+     */
+    void controlRespond(int iChannel,LightState lightstate);
+    /**
+     * @brief 预调节响应接收信号
+     * @param iChannel
+     * @param modestate
+     */
+    void preconditioningRespond(int iChannel,ModeState modestate);
+
+    void AUpdated(int iChannel,int AValue);
+
+    void PowOn(ModeState powOnState);
+
+
+protected:
+    void dealDate(QByteArray) override;
+
+private:
+    CODECXyckDigital *_codec;
+    bool testConnectSuccess;
+    bool testStart;
+
+
+private:
+    void initCodec();
+
+
+
+public slots:
+    void OnCommandSendErrorRev(int iChannel,ErrorCode errorcode,int iFunctionCode);
+    /**
+     * @brief 帧数据解析异常
+     * @param errorcode
+     * @param errBuffer
+     */
+    void OnFrameErrorRev(ErrorCode errorcode,QByteArray errBuffer=nullptr);
+    /**
+     * @brief 数字板信息接收信号
+     * @param di
+     */
+    void OnDigitalInfoRev(DigitalInfo *di);
+    /**
+     * @brief 关机指令接收信号
+     */
+    void OnPowOffCommandRev();
+    /**
+     * @brief 控制响应接收信号
+     * @param iChannel
+     * @param lightstate
+     */
+    void OnControlRespondRev(int iChannel,LightState lightstate);
+    /**
+     * @brief 预调节响应接收信号
+     * @param iChannel
+     * @param modestate
+     */
+    void OnPreconditioningRespondRev(int iChannel,ModeState modestate);
+
+    void OnAUpdated(int iChannel,int AValue);
+
+    void OnPowOn(ModeState powOnState);
+
+
+};
+
+#endif // XYCKDIGITALBOARD_H