first commnit

othersoft/shuttercali/source/Thread/AbstractFSController.cpp

@@ -0,0 +1,74 @@
+#include "AbstractFSController.h"
+CAbstractFSController::CAbstractFSController(QObject* parent /*= nullptr*/)
+{
+	m_pFSCtrl = NULL;
+	m_iThreadID = -1;
+}
+
+CAbstractFSController::~CAbstractFSController()
+{
+	if (m_pFSCtrl!= 0 )
+	{
+		delete m_pFSCtrl;
+	}
+}
+
+int CAbstractFSController::SetRunParas(int iThreadID, FSInfo fsInfo)
+{
+	m_iThreadID = iThreadID;
+	m_fsInfo = fsInfo;
+	return 0;
+}
+
+
+
+int CAbstractFSController::InitializeFSControl()
+{
+	using namespace ZZ_MISCDEF::IRIS;
+	if (m_iThreadID == -1/*|| m_iDeviceType == -1*/)
+	{
+		qDebug() << "Params Err. Call SetRunParas first";
+		return 1;
+	}
+	switch (m_fsInfo.ucDeviceModel)
+	{
+	case DeviceModel::OSIFAlpha:  
+		
+		break;
+	case DeviceModel::OSIFBeta:
+		break;
+	case DeviceModel::ISIF: 
+		m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
+		m_pFSCtrl->Initialize(false, m_fsInfo.iInterface, NULL);
+		break;
+	case DeviceModel::IS1:
+		m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
+		m_pFSCtrl->Initialize(false, m_fsInfo.iInterface, NULL);
+		break;
+	case DeviceModel::IS2:
+		m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
+		m_pFSCtrl->Initialize(false, m_fsInfo.iInterface, NULL);
+		break;
+	default: 
+		break;
+	}
+	return 0;
+}
+
+int CAbstractFSController::StartAcquisition()
+{
+	//
+	qDebug() << "Starting acq" << " Thread ID:" << m_iThreadID;
+	QThread::msleep(5000);
+	qDebug() << "Stop acq" << " Thread ID:" << m_iThreadID;
+	emit SignalAcqFinished(m_iThreadID, 1);
+	return 0;
+}
+
+int CAbstractFSController::StopAcquisition()
+{
+	
+	return 0;
+}
+
+

othersoft/shuttercali/source/Thread/AbstractFSController.h

@@ -0,0 +1,38 @@
+#pragma once
+#include "pch.h"
+#include "ATPControl_Serial_QT.h"
+#include <atomic>
+
+typedef struct tagFSInfo
+{
+	ZZ_U8         ucDeviceModel;
+	int           iInterface;
+	std::string   strSN;
+}FSInfo;
+
+class CAbstractFSController :public QObject
+{
+	Q_OBJECT
+public:
+	CAbstractFSController(QObject* parent = nullptr);
+	virtual ~CAbstractFSController();
+public:
+	//call first
+	virtual int SetRunParas(int iThreadID, FSInfo fsInfo);
+
+	//create derived class from base class 
+	virtual int InitializeFSControl();
+
+private:
+	CIrisFSBase *m_pFSCtrl;
+	int m_iThreadID;
+	FSInfo m_fsInfo;
+
+public slots:
+	virtual int StartAcquisition();
+	virtual int StopAcquisition();
+
+signals:
+	void SignalAcqStarted();
+	void SignalAcqFinished(int iThreadID, int iFlagStatus);
+};

othersoft/shuttercali/source/Thread/MainDataGrabber.cpp

@@ -0,0 +1,140 @@
+#include "MainDataGrabber.h"
+
+CMainDataGrabber::CMainDataGrabber(QObject* parent /*= nullptr*/)
+{
+	m_piFlagCaptureThreadStatus = NULL;
+}
+
+CMainDataGrabber::~CMainDataGrabber()
+{
+	if (m_pControlThread.size() != 0)
+	{
+		for (int i=0;i< m_pControlThread.size();i++)
+		{
+			delete m_pControlThread[i];
+		}
+	}
+	m_pControlThread.clear();
+
+	if (m_piFlagCaptureThreadStatus!=NULL)
+	{
+		delete m_piFlagCaptureThreadStatus;
+	}
+}
+
+int CMainDataGrabber::SetGrabberParams(RunTimeGrabberParams struGrabberRTParams)
+{
+	m_struAcqTime = struGrabberRTParams.atsParams;
+	m_struDeviceContext = struGrabberRTParams.fscParams;
+	m_iTotalThreads = m_struDeviceContext.ucDeviceNumber;
+	return 0;
+}
+
+int CMainDataGrabber::InitThreadStatus()
+{
+	if (m_piFlagCaptureThreadStatus!=NULL)
+	{
+		delete m_piFlagCaptureThreadStatus;
+	}
+	m_piFlagCaptureThreadStatus = new int[m_iTotalThreads];
+	for (int i = 0; i < m_iTotalThreads; i++)
+	{
+		m_piFlagCaptureThreadStatus[i] = 0;
+	}
+	return 0;
+}
+
+int CMainDataGrabber::InitializeWorkers()
+{
+	for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
+	{
+		m_piFlagCaptureThreadStatus[i] = 0;
+
+		FSInfo fsInfo;
+		fsInfo.iInterface = m_struDeviceContext.iInterface[i];
+		fsInfo.ucDeviceModel = m_struDeviceContext.ucDeviceModel[i];
+		fsInfo.strSN = m_struDeviceContext.strSN[i];
+
+		CAbstractFSController* m_pWorkThread = new CAbstractFSController;
+		m_pWorkThread->SetRunParas(i, fsInfo);
+		//m_pWorkThread->InitializeFSControl();
+		m_pControlThread.push_back(m_pWorkThread);
+	}
+	return 0;
+}
+
+int CMainDataGrabber::StartWorkers()
+{
+
+	for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
+	{
+		QThread *pWorkThreadHolder = new QThread();
+		m_pControlThread[i]->moveToThread(pWorkThreadHolder);
+		pWorkThreadHolder->start();
+	}
+	
+	return 0;
+}
+
+int CMainDataGrabber::SetupMsgPipelines()
+{
+	//connect(this, &CMainDataGrabber::SignalStartGrabOnce, this, &CMainDataGrabber::StartGrab);
+
+	for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
+	{
+		connect(this, &CMainDataGrabber::SignalStartGrabOnce, m_pControlThread[i], &CAbstractFSController::StartAcquisition);
+		connect(m_pControlThread[i], &CAbstractFSController::SignalAcqFinished, this, &CMainDataGrabber::HandleThreadEvent);
+	}
+
+	connect(this, &CMainDataGrabber::SignalGrabOnceFinished, this, &CMainDataGrabber::GrabFinished);
+	
+	return 0;
+}
+
+int CMainDataGrabber::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 CMainDataGrabber::StartGrab()
+{
+	m_iFlagIsCapturing = true;
+	emit SignalStartGrabOnce();
+ 	while (m_iFlagIsCapturing)
+ 	{
+ 		QThread::msleep(1000);
+ 	}
+	
+	m_iFlagIsCapturing = true;
+	InitThreadStatus();
+	emit SignalStartGrabOnce();
+	while (m_iFlagIsCapturing)
+	{
+		QThread::msleep(1000);
+	}
+	qDebug() << "Allgrab stopped" << " Thread ID:" <<2;
+	return 0;
+}
+
+int CMainDataGrabber::GrabFinished()
+{
+	m_iFlagIsCapturing = false;
+	return 0;
+}
+

othersoft/shuttercali/source/Thread/MainDataGrabber.h

@@ -0,0 +1,48 @@
+#pragma once
+#include"pch.h"
+#include <vector>
+#include "AbstractFSController.h"
+
+using namespace std;
+using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
+
+class CMainDataGrabber :public QObject
+{
+	Q_OBJECT
+public:
+	CMainDataGrabber(QObject* parent = nullptr);
+	~CMainDataGrabber();
+
+private:
+	vector<CAbstractFSController *> m_pControlThread;
+	vector<QThread* >               m_pqThreadHolder;
+
+	int *m_piFlagCaptureThreadStatus;
+	int m_iTotalThreads;
+
+	int m_iFlagIsCapturing;
+
+	AcqTimeSettings m_struAcqTime;
+	FSContext   m_struDeviceContext;
+
+public:
+	//Call this first
+	int SetGrabberParams(RunTimeGrabberParams struGrabberRTParams);
+
+	int InitThreadStatus();
+	int InitializeWorkers();
+	int StartWorkers();
+
+	int SetupMsgPipelines();
+
+public slots:
+	int HandleThreadEvent(int iThreadID, int iFlagStatus);
+	int StartGrab();
+	int GrabFinished();
+
+signals:
+	void SignalStartGrabOnce();
+	void SignalStopGrab();
+	void SignalGrabOnceFinished();
+	void SignalStartGrab();
+};