更新了底层逻辑

UnSupported/ATPAbstractController.cpp

@@ -0,0 +1,61 @@
+#include "ATPAbstractController.h"
+
+ZZ_ATPAbsCtrlThread::ZZ_ATPAbsCtrlThread(QObject* parent /*= nullptr*/)
+{
+
+}
+
+ZZ_ATPAbsCtrlThread::~ZZ_ATPAbsCtrlThread()
+{
+
+}
+
+int ZZ_ATPAbsCtrlThread::InitializeFSControl()
+{
+	qDebug() << "base class not implemented";
+	return 0;
+}
+
+int ZZ_ATPAbsCtrlThread::StartAcquisition()
+{
+	qDebug() << "base class not implemented";
+	return 0;
+}
+
+int ZZ_ATPAbsCtrlThread::StopAcquisition()
+{
+	qDebug() << "base class not implemented";
+	return 0;
+}
+
+// 
+// void ZZ_ATPAbsCtrlThread::SetWaitCondition(QWaitCondition *pFinish, QMutex *pMutex)
+// {
+// 	m_pwcFinish = pFinish;
+// 	m_pMutex = pMutex;
+// }
+
+int ZZ_ATPAbsCtrlThread::StartTestAcquisition()
+{
+	qDebug() << "base class not implemented";
+	return 0;
+// 	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);
+}
+
+int ZZ_ATPAbsCtrlThread::StopTestAcquisition()
+{
+	qDebug() << "base class not implemented";
+	return 0;
+	//QMutexLocker locker(&m_Mutex);
+	//m_bFlagIsCollecting = false;
+}

UnSupported/ATPAbstractController.h

@@ -0,0 +1,38 @@
+//////////////////////////////////////////////////////////////////////////
+//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:
+	std::atomic<bool> m_bFlagIsCollecting;
+	//QMutex *m_pMutex;
+	//QWaitCondition *m_pwcFinish;
+public:
+	 ZZ_ATPAbsCtrlThread(QObject* parent = nullptr);
+	virtual ~ZZ_ATPAbsCtrlThread();
+private:
+	CIrisFSBase *m_pFSCtrl;
+	//ZZ_ATPControl_Serial_Qt m_iSIFctrl;
+public slots:
+	
+	//create derived class from base class 
+	virtual int InitializeFSControl();
+
+	virtual int StartAcquisition();
+	virtual int StopAcquisition();
+
+	virtual int StartTestAcquisition();
+	int StopTestAcquisition();
+
+	//virtual void SetWaitCondition(QWaitCondition *pFinish, QMutex *pMutex);
+signals:
+	void SignalAcqStarted();
+	void SignalAcqFinished(int iThreadID,int iFlagStatus);
+};

UnSupported/ThreadDataGrabber.cpp

@@ -0,0 +1,165 @@
+#include "ThreadDataGrabber.h"
+
+ZZ_DataGrabberThread::ZZ_DataGrabberThread(QObject* parent /*= nullptr*/)
+{
+	m_GrabTimer = new QTimer(this);
+	m_bFlagIsCollecting = false;
+	
+
+
+	ZZ_ATPAbsCtrlThread* m_p1 = new ZZ_iSIFControlThread;
+	m_pControlThread.push_back(m_p1);
+	ZZ_ATPAbsCtrlThread* m_p2 = new ZZ_IS1ControlThread;
+	m_pControlThread.push_back(m_p2);
+	//m_iTotalThreads = 2;
+
+	InitThreadStatus();
+	SetupSignals();
+	StartGrabberThread();
+}
+
+ZZ_DataGrabberThread::~ZZ_DataGrabberThread()
+{
+	if (m_piFlagCaptureThreadStatus!=NULL)
+	{
+		delete m_piFlagCaptureThreadStatus;
+	}
+
+
+}
+
+void ZZ_DataGrabberThread::SetGrabTimer(AcqTimeSettings struAcqTimer)
+{
+	m_struAcqTime = struAcqTimer;
+}
+
+int ZZ_DataGrabberThread::SetupSignals()
+{
+	connect(m_GrabTimer, &QTimer::timeout, this, &ZZ_DataGrabberThread::OnTimeCounter);
+
+	connect(this, &ZZ_DataGrabberThread::SignalStartGrab, this, &ZZ_DataGrabberThread::StartGrab);
+
+	//connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, &m_tcISIFCtrlThread, &ZZ_ATPAbsCtrlThread::StartTestAcquisition);
+	//connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, &m_tcIS1CtrlThread,  &ZZ_ATPAbsCtrlThread::StartTestAcquisition);
+
+	connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, m_pControlThread[0], &ZZ_ATPAbsCtrlThread::StartTestAcquisition);
+	connect(this, &ZZ_DataGrabberThread::SignalStartGrabOnce, m_pControlThread[1], &ZZ_ATPAbsCtrlThread::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(m_pControlThread[0], &ZZ_ATPAbsCtrlThread::SignalAcqFinished, this, &ZZ_DataGrabberThread::HandleThreadEvent);
+	connect(m_pControlThread[1], &ZZ_ATPAbsCtrlThread::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::StartGrabCall()
+{
+	emit SignalStartGrab();
+	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_pqISIFThreadHolder = new QThread();
+	m_pControlThread[0]->moveToThread(m_pqISIFThreadHolder);
+	m_pqISIFThreadHolder->start();
+
+	m_pqIS1ThreadHolder = new QThread();
+	m_pControlThread[1]->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()
+{
+	InitThreadStatus();
+	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;
+}

UnSupported/ThreadDataGrabber.h

@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////
+//<2F><><EFBFBD>ɼ<EFBFBD><C9BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߳<EFBFBD>
+//////////////////////////////////////////////////////////////////////////
+#pragma once
+#include"pch.h"
+#include <vector>
+using namespace std;
+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:
+	vector<ZZ_ATPAbsCtrlThread *> m_pControlThread;
+	
+	//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 struAcqTimer);
+	
+	int SetupSignals();
+	int StartGrabCall();
+
+private:
+	int OnTimeCounter();
+	int InitThreadStatus();
+	int StartGrabberThread();
+public slots:
+	int TestGrab();
+	int TestGrabOnce();
+	int TestStopGrab();
+	int HandleThreadEvent(int iThreadID, int iFlagStatus);
+	int StartGrab();
+signals:
+	void SignalStartGrabOnce();
+	void SignalStopGrab();
+	void SignalGrabOnceFinished();
+	void SignalStartGrab();
+};

UnSupported/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;
+}

UnSupported/ThreadIS1Controller.h

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

UnSupported/ThreadOSIFAController.cpp

@@ -0,0 +1 @@
+#include "ThreadOSIFAController.h"

UnSupported/ThreadOSIFAController.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "ATPAbstractController.h"
+
+
+class ZZ_OSIFAControlThread :public ZZ_ATPAbsCtrlThread
+{
+	Q_OBJECT
+public:
+	ZZ_OSIFAControlThread(QObject* parent = nullptr);
+	~ZZ_OSIFAControlThread();
+public slots:
+};

UnSupported/ThreadOSIFBController.cpp

@@ -0,0 +1 @@
+#include "ThreadOSIFBController.h"

UnSupported/ThreadOSIFBController.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "ATPAbstractController.h"
+
+class ZZ_OSIFBControlThread :public ZZ_ATPAbsCtrlThread
+{
+	Q_OBJECT
+public:
+	ZZ_OSIFBControlThread(QObject* parent = nullptr);
+	~ZZ_OSIFBControlThread();
+public slots:
+};

UnSupported/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;
+}
+

UnSupported/ThreadiSIFController.h

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