mirror of
http://172.16.0.230/r/SIF/TowerOptoSifAndSpectral.git
synced 2025-10-18 19:39:43 +08:00
460 lines
11 KiB
C++
460 lines
11 KiB
C++
#include "MainDataGrabber.h"
|
|
|
|
CMainDataGrabber::CMainDataGrabber(QObject* parent /*= nullptr*/)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Signal = NULL;
|
|
m_piFlagCaptureThreadStatus_Dark = NULL;
|
|
|
|
//m_GrabTimer = new QTimer(this);
|
|
|
|
m_iFlagIsCapturing = false;
|
|
m_iFlagIsCapturing_Signal = false;
|
|
m_iFlagIsCapturing_Dark = false;
|
|
}
|
|
|
|
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_Signal!=NULL)
|
|
{
|
|
delete m_piFlagCaptureThreadStatus_Signal;
|
|
}
|
|
|
|
if (m_piFlagCaptureThreadStatus_Dark != NULL)
|
|
{
|
|
delete m_piFlagCaptureThreadStatus_Dark;
|
|
}
|
|
|
|
|
|
// if (m_GrabTimer!=NULL)
|
|
// {
|
|
// m_GrabTimer->stop();
|
|
// delete m_GrabTimer;
|
|
// }
|
|
}
|
|
|
|
void CMainDataGrabber::Delay_MSec(ZZ_U16 usMS)
|
|
{
|
|
QEventLoop qeLoop;
|
|
QTimer::singleShot(usMS, &qeLoop, SLOT(quit()));
|
|
qeLoop.exec();
|
|
}
|
|
|
|
void CMainDataGrabber::SubDataFrame(DataFrame& dfLeft, DataFrame const dfRight, int iCount)
|
|
{
|
|
for (int i = 0; i < iCount; i++)
|
|
{
|
|
dfLeft.lData[i] = dfLeft.lData[i]- dfRight.lData[i];
|
|
}
|
|
}
|
|
|
|
int CMainDataGrabber::SetContext(RunTimeGrabberParams struGrabberRTParams, DataFileProcessor &dfpSaver, Scheduler &sScheduler)
|
|
{
|
|
SetGrabberParams(struGrabberRTParams);
|
|
SetGrabberFileProcessor(dfpSaver);
|
|
SetTimer(sScheduler);
|
|
return 0;
|
|
}
|
|
|
|
void CMainDataGrabber::Init_Normal()
|
|
{
|
|
InitThreadStatus();
|
|
InitializeWorkers();
|
|
SetupMsgPipelines();
|
|
StartWorkers();
|
|
}
|
|
|
|
int CMainDataGrabber::SetGrabberParams(RunTimeGrabberParams struGrabberRTParams)
|
|
{
|
|
m_struAcqTime = struGrabberRTParams.atsParams;
|
|
m_struDeviceContext = struGrabberRTParams.fscParams;
|
|
m_struAcqPosSetting = struGrabberRTParams.apsParams;
|
|
m_struLinearShutterContext = struGrabberRTParams.lscParam;
|
|
|
|
m_iTotalThreads = m_struDeviceContext.ucDeviceNumber;
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::SetGrabberFileProcessor(DataFileProcessor &dfpSaver)
|
|
{
|
|
m_pdfpSaver = &dfpSaver;
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::SetTimer(Scheduler &sScheduler)
|
|
{
|
|
m_psScheduler = &sScheduler;
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::InitLS()
|
|
{
|
|
PortInfo piTemp;
|
|
piTemp.qstrFullPortName = QString::fromStdString(m_struLinearShutterContext.strInterface);
|
|
m_ctrlLS.ILMES_InitializeComm(piTemp, m_struLinearShutterContext.ucProtocolType, m_struLinearShutterContext.ucCmdID);
|
|
ControllerParams cpTemp;
|
|
bool res = m_ctrlLS.ILMES_InitializeParams(cpTemp);
|
|
|
|
m_ctrlLS.ILMES_SetPosition(m_struAcqPosSetting.iPosition, m_struAcqPosSetting.iTotalPosition);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::InitThreadStatus()
|
|
{
|
|
if (m_piFlagCaptureThreadStatus_Signal!=NULL)
|
|
{
|
|
delete m_piFlagCaptureThreadStatus_Signal;
|
|
}
|
|
m_piFlagCaptureThreadStatus_Signal = new int[m_iTotalThreads];
|
|
for (int i = 0; i < m_iTotalThreads; i++)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Signal[i] = 0;
|
|
}
|
|
|
|
|
|
if (m_piFlagCaptureThreadStatus_Dark != NULL)
|
|
{
|
|
delete m_piFlagCaptureThreadStatus_Dark;
|
|
}
|
|
m_piFlagCaptureThreadStatus_Dark = new int[m_iTotalThreads];
|
|
for (int i = 0; i < m_iTotalThreads; i++)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Dark[i] = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::InitializeWorkers()
|
|
{
|
|
for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Signal[i] = 0;
|
|
m_piFlagCaptureThreadStatus_Dark[i] = 0;
|
|
|
|
FSInfo fsInfo;
|
|
fsInfo.strInterface = m_struDeviceContext.strInterface[i];
|
|
fsInfo.ucDeviceModel = m_struDeviceContext.ucDeviceModel[i];
|
|
fsInfo.strSN = m_struDeviceContext.strSN[i];
|
|
fsInfo.fMaxFactor = m_struDeviceContext.fMaxFactor[i];
|
|
fsInfo.fMinFactor = m_struDeviceContext.fMinFactor[i];
|
|
fsInfo.lDepth = m_struDeviceContext.lDepth[i];
|
|
|
|
CAbstractFSController* m_pWorkThread = new CAbstractFSController;
|
|
m_pWorkThread->SetRunParas(i, fsInfo);
|
|
m_pWorkThread->InitializeFSControl();
|
|
|
|
DeviceAttribute daAttrTemp;
|
|
m_pWorkThread->GetDeviceAttr(daAttrTemp);
|
|
m_struDeviceContext.usPixels[i] = (ZZ_U16)daAttrTemp.iPixels;
|
|
for (ZZ_U16 j=0;j< daAttrTemp.iPixels;j++)
|
|
{
|
|
m_struDeviceContext.fWavelength[i][j] = daAttrTemp.fWaveLengthInNM[j];
|
|
}
|
|
|
|
m_pControlThread.push_back(m_pWorkThread);
|
|
}
|
|
m_pdfpSaver->SetDeviceInfo(m_struDeviceContext);
|
|
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_Signal, m_pControlThread[i], &CAbstractFSController::StartAcquisitionSignal);
|
|
connect(this, &CMainDataGrabber::SignalStartGrabOnce_Dark, m_pControlThread[i], &CAbstractFSController::StartAcquisitionDark);
|
|
connect(m_pControlThread[i], &CAbstractFSController::SignalAcqFinished_Signal, this, &CMainDataGrabber::HandleThreadEvent_Signal);
|
|
connect(m_pControlThread[i], &CAbstractFSController::SignalAcqFinished_Dark, this, &CMainDataGrabber::HandleThreadEvent_Dark);
|
|
}
|
|
|
|
connect(this, &CMainDataGrabber::SignalGrabOnceFinished, this, &CMainDataGrabber::GrabOnceFinished);
|
|
|
|
//connect(m_GrabTimer, &QTimer::timeout, this, &CMainDataGrabber::OnTimeCounter);
|
|
connect(m_psScheduler, &Scheduler::SignalGrabOnce, this, &CMainDataGrabber::OnTimeCounter);
|
|
|
|
connect(this, &CMainDataGrabber::SignalStartGrab, this, &CMainDataGrabber::StartGrabTimer);
|
|
|
|
connect(this, &CMainDataGrabber::SignalGrabOnceFinished_Signal, this, &CMainDataGrabber::GrabOnceFinished_Signal);
|
|
connect(this, &CMainDataGrabber::SignalGrabOnceFinished_Dark, this, &CMainDataGrabber::GrabOnceFinished_Dark);
|
|
|
|
qDebug()<<connect(this,&CMainDataGrabber::SignalLSInit,this,&CMainDataGrabber::InitLS);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::StartGrab()
|
|
{
|
|
emit SignalStartGrab();
|
|
return 0;
|
|
}
|
|
|
|
void CMainDataGrabber::Init_Self()
|
|
{
|
|
emit SignalLSInit();
|
|
return;
|
|
}
|
|
|
|
int CMainDataGrabber::HandleThreadEvent_Signal(int iThreadID, int iFlagStatus)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Signal[iThreadID] = iFlagStatus;
|
|
|
|
bool bFinished = true;
|
|
for (int i = 0; i < m_iTotalThreads; i++)
|
|
{
|
|
if (m_piFlagCaptureThreadStatus_Signal[i] != 1)
|
|
{
|
|
bFinished = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bFinished)
|
|
{
|
|
emit SignalGrabOnceFinished_Signal();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::HandleThreadEvent_Dark(int iThreadID, int iFlagStatus)
|
|
{
|
|
m_piFlagCaptureThreadStatus_Dark[iThreadID] = iFlagStatus;
|
|
|
|
bool bFinished = true;
|
|
for (int i = 0; i < m_iTotalThreads; i++)
|
|
{
|
|
if (m_piFlagCaptureThreadStatus_Dark[i] != 1)
|
|
{
|
|
bFinished = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bFinished)
|
|
{
|
|
emit SignalGrabOnceFinished_Dark();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::GrabOnceFinished_Signal()
|
|
{
|
|
m_iFlagIsCapturing_Signal = false;
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::GrabOnceFinished_Dark()
|
|
{
|
|
m_iFlagIsCapturing_Dark = false;
|
|
return 0;
|
|
}
|
|
|
|
//int CMainDataGrabber::InitLS_Self(/*RunTimeGrabberParams struGrabberRTParams, DataFileProcessor &dfpSaver, Scheduler &sScheduler*/)
|
|
//{
|
|
// //SetGrabberFileProcessor(dfpSaver);
|
|
// //SetGrabberParams(struGrabberRTParams);
|
|
// //SetTimer(sScheduler);
|
|
// InitLS();
|
|
// return 0;
|
|
//}
|
|
|
|
int CMainDataGrabber::StartGrabTimer()
|
|
{
|
|
//////////////////////////////////////////////////////////////////////////start
|
|
////check start time
|
|
// bool bStopWait = false;
|
|
// while (!bStopWait)
|
|
// {
|
|
// QTime qtTime = QTime::currentTime();
|
|
// if (m_struAcqTime.qtStartTime >= qtTime && qtTime<m_struAcqTime.qtStopTime)
|
|
// {
|
|
// bStopWait = true;
|
|
// }
|
|
// }
|
|
//start
|
|
//int iIntervalInMS =m_struAcqTime.qtInterval.hour()*3600*1000+ m_struAcqTime.qtInterval.minute()*60*1000+ m_struAcqTime.qtInterval.second()*1000;
|
|
//m_GrabTimer->start(3000);
|
|
//////////////////////////////////////////////////////////////////////////test
|
|
// 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;
|
|
////final test code eat my ass
|
|
// m_iFlagIsCapturing = 1;
|
|
//
|
|
//
|
|
// for (int i=0;i<5;i++)
|
|
// {
|
|
// m_iFlagIsCapturing_Signal = 1;
|
|
// emit SignalStartGrabOnce_Signal();
|
|
// while (m_iFlagIsCapturing_Signal)
|
|
// {
|
|
// Delay_MSec(200);
|
|
// qDebug() << "msleep" << 200;
|
|
// }
|
|
//
|
|
// m_iFlagIsCapturing_Dark = 1;
|
|
// emit SignalStartGrabOnce_Dark();
|
|
// while (m_iFlagIsCapturing_Dark)
|
|
// {
|
|
// Delay_MSec(200);
|
|
// qDebug() << "msleep" << 200;
|
|
// }
|
|
//
|
|
// }
|
|
// qDebug() << "for quit";
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::GrabOnceFinished()
|
|
{
|
|
m_iFlagIsCapturing = false;
|
|
// QTimer t;
|
|
// t.start();
|
|
// while (1)
|
|
// {
|
|
// QThread::msleep(1);
|
|
// QCoreApplication::processEvents();
|
|
// }
|
|
return 0;
|
|
}
|
|
|
|
int CMainDataGrabber::OnTimeCounter()
|
|
{
|
|
if (m_iFlagIsCapturing)
|
|
{
|
|
qDebug() << "Fatal Thread Err.";
|
|
return 1000;
|
|
}
|
|
m_iFlagIsCapturing = 1;
|
|
|
|
//return 0;
|
|
// m_struAcqPosSetting.iTotalPosition = 5;
|
|
|
|
//m_pdfpSaver->WriteDataFile();
|
|
for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
|
|
{
|
|
m_pControlThread[i]->ClearBuffer();
|
|
}
|
|
|
|
for (int i=0;i< m_struAcqPosSetting.iTotalPosition-1;i++)
|
|
{
|
|
////move to
|
|
qDebug()<<"Start ILMES_MoveToPos:"<<i+1;
|
|
m_ctrlLS.ILMES_MoveToPos(i+1);
|
|
qDebug() << "Stop ILMES_MoveToPos:" << i + 1;
|
|
m_struAcqPosSetting.iPosition[i + 1];
|
|
m_iFlagIsCapturing_Signal = 1;
|
|
emit SignalStartGrabOnce_Signal();
|
|
while (m_iFlagIsCapturing_Signal)
|
|
{
|
|
Delay_MSec(1000);
|
|
}
|
|
|
|
|
|
////move to
|
|
qDebug() << "Start ILMES_MoveToPos:" << 0;
|
|
m_ctrlLS.ILMES_MoveToPos(0);
|
|
qDebug() << "Stop ILMES_MoveToPos:" << 0;
|
|
m_struAcqPosSetting.iPosition[0];
|
|
m_iFlagIsCapturing_Dark = 1;
|
|
emit SignalStartGrabOnce_Dark();
|
|
while (m_iFlagIsCapturing_Dark)
|
|
{
|
|
Delay_MSec(1000);
|
|
}
|
|
|
|
}
|
|
|
|
std::vector<std::vector<DataFrame>> vecData;
|
|
|
|
for (ZZ_U8 i = 0; i < m_struDeviceContext.ucDeviceNumber; i++)
|
|
{
|
|
std::vector<DataFrame> vecDark, vecSignal, vecResult;
|
|
m_pControlThread[i]->GetBuffer(vecDark, vecSignal);
|
|
for (size_t j=0;j< vecDark.size();j++)
|
|
{
|
|
SubDataFrame(vecSignal[j], vecDark[j], m_struDeviceContext.usPixels[i]);
|
|
}
|
|
vecData.push_back(vecSignal);
|
|
}
|
|
m_pdfpSaver->SetData(vecData);
|
|
m_pdfpSaver->WriteDataFile();
|
|
m_iFlagIsCapturing = 0;
|
|
|
|
// qDebug() << "-------------------------------------------busy" << QTime::currentTime().toString();
|
|
// QThread::msleep(5000);
|
|
// return 0;
|
|
// if (m_iFlagIsCapturing)
|
|
// {
|
|
//
|
|
// }
|
|
// m_iFlagIsCapturing = 1;
|
|
//qDebug() << "-------------------------------------------return";
|
|
//return 1;
|
|
// for (int i = 0; i < 5; i++)
|
|
// {
|
|
// m_iFlagIsCapturing_Signal = 1;
|
|
// emit SignalStartGrabOnce_Signal();
|
|
// while (m_iFlagIsCapturing_Signal)
|
|
// {
|
|
// //Delay_MSec(1000);
|
|
// QThread::msleep(100);
|
|
// QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
|
|
// //qDebug() << "msleep" << 1000;
|
|
// }
|
|
//
|
|
// m_iFlagIsCapturing_Dark = 1;
|
|
// emit SignalStartGrabOnce_Dark();
|
|
// while (m_iFlagIsCapturing_Dark)
|
|
// {
|
|
// Delay_MSec(1000);
|
|
// QThread::msleep(100);
|
|
// QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
|
|
// //qDebug() << "msleep" << 1000;
|
|
// }
|
|
//
|
|
// }
|
|
// qDebug() << "for quit";
|
|
//
|
|
//
|
|
// emit SignalGrabOnceFinished();
|
|
return 0;
|
|
}
|
|
|