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

add BlockingQueuedConnection and sig-slot check

mehrabi
mehrabi 3 years ago
parent
deece14f69
commit
aadd7e3ca3
20 changed files with 1248 additions and 1511 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. 4
      Plx/Plx.pro
  2. 54
      Plx/include/API/HonaAPI.h
  3. 22
      Plx/include/LowLevel/Exception/HonaAlreadyStartedException.h
  4. 18
      Plx/include/LowLevel/Exception/HonaBusyException.h
  5. 18
      Plx/include/LowLevel/Exception/HonaException.h
  6. 218
      Plx/include/LowLevel/HonaLowLevelAPI.h
  7. 102
      Plx/include/LowLevel/HonaPacket.h
  8. 32
      Plx/include/LowLevel/Setting/Setting.h
  9. 63
      Plx/include/LowLevel/Utils/Utils.h
  10. 76
      Plx/include/Wrapper/PlxWrapper.h
  11. 255
      Plx/src/API/HonaAPI.cpp
  12. 1614
      Plx/src/LowLevel/HonaLowLevelAPI.cpp
  13. 48
      Plx/src/LowLevel/HonaPacket.cpp
  14. 99
      Plx/src/Wrapper/PlxWrapper.cpp
  15. 97
      Test/MainWindow.cpp
  16. 25
      Test/MainWindow.h
  17. 10
      Test/MainWindow.ui
  18. 2
      Test/Test.pro
  19. 1
      Test/main.cpp
  20. 1
      ignore.save

4
Plx/Plx.pro
View File

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

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

@ -4,42 +4,42 @@
#include <QObject>
#include "LowLevel/Setting/Setting.h"
#include "include/LowLevel/Exception/HonaAlreadyStartedException.h"
#include "include/LowLevel/Exception/HonaException.h"
#include "include/LowLevel/Utils/Utils.h"
#include "include/LowLevel/HonaLowLevelAPI.h"
#include "LowLevel/Exception/HonaAlreadyStartedException.h"
#include "LowLevel/Exception/HonaException.h"
#include "LowLevel/Utils/Utils.h"
#include "LowLevel/HonaLowLevelAPI.h"
class HonaAPI : public QObject
{
Q_OBJECT
Q_OBJECT
private:
HonaLowLevelAPI _honaLowLevelAPI;
HonaLowLevelAPI _honaLowLevelAPI;
public:
HonaAPI()
{
}
~HonaAPI()
{
}
ApiResult isHsruStarted();
ApiResult isHiruStarted();
ApiResult deviceReset();
ApiResult setConfig(HonaSettings& settings);
ApiResult getConfig(HonaSettings& settings);
ApiResult getSwVersion(QString& swVerion);
ApiResult getDeviceId(QString& deviceId);
ApiResult hsruStart();
ApiResult hiruStart();
ApiResult hsruStop();
ApiResult init();
HonaAPI()
{
}
~HonaAPI()
{
}
ApiResult isHsruStarted();
ApiResult isHiruStarted();
ApiResult deviceReset();
ApiResult setConfig(HonaSettings& settings);
ApiResult getConfig(HonaSettings& settings);
ApiResult getSwVersion(QString& swVerion);
ApiResult getDeviceId(QString& deviceId);
ApiResult hsruStart();
ApiResult hiruStart();
ApiResult hsruStop();
ApiResult init();
signals:
void honaDataResult(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
void honaDataResult(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
};
#endif //HONAAPI_H

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

@ -7,21 +7,21 @@
class HonaAlreadyStartedException : public std::exception
{
private:
QString _str;
QString _str;
public:
HonaAlreadyStartedException(QString str)
{
_str = str;
qDebug() << "HonaAlreadyStartedException " << str;
}
HonaAlreadyStartedException(QString str)
{
_str = str;
qDebug() << "HonaAlreadyStartedException " << str;
}
virtual const char* what() const throw()
{
qDebug() << "HonaAlreadyStartedException return " << _str;
virtual const char* what() const throw()
{
qDebug() << "HonaAlreadyStartedException return " << _str;
return _str.toStdString().c_str();
}
return _str.toStdString().c_str();
}
};
#endif //HONAALREADYSTARTEDEXCEPTION_H

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

@ -7,18 +7,18 @@
class HonaBusyException : public std::exception
{
private:
QString _str;
QString _str;
public:
HonaBusyException(QString str)
{
_str = str;
}
HonaBusyException(QString str)
{
_str = str;
}
virtual const char* what() const throw()
{
return _str.toStdString().c_str();
}
virtual const char* what() const throw()
{
return _str.toStdString().c_str();
}
};
#endif //HONABUSYEXCEPTION_H

18
Plx/include/LowLevel/Exception/HonaException.h
View File

@ -7,18 +7,18 @@
class HonaException : public std::exception
{
private:
QString _str;
QString _str;
public:
HonaException(QString str)
{
_str = str;
}
HonaException(QString str)
{
_str = str;
}
virtual const char* what() const throw()
{
return _str.toStdString().c_str();
}
virtual const char* what() const throw()
{
return _str.toStdString().c_str();
}
};
#endif //HONAEXCEPTION_H

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

@ -1,163 +1,137 @@
#ifndef HONALOWLEVELAPI_H
#define HONALOWLEVELAPI_H
#include <QObject>
#include <QMutex>
#include <QWaitCondition>
#include "LowLevel/Setting/Setting.h"
#include "LowLevel/HonaPacket.h"
#include "LowLevel/Setting/Setting.h"
#include "HonaPacket.h"
#include "QWaitCondition"
#include "QMutex"
<<<<<<< HEAD
#include "include/LowLevel/HonaPacket.h"
#include "include/Wrapper/PlxWrapper.h"
=======
#include "LowLevel/Exception/HonaAlreadyStartedException.h"
#include "LowLevel/Exception/HonaException.h"
#include "Wrapper/PlxWrapper.h"
#include "LowLevel/Utils/Utils.h"
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
class HonaLowLevelAPI : public QObject
{
Q_OBJECT
Q_OBJECT
private:
bool _hsruIsStarted = false;
bool _hiruIsStarted = false;
quint32 _hsruLoss;
HonaSettings _honaSetting;
QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
_hiruUpdateAck1;
QList<HonaPacket> honaPacketList;
QMutex _mutex;
int _threadSforValue = 0;
<<<<<<< HEAD
bool _isReaderThreadFree = false;
bool _isUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
bool _hsruIsStarted = false;
bool _hiruIsStarted = false;
quint32 _hsruLoss;
HonaSettings _honaSetting;
QWaitCondition _hsruReadDone, _hsruUpdateAck, _hsruStopEvent, _hiruReadDone0, _hiruCountDone,
_hiruUpdateAck1;
QList<HonaPacket> honaPacketList;
PlxWrapper plxwrapper;
QMutex _mutex;
int _threadSforValue = 0;
bool _isHsruMainThreadFree = false;
bool _isHsruReaderThreadFree = false;
bool _isHsruUpdateThreadFree = false;
bool _isHiruReaderThreadFree = false;
bool _isHiruUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
PlxWrapper plxWrapper;
quint32 hsruLoss = 0;
static quint32 packetLenInt4;
static quint32 packetLenRes4;
static quint32 packetLenSinglePulse;
static quint32 packetLenInt123C;
static quint32 packetLenRes123C;
static quint32 packetLenIntS;
static quint32 packetLenResS;
=======
bool _isHsruMainThreadFree = false;
bool _isHsruReaderThreadFree = false;
bool _isHsruUpdateThreadFree = false;
bool _isHiruReaderThreadFree = false;
bool _isHiruUpdateThreadFree = false;
QVector<quint32> honaRegisterBuffer;
PlxWrapper plxWrapper;
static quint32 packetLenInt4;
static quint32 packetLenRes4;
static quint32 packetLenSinglePulse;
static quint32 packetLenInt123C;
static quint32 packetLenRes123C;
static quint32 packetLenIntS;
static quint32 packetLenResS;
static quint32 nextInt4;
static quint32 nextRes4;
static quint32 nextSinglePulse;
static quint32 nextInt123C;
static quint32 nextRes123C;
static quint32 nextIntS;
static quint32 nextResS;
quint32 lastPNInt4 = 0;
quint32 lastPNRes4 = 0;
quint32 lastPNSinglePulse = 0;
quint32 lastPNInt123C = 0;
quint32 lastPNRes123C = 0;
quint32 lastPNIntS = 0;
quint32 lastPNResS = 0;
HonaPacket tempHonaPacketInt4;
HonaPacket tempHonaPacketRes4;
HonaPacket tempHonaPacketSinglePulse;
HonaPacket tempHonaPacketInt123C;
HonaPacket tempHonaPacketRes123C;
HonaPacket tempHonaPacketIntS;
HonaPacket tempHonaPacketResS;
>>>>>>> 64f6e7f618eb5a6f1f63a4c5f377b46f1e7bc126
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;
qulonglong toaStartBoard = 0;
HonaLowLevelAPI(QObject* parent = nullptr);
~HonaLowLevelAPI()
{
}
HonaLowLevelAPI(QObject* parent = nullptr);
~HonaLowLevelAPI()
{
}
bool isHsruStarted();
bool isHiruStarted();
void deviceReset();
bool isHsruStarted();
bool isHiruStarted();
void deviceReset();
void setConfig(HonaSettings& settings);
HonaSettings getConfig();
QString getSwVersion();
QString getDeviceId();
void hsruStart();
void hiruStart();
void hsruStop();
void init();
void setConfig(HonaSettings& settings);
HonaSettings getConfig();
QString getSwVersion();
QString getDeviceId();
void hsruStart();
void hiruStart();
void hsruStop();
void init();
bool getHsruIsStarted() const;
void setHsruIsStarted(bool hsruIsStarted);
bool getHsruIsStarted() const;
void setHsruIsStarted(bool hsruIsStarted);
bool getHiruIsStarted() const;
void setHiruIsStarted(bool hiruIsStarted);
bool getHiruIsStarted() const;
void setHiruIsStarted(bool hiruIsStarted);
private:
void writeSettingToRegisters(HonaSettings& settings);
void setConfig();
void hsruMainThread();
void hsruReadThread();
void hsruUpdateThread();
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);
void writeSettingToRegisters(HonaSettings& settings);
void setConfig();
void hsruMainThread();
void hsruReadThread();
void hsruUpdateThread();
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);
public:
void hsruReaderMethod();
QVector<quint32> hsruReadHonaBuffer(honaReceivers receiver);
quint32 hsruParserInt123C(quint32 honaData,QList<HonaPacket> honaPacketList);
bool isValid(HonaPacket hp);
public:
signals:
void lowLevelHonaData(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
void lowLevelHonaData(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
//uncrustify off
//uncrustify off
public slots:
//uncrustify on
//uncrustify on
};
#endif //HONALOWLEVELAPI_H

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

@ -8,59 +8,59 @@
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;
qulonglong m_CodeL;
qulonglong m_CodeM;
quint8 m4Status;
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;
qulonglong m_CodeL;
qulonglong m_CodeM;
quint8 m4Status;
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);
/******************************************************************/
quint8 getm4Status();
void setm4Status(quint8 temp);
/******************************************************************/
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);
/******************************************************************/
quint8 getm4Status();
void setm4Status(quint8 temp);
/******************************************************************/
};
#endif //HONAPACKET_H

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

@ -9,32 +9,32 @@
/***********************************************************************************************/
struct hiruSettings_t
{
recorderStart recordStard;
recorderMode recordMode;
quint32 recordChannel;
quint32 threshold = 0;
quint32 timeout = 1000;
quint32 count = 5;
recorderStart recordStard;
recorderMode recordMode;
quint32 recordChannel;
quint32 threshold = 0;
quint32 timeout = 1000;
quint32 count = 5;
};
/***********************************************************************************************/
struct hsruSettings_t
{
bool isReal = true;
quint32 honaInt123CTHR = 128;
quint32 honaRes123CTHR = 128;
quint32 honaIntSTHR = 20;
quint32 honaResSTHR = 20;
quint32 honaSPTHR = 20; //mode4
quint32 intM4_THR = 20; //mode4
quint32 resM4_THR = 20; //mode4
bool isReal = true;
quint32 honaInt123CTHR = 128;
quint32 honaRes123CTHR = 128;
quint32 honaIntSTHR = 20;
quint32 honaResSTHR = 20;
quint32 honaSPTHR = 20;
quint32 intM4_THR = 20;
quint32 resM4_THR = 20;
};
/***********************************************************************************************/
struct HonaSettings
{
hiruSettings_t hiruSettings;
hsruSettings_t hsruSettings;
hiruSettings_t hiruSettings;
hsruSettings_t hsruSettings;
};
/***********************************************************************************************/

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

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

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

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

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

@ -1,186 +1,185 @@
#include "include/API/HonaAPI.h"
/*************************************************************************************************/
ApiResult HonaAPI::isHsruStarted()
{
try {
if(_honaLowLevelAPI.isHsruStarted())
return ApiResult::success;
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
if(_honaLowLevelAPI.isHsruStarted())
return ApiResult::success;
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::isHiruStarted()
{
try {
if(_honaLowLevelAPI.isHiruStarted())
return ApiResult::success;
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
if(_honaLowLevelAPI.isHiruStarted())
return ApiResult::success;
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::deviceReset()
{
try {
_honaLowLevelAPI.deviceReset();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
_honaLowLevelAPI.deviceReset();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::setConfig(HonaSettings& settings)
{
try {
_honaLowLevelAPI.setConfig(settings);
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
_honaLowLevelAPI.setConfig(settings);
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::getConfig(HonaSettings& settings)
{
try {
settings = _honaLowLevelAPI.getConfig();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
settings = _honaLowLevelAPI.getConfig();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::getSwVersion(QString& swVerion)
{
try {
swVerion = _honaLowLevelAPI.getSwVersion();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
swVerion = _honaLowLevelAPI.getSwVersion();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::getDeviceId(QString& deviceId)
{
try {
deviceId = _honaLowLevelAPI.getDeviceId();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
deviceId = _honaLowLevelAPI.getDeviceId();
}
catch(HonaException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::hsruStart()
{
try {
_honaLowLevelAPI.hsruStart();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
_honaLowLevelAPI.hsruStart();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::hiruStart()
{
try {
_honaLowLevelAPI.hiruStart();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
_honaLowLevelAPI.hiruStart();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::hsruStop()
{
try {
_honaLowLevelAPI.hsruStop();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
try {
_honaLowLevelAPI.hsruStop();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/
ApiResult HonaAPI::init()
{
connect(&_honaLowLevelAPI, &HonaLowLevelAPI::lowLevelHonaData, this, &HonaAPI::honaDataResult);
try {
_honaLowLevelAPI.init();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
connect(&_honaLowLevelAPI, &HonaLowLevelAPI::lowLevelHonaData, this, &HonaAPI::honaDataResult,Qt::BlockingQueuedConnection);
try {
_honaLowLevelAPI.init();
}
catch(HonaException ex)
{
return ApiResult::error;
}
catch(HonaAlreadyStartedException ex)
{
return ApiResult::error;
}
return ApiResult::success;
}
/*************************************************************************************************/

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

File diff suppressed because it is too large

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

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

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

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

97
Test/MainWindow.cpp
View File

@ -1,72 +1,75 @@
#include "MainWindow.h"
#include "ui_MainWindow.h"
HonaAPI _honaAPI;
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
ui->setupUi(this);
connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
}
MainWindow::~MainWindow()
{
delete ui;
delete ui;
}
/*************************************************************************************************/
void MainWindow::honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa)
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 *********************************************";
}
QString _str;
for(auto i = 0; i < honaPacketList.length(); i++)
{
_str += "\n[hsruLoss] :" + QString::number(hsruLoss, 16);
_str += "\n[getToa] :" + QString::number(honaPacketList[i].getToa(), 16);
_str += "\n[getDoa] :" + QString::number(honaPacketList[i].getDoa(), 16);
_str += "\n[getPa1] :" + QString::number(honaPacketList[i].getPa1(), 16);
_str += "\n[getPa2] :" + QString::number(honaPacketList[i].getPa2(), 16);
_str += "\n[getPa3] :" + QString::number(honaPacketList[i].getPa3(), 16);
_str += "\n[getPa4] :" + QString::number(honaPacketList[i].getPa4(), 16);
_str += "\n[getCode] :" + QString::number(honaPacketList[i].getCode(), 16);
_str += "\n[getCodeL] :" + QString::number(honaPacketList[i].getCodeL(), 16);
_str += "\n[getCodeM] :" + QString::number(honaPacketList[i].getCodeM(), 16);
}
ui->dataFromMemory->setText(_str);
ui->dataFromMemory->setText(_str);
}
void MainWindow::on_testPLX_clicked()
{
ApiResult _resultInit = _honaAPI.init();
//ApiResult _deviceReset = _honaAPI.deviceReset();
//HonaSettings settings;
//ApiResult _configResult = _honaAPI.setConfig(settings);
//ApiResult isHsruStarted = _honaAPI.isHsruStarted();
ApiResult _hsruStartResult = _honaAPI.hsruStart();
ApiResult _resultInit = _honaAPI.init();
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");
}
//********************************************************
//********************************************************
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");
}
//********************************************************
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");
}
QString temp = ui->errorMonitoring->text();
ApiResult _hsruStop = _honaAPI.hsruStop();
if(_hsruStop == ApiResult::error)
{
ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
}
}

25
Test/MainWindow.h
View File

@ -10,29 +10,28 @@
QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow;
}
}
QT_END_NAMESPACE
class MainWindow : public QMainWindow
{
Q_OBJECT
Q_OBJECT
private:
Ui::MainWindow* ui;
int a;
Ui::MainWindow* ui;
HonaAPI _honaAPI;
public:
MainWindow(QWidget* parent = nullptr);
~MainWindow();
MainWindow(QWidget* parent = nullptr);
~MainWindow();
//uncrustify off
//uncrustify off
private slots:
void honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa);
void on_testPLX_clicked();
void on_stopHsru_clicked();
//uncrustify on:
private:
//HonaAPI _honaAPI;
void honaDataResultUi(QList<HonaPacket> &honaPacketList, quint32 hsruLoss, quint32 Doa);
void on_testPLX_clicked();
void on_stopHsru_clicked();
//uncrustify on:
};
#endif //MAINWINDOW_H

10
Test/MainWindow.ui
View File

@ -70,11 +70,17 @@
<property name="geometry">
<rect>
<x>50</x>
<y>160</y>
<y>140</y>
<width>451</width>
<height>261</height>
<height>301</height>
</rect>
</property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOn</enum>
</property>
<property name="sizeAdjustPolicy">
<enum>QAbstractScrollArea::AdjustToContentsOnFirstShow</enum>
</property>
</widget>
</widget>
<widget class="QMenuBar" name="menubar">

2
Test/Test.pro
View File

@ -35,6 +35,7 @@ qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target
unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
INCLUDEPATH += $$PWD/../../Plxlibrary/Library
@ -44,3 +45,4 @@ INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

1
Test/main.cpp
View File

@ -5,6 +5,7 @@
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();

1
ignore.save
View File

@ -0,0 +1 @@
*.pro.user
Write Preview
Loading…
Cancel
Save