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

Update LAst Change after crash Computer

heydari
Alireza 3 years ago
parent
e806f5dca5
commit
64f6e7f618
21 changed files with 662 additions and 447 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 19
      Plx/Plx.pro
  2. 13
      Plx/include/API/HonaAPI.h
  3. 3
      Plx/include/LowLevel/Exception/HonaAlreadyStartedException.h
  4. 24
      Plx/include/LowLevel/Exception/HonaBusyException.h
  5. 43
      Plx/include/LowLevel/HonaLowLevelAPI.h
  6. 6
      Plx/include/LowLevel/HonaPacket.h
  7. 7
      Plx/include/LowLevel/Setting/Setting.h
  8. 43
      Plx/include/Wrapper/PlxWrapper.h
  9. 11
      Plx/src/API/HonaAPI.cpp
  10. 549
      Plx/src/LowLevel/HonaLowLevelAPI.cpp
  11. 13
      Plx/src/LowLevel/HonaPacket.cpp
  12. 146
      Plx/src/Wrapper/PlxWrapper.cpp
  13. 54
      Test/MainWindow.cpp
  14. 17
      Test/MainWindow.h
  15. 46
      Test/MainWindow.ui
  16. 15
      Test/Test.pro
  17. 15
      Test2/MainWindow.cpp
  18. 21
      Test2/MainWindow.h
  19. 22
      Test2/MainWindow.ui
  20. 31
      Test2/Test2.pro
  21. 11
      Test2/main.cpp

19
Plx/Plx.pro
View File

@ -17,19 +17,13 @@ DEFINES += QT_DEPRECATED_WARNINGS
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
SOURCES += \ SOURCES += \
$$files(*.cpp, true) \ \ \ $$files(*.cpp, true)
HEADERS += \ HEADERS += \
$$files(*.h, true) \ \ \ $$files(*.h, true)
INCLUDEPATH += $$PWD/include INCLUDEPATH += $$PWD/include
# Default rules for deployment. # Default rules for deployment.
unix { unix {
target.path = $$[QT_INSTALL_PLUGINS]/generic 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

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

@ -17,7 +17,14 @@ private:
HonaLowLevelAPI _honaLowLevelAPI; HonaLowLevelAPI _honaLowLevelAPI;
public: public:
explicit HonaAPI(QObject* parent = nullptr); HonaAPI()
{
}
~HonaAPI()
{
}
ApiResult isHsruStarted(); ApiResult isHsruStarted();
ApiResult isHiruStarted(); ApiResult isHiruStarted();
ApiResult deviceReset(); ApiResult deviceReset();
@ -32,9 +39,7 @@ public:
ApiResult init(); ApiResult init();
signals: signals:
//uncrustify off void honaDataResult(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
public slots:
//uncrustify on
}; };
#endif //HONAAPI_H #endif //HONAAPI_H

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

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

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

@ -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

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

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

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

@ -3,7 +3,7 @@
#include <QtGlobal> #include <QtGlobal>
#include "include/LowLevel/Utils/Utils.h" #include "LowLevel/Utils/Utils.h"
class HonaPacket class HonaPacket
{ {
@ -18,8 +18,8 @@ private:
quint32 m_Pa3; quint32 m_Pa3;
quint32 m_Pa4; quint32 m_Pa4;
quint32 m_Code; quint32 m_Code;
quint32 m_CodeL; qulonglong m_CodeL;
quint32 m_CodeM; qulonglong m_CodeM;
quint8 m4Status; quint8 m4Status;
public: public:

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

@ -3,10 +3,9 @@
#include <QtGlobal> #include <QtGlobal>
#include <QList> #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 struct hiruSettings_t
{ {

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

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

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

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

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

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

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

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

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

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

54
Test/MainWindow.cpp
View File

@ -1,11 +1,13 @@
#include "MainWindow.h" #include "MainWindow.h"
#include "ui_MainWindow.h" #include "ui_MainWindow.h"
HonaAPI _honaAPI;
MainWindow::MainWindow(QWidget* parent) MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent) : QMainWindow(parent)
, ui(new Ui::MainWindow) , ui(new Ui::MainWindow)
{ {
ui->setupUi(this); ui->setupUi(this);
connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
} }
MainWindow::~MainWindow() MainWindow::~MainWindow()
@ -13,6 +15,58 @@ MainWindow::~MainWindow()
delete ui; delete ui;
} }
/*************************************************************************************************/
void MainWindow::honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa)
{
qDebug() << "honaDataResultUi inside " << honaPacketList.length();
QString _str;
for(auto i = 0; i < honaPacketList.length(); i++)
{
_str = "[" + QString::number(i) + "] " + "0x hsruLoss" + QString::number(hsruLoss);
_str += "\n *********************************************";
}
ui->dataFromMemory->setText(_str);
}
void MainWindow::on_testPLX_clicked() 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");
}
} }

17
Test/MainWindow.h
View File

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

46
Test/MainWindow.ui
View File

@ -6,8 +6,8 @@
<rect> <rect>
<x>0</x> <x>0</x>
<y>0</y> <y>0</y>
<width>311</width> <width>543</width>
<height>281</height> <height>475</height>
</rect> </rect>
</property> </property>
<property name="windowTitle"> <property name="windowTitle">
@ -17,8 +17,8 @@
<widget class="QPushButton" name="testPLX"> <widget class="QPushButton" name="testPLX">
<property name="geometry"> <property name="geometry">
<rect> <rect>
<x>100</x> <x>250</x>
<y>120</y> <y>40</y>
<width>89</width> <width>89</width>
<height>25</height> <height>25</height>
</rect> </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> <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> </property>
</widget> </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>
<widget class="QMenuBar" name="menubar"> <widget class="QMenuBar" name="menubar">
<property name="geometry"> <property name="geometry">
<rect> <rect>
<x>0</x> <x>0</x>
<y>0</y> <y>0</y>
<width>311</width> <width>543</width>
<height>22</height> <height>22</height>
</rect> </rect>
</property> </property>

15
Test/Test.pro
View File

@ -22,10 +22,25 @@ SOURCES += \
HEADERS += \ HEADERS += \
MainWindow.h MainWindow.h
INCLUDEPATH += $$PWD/../Plx/include
FORMS += \ FORMS += \
MainWindow.ui MainWindow.ui
LIBS += -L$$OUT_PWD/../Plx/ -lPlx
PRE_TARGETDEPS += $$OUT_PWD/../Plx/libPlx.a
# Default rules for deployment. # Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target !isEmpty(target.path): INSTALLS += target
unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
INCLUDEPATH += $$PWD/../../Plxlibrary/Library
DEPENDPATH += $$PWD/../../Plxlibrary/Library
INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

15
Test2/MainWindow.cpp
View File

@ -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;
}

21
Test2/MainWindow.h
View File

@ -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

22
Test2/MainWindow.ui
View File

@ -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>

31
Test2/Test2.pro
View File

@ -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

11
Test2/main.cpp
View File

@ -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();
}
Write Preview
Loading…
Cancel
Save