Merge branch 'heydari' of http://194.5.205.38:3000/h-4nd-h/plx into mehrabi

Plx/Plx.pro

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

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

@@ -13,10 +13,13 @@ public:
 	HonaAlreadyStartedException(QString str)
 	{
 		_str = str;
+		qDebug() << "HonaAlreadyStartedException " << str;
 	}
 
 	virtual const char* what() const throw()
 	{
+		qDebug() << "HonaAlreadyStartedException return   " << _str;
+
 		return _str.toStdString().c_str();
 	}
 };

Plx/include/LowLevel/HonaLowLevelAPI.h

@@ -1,31 +1,41 @@
-#ifndef HONALOWLEVELAPI_H
+#ifndef HONALOWLEVELAPI_H
 #define HONALOWLEVELAPI_H
-
 #include <QObject>
-#include "include/LowLevel/Setting/Setting.h"
+#include "LowLevel/Setting/Setting.h"
-#include "include/LowLevel/HonaPacket.h"
+#include "LowLevel/HonaPacket.h"
-
 #include "LowLevel/Setting/Setting.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/HonaException.h"
+#include "Wrapper/PlxWrapper.h"
+#include "LowLevel/Utils/Utils.h"
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
 
 class HonaLowLevelAPI : public QObject
 {
 	Q_OBJECT
 
 private:
-	bool _hsruIsStarted;
+	bool _hsruIsStarted = false;
-	bool _hiruIsStarted;
+	bool _hiruIsStarted = false;
+	quint32 _hsruLoss;
 	HonaSettings _honaSetting;
-	QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent;
+	QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
+				   _hiruUpdateAck1;
+
+	QList<HonaPacket> honaPacketList;
 	QMutex _mutex;
 	int _threadSforValue = 0;
+<<<<<<< HEAD
 	bool _isReaderThreadFree = false;
 	bool _isUpdateThreadFree = false;
     QVector<quint32> honaRegisterBuffer;
@@ -38,20 +48,72 @@ private:
     static quint32 packetLenRes123C;
     static quint32 packetLenIntS;
     static quint32 packetLenResS;
+=======
+	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;
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
 
 public:
-	explicit HonaLowLevelAPI(QObject* parent = nullptr);
+	qulonglong toaStartBoard = 0;
+
+	HonaLowLevelAPI(QObject* parent = nullptr);
+	~HonaLowLevelAPI()
+	{
+	}
+
 	bool isHsruStarted();
 	bool isHiruStarted();
 	void deviceReset();
 
-	void setConfig(HonaSettings* honaSetting);
+	void setConfig(HonaSettings& settings);
 	HonaSettings getConfig();
 	QString getSwVersion();
 	QString getDeviceId();
 	void hsruStart();
-
 	void hiruStart();
+	void hsruStop();
 	void init();
 
 	bool getHsruIsStarted() const;
@@ -66,14 +128,33 @@ private:
 	void hsruMainThread();
 	void hsruReadThread();
 	void hsruUpdateThread();
-	int hiruGetDOA();
+	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:
 
     void hsruReaderMethod();
     QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
     quint32 hsruParserInt123C(quint32 honaData,QList<HonaPacket> honaPacketList);
 
 signals:
-	void signalToTop(QList<HonaPacket*> honaPacketList, int i, int j);
+	void lowLevelHonaData(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
+
 	//uncrustify off
 public	slots:
 	//uncrustify on

Plx/include/LowLevel/HonaPacket.h

@@ -3,7 +3,7 @@
 
 #include <QtGlobal>
 
-#include "include/LowLevel/Utils/Utils.h"
+#include "LowLevel/Utils/Utils.h"
 
 class HonaPacket
 {
@@ -18,14 +18,15 @@ private:
 	quint32 m_Pa3;
 	quint32 m_Pa4;
 	quint32 m_Code;
-	quint32 m_CodeL;
+	qulonglong m_CodeL;
-	quint32 m_CodeM;
+	qulonglong m_CodeM;
+	quint8 m4Status;
 
 public:
 	HonaPacket();
 	/******************************************************************/
 	honaPacketType getPacketType();
-	void setPacketType(honaPacketType& temp);
+	void setPacketType(honaPacketType temp);
 	/******************************************************************/
 	quint32 getPacketNumber();
 	void setPacketNumber(quint32 temp);
@@ -57,6 +58,9 @@ public:
 	quint32 getCodeM();
 	void setCodeM(quint32 temp);
 	/******************************************************************/
+	quint8 getm4Status();
+	void setm4Status(quint8 temp);
+	/******************************************************************/
 };
 
 #endif //HONAPACKET_H

Plx/include/LowLevel/Setting/Setting.h

@@ -3,10 +3,9 @@
 
 #include <QtGlobal>
 #include <QList>
-#include "include/LowLevel/Utils/Utils.h"
+
-#include <QtGlobal>
+#include "LowLevel/Utils/Utils.h"
-#include <QList>
+
-#include "include/LowLevel/Utils/Utils.h"
 /***********************************************************************************************/
 struct hiruSettings_t
 {

Plx/include/LowLevel/Utils/Utils.h

@@ -4,23 +4,25 @@
 #include <QtCore>
 
 /*************************************************************************************************/
-enum apiResult : quint8
+enum ApiResult : quint8
 {
 	success,
 	alreadyStarted,
 	busy,
 	error
 };
+
 /*************************************************************************************************/
 enum drxDeviceIfChannel : quint8
 {
 	ifChannel11,
 	ifChannel12
-
 };
+
 /*************************************************************************************************/
 enum honaReceivers : quint8
 {
+<<<<<<< HEAD
     int123C,
     res123C,
     intS,
@@ -29,20 +31,31 @@ enum honaReceivers : quint8
     res4,           //Mode 4
     singlePulse     //Mode 4
 
+=======
+	int123C,
+	res123C,
+	intS,
+	resS,
+	int4,           //Mode 4
+	res4,           //Mode 4
+	singlePulse     //Mode 4
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
 };
+
 /*************************************************************************************************/
 enum recorderMode : quint8
 {
 	signalChannel,
 	dualChannel
-
 };
+
 /*************************************************************************************************/
 enum  recorderStart : quint8
 {
 	selfTestCounter = 1,
 	freeRunRecording = 2
 };
+
 /*************************************************************************************************/
 enum honaPacketType : quint8
 {
@@ -56,9 +69,15 @@ enum honaPacketType : quint8
 	responseModeS112,
 
 	responseMode4,
-    signalPulseMode4
+	singlePulseMode4
-
 };
+<<<<<<< HEAD
+/*************************************************************************************************/
+
+#endif // UTILS_H
+=======
+
 /*************************************************************************************************/
 
 #endif //UTILS_H
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126

Plx/include/Wrapper/PlxWrapper.h

@@ -2,6 +2,7 @@
 #define PLXWRAPPER_H
 #include <QtGlobal>
 #include "PlxPci_9054_Func.h"
+<<<<<<< HEAD
 class PlxWrapper
 {
 public:
@@ -28,6 +29,35 @@ public:
         bool deviceDisableInterrupt(void);
         bool deviceWaitForInterrupt(quint32 timeout);
         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

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/HonaLowLevelAPI.cpp

@@ -1,10 +1,34 @@
+#include <QtConcurrent/QtConcurrent>
+
 #include <include/LowLevel/Utils/Utils.h>
 #include "include/LowLevel/HonaLowLevelAPI.h"
 #include "include/Wrapper/PlxWrapper.h"
 
+<<<<<<< HEAD
 #include "qdebug.h"
 #include "QTime"
 #include "QtConcurrent/QtConcurrent"
+=======
+#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;
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
 
 bool HonaLowLevelAPI::getHsruIsStarted() const
 {
@@ -32,6 +56,13 @@ void HonaLowLevelAPI::setHiruIsStarted(bool hiruIsStarted)
 /*************************************************************************************************/
 HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent)
 {
+	packetLenInt4 = 7;
+	packetLenRes4 = 5;
+	packetLenSinglePulse = 5;
+	packetLenInt123C = 6;
+	packetLenRes123C = 6;
+	packetLenIntS = 7;
+	packetLenResS = 7;
 }
 
 /*************************************************************************************************/
@@ -49,82 +80,98 @@ bool HonaLowLevelAPI::isHiruStarted()
 /*************************************************************************************************/
 void HonaLowLevelAPI::deviceReset()
 {
-	//ApiResult status;
+	if(!plxWrapper.deviceReset())
-	//if(ApiResult::success)
+		throw HonaException("Reset Doesnt Occur");
-	//{
+}
-	//}
-	/*
-	   QTime t;
-	   t.elapsed()
-
-	   PLX_STATUS status = base.DeviceReset();
-	   qDebug() << "Board Reseted, status: " + status.ToString());
 
-	   if (status == PLX_STATUS.ApiSuccess)
+/*************************************************************************************************/
+void HonaLowLevelAPI::setConfig(HonaSettings& settings)
 {
-		toaStartBoard = (ulong) (DateTime.Now.Ticks);
+	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
-		return ApiResult.Success;
+	{
+		throw HonaException("DeviceReadRegister Doesnt Occur");
 	}
-	   else
+	_honaSetting = settings;
-		return ApiResult.Error; */
+	writeSettingToRegisters(settings);
+	if(!plxWrapper.deviceWriteRegister(0x10000000, honaRegisterBuffer))
+	{
+		throw HonaException("DeviceWriteRegister Doesnt Occur");
 	}
 
-/*************************************************************************************************/
+	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
-void HonaLowLevelAPI::setConfig(HonaSettings* honaSetting)
 	{
-	//Initial State Checking
+		throw HonaException("DeviceReadRegister Doesnt Occur");
-	/*
+	}
-	   HonaRegisterBuffer = new uint[8];  // Mode4 :: changed from 5 to 8 by H.H
-	   DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer);
-
-	   _honaSetting = Settings;
-	   HonaFillRegisters(Settings);
-	   DeviceWriteRegisters(0x10000000, HonaRegisterBuffer);
-
-	   HonaRegisterBuffer = new uint[8];  // Mode4 :: changed from 5 to 8 by H.H
-	   DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer);
-
-	   return ApiResult.Success; */
 }
 
 /*************************************************************************************************/
 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())
+	if(!isHiruStarted())
-		//exceptiom
+		throw HonaException("HiruStarted doesn't started ");
+	QtConcurrent::run(this, &HonaLowLevelAPI::hiruMainThread);
+	setHiruIsStarted(true);
+}
 
-		QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
+/*************************************************************************************************/
+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)
 {
+<<<<<<< HEAD
     honaRegisterBuffer.clear();
     honaRegisterBuffer.insert(0,0x00000000);
     /************************************************************************/
@@ -153,35 +200,119 @@ void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings)
     honaRegisterBuffer.insert(5,settings.hsruSettings.honaSPTHR);
     honaRegisterBuffer.insert(6,settings.hsruSettings.intM4_THR);
     honaRegisterBuffer.insert(7,settings.hsruSettings.resM4_THR);
+=======
+	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);
+>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
 }
 
 /*************************************************************************************************/
 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;
 
-	_isReaderThreadFree = true;
+	if(!plxWrapper.deviceDisableInterrupt())
-	_isUpdateThreadFree = true;
+	{
+		throw HonaException("DeviceEnableInterrupt Doesnt Occur");
+	}
 }
 
 /*************************************************************************************************/
 void HonaLowLevelAPI::hsruReadThread()
 {
+	_hsruLoss = 0;
 	while(true)
 	{
-		if(_isReaderThreadFree)
+		if(_isHsruReaderThreadFree)
 			break;
-		//dosth
+
+		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);
@@ -197,16 +328,657 @@ void HonaLowLevelAPI::hsruUpdateThread()
 		_mutex.lock();
 		_hsruReadDone.wait(&_mutex);
 		_mutex.unlock();
-		if(_isUpdateThreadFree)
+		if(_isHsruUpdateThreadFree)
 			break;
-		//dosth
+		quint32 Doa = 0;
+		Doa = hiruGetDOA();
+		emit lowLevelHonaData(honaPacketList, _hsruLoss, Doa);
 		_hsruUpdateAck.wakeAll();
 	}
 }
 
 /*************************************************************************************************/
-int HonaLowLevelAPI::hiruGetDOA()
+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(void)
+honaPacketType HonaPacket::getPacketType()
 {
 	return m_PacketType;
 }
- void HonaPacket::setPacketType(honaPacketType &temp)
+
+void HonaPacket::setPacketType(honaPacketType temp)
 {
 	m_PacketType = temp;
 }
+
 /*************************************************************************************************/
- quint32 HonaPacket::getPacketNumber(void)
+quint32 HonaPacket::getPacketNumber()
 {
 	return m_PacketNumber;
 }
+
 void HonaPacket::setPacketNumber(quint32 temp)
 {
 	m_PacketNumber = temp;
 }
+
 /*************************************************************************************************/
-  qulonglong HonaPacket::getToa(void)
+qulonglong HonaPacket::getToa()
 {
 	return m_Toa;
 }
+
 void HonaPacket::setToa(qulonglong temp)
 {
 	m_Toa = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getDoa(void)
+quint32 HonaPacket::getDoa()
 {
 	return m_Doa;
 }
+
 void HonaPacket::setDoa(quint32 temp)
 {
 	m_Doa = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getPa1(void)
+quint32 HonaPacket::getPa1()
 {
 	return m_Pa1;
 }
+
 void HonaPacket::setPa1(quint32 temp)
 {
 	m_Pa1 = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getPa2(void)
+quint32 HonaPacket::getPa2()
 {
 	return m_Pa2;
 }
+
 void HonaPacket::setPa2(quint32 temp)
 {
 	m_Pa2 = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getPa3(void)
+quint32 HonaPacket::getPa3()
 {
 	return m_Pa3;
 }
+
 void HonaPacket::setPa3(quint32 temp)
 {
 	m_Pa3 = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getPa4(void)
+quint32 HonaPacket::getPa4()
 {
 	return m_Pa4;
 }
+
 void HonaPacket::setPa4(quint32 temp)
 {
 	m_Pa4 = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getCode(void)
+quint32 HonaPacket::getCode()
 {
 	return m_Code;
 }
+
 void HonaPacket::setCode(quint32 temp)
 {
 	m_Code = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getCodeL(void)
+quint32 HonaPacket::getCodeL()
 {
 	return m_CodeL;
 }
+
 void HonaPacket::setCodeL(quint32 temp)
 {
 	m_CodeL = temp;
 }
+
 /*************************************************************************************************/
-  quint32 HonaPacket::getCodeM(void)
+quint32 HonaPacket::getCodeM()
 {
 	return m_CodeM;
 }
+
 void HonaPacket::setCodeM(quint32 temp)
 {
 	m_CodeM = temp;
 }
+
+/*************************************************************************************************/
+quint8 HonaPacket::getm4Status()
+{
+	return m4Status;
+}
+
+void HonaPacket::setm4Status(quint8 temp)
+{
+	m4Status = temp;
+}
+
 /*************************************************************************************************/

Plx/src/Wrapper/PlxWrapper.cpp

@@ -1,37 +1,43 @@
 #include <QDebug>
 #include <QVector>
+
 #include "include/Wrapper/PlxWrapper.h"
 
 PlxWrapper::PlxWrapper()
 {
-
 }
+
 /*************************************************************************************************/
 bool PlxWrapper::deviceInit(quint32 devicekey)
 {
 	return PlxPci_9054_SelDevice(devicekey);
 }
+
 /*************************************************************************************************/
-bool PlxWrapper::deviceOpen(void)
+bool PlxWrapper::deviceOpen()
 {
 	return PlxPci_9054_Open();
 }
+
 /*************************************************************************************************/
 
-bool PlxWrapper::deviceClose(void)
+bool PlxWrapper::deviceClose()
 {
 	return PlxPci_9054_Close();
 }
+
 /*************************************************************************************************/
-bool PlxWrapper::deviceReset(void)
+bool PlxWrapper::deviceReset()
 {
 	return PlxPci_9054_Reset();
 }
+
 /*************************************************************************************************/
-bool PlxWrapper::deviceLoadE2pToFPGA(void)
+bool PlxWrapper::deviceLoadE2pToFPGA()
 {
 	return PlxPci_9054_LoadE2pToFPGA();
 }
+
 /*************************************************************************************************/
 bool PlxWrapper::deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data)
 {
@@ -44,13 +50,16 @@ bool PlxWrapper::deviceReadEeprom(quint16 offset,quint32 length, QVector<quint32
 		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)
 {
@@ -67,13 +76,16 @@ bool PlxWrapper::deviceReadRegister(quint32 address,QVector<quint32> &data,quint
 			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)
 {
@@ -88,11 +100,13 @@ bool PlxWrapper::deviceWriteRegister(quint32 address,QVector<quint32> &data)
 
 	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)
 {
@@ -107,32 +121,38 @@ bool PlxWrapper::deviceReadMemory(quint32 localAddress ,QVector<quint32> &data,q
 
 	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)
 {

Test/MainWindow.cpp

@@ -1,11 +1,13 @@
 #include "MainWindow.h"
 #include "ui_MainWindow.h"
+HonaAPI _honaAPI;
 
 MainWindow::MainWindow(QWidget* parent)
 	: QMainWindow(parent)
 	, ui(new Ui::MainWindow)
 {
 	ui->setupUi(this);
+	connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
 }
 
 MainWindow::~MainWindow()
@@ -13,3 +15,58 @@ MainWindow::~MainWindow()
 	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
 
+private:
+	Ui::MainWindow* ui;
+	int a;
+
 public:
 	MainWindow(QWidget* parent = nullptr);
 	~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

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

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();
+}