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

Update LAst Change after crash Computer

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

19
Plx/Plx.pro
View File

@ -17,19 +17,13 @@ DEFINES += QT_DEPRECATED_WARNINGS
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
SOURCES += \
$$files(*.cpp, true) \ \ \
$$files(*.cpp, true)
HEADERS += \
$$files(*.h, true) \ \ \
$$files(*.h, true)
INCLUDEPATH += $$PWD/include
# Default rules for deployment.
unix {
target.path = $$[QT_INSTALL_PLUGINS]/generic
@ -38,4 +32,13 @@ unix {
unix:!macx: LIBS += -L$$PWD/../../Plxlibrary/Library/ -lPlxApi
INCLUDEPATH += $$PWD/../../Plxlibrary/Library
DEPENDPATH += $$PWD/../../Plxlibrary/Library
INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

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

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

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

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

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

@ -1,24 +0,0 @@
#ifndef HONABUSYEXCEPTION_H
#define HONABUSYEXCEPTION_H
#include <QDebug>
#include <QString>
class HonaBusyException : public std::exception
{
private:
QString _str;
public:
HonaBusyException(QString str)
{
_str = str;
}
virtual const char* what() const throw()
{
return _str.toStdString().c_str();
}
};
#endif //HONABUSYEXCEPTION_H

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

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

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

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

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

@ -3,10 +3,9 @@
#include <QtGlobal>
#include <QList>
#include "include/LowLevel/Utils/Utils.h"
#include <QtGlobal>
#include <QList>
#include "include/LowLevel/Utils/Utils.h"
#include "LowLevel/Utils/Utils.h"
/***********************************************************************************************/
struct hiruSettings_t
{

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

@ -2,7 +2,7 @@
#define PLXWRAPPER_H
#include <QtGlobal>
#include "../../plxlib/plxinc/PlxPci_9054_Func.h"
#include "PlxPci_9054_Func.h"
class PlxWrapper
{
@ -31,4 +31,5 @@ public:
bool deviceWaitForInterrupt(quint32 timeout);
bool deviceGetChipType(quint8 revision, quint16 chipType);
};
#endif //PLXWRAPPER_H

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

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

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

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

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

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

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

@ -1,37 +1,43 @@
#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)
bool PlxWrapper::deviceOpen()
{
return PlxPci_9054_Open();
}
/*************************************************************************************************/
bool PlxWrapper::deviceClose(void)
bool PlxWrapper::deviceClose()
{
return PlxPci_9054_Close();
}
/*************************************************************************************************/
bool PlxWrapper::deviceReset(void)
bool PlxWrapper::deviceReset()
{
return PlxPci_9054_Reset();
}
/*************************************************************************************************/
bool PlxWrapper::deviceLoadE2pToFPGA(void)
bool PlxWrapper::deviceLoadE2pToFPGA()
{
return PlxPci_9054_LoadE2pToFPGA();
}
/*************************************************************************************************/
bool PlxWrapper::deviceReadEeprom(quint16 offset, quint32 length, QVector<quint32>& data)
{
@ -44,13 +50,16 @@ bool PlxWrapper::deviceReadEeprom(quint16 offset,quint32 length, QVector<quint32
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)
{
@ -67,13 +76,16 @@ bool PlxWrapper::deviceReadRegister(quint32 address,QVector<quint32> &data,quint
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)
{
@ -88,11 +100,13 @@ bool PlxWrapper::deviceWriteRegister(quint32 address,QVector<quint32> &data)
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)
{
@ -107,32 +121,38 @@ bool PlxWrapper::deviceReadMemory(quint32 localAddress ,QVector<quint32> &data,q
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)
{

54
Test/MainWindow.cpp
View File

@ -1,11 +1,13 @@
#include "MainWindow.h"
#include "ui_MainWindow.h"
HonaAPI _honaAPI;
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
connect(&_honaAPI, &HonaAPI::honaDataResult, this, &MainWindow::honaDataResultUi);
}
MainWindow::~MainWindow()
@ -13,6 +15,58 @@ MainWindow::~MainWindow()
delete ui;
}
/*************************************************************************************************/
void MainWindow::honaDataResultUi(QList<HonaPacket> honaPacketList, quint32 hsruLoss, quint32 Doa)
{
qDebug() << "honaDataResultUi inside " << honaPacketList.length();
QString _str;
for(auto i = 0; i < honaPacketList.length(); i++)
{
_str = "[" + QString::number(i) + "] " + "0x hsruLoss" + QString::number(hsruLoss);
_str += "\n *********************************************";
}
ui->dataFromMemory->setText(_str);
}
void MainWindow::on_testPLX_clicked()
{
ApiResult _resultInit = _honaAPI.init();
//ApiResult _deviceReset = _honaAPI.deviceReset();
//HonaSettings settings;
//ApiResult _configResult = _honaAPI.setConfig(settings);
//ApiResult isHsruStarted = _honaAPI.isHsruStarted();
ApiResult _hsruStartResult = _honaAPI.hsruStart();
//********************************************************
QString temp = ui->errorMonitoring->text();
if(_resultInit == ApiResult::error)
{
ui->errorMonitoring->setText(temp + "\n" + " Error _resultInit");
}
else if(_resultInit == ApiResult::success)
{
ui->errorMonitoring->setText(temp + "\n" + "success _resultInit");
}
//********************************************************
if(_hsruStartResult == ApiResult::error)
{
ui->errorMonitoring->setText(temp + "\n" + " Error _hsruStartResult");
}
else if(_hsruStartResult == ApiResult::success)
{
ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
}
//********************************************************
}
void MainWindow::on_stopHsru_clicked()
{
QString temp = ui->errorMonitoring->text();
ApiResult _hsruStop = _honaAPI.hsruStop();
if(_hsruStop == ApiResult::error)
{
ui->errorMonitoring->setText(temp + "\n" + " success _hsruStartResult");
}
}

15
Test/MainWindow.h
View File

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

46
Test/MainWindow.ui
View File

@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>311</width>
<height>281</height>
<width>543</width>
<height>475</height>
</rect>
</property>
<property name="windowTitle">
@ -17,8 +17,8 @@
<widget class="QPushButton" name="testPLX">
<property name="geometry">
<rect>
<x>100</x>
<y>120</y>
<x>250</x>
<y>40</y>
<width>89</width>
<height>25</height>
</rect>
@ -40,13 +40,49 @@
<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p align=&quot;center&quot;&gt;&lt;span style=&quot; font-size:20pt;&quot;&gt;Test PLX&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property>
</widget>
<widget class="QLabel" name="errorMonitoring">
<property name="geometry">
<rect>
<x>50</x>
<y>90</y>
<width>411</width>
<height>61</height>
</rect>
</property>
<property name="text">
<string>TextLabel</string>
</property>
</widget>
<widget class="QPushButton" name="stopHsru">
<property name="geometry">
<rect>
<x>390</x>
<y>40</y>
<width>89</width>
<height>25</height>
</rect>
</property>
<property name="text">
<string>stopHsru</string>
</property>
</widget>
<widget class="QTextEdit" name="dataFromMemory">
<property name="geometry">
<rect>
<x>50</x>
<y>160</y>
<width>451</width>
<height>261</height>
</rect>
</property>
</widget>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>311</width>
<width>543</width>
<height>22</height>
</rect>
</property>

15
Test/Test.pro
View File

@ -22,10 +22,25 @@ SOURCES += \
HEADERS += \
MainWindow.h
INCLUDEPATH += $$PWD/../Plx/include
FORMS += \
MainWindow.ui
LIBS += -L$$OUT_PWD/../Plx/ -lPlx
PRE_TARGETDEPS += $$OUT_PWD/../Plx/libPlx.a
# Default rules for deployment.
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
DEPENDPATH += $$PWD/../../Plxlibrary/Library
INCLUDEPATH += $$PWD/../../Plxlibrary
DEPENDPATH += $$PWD/../../Plxlibrary
unix:!macx: PRE_TARGETDEPS += $$PWD/../../Plxlibrary/Library/libPlxApi.a

15
Test2/MainWindow.cpp
View File

@ -0,0 +1,15 @@
#include "MainWindow.h"
#include "ui_MainWindow.h"
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
delete ui;
}

21
Test2/MainWindow.h
View File

@ -0,0 +1,21 @@
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

22
Test2/MainWindow.ui
View File

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget"/>
<widget class="QMenuBar" name="menubar"/>
<widget class="QStatusBar" name="statusbar"/>
</widget>
<resources/>
<connections/>
</ui>

31
Test2/Test2.pro
View File

@ -0,0 +1,31 @@
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG += c++11
# The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings
# depend on your compiler). Please consult the documentation of the
# deprecated API in order to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS
# You can also make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
SOURCES += \
main.cpp \
MainWindow.cpp
HEADERS += \
MainWindow.h
FORMS += \
MainWindow.ui
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

11
Test2/main.cpp
View File

@ -0,0 +1,11 @@
#include "MainWindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
Write Preview
Loading…
Cancel
Save