Update LAst Change after crash Computer

Plx/Plx.pro

@@ -17,17 +17,28 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 SOURCES += \
-    $$files(*.cpp, true) \
+    $$files(*.cpp, true)
-
 
 HEADERS += \
-    $$files(*.h, true) \
+    $$files(*.h, true)
 
 INCLUDEPATH += $$PWD/include
 
-
 # Default rules for deployment.
 unix {
     target.path = $$[QT_INSTALL_PLUGINS]/generic
 }
 !isEmpty(target.path): INSTALLS += target
+
+
+
+unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
+
+INCLUDEPATH += $$PWD/../../Plxlibrary/Library
+DEPENDPATH += $$PWD/../../Plxlibrary/Library
+
+INCLUDEPATH += $$PWD/../../Plxlibrary
+DEPENDPATH += $$PWD/../../Plxlibrary
+
+unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a
+

Plx/include/API/HonaAPI.h

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

Plx/include/LowLevel/Exception/HonaAlreadyStartedException.h

@@ -1,17 +1,27 @@
 #ifndef HONAALREADYSTARTEDEXCEPTION_H
 #define HONAALREADYSTARTEDEXCEPTION_H
 
-#include <QObject>
+#include <QDebug>
+#include <QString>
 
-class HonaAlreadyStartedException : public QObject
+class HonaAlreadyStartedException : public std::exception
 {
-	Q_OBJECT
+private:
+	QString _str;
+
 public:
-	explicit HonaAlreadyStartedException(QObject *parent = nullptr);
+	HonaAlreadyStartedException(QString str)
+	{
+		_str = str;
+		qDebug() << "HonaAlreadyStartedException " << str;
+	}
 
-signals:
+	virtual const char* what() const throw()
+	{
+		qDebug() << "HonaAlreadyStartedException return   " << _str;
 
-public slots:
+		return _str.toStdString().c_str();
+	}
 };
 
-#endif // HONAALREADYSTARTEDEXCEPTION_H
+#endif //HONAALREADYSTARTEDEXCEPTION_H

Plx/include/LowLevel/Exception/HonaBusyException.h

@@ -1,17 +0,0 @@
-#ifndef HONABUSYEXCEPTION_H
-#define HONABUSYEXCEPTION_H
-
-#include <QObject>
-
-class HonaBusyException : public QObject
-{
-	Q_OBJECT
-public:
-	explicit HonaBusyException(QObject *parent = nullptr);
-
-signals:
-
-public slots:
-};
-
-#endif // HONABUSYEXCEPTION_H

Plx/include/LowLevel/Exception/HonaException.h

@@ -1,17 +1,24 @@
 #ifndef HONAEXCEPTION_H
 #define HONAEXCEPTION_H
 
-#include <QObject>
+#include <QDebug>
+#include <QString>
 
-class HonaException : public QObject
+class HonaException : public std::exception
 {
-	Q_OBJECT
+private:
-public:
+	QString _str;
-	explicit HonaException(QObject *parent = nullptr);
 
-signals:
+public:
+	HonaException(QString str)
+	{
+		_str = str;
+	}
 
-public slots:
+	virtual const char* what() const throw()
+	{
+		return _str.toStdString().c_str();
+	}
 };
 
-#endif // HONAEXCEPTION_H
+#endif //HONAEXCEPTION_H

Plx/include/LowLevel/HonaLowLevelAPI.h

@@ -1,17 +1,136 @@
-#ifndef HONALOWLEVELAPI_H
+#ifndef HONALOWLEVELAPI_H
 #define HONALOWLEVELAPI_H
-
 #include <QObject>
+#include "LowLevel/Setting/Setting.h"
+#include "LowLevel/HonaPacket.h"
+#include "LowLevel/Setting/Setting.h"
+#include "HonaPacket.h"
+#include "QWaitCondition"
+#include "QMutex"
+#include "LowLevel/Exception/HonaAlreadyStartedException.h"
+#include "LowLevel/Exception/HonaException.h"
+#include "Wrapper/PlxWrapper.h"
+#include "LowLevel/Utils/Utils.h"
 
 class HonaLowLevelAPI : public QObject
 {
 	Q_OBJECT
+
+private:
+	bool _hsruIsStarted = false;
+	bool _hiruIsStarted = false;
+	quint32 _hsruLoss;
+	HonaSettings _honaSetting;
+	QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
+				   _hiruUpdateAck1;
+
+	QList<HonaPacket> honaPacketList;
+	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;
+
+	static quint32 packetLenInt4;
+	static quint32 packetLenRes4;
+	static quint32 packetLenSinglePulse;
+
+	static quint32 packetLenInt123C;
+	static quint32 packetLenRes123C;
+	static quint32 packetLenIntS;
+	static quint32 packetLenResS;
+
+	static quint32 nextInt4;
+	static quint32 nextRes4;
+	static quint32 nextSinglePulse;
+
+	static quint32 nextInt123C;
+	static quint32 nextRes123C;
+	static quint32 nextIntS;
+	static quint32 nextResS;
+
+	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;
+
+public:
+	qulonglong toaStartBoard = 0;
+
+	HonaLowLevelAPI(QObject* parent = nullptr);
+	~HonaLowLevelAPI()
+	{
+	}
+
+	bool isHsruStarted();
+	bool isHiruStarted();
+	void deviceReset();
+
+	void setConfig(HonaSettings& settings);
+	HonaSettings getConfig();
+	QString getSwVersion();
+	QString getDeviceId();
+	void hsruStart();
+	void hiruStart();
+	void hsruStop();
+	void init();
+
+	bool getHsruIsStarted() const;
+	void setHsruIsStarted(bool hsruIsStarted);
+
+	bool getHiruIsStarted() const;
+	void setHiruIsStarted(bool hiruIsStarted);
+
+private:
+	void writeSettingToRegisters(HonaSettings& settings);
+	void setConfig();
+	void hsruMainThread();
+	void hsruReadThread();
+	void hsruUpdateThread();
+	void hiruMainThread();
+	void hiruReadThread();
+	void hiruUpdateThread();
+	quint32 hiruGetDOA();
+
+	quint32 hsruParserInt123C(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 hsruParserResS(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 hsruParserSinglePulse(const QVector<quint32>& honaData,
+								  QList<HonaPacket>& honaPacketList);
+
+	QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
+
+	bool isValid(HonaPacket hp);
+
 public:
-	explicit HonaLowLevelAPI(QObject *parent = nullptr);
 
 signals:
+	void lowLevelHonaData(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
 
-public slots:
+	//uncrustify off
+public	slots:
+	//uncrustify on
 };
 
-#endif // HONALOWLEVELAPI_H
+#endif //HONALOWLEVELAPI_H

Plx/include/LowLevel/HonaPacket.h

@@ -2,62 +2,65 @@
 #define HONAPACKET_H
 
 #include <QtGlobal>
-#include "include/LowLevel/Utils/Utils.h"
 
+#include "LowLevel/Utils/Utils.h"
 
 class HonaPacket
 {
 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;
-    quint32 m_CodeL;
+	qulonglong m_CodeM;
-    quint32 m_CodeM;
+	quint8 m4Status;
 
 public:
-    HonaPacket();
+	HonaPacket();
-    /******************************************************************/
+	/******************************************************************/
-    honaPacketType getPacketType(void);
+	honaPacketType getPacketType();
-    void setPacketType(honaPacketType &temp);
+	void setPacketType(honaPacketType temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getPacketNumber(void);
+	quint32 getPacketNumber();
-    void setPacketNumber(quint32 temp);
+	void setPacketNumber(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    qulonglong getToa(void);
+	qulonglong getToa();
-    void setToa(qulonglong temp);
+	void setToa(qulonglong temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getDoa(void);
+	quint32 getDoa();
-    void setDoa(quint32 temp);
+	void setDoa(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getPa1(void);
+	quint32 getPa1();
-    void setPa1(quint32 temp);
+	void setPa1(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getPa2(void);
+	quint32 getPa2();
-    void setPa2(quint32 temp);
+	void setPa2(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getPa3(void);
+	quint32 getPa3();
-    void setPa3(quint32 temp);
+	void setPa3(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getPa4(void);
+	quint32 getPa4();
-    void setPa4(quint32 temp);
+	void setPa4(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getCode(void);
+	quint32 getCode();
-    void setCode(quint32 temp);
+	void setCode(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getCodeL(void);
+	quint32 getCodeL();
-    void setCodeL(quint32 temp);
+	void setCodeL(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
-    quint32 getCodeM(void);
+	quint32 getCodeM();
-    void setCodeM(quint32 temp);
+	void setCodeM(quint32 temp);
-    /******************************************************************/
+	/******************************************************************/
+	quint8 getm4Status();
+	void setm4Status(quint8 temp);
+	/******************************************************************/
 };
 
-#endif // HONAPACKET_H
+#endif //HONAPACKET_H

Plx/include/LowLevel/Setting/Setting.h

@@ -1,41 +1,42 @@
-
 #ifndef SETTINGS_H
 #define SETTINGS_H
 
 #include <QtGlobal>
-#include "include/LowLevel/Utils/Utils.h"
+#include <QList>
+
+#include "LowLevel/Utils/Utils.h"
 
 /***********************************************************************************************/
-typedef struct _HIRUSETTINGS
+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;
+};
 
-}hiruSettings;
 /***********************************************************************************************/
-typedef struct _HSRUSETTINGS
+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;     //mode4
-    quint32 intM4_THR = 20;     //mode4
+	quint32 intM4_THR = 20;     //mode4
-    quint32 resM4_THR = 20;     //mode4
+	quint32 resM4_THR = 20;     //mode4
+};
 
-}hsruSettings;
 /***********************************************************************************************/
-typedef struct _HONASETTINGS
+struct HonaSettings
 {
-    quint32 hsruSettings;
+	hiruSettings_t hiruSettings;
-    quint32 hiruSettings;
+	hsruSettings_t hsruSettings;
+};
 
-}honaSettings;
 /***********************************************************************************************/
 
-#endif // SETTING_H
+#endif //SETTING_H

Plx/include/LowLevel/Utils/Utils.h

@@ -1,69 +1,66 @@
 #ifndef UTILS_H
 #define UTILS_H
 
+#include <QtCore>
 
 /*************************************************************************************************/
-typedef  enum _APIRESULT
+enum ApiResult : quint8
 {
-    success,
+	success,
-    alreadyStarted,
+	alreadyStarted,
-    busy,
+	busy,
-    error
+	error
+};
 
-}apiResult;
 /*************************************************************************************************/
-typedef  enum _DRXDEVICEIFCHANNEL
+enum drxDeviceIfChannel : quint8
 {
-    ifChannel11,
+	ifChannel11,
-    ifChannel12
+	ifChannel12
+};
 
-}drxDeviceIfChannel;
 /*************************************************************************************************/
-typedef  enum _HONARECEIVERS
+enum honaReceivers : quint8
 {
-    int123C,
+	int123C,
-    intS,
+	res123C,
-    resS,
+	intS,
-    int4,           //Mode 4
+	resS,
-    res4,           //Mode 4
+	int4,           //Mode 4
-    signalPulse     //Mode 4
+	res4,           //Mode 4
+	singlePulse     //Mode 4
+};
 
-}honaReceivers;
 /*************************************************************************************************/
-typedef  enum _RECORDERMODE
+enum recorderMode : quint8
 {
-    signalChannel,
+	signalChannel,
-    dualChannel
+	dualChannel
+};
 
-}recorderMode;
 /*************************************************************************************************/
-typedef  enum _RECORDSTART
+enum  recorderStart : quint8
 {
-    selfTestCounter,
+	selfTestCounter = 1,
-    freeRunRecording
+	freeRunRecording = 2
+};
 
-}recorderStart;
 /*************************************************************************************************/
-typedef  enum _HONAPACKETTYPE
+enum honaPacketType : quint8
 {
-    interrogationMode123C,
+	interrogationMode123C,
-    interrogationModeS56,
+	interrogationModeS56,
-    interrogationModeS112,
+	interrogationModeS112,
-    interrogationMode4,
+	interrogationMode4,
 
-    responseMode123C,
+	responseMode123C,
-    responseModeS56,
+	responseModeS56,
-    responseModeS112,
+	responseModeS112,
 
-    responseMode4,
+	responseMode4,
-    signalPulseMode4
+	singlePulseMode4
+};
 
-}honaPacketType;
 /*************************************************************************************************/
 
-
+#endif //UTILS_H
-
-
-
-
-#endif // UTILS_H

Plx/include/Wrapper/PlxWrapper.h

@@ -0,0 +1,35 @@
+#ifndef PLXWRAPPER_H
+#define PLXWRAPPER_H
+
+#include <QtGlobal>
+#include "PlxPci_9054_Func.h"
+
+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);
+};
+
+#endif //PLXWRAPPER_H

Plx/src/API/HonaAPI.cpp

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

Plx/src/LowLevel/Exception/HonaAlreadyStartedException.cpp

@@ -1,6 +0,0 @@
-#include "../../../include/LowLevel/Exception/HonaAlreadyStartedException.h"
-
-HonaAlreadyStartedException::HonaAlreadyStartedException(QObject *parent) : QObject(parent)
-{
-
-}

Plx/src/LowLevel/Exception/HonaBusyException.cpp

@@ -1,6 +0,0 @@
-#include "../../../include/LowLevel/Exception/HonaBusyException.h"
-
-HonaBusyException::HonaBusyException(QObject *parent) : QObject(parent)
-{
-
-}

Plx/src/LowLevel/Exception/HonaException.cpp

@@ -1,6 +0,0 @@
-#include "../../../include/LowLevel/Exception/HonaException.h"
-
-HonaException::HonaException(QObject *parent) : QObject(parent)
-{
-
-}

Plx/src/LowLevel/HonaLowLevelAPI.cpp

@@ -1,6 +1,947 @@
-#include "../../include/LowLevel/HonaLowLevelAPI.h"
+#include <QtConcurrent/QtConcurrent>
 
-HonaLowLevelAPI::HonaLowLevelAPI(QObject *parent) : QObject(parent)
+#include <include/LowLevel/Utils/Utils.h>
+#include "include/LowLevel/HonaLowLevelAPI.h"
+#include "include/Wrapper/PlxWrapper.h"
+
+#include <QDebug>
+
+quint32 HonaLowLevelAPI::packetLenInt4;
+quint32 HonaLowLevelAPI::packetLenRes4;
+quint32 HonaLowLevelAPI::packetLenSinglePulse;
+
+quint32 HonaLowLevelAPI::packetLenInt123C;
+quint32 HonaLowLevelAPI::packetLenRes123C;
+quint32 HonaLowLevelAPI::packetLenIntS;
+quint32 HonaLowLevelAPI::packetLenResS;
+
+quint32 HonaLowLevelAPI::nextInt4;
+quint32 HonaLowLevelAPI::nextRes4;
+quint32 HonaLowLevelAPI::nextSinglePulse;
+
+quint32 HonaLowLevelAPI::nextResS;
+quint32 HonaLowLevelAPI::nextInt123C;
+quint32 HonaLowLevelAPI::nextRes123C;
+quint32 HonaLowLevelAPI::nextIntS;
+
+bool HonaLowLevelAPI::getHsruIsStarted() const
+{
+	return _hsruIsStarted;
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setHsruIsStarted(bool hsruIsStarted)
+{
+	_hsruIsStarted = hsruIsStarted;
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::getHiruIsStarted() const
+{
+	return _hiruIsStarted;
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setHiruIsStarted(bool hiruIsStarted)
+{
+	_hiruIsStarted = hiruIsStarted;
+}
+
+/*************************************************************************************************/
+HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent)
+{
+	packetLenInt4 = 7;
+	packetLenRes4 = 5;
+	packetLenSinglePulse = 5;
+	packetLenInt123C = 6;
+	packetLenRes123C = 6;
+	packetLenIntS = 7;
+	packetLenResS = 7;
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::isHsruStarted()
+{
+	return getHsruIsStarted();
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::isHiruStarted()
+{
+	return getHiruIsStarted();
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::deviceReset()
+{
+	if(!plxWrapper.deviceReset())
+		throw HonaException("Reset Doesnt Occur");
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setConfig(HonaSettings& settings)
+{
+	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
+	{
+		throw HonaException("DeviceReadRegister Doesnt Occur");
+	}
+	_honaSetting = settings;
+	writeSettingToRegisters(settings);
+	if(!plxWrapper.deviceWriteRegister(0x10000000, honaRegisterBuffer))
+	{
+		throw HonaException("DeviceWriteRegister Doesnt Occur");
+	}
+
+	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
+	{
+		throw HonaException("DeviceReadRegister Doesnt Occur");
+	}
+}
+
+/*************************************************************************************************/
+HonaSettings HonaLowLevelAPI::getConfig()
+{
+	return _honaSetting;
+}
+
+/*************************************************************************************************/
+
+QString HonaLowLevelAPI::getSwVersion()
+{
+	return("94072200");
+}
+
+/*************************************************************************************************/
+QString HonaLowLevelAPI::getDeviceId()
+{
+	return("ssr");
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruStart()
+{
+	if(HonaLowLevelAPI::isHsruStarted())
+	{
+		throw HonaAlreadyStartedException(" alreadyStarted");
+	}
+	else
+	{
+		setHsruIsStarted(true);
+		QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruStart()
+{
+	if(!isHiruStarted())
+		throw HonaException("HiruStarted doesn't started ");
+	QtConcurrent::run(this, &HonaLowLevelAPI::hiruMainThread);
+	setHiruIsStarted(true);
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruStop()
+{
+	if(isHiruStarted())
+		setHsruIsStarted(false);
+	_hsruStopEvent.wakeAll();
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::init()
+{
+	if(!plxWrapper.deviceInit(0X9054))
+	{
+		throw HonaException("Init Doesn't Occur");
+	}
+
+	if(!plxWrapper.deviceOpen())
+	{
+		throw HonaException("deviceOpen Doesn't Occur");
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings)
+{
+	honaRegisterBuffer.clear();
+	honaRegisterBuffer.insert(0, 0x00000000);
+	/************************************************************************/
+	if(settings.hiruSettings.recordStard == recorderStart::selfTestCounter)
+		honaRegisterBuffer.insert(0, 0x80000000);
+	else
+		honaRegisterBuffer.insert(0, 0x7FFFFFFF);
+	/************************************************************************/
+	if(settings.hiruSettings.recordChannel == drxDeviceIfChannel::ifChannel12)
+		honaRegisterBuffer.insert(0, 0x20000000);
+	else
+		honaRegisterBuffer.insert(0, 0xDFFFFFFF);
+	/************************************************************************/
+	if(settings.hiruSettings.recordMode == recorderMode::dualChannel)
+		honaRegisterBuffer.insert(0, 0x10000000);
+	else
+		honaRegisterBuffer.insert(0, 0xEFFFFFFF);
+	/************************************************************************/
+
+	honaRegisterBuffer.insert(0,
+							  (honaRegisterBuffer.at(0) +
+							   (settings.hiruSettings.threshold & 0x00000FFF)));
+
+	honaRegisterBuffer.insert(1, settings.hsruSettings.honaInt123CTHR);
+	honaRegisterBuffer.insert(2, settings.hsruSettings.honaRes123CTHR);
+	honaRegisterBuffer.insert(3, settings.hsruSettings.honaIntSTHR);
+	honaRegisterBuffer.insert(4, settings.hsruSettings.honaResSTHR);
+	honaRegisterBuffer.insert(5, settings.hsruSettings.honaSPTHR);
+	honaRegisterBuffer.insert(6, settings.hsruSettings.intM4_THR);
+	honaRegisterBuffer.insert(7, settings.hsruSettings.resM4_THR);
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setConfig()
+{
+	setConfig(_honaSetting);
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruMainThread()
+{
+	//try
+	//{
+	deviceReset();
+	setConfig();
+	deviceReset();
+	if(!plxWrapper.deviceEnableInterrupt())
+	{
+		throw HonaException("DeviceEnableInterrupt Doesnt Occur");
+	}
+
+	QtConcurrent::run(this, &HonaLowLevelAPI::hsruReadThread);
+	QtConcurrent::run(this, &HonaLowLevelAPI::hsruUpdateThread);
+	//}
+	//catch(...)
+	//{
+	//_isHsruReaderThreadFree = true;
+	//_isHsruUpdateThreadFree = true;
+	//hsruStop();
+	//}
+
+	_mutex.lock();
+	_hsruStopEvent.wait(&_mutex);
+	_mutex.unlock();
+	_isHsruReaderThreadFree = true;
+	_isHsruUpdateThreadFree = true;
+
+	if(!plxWrapper.deviceDisableInterrupt())
+	{
+		throw HonaException("DeviceEnableInterrupt Doesnt Occur");
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruReadThread()
+{
+	_hsruLoss = 0;
+	while(true)
+	{
+		if(_isHsruReaderThreadFree)
+			break;
+
+		if(!plxWrapper.deviceWaitForInterrupt(1000))
+		{
+			throw HonaException("DeviceWaitForInterrupt Doesnt Occur");
+		}
+		honaPacketList.clear();
+		_hsruLoss = 0;
+		if(!plxWrapper.deviceOpenPCIChannel())
+		{
+			throw HonaException("DeviceOpenPCIChannel Doesnt Occur");
+		}
+
+		_hsruLoss += hsruParserInt123C(hsruReadHonaBuffer(honaReceivers::int123C),
+									   honaPacketList);
+		_hsruLoss += hsruParserRes123C(hsruReadHonaBuffer(honaReceivers::res123C),
+									   honaPacketList);
+		_hsruLoss += hsruParserIntS(hsruReadHonaBuffer(honaReceivers::intS), honaPacketList);
+		_hsruLoss += hsruParserResS(hsruReadHonaBuffer(honaReceivers::resS), honaPacketList);
+		_hsruLoss += hsruParserInt4(hsruReadHonaBuffer(honaReceivers::int4), honaPacketList);
+		_hsruLoss += hsruParserRes4(hsruReadHonaBuffer(honaReceivers::res4), honaPacketList);
+		_hsruLoss += hsruParserSinglePulse(hsruReadHonaBuffer(honaReceivers::singlePulse),
+										   honaPacketList);
+		if(!plxWrapper.deviceClosePCIChannel())
+		{
+			throw HonaException("DeviceClosePCIChannel Doesnt Occur");
+		}
+		if(!plxWrapper.deviceEnableInterrupt())
+		{
+			throw HonaException("DeviceEnableInterrupt Doesnt Occur");
+		}
+		_mutex.lock();
+		_hsruReadDone.wakeAll();
+		_hsruUpdateAck.wait(&_mutex);
+		_mutex.unlock();
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruUpdateThread()
+{
+	while(true)
+	{
+		_mutex.lock();
+		_hsruReadDone.wait(&_mutex);
+		_mutex.unlock();
+		if(_isHsruUpdateThreadFree)
+			break;
+		quint32 Doa = 0;
+		Doa = hiruGetDOA();
+		emit lowLevelHonaData(honaPacketList, _hsruLoss, Doa);
+		_hsruUpdateAck.wakeAll();
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruMainThread()
+{
+	QtConcurrent::run(this, &HonaLowLevelAPI::hiruReadThread);
+	QtConcurrent::run(this, &HonaLowLevelAPI::hiruUpdateThread);
+	while(true)
+	{
+		_mutex.lock();
+		_hsruStopEvent.wait(&_mutex);
+		_mutex.unlock();
+	}
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruReadThread()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruUpdateThread()
+{
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hiruGetDOA()
+{
+	quint32 Doa = 0;
+	if(!plxWrapper.deviceReadRegister(0x30000004, Doa))
+	{
+		throw HonaException("DeviceReadRegister Doesnt Occur");
+	}
+	Doa = Doa & 0x0000FFFF;
+
+	return Doa;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserInt123C(const QVector<quint32>& honaData,
+										   QList<HonaPacket>& honaPacketList)
+{
+	quint32 lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			HonaPacket tempHonaPacketInt123C;
+			tempHonaPacketInt123C.setPacketType(honaPacketType::interrogationMode123C);
+			packetLenInt123C = 6;
+			tempHonaPacketInt123C.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketInt123C.getPacketNumber() !=
+				(lastPNInt123C + 1)) & (lastPNInt123C > 0))
+			{
+				lossFound +=
+					((tempHonaPacketInt123C.getPacketNumber() - lastPNInt123C + 65536) % 65536 - 1);
+			}
+			lastPNInt123C = tempHonaPacketInt123C.getPacketNumber();
+			if(nextInt123C > 0)
+				lossFound++;
+			nextInt123C = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextInt123C == 1))
+		{
+			tempHonaPacketInt123C.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextInt123C = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextInt123C == 2))
+		{
+			tempHonaPacketInt123C.setToa((tempHonaPacketInt123C.getToa()) +
+										 (static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF) <<
+										  28));
+
+			tempHonaPacketInt123C.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextInt123C = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextInt123C == 3))
+		{
+			tempHonaPacketInt123C.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt123C.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextInt123C = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextInt123C == 4))
+		{
+			tempHonaPacketInt123C.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt123C.setPa2(tempHonaPacketInt123C.getPa2() +
+										 ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketInt123C.setPa3(tempHonaPacketInt123C.getPa3() +
+										 ((honaData[Ind] & 0x00F00000) >> 8));
+			nextInt123C = 5;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextInt123C == 5))
+		{
+			tempHonaPacketInt123C.setCodeM(
+				(static_cast<qulonglong>(honaData[Ind] & 0x0000001F)) << 59);
+			tempHonaPacketInt123C.setCodeL(0);
+			nextInt123C = 6;
+		}
+
+		if(nextInt123C == packetLenInt123C)
+		{
+			if(isValid(tempHonaPacketInt123C))
+			{
+				tempHonaPacketInt123C.setToa((tempHonaPacketInt123C.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketInt123C);
+			}
+			nextInt123C = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserRes123C(const QVector<quint32>& honaData,
+										   QList<HonaPacket>& honaPacketList)
+{
+	quint32 lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			tempHonaPacketRes123C.setPacketType(honaPacketType::responseMode123C);
+			packetLenRes123C = 6;
+			tempHonaPacketRes123C.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketRes123C.getPacketNumber() !=
+				(lastPNRes123C + 1)) & (lastPNRes123C > 0))
+			{
+				lossFound +=
+					((tempHonaPacketRes123C.getPacketNumber() - lastPNRes123C + 65536) % 65536 - 1);
+			}
+			lastPNRes123C = tempHonaPacketRes123C.getPacketNumber();
+			if(nextRes123C > 0)
+				lossFound++;
+			nextRes123C = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextRes123C == 1))
+		{
+			tempHonaPacketRes123C.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextRes123C = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextRes123C == 2))
+		{
+			tempHonaPacketRes123C.setToa(tempHonaPacketRes123C.getToa() +
+										 ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+										  28));
+			tempHonaPacketRes123C.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextRes123C = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextRes123C == 3))
+		{
+			tempHonaPacketRes123C.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes123C.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextRes123C = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextRes123C == 4))
+		{
+			tempHonaPacketRes123C.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes123C.setPa2(tempHonaPacketRes123C.getPa2() +
+										 ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketRes123C.setPa3(tempHonaPacketRes123C.getPa3() +
+										 ((honaData[Ind] & 0x00F00000) >> 8));
+			nextRes123C = 5;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextRes123C == 5))
+		{
+			tempHonaPacketRes123C.setCodeM(
+				(static_cast<qulonglong>(honaData[Ind] & 0x00001FFF)) << 51);
+			tempHonaPacketRes123C.setCodeL(0);
+			nextRes123C = 6;
+		}
+
+		if(nextRes123C == packetLenRes123C)
+		{
+			if(isValid(tempHonaPacketRes123C))
+			{
+				tempHonaPacketRes123C.setToa((tempHonaPacketRes123C.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketRes123C);
+			}
+			nextRes123C = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
+										QList<HonaPacket>& honaPacketList)
+{
+	uint lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			qint32 TypeVal = (honaData[Ind] & 0x00F00000) >> 20;
+			if(TypeVal == 2)
+			{
+				tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS56);
+				packetLenIntS = 7;
+			}
+			else
+			{
+				tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS112);
+				packetLenIntS = 9;
+			}
+			tempHonaPacketIntS.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketIntS.getPacketNumber() != (lastPNIntS + 1)) & (lastPNIntS > 0))
+			{
+				lossFound +=
+					((tempHonaPacketIntS.getPacketNumber() - lastPNIntS + 65536) % 65536 - 1);
+			}
+			lastPNIntS = tempHonaPacketIntS.getPacketNumber();
+			if(nextIntS > 0)
+				lossFound++;
+			nextIntS = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextIntS == 1))
+		{
+			tempHonaPacketIntS.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextIntS = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextIntS == 2))
+		{
+			tempHonaPacketIntS.setToa(tempHonaPacketIntS.getToa() +
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketIntS.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextIntS = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextIntS == 3))
+		{
+			tempHonaPacketIntS.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketIntS.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextIntS = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextIntS == 4))
+		{
+			tempHonaPacketIntS.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketIntS.setPa2(tempHonaPacketIntS.getPa2() + ((honaData[Ind] & 0x000F0000)));
+			tempHonaPacketIntS.setPa3(tempHonaPacketIntS.getPa3() +
+									  ((honaData[Ind] & 0x00F00000) >> 4));
+			nextIntS = 5;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextIntS == 5))
+		{
+			tempHonaPacketIntS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
+			tempHonaPacketIntS.setCodeL(0);
+			nextIntS = 6;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextIntS == 6))
+		{
+			tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
+			tempHonaPacketIntS.setCodeL(0);
+			nextIntS = 7;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x70000000) && (nextIntS == 7))
+		{
+			tempHonaPacketIntS.setCodeL(tempHonaPacketIntS.getCodeM());
+			tempHonaPacketIntS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
+			nextIntS = 8;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x80000000) && (nextIntS == 8))
+		{
+			tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
+			nextIntS = 9;
+		}
+
+		if(nextIntS == packetLenIntS)
+		{
+			if(isValid(tempHonaPacketIntS))
+			{
+				tempHonaPacketIntS.setToa((tempHonaPacketIntS.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketIntS);
+			}
+			nextIntS = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
+										QList<HonaPacket>& honaPacketList)
+{
+	uint lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			qint32 TypeVal = (honaData[Ind] & 0x00F00000) >> 20;
+			if(TypeVal == 4)
+			{
+				tempHonaPacketResS.setPacketType(honaPacketType::responseModeS56);
+				packetLenResS = 7;
+			}
+			else
+			{
+				tempHonaPacketResS.setPacketType(honaPacketType::responseModeS112);
+				packetLenResS = 9;
+			}
+			tempHonaPacketResS.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketResS.getPacketNumber() != (lastPNResS + 1)) & (lastPNResS > 0))
+			{
+				lossFound +=
+					((tempHonaPacketResS.getPacketNumber() - lastPNResS + 65536) % 65536 - 1);
+			}
+			lastPNResS = tempHonaPacketResS.getPacketNumber();
+			if(nextResS > 0)
+				lossFound++;
+			nextResS = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextResS == 1))
+		{
+			tempHonaPacketResS.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextResS = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextResS == 2))
+		{
+			tempHonaPacketResS.setToa(tempHonaPacketResS.getToa() +
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketResS.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextResS = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextResS == 3))
+		{
+			tempHonaPacketResS.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketResS.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextResS = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextResS == 4))
+		{
+			tempHonaPacketResS.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketResS.setPa2(tempHonaPacketResS.getPa2() + ((honaData[Ind] & 0x000F0000)));
+			tempHonaPacketResS.setPa3(tempHonaPacketResS.getPa3() +
+									  ((honaData[Ind] & 0x00F00000) >> 4));
+			nextResS = 5;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextResS == 5))
+		{
+			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
+			tempHonaPacketResS.setCodeL(0);
+			nextResS = 6;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextResS == 6))
+		{
+			tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
+			tempHonaPacketResS.setCodeL(0);
+			nextResS = 7;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x70000000) && (nextResS == 7))
+		{
+			tempHonaPacketResS.setCodeL(tempHonaPacketResS.getCodeM());
+			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
+			nextResS = 8;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x80000000) && (nextResS == 8))
+		{
+			tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
+			nextResS = 9;
+		}
+		if(nextResS == packetLenResS)
+		{
+			if(isValid(tempHonaPacketResS))
+			{
+				tempHonaPacketResS.setToa((tempHonaPacketResS.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketResS);
+			}
+			nextResS = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserInt4(const QVector<quint32>& honaData,
+										QList<HonaPacket>& honaPacketList)
+{
+	uint lossFound = 0;
+
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			tempHonaPacketInt4.setPacketType(honaPacketType::interrogationMode4);
+			packetLenInt4 = 7;
+			tempHonaPacketInt4.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketInt4.getPacketNumber() != (lastPNInt4 + 1)) & (lastPNInt4 > 0))
+			{
+				lossFound +=
+					((tempHonaPacketInt4.getPacketNumber() - lastPNInt4 + 65536) % 65536 - 1);
+			}
+			lastPNInt4 = tempHonaPacketInt4.getPacketNumber();
+			if(nextInt4 > 0)
+				lossFound++;
+			nextInt4 = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextInt4 == 1))
+		{
+			tempHonaPacketInt4.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextInt4 = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextInt4 == 2))
+		{
+			tempHonaPacketInt4.setToa(tempHonaPacketInt4.getToa() +
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketInt4.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextInt4 = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextInt4 == 3))
+		{
+			tempHonaPacketInt4.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt4.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextInt4 = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextInt4 == 4))
+		{
+			tempHonaPacketInt4.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt4.setPa2(tempHonaPacketInt4.getPa2() +
+									  ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketInt4.setPa3(tempHonaPacketInt4.getPa3() +
+									  ((honaData[Ind] & 0x00F00000) >> 8));
+			nextInt4 = 5;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextInt4 == 5))
+		{
+			tempHonaPacketInt4.setCodeM(0);
+			tempHonaPacketInt4.setCodeL(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
+			nextInt4 = 6;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextInt4 == 6))
+		{
+			tempHonaPacketInt4.setPa4(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt4.setCodeL(tempHonaPacketInt4.getCodeL() +
+										((static_cast<qulonglong>(honaData[Ind] & 0x000F0000)) <<
+										 12));
+			tempHonaPacketInt4.setm4Status(static_cast<quint8>((honaData[Ind] & 0x0F000000) >> 20));
+			nextInt4 = 7;
+		}
+
+		if(nextInt4 == packetLenInt4)
+		{
+			if(isValid(tempHonaPacketInt4))
+			{
+				tempHonaPacketInt4.setToa((tempHonaPacketInt4.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketInt4);
+			}
+			nextInt4 = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+quint32 HonaLowLevelAPI::hsruParserRes4(const QVector<quint32>& honaData,
+										QList<HonaPacket>& honaPacketList)
+{
+	uint lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			tempHonaPacketRes4.setPacketType(honaPacketType::responseMode4);
+			packetLenRes4 = 5;
+			tempHonaPacketRes4.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketRes4.getPacketNumber() != (lastPNRes4 + 1)) & (lastPNRes4 > 0))
+			{
+				lossFound +=
+					((tempHonaPacketRes4.getPacketNumber() - lastPNRes4 + 65536) % 65536 - 1);
+			}
+			lastPNRes4 = tempHonaPacketRes4.getPacketNumber();
+			if(nextRes4 > 0)
+				lossFound++;
+			nextRes4 = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextRes4 == 1))
+		{
+			tempHonaPacketRes4.setToa((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)));
+			nextRes4 = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextRes4 == 2))
+		{
+			tempHonaPacketRes4.setToa(tempHonaPacketRes4.getToa() +
+									  (static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF) <<
+									   28));
+			tempHonaPacketRes4.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextRes4 = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextRes4 == 3))
+		{
+			tempHonaPacketRes4.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes4.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextRes4 = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextRes4 == 4))
+		{
+			tempHonaPacketRes4.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes4.setPa2(tempHonaPacketRes4.getPa2() +
+									  ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketRes4.setPa3(tempHonaPacketRes4.getPa3() +
+									  ((honaData[Ind] & 0x00F00000) >> 8));
+			nextRes4 = 5;
+		}
+
+		if(nextRes4 == packetLenRes4)
+		{
+			if(isValid(tempHonaPacketRes4))
+			{
+				tempHonaPacketRes4.setToa((tempHonaPacketRes4.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketRes4);
+			}
+			nextRes4 = 0;
+		}
+	}
+
+	return lossFound;
+}
+
+/*************************************************************************************************/
+quint32 HonaLowLevelAPI::hsruParserSinglePulse(const QVector<quint32>& honaData,
+											   QList<HonaPacket>& honaPacketList)
 {
+	uint lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
+	{
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
+		{
+			tempHonaPacketSinglePulse.setPacketType(honaPacketType::singlePulseMode4);
+			packetLenSinglePulse = 5;
+			tempHonaPacketSinglePulse.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketSinglePulse.getPacketNumber() !=
+				(lastPNSinglePulse + 1)) & (lastPNSinglePulse > 0))
+			{
+				lossFound +=
+					((tempHonaPacketSinglePulse.getPacketNumber() - lastPNSinglePulse + 65536) %
+					 65536 -
+					 1);
+			}
+			lastPNSinglePulse = tempHonaPacketSinglePulse.getPacketNumber();
+			if(nextSinglePulse > 0)
+				lossFound++;
+			nextSinglePulse = 1;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextSinglePulse == 1))
+		{
+			tempHonaPacketSinglePulse.setToa(static_cast<qulonglong>(honaData[Ind] &
+																	 0x0FFFFFFF));
+			nextSinglePulse = 2;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextSinglePulse == 2))
+		{
+			tempHonaPacketSinglePulse.setToa(tempHonaPacketSinglePulse.getToa() +
+											 ((static_cast<qulonglong>(honaData[Ind] &
+																	   0x0000FFFF)) << 28));
+			tempHonaPacketSinglePulse.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextSinglePulse = 3;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextSinglePulse == 3))
+		{
+			tempHonaPacketSinglePulse.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketSinglePulse.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
+			nextSinglePulse = 4;
+		}
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextSinglePulse == 4))
+		{
+			tempHonaPacketSinglePulse.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketSinglePulse.setPa2(tempHonaPacketSinglePulse.getPa2() +
+											 ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketSinglePulse.setPa3(tempHonaPacketSinglePulse.getPa3() +
+											 ((honaData[Ind] & 0x00F00000) >> 8));
+			nextSinglePulse = 5;
+		}
+
+		if(nextSinglePulse == packetLenSinglePulse)
+		{
+			if(isValid(tempHonaPacketSinglePulse))
+			{
+				tempHonaPacketSinglePulse.setToa(
+					(tempHonaPacketSinglePulse.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketSinglePulse);
+			}
+			nextSinglePulse = 0;
+		}
+	}
 
+	return lossFound;
 }
+
+/*************************************************************************************************/
+QVector<quint32> HonaLowLevelAPI::hsruReadHonaBuffer(honaReceivers receiver)
+{
+	QVector<quint32> honaData;
+	honaData.resize(16384);
+	quint32 address = 0;
+
+	if(receiver == honaReceivers::int123C)
+		address = 0X50000000;
+	else if(receiver == honaReceivers::res123C)
+		address = 0X60000000;
+	else if(receiver == honaReceivers::intS)
+		address = 0X70000000;
+	else if(receiver == honaReceivers::resS)
+		address = 0X80000000;
+	else if(receiver == honaReceivers::int4)
+		address = 0X90000000;
+	else if(receiver == honaReceivers::res4)
+		address = 0XA0000000;
+	else if(receiver == honaReceivers::singlePulse)
+		address = 0XB0000000;
+
+	else
+		throw HonaException("honaReceivers is Not Valid");
+
+	if(!plxWrapper.deviceReadMemory(address, honaData, honaData.size()))
+	{
+		throw HonaException("DeviceReadMemory Doesnt Occur");
+	}
+
+	//qDebug() << " hsruReadHonaBuffer  receiver "<< receiver;
+	//for(auto i = 0 ; i < 10; i++)
+	//qDebug() << "[" << i << "] " << "0x" << QString::number(honaData[i], 16);
+	//qDebug() << "------------------------------------------------------------";
+	return honaData;
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::isValid(HonaPacket hp)
+{
+	if(hp.getToa() <= 0)
+		return false;
+
+	return true;
+}
+
+/*************************************************************************************************/

Plx/src/LowLevel/HonaPacket.cpp

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

Plx/src/Wrapper/PlxWrapper.cpp

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

PlxBoard.pro

@@ -1,7 +1,7 @@
 TEMPLATE = subdirs
 
 SUBDIRS += \
-    Plx\
+    Plx \
     Test
 Test.depends += Plx
 

Test/MainWindow.cpp

@@ -1,15 +1,72 @@
 #include "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);
 }
 
 MainWindow::~MainWindow()
 {
-    delete ui;
+	delete ui;
 }
 
+/*************************************************************************************************/
+void MainWindow::honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa)
+{
+	qDebug() << "honaDataResultUi inside " << honaPacketList.length();
+	QString _str;
+	for(auto i = 0; i < honaPacketList.length(); i++)
+	{
+		_str = "[" + QString::number(i) + "] " + "0x hsruLoss" + QString::number(hsruLoss);
+		_str += "\n *********************************************";
+	}
+
+	ui->dataFromMemory->setText(_str);
+}
+
+void MainWindow::on_testPLX_clicked()
+{
+	ApiResult _resultInit = _honaAPI.init();
+	//ApiResult _deviceReset = _honaAPI.deviceReset();
+	//HonaSettings settings;
+	//ApiResult _configResult = _honaAPI.setConfig(settings);
+	//ApiResult isHsruStarted = _honaAPI.isHsruStarted();
+	ApiResult _hsruStartResult = _honaAPI.hsruStart();
+
+	//********************************************************
+	QString temp = ui->errorMonitoring->text();
+	if(_resultInit == ApiResult::error)
+	{
+		ui->errorMonitoring->setText(temp + "\n" + " Error _resultInit");
+	}
+	else if(_resultInit == ApiResult::success)
+	{
+		ui->errorMonitoring->setText(temp + "\n" + "success _resultInit");
+	}
+	//********************************************************
+
+	if(_hsruStartResult == ApiResult::error)
+	{
+		ui->errorMonitoring->setText(temp + "\n" + " Error _hsruStartResult");
+	}
+	else if(_hsruStartResult == ApiResult::success)
+	{
+		ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
+	}
+	//********************************************************
+}
+
+void MainWindow::on_stopHsru_clicked()
+{
+	QString temp = ui->errorMonitoring->text();
+	ApiResult _hsruStop = _honaAPI.hsruStop();
+	if(_hsruStop == ApiResult::error)
+	{
+		ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
+	}
+}

Test/MainWindow.h

@@ -3,19 +3,36 @@
 
 #include <QMainWindow>
 
+#include "API/HonaAPI.h"
+#include "LowLevel/Setting/Setting.h"
+#include "LowLevel/Utils/Utils.h"
+#include "LowLevel/HonaPacket.h"
+
 QT_BEGIN_NAMESPACE
-namespace Ui { class MainWindow; }
+namespace Ui { class MainWindow;
+}
 QT_END_NAMESPACE
 
 class MainWindow : public QMainWindow
 {
-    Q_OBJECT
+	Q_OBJECT
+
+private:
+	Ui::MainWindow* ui;
+	int a;
 
 public:
-    MainWindow(QWidget *parent = nullptr);
+	MainWindow(QWidget* parent = nullptr);
-    ~MainWindow();
+	~MainWindow();
 
+	//uncrustify off
+private	slots:
+	void honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
+	void on_testPLX_clicked();
+	void on_stopHsru_clicked();
+	//uncrustify on:
 private:
-    Ui::MainWindow *ui;
+	//HonaAPI _honaAPI;
 };
-#endif // MAINWINDOW_H
+
+#endif //MAINWINDOW_H

Test/MainWindow.ui

@@ -6,15 +6,87 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>800</width>
+    <width>543</width>
-    <height>600</height>
+    <height>475</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>MainWindow</string>
   </property>
-  <widget class="QWidget" name="centralwidget"/>
+  <widget class="QWidget" name="centralwidget">
-  <widget class="QMenuBar" name="menubar"/>
+   <widget class="QPushButton" name="testPLX">
+    <property name="geometry">
+     <rect>
+      <x>250</x>
+      <y>40</y>
+      <width>89</width>
+      <height>25</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Test PLX</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="label">
+    <property name="geometry">
+     <rect>
+      <x>60</x>
+      <y>30</y>
+      <width>171</width>
+      <height>51</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p align=&quot;center&quot;&gt;&lt;span style=&quot; font-size:20pt;&quot;&gt;Test PLX&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="errorMonitoring">
+    <property name="geometry">
+     <rect>
+      <x>50</x>
+      <y>90</y>
+      <width>411</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>TextLabel</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="stopHsru">
+    <property name="geometry">
+     <rect>
+      <x>390</x>
+      <y>40</y>
+      <width>89</width>
+      <height>25</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>stopHsru</string>
+    </property>
+   </widget>
+   <widget class="QTextEdit" name="dataFromMemory">
+    <property name="geometry">
+     <rect>
+      <x>50</x>
+      <y>160</y>
+      <width>451</width>
+      <height>261</height>
+     </rect>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>543</width>
+     <height>22</height>
+    </rect>
+   </property>
+  </widget>
   <widget class="QStatusBar" name="statusbar"/>
  </widget>
  <resources/>

Test/Test.pro

@@ -34,3 +34,13 @@ PRE_TARGETDEPS += $$OUT_PWD/../Plx/libPlx.a
 qnx: target.path = /tmp/$${TARGET}/bin
 else: unix:!android: target.path = /opt/$${TARGET}/bin
 !isEmpty(target.path): INSTALLS += target
+
+unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
+
+INCLUDEPATH += $$PWD/../../Plxlibrary/Library
+DEPENDPATH += $$PWD/../../Plxlibrary/Library
+
+INCLUDEPATH += $$PWD/../../Plxlibrary
+DEPENDPATH += $$PWD/../../Plxlibrary
+
+unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

Test/main.cpp

@@ -4,8 +4,8 @@
 
 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();
 }

Test2/MainWindow.cpp

@@ -0,0 +1,15 @@
+#include "MainWindow.h"
+#include "ui_MainWindow.h"
+
+MainWindow::MainWindow(QWidget *parent)
+	: QMainWindow(parent)
+	, ui(new Ui::MainWindow)
+{
+	ui->setupUi(this);
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui;
+}
+

Test2/MainWindow.h

@@ -0,0 +1,21 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class MainWindow; }
+QT_END_NAMESPACE
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	MainWindow(QWidget *parent = nullptr);
+	~MainWindow();
+
+private:
+	Ui::MainWindow *ui;
+};
+#endif // MAINWINDOW_H

Test2/MainWindow.ui

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget"/>
+  <widget class="QMenuBar" name="menubar"/>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

Test2/Test2.pro

@@ -0,0 +1,31 @@
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+CONFIG += c++11
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+    main.cpp \
+    MainWindow.cpp
+
+HEADERS += \
+    MainWindow.h
+
+FORMS += \
+    MainWindow.ui
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target

Test2/main.cpp

@@ -0,0 +1,11 @@
+#include "MainWindow.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	MainWindow w;
+	w.show();
+	return a.exec();
+}