合并

main.cpp

@@ -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;
+	ZZ_DataGrabberThread m_test;
-	QByteArray qbTest;
+	//m_test.GrabOnce();
-	m_ctrlATP.ATPInitialize(7);
+	QThread*      m_pqDataGrabberThreadHolder;
-	m_ctrlATP.GetDeviceAttribute();
+
-	m_ctrlATP.SetExposureTime(m_ctrlATP.m_adaDeviceAttr.iMinIntegrationTime);
+	m_pqDataGrabberThreadHolder = new QThread();
-	
+	m_test.moveToThread(m_pqDataGrabberThreadHolder);
-	m_ctrlATP.RecvData(qbTest);
+	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();
 }

source/ATP/ATPControl_Serial_QT.cpp

@@ -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;

source/ATP/ATPControl_Serial_QT.h

@@ -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);

source/ATP/ZZ_Types.h

@@ -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

source/Settings/SystemConfigger.cpp

@@ -1,25 +1,129 @@
 #include "SystemConfigger.h"
 
-ZZ_SysConfigger::ZZ_SysConfigger(QObject *parent /*= nullptr*/)
+ 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::Initialize()
+ {
+	 qfConfig.setFileName(m_qstrJSONConfigFilePath);
+	 bool bRes = qfConfig.open(QIODevice::ReadOnly);
+	 if (!bRes)
+	 {
+		 qDebug() << "QFile open config file Err.";
+		 return 1;
+	 }
 
-ZZ_SysConfigger::~ZZ_SysConfigger()
+	 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_IS1()
+ int ZZ_SysConfigger::LoadSettingsFromFile_IS1()
-{
+ {
-	return 0;
+	 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();
 
-int ZZ_SysConfigger::LoadSettings_iSIF()
+	
-{
+ 	return 0;
-	return 0;
+ }
-}
+ 
+ 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;
+	 }
 
-int ZZ_SysConfigger::LoadSettings_System()
+	 m_struAcqTime.qtStopTime = QTime::fromString(m_qjoJObj.value("EndTime").toString(), "hh:mm");
-{
+	 if (!m_struAcqTime.qtStopTime.isValid())
-	return 0;
+	 {
-}
+		 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;
+ }

source/Settings/SystemConfigger.h

@@ -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 Initialize();
-	int LoadSettings_iSIF();
-	int LoadSettings_System();
 
+	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;
+
+	
+
 };

source/Thread/ATPAbstractController.cpp

@@ -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;
+}

source/Thread/ATPAbstractController.h

@@ -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);
+};

source/Thread/ThreadDataGrabber.cpp

@@ -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;
+}

source/Thread/ThreadDataGrabber.h

@@ -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();
+};

source/Thread/ThreadIS1Controller.cpp

@@ -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;
+}

source/Thread/ThreadIS1Controller.h

@@ -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:
+};

source/Thread/ThreadISIFController.h

@@ -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();//
 };

source/Thread/ThreadiSIFController.cpp

@@ -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;
+}
+

source/pch.h

@@ -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 <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>