h-4nd-h
/
plx
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

add BlockingQueuedConnection and sig-slot check

mehrabi
mehrabi 3 years ago
parent
deece14f69
commit
aadd7e3ca3
20 changed files with 1248 additions and 1511 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      Plx/Plx.pro
  2. 54
      Plx/include/API/HonaAPI.h
  3. 22
      Plx/include/LowLevel/Exception/HonaAlreadyStartedException.h
  4. 18
      Plx/include/LowLevel/Exception/HonaBusyException.h
  5. 18
      Plx/include/LowLevel/Exception/HonaException.h
  6. 218
      Plx/include/LowLevel/HonaLowLevelAPI.h
  7. 102
      Plx/include/LowLevel/HonaPacket.h
  8. 32
      Plx/include/LowLevel/Setting/Setting.h
  9. 63
      Plx/include/LowLevel/Utils/Utils.h
  10. 76
      Plx/include/Wrapper/PlxWrapper.h
  11. 255
      Plx/src/API/HonaAPI.cpp
  12. 1614
      Plx/src/LowLevel/HonaLowLevelAPI.cpp
  13. 48
      Plx/src/LowLevel/HonaPacket.cpp
  14. 99
      Plx/src/Wrapper/PlxWrapper.cpp
  15. 97
      Test/MainWindow.cpp
  16. 25
      Test/MainWindow.h
  17. 10
      Test/MainWindow.ui
  18. 2
      Test/Test.pro
  19. 1
      Test/main.cpp
  20. 1
      ignore.save

4
Plx/Plx.pro
View File

@ -41,7 +41,3 @@ INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a
<<<<<<< HEAD
=======
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126

54
Plx/include/API/HonaAPI.h
View File

@ -4,42 +4,42 @@
#include <QObject> #include <QObject>
#include "LowLevel/Setting/Setting.h" #include "LowLevel/Setting/Setting.h"
#include "include/LowLevel/Exception/HonaAlreadyStartedException.h" #include "LowLevel/Exception/HonaAlreadyStartedException.h"
#include "include/LowLevel/Exception/HonaException.h" #include "LowLevel/Exception/HonaException.h"
#include "include/LowLevel/Utils/Utils.h" #include "LowLevel/Utils/Utils.h"
#include "include/LowLevel/HonaLowLevelAPI.h" #include "LowLevel/HonaLowLevelAPI.h"
class HonaAPI : public QObject class HonaAPI : public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
HonaLowLevelAPI _honaLowLevelAPI; HonaLowLevelAPI _honaLowLevelAPI;
public: public:
HonaAPI() HonaAPI()
{ {
} }
~HonaAPI() ~HonaAPI()
{ {
} }
ApiResult isHsruStarted(); ApiResult isHsruStarted();
ApiResult isHiruStarted(); ApiResult isHiruStarted();
ApiResult deviceReset(); ApiResult deviceReset();
ApiResult setConfig(HonaSettings& settings); ApiResult setConfig(HonaSettings& settings);
ApiResult getConfig(HonaSettings& settings); ApiResult getConfig(HonaSettings& settings);
ApiResult getSwVersion(QString& swVerion); ApiResult getSwVersion(QString& swVerion);
ApiResult getDeviceId(QString& deviceId); ApiResult getDeviceId(QString& deviceId);
ApiResult hsruStart(); ApiResult hsruStart();
ApiResult hiruStart(); ApiResult hiruStart();
ApiResult hsruStop(); ApiResult hsruStop();
ApiResult init(); ApiResult init();
signals: signals:
void honaDataResult(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa); void honaDataResult(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
}; };
#endif //HONAAPI_H #endif //HONAAPI_H

22
Plx/include/LowLevel/Exception/HonaAlreadyStartedException.h
View File

@ -7,21 +7,21 @@
class HonaAlreadyStartedException : public std::exception class HonaAlreadyStartedException : public std::exception
{ {
private: private:
QString _str; QString _str;
public: public:
HonaAlreadyStartedException(QString str) HonaAlreadyStartedException(QString str)
{ {
_str = str; _str = str;
qDebug() << "HonaAlreadyStartedException " << str; qDebug() << "HonaAlreadyStartedException " << str;
} }
virtual const char* what() const throw() virtual const char* what() const throw()
{ {
qDebug() << "HonaAlreadyStartedException return " << _str; qDebug() << "HonaAlreadyStartedException return " << _str;
return _str.toStdString().c_str(); return _str.toStdString().c_str();
} }
}; };
#endif //HONAALREADYSTARTEDEXCEPTION_H #endif //HONAALREADYSTARTEDEXCEPTION_H

18
Plx/include/LowLevel/Exception/HonaBusyException.h
View File

@ -7,18 +7,18 @@
class HonaBusyException : public std::exception class HonaBusyException : public std::exception
{ {
private: private:
QString _str; QString _str;
public: public:
HonaBusyException(QString str) HonaBusyException(QString str)
{ {
_str = str; _str = str;
} }
virtual const char* what() const throw() virtual const char* what() const throw()
{ {
return _str.toStdString().c_str(); return _str.toStdString().c_str();
} }
}; };
#endif //HONABUSYEXCEPTION_H #endif //HONABUSYEXCEPTION_H

18
Plx/include/LowLevel/Exception/HonaException.h
View File

@ -7,18 +7,18 @@
class HonaException : public std::exception class HonaException : public std::exception
{ {
private: private:
QString _str; QString _str;
public: public:
HonaException(QString str) HonaException(QString str)
{ {
_str = str; _str = str;
} }
virtual const char* what() const throw() virtual const char* what() const throw()
{ {
return _str.toStdString().c_str(); return _str.toStdString().c_str();
} }
}; };
#endif //HONAEXCEPTION_H #endif //HONAEXCEPTION_H

218
Plx/include/LowLevel/HonaLowLevelAPI.h
View File

@ -1,163 +1,137 @@
#ifndef HONALOWLEVELAPI_H #ifndef HONALOWLEVELAPI_H
#define HONALOWLEVELAPI_H #define HONALOWLEVELAPI_H
#include <QObject> #include <QObject>
#include <QMutex>
#include <QWaitCondition>
#include "LowLevel/Setting/Setting.h" #include "LowLevel/Setting/Setting.h"
#include "LowLevel/HonaPacket.h" #include "LowLevel/HonaPacket.h"
#include "LowLevel/Setting/Setting.h" #include "LowLevel/Setting/Setting.h"
#include "HonaPacket.h" #include "HonaPacket.h"
#include "QWaitCondition"
#include "QMutex"
<<<<<<< HEAD
#include "include/LowLevel/HonaPacket.h"
#include "include/Wrapper/PlxWrapper.h"
=======
#include "LowLevel/Exception/HonaAlreadyStartedException.h" #include "LowLevel/Exception/HonaAlreadyStartedException.h"
#include "LowLevel/Exception/HonaException.h" #include "LowLevel/Exception/HonaException.h"
#include "Wrapper/PlxWrapper.h" #include "Wrapper/PlxWrapper.h"
#include "LowLevel/Utils/Utils.h" #include "LowLevel/Utils/Utils.h"
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
class HonaLowLevelAPI : public QObject class HonaLowLevelAPI : public QObject
{ {
Q_OBJECT Q_OBJECT
private: private:
bool _hsruIsStarted = false; bool _hsruIsStarted = false;
bool _hiruIsStarted = false; bool _hiruIsStarted = false;
quint32 _hsruLoss; quint32 _hsruLoss;
HonaSettings _honaSetting; HonaSettings _honaSetting;
QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone, QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
_hiruUpdateAck1; _hiruUpdateAck1;
QList<HonaPacket> honaPacketList;
QMutex _mutex;
int _threadSforValue = 0;
<<<<<<< HEAD
bool _isReaderThreadFree = false;
bool _isUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
QList<HonaPacket> honaPacketList; QList<HonaPacket> honaPacketList;
PlxWrapper plxwrapper; QMutex _mutex;
int _threadSforValue = 0;
bool _isHsruMainThreadFree = false;
bool _isHsruReaderThreadFree = false;
bool _isHsruUpdateThreadFree = false;
bool _isHiruReaderThreadFree = false;
bool _isHiruUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
PlxWrapper plxWrapper;
quint32 hsruLoss = 0; static quint32 packetLenInt4;
static quint32 packetLenRes4;
static quint32 packetLenSinglePulse;
static quint32 packetLenInt123C; static quint32 packetLenInt123C;
static quint32 packetLenRes123C; static quint32 packetLenRes123C;
static quint32 packetLenIntS; static quint32 packetLenIntS;
static quint32 packetLenResS; static quint32 packetLenResS;
=======
bool _isHsruMainThreadFree = false; static quint32 nextInt4;
bool _isHsruReaderThreadFree = false; static quint32 nextRes4;
bool _isHsruUpdateThreadFree = false; static quint32 nextSinglePulse;
bool _isHiruReaderThreadFree = false; static quint32 nextInt123C;
bool _isHiruUpdateThreadFree = false; static quint32 nextRes123C;
QVector<quint32> honaRegisterBuffer; static quint32 nextIntS;
PlxWrapper plxWrapper; static quint32 nextResS;
static quint32 packetLenInt4; quint32 lastPNInt4 = 0;
static quint32 packetLenRes4; quint32 lastPNRes4 = 0;
static quint32 packetLenSinglePulse; quint32 lastPNSinglePulse = 0;
static quint32 packetLenInt123C; quint32 lastPNInt123C = 0;
static quint32 packetLenRes123C; quint32 lastPNRes123C = 0;
static quint32 packetLenIntS; quint32 lastPNIntS = 0;
static quint32 packetLenResS; quint32 lastPNResS = 0;
static quint32 nextInt4; HonaPacket tempHonaPacketInt4;
static quint32 nextRes4; HonaPacket tempHonaPacketRes4;
static quint32 nextSinglePulse; HonaPacket tempHonaPacketSinglePulse;
static quint32 nextInt123C; HonaPacket tempHonaPacketInt123C;
static quint32 nextRes123C; HonaPacket tempHonaPacketRes123C;
static quint32 nextIntS; HonaPacket tempHonaPacketIntS;
static quint32 nextResS; HonaPacket tempHonaPacketResS;
quint32 lastPNInt4 = 0;
quint32 lastPNRes4 = 0;
quint32 lastPNSinglePulse = 0;
quint32 lastPNInt123C = 0;
quint32 lastPNRes123C = 0;
quint32 lastPNIntS = 0;
quint32 lastPNResS = 0;
HonaPacket tempHonaPacketInt4;
HonaPacket tempHonaPacketRes4;
HonaPacket tempHonaPacketSinglePulse;
HonaPacket tempHonaPacketInt123C;
HonaPacket tempHonaPacketRes123C;
HonaPacket tempHonaPacketIntS;
HonaPacket tempHonaPacketResS;
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
public: public:
qulonglong toaStartBoard = 0; qulonglong toaStartBoard = 0;
HonaLowLevelAPI(QObject* parent = nullptr); HonaLowLevelAPI(QObject* parent = nullptr);
~HonaLowLevelAPI() ~HonaLowLevelAPI()
{ {
} }
bool isHsruStarted(); bool isHsruStarted();
bool isHiruStarted(); bool isHiruStarted();
void deviceReset(); void deviceReset();
void setConfig(HonaSettings& settings); void setConfig(HonaSettings& settings);
HonaSettings getConfig(); HonaSettings getConfig();
QString getSwVersion(); QString getSwVersion();
QString getDeviceId(); QString getDeviceId();
void hsruStart(); void hsruStart();
void hiruStart(); void hiruStart();
void hsruStop(); void hsruStop();
void init(); void init();
bool getHsruIsStarted() const; bool getHsruIsStarted() const;
void setHsruIsStarted(bool hsruIsStarted); void setHsruIsStarted(bool hsruIsStarted);
bool getHiruIsStarted() const; bool getHiruIsStarted() const;
void setHiruIsStarted(bool hiruIsStarted); void setHiruIsStarted(bool hiruIsStarted);
private: private:
void writeSettingToRegisters(HonaSettings& settings); void writeSettingToRegisters(HonaSettings& settings);
void setConfig(); void setConfig();
void hsruMainThread(); void hsruMainThread();
void hsruReadThread(); void hsruReadThread();
void hsruUpdateThread(); void hsruUpdateThread();
void hiruMainThread(); void hiruMainThread();
void hiruReadThread(); void hiruReadThread();
void hiruUpdateThread(); void hiruUpdateThread();
quint32 hiruGetDOA(); quint32 hiruGetDOA();
quint32 hsruParserInt123C(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserInt123C(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserRes123C(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserRes123C(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserIntS(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserIntS(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserResS(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserResS(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserInt4(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserInt4(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserRes4(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList); quint32 hsruParserRes4(const QVector<quint32>& honaData, QList<HonaPacket>& honaPacketList);
quint32 hsruParserSinglePulse(const QVector<quint32>& honaData, quint32 hsruParserSinglePulse(const QVector<quint32>& honaData,
QList<HonaPacket>& honaPacketList); QList<HonaPacket>& honaPacketList);
QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
bool isValid(HonaPacket hp);
public:
void hsruReaderMethod();
QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver); QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
quint32 hsruParserInt123C(quint32 honaData,QList<HonaPacket> honaPacketList);
bool isValid(HonaPacket hp);
public:
signals: signals:
void lowLevelHonaData(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa); void lowLevelHonaData(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
//uncrustify off //uncrustify off
public slots: public slots:
//uncrustify on //uncrustify on
}; };
#endif //HONALOWLEVELAPI_H #endif //HONALOWLEVELAPI_H

102
Plx/include/LowLevel/HonaPacket.h
View File

@ -8,59 +8,59 @@
class HonaPacket class HonaPacket
{ {
private: private:
qreal toaClock; qreal toaClock;
honaPacketType m_PacketType; honaPacketType m_PacketType;
quint32 m_PacketNumber; quint32 m_PacketNumber;
qulonglong m_Toa; qulonglong m_Toa;
quint32 m_Doa; quint32 m_Doa;
quint32 m_Pa1; quint32 m_Pa1;
quint32 m_Pa2; quint32 m_Pa2;
quint32 m_Pa3; quint32 m_Pa3;
quint32 m_Pa4; quint32 m_Pa4;
quint32 m_Code; quint32 m_Code;
qulonglong m_CodeL; qulonglong m_CodeL;
qulonglong m_CodeM; qulonglong m_CodeM;
quint8 m4Status; quint8 m4Status;
public: public:
HonaPacket(); HonaPacket();
/******************************************************************/ /******************************************************************/
honaPacketType getPacketType(); honaPacketType getPacketType();
void setPacketType(honaPacketType temp); void setPacketType(honaPacketType temp);
/******************************************************************/ /******************************************************************/
quint32 getPacketNumber(); quint32 getPacketNumber();
void setPacketNumber(quint32 temp); void setPacketNumber(quint32 temp);
/******************************************************************/ /******************************************************************/
qulonglong getToa(); qulonglong getToa();
void setToa(qulonglong temp); void setToa(qulonglong temp);
/******************************************************************/ /******************************************************************/
quint32 getDoa(); quint32 getDoa();
void setDoa(quint32 temp); void setDoa(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getPa1(); quint32 getPa1();
void setPa1(quint32 temp); void setPa1(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getPa2(); quint32 getPa2();
void setPa2(quint32 temp); void setPa2(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getPa3(); quint32 getPa3();
void setPa3(quint32 temp); void setPa3(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getPa4(); quint32 getPa4();
void setPa4(quint32 temp); void setPa4(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getCode(); quint32 getCode();
void setCode(quint32 temp); void setCode(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getCodeL(); quint32 getCodeL();
void setCodeL(quint32 temp); void setCodeL(quint32 temp);
/******************************************************************/ /******************************************************************/
quint32 getCodeM(); quint32 getCodeM();
void setCodeM(quint32 temp); void setCodeM(quint32 temp);
/******************************************************************/ /******************************************************************/
quint8 getm4Status(); quint8 getm4Status();
void setm4Status(quint8 temp); void setm4Status(quint8 temp);
/******************************************************************/ /******************************************************************/
}; };
#endif //HONAPACKET_H #endif //HONAPACKET_H

32
Plx/include/LowLevel/Setting/Setting.h
View File

@ -9,32 +9,32 @@
/***********************************************************************************************/ /***********************************************************************************************/
struct hiruSettings_t struct hiruSettings_t
{ {
recorderStart recordStard; recorderStart recordStard;
recorderMode recordMode; recorderMode recordMode;
quint32 recordChannel; quint32 recordChannel;
quint32 threshold = 0; quint32 threshold = 0;
quint32 timeout = 1000; quint32 timeout = 1000;
quint32 count = 5; quint32 count = 5;
}; };
/***********************************************************************************************/ /***********************************************************************************************/
struct hsruSettings_t struct hsruSettings_t
{ {
bool isReal = true; bool isReal = true;
quint32 honaInt123CTHR = 128; quint32 honaInt123CTHR = 128;
quint32 honaRes123CTHR = 128; quint32 honaRes123CTHR = 128;
quint32 honaIntSTHR = 20; quint32 honaIntSTHR = 20;
quint32 honaResSTHR = 20; quint32 honaResSTHR = 20;
quint32 honaSPTHR = 20; //mode4 quint32 honaSPTHR = 20;
quint32 intM4_THR = 20; //mode4 quint32 intM4_THR = 20;
quint32 resM4_THR = 20; //mode4 quint32 resM4_THR = 20;
}; };
/***********************************************************************************************/ /***********************************************************************************************/
struct HonaSettings struct HonaSettings
{ {
hiruSettings_t hiruSettings; hiruSettings_t hiruSettings;
hsruSettings_t hsruSettings; hsruSettings_t hsruSettings;
}; };
/***********************************************************************************************/ /***********************************************************************************************/

63
Plx/include/LowLevel/Utils/Utils.h
View File

@ -1,83 +1,64 @@
#ifndef UTILS_H #ifndef UTILS_H
#define UTILS_H #define UTILS_H
#include <QtCore> #include <QtCore>
/*************************************************************************************************/ /*************************************************************************************************/
enum ApiResult : quint8 enum ApiResult : quint8
{ {
success, success,
alreadyStarted, alreadyStarted,
busy, busy,
error error
}; };
/*************************************************************************************************/ /*************************************************************************************************/
enum drxDeviceIfChannel : quint8 enum drxDeviceIfChannel : quint8
{ {
ifChannel11, ifChannel11,
ifChannel12 ifChannel12
}; };
/*************************************************************************************************/ /*************************************************************************************************/
enum honaReceivers : quint8 enum honaReceivers : quint8
{ {
<<<<<<< HEAD
int123C, int123C,
res123C, res123C,
intS, intS,
resS, resS,
int4, //Mode 4 int4,
res4, //Mode 4 res4,
singlePulse //Mode 4 singlePulse
=======
int123C,
res123C,
intS,
resS,
int4, //Mode 4
res4, //Mode 4
singlePulse //Mode 4
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
}; };
/*************************************************************************************************/ /*************************************************************************************************/
enum recorderMode : quint8 enum recorderMode : quint8
{ {
signalChannel, signalChannel,
dualChannel dualChannel
}; };
/*************************************************************************************************/ /*************************************************************************************************/
enum recorderStart : quint8 enum recorderStart : quint8
{ {
selfTestCounter = 1, selfTestCounter = 1,
freeRunRecording = 2 freeRunRecording = 2
}; };
/*************************************************************************************************/ /*************************************************************************************************/
enum honaPacketType : quint8 enum honaPacketType : quint8
{ {
interrogationMode123C, interrogationMode123C,
interrogationModeS56, interrogationModeS56,
interrogationModeS112, interrogationModeS112,
interrogationMode4, interrogationMode4,
responseMode123C, responseMode123C,
responseModeS56, responseModeS56,
responseModeS112, responseModeS112,
responseMode4, responseMode4,
singlePulseMode4 singlePulseMode4
}; };
<<<<<<< HEAD
/*************************************************************************************************/
#endif // UTILS_H
=======
/*************************************************************************************************/ /*************************************************************************************************/
#endif //UTILS_H #endif //UTILS_H
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126

76
Plx/include/Wrapper/PlxWrapper.h
View File

@ -2,62 +2,32 @@
#define PLXWRAPPER_H #define PLXWRAPPER_H
#include <QtGlobal> #include <QtGlobal>
#include "PlxPci_9054_Func.h" #include "PlxPci_9054_Func.h"
<<<<<<< HEAD
class PlxWrapper class PlxWrapper
{ {
public: public:
PlxWrapper(); PlxWrapper();
bool deviceInit(quint32 devicekey); bool deviceInit(quint32 devicekey);
bool deviceOpen(void); bool deviceOpen(void);
bool deviceClose(void); bool deviceClose(void);
bool deviceReset(void); bool deviceReset(void);
bool deviceLoadE2pToFPGA(void); bool deviceLoadE2pToFPGA(void);
bool deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data); bool deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data);
bool deviceWriteEeprom(quint16 offset, quint32 data); bool deviceWriteEeprom(quint16 offset, quint32 data);
bool deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length); bool deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length);
bool deviceReadRegister(quint32 address, quint32& data); bool deviceReadRegister(quint32 address, quint32& data);
bool deviceWriteRegister(quint32 address, QVector<quint32>& data); bool deviceWriteRegister(quint32 address, QVector<quint32>& data);
bool deviceWriteRegister(quint32 address, quint32 data); bool deviceWriteRegister(quint32 address, quint32 data);
bool deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length); bool deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length);
bool deviceOpenPCIChannel(void); bool deviceOpenPCIChannel(void);
bool deviceClosePCIChannel(void); bool deviceClosePCIChannel(void);
bool deviceEnableInterrupt(void); bool deviceEnableInterrupt(void);
bool deviceDisableInterrupt(void); bool deviceDisableInterrupt(void);
bool deviceWaitForInterrupt(quint32 timeout); bool deviceWaitForInterrupt(quint32 timeout);
bool deviceGetChipType(quint8 revision, quint16 chipType); bool deviceGetChipType(quint8 revision, quint16 chipType);
=======
class PlxWrapper
{
public:
PlxWrapper();
bool deviceInit(quint32 devicekey);
bool deviceOpen(void);
bool deviceClose(void);
bool deviceReset(void);
bool deviceLoadE2pToFPGA(void);
bool deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data);
bool deviceWriteEeprom(quint16 offset, quint32 data);
bool deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length);
bool deviceReadRegister(quint32 address, quint32& data);
bool deviceWriteRegister(quint32 address, QVector<quint32>& data);
bool deviceWriteRegister(quint32 address, quint32 data);
bool deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length);
bool deviceOpenPCIChannel(void);
bool deviceClosePCIChannel(void);
bool deviceEnableInterrupt(void);
bool deviceDisableInterrupt(void);
bool deviceWaitForInterrupt(quint32 timeout);
bool deviceGetChipType(quint8 revision, quint16 chipType);
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
}; };
#endif //PLXWRAPPER_H #endif //PLXWRAPPER_H

255
Plx/src/API/HonaAPI.cpp
View File

@ -1,186 +1,185 @@
#include "include/API/HonaAPI.h" #include "include/API/HonaAPI.h"
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::isHsruStarted() ApiResult HonaAPI::isHsruStarted()
{ {
try { try {
if(_honaLowLevelAPI.isHsruStarted()) if(_honaLowLevelAPI.isHsruStarted())
return ApiResult::success; return ApiResult::success;
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::isHiruStarted() ApiResult HonaAPI::isHiruStarted()
{ {
try { try {
if(_honaLowLevelAPI.isHiruStarted()) if(_honaLowLevelAPI.isHiruStarted())
return ApiResult::success; return ApiResult::success;
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::deviceReset() ApiResult HonaAPI::deviceReset()
{ {
try { try {
_honaLowLevelAPI.deviceReset(); _honaLowLevelAPI.deviceReset();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::setConfig(HonaSettings& settings) ApiResult HonaAPI::setConfig(HonaSettings& settings)
{ {
try { try {
_honaLowLevelAPI.setConfig(settings); _honaLowLevelAPI.setConfig(settings);
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::getConfig(HonaSettings& settings) ApiResult HonaAPI::getConfig(HonaSettings& settings)
{ {
try { try {
settings = _honaLowLevelAPI.getConfig(); settings = _honaLowLevelAPI.getConfig();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::getSwVersion(QString& swVerion) ApiResult HonaAPI::getSwVersion(QString& swVerion)
{ {
try { try {
swVerion = _honaLowLevelAPI.getSwVersion(); swVerion = _honaLowLevelAPI.getSwVersion();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::getDeviceId(QString& deviceId) ApiResult HonaAPI::getDeviceId(QString& deviceId)
{ {
try { try {
deviceId = _honaLowLevelAPI.getDeviceId(); deviceId = _honaLowLevelAPI.getDeviceId();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::hsruStart() ApiResult HonaAPI::hsruStart()
{ {
try { try {
_honaLowLevelAPI.hsruStart(); _honaLowLevelAPI.hsruStart();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::hiruStart() ApiResult HonaAPI::hiruStart()
{ {
try { try {
_honaLowLevelAPI.hiruStart(); _honaLowLevelAPI.hiruStart();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::hsruStop() ApiResult HonaAPI::hsruStop()
{ {
try { try {
_honaLowLevelAPI.hsruStop(); _honaLowLevelAPI.hsruStop();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/
ApiResult HonaAPI::init() ApiResult HonaAPI::init()
{ {
connect(&_honaLowLevelAPI, &HonaLowLevelAPI::lowLevelHonaData, this, &HonaAPI::honaDataResult); connect(&_honaLowLevelAPI, &HonaLowLevelAPI::lowLevelHonaData, this, &HonaAPI::honaDataResult,Qt::BlockingQueuedConnection);
try { try {
_honaLowLevelAPI.init(); _honaLowLevelAPI.init();
} }
catch(HonaException ex) catch(HonaException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
catch(HonaAlreadyStartedException ex) catch(HonaAlreadyStartedException ex)
{ {
return ApiResult::error; return ApiResult::error;
} }
return ApiResult::success; return ApiResult::success;
} }
/*************************************************************************************************/ /*************************************************************************************************/

1614
Plx/src/LowLevel/HonaLowLevelAPI.cpp
View File

File diff suppressed because it is too large

48
Plx/src/LowLevel/HonaPacket.cpp
View File

@ -7,133 +7,133 @@ HonaPacket::HonaPacket()
/*************************************************************************************************/ /*************************************************************************************************/
honaPacketType HonaPacket::getPacketType() honaPacketType HonaPacket::getPacketType()
{ {
return m_PacketType; return m_PacketType;
} }
void HonaPacket::setPacketType(honaPacketType temp) void HonaPacket::setPacketType(honaPacketType temp)
{ {
m_PacketType = temp; m_PacketType = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getPacketNumber() quint32 HonaPacket::getPacketNumber()
{ {
return m_PacketNumber; return m_PacketNumber;
} }
void HonaPacket::setPacketNumber(quint32 temp) void HonaPacket::setPacketNumber(quint32 temp)
{ {
m_PacketNumber = temp; m_PacketNumber = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
qulonglong HonaPacket::getToa() qulonglong HonaPacket::getToa()
{ {
return m_Toa; return m_Toa;
} }
void HonaPacket::setToa(qulonglong temp) void HonaPacket::setToa(qulonglong temp)
{ {
m_Toa = temp; m_Toa = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getDoa() quint32 HonaPacket::getDoa()
{ {
return m_Doa; return m_Doa;
} }
void HonaPacket::setDoa(quint32 temp) void HonaPacket::setDoa(quint32 temp)
{ {
m_Doa = temp; m_Doa = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getPa1() quint32 HonaPacket::getPa1()
{ {
return m_Pa1; return m_Pa1;
} }
void HonaPacket::setPa1(quint32 temp) void HonaPacket::setPa1(quint32 temp)
{ {
m_Pa1 = temp; m_Pa1 = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getPa2() quint32 HonaPacket::getPa2()
{ {
return m_Pa2; return m_Pa2;
} }
void HonaPacket::setPa2(quint32 temp) void HonaPacket::setPa2(quint32 temp)
{ {
m_Pa2 = temp; m_Pa2 = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getPa3() quint32 HonaPacket::getPa3()
{ {
return m_Pa3; return m_Pa3;
} }
void HonaPacket::setPa3(quint32 temp) void HonaPacket::setPa3(quint32 temp)
{ {
m_Pa3 = temp; m_Pa3 = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getPa4() quint32 HonaPacket::getPa4()
{ {
return m_Pa4; return m_Pa4;
} }
void HonaPacket::setPa4(quint32 temp) void HonaPacket::setPa4(quint32 temp)
{ {
m_Pa4 = temp; m_Pa4 = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getCode() quint32 HonaPacket::getCode()
{ {
return m_Code; return m_Code;
} }
void HonaPacket::setCode(quint32 temp) void HonaPacket::setCode(quint32 temp)
{ {
m_Code = temp; m_Code = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getCodeL() quint32 HonaPacket::getCodeL()
{ {
return m_CodeL; return m_CodeL;
} }
void HonaPacket::setCodeL(quint32 temp) void HonaPacket::setCodeL(quint32 temp)
{ {
m_CodeL = temp; m_CodeL = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint32 HonaPacket::getCodeM() quint32 HonaPacket::getCodeM()
{ {
return m_CodeM; return m_CodeM;
} }
void HonaPacket::setCodeM(quint32 temp) void HonaPacket::setCodeM(quint32 temp)
{ {
m_CodeM = temp; m_CodeM = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/
quint8 HonaPacket::getm4Status() quint8 HonaPacket::getm4Status()
{ {
return m4Status; return m4Status;
} }
void HonaPacket::setm4Status(quint8 temp) void HonaPacket::setm4Status(quint8 temp)
{ {
m4Status = temp; m4Status = temp;
} }
/*************************************************************************************************/ /*************************************************************************************************/

99
Plx/src/Wrapper/PlxWrapper.cpp
View File

@ -10,151 +10,150 @@ PlxWrapper::PlxWrapper()
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceInit(quint32 devicekey) bool PlxWrapper::deviceInit(quint32 devicekey)
{ {
return PlxPci_9054_SelDevice(devicekey); return PlxPci_9054_SelDevice(devicekey);
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceOpen() bool PlxWrapper::deviceOpen()
{ {
return PlxPci_9054_Open(); return PlxPci_9054_Open();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceClose() bool PlxWrapper::deviceClose()
{ {
return PlxPci_9054_Close(); return PlxPci_9054_Close();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceReset() bool PlxWrapper::deviceReset()
{ {
return PlxPci_9054_Reset(); return PlxPci_9054_Reset();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceLoadE2pToFPGA() bool PlxWrapper::deviceLoadE2pToFPGA()
{ {
return PlxPci_9054_LoadE2pToFPGA(); return PlxPci_9054_LoadE2pToFPGA();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data) bool PlxWrapper::deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data)
{ {
bool ret = true; bool ret = true;
data.clear(); data.clear();
for(auto i = 0U; i < (length - 1) * 4; i += 4) for(auto i = 0U; i < (length - 1) * 4; i += 4)
{ {
quint32 temp; quint32 temp;
ret &= PlxPci_9054_ReadEep(offset + i, &temp); ret &= PlxPci_9054_ReadEep(offset + i, &temp);
data.append(temp); data.append(temp);
} }
return ret; return ret;
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceWriteEeprom(quint16 offset, quint32 data) bool PlxWrapper::deviceWriteEeprom(quint16 offset, quint32 data)
{ {
return PlxPci_9054_WriteEep(offset, data); return PlxPci_9054_WriteEep(offset, data);
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length) bool PlxWrapper::deviceReadRegister(quint32 address, QVector<quint32>& data, quint32 length)
{ {
bool ret = true; bool ret = true;
data.clear(); data.clear();
quint32 temp[length]; quint32 temp[length];
ret &= PlxPci_9054_ReadBar(address, &temp, length * 4); ret &= PlxPci_9054_ReadBar(address, &temp, length * 4);
if(ret == true) if(ret == true)
{ {
for(auto i = 0U; i < length; i++) for(auto i = 0U; i < length; i++)
{ {
data.append(temp[i]); data.append(temp[i]);
qDebug() << hex << temp[i]; }
} }
}
return ret; return ret;
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceReadRegister(quint32 address, quint32& data) bool PlxWrapper::deviceReadRegister(quint32 address, quint32& data)
{ {
return PlxPci_9054_ReadBar(address, &data, 4); return PlxPci_9054_ReadBar(address, &data, 4);
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceWriteRegister(quint32 address, QVector<quint32>& data) bool PlxWrapper::deviceWriteRegister(quint32 address, QVector<quint32>& data)
{ {
bool ret = true; bool ret = true;
auto length = data.length(); auto length = data.length();
quint32 temp[length]; quint32 temp[length];
for(auto i = 0U; i < length; i++) for(auto i = 0U; i < length; i++)
temp[i] = data.at(i); temp[i] = data.at(i);
ret &= PlxPci_9054_WriteBar(address, &temp, length * 4); ret &= PlxPci_9054_WriteBar(address, &temp, length * 4);
return ret; return ret;
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceWriteRegister(quint32 address, quint32 data) bool PlxWrapper::deviceWriteRegister(quint32 address, quint32 data)
{ {
return PlxPci_9054_WriteBar(address, &data, 4); return PlxPci_9054_WriteBar(address, &data, 4);
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length) bool PlxWrapper::deviceReadMemory(quint32 localAddress, QVector<quint32>& data, quint32 length)
{ {
bool ret = true; bool ret = true;
data.clear(); data.clear();
quint32 temp[length]; quint32 temp[length];
ret &= PlxPci_9054_DMATransfer(localAddress, &temp, (quint32)(length * 4)); ret &= PlxPci_9054_DMATransfer(localAddress, &temp, (quint32)(length * 4));
for(auto i = 0U; i < length; i++) for(auto i = 0U; i < length; i++)
data.append(temp[i]); data.append(temp[i]);
return ret; return ret;
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceOpenPCIChannel(void) bool PlxWrapper::deviceOpenPCIChannel(void)
{ {
return PlxPci_9054_DMAChannelOpen(); return PlxPci_9054_DMAChannelOpen();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceClosePCIChannel(void) bool PlxWrapper::deviceClosePCIChannel(void)
{ {
return PlxPci_9054_DMAChannelClose(); return PlxPci_9054_DMAChannelClose();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceEnableInterrupt(void) bool PlxWrapper::deviceEnableInterrupt(void)
{ {
return PlxPci_9054_EnableInterrupt(); return PlxPci_9054_EnableInterrupt();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceDisableInterrupt(void) bool PlxWrapper::deviceDisableInterrupt(void)
{ {
return PlxPci_9054_DisableInterrupt(); return PlxPci_9054_DisableInterrupt();
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceWaitForInterrupt(quint32 timeout) bool PlxWrapper::deviceWaitForInterrupt(quint32 timeout)
{ {
return PlxPci_9054_WaitForInterrupt(timeout); return PlxPci_9054_WaitForInterrupt(timeout);
} }
/*************************************************************************************************/ /*************************************************************************************************/
bool PlxWrapper::deviceGetChipType(quint8 revision, quint16 chipType) bool PlxWrapper::deviceGetChipType(quint8 revision, quint16 chipType)
{ {
return PlxPci_9054_ChipTypeGet(revision, chipType); return PlxPci_9054_ChipTypeGet(revision, chipType);
} }

97
Test/MainWindow.cpp
View File

@ -1,72 +1,75 @@
#include "MainWindow.h" #include "MainWindow.h"
#include "ui_MainWindow.h" #include "ui_MainWindow.h"
HonaAPI _honaAPI;
MainWindow::MainWindow(QWidget* parent) MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent) : QMainWindow(parent)
, ui(new Ui::MainWindow) , ui(new Ui::MainWindow)
{ {
ui->setupUi(this); ui->setupUi(this);
connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi); connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
} }
MainWindow::~MainWindow() MainWindow::~MainWindow()
{ {
delete ui; delete ui;
} }
/*************************************************************************************************/ /*************************************************************************************************/
void MainWindow::honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa) void MainWindow::honaDataResultUi(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa)
{ {
qDebug() << "honaDataResultUi inside " << honaPacketList.length(); QString _str;
QString _str; for(auto i = 0; i < honaPacketList.length(); i++)
for(auto i = 0; i < honaPacketList.length(); i++) {
{ _str += "\n[hsruLoss] :" + QString::number(hsruLoss, 16);
_str = "[" + QString::number(i) + "] " + "0x hsruLoss" + QString::number(hsruLoss); _str += "\n[getToa] :" + QString::number(honaPacketList[i].getToa(), 16);
_str += "\n *********************************************"; _str += "\n[getDoa] :" + QString::number(honaPacketList[i].getDoa(), 16);
} _str += "\n[getPa1] :" + QString::number(honaPacketList[i].getPa1(), 16);
_str += "\n[getPa2] :" + QString::number(honaPacketList[i].getPa2(), 16);
_str += "\n[getPa3] :" + QString::number(honaPacketList[i].getPa3(), 16);
_str += "\n[getPa4] :" + QString::number(honaPacketList[i].getPa4(), 16);
_str += "\n[getCode] :" + QString::number(honaPacketList[i].getCode(), 16);
_str += "\n[getCodeL] :" + QString::number(honaPacketList[i].getCodeL(), 16);
_str += "\n[getCodeM] :" + QString::number(honaPacketList[i].getCodeM(), 16);
}
ui->dataFromMemory->setText(_str); ui->dataFromMemory->setText(_str);
} }
void MainWindow::on_testPLX_clicked() void MainWindow::on_testPLX_clicked()
{ {
ApiResult _resultInit = _honaAPI.init(); ApiResult _resultInit = _honaAPI.init();
//ApiResult _deviceReset = _honaAPI.deviceReset(); ApiResult _hsruStartResult = _honaAPI.hsruStart();
//HonaSettings settings;
//ApiResult _configResult = _honaAPI.setConfig(settings);
//ApiResult isHsruStarted = _honaAPI.isHsruStarted();
ApiResult _hsruStartResult = _honaAPI.hsruStart();
//******************************************************** //********************************************************
QString temp = ui->errorMonitoring->text(); QString temp = ui->errorMonitoring->text();
if(_resultInit == ApiResult::error) if(_resultInit == ApiResult::error)
{ {
ui->errorMonitoring->setText(temp + "\n" + " Error _resultInit"); ui->errorMonitoring->setText(temp + "\n" + " Error _resultInit");
} }
else if(_resultInit == ApiResult::success) else if(_resultInit == ApiResult::success)
{ {
ui->errorMonitoring->setText(temp + "\n" + "success _resultInit"); ui->errorMonitoring->setText(temp + "\n" + "success _resultInit");
} }
//******************************************************** //********************************************************
if(_hsruStartResult == ApiResult::error) if(_hsruStartResult == ApiResult::error)
{ {
ui->errorMonitoring->setText(temp + "\n" + " Error _hsruStartResult"); ui->errorMonitoring->setText(temp + "\n" + " Error _hsruStartResult");
} }
else if(_hsruStartResult == ApiResult::success) else if(_hsruStartResult == ApiResult::success)
{ {
ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult"); ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
} }
//******************************************************** //********************************************************
} }
void MainWindow::on_stopHsru_clicked() void MainWindow::on_stopHsru_clicked()
{ {
QString temp = ui->errorMonitoring->text(); QString temp = ui->errorMonitoring->text();
ApiResult _hsruStop = _honaAPI.hsruStop(); ApiResult _hsruStop = _honaAPI.hsruStop();
if(_hsruStop == ApiResult::error) if(_hsruStop == ApiResult::error)
{ {
ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult"); ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
} }
} }

25
Test/MainWindow.h
View File

@ -10,29 +10,28 @@
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; namespace Ui { class MainWindow;
} }
QT_END_NAMESPACE QT_END_NAMESPACE
class MainWindow : public QMainWindow class MainWindow : public QMainWindow
{ {
Q_OBJECT Q_OBJECT
private: private:
Ui::MainWindow* ui; Ui::MainWindow* ui;
int a; HonaAPI _honaAPI;
public: public:
MainWindow(QWidget* parent = nullptr); MainWindow(QWidget* parent = nullptr);
~MainWindow(); ~MainWindow();
//uncrustify off //uncrustify off
private slots: private slots:
void honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa); void honaDataResultUi(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
void on_testPLX_clicked(); void on_testPLX_clicked();
void on_stopHsru_clicked(); void on_stopHsru_clicked();
//uncrustify on: //uncrustify on:
private:
//HonaAPI _honaAPI;
}; };
#endif //MAINWINDOW_H #endif //MAINWINDOW_H

10
Test/MainWindow.ui
View File

@ -70,11 +70,17 @@
<property name="geometry"> <property name="geometry">
<rect> <rect>
<x>50</x> <x>50</x>
<y>160</y> <y>140</y>
<width>451</width> <width>451</width>
<height>261</height> <height>301</height>
</rect> </rect>
</property> </property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOn</enum>
</property>
<property name="sizeAdjustPolicy">
<enum>QAbstractScrollArea::AdjustToContentsOnFirstShow</enum>
</property>
</widget> </widget>
</widget> </widget>
<widget class="QMenuBar" name="menubar"> <widget class="QMenuBar" name="menubar">

2
Test/Test.pro
View File

@ -35,6 +35,7 @@ qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target !isEmpty(target.path): INSTALLS += target
unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
INCLUDEPATH += $$PWD/../../Plxlibrary/Library INCLUDEPATH += $$PWD/../../Plxlibrary/Library
@ -44,3 +45,4 @@ INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

1
Test/main.cpp
View File

@ -5,6 +5,7 @@
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
QApplication a(argc, argv); QApplication a(argc, argv);
MainWindow w; MainWindow w;
w.show(); w.show();
return a.exec(); return a.exec();

1
ignore.save
View File

@ -0,0 +1 @@
*.pro.user
Write Preview
Loading…
Cancel
Save