xin/TowerOptoSifAndSpectral
1
0
Fork 0
mirror of http://172.16.0.230/r/SIF/TowerOptoSifAndSpectral.git synced 2025-10-18 19:39:43 +08:00
Code Issues Projects Releases Wiki Activity

合并

Browse Source
This commit is contained in:
任立新
2021-11-19 16:22:06 +08:00
parent b4c610dc71 33c422fcac
commit c0fe9a89db
15 changed files with 648 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
main.cpp
View File

@ -1,6 +1,8 @@
#include "pch.h"
#include "ATPControl_Serial_QT.h"
#include "Logger.h"
#include "ThreadDataGrabber.h"
#include "SystemConfigger.h"
using namespace std;
#pragma once
@ -13,14 +15,32 @@ int main(int argc, char *argv[])
QString qstrTest="This is a test message 2";
qDebug() << qstrTest;
cout << "This is a test message";
//////////////////////////////////////////////////////////////////////////configger
ZZ_SysConfigger test;
test.Initialize();
test.LoadSettingsFromFile_System();
test.LoadSettings_Test();
//////////////////////////////////////////////////////////////////////////test
ZZ_ATPControl_Serial_Qt m_ctrlATP;
QByteArray qbTest;
m_ctrlATP.ATPInitialize(7);
m_ctrlATP.GetDeviceAttribute();
m_ctrlATP.SetExposureTime(m_ctrlATP.m_adaDeviceAttr.iMinIntegrationTime);
ZZ_DataGrabberThread m_test;
//m_test.GrabOnce();
QThread* m_pqDataGrabberThreadHolder;
m_ctrlATP.RecvData(qbTest);
m_pqDataGrabberThreadHolder = new QThread();
m_test.moveToThread(m_pqDataGrabberThreadHolder);
m_pqDataGrabberThreadHolder->start();
m_test.StartGrab();
//QThread::msleep(5000);
//m_test.StopTestGrab();
// ZZ_ATPControl_Serial_Qt m_ctrlATP;
// QByteArray qbTest;
// m_ctrlATP.ATPInitialize(7);
// m_ctrlATP.GetDeviceAttribute();
// m_ctrlATP.SetExposureTime(m_ctrlATP.m_adaDeviceAttr.iMinIntegrationTime);
// m_ctrlATP.RecvData(qbTest);
//////////////////////////////////////////////////////////////////////////
return a.exec();
}

14
source/ATP/ATPControl_Serial_QT.cpp
View File

@ -447,9 +447,12 @@ int ZZ_ATPControl_Serial_Qt::PerformAutoExposure(float fMinScaleFactor, float fM
return 0;
}
int ZZ_ATPControl_Serial_Qt::SetExtShutter(int iShutterA, int iShutterB)
int ZZ_ATPControl_Serial_Qt::SetExtShutter(int iShutterUP0, int iShutterDOWN1, int iShutterDOWN2, int iShutterDOWN3)
{
return 0;
qDebug() << "stub code not implemented";
return -1;
}
int ZZ_ATPControl_Serial_Qt::SetExposureTime(int iExposureTimeInMS)
@ -527,6 +530,13 @@ int ZZ_ATPControl_Serial_Qt::SingleShot(int &iPixels)
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShotDark(ATPDataFrame &dfData)
{
SetExtShutter(0,0,0,0);
SingleShot(dfData);
return 0;
}
//void ZZ_ATPControl_Serial_Qt::ReadMessage()
//{
// QByteArray qbTemp, qbTemp1;

18
source/ATP/ATPControl_Serial_QT.h
View File

@ -1,3 +1,6 @@
//////////////////////////////////////////////////////////////////////////
//ATP<54><50><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
@ -14,25 +17,38 @@ public:
virtual ~ZZ_ATPControl_Serial_Qt();
public:
//<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
int SetBaudRate(int iBaud);
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
int ATPInitialize( ZZ_U8 ucPortNumber);
//<2F>ر<EFBFBD><D8B1>豸
int ATPClose();
//<2F><><EFBFBD>β<EFBFBD><CEB2>Բɼ<D4B2> <20><><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int SingleShot(int &iPixels);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
int SingleShot(ATPDataFrame &dfData);
//<2F><><EFBFBD>ΰ<EFBFBD><CEB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɼ<EFBFBD>
int SingleShotDark(ATPDataFrame &dfData);
int SingleShotDeducted(ATPDataFrame &dfData);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int SetExposureTime(int iExposureTimeInMS);
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int GetExposureTime(int &iExposureTimeInMS);
//int GetWaveLength(float *pfWaveLength);
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
int GetDeviceInfo();
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int GetDeviceAttribute();
int GetDeviceListInfo(); //use type name to enum
int GetDeviceTemperature(float &fTemperature);
//<2F>Զ<EFBFBD><D4B6>ع<EFBFBD>
int PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float &fPredictedExposureTime);
#ifdef _DEBUG
@ -49,7 +65,7 @@ private:
ATPDeviceAttribute m_adaDeviceAttr;
//////////////////////////////////////////////////////////////////////////shutter control stub code s
int SetExtShutter(int iShutterA, int iShutterB); //0:close 1:open
int SetExtShutter(int iShutterUP0, int iShutterDOWN1,int iShutterDOWN2,int iShutterDOWN3); //0:close 1:open
//////////////////////////////////////////////////////////////////////////shutter control stub code e
int SendCommand(QByteArray qbCommand);
int RecvData(QByteArray &qbData);

87
source/ATP/ZZ_Types.h
View File

@ -1,3 +1,6 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
@ -7,7 +10,7 @@ namespace ZZ_MISCDEF
typedef unsigned short int ZZ_U16;
typedef unsigned long int ZZ_U32;
//ATPָ<50><D6B8>ת<EFBFBD><D7AA>
namespace ATP
{
const int MAX_SPECTRUM_SIZE = 4096;
@ -46,6 +49,7 @@ namespace ZZ_MISCDEF
ATP6500
};
//<2F><><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>
typedef struct tagATPDataFrame
{
unsigned short usExposureTime;
@ -54,12 +58,14 @@ namespace ZZ_MISCDEF
double dTimes = 0;
}ATPDataFrame;
//<2F>豸<EFBFBD><E8B1B8>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>
typedef struct tagATPDeviceInfo
{
std::string strPN;
std::string strSN;
}ATPDeviceInfo;
//<2F>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
typedef struct tagATPDeviceAttribute
{
int iPixels;
@ -74,24 +80,101 @@ namespace ZZ_MISCDEF
}
//<2F><><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
namespace ZZ_RUNPARAMS
{
typedef struct tagAcquisitionTimeSettings
{
QTime qtStartTime;
QTime qtStopTime;
QTime qtInterval;
}AcqTimeSettings;
typedef struct tagATPCalibrationSettings
{
//Up0 Down1,2,3
QString qsISIF_CalibrationFilePath[4];
QString qsIS1_CalibrationFilePath[4];
}ATPCalibrationSettings;
}
//ϵͳ<CFB5><CDB3><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>ṹ
namespace ZZ_DATAFILE
{
typedef struct tagEnvironmentalContext
{
QString qstrUTCDateTime;
QString qstrLocation;
QString qstrGPS_Longtitude;
QString qstrGPS_Latitude;
QString qstrGPS_Altitude;
QString qstrGPS_North;
QString qstrCaseTemperature;
QString qstrCaseHumidity;
}EContext;
typedef struct tagManmadeEnviromentalContext
{
QString qstrOriFileName;
QString qstrInstallationTime;
QString qstrISIFCalibrationTime;
QString qstrIS1CalibrationTime;
QString qstrNameOfMaintenanceStaff;
QString qstrPhoneNumberOfMaintenanceStaff;
QString qstrDownloadUserID;
QString qstrDownlaodAddress;
QString qstrHTTPServer;
}MEContext;
}EnvironmentalContext;
typedef struct tagIS1Information
{
QString qstrSN_ATP;
QString qstrSN_IRIS;
QString qstrCalFile_U0;
QString qstrCalFile_D1;
QString qstrCalFile_D2;
QString qstrCalFile_D3;
int iPixelCount;
int iExposureTimeInMS_U0;
int iExposureTimeInMS_D1;
int iExposureTimeInMS_D2;
int iExposureTimeInMS_D3;
float fTemperature_U0;
float fTemperature_D1;
float fTemperature_D2;
float fTemperature_D3;
}IS1Info;
typedef struct tagISIFInformation
{
QString qstrSN_ATP;
QString qstrSN_IRIS;
QString qstrCalFile_U0;
QString qstrCalFile_D1;
QString qstrCalFile_D2;
QString qstrCalFile_D3;
int iPixelCount;
int iExposureTimeInMS_U0;
int iExposureTimeInMS_D1;
int iExposureTimeInMS_D2;
int iExposureTimeInMS_D3;
float fTemperature_U0;
float fTemperature_D1;
float fTemperature_D2;
float fTemperature_D3;
}ISIFInfo;
typedef struct tagATPDataHeader

112
source/Settings/SystemConfigger.cpp
View File

@ -2,24 +2,128 @@
ZZ_SysConfigger::ZZ_SysConfigger(QObject *parent /*= nullptr*/)
{
m_qstrFilePath = QCoreApplication::applicationDirPath()+ "/Settings/DeviceSettings.ini";
#ifdef _DEBUG
m_qstrFilePath = QCoreApplication::applicationDirPath() + "home/data/Settings/DeviceSettings.ini";
m_qstrJSONConfigFilePath = QCoreApplication::applicationDirPath() + "/home/data/Settings/config.json";
#else
m_qstrJSONConfigFilePath = ("/home/data/Setting/config.json");
#endif // DEBUG
}
ZZ_SysConfigger::~ZZ_SysConfigger()
{
if (qfConfig.isOpen())
{
qfConfig.close();
}
}
int ZZ_SysConfigger::LoadSettings_IS1()
int ZZ_SysConfigger::Initialize()
{
qfConfig.setFileName(m_qstrJSONConfigFilePath);
bool bRes = qfConfig.open(QIODevice::ReadOnly);
if (!bRes)
{
qDebug() << "QFile open config file Err.";
return 1;
}
m_qbaJData = qfConfig.readAll();
m_qjdJDoc= QJsonDocument::fromJson(m_qbaJData, &m_qjpeJErr);
if (m_qjpeJErr.error != QJsonParseError::NoError)
{
qDebug() << m_qjpeJErr.errorString();
return 2;
}
m_qjoJObj = m_qjdJDoc.object();
return 0;
}
int ZZ_SysConfigger::LoadSettings_iSIF()
int ZZ_SysConfigger::LoadSettingsFromFile_IS1()
{
m_struIS1Info.qstrCalFile_U0 = m_qjoJObj.value("IS1UpCalFile").toString();
m_struIS1Info.qstrCalFile_D1 = m_qjoJObj.value("IS1DownCalFile1").toString();
m_struIS1Info.qstrCalFile_D2 = m_qjoJObj.value("IS1DownCalFile2").toString();
m_struIS1Info.qstrCalFile_D3 = m_qjoJObj.value("IS1DownCalFile3").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettings_System()
int ZZ_SysConfigger::LoadSettingsFromFile_iSIF()
{
m_struISIFInfo.qstrCalFile_U0 = m_qjoJObj.value("SIFUpCalFile").toString();
m_struISIFInfo.qstrCalFile_D1 = m_qjoJObj.value("SIFDownCalFile1").toString();
m_struISIFInfo.qstrCalFile_D2 = m_qjoJObj.value("SIFDownCalFile2").toString();
m_struISIFInfo.qstrCalFile_D3 = m_qjoJObj.value("SIFDownCalFile3").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_System()
{
// QString qstr = m_qjoJObj.value("IntervalTime").toString();
m_struAcqTime.qtStartTime=QTime::fromString(m_qjoJObj.value("BeginTime").toString(), "hh:mm");
if (!m_struAcqTime.qtStartTime.isValid())
{
qDebug() << "Invalid BeginTime";
return 1;
}
m_struAcqTime.qtInterval = QTime::fromString(m_qjoJObj.value("IntervalTime").toString(), "mm");
if (!m_struAcqTime.qtInterval.isValid())
{
qDebug() << "Invalid BeginTime";
return 1;
}
m_struAcqTime.qtStopTime = QTime::fromString(m_qjoJObj.value("EndTime").toString(), "hh:mm");
if (!m_struAcqTime.qtStopTime.isValid())
{
qDebug() << "Invalid BeginTime";
return 1;
}
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_MISC()
{
m_struEC.qstrLocation = m_qjoJObj.value("Location").toString();
m_struEC.qstrGPS_Altitude = m_qjoJObj.value("GPS_Altitude").toString();
m_struEC.qstrGPS_Latitude = m_qjoJObj.value("GPS_Latitude").toString();
m_struEC.qstrGPS_Longtitude = m_qjoJObj.value("GPS_Longtitude").toString();
m_struEC.qstrGPS_North = m_qjoJObj.value("GPS_North").toString();
m_struMEC.qstrInstallationTime = m_qjoJObj.value("InstallationTime").toString();
m_struMEC.qstrISIFCalibrationTime = m_qjoJObj.value("ISIFCalibrationTime").toString();
m_struMEC.qstrIS1CalibrationTime = m_qjoJObj.value("IS1CalibrationTime").toString();
m_struMEC.qstrNameOfMaintenanceStaff = m_qjoJObj.value("NameOfMaintenanceStaff").toString();
m_struMEC.qstrPhoneNumberOfMaintenanceStaff = m_qjoJObj.value("PhoneNumberOfMaintenanceStaff").toString();
m_struMEC.qstrDownloadUserID = m_qjoJObj.value("DownloadUserID").toString();
m_struMEC.qstrDownlaodAddress = m_qjoJObj.value("DownlaodAddress").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettings_Test()
{
QFile qfTest(m_qstrJSONConfigFilePath);
qfTest.open(QFile::ReadOnly);
QByteArray qbJData = qfTest.readAll();
QJsonParseError jerr;
QJsonDocument jdoc(QJsonDocument::fromJson(qbJData, &jerr));
if (jerr.error!= QJsonParseError::NoError)
{
qDebug() << jerr.errorString();
}
QJsonObject rootobj = jdoc.object();
QStringList key = rootobj.keys();
QString qtest1 = rootobj.value(rootobj.keys().at(15)).toString();
return 0;
}

32
source/Settings/SystemConfigger.h
View File

@ -1,7 +1,8 @@
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
class ZZ_SysConfigger :public QObject
@ -12,10 +13,31 @@ public:
ZZ_SysConfigger(QObject *parent = nullptr);
virtual ~ZZ_SysConfigger();
public:
int LoadSettings_IS1();
int LoadSettings_iSIF();
int LoadSettings_System();
int Initialize();
int LoadSettingsFromFile_IS1();
int LoadSettingsFromFile_iSIF();
int LoadSettingsFromFile_System();
int LoadSettingsFromFile_MISC();
int LoadSettings_Test();
public:
AcqTimeSettings m_struAcqTime;
EContext m_struEC;
MEContext m_struMEC;
IS1Info m_struIS1Info;
ISIFInfo m_struISIFInfo;
private:
QString m_qstrFilePath;
QString m_qstrJSONConfigFilePath;
QFile qfConfig;
QByteArray m_qbaJData;
QJsonParseError m_qjpeJErr;
QJsonObject m_qjoJObj;
QJsonDocument m_qjdJDoc;
};

40
source/Thread/ATPAbstractController.cpp Normal file
View File

@ -0,0 +1,40 @@
#include "ATPAbstractController.h"
ZZ_ATPAbsCtrlThread::ZZ_ATPAbsCtrlThread(QObject* parent /*= nullptr*/)
{
}
ZZ_ATPAbsCtrlThread::~ZZ_ATPAbsCtrlThread()
{
}
//
// void ZZ_ATPAbsCtrlThread::SetWaitCondition(QWaitCondition *pFinish, QMutex *pMutex)
// {
// m_pwcFinish = pFinish;
// m_pMutex = pMutex;
// }
int ZZ_ATPAbsCtrlThread::StartTestAcquisition()
{
m_bFlagIsCollecting = true;
while (m_bFlagIsCollecting)
{
//QMutexLocker locker(&m_Mutex);
QThread::msleep(1000);
qDebug() << "ThreadATPAbsController busy";
}
qDebug() << "ThreadATPAbsController quit";
//m_pwcFinish->wakeAll();
emit SignalAcqFinished(0,1);
return 0;
}
int ZZ_ATPAbsCtrlThread::StopTestAcquisition()
{
//QMutexLocker locker(&m_Mutex);
m_bFlagIsCollecting = false;
return 0;
}

32
source/Thread/ATPAbstractController.h Normal file
View File

@ -0,0 +1,32 @@
//////////////////////////////////////////////////////////////////////////
//ATP<54>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include "ATPControl_Serial_QT.h"
#include <atomic>
class ZZ_ATPAbsCtrlThread :public QObject
{
Q_OBJECT
public:
public:
std::atomic<bool> m_bFlagIsCollecting;
//QMutex *m_pMutex;
//QWaitCondition *m_pwcFinish;
public:
ZZ_ATPAbsCtrlThread(QObject* parent = nullptr);
virtual ~ZZ_ATPAbsCtrlThread();
private:
ZZ_ATPControl_Serial_Qt m_iSIFctrl;
public slots:
//virtual void SetWaitCondition(QWaitCondition *pFinish, QMutex *pMutex);
virtual int StartTestAcquisition();
int StopTestAcquisition();
signals:
void SignalAcqStarted();
void SignalAcqFinished(int iThreadID,int iFlagStatus);
};

132
source/Thread/ThreadDataGrabber.cpp
View File

@ -0,0 +1,132 @@
#include "ThreadDataGrabber.h"
ZZ_DataGrabberThread::ZZ_DataGrabberThread(QObject* parent /*= nullptr*/)
{
m_GrabTimer = new QTimer(this);
m_bFlagIsCollecting = false;
InitThreadStatus();
SetupSignals();
StartGrabberThread();
//m_iTotalThreads = 2;
}
ZZ_DataGrabberThread::~ZZ_DataGrabberThread()
{
if (m_piFlagCaptureThreadStatus!=NULL)
{
delete m_piFlagCaptureThreadStatus;
}
}
void ZZ_DataGrabberThread::SetGrabTimer(AcqTimeSettings struAcqTime)
{
m_struAcqTime = struAcqTime;
}
int ZZ_DataGrabberThread::SetupSignals()
{
connect(m_GrabTimer, &QTimer::timeout, this, &ZZ_DataGrabberThread::OnTimeCounter);
connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, &m_tcISIFCtrlThread, &ZZ_iSIFControlThread::StartTestAcquisition);
connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, &m_tcIS1CtrlThread, &ZZ_IS1ControlThread::StartTestAcquisition);
//connect(this, &ZZ_DataGrabberThread::SignalStopGrab, &m_tcISIFCtrlThread, &ZZ_iSIFControlThread::StopTestAcquisition, Qt::DirectConnection);
//connect(this, &ZZ_DataGrabberThread::SignalStopGrab, &m_tcIS1CtrlThread, &ZZ_IS1ControlThread::StopTestAcquisition, Qt::DirectConnection);
connect(&m_tcISIFCtrlThread, &ZZ_iSIFControlThread::SignalAcqFinished, this, &ZZ_DataGrabberThread::HandleThreadEvent);
connect(&m_tcIS1CtrlThread, &ZZ_IS1ControlThread::SignalAcqFinished, this, &ZZ_DataGrabberThread::HandleThreadEvent);
connect(this, &ZZ_DataGrabberThread::SignalGrabOnceFinished, this, &ZZ_DataGrabberThread::TestGrabOnce);
//m_tcISIFCtrlThread.SetWaitCondition(&m_wcWaitISIF,&m_mTestMutex);
//m_tcIS1CtrlThread.SetWaitCondition(&m_wcWaitIS1, &m_mTestMutex);
return 0;
}
int ZZ_DataGrabberThread::StartGrab()
{
m_GrabTimer->start(1000);
return 0;
}
int ZZ_DataGrabberThread::StartGrabberThread()
{
m_pqISIFThreadHolder = new QThread();
m_tcISIFCtrlThread.moveToThread(m_pqISIFThreadHolder);
m_pqISIFThreadHolder->start();
m_pqIS1ThreadHolder = new QThread();
m_tcIS1CtrlThread.moveToThread(m_pqIS1ThreadHolder);
m_pqIS1ThreadHolder->start();
//m_stCameraServiceThread.SetController(this);
return 0;
}
int ZZ_DataGrabberThread::InitThreadStatus()
{
m_piFlagCaptureThreadStatus = new int[m_iTotalThreads];
for (int i=0;i< m_iTotalThreads;i++)
{
m_piFlagCaptureThreadStatus[i] = 0;
}
return 0;
}
int ZZ_DataGrabberThread::TestGrab()
{
m_bFlagIsCollecting = true;
while (m_bFlagIsCollecting)
{
emit SignalStartGrabOnce();
//m_mTestMutex.lock();
//m_wcWaitISIF.wait(&m_mTestMutex);
//m_mTestMutex.lock();
//m_wcWaitIS1.wait(&m_mTestMutex);
//m_mTestMutex.unlock();
}
return 0;
}
int ZZ_DataGrabberThread::TestGrabOnce()
{
emit SignalStartGrabOnce();
return 0;
}
int ZZ_DataGrabberThread::TestStopGrab()
{
//emit SignalStopGrab();
m_tcISIFCtrlThread.StopTestAcquisition();
m_tcIS1CtrlThread.StopTestAcquisition();
return 0;
}
int ZZ_DataGrabberThread::HandleThreadEvent(int iThreadID, int iFlagStatus)
{
m_piFlagCaptureThreadStatus[iThreadID] = iFlagStatus;
bool bFinished = true;
for (int i = 0; i < m_iTotalThreads; i++)
{
if (m_piFlagCaptureThreadStatus[i] != 1)
{
bFinished = false;
break;
}
}
if (bFinished)
{
emit SignalGrabOnceFinished();
}
return 0;
}
int ZZ_DataGrabberThread::OnTimeCounter()
{
qDebug() << "OnTimeCounter";
return 0;
}

50
source/Thread/ThreadDataGrabber.h
View File

@ -1 +1,51 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD>ɼ<EFBFBD><C9BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߳<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include"pch.h"
#include "ThreadIS1Controller.h"
#include "ThreadiSIFController.h"
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
class ZZ_DataGrabberThread :public QObject
{
Q_OBJECT
public:
ZZ_DataGrabberThread(QObject* parent = nullptr);
~ZZ_DataGrabberThread();
public:
//QWaitCondition m_wcWaitISIF,m_wcWaitIS1;
//QMutex m_mTestMutex;
private:
ZZ_iSIFControlThread m_tcISIFCtrlThread;
ZZ_IS1ControlThread m_tcIS1CtrlThread;
QThread* m_pqISIFThreadHolder;
QThread* m_pqIS1ThreadHolder;
std::atomic<bool> m_bFlagIsCollecting;
std::atomic<bool> m_bFlagIsCollectingFinished;
int *m_piFlagCaptureThreadStatus;
const int m_iTotalThreads = 2;
QTimer *m_GrabTimer;
AcqTimeSettings m_struAcqTime;
public:
void SetGrabTimer(AcqTimeSettings struAcqTime);
int SetupSignals();
int StartGrab();
private:
int OnTimeCounter();
int InitThreadStatus();
int StartGrabberThread();
public slots:
int TestGrab();
int TestGrabOnce();
int TestStopGrab();
int HandleThreadEvent(int iThreadID, int iFlagStatus);
signals:
void SignalStartGrabOnce();
void SignalStopGrab();
void SignalGrabOnceFinished();
};

31
source/Thread/ThreadIS1Controller.cpp
View File

@ -0,0 +1,31 @@
#include "ThreadIS1Controller.h"
ZZ_IS1ControlThread::ZZ_IS1ControlThread(QObject* parent /*= nullptr*/)
{
}
ZZ_IS1ControlThread::~ZZ_IS1ControlThread()
{
}
int ZZ_IS1ControlThread::StartTestAcquisition()
{
// m_bFlagIsCollecting = true;
// while (m_bFlagIsCollecting)
// {
// //QMutexLocker locker(&m_Mutex);
// QThread::msleep(1000);
// qDebug() << "ThreadIS1Controller busy";
// }
// qDebug() << "ThreadIS1Controller quit";
qDebug() << "ThreadIS1Controller busy";
QThread::msleep(1000);
qDebug() << "ThreadIS1Controller quit";
//m_pwcFinish->wakeAll();
emit SignalAcqFinished(1,1);
return 0;
}

13
source/Thread/ThreadIS1Controller.h
View File

@ -1 +1,14 @@
#pragma once
#include "ATPAbstractController.h"
class ZZ_IS1ControlThread :public ZZ_ATPAbsCtrlThread
{
Q_OBJECT
public:
ZZ_IS1ControlThread(QObject* parent = nullptr);
~ZZ_IS1ControlThread();
private:
public slots:
int StartTestAcquisition();
signals:
};

10
source/Thread/ThreadISIFController.h
View File

@ -1,12 +1,18 @@
#pragma once
#include "pch.h"
#include "ATPAbstractController.h"
class ZZ_iSIFControlThread :public QObject
class ZZ_iSIFControlThread :public ZZ_ATPAbsCtrlThread
{
Q_OBJECT
public:
private:
public:
ZZ_iSIFControlThread(QObject* parent = nullptr);
~ZZ_iSIFControlThread();
public slots:
int StartTestAcquisition();
int test();//
};

37
source/Thread/ThreadiSIFController.cpp
View File

@ -0,0 +1,37 @@
#include "ThreadiSIFController.h"
ZZ_iSIFControlThread::ZZ_iSIFControlThread(QObject* parent /*= nullptr*/)
{
}
ZZ_iSIFControlThread::~ZZ_iSIFControlThread()
{
}
int ZZ_iSIFControlThread::test()
{
return 0;
}
int ZZ_iSIFControlThread::StartTestAcquisition()
{
// m_bFlagIsCollecting = true;
// while (m_bFlagIsCollecting)
// {
// //QMutexLocker locker(&m_Mutex);
// QThread::msleep(1000);
// qDebug() << "ThreadiSIFController busy";
// }
// qDebug() << "ThreadiSIFController quit";
qDebug() << "ThreadiSIFController busy";
QThread::msleep(2000);
qDebug() << "ThreadiSIFController quit";
//m_pwcFinish->wakeAll();
emit SignalAcqFinished(0,1);
return 0;
}

14
source/pch.h
View File

@ -1,10 +1,22 @@
#pragma once
#include <iostream>
#include <QtCore/QCoreApplication>
#include <QtCore/QTime>
#include <QString>
#include <QDebug>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QDir>
#include <QObject>
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
////////////////////////////json
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonParseError>
////////////////////////////time
#include <QtCore/QTime>
#include <QDateTime>
#include <QTimer>