zhangzhuo/TowerOptoSifAndSpectral_Tooling
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

first commnit

Browse Source
This commit is contained in:
zhangzhuo
2022-08-16 09:26:36 +08:00
commit 11d5fc83c2
941 changed files with 168924 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

314
source/Uploader/DataFileTransfer.cpp Normal file
View File

@ -0,0 +1,314 @@
#include "DataFileTransfer.h"
ZZ_HttpTransfer::ZZ_HttpTransfer(QObject* parent /*= nullptr*/)
{
m_pNetworkManager = nullptr;
m_pNetworkManagerThread = nullptr;
//connect(this, &ZZ_HttpTransfer::SignalInit_Self, this, &ZZ_HttpTransfer::SlotInit_Self);
}
ZZ_HttpTransfer::~ZZ_HttpTransfer()
{
if (m_pNetworkManager!= nullptr)
{
delete m_pNetworkManager;
}
if (m_pNetworkManagerThread != nullptr)
{
delete m_pNetworkManagerThread;
}
}
// void ZZ_HttpTransfer::Init_Self()
// {
// emit SignalInit_Self();
// }
int ZZ_HttpTransfer::SendData()
{
if (m_pNetworkManagerThread == nullptr)
{
m_pNetworkManagerThread = new QNetworkAccessManager();
connect(m_pNetworkManagerThread, SIGNAL(finished(QNetworkReply*)), this, SLOT(SlotReplyFinishedThread(QNetworkReply*)));
}
QNetworkRequest qnRequest;
qnRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/json"));
QString qstrURL = m_qstrUploadURL + "/Data_uper.php";
qnRequest.setUrl(QUrl(qstrURL));
QByteArray qbSend;
QString qstrSend;
for (int i = 0; i < m_struGrabberRTParams.fscParams.ucDeviceNumber; i++)
{
for (int j = 0; j < m_struGrabberRTParams.apsParams.iTotalPosition - 1; j++)
{
qstrSend.clear();
qstrSend = m_vecCalcedData[i][j].qstrGrabDate + "##";
qstrSend += /*"FS_SN:" +*/ QString::fromLocal8Bit(m_struGrabberRTParams.fscParams.strSN[i].c_str()) + "##";
qstrSend += /*"Position:" +*/ QString("%1").arg(j + 1) + "##";
qstrSend += /*"ExpTime:" +*/ QString("%1").arg(m_vecCalcedData[i][j].usExposureTimeInMS) + "##";
qstrSend += /*"Bands:" +*/ QString("%1").arg(m_vecCalcedData[i][j].iPixels) + "##";
qstrSend += /*"temp:" +*/ QString("%1").arg(m_vecCalcedData[i][j].fTemperature) + "##";
//send
qbSend.clear();
qbSend.append(qstrSend.toLatin1());
qbSend.append((char*)m_vecCalcedData[i][j].fData, sizeof(float)*m_vecCalcedData[i][j].iPixels);
m_pNetworkManagerThread->post(qnRequest, qbSend);
qDebug() << "Network Sending: Data";
m_iFlagIsReplied = 0;
int iCount = 0;
while (!m_iFlagIsReplied)
{
iCount++;
Delay_MSec(500);
if (iCount > 20)
{
m_iFlagIsReplied = 1;
qDebug() << "Reply Timeout:Upload Data ";
qDebug() << "UpLoadAddr:" << qstrURL;
}
}
}
}
return 0;
}
int ZZ_HttpTransfer::SendInfo()
{
if (m_pNetworkManager == nullptr)
{
m_pNetworkManager = new QNetworkAccessManager();
connect(m_pNetworkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(SlotReplyFinished(QNetworkReply*)));
}
QNetworkRequest qnRequest;
qnRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/json"));
QString qstrURL = m_qstrUploadURL + "/Dev_info_uper.php";
qnRequest.setUrl(QUrl(qstrURL));
//qnRequest.setUrl(QUrl("http://172.16.0.234/fileup/Dev_info_uper.php"));
QByteArray qbSend;
QString qstrSend;
QString qstrWaveLength;
m_iFlagIsReplied = false;
for (int i = 0; i < m_struGrabberRTParams.fscParams.ucDeviceNumber; i++)
{
qstrSend = "Location:" + QString("%1").arg(m_struEC.qstrLocation) + "####";
qstrSend += "DEV_SN:" + QString("%1").arg(m_struEC.qstrDEV_SN) + "####";
qstrSend += "FS_SN:" + QString::fromLocal8Bit(m_struGrabberRTParams.fscParams.strSN[i].c_str()) + "####";
qstrSend += "GPS_Longtitude:" + QString("%1").arg(m_struEC.qstrGPS_Longtitude) + "####";
qstrSend += "GPS_Latitude:" + QString("%1").arg(m_struEC.qstrGPS_Latitude) + "####";
qstrSend += "GPS_Altitude:" + QString("%1").arg(m_struEC.qstrGPS_Altitude) + "####";
qstrSend += "GPS_North:" + QString("%1").arg(m_struEC.qstrGPS_North) + "####";
qstrSend += "InstallationTime:" + QString("%1").arg(m_struMEC.qstrInstallationTime) + "####";
qstrSend += "NameOfMaintenanceStaff:" + QString("%1").arg(m_struMEC.qstrNameOfMaintenanceStaff) + "####";
qstrSend += "PhoneNumberOfMaintenanceStaff:" + QString("%1").arg(m_struMEC.qstrPhoneNumberOfMaintenanceStaff) + "####";
qstrSend += "Bands:" + QString("%1").arg(m_struGrabberRTParams.fscParams.usPixels[i]) + "####";
qstrSend += "Positions:" + QString("%1").arg(m_struGrabberRTParams.apsParams.iTotalPosition-1) + "####";
qstrSend += "WaveLength:";
qDebug() << m_struEC.qstrDEV_SN;
for (int j=0;j< m_struGrabberRTParams.fscParams.usPixels[i];j++)
{
qstrWaveLength = QString("%1").arg(m_struGrabberRTParams.fscParams.fWavelength[i][j]);
qstrSend += qstrWaveLength;
if (j == m_struGrabberRTParams.fscParams.usPixels[i]-1)
{
//qstrSend += "####";
}
else
{
qstrSend += ",";
}
}
qbSend = qstrSend.toLatin1();
m_pNetworkManager->post(qnRequest, qbSend);
qDebug() << "Network Sending:Dev Info ";
m_iFlagIsReplied = 0;
int iCount = 0;
while (!m_iFlagIsReplied)
{
iCount++;
Delay_MSec(500);
if (iCount>2)
{
m_iFlagIsReplied = 1;
qDebug() << "Reply Timeout:Upload Info ";
qDebug() << "UpLoadAddr:" << qstrURL;
}
}
}
//qDebug() << qstrSend;
return 0;
}
int ZZ_HttpTransfer::SendErr()
{
if (m_pNetworkManager == nullptr)
{
m_pNetworkManager = new QNetworkAccessManager();
connect(m_pNetworkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(SlotReplyFinished(QNetworkReply*)));
}
QNetworkRequest qnRequest;
qnRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/json"));
QString qstrURL = m_qstrUploadURL + "/Warning.php";
qnRequest.setUrl(QUrl(qstrURL));
//qnRequest.setUrl(QUrl("http://172.16.0.234/fileup/Warning.php"));
QByteArray qbSend;
QString qstrSend;
qbSend.clear();
qstrSend.clear();
if (m_struErrInfo.fChassisTempErr==-1000)
{
}
else
{
qstrSend += "Case_Temp:" + QString("%1").arg(m_struErrInfo.iDataTransferErr);
}
if (m_struErrInfo.fTecTempErr == -1000)
{
}
else
{
qstrSend += "##TEC_Temp:" + QString("%1").arg(m_struErrInfo.fTecTempErr);
}
if (m_struErrInfo.iDataTransferErr == -1000)
{
}
else
{
qstrSend += "##No_Data:" + QString("%1").arg(m_struErrInfo.iDataTransferErr);
}
if (m_struErrInfo.iShutterErr == -1000)
{
}
else
{
qstrSend += "##Shutter_Pos:" + QString("%1").arg(m_struErrInfo.iDataTransferErr);
}
qbSend = qstrSend.toLatin1();
m_pNetworkManager->post(qnRequest, qbSend);
qDebug() << "Network Sending:Warning Info ";
m_iFlagIsReplied = 0;
int iCount = 0;
while (!m_iFlagIsReplied)
{
iCount++;
Delay_MSec(500);
if (iCount > 2)
{
m_iFlagIsReplied = 1;
qDebug() << "Reply Timeout:Upload Info ";
qDebug() << "UpLoadAddr:" << qstrURL;
}
}
return 0;
}
void ZZ_HttpTransfer::SetErrInfo(ErrInfo struErrInfo)
{
m_struErrInfo = struErrInfo;
}
void ZZ_HttpTransfer::SetContext(EContext struEC, MEContext struMEC)
{
m_struEC = struEC;
m_struMEC = struMEC;
m_qstrUploadURL = m_struMEC.qstrHTTPServer;
}
void ZZ_HttpTransfer::SetDeviceInfo(RunTimeGrabberParams struGrabberRTParams)
{
m_struGrabberRTParams = struGrabberRTParams;
}
void ZZ_HttpTransfer::SetCalData(vector<vector<CalDataFrame>> vecCalcedData)
{
m_vecCalcedData.clear();
m_vecCalcedData = vecCalcedData;
}
void ZZ_HttpTransfer::Delay_MSec(ZZ_U16 usMS)
{
QEventLoop qeLoop;
QTimer::singleShot(usMS, &qeLoop, SLOT(quit()));
qeLoop.exec();
}
int ZZ_HttpTransfer::SlotReplyFinished(QNetworkReply* qnReply)
{
QString qstrURL = qnReply->url().toString();
QByteArray qbData = qnReply->readAll();
if (qnReply->error()== QNetworkReply::NoError)
{
qDebug() << "Reply NoError:" << "Server:" << qstrURL;
m_iFlagIsReplied = 1;
}
else
{
qDebug() << "Reply Error:" << qnReply->error() << "Server:" << qstrURL;
}
qnReply->abort();
qnReply->close();
qnReply->deleteLater();
qnReply = NULL;
//delete qnReply;
return 0;
}
int ZZ_HttpTransfer::SlotReplyFinishedThread(QNetworkReply* qnReply)
{
QString qstrURL = qnReply->url().toString();
QByteArray qbData = qnReply->readAll();
if (qnReply->error() == QNetworkReply::NoError)
{
qDebug() << "Reply NoError:" << "Server:"<<qstrURL;
m_iFlagIsReplied = 1;
}
else
{
qDebug() << "Reply Error:" << qnReply->error()<< "Server:"<<qstrURL;
}
qnReply->abort();
qnReply->close();
qnReply->deleteLater();
qnReply = NULL;
//delete qnReply;
return 0;
}
// int ZZ_HttpTransfer::SlotInit_Self()
// {
// if (m_pNetworkManager == nullptr)
// {
// m_pNetworkManager = new QNetworkAccessManager();
// connect(m_pNetworkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(SlotReplyFinished(QNetworkReply*)));
// }
// else
// {
// delete m_pNetworkManager;
// m_pNetworkManager = new QNetworkAccessManager();
// connect(m_pNetworkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(SlotReplyFinished(QNetworkReply*)));
// }
// return 0;
// }

53
source/Uploader/DataFileTransfer.h Normal file
View File

@ -0,0 +1,53 @@
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
//http://172.16.0.234/fileup/Data_uper.php
//http://172.16.0.234/fileup/Dev_info_uper.php
//http://172.16.0.234/fileup/Warning.php
using namespace std;
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::IRIS::FS;
using namespace ZZ_MISCDEF;
class ZZ_HttpTransfer :public QObject
{
Q_OBJECT
public:
ZZ_HttpTransfer(QObject* parent = nullptr);
~ZZ_HttpTransfer();
public:
public:
//void Init_Self();
int SendData();
int SendInfo();
int SendErr();
void SetErrInfo(ErrInfo struErrInfo);
void SetContext(EContext struEC, MEContext struMEC);
void SetDeviceInfo(RunTimeGrabberParams struGrabberRTParams);
void SetCalData(vector<vector<CalDataFrame>> vecCalcedData);
private:
void Delay_MSec(ZZ_U16 usMS);
private:
QNetworkAccessManager *m_pNetworkManager;
QNetworkAccessManager *m_pNetworkManagerThread;
ErrInfo m_struErrInfo;
EContext m_struEC;
MEContext m_struMEC;
RunTimeGrabberParams m_struGrabberRTParams;
vector<vector<CalDataFrame>> m_vecCalcedData;
QString m_qstrUploadURL;
int m_iFlagIsReplied;
public slots:
int SlotReplyFinished(QNetworkReply* qnReply);
int SlotReplyFinishedThread(QNetworkReply* qnReply);
//int SlotInit_Self();
signals:
//void SignalInit_Self();
};

134
source/Uploader/MainDataUploader.cpp Normal file
View File

@ -0,0 +1,134 @@
#include "MainDataUploader.h"
CMainDataUploader::CMainDataUploader(QObject* parent /*= nullptr*/)
{
m_pRadConverter = new RadConverter;
m_pTransfer = new ZZ_HttpTransfer;
//connect(this, &CMainDataUploader::SignalInit_Self, m_pTransfer, &ZZ_HttpTransfer::SlotInit_Self);
}
CMainDataUploader::~CMainDataUploader()
{
if (m_pRadConverter)
{
delete m_pRadConverter;
}
if (m_pTransfer)
{
delete m_pTransfer;
}
}
void CMainDataUploader::SetErr(ErrInfo struErrInfo)
{
m_pTransfer->SetErrInfo(struErrInfo);
//m_struErrInfo = struErrInfo;
}
void CMainDataUploader::SetData(vector<vector<DataFrame>> vecData)
{
QDateTime qdtTime = QDateTime::currentDateTime();
QString qstrAddYMD = qdtTime.toString("yyyy_MM_dd");
QString qstrAddHMS = qdtTime.toString("_hh_mm_ss");
m_qstrGrabDate.clear();
m_qstrGrabDate = qstrAddYMD + qstrAddHMS;
m_vecData = vecData;
}
void CMainDataUploader::SetRTGP(RunTimeGrabberParams struGrabberRTParams)
{
m_struGrabberRTParams = struGrabberRTParams;
}
void CMainDataUploader::SetContext(EContext struEC, MEContext struMEC)
{
m_struEC = struEC;
m_struMEC = struMEC;
}
void CMainDataUploader::Calibration()
{
int iScanPoints = m_struGrabberRTParams.apsParams.iTotalPosition - 1;
int iDevices = m_struGrabberRTParams.fscParams.ucDeviceNumber;
m_vecCalcedData.clear();
m_vecCalcedData.resize(iDevices);
for (int i=0;i< iDevices;i++)
{
m_vecCalcedData[i].resize(iScanPoints);
}
for (int j = 0; j < iDevices; j++)
{
for (int i = 0; i < iScanPoints; i++)
{
m_vecCalcedData[j][i].usExposureTimeInMS = m_vecData[j][i].usExposureTimeInMS;
m_vecCalcedData[j][i].iPixels = m_vecCalData[j][i].iPixels;
m_vecCalcedData[j][i].fTemperature = m_vecData[j][i].fTemperature;
m_vecCalcedData[j][i].qstrGrabDate = m_qstrGrabDate;
for (int k=0;k< m_struGrabberRTParams.fscParams.usPixels[j];k++)
{
m_vecCalcedData[j][i].fData[k] = (float)(m_vecData[j][i].lData[k]* m_vecCalData[j][i].dCal_Gain[k]* m_vecCalData[j][i].uiExposureTimeInMS/m_vecData[j][i].usExposureTimeInMS);
}
}
}
}
int CMainDataUploader::UploadInfo()
{
m_pTransfer->SendInfo();
return 0;
}
int CMainDataUploader::UploadErr()
{
m_pTransfer->SendErr();
return 0;
}
int CMainDataUploader::UploadData()
{
m_pTransfer->SetCalData(m_vecCalcedData);
m_pTransfer->SendData();
return 0;
}
int CMainDataUploader::Initialize()
{
m_pRadConverter->LoadCalibrationFrames(m_struGrabberRTParams,m_vecCalData);
m_pTransfer->SetContext(m_struEC, m_struMEC);
m_pTransfer->SetDeviceInfo(m_struGrabberRTParams);
//m_pTransfer->Init_Self();
return 0;
}
// int CMainDataUploader::Init_Self()
// {
// emit SignalInit_Self();
// return 0;
// }
// int CMainDataUploader::SlotPushOneDataFrame(vector<vector<DataFrame>> vecData)
// {
// return 0;
// }
int CMainDataUploader::SlotPushOneDataFrame()
{
Calibration();
UploadData();
m_vecData.clear();
return 0;
}
int CMainDataUploader::SlotUpdateErrorInfo()
{
return 0;
}
// int CMainDataUploader::SlotInit_Self()
// {
//
// }

59
source/Uploader/MainDataUploader.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
#include "pch.h"
#include <vector>
#include "ZZ_Types.h"
#include "DataFileTransfer.h"
#include "RadianceConverter.h"
using namespace std;
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::IRIS::FS;
class CMainDataUploader :public QObject
{
Q_OBJECT
public:
CMainDataUploader(QObject* parent = nullptr);
~CMainDataUploader();
public:
public:
//set attributes
void SetErr(ErrInfo struErrInfo);
void SetData(vector<vector<DataFrame>> vecData);
void SetRTGP(RunTimeGrabberParams struGrabberRTParams);
void SetContext(EContext struEC, MEContext struMEC);
//load calibration file after set attributes
int Initialize();
//int Init_Self();
void Calibration();
int UploadInfo();
int UploadErr();
int UploadData();
public:
RadConverter *m_pRadConverter = NULL;
ZZ_HttpTransfer *m_pTransfer = NULL;
private:
//ErrInfo m_struErrInfo;
EContext m_struEC;
MEContext m_struMEC;
RunTimeGrabberParams m_struGrabberRTParams;
vector<vector<DataFrame>> m_vecData;
vector<vector<CalFrame>> m_vecCalData;
vector<vector<CalDataFrame>> m_vecCalcedData;
QString m_qstrGrabDate;
public slots:
//int SlotPushOneDataFrame(vector<vector<DataFrame>> vecData);
int SlotPushOneDataFrame();
int SlotUpdateErrorInfo();
signals:
//void SignalInit_Self();
};

75
source/Uploader/RadianceConverter.cpp Normal file
View File

@ -0,0 +1,75 @@
#include "RadianceConverter.h"
RadConverter::RadConverter(QObject* parent /*= nullptr*/)
{
#ifdef _DEBUG
m_qstrCalFilePath = "E:/WorkSpace/TowerOptoSifAndSpectral/Cal";
#else
m_qstrCalFilePath = "/home/data/Cal";
#endif // DEBUG
}
RadConverter::~RadConverter()
{
}
int RadConverter::LoadCalibrationFrames(RunTimeGrabberParams struGrabberRTParams, vector<vector<CalFrame>> &struAllCalFrame)
{
/////param
int iScanPoints = struGrabberRTParams.apsParams.iTotalPosition - 1;
int iDevices = struGrabberRTParams.fscParams.ucDeviceNumber;
//int iScanPoints = 4;
//int iDevices = 1;
/////check dir
QDir qdirPath(m_qstrCalFilePath);
if (!qdirPath.exists())
{
qDebug() << "Calibration File not exist";
return -1;
}
/////check quantities
QStringList qslFilter;
qslFilter << "*.dat";
qdirPath.setNameFilters(qslFilter);
QFileInfoList qfiInfo = qdirPath.entryInfoList(qslFilter);
if (qfiInfo.size()<iScanPoints * iDevices)
{
qDebug() << "Calibration Files quantities not match";
return -2;
}
/////read file
QString qstrFilePath;
vector<CalFrame> vecOneDev;
CalFrame OneFile;
for (int j=0;j<iDevices;j++)
{
vecOneDev.clear();
for (int i = 0; i < iScanPoints; i++)
{
qstrFilePath = m_qstrCalFilePath+QString("/FS%1_").arg(j + 1)+ QString("P%1").arg(i + 1)+".dat";
QFile qfCalFile(qstrFilePath);
bool bRes = qfCalFile.open(QFile::ReadOnly);
using namespace ZZ_MISCDEF;
qfCalFile.read((char *)&OneFile.uiExposureTimeInMS,sizeof(ZZ_U32));//U32
qfCalFile.read((char*)&OneFile.fTemperature, sizeof(float));
qfCalFile.read((char*)&OneFile.iPixels,sizeof(int));
qfCalFile.read((char*)OneFile.fWaveLength, sizeof(float)*OneFile.iPixels);
qfCalFile.read((char*)OneFile.dCal_Gain, sizeof(double)*OneFile.iPixels);
qfCalFile.read((char*)OneFile.dCal_Offset, sizeof(double)*OneFile.iPixels);
vecOneDev.push_back(OneFile);
}
struAllCalFrame.push_back(vecOneDev);
}
return 0;
}
// int RadConverter::LoadQEProLinearParams(RunTimeGrabberParams struGrabberRTParams, vector<vector<double>>& vecQEPLP)
// {
// int iQEPDevices = 0;
// return 0;
// }

23
source/Uploader/RadianceConverter.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
using namespace std;
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::IRIS::FS;
class RadConverter :public QObject
{
Q_OBJECT
public:
RadConverter(QObject* parent = nullptr);
~RadConverter();
public:
public:
int LoadCalibrationFrames(RunTimeGrabberParams struGrabberRTParams, vector<vector<CalFrame>> &struAllCalFrame);
//int LoadQEProLinearParams(RunTimeGrabberParams struGrabberRTParams, vector<vector<double>>& vecQEPLP);
private:
QString m_qstrCalFilePath;
private:
public slots:
};