Update LAst Change after crash Computer

Plx/Plx.pro

@@ -17,19 +17,13 @@ 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
@@ -38,4 +32,13 @@ unix {
 
 
 
+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

@@ -17,7 +17,14 @@ private:
 	HonaLowLevelAPI _honaLowLevelAPI;
 
 public:
-	explicit HonaAPI(QObject* parent = nullptr);
+	HonaAPI()
+	{
+	}
+
+	~HonaAPI()
+	{
+	}
+
 	ApiResult isHsruStarted();
 	ApiResult isHiruStarted();
 	ApiResult deviceReset();
@@ -32,9 +39,7 @@ public:
 	ApiResult init();
 
 signals:
-	//uncrustify off
-	public	slots:
-	//uncrustify on
+	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/Exception/HonaBusyException.h

@@ -1,24 +0,0 @@
-#ifndef HONABUSYEXCEPTION_H
-#define HONABUSYEXCEPTION_H
-
-#include <QDebug>
-#include <QString>
-
-class HonaBusyException : public std::exception
-{
-private:
-	QString _str;
-
-public:
-	HonaBusyException(QString str)
-	{
-		_str = str;
-	}
-
-	virtual const char* what() const throw()
-	{
-		return _str.toStdString().c_str();
-	}
-};
-
-#endif //HONABUSYEXCEPTION_H

Plx/include/LowLevel/HonaLowLevelAPI.h

@@ -1,26 +1,24 @@
 #ifndef HONALOWLEVELAPI_H
 #define HONALOWLEVELAPI_H
-
 #include <QObject>
-#include "include/LowLevel/Setting/Setting.h"
-#include "include/LowLevel/HonaPacket.h"
-
+#include "LowLevel/Setting/Setting.h"
+#include "LowLevel/HonaPacket.h"
 #include "LowLevel/Setting/Setting.h"
 #include "HonaPacket.h"
 #include "QWaitCondition"
 #include "QMutex"
-#include "include/LowLevel/Exception/HonaAlreadyStartedException.h"
-#include "include/LowLevel/Exception/HonaException.h"
-#include "include/Wrapper/PlxWrapper.h"
-#include "include/LowLevel/Utils/Utils.h"
+#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;
-	bool _hiruIsStarted;
+	bool _hsruIsStarted = false;
+	bool _hiruIsStarted = false;
 	quint32 _hsruLoss;
 	HonaSettings _honaSetting;
 	QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
@@ -77,8 +75,11 @@ private:
 public:
 	qulonglong toaStartBoard = 0;
 
-public:
-	explicit HonaLowLevelAPI(QObject* parent = nullptr);
+	HonaLowLevelAPI(QObject* parent = nullptr);
+	~HonaLowLevelAPI()
+	{
+	}
+
 	bool isHsruStarted();
 	bool isHiruStarted();
 	void deviceReset();
@@ -109,21 +110,23 @@ private:
 	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 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);
+								  QList<HonaPacket>& honaPacketList);
 
 	QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
 
 	bool isValid(HonaPacket hp);
 
+public:
+
 signals:
-	void signalToTop(QList<HonaPacket> honaPacketList, quint32 i, quint32 j);
+	void lowLevelHonaData(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
 
 	//uncrustify off
 public	slots:

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,8 +18,8 @@ private:
 	quint32 m_Pa3;
 	quint32 m_Pa4;
 	quint32 m_Code;
-	quint32 m_CodeL;
-	quint32 m_CodeM;
+	qulonglong m_CodeL;
+	qulonglong m_CodeM;
 	quint8 m4Status;
 
 public:

Plx/include/LowLevel/Setting/Setting.h

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

Plx/include/Wrapper/PlxWrapper.h

@@ -2,33 +2,34 @@
 #define PLXWRAPPER_H
 
 #include <QtGlobal>
-#include "../../plxlib/plxinc/PlxPci_9054_Func.h"
+#include "PlxPci_9054_Func.h"
 
 class PlxWrapper
 {
 public:
-    PlxWrapper();
+	PlxWrapper();
 
-    bool deviceInit(quint32 devicekey);
-    bool deviceOpen(void);
-    bool deviceClose(void);
-    bool deviceReset(void);
-    bool deviceLoadE2pToFPGA(void);
+	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 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 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);
+	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
+
+#endif //PLXWRAPPER_H

Plx/src/API/HonaAPI.cpp

@@ -1,10 +1,7 @@
 #include "include/API/HonaAPI.h"
 
-HonaAPI::HonaAPI(QObject* parent) : QObject(parent)
-{
-}
-
 /*************************************************************************************************/
+
 ApiResult HonaAPI::isHsruStarted()
 {
 	try {
@@ -15,6 +12,8 @@ ApiResult HonaAPI::isHsruStarted()
 	{
 		return ApiResult::error;
 	}
+
+	return ApiResult::success;
 }
 
 /*************************************************************************************************/
@@ -28,6 +27,8 @@ ApiResult HonaAPI::isHiruStarted()
 	{
 		return ApiResult::error;
 	}
+
+	return ApiResult::success;
 }
 
 /*************************************************************************************************/
@@ -165,6 +166,8 @@ ApiResult HonaAPI::hsruStop()
 /*************************************************************************************************/
 ApiResult HonaAPI::init()
 {
+	connect(&_honaLowLevelAPI, &HonaLowLevelAPI::lowLevelHonaData, this, &HonaAPI::honaDataResult);
+
 	try {
 		_honaLowLevelAPI.init();
 	}

Plx/src/LowLevel/HonaLowLevelAPI.cpp

@@ -1,9 +1,28 @@
+#include <QtConcurrent/QtConcurrent>
+
 #include <include/LowLevel/Utils/Utils.h>
 #include "include/LowLevel/HonaLowLevelAPI.h"
 #include "include/Wrapper/PlxWrapper.h"
-#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;
 
 bool HonaLowLevelAPI::getHsruIsStarted() const
 {
@@ -56,7 +75,7 @@ bool HonaLowLevelAPI::isHiruStarted()
 void HonaLowLevelAPI::deviceReset()
 {
 	if(!plxWrapper.deviceReset())
-		throw HonaAlreadyStartedException("Reset Doesnt Occur");
+		throw HonaException("Reset Doesnt Occur");
 }
 
 /*************************************************************************************************/
@@ -64,18 +83,18 @@ void HonaLowLevelAPI::setConfig(HonaSettings& settings)
 {
 	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
 	{
-		throw HonaAlreadyStartedException("DeviceReadRegister Doesnt Occur");
+		throw HonaException("DeviceReadRegister Doesnt Occur");
 	}
 	_honaSetting = settings;
 	writeSettingToRegisters(settings);
 	if(!plxWrapper.deviceWriteRegister(0x10000000, honaRegisterBuffer))
 	{
-		throw HonaAlreadyStartedException("DeviceWriteRegister Doesnt Occur");
+		throw HonaException("DeviceWriteRegister Doesnt Occur");
 	}
 
 	if(!plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8))
 	{
-		throw HonaAlreadyStartedException("DeviceReadRegister Doesnt Occur");
+		throw HonaException("DeviceReadRegister Doesnt Occur");
 	}
 }
 
@@ -101,10 +120,15 @@ QString HonaLowLevelAPI::getDeviceId()
 /*************************************************************************************************/
 void HonaLowLevelAPI::hsruStart()
 {
-	if(!isHsruStarted())
-		throw HonaException("HsruStarted doesn't started ");
-	QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
-	setHsruIsStarted(true);
+	if(HonaLowLevelAPI::isHsruStarted())
+	{
+		throw HonaAlreadyStartedException(" alreadyStarted");
+	}
+	else
+	{
+		setHsruIsStarted(true);
+		QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
+	}
 }
 
 /*************************************************************************************************/
@@ -129,7 +153,12 @@ void HonaLowLevelAPI::init()
 {
 	if(!plxWrapper.deviceInit(0X9054))
 	{
-		throw HonaAlreadyStartedException("Init Doesnt Occur");
+		throw HonaException("Init Doesn't Occur");
+	}
+
+	if(!plxWrapper.deviceOpen())
+	{
+		throw HonaException("deviceOpen Doesn't Occur");
 	}
 }
 
@@ -156,8 +185,8 @@ void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings)
 	/************************************************************************/
 
 	honaRegisterBuffer.insert(0,
-	                          (honaRegisterBuffer.at(0) +
-	                           (settings.hiruSettings.threshold & 0x00000FFF)));
+							  (honaRegisterBuffer.at(0) +
+							   (settings.hiruSettings.threshold & 0x00000FFF)));
 
 	honaRegisterBuffer.insert(1, settings.hsruSettings.honaInt123CTHR);
 	honaRegisterBuffer.insert(2, settings.hsruSettings.honaRes123CTHR);
@@ -177,26 +206,26 @@ void HonaLowLevelAPI::setConfig()
 /*************************************************************************************************/
 void HonaLowLevelAPI::hsruMainThread()
 {
-	try
-	{
-		deviceReset();
-		setConfig();
-		deviceReset();
-		if(!plxWrapper.deviceEnableInterrupt())
-		{
-			throw HonaAlreadyStartedException("DeviceEnableInterrupt Doesnt Occur");
-		}
-
-		QtConcurrent::run(this, &HonaLowLevelAPI::hsruReadThread);
-		QtConcurrent::run(this, &HonaLowLevelAPI::hsruUpdateThread);
-	}
-	catch(...)
+	//try
+	//{
+	deviceReset();
+	setConfig();
+	deviceReset();
+	if(!plxWrapper.deviceEnableInterrupt())
 	{
-		_isHsruReaderThreadFree = true;
-		_isHsruUpdateThreadFree = true;
-		hsruStop();
+		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();
@@ -205,7 +234,7 @@ void HonaLowLevelAPI::hsruMainThread()
 
 	if(!plxWrapper.deviceDisableInterrupt())
 	{
-		throw HonaAlreadyStartedException("DeviceEnableInterrupt Doesnt Occur");
+		throw HonaException("DeviceEnableInterrupt Doesnt Occur");
 	}
 }
 
@@ -220,34 +249,33 @@ void HonaLowLevelAPI::hsruReadThread()
 
 		if(!plxWrapper.deviceWaitForInterrupt(1000))
 		{
-			throw HonaAlreadyStartedException("DeviceWaitForInterrupt Doesnt Occur");
+			throw HonaException("DeviceWaitForInterrupt Doesnt Occur");
 		}
 		honaPacketList.clear();
 		_hsruLoss = 0;
 		if(!plxWrapper.deviceOpenPCIChannel())
 		{
-			throw HonaAlreadyStartedException("DeviceOpenPCIChannel Doesnt Occur");
+			throw HonaException("DeviceOpenPCIChannel Doesnt Occur");
 		}
 
 		_hsruLoss += hsruParserInt123C(hsruReadHonaBuffer(honaReceivers::int123C),
-		                               honaPacketList);
+									   honaPacketList);
 		_hsruLoss += hsruParserRes123C(hsruReadHonaBuffer(honaReceivers::res123C),
-		                               honaPacketList);
+									   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);
+										   honaPacketList);
 		if(!plxWrapper.deviceClosePCIChannel())
 		{
-			throw HonaAlreadyStartedException("DeviceClosePCIChannel Doesnt Occur");
+			throw HonaException("DeviceClosePCIChannel Doesnt Occur");
 		}
 		if(!plxWrapper.deviceEnableInterrupt())
 		{
-			throw HonaAlreadyStartedException("DeviceEnableInterrupt Doesnt Occur");
+			throw HonaException("DeviceEnableInterrupt Doesnt Occur");
 		}
-
 		_mutex.lock();
 		_hsruReadDone.wakeAll();
 		_hsruUpdateAck.wait(&_mutex);
@@ -267,7 +295,7 @@ void HonaLowLevelAPI::hsruUpdateThread()
 			break;
 		quint32 Doa = 0;
 		Doa = hiruGetDOA();
-		emit signalToTop(honaPacketList, _hsruLoss, Doa);
+		emit lowLevelHonaData(honaPacketList, _hsruLoss, Doa);
 		_hsruUpdateAck.wakeAll();
 	}
 }
@@ -301,7 +329,7 @@ quint32 HonaLowLevelAPI::hiruGetDOA()
 	quint32 Doa = 0;
 	if(!plxWrapper.deviceReadRegister(0x30000004, Doa))
 	{
-		throw HonaAlreadyStartedException("DeviceReadRegister Doesnt Occur");
+		throw HonaException("DeviceReadRegister Doesnt Occur");
 	}
 	Doa = Doa & 0x0000FFFF;
 
@@ -310,20 +338,19 @@ quint32 HonaLowLevelAPI::hiruGetDOA()
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserInt123C(const QVector<quint32>& honaData,
-                                           QList<HonaPacket> honaPacketList)
+										   QList<HonaPacket>& honaPacketList)
 {
-	quint32 lossFound;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	quint32 lossFound = 0;
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
 			HonaPacket tempHonaPacketInt123C;
-			tempHonaPacketInt123C.setPacketType(honaPacketType::responseMode123C);
+			tempHonaPacketInt123C.setPacketType(honaPacketType::interrogationMode123C);
 			packetLenInt123C = 6;
-			tempHonaPacketInt123C.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketInt123C.setPacketNumber(honaData[Ind] & 0x0000FFFF);
 			if((tempHonaPacketInt123C.getPacketNumber() !=
-			    (lastPNInt123C + 1)) & (lastPNInt123C > 0))
-			//& (LastPNInt123C != 65535))
+				(lastPNInt123C + 1)) & (lastPNInt123C > 0))
 			{
 				lossFound +=
 					((tempHonaPacketInt123C.getPacketNumber() - lastPNInt123C + 65536) % 65536 - 1);
@@ -333,53 +360,49 @@ quint32 HonaLowLevelAPI::hsruParserInt123C(const QVector<quint32>& honaData,
 				lossFound++;
 			nextInt123C = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextInt123C == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextInt123C == 1))
 		{
-			tempHonaPacketInt123C.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketInt123C.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextInt123C = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextInt123C == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextInt123C == 2))
 		{
-			tempHonaPacketInt123C.setToa(((tempHonaPacketInt123C.getToa()) +
-			                              (qulonglong)((honaData.at(Ind) & 0x0000FFFF) << 28)));
+			tempHonaPacketInt123C.setToa((tempHonaPacketInt123C.getToa()) +
+										 (static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF) <<
+										  28));
 
-			tempHonaPacketInt123C.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketInt123C.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextInt123C = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextInt123C == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextInt123C == 3))
 		{
-			tempHonaPacketInt123C.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketInt123C.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketInt123C.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt123C.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextInt123C = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextInt123C == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextInt123C == 4))
 		{
-			tempHonaPacketInt123C.setPa1(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketInt123C.setPa2((honaData.at(Ind) & 0x000F0000) >> 4);
-			tempHonaPacketInt123C.setPa3((honaData.at(Ind) & 0x00F00000) >> 8);
+			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.at(Ind) & 0xF0000000) == 0x50000000) && (nextInt123C == 5))
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextInt123C == 5))
 		{
-			tempHonaPacketInt123C.setCodeM(((ulong)(honaData.at(Ind) & 0x0000001F)) << 59);
+			tempHonaPacketInt123C.setCodeM(
+				(static_cast<qulonglong>(honaData[Ind] & 0x0000001F)) << 59);
 			tempHonaPacketInt123C.setCodeL(0);
 			nextInt123C = 6;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextInt123C == packetLenInt123C)
 		{
 			if(isValid(tempHonaPacketInt123C))
 			{
-				//tempHonaPacketInt123C.setToa((tempHonaPacketInt123C.getToa()/8)/SimulationSpeed + toaStartBoard);
-				//honaPacketList.append(tempHonaPacketInt123C);
+				tempHonaPacketInt123C.setToa((tempHonaPacketInt123C.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketInt123C);
 			}
 			nextInt123C = 0;
 		}
@@ -390,19 +413,18 @@ quint32 HonaLowLevelAPI::hsruParserInt123C(const QVector<quint32>& honaData,
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserRes123C(const QVector<quint32>& honaData,
-                                           QList<HonaPacket> honaPacketList)
+										   QList<HonaPacket>& honaPacketList)
 {
 	quint32 lossFound = 0;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
-			tempHonaPacketRes123C.setPacketNumber(honaPacketType::responseMode123C);
+			tempHonaPacketRes123C.setPacketType(honaPacketType::responseMode123C);
 			packetLenRes123C = 6;
-			tempHonaPacketRes123C.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketRes123C.setPacketNumber(honaData[Ind] & 0x0000FFFF);
 			if((tempHonaPacketRes123C.getPacketNumber() !=
-			    (lastPNRes123C + 1)) & (lastPNRes123C > 0))
-			//& (LastPNRes123C != 65535))
+				(lastPNRes123C + 1)) & (lastPNRes123C > 0))
 			{
 				lossFound +=
 					((tempHonaPacketRes123C.getPacketNumber() - lastPNRes123C + 65536) % 65536 - 1);
@@ -412,54 +434,48 @@ quint32 HonaLowLevelAPI::hsruParserRes123C(const QVector<quint32>& honaData,
 				lossFound++;
 			nextRes123C = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextRes123C == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextRes123C == 1))
 		{
-			tempHonaPacketRes123C.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketRes123C.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextRes123C = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextRes123C == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextRes123C == 2))
 		{
 			tempHonaPacketRes123C.setToa(tempHonaPacketRes123C.getToa() +
-			                             (((ulong)(honaData.at(Ind) & 0x0000FFFF)) << 28));
-			tempHonaPacketRes123C.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+										 ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+										  28));
+			tempHonaPacketRes123C.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextRes123C = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextRes123C == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextRes123C == 3))
 		{
-			tempHonaPacketRes123C.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketRes123C.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketRes123C.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes123C.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextRes123C = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextRes123C == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextRes123C == 4))
 		{
-			tempHonaPacketRes123C.setPa1(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketRes123C.setPa1(honaData[Ind] & 0x0000FFFF);
 			tempHonaPacketRes123C.setPa2(tempHonaPacketRes123C.getPa2() +
-			                             ((honaData.at(Ind) & 0x000F0000) >> 4));
+										 ((honaData[Ind] & 0x000F0000) >> 4));
 			tempHonaPacketRes123C.setPa3(tempHonaPacketRes123C.getPa3() +
-			                             ((honaData.at(Ind) & 0x00F00000) >> 8));
+										 ((honaData[Ind] & 0x00F00000) >> 8));
 			nextRes123C = 5;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextRes123C == 5))
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextRes123C == 5))
 		{
-			tempHonaPacketRes123C.setCodeM(((ulong)(honaData.at(Ind) & 0x00001FFF)) << 51);
+			tempHonaPacketRes123C.setCodeM(
+				(static_cast<qulonglong>(honaData[Ind] & 0x00001FFF)) << 51);
 			tempHonaPacketRes123C.setCodeL(0);
 			nextRes123C = 6;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextRes123C == packetLenRes123C)
 		{
 			if(isValid(tempHonaPacketRes123C))
 			{
-				//tempHonaPacketRes123C.setDoa((tempHonaPacketRes123C.TOA/8)/SimulationSpeed + toaStartBoard);
-				//honaPacketList.append(tempHonaPacketRes123C);
+				tempHonaPacketRes123C.setToa((tempHonaPacketRes123C.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketRes123C);
 			}
 			nextRes123C = 0;
 		}
@@ -470,14 +486,14 @@ quint32 HonaLowLevelAPI::hsruParserRes123C(const QVector<quint32>& honaData,
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
-                                        QList<HonaPacket> honaPacketList)
+										QList<HonaPacket>& honaPacketList)
 {
 	uint lossFound = 0;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
-			uint TypeVal = (honaData.at(Ind) & 0x00F00000) >> 20;
+			qint32 TypeVal = (honaData[Ind] & 0x00F00000) >> 20;
 			if(TypeVal == 2)
 			{
 				tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS56);
@@ -488,9 +504,8 @@ quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
 				tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS112);
 				packetLenIntS = 9;
 			}
-			tempHonaPacketIntS.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketIntS.setPacketNumber(honaData[Ind] & 0x0000FFFF);
 			if((tempHonaPacketIntS.getPacketNumber() != (lastPNIntS + 1)) & (lastPNIntS > 0))
-			//& (LastPNIntS != 65535))
 			{
 				lossFound +=
 					((tempHonaPacketIntS.getPacketNumber() - lastPNIntS + 65536) % 65536 - 1);
@@ -500,74 +515,67 @@ quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
 				lossFound++;
 			nextIntS = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextIntS == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextIntS == 1))
 		{
-			tempHonaPacketIntS.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketIntS.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextIntS = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextIntS == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextIntS == 2))
 		{
 			tempHonaPacketIntS.setToa(tempHonaPacketIntS.getToa() +
-			                          (((ulong)(honaData.at(Ind) & 0x0000FFFF)) << 28));
-			tempHonaPacketIntS.setToa((honaData.at(Ind) & 0x0FFF0000) >> 16);
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketIntS.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextIntS = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextIntS == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextIntS == 3))
 		{
-			tempHonaPacketIntS.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketIntS.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketIntS.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketIntS.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextIntS = 4;
 		}
-		else if(((honaData.at(static_cast<int>(Ind)) & 0xF0000000) == 0x40000000) &&
-		        (nextIntS == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextIntS == 4))
 		{
-			tempHonaPacketIntS.setPa1(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketIntS.setPa2(tempHonaPacketIntS.getPa2() + ((honaData.at(
-																		  Ind) & 0x000F0000)));
+			tempHonaPacketIntS.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketIntS.setPa2(tempHonaPacketIntS.getPa2() + ((honaData[Ind] & 0x000F0000)));
 			tempHonaPacketIntS.setPa3(tempHonaPacketIntS.getPa3() +
-			                          ((honaData.at(Ind) & 0x00F00000) >> 4));
+									  ((honaData[Ind] & 0x00F00000) >> 4));
 			nextIntS = 5;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextIntS == 5))
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextIntS == 5))
 		{
-			tempHonaPacketIntS.setCodeM(((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 8);
+			tempHonaPacketIntS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
 			tempHonaPacketIntS.setCodeL(0);
 			nextIntS = 6;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextIntS == 6))
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextIntS == 6))
 		{
 			tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
-			                            ((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 36);
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
 			tempHonaPacketIntS.setCodeL(0);
 			nextIntS = 7;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x70000000) && (nextIntS == 7))
+		else if(((honaData[Ind] & 0xF0000000) == 0x70000000) && (nextIntS == 7))
 		{
 			tempHonaPacketIntS.setCodeL(tempHonaPacketIntS.getCodeM());
-			tempHonaPacketIntS.setCodeM(((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 8);
+			tempHonaPacketIntS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
 			nextIntS = 8;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x80000000) && (nextIntS == 8))
+		else if(((honaData[Ind] & 0xF0000000) == 0x80000000) && (nextIntS == 8))
 		{
 			tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
-			                            ((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 36);
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
 			nextIntS = 9;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextIntS == packetLenIntS)
 		{
 			if(isValid(tempHonaPacketIntS))
 			{
-				//tempHonaPacketIntS.setToa( (tempHonaPacketIntS.getToa()/8)/SimulationSpeed + toaStartBoard;
-				//honaPacketList.append(tempHonaPacketIntS);
+				tempHonaPacketIntS.setToa((tempHonaPacketIntS.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketIntS);
 			}
 			nextIntS = 0;
 		}
@@ -578,14 +586,14 @@ quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
-                                        QList<HonaPacket> honaPacketList)
+										QList<HonaPacket>& honaPacketList)
 {
 	uint lossFound = 0;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
-			uint TypeVal = (honaData.at(Ind) & 0x00F00000) >> 20;
+			qint32 TypeVal = (honaData[Ind] & 0x00F00000) >> 20;
 			if(TypeVal == 4)
 			{
 				tempHonaPacketResS.setPacketType(honaPacketType::responseModeS56);
@@ -596,9 +604,8 @@ quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
 				tempHonaPacketResS.setPacketType(honaPacketType::responseModeS112);
 				packetLenResS = 9;
 			}
-			tempHonaPacketResS.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketResS.setPacketNumber(honaData[Ind] & 0x0000FFFF);
 			if((tempHonaPacketResS.getPacketNumber() != (lastPNResS + 1)) & (lastPNResS > 0))
-			//& (LastPNResS != 65535))
 			{
 				lossFound +=
 					((tempHonaPacketResS.getPacketNumber() - lastPNResS + 65536) % 65536 - 1);
@@ -608,78 +615,66 @@ quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
 				lossFound++;
 			nextResS = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextResS == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextResS == 1))
 		{
-			tempHonaPacketResS.setToa(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketResS.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextResS = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextResS == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextResS == 2))
 		{
-			tempHonaPacketResS.setDoa(tempHonaPacketResS.getDoa() +
-			                          ((static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF)) <<
-			                           28));
-			tempHonaPacketResS.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketResS.setToa(tempHonaPacketResS.getToa() +
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketResS.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextResS = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextResS == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextResS == 3))
 		{
-			tempHonaPacketResS.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketResS.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketResS.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketResS.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextResS = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextResS == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextResS == 4))
 		{
-			tempHonaPacketResS.setPa1(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketResS.setPa2(tempHonaPacketResS.getPa2() + ((honaData.at(
-																		  Ind) & 0x000F0000)));
+			tempHonaPacketResS.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketResS.setPa2(tempHonaPacketResS.getPa2() + ((honaData[Ind] & 0x000F0000)));
 			tempHonaPacketResS.setPa3(tempHonaPacketResS.getPa3() +
-			                          ((honaData.at(Ind) & 0x00F00000) >> 4));
+									  ((honaData[Ind] & 0x00F00000) >> 4));
 			nextResS = 5;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextResS == 5))
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextResS == 5))
 		{
-			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData.at(
-																	 Ind) & 0x0FFFFFFF)) << 8);
+			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
 			tempHonaPacketResS.setCodeL(0);
 			nextResS = 6;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextResS == 6))
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextResS == 6))
 		{
 			tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
-			                            (static_cast<qulonglong>(honaData.at(
-																	 Ind) & 0x0FFFFFFF)) << 36);
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
 			tempHonaPacketResS.setCodeL(0);
 			nextResS = 7;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x70000000) && (nextResS == 7))
+		else if(((honaData[Ind] & 0xF0000000) == 0x70000000) && (nextResS == 7))
 		{
 			tempHonaPacketResS.setCodeL(tempHonaPacketResS.getCodeM());
-			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData.at(
-																	 Ind) & 0x0FFFFFFF)) << 8);
+			tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) << 8);
 			nextResS = 8;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x80000000) && (nextResS == 8))
+		else if(((honaData[Ind] & 0xF0000000) == 0x80000000) && (nextResS == 8))
 		{
 			tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
-			                            (static_cast<qulonglong>(honaData.at(
-																	 Ind) & 0x0FFFFFFF)) << 36);
+										(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)) <<
+										36);
 			nextResS = 9;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
-
 		if(nextResS == packetLenResS)
 		{
 			if(isValid(tempHonaPacketResS))
 			{
-				//tempHonaPacketResS.setToa( (tempHonaPacketResS.getToa()/8)/SimulationSpeed + toaStartBoard;
-				//honaPacketList.append(tempHonaPacketResS);
+				tempHonaPacketResS.setToa((tempHonaPacketResS.getToa() / 8) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketResS);
 			}
 			nextResS = 0;
 		}
@@ -690,18 +685,18 @@ quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserInt4(const QVector<quint32>& honaData,
-                                        QList<HonaPacket> honaPacketList)
+										QList<HonaPacket>& honaPacketList)
 {
 	uint lossFound = 0;
 
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
 			tempHonaPacketInt4.setPacketType(honaPacketType::interrogationMode4);
 			packetLenInt4 = 7;
-			tempHonaPacketInt4.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
-			if((tempHonaPacketInt4.getPacketNumber() != (lastPNInt4 + 1)) & (lastPNInt4 > 0)) //& (LastPNInt123C != 65535))
+			tempHonaPacketInt4.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketInt4.getPacketNumber() != (lastPNInt4 + 1)) & (lastPNInt4 > 0))
 			{
 				lossFound +=
 					((tempHonaPacketInt4.getPacketNumber() - lastPNInt4 + 65536) % 65536 - 1);
@@ -711,64 +706,56 @@ quint32 HonaLowLevelAPI::hsruParserInt4(const QVector<quint32>& honaData,
 				lossFound++;
 			nextInt4 = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextInt4 == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextInt4 == 1))
 		{
-			tempHonaPacketInt4.setToa(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketInt4.setToa(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextInt4 = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextInt4 == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextInt4 == 2))
 		{
 			tempHonaPacketInt4.setToa(tempHonaPacketInt4.getToa() +
-			                          ((static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF)) <<
-			                           28));
-			tempHonaPacketInt4.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+									  ((static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF)) <<
+									   28));
+			tempHonaPacketInt4.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextInt4 = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextInt4 == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextInt4 == 3))
 		{
-			tempHonaPacketInt4.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketInt4.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketInt4.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketInt4.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextInt4 = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextInt4 == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextInt4 == 4))
 		{
-			tempHonaPacketInt4.setPa1(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketInt4.setPa1(honaData[Ind] & 0x0000FFFF);
 			tempHonaPacketInt4.setPa2(tempHonaPacketInt4.getPa2() +
-			                          ((honaData.at(Ind) & 0x000F0000) >> 4));
+									  ((honaData[Ind] & 0x000F0000) >> 4));
 			tempHonaPacketInt4.setPa3(tempHonaPacketInt4.getPa3() +
-			                          ((honaData.at(Ind) & 0x00F00000) >> 8));
+									  ((honaData[Ind] & 0x00F00000) >> 8));
 			nextInt4 = 5;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextInt4 == 5))
+		else if(((honaData[Ind] & 0xF0000000) == 0x50000000) && (nextInt4 == 5))
 		{
 			tempHonaPacketInt4.setCodeM(0);
-			tempHonaPacketInt4.setCodeL(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
+			tempHonaPacketInt4.setCodeL(static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF));
 			nextInt4 = 6;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextInt4 == 6))
+		else if(((honaData[Ind] & 0xF0000000) == 0x60000000) && (nextInt4 == 6))
 		{
-			tempHonaPacketInt4.setPa4(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketInt4.setPa4(honaData[Ind] & 0x0000FFFF);
 			tempHonaPacketInt4.setCodeL(tempHonaPacketInt4.getCodeL() +
-			                            ((static_cast<qulonglong>(honaData.at(Ind) & 0x000F0000)) <<
-			                             12));
-			tempHonaPacketInt4.setm4Status((quint8)((honaData.at(Ind) & 0x0F000000) >> 20));
+										((static_cast<qulonglong>(honaData[Ind] & 0x000F0000)) <<
+										 12));
+			tempHonaPacketInt4.setm4Status(static_cast<quint8>((honaData[Ind] & 0x0F000000) >> 20));
 			nextInt4 = 7;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextInt4 == packetLenInt4)
 		{
 			if(isValid(tempHonaPacketInt4))
 			{
-				//tempHonaPacketInt4.setToa((tempHonaPacketInt4.TOA / 6) / SimulationSpeed + toaStartBoard);
-				//honaPacketList.append(tempHonaPacketInt4);
+				tempHonaPacketInt4.setToa((tempHonaPacketInt4.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketInt4);
 			}
 			nextInt4 = 0;
 		}
@@ -778,17 +765,17 @@ quint32 HonaLowLevelAPI::hsruParserInt4(const QVector<quint32>& honaData,
 }
 
 quint32 HonaLowLevelAPI::hsruParserRes4(const QVector<quint32>& honaData,
-                                        QList<HonaPacket> honaPacketList)
+										QList<HonaPacket>& honaPacketList)
 {
 	uint lossFound = 0;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
 			tempHonaPacketRes4.setPacketType(honaPacketType::responseMode4);
 			packetLenRes4 = 5;
-			tempHonaPacketRes4.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
-			if((tempHonaPacketRes4.getPacketNumber() != (lastPNRes4 + 1)) & (lastPNRes4 > 0)) //& (LastPNRes123C != 65535))
+			tempHonaPacketRes4.setPacketNumber(honaData[Ind] & 0x0000FFFF);
+			if((tempHonaPacketRes4.getPacketNumber() != (lastPNRes4 + 1)) & (lastPNRes4 > 0))
 			{
 				lossFound +=
 					((tempHonaPacketRes4.getPacketNumber() - lastPNRes4 + 65536) % 65536 - 1);
@@ -798,49 +785,41 @@ quint32 HonaLowLevelAPI::hsruParserRes4(const QVector<quint32>& honaData,
 				lossFound++;
 			nextRes4 = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextRes4 == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextRes4 == 1))
 		{
-			tempHonaPacketRes4.setToa((static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF)));
+			tempHonaPacketRes4.setToa((static_cast<qulonglong>(honaData[Ind] & 0x0FFFFFFF)));
 			nextRes4 = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextRes4 == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextRes4 == 2))
 		{
 			tempHonaPacketRes4.setToa(tempHonaPacketRes4.getToa() +
-			                          (static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF) <<
-			                           28));
-			tempHonaPacketRes4.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+									  (static_cast<qulonglong>(honaData[Ind] & 0x0000FFFF) <<
+									   28));
+			tempHonaPacketRes4.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextRes4 = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextRes4 == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextRes4 == 3))
 		{
-			tempHonaPacketRes4.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketRes4.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketRes4.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes4.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextRes4 = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextRes4 == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextRes4 == 4))
 		{
-			tempHonaPacketRes4.setPa1(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketRes4.setPa2(tempHonaPacketRes4.getPa2() + (honaData.at(
-																		 Ind) & 0x000F0000) >> 4);        //NOTE: shifted by 4
-			tempHonaPacketRes4.setPa3(tempHonaPacketRes4.getPa3() + (honaData.at(
-																		 Ind) & 0x00F00000) >> 8);        //NOTE: shifted by 8
+			tempHonaPacketRes4.setPa1(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketRes4.setPa2(tempHonaPacketRes4.getPa2() +
+									  ((honaData[Ind] & 0x000F0000) >> 4));
+			tempHonaPacketRes4.setPa3(tempHonaPacketRes4.getPa3() +
+									  ((honaData[Ind] & 0x00F00000) >> 8));
 			nextRes4 = 5;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextRes4 == packetLenRes4)
 		{
 			if(isValid(tempHonaPacketRes4))
 			{
-				//tempHonaPacketRes4.setToa((tempHonaPacketRes4.getToa() / 6) / SimulationSpeed + toaStartBoard);
-				//honaPacketList.append(tempHonaPacketRes4);
+				tempHonaPacketRes4.setToa((tempHonaPacketRes4.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketRes4);
 			}
 			nextRes4 = 0;
 		}
@@ -851,19 +830,18 @@ quint32 HonaLowLevelAPI::hsruParserRes4(const QVector<quint32>& honaData,
 
 /*************************************************************************************************/
 quint32 HonaLowLevelAPI::hsruParserSinglePulse(const QVector<quint32>& honaData,
-                                               QList<HonaPacket> honaPacketList)
+											   QList<HonaPacket>& honaPacketList)
 {
 	uint lossFound = 0;
-	for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
+	for(qint32 Ind = 0; Ind < honaData.length(); Ind++)
 	{
-		if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
+		if((honaData[Ind] & 0xFF000000) == 0x0F000000)
 		{
 			tempHonaPacketSinglePulse.setPacketType(honaPacketType::singlePulseMode4);
 			packetLenSinglePulse = 5;
-			tempHonaPacketSinglePulse.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketSinglePulse.setPacketNumber(honaData[Ind] & 0x0000FFFF);
 			if((tempHonaPacketSinglePulse.getPacketNumber() !=
-			    (lastPNSinglePulse + 1)) & (lastPNSinglePulse > 0))
-				;
+				(lastPNSinglePulse + 1)) & (lastPNSinglePulse > 0))
 			{
 				lossFound +=
 					((tempHonaPacketSinglePulse.getPacketNumber() - lastPNSinglePulse + 65536) %
@@ -875,50 +853,43 @@ quint32 HonaLowLevelAPI::hsruParserSinglePulse(const QVector<quint32>& honaData,
 				lossFound++;
 			nextSinglePulse = 1;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextSinglePulse == 1))
+		else if(((honaData[Ind] & 0xF0000000) == 0x10000000) && (nextSinglePulse == 1))
 		{
-			tempHonaPacketSinglePulse.setToa(static_cast<qulonglong>(honaData.at(Ind) &
-			                                                         0x0FFFFFFF));
+			tempHonaPacketSinglePulse.setToa(static_cast<qulonglong>(honaData[Ind] &
+																	 0x0FFFFFFF));
 			nextSinglePulse = 2;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextSinglePulse == 2))
+		else if(((honaData[Ind] & 0xF0000000) == 0x20000000) && (nextSinglePulse == 2))
 		{
 			tempHonaPacketSinglePulse.setToa(tempHonaPacketSinglePulse.getToa() +
-			                                 ((static_cast<qulonglong>(honaData.at(Ind) &
-			                                                           0x0000FFFF)) << 28));
-			tempHonaPacketSinglePulse.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
+											 ((static_cast<qulonglong>(honaData[Ind] &
+																	   0x0000FFFF)) << 28));
+			tempHonaPacketSinglePulse.setPa2((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextSinglePulse = 3;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextSinglePulse == 3))
+		else if(((honaData[Ind] & 0xF0000000) == 0x30000000) && (nextSinglePulse == 3))
 		{
-			tempHonaPacketSinglePulse.setDoa(honaData.at(Ind) & 0x0000FFFF);
-			tempHonaPacketSinglePulse.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
+			tempHonaPacketSinglePulse.setDoa(honaData[Ind] & 0x0000FFFF);
+			tempHonaPacketSinglePulse.setPa3((honaData[Ind] & 0x0FFF0000) >> 16);
 			nextSinglePulse = 4;
 		}
-		else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextSinglePulse == 4))
+		else if(((honaData[Ind] & 0xF0000000) == 0x40000000) && (nextSinglePulse == 4))
 		{
-			tempHonaPacketSinglePulse.setPa1(honaData.at(Ind) & 0x0000FFFF);
+			tempHonaPacketSinglePulse.setPa1(honaData[Ind] & 0x0000FFFF);
 			tempHonaPacketSinglePulse.setPa2(tempHonaPacketSinglePulse.getPa2() +
-			                                 ((honaData.at(Ind) & 0x000F0000) >> 4));                                     //NOTE: shifted by 4
+											 ((honaData[Ind] & 0x000F0000) >> 4));
 			tempHonaPacketSinglePulse.setPa3(tempHonaPacketSinglePulse.getPa3() +
-			                                 ((honaData.at(Ind) & 0x00F00000) >> 8));                                     //NOTE: shifted by 8
+											 ((honaData[Ind] & 0x00F00000) >> 8));
 			nextSinglePulse = 5;
 		}
-		else if(honaData.at(Ind) == 0xEEEEEEEE)
-		{
-			//Console.Write("-");
-		}
-		else
-		{
-			//Console.Write(".");
-		}
 
 		if(nextSinglePulse == packetLenSinglePulse)
 		{
 			if(isValid(tempHonaPacketSinglePulse))
 			{
-				//tempHonaPacketSinglePulse.setToa((tempHonaPacketSinglePulse.getToa() / 6) / SimulationSpeed + toaStartBoard);
-				//honaPacketList.append(tempHonaPacketSinglePulse);
+				tempHonaPacketSinglePulse.setToa(
+					(tempHonaPacketSinglePulse.getToa() / 6) + toaStartBoard);
+				honaPacketList.append(tempHonaPacketSinglePulse);
 			}
 			nextSinglePulse = 0;
 		}
@@ -942,11 +913,11 @@ QVector<quint32> HonaLowLevelAPI::hsruReadHonaBuffer(honaReceivers receiver)
 		address = 0X70000000;
 	else if(receiver == honaReceivers::resS)
 		address = 0X80000000;
-	else if(receiver == honaReceivers::int4) //Mode4 :: added by H.H
+	else if(receiver == honaReceivers::int4)
 		address = 0X90000000;
-	else if(receiver == honaReceivers::res4) //Mode4 :: added by H.H
+	else if(receiver == honaReceivers::res4)
 		address = 0XA0000000;
-	else if(receiver == honaReceivers::singlePulse) //Mode4 :: added by H.H
+	else if(receiver == honaReceivers::singlePulse)
 		address = 0XB0000000;
 
 	else
@@ -954,9 +925,13 @@ QVector<quint32> HonaLowLevelAPI::hsruReadHonaBuffer(honaReceivers receiver)
 
 	if(!plxWrapper.deviceReadMemory(address, honaData, honaData.size()))
 	{
-		throw HonaAlreadyStartedException("DeviceReadMemory Doesnt Occur");
+		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;
 }
 

Plx/src/LowLevel/HonaPacket.cpp

@@ -1,4 +1,4 @@
-#include "../../include/LowLevel/HonaPacket.h"
+#include "LowLevel/HonaPacket.h"
 
 HonaPacket::HonaPacket()
 {
@@ -126,3 +126,14 @@ void HonaPacket::setCodeM(quint32 temp)
 }
 
 /*************************************************************************************************/
+quint8 HonaPacket::getm4Status()
+{
+	return m4Status;
+}
+
+void HonaPacket::setm4Status(quint8 temp)
+{
+	m4Status = temp;
+}
+
+/*************************************************************************************************/

Plx/src/Wrapper/PlxWrapper.cpp

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

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,6 +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,6 +3,11 @@
 
 #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;
 }
@@ -12,16 +17,22 @@ class MainWindow : public QMainWindow
 {
 	Q_OBJECT
 
+private:
+	Ui::MainWindow* ui;
+	int a;
+
 public:
 	MainWindow(QWidget* parent = nullptr);
 	~MainWindow();
 
 	//uncrustify off
 private	slots:
-		void on_testPLX_clicked();
-	//uncrustify on
+	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,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>311</width>
-    <height>281</height>
+    <width>543</width>
+    <height>475</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,8 +17,8 @@
    <widget class="QPushButton" name="testPLX">
     <property name="geometry">
      <rect>
-      <x>100</x>
-      <y>120</y>
+      <x>250</x>
+      <y>40</y>
       <width>89</width>
       <height>25</height>
      </rect>
@@ -40,13 +40,49 @@
      <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>311</width>
+     <width>543</width>
      <height>22</height>
     </rect>
    </property>

Test/Test.pro

@@ -22,10 +22,25 @@ SOURCES += \
 HEADERS += \
     MainWindow.h
 
+INCLUDEPATH += $$PWD/../Plx/include
+
 FORMS += \
     MainWindow.ui
 
+LIBS += -L$$OUT_PWD/../Plx/ -lPlx
+PRE_TARGETDEPS += $$OUT_PWD/../Plx/libPlx.a
+
 # Default rules for deployment.
 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();
+}