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

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

@ -2,6 +2,7 @@
#define UTILS_H
#include <QtCore>
/*************************************************************************************************/
enum apiResult : quint8
{
@ -10,36 +11,40 @@ enum apiResult : quint8
busy,
error
};
/*************************************************************************************************/
enum drxDeviceIfChannel : quint8
{
ifChannel11,
ifChannel12
};
/*************************************************************************************************/
enum honaReceivers : quint8
{
int123C,
res123C,
intS,
resS,
int4, //Mode 4
res4, //Mode 4
signalPulse //Mode 4
singlePulse //Mode 4
};
/*************************************************************************************************/
enum recorderMode : quint8
{
signalChannel,
dualChannel
};
/*************************************************************************************************/
enum recorderStart : quint8
{
selfTestCounter = 1,
freeRunRecording = 2
};
/*************************************************************************************************/
enum honaPacketType : quint8
{
@ -53,13 +58,9 @@ enum honaPacketType : quint8
responseModeS112,
responseMode4,
signalPulseMode4
singlePulseMode4
};
/*************************************************************************************************/
/*************************************************************************************************/
#endif //UTILS_H

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

@ -1,11 +1,9 @@
#include <include/LowLevel/Utils/Utils.h>
#include "include/LowLevel/HonaLowLevelAPI.h"
#include "include/Wrapper/PlxWrapper.h"
#include "qdebug.h"
#include "QTime"
#include "QtConcurrent/QtConcurrent"
PlxWrapper plx;
bool HonaLowLevelAPI::getHsruIsStarted() const
{
@ -33,6 +31,13 @@ void HonaLowLevelAPI::setHiruIsStarted(bool hiruIsStarted)
/*************************************************************************************************/
HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent)
{
packetLenInt4 = 7;
packetLenRes4 = 5;
packetLenSinglePulse = 5;
packetLenInt123C = 6;
packetLenRes123C = 6;
packetLenIntS = 7;
packetLenResS = 7;
}
/*************************************************************************************************/
@ -50,72 +55,55 @@ bool HonaLowLevelAPI::isHiruStarted()
/*************************************************************************************************/
void HonaLowLevelAPI::deviceReset()
{
//ApiResult status;
//if(ApiResult::success)
//{
//}
/*
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; */
if(!plxWrapper.deviceReset())
throw HonaAlreadyStartedException("reset Doesnt Occur");
}
/*************************************************************************************************/
void HonaLowLevelAPI::setConfig(HonaSettings* honaSetting)
void HonaLowLevelAPI::setConfig(HonaSettings& settings)
{
//Initial State Checking
/*
HonaRegisterBuffer = new uint[8]; // Mode4 :: changed from 5 to 8 by H.H
DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer);
_honaSetting = Settings;
HonaFillRegisters(Settings);
DeviceWriteRegisters(0x10000000, HonaRegisterBuffer);
HonaRegisterBuffer = new uint[8]; // Mode4 :: changed from 5 to 8 by H.H
DeviceReadRegisters(0x10000000, ref HonaRegisterBuffer);
return ApiResult.Success; */
plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8);
_honaSetting = settings;
writeSettingToRegisters(settings);
plxWrapper.deviceWriteRegister(0x10000000, honaRegisterBuffer);
plxWrapper.deviceReadRegister(0x10000000, honaRegisterBuffer, 8);
}
/*************************************************************************************************/
HonaSettings HonaLowLevelAPI::getConfig()
{
return _honaSetting;
}
/*************************************************************************************************/
QString HonaLowLevelAPI::getSwVersion()
{
return("94072200");
}
/*************************************************************************************************/
QString HonaLowLevelAPI::getDeviceId()
{
return("ssr");
}
/*************************************************************************************************/
void HonaLowLevelAPI::hsruStart()
{
if(!isHsruStarted())
throw HonaAlreadyStartedException("HsruStarted doesn't started ");
QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
setHsruIsStarted(true);
}
/*************************************************************************************************/
void HonaLowLevelAPI::hiruStart()
{
if(isHiruStarted())
//exceptiom
QtConcurrent::run(this, &HonaLowLevelAPI::hsruMainThread);
if(!isHiruStarted())
throw HonaAlreadyStartedException("HiruStarted doesn't started ");
QtConcurrent::run(this, &HonaLowLevelAPI::hiruMainThread);
setHiruIsStarted(true);
}
/*************************************************************************************************/
@ -126,62 +114,100 @@ void HonaLowLevelAPI::init()
/*************************************************************************************************/
void HonaLowLevelAPI::writeSettingToRegisters(HonaSettings& settings)
{
honaRegisterBuffer[0] = 0x00000000;
honaRegisterBuffer.clear();
honaRegisterBuffer.insert(0, 0x00000000);
/************************************************************************/
if(settings.hiruSettings.recordStard == recorderStart::selfTestCounter)
honaRegisterBuffer[0] = 0x80000000;
honaRegisterBuffer.insert(0, 0x80000000);
else
honaRegisterBuffer[0] = 0x7FFFFFFF;
honaRegisterBuffer.insert(0, 0x7FFFFFFF);
/************************************************************************/
if(settings.hiruSettings.recordChannel == drxDeviceIfChannel::ifChannel12)
honaRegisterBuffer[0] = 0x20000000;
honaRegisterBuffer.insert(0, 0x20000000);
else
honaRegisterBuffer[0] = 0xDFFFFFFF;
honaRegisterBuffer.insert(0, 0xDFFFFFFF);
/************************************************************************/
if(settings.hiruSettings.recordMode == recorderMode::dualChannel)
honaRegisterBuffer[0] = 0x10000000;
honaRegisterBuffer.insert(0, 0x10000000);
else
honaRegisterBuffer[0] = 0xEFFFFFFF;
honaRegisterBuffer.insert(0, 0xEFFFFFFF);
/************************************************************************/
honaRegisterBuffer[0] += (settings.hiruSettings.threshold & 0x00000FFF);
honaRegisterBuffer[1] = settings.hsruSettings.honaInt123CTHR;
honaRegisterBuffer[2] = settings.hsruSettings.honaRes123CTHR;
honaRegisterBuffer[3] = settings.hsruSettings.honaIntSTHR;
honaRegisterBuffer[4] = settings.hsruSettings.honaResSTHR;
honaRegisterBuffer[5] = settings.hsruSettings.honaSPTHR;
honaRegisterBuffer[6] = settings.hsruSettings.intM4_THR;
honaRegisterBuffer[7] = settings.hsruSettings.resM4_THR;
honaRegisterBuffer.insert(0,
(honaRegisterBuffer.at(0) +
(settings.hiruSettings.threshold & 0x00000FFF)));
honaRegisterBuffer.insert(1, settings.hsruSettings.honaInt123CTHR);
honaRegisterBuffer.insert(2, settings.hsruSettings.honaRes123CTHR);
honaRegisterBuffer.insert(3, settings.hsruSettings.honaIntSTHR);
honaRegisterBuffer.insert(4, settings.hsruSettings.honaResSTHR);
honaRegisterBuffer.insert(5, settings.hsruSettings.honaSPTHR);
honaRegisterBuffer.insert(6, settings.hsruSettings.intM4_THR);
honaRegisterBuffer.insert(7, settings.hsruSettings.resM4_THR);
}
/*************************************************************************************************/
void HonaLowLevelAPI::setConfig()
{
setConfig(_honaSetting);
}
/*************************************************************************************************/
void HonaLowLevelAPI::hsruMainThread()
{
try
{
deviceReset();
setConfig();
deviceReset();
plxWrapper.deviceEnableInterrupt();
QtConcurrent::run(this, &HonaLowLevelAPI::hsruReadThread);
QtConcurrent::run(this, &HonaLowLevelAPI::hsruUpdateThread);
}
catch(...)
{
_isHsruReaderThreadFree = true;
_isHsruUpdateThreadFree = true;
setHiruIsStarted(false);
}
_mutex.lock();
_hsruStopEvent.wait(&_mutex);
_mutex.unlock();
_isHsruReaderThreadFree = true;
_isHsruUpdateThreadFree = true;
_isReaderThreadFree = true;
_isUpdateThreadFree = true;
plxWrapper.deviceDisableInterrupt();
}
/*************************************************************************************************/
void HonaLowLevelAPI::hsruReadThread()
{
_hsruLoss = 0;
while(true)
{
if(_isReaderThreadFree)
if(_isHsruReaderThreadFree)
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();
_hsruReadDone.wakeAll();
_hsruUpdateAck.wait(&_mutex);
@ -197,16 +223,707 @@ void HonaLowLevelAPI::hsruUpdateThread()
_mutex.lock();
_hsruReadDone.wait(&_mutex);
_mutex.unlock();
if(_isUpdateThreadFree)
if(_isHsruUpdateThreadFree)
break;
//dosth
quint32 Doa = 0;
Doa = hiruGetDOA();
emit signalToTop(honaPacketList, _hsruLoss, Doa);
_hsruUpdateAck.wakeAll();
}
}
/*************************************************************************************************/
int HonaLowLevelAPI::hiruGetDOA()
void HonaLowLevelAPI::hiruMainThread()
{
QtConcurrent::run(this, &HonaLowLevelAPI::hiruReadThread);
QtConcurrent::run(this, &HonaLowLevelAPI::hiruUpdateThread);
while(true)
{
_mutex.lock();
_hsruStopEvent.wait(&_mutex);
_mutex.unlock();
//_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;
}
/*************************************************************************************************/

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

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

Write Preview
Loading…
Cancel
Save