add Wrapper

Plx/include/LowLevel/HonaLowLevelAPI.h

@@ -2,16 +2,54 @@
 #define HONALOWLEVELAPI_H
 
 #include <QObject>
+#include "include/LowLevel/Setting/Setting.h"
+#include "include/LowLevel/HonaPacket.h"
+
 
 class HonaLowLevelAPI : public QObject
 {
-	Q_OBJECT
+    Q_OBJECT
+
+private:
+    quint32 honaRegisterBuffer[8];
+
+    bool _hsruIsStarted;
+    bool _hiruIsStarted;
+    honaSettings _honaSettings;
+
+
 public:
-	explicit HonaLowLevelAPI(QObject *parent = nullptr);
+    explicit HonaLowLevelAPI(QObject* parent = nullptr);
+    bool isHsruStarted();
+    bool isHiruStarted();
+    void deviceReset();
+    void setConfig(honaSettings* honaSettings);
+    honaSettings getConfig();
+    QString getSwVersion();
+    QString getDeviceId();
+    void hsruStarte();
+    void hiruStart();
+    void init();
 
-signals:
+    bool getHsruIsStarted() const;
+    void setHsruIsStarted(bool hsruIsStarted);
+
+    bool getHiruIsStarted() const;
+    void setHiruIsStarted(bool hiruIsStarted);
 
-public slots:
+private:
+    void writeSettingToRegisters(honaSettings& settings);
+    void setConfig();
+    void hsruMainThread();
+    void hiruReadThread();
+    void hsruUpdateThread();
+    int hiruGetDOA();
+
+signals:
+    void signalToTop(QList<HonaPacket*> honaPacketList, int i, int j);
+    //uncrustify off
+public	slots:
+    //uncrustify on
 };
 
-#endif // HONALOWLEVELAPI_H
+#endif //HONALOWLEVELAPI_H

Plx/include/LowLevel/HonaPacket.h

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

Plx/include/LowLevel/Setting/Setting.h

@@ -1,12 +1,11 @@
-
 #ifndef SETTINGS_H
 #define SETTINGS_H
 
 #include <QtGlobal>
+#include <QList>
 #include "include/LowLevel/Utils/Utils.h"
-
 /***********************************************************************************************/
-typedef struct _HIRUSETTINGS
+ struct hiruSettings_t
 {
     recorderStart recordStard;
     recorderMode recordMode;
@@ -15,9 +14,9 @@ typedef struct _HIRUSETTINGS
     quint32 timeout = 1000;
     quint32 count = 5;
 
-}hiruSettings;
+};
 /***********************************************************************************************/
-typedef struct _HSRUSETTINGS
+ struct hsruSettings_t
 {
     bool isReal = true;
     quint32 honaInt123CTHR = 128;
@@ -28,14 +27,14 @@ typedef struct _HSRUSETTINGS
     quint32 intM4_THR = 20;     //mode4
     quint32 resM4_THR = 20;     //mode4
 
-}hsruSettings;
+};
 /***********************************************************************************************/
-typedef struct _HONASETTINGS
+ struct honaSettings
 {
-    quint32 hsruSettings;
+    hiruSettings_t hiruSettings;
-    quint32 hiruSettings;
+    hsruSettings_t hsruSettings;
 
-}honaSettings;
+};
 /***********************************************************************************************/
 
 #endif // SETTING_H

Plx/include/LowLevel/Utils/Utils.h

@@ -1,25 +1,25 @@
 #ifndef UTILS_H
 #define UTILS_H
 
+#include <QtCore>
 
 /*************************************************************************************************/
-typedef  enum _APIRESULT
+enum apiResult : quint8
 {
     success,
     alreadyStarted,
     busy,
     error
-
+};
-}apiResult;
 /*************************************************************************************************/
-typedef  enum _DRXDEVICEIFCHANNEL
+enum drxDeviceIfChannel : quint8
 {
     ifChannel11,
     ifChannel12
 
-}drxDeviceIfChannel;
+};
 /*************************************************************************************************/
-typedef  enum _HONARECEIVERS
+enum honaReceivers : quint8
 {
     int123C,
     intS,
@@ -28,23 +28,22 @@ typedef  enum _HONARECEIVERS
     res4,           //Mode 4
     signalPulse     //Mode 4
 
-}honaReceivers;
+};
 /*************************************************************************************************/
-typedef  enum _RECORDERMODE
+enum recorderMode : quint8
 {
     signalChannel,
     dualChannel
 
-}recorderMode;
+};
 /*************************************************************************************************/
-typedef  enum _RECORDSTART
+enum  recorderStart : quint8
 {
-    selfTestCounter,
+    selfTestCounter= 1,
-    freeRunRecording
+    freeRunRecording = 2
-
+};
-}recorderStart;
 /*************************************************************************************************/
-typedef  enum _HONAPACKETTYPE
+enum honaPacketType : quint8
 {
     interrogationMode123C,
     interrogationModeS56,
@@ -58,7 +57,7 @@ typedef  enum _HONAPACKETTYPE
     responseMode4,
     signalPulseMode4
 
-}honaPacketType;
+};
 /*************************************************************************************************/
 
 

Plx/src/LowLevel/HonaLowLevelAPI.cpp

@@ -1,6 +1,179 @@
-#include "../../include/LowLevel/HonaLowLevelAPI.h"
+#include "qdebug.h"
+#include "QTime"
 
-HonaLowLevelAPI::HonaLowLevelAPI(QObject *parent) : QObject(parent)
+#include "include/LowLevel/HonaLowLevelAPI.h"
+#include "include/Wrapper/PlxWrapper.h"
+
+
+
+
+
+PlxWrapper plx;
+
+
+bool HonaLowLevelAPI::getHsruIsStarted() const
+{
+    return _hsruIsStarted;
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setHsruIsStarted(bool hsruIsStarted)
 {
+    _hsruIsStarted = hsruIsStarted;
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::getHiruIsStarted() const
+{
+    return _hiruIsStarted;
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setHiruIsStarted(bool hiruIsStarted)
+{
+    _hiruIsStarted = hiruIsStarted;
+}
+
+/*************************************************************************************************/
+HonaLowLevelAPI::HonaLowLevelAPI(QObject* parent) : QObject(parent)
+{
+}
 
+/*************************************************************************************************/
+bool HonaLowLevelAPI::isHsruStarted()
+{
+    return getHsruIsStarted();
+}
+
+/*************************************************************************************************/
+bool HonaLowLevelAPI::isHiruStarted()
+{
+    return getHiruIsStarted();
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::deviceReset()
+{
+//    deviceReset();
+
+
+//       bool status = deviceReset();
+//       qDebug() << "Board Reseted, status: " + status);
+
+//       if (status == PLX_STATUS.ApiSuccess)
+//       {
+//        toaStartBoard = (ulong) (DateTime.Now.Ticks);
+//        return ApiResult.Success;
+//       }
+//       else
+//        return ApiResult.Error;
+}
+
+/*************************************************************************************************/
+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);
+
+       _honaSettings = 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()
+{
 }
+
+/*************************************************************************************************/
+
+QString HonaLowLevelAPI::getSwVersion()
+{
+}
+
+/*************************************************************************************************/
+QString HonaLowLevelAPI::getDeviceId()
+{
+
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruStarte()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruStart()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::init()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::writeSettingToRegisters(honaSettings& settings)
+{
+    honaRegisterBuffer[0] = 0x00000000;
+    /************************************************************************/
+    if(settings.hiruSettings.recordStard == recorderStart::selfTestCounter)
+        honaRegisterBuffer[0] = 0x80000000;
+    else
+        honaRegisterBuffer[0] = 0x7FFFFFFF;
+     /************************************************************************/
+    if(settings.hiruSettings.recordChannel == drxDeviceIfChannel::ifChannel12)
+        honaRegisterBuffer[0] = 0x20000000;
+    else
+        honaRegisterBuffer[0] = 0xDFFFFFFF;
+    /************************************************************************/
+    if(settings.hiruSettings.recordMode == recorderMode::dualChannel)
+        honaRegisterBuffer[0] = 0x10000000;
+    else
+        honaRegisterBuffer[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;
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::setConfig()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruMainThread()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hiruReadThread()
+{
+}
+
+/*************************************************************************************************/
+void HonaLowLevelAPI::hsruUpdateThread()
+{
+}
+
+/*************************************************************************************************/
+int HonaLowLevelAPI::hiruGetDOA()
+{
+}
+
+/*************************************************************************************************/

Plx/src/Wrapper/PlxWrapper.cpp

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