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

work on honaapi function

heydari
Alireza 3 years ago
parent
12654baa73
commit
237bdbe26e
5 changed files with 1059 additions and 190 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. 85
      Plx/include/LowLevel/HonaLowLevelAPI.h
  2. 62
      Plx/include/LowLevel/HonaPacket.h.autosave
  3. 67
      Plx/include/LowLevel/Utils/Utils.h
  4. 843
      Plx/src/LowLevel/HonaLowLevelAPI.cpp
  5. 192
      Plx/src/LowLevel/HonaPacket.cpp

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

@ -1,4 +1,4 @@
#ifndef HONALOWLEVELAPI_H #ifndef HONALOWLEVELAPI_H
#define HONALOWLEVELAPI_H #define HONALOWLEVELAPI_H
#include <QObject> #include <QObject>
@ -10,6 +10,9 @@
#include "QWaitCondition" #include "QWaitCondition"
#include "QMutex" #include "QMutex"
#include "include/LowLevel/Exception/HonaAlreadyStartedException.h" #include "include/LowLevel/Exception/HonaAlreadyStartedException.h"
#include "include/LowLevel/Exception/HonaException.h"
#include "include/Wrapper/PlxWrapper.h"
#include "include/LowLevel/Utils/Utils.h"
class HonaLowLevelAPI : public QObject class HonaLowLevelAPI : public QObject
{ {
@ -18,13 +21,61 @@ class HonaLowLevelAPI : public QObject
private: private:
bool _hsruIsStarted; bool _hsruIsStarted;
bool _hiruIsStarted; bool _hiruIsStarted;
quint32 _hsruLoss;
HonaSettings _honaSetting; HonaSettings _honaSetting;
QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent; QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
_hiruUpdateAck1;
QList<HonaPacket> honaPacketList;
QMutex _mutex; QMutex _mutex;
int _threadSforValue = 0; int _threadSforValue = 0;
bool _isReaderThreadFree = false; bool _isHsruMainThreadFree = false;
bool _isUpdateThreadFree = false; bool _isHsruReaderThreadFree = false;
quint32 honaRegisterBuffer[8]; bool _isHsruUpdateThreadFree = false;
bool _isHiruReaderThreadFree = false;
bool _isHiruUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
PlxWrapper plxWrapper;
static quint32 packetLenInt4;
static quint32 packetLenRes4;
static quint32 packetLenSinglePulse;
static quint32 packetLenInt123C;
static quint32 packetLenRes123C;
static quint32 packetLenIntS;
static quint32 packetLenResS;
static quint32 nextInt4;
static quint32 nextRes4;
static quint32 nextSinglePulse;
static quint32 nextInt123C;
static quint32 nextRes123C;
static quint32 nextIntS;
static quint32 nextResS;
quint32 lastPNInt4 = 0;
quint32 lastPNRes4 = 0;
quint32 lastPNSinglePulse = 0;
quint32 lastPNInt123C = 0;
quint32 lastPNRes123C = 0;
quint32 lastPNIntS = 0;
quint32 lastPNResS = 0;
HonaPacket tempHonaPacketInt4;
HonaPacket tempHonaPacketRes4;
HonaPacket tempHonaPacketSinglePulse;
HonaPacket tempHonaPacketInt123C;
HonaPacket tempHonaPacketRes123C;
HonaPacket tempHonaPacketIntS;
HonaPacket tempHonaPacketResS;
public:
qulonglong toaStartBoard = 0;
public: public:
explicit HonaLowLevelAPI(QObject* parent = nullptr); explicit HonaLowLevelAPI(QObject* parent = nullptr);
@ -32,12 +83,11 @@ public:
bool isHiruStarted(); bool isHiruStarted();
void deviceReset(); void deviceReset();
void setConfig(HonaSettings* honaSetting); void setConfig(HonaSettings& settings);
HonaSettings getConfig(); HonaSettings getConfig();
QString getSwVersion(); QString getSwVersion();
QString getDeviceId(); QString getDeviceId();
void hsruStart(); void hsruStart();
void hiruStart(); void hiruStart();
void init(); void init();
@ -53,10 +103,27 @@ private:
void hsruMainThread(); void hsruMainThread();
void hsruReadThread(); void hsruReadThread();
void hsruUpdateThread(); void hsruUpdateThread();
int hiruGetDOA(); void hiruMainThread();
void hiruReadThread();
void hiruUpdateThread();
quint32 hiruGetDOA();
quint32 hsruParserInt123C(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserRes123C(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserIntS(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserResS(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserInt4(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserRes4(const QVector<quint32>& honaData, QList<HonaPacket> honaPacketList);
quint32 hsruParserSinglePulse(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList);
QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
bool isValid(HonaPacket hp);
signals: signals:
void signalToTop(QList<HonaPacket*> honaPacketList, int i, int j); void signalToTop(QList<HonaPacket> honaPacketList, quint32 i, quint32 j);
//uncrustify off //uncrustify off
public slots: public slots:
//uncrustify on //uncrustify on

62
Plx/include/LowLevel/HonaPacket.h.autosave
View File

@ -0,0 +1,62 @@
#ifndef HONAPACKET_H
#define HONAPACKET_H
#include <QtGlobal>
#include "include/LowLevel/Utils/Utils.h"
class HonaPacket
{
private:
qreal toaClock;
honaPacketType m_PacketType;
quint32 m_PacketNumber;
qulonglong m_Toa;
quint32 m_Doa;
quint32 m_Pa1;
quint32 m_Pa2;
quint32 m_Pa3;
quint32 m_Pa4;
quint32 m_Code;
quint32 m_CodeL;
quint32 m_CodeM;
public:
HonaPacket();
/******************************************************************/
honaPacketType getPacketType();
void setPacketType(honaPacketType temp);
/******************************************************************/
quint32 getPacketNumber();
void setPacketNumber(quint32 temp);
/******************************************************************/
qulonglong getToa();
void setToa(qulonglong temp);
/******************************************************************/
quint32 getDoa();
void setDoa(quint32 temp);
/******************************************************************/
quint32 getPa1();
void setPa1(quint32 temp);
/******************************************************************/
quint32 getPa2();
void setPa2(quint32 temp);
/******************************************************************/
quint32 getPa3();
void setPa3(quint32 temp);
/******************************************************************/
quint32 getPa4();
void setPa4(quint32 temp);
/******************************************************************/
quint32 getCode();
void setCode(quint32 temp);
/******************************************************************/
quint32 getCodeL();
void setCodeL(quint32 temp);
/******************************************************************/
quint32 getCodeM();
void setCodeM(quint32 temp);
/******************************************************************/
};
#endif //HONAPACKET_H

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

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

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

@ -1,11 +1,9 @@
#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 "qdebug.h"
#include "QTime" #include "QTime"
#include "QtConcurrent/QtConcurrent" #include "QtConcurrent/QtConcurrent"
PlxWrapper plx;
bool HonaLowLevelAPI::getHsruIsStarted() const bool HonaLowLevelAPI::getHsruIsStarted() const
{ {
@ -33,6 +31,13 @@ void HonaLowLevelAPI::setHiruIsStarted(bool hiruIsStarted)
/*************************************************************************************************/ /*************************************************************************************************/
HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent) HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent)
{ {
packetLenInt4 = 7;
packetLenRes4 = 5;
packetLenSinglePulse = 5;
packetLenInt123C = 6;
packetLenRes123C = 6;
packetLenIntS = 7;
packetLenResS = 7;
} }
/*************************************************************************************************/ /*************************************************************************************************/
@ -50,72 +55,55 @@ bool HonaLowLevelAPI::isHiruStarted()
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::deviceReset() void HonaLowLevelAPI::deviceReset()
{ {
//ApiResult status; if(!plxWrapper.deviceReset())
//if(ApiResult::success) throw HonaAlreadyStartedException("reset Doesnt Occur");
//{
//}
/*
QTime t;
t.elapsed()
PLX_STATUS status = base.DeviceReset();
qDebug() << "Board Reseted, status: " + status.ToString());
if (status == PLX_STATUS.ApiSuccess)
{
toaStartBoard = (ulong) (DateTime.Now.Ticks);
return ApiResult.Success;
}
else
return ApiResult.Error; */
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::setConfig(HonaSettings* honaSetting) void HonaLowLevelAPI::setConfig(HonaSettings& settings)
{ {
//Initial State Checking plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8);
/* _honaSetting = settings;
HonaRegisterBuffer = new uint[8]; // Mode4 :: changed from 5 to 8 by H.H writeSettingToRegisters(settings);
DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer); plxWrapper.deviceWriteRegister(0x10000000, honaRegisterBuffer);
plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8);
_honaSetting = Settings;
HonaFillRegisters(Settings);
DeviceWriteRegisters(0x10000000, HonaRegisterBuffer);
HonaRegisterBuffer = new uint[8]; // Mode4 :: changed from 5 to 8 by H.H
DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer);
return ApiResult.Success; */
} }
/*************************************************************************************************/ /*************************************************************************************************/
HonaSettings HonaLowLevelAPI::getConfig() HonaSettings HonaLowLevelAPI::getConfig()
{ {
return _honaSetting;
} }
/*************************************************************************************************/ /*************************************************************************************************/
QString HonaLowLevelAPI::getSwVersion() QString HonaLowLevelAPI::getSwVersion()
{ {
return("94072200");
} }
/*************************************************************************************************/ /*************************************************************************************************/
QString HonaLowLevelAPI::getDeviceId() QString HonaLowLevelAPI::getDeviceId()
{ {
return("ssr");
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::hsruStart() void HonaLowLevelAPI::hsruStart()
{ {
if(!isHsruStarted())
throw HonaAlreadyStartedException("HsruStarted doesn't started ");
QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
setHsruIsStarted(true);
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::hiruStart() void HonaLowLevelAPI::hiruStart()
{ {
if(isHiruStarted()) if(!isHiruStarted())
//exceptiom throw HonaAlreadyStartedException("HiruStarted doesn't started ");
QtConcurrent::run(this, &HonaLowLevelAPI::hiruMainThread);
QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread); setHiruIsStarted(true);
} }
/*************************************************************************************************/ /*************************************************************************************************/
@ -126,62 +114,100 @@ void HonaLowLevelAPI::init()
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings) void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings)
{ {
honaRegisterBuffer[0] = 0x00000000; honaRegisterBuffer.clear();
honaRegisterBuffer.insert(0, 0x00000000);
/************************************************************************/ /************************************************************************/
if(settings.hiruSettings.recordStard == recorderStart::selfTestCounter) if(settings.hiruSettings.recordStard == recorderStart::selfTestCounter)
honaRegisterBuffer[0] = 0x80000000; honaRegisterBuffer.insert(0, 0x80000000);
else else
honaRegisterBuffer[0] = 0x7FFFFFFF; honaRegisterBuffer.insert(0, 0x7FFFFFFF);
/************************************************************************/ /************************************************************************/
if(settings.hiruSettings.recordChannel == drxDeviceIfChannel::ifChannel12) if(settings.hiruSettings.recordChannel == drxDeviceIfChannel::ifChannel12)
honaRegisterBuffer[0] = 0x20000000; honaRegisterBuffer.insert(0, 0x20000000);
else else
honaRegisterBuffer[0] = 0xDFFFFFFF; honaRegisterBuffer.insert(0, 0xDFFFFFFF);
/************************************************************************/ /************************************************************************/
if(settings.hiruSettings.recordMode == recorderMode::dualChannel) if(settings.hiruSettings.recordMode == recorderMode::dualChannel)
honaRegisterBuffer[0] = 0x10000000; honaRegisterBuffer.insert(0, 0x10000000);
else else
honaRegisterBuffer[0] = 0xEFFFFFFF; honaRegisterBuffer.insert(0, 0xEFFFFFFF);
/************************************************************************/ /************************************************************************/
honaRegisterBuffer[0] += (settings.hiruSettings.threshold & 0x00000FFF); honaRegisterBuffer.insert(0,
(honaRegisterBuffer.at(0) +
honaRegisterBuffer[1] = settings.hsruSettings.honaInt123CTHR; (settings.hiruSettings.threshold & 0x00000FFF)));
honaRegisterBuffer[2] = settings.hsruSettings.honaRes123CTHR;
honaRegisterBuffer[3] = settings.hsruSettings.honaIntSTHR; honaRegisterBuffer.insert(1, settings.hsruSettings.honaInt123CTHR);
honaRegisterBuffer[4] = settings.hsruSettings.honaResSTHR; honaRegisterBuffer.insert(2, settings.hsruSettings.honaRes123CTHR);
honaRegisterBuffer[5] = settings.hsruSettings.honaSPTHR; honaRegisterBuffer.insert(3, settings.hsruSettings.honaIntSTHR);
honaRegisterBuffer[6] = settings.hsruSettings.intM4_THR; honaRegisterBuffer.insert(4, settings.hsruSettings.honaResSTHR);
honaRegisterBuffer[7] = settings.hsruSettings.resM4_THR; honaRegisterBuffer.insert(5, settings.hsruSettings.honaSPTHR);
honaRegisterBuffer.insert(6, settings.hsruSettings.intM4_THR);
honaRegisterBuffer.insert(7, settings.hsruSettings.resM4_THR);
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::setConfig() void HonaLowLevelAPI::setConfig()
{ {
setConfig(_honaSetting);
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::hsruMainThread() void HonaLowLevelAPI::hsruMainThread()
{ {
QtConcurrent::run(this, &HonaLowLevelAPI::hsruReadThread); try
QtConcurrent::run(this, &HonaLowLevelAPI::hsruUpdateThread); {
deviceReset();
setConfig();
deviceReset();
plxWrapper.deviceEnableInterrupt();
QtConcurrent::run(this, &HonaLowLevelAPI::hsruReadThread);
QtConcurrent::run(this, &HonaLowLevelAPI::hsruUpdateThread);
}
catch(...)
{
_isHsruReaderThreadFree = true;
_isHsruUpdateThreadFree = true;
setHiruIsStarted(false);
}
_mutex.lock(); _mutex.lock();
_hsruStopEvent.wait(&_mutex); _hsruStopEvent.wait(&_mutex);
_mutex.unlock(); _mutex.unlock();
_isHsruReaderThreadFree = true;
_isHsruUpdateThreadFree = true;
_isReaderThreadFree = true; plxWrapper.deviceDisableInterrupt();
_isUpdateThreadFree = true;
} }
/*************************************************************************************************/ /*************************************************************************************************/
void HonaLowLevelAPI::hsruReadThread() void HonaLowLevelAPI::hsruReadThread()
{ {
_hsruLoss = 0;
while(true) while(true)
{ {
if(_isReaderThreadFree) if(_isHsruReaderThreadFree)
break; break;
//dosth
plxWrapper.deviceWaitForInterrupt(1000);
honaPacketList.clear();
_hsruLoss = 0;
plxWrapper.deviceOpenPCIChannel();
_hsruLoss += hsruParserInt123C(hsruReadHonaBuffer(honaReceivers::int123C),
honaPacketList);
_hsruLoss += hsruParserRes123C(hsruReadHonaBuffer(honaReceivers::res123C),
honaPacketList);
_hsruLoss += hsruParserIntS(hsruReadHonaBuffer(honaReceivers::intS), honaPacketList);
_hsruLoss += hsruParserResS(hsruReadHonaBuffer(honaReceivers::resS), honaPacketList);
_hsruLoss += hsruParserInt4(hsruReadHonaBuffer(honaReceivers::int4), honaPacketList);
_hsruLoss += hsruParserRes4(hsruReadHonaBuffer(honaReceivers::res4), honaPacketList);
_hsruLoss += hsruParserSinglePulse(hsruReadHonaBuffer(honaReceivers::singlePulse),
honaPacketList);
plxWrapper.deviceClosePCIChannel();
plxWrapper.deviceEnableInterrupt();
_mutex.lock(); _mutex.lock();
_hsruReadDone.wakeAll(); _hsruReadDone.wakeAll();
_hsruUpdateAck.wait(&_mutex); _hsruUpdateAck.wait(&_mutex);
@ -197,16 +223,707 @@ void HonaLowLevelAPI::hsruUpdateThread()
_mutex.lock(); _mutex.lock();
_hsruReadDone.wait(&_mutex); _hsruReadDone.wait(&_mutex);
_mutex.unlock(); _mutex.unlock();
if(_isUpdateThreadFree) if(_isHsruUpdateThreadFree)
break; break;
//dosth quint32 Doa = 0;
Doa = hiruGetDOA();
emit signalToTop(honaPacketList, _hsruLoss, Doa);
_hsruUpdateAck.wakeAll(); _hsruUpdateAck.wakeAll();
} }
} }
/*************************************************************************************************/ /*************************************************************************************************/
int HonaLowLevelAPI::hiruGetDOA() void HonaLowLevelAPI::hiruMainThread()
{
QtConcurrent::run(this, &HonaLowLevelAPI::hiruReadThread);
QtConcurrent::run(this, &HonaLowLevelAPI::hiruUpdateThread);
while(true)
{
_mutex.lock();
_hsruStopEvent.wait(&_mutex);
_mutex.unlock();
//_isReaderThreadFree = true;
//_isUpdateThreadFree = true;
}
}
/*************************************************************************************************/
void HonaLowLevelAPI::hiruReadThread()
{
}
/*************************************************************************************************/
void HonaLowLevelAPI::hiruUpdateThread()
{
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hiruGetDOA()
{
quint32 Doa = 0;
plxWrapper.deviceReadRegister(0x30000004, Doa);
Doa = Doa & 0x0000FFFF;
return Doa;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserInt123C(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
quint32 lossFound;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
HonaPacket tempHonaPacketInt123C;
tempHonaPacketInt123C.setPacketType(honaPacketType::responseMode123C);
packetLenInt123C = 6;
tempHonaPacketInt123C.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketInt123C.getPacketNumber() !=
(lastPNInt123C + 1)) & (lastPNInt123C > 0))
//& (LastPNInt123C != 65535))
{
lossFound +=
((tempHonaPacketInt123C.getPacketNumber() - lastPNInt123C + 65536) % 65536 - 1);
}
lastPNInt123C = tempHonaPacketInt123C.getPacketNumber();
if(nextInt123C > 0)
lossFound++;
nextInt123C = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextInt123C == 1))
{
tempHonaPacketInt123C.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
nextInt123C = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextInt123C == 2))
{
tempHonaPacketInt123C.setToa(((tempHonaPacketInt123C.getToa()) +
(qulonglong)((honaData.at(Ind) & 0x0000FFFF) << 28)));
tempHonaPacketInt123C.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextInt123C = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextInt123C == 3))
{
tempHonaPacketInt123C.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketInt123C.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextInt123C = 4;
}
else if(((honaData.at(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);
nextInt123C = 5;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextInt123C == 5))
{
tempHonaPacketInt123C.setCodeM(((ulong)(honaData.at(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);
}
nextInt123C = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserRes123C(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
quint32 lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
tempHonaPacketRes123C.setPacketNumber(honaPacketType::responseMode123C);
packetLenRes123C = 6;
tempHonaPacketRes123C.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketRes123C.getPacketNumber() !=
(lastPNRes123C + 1)) & (lastPNRes123C > 0))
//& (LastPNRes123C != 65535))
{
lossFound +=
((tempHonaPacketRes123C.getPacketNumber() - lastPNRes123C + 65536) % 65536 - 1);
}
lastPNRes123C = tempHonaPacketRes123C.getPacketNumber();
if(nextRes123C > 0)
lossFound++;
nextRes123C = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextRes123C == 1))
{
tempHonaPacketRes123C.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
nextRes123C = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextRes123C == 2))
{
tempHonaPacketRes123C.setToa(tempHonaPacketRes123C.getToa() +
(((ulong)(honaData.at(Ind) & 0x0000FFFF)) << 28));
tempHonaPacketRes123C.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextRes123C = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextRes123C == 3))
{
tempHonaPacketRes123C.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketRes123C.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextRes123C = 4;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextRes123C == 4))
{
tempHonaPacketRes123C.setPa1(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketRes123C.setPa2(tempHonaPacketRes123C.getPa2() +
((honaData.at(Ind) & 0x000F0000) >> 4));
tempHonaPacketRes123C.setPa3(tempHonaPacketRes123C.getPa3() +
((honaData.at(Ind) & 0x00F00000) >> 8));
nextRes123C = 5;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextRes123C == 5))
{
tempHonaPacketRes123C.setCodeM(((ulong)(honaData.at(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);
}
nextRes123C = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserIntS(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
uint lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
uint TypeVal = (honaData.at(Ind) & 0x00F00000) >> 20;
if(TypeVal == 2)
{
tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS56);
packetLenIntS = 7;
}
else
{
tempHonaPacketIntS.setPacketType(honaPacketType::interrogationModeS112);
packetLenIntS = 9;
}
tempHonaPacketIntS.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketIntS.getPacketNumber() != (lastPNIntS + 1)) & (lastPNIntS > 0))
//& (LastPNIntS != 65535))
{
lossFound +=
((tempHonaPacketIntS.getPacketNumber() - lastPNIntS + 65536) % 65536 - 1);
}
lastPNIntS = tempHonaPacketIntS.getPacketNumber();
if(nextIntS > 0)
lossFound++;
nextIntS = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextIntS == 1))
{
tempHonaPacketIntS.setToa((qulonglong)(honaData.at(Ind) & 0x0FFFFFFF));
nextIntS = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextIntS == 2))
{
tempHonaPacketIntS.setToa(tempHonaPacketIntS.getToa() +
(((ulong)(honaData.at(Ind) & 0x0000FFFF)) << 28));
tempHonaPacketIntS.setToa((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextIntS = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextIntS == 3))
{
tempHonaPacketIntS.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketIntS.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextIntS = 4;
}
else if(((honaData.at(static_cast<int>(Ind)) & 0xF0000000) == 0x40000000) &&
(nextIntS == 4))
{
tempHonaPacketIntS.setPa1(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketIntS.setPa2(tempHonaPacketIntS.getPa2() + ((honaData.at(
Ind) & 0x000F0000)));
tempHonaPacketIntS.setPa3(tempHonaPacketIntS.getPa3() +
((honaData.at(Ind) & 0x00F00000) >> 4));
nextIntS = 5;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextIntS == 5))
{
tempHonaPacketIntS.setCodeM(((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 8);
tempHonaPacketIntS.setCodeL(0);
nextIntS = 6;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextIntS == 6))
{
tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 36);
tempHonaPacketIntS.setCodeL(0);
nextIntS = 7;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x70000000) && (nextIntS == 7))
{
tempHonaPacketIntS.setCodeL(tempHonaPacketIntS.getCodeM());
tempHonaPacketIntS.setCodeM(((ulong)(honaData.at(Ind) & 0x0FFFFFFF)) << 8);
nextIntS = 8;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x80000000) && (nextIntS == 8))
{
tempHonaPacketIntS.setCodeM(tempHonaPacketIntS.getCodeM() +
((ulong)(honaData.at(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);
}
nextIntS = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserResS(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
uint lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
uint TypeVal = (honaData.at(Ind) & 0x00F00000) >> 20;
if(TypeVal == 4)
{
tempHonaPacketResS.setPacketType(honaPacketType::responseModeS56);
packetLenResS = 7;
}
else
{
tempHonaPacketResS.setPacketType(honaPacketType::responseModeS112);
packetLenResS = 9;
}
tempHonaPacketResS.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketResS.getPacketNumber() != (lastPNResS + 1)) & (lastPNResS > 0))
//& (LastPNResS != 65535))
{
lossFound +=
((tempHonaPacketResS.getPacketNumber() - lastPNResS + 65536) % 65536 - 1);
}
lastPNResS = tempHonaPacketResS.getPacketNumber();
if(nextResS > 0)
lossFound++;
nextResS = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextResS == 1))
{
tempHonaPacketResS.setToa(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
nextResS = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextResS == 2))
{
tempHonaPacketResS.setDoa(tempHonaPacketResS.getDoa() +
((static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF)) <<
28));
tempHonaPacketResS.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextResS = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextResS == 3))
{
tempHonaPacketResS.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketResS.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextResS = 4;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextResS == 4))
{
tempHonaPacketResS.setPa1(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketResS.setPa2(tempHonaPacketResS.getPa2() + ((honaData.at(
Ind) & 0x000F0000)));
tempHonaPacketResS.setPa3(tempHonaPacketResS.getPa3() +
((honaData.at(Ind) & 0x00F00000) >> 4));
nextResS = 5;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextResS == 5))
{
tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData.at(
Ind) & 0x0FFFFFFF)) << 8);
tempHonaPacketResS.setCodeL(0);
nextResS = 6;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextResS == 6))
{
tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
(static_cast<qulonglong>(honaData.at(
Ind) & 0x0FFFFFFF)) << 36);
tempHonaPacketResS.setCodeL(0);
nextResS = 7;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x70000000) && (nextResS == 7))
{
tempHonaPacketResS.setCodeL(tempHonaPacketResS.getCodeM());
tempHonaPacketResS.setCodeM((static_cast<qulonglong>(honaData.at(
Ind) & 0x0FFFFFFF)) << 8);
nextResS = 8;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x80000000) && (nextResS == 8))
{
tempHonaPacketResS.setCodeM(tempHonaPacketResS.getCodeM() +
(static_cast<qulonglong>(honaData.at(
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);
}
nextResS = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserInt4(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
uint lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
tempHonaPacketInt4.setPacketType(honaPacketType::interrogationMode4);
packetLenInt4 = 7;
tempHonaPacketInt4.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketInt4.getPacketNumber() != (lastPNInt4 + 1)) & (lastPNInt4 > 0)) //& (LastPNInt123C != 65535))
{
lossFound +=
((tempHonaPacketInt4.getPacketNumber() - lastPNInt4 + 65536) % 65536 - 1);
}
lastPNInt4 = tempHonaPacketInt4.getPacketNumber();
if(nextInt4 > 0)
lossFound++;
nextInt4 = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextInt4 == 1))
{
tempHonaPacketInt4.setToa(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
nextInt4 = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextInt4 == 2))
{
tempHonaPacketInt4.setToa(tempHonaPacketInt4.getToa() +
((static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF)) <<
28));
tempHonaPacketInt4.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextInt4 = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextInt4 == 3))
{
tempHonaPacketInt4.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketInt4.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextInt4 = 4;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextInt4 == 4))
{
tempHonaPacketInt4.setPa1(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketInt4.setPa2(tempHonaPacketInt4.getPa2() +
((honaData.at(Ind) & 0x000F0000) >> 4));
tempHonaPacketInt4.setPa3(tempHonaPacketInt4.getPa3() +
((honaData.at(Ind) & 0x00F00000) >> 8));
nextInt4 = 5;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x50000000) && (nextInt4 == 5))
{
tempHonaPacketInt4.setCodeM(0);
tempHonaPacketInt4.setCodeL(static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF));
nextInt4 = 6;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x60000000) && (nextInt4 == 6))
{
tempHonaPacketInt4.setPa4(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketInt4.setCodeL(tempHonaPacketInt4.getCodeL() +
((static_cast<qulonglong>(honaData.at(Ind) & 0x000F0000)) <<
12));
tempHonaPacketInt4.M4Status = ((byte)((honaData.at(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);
}
nextInt4 = 0;
}
}
return lossFound;
}
quint32 HonaLowLevelAPI::hsruParserRes4(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
uint lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
tempHonaPacketRes4.setPacketType(honaPacketType::responseMode4);
packetLenRes4 = 5;
tempHonaPacketRes4.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketRes4.getPacketNumber() != (lastPNRes4 + 1)) & (lastPNRes4 > 0)) //& (LastPNRes123C != 65535))
{
lossFound +=
((tempHonaPacketRes4.getPacketNumber() - lastPNRes4 + 65536) % 65536 - 1);
}
lastPNRes4 = tempHonaPacketRes4.getPacketNumber();
if(nextRes4 > 0)
lossFound++;
nextRes4 = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextRes4 == 1))
{
tempHonaPacketRes4.setToa((static_cast<qulonglong>(honaData.at(Ind) & 0x0FFFFFFF)));
nextRes4 = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextRes4 == 2))
{
tempHonaPacketRes4.setToa(tempHonaPacketRes4.getToa() +
(static_cast<qulonglong>(honaData.at(Ind) & 0x0000FFFF) <<
28));
tempHonaPacketRes4.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextRes4 = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextRes4 == 3))
{
tempHonaPacketRes4.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketRes4.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextRes4 = 4;
}
else if(((honaData.at(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
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);
}
nextRes4 = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
quint32 HonaLowLevelAPI::hsruParserSinglePulse(const QVector<quint32>& honaData,
QList<HonaPacket> honaPacketList)
{
uint lossFound = 0;
for(quint32 Ind = 0; Ind < honaData.length(); Ind++)
{
if((honaData.at(Ind) & 0xFF000000) == 0x0F000000)
{
tempHonaPacketSinglePulse.setPacketType(honaPacketType::singlePulseMode4);
packetLenSinglePulse = 5;
tempHonaPacketSinglePulse.setPacketNumber(honaData.at(Ind) & 0x0000FFFF);
if((tempHonaPacketSinglePulse.getPacketNumber() !=
(lastPNSinglePulse + 1)) & (lastPNSinglePulse > 0))
;
{
lossFound +=
((tempHonaPacketSinglePulse.getPacketNumber() - lastPNSinglePulse + 65536) %
65536 -
1);
}
lastPNSinglePulse = tempHonaPacketSinglePulse.getPacketNumber();
if(nextSinglePulse > 0)
lossFound++;
nextSinglePulse = 1;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x10000000) && (nextSinglePulse == 1))
{
tempHonaPacketSinglePulse.setToa(static_cast<qulonglong>(honaData.at(Ind) &
0x0FFFFFFF));
nextSinglePulse = 2;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x20000000) && (nextSinglePulse == 2))
{
tempHonaPacketSinglePulse.setToa(tempHonaPacketSinglePulse.getToa() +
((static_cast<qulonglong>(honaData.at(Ind) &
0x0000FFFF)) << 28));
tempHonaPacketSinglePulse.setPa2((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextSinglePulse = 3;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x30000000) && (nextSinglePulse == 3))
{
tempHonaPacketSinglePulse.setDoa(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketSinglePulse.setPa3((honaData.at(Ind) & 0x0FFF0000) >> 16);
nextSinglePulse = 4;
}
else if(((honaData.at(Ind) & 0xF0000000) == 0x40000000) && (nextSinglePulse == 4))
{
tempHonaPacketSinglePulse.setPa1(honaData.at(Ind) & 0x0000FFFF);
tempHonaPacketSinglePulse.setPa2(tempHonaPacketSinglePulse.getPa2() +
((honaData.at(Ind) & 0x000F0000) >> 4)); //NOTE: shifted by 4
tempHonaPacketSinglePulse.setPa3(tempHonaPacketSinglePulse.getPa3() +
((honaData.at(Ind) & 0x00F00000) >> 8)); //NOTE: shifted by 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);
}
nextSinglePulse = 0;
}
}
return lossFound;
}
/*************************************************************************************************/
QVector<quint32> HonaLowLevelAPI::hsruReadHonaBuffer(honaReceivers receiver)
{
QVector<quint32> honaData;
honaData.resize(16384);
quint32 address = 0;
if(receiver == honaReceivers::int123C)
address = 0X50000000;
else if(receiver == honaReceivers::res123C)
address = 0X60000000;
else if(receiver == honaReceivers::intS)
address = 0X70000000;
else if(receiver == honaReceivers::resS)
address = 0X80000000;
else if(receiver == honaReceivers::int4) //Mode4 :: added by H.H
address = 0X90000000;
else if(receiver == honaReceivers::res4) //Mode4 :: added by H.H
address = 0XA0000000;
else if(receiver == honaReceivers::singlePulse) //Mode4 :: added by H.H
address = 0XB0000000;
else
throw HonaException("honaReceivers is Not Valid");
plxWrapper.deviceReadMemory(address, honaData, honaData.size());
return honaData;
}
/*************************************************************************************************/
bool HonaLowLevelAPI::isValid(HonaPacket hp)
{ {
if(hp.getToa() <= 0)
return false;
return true;
} }
/*************************************************************************************************/ /*************************************************************************************************/

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

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

Write Preview
Loading…
Cancel
Save