tangchao0503/IRIS_FODIS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1.air部署，细节待修改

Browse Source
This commit is contained in:
zhangzhuo
2022-04-15 13:51:42 +08:00
parent 3b74dfc608
commit 8c6be81f94
440 changed files with 7 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
Source/Calibration/MakeDarkCurrentTable.cpp Normal file
View File

@ -0,0 +1,223 @@
#include "MakeDarkCurrentTable.h"
MakeDCT::MakeDCT(QObject* parent /*= nullptr*/)
{
m_qstrDarkCurrentTable = "/home/data/Data/DCTable.txt";
}
MakeDCT::~MakeDCT()
{
}
void MakeDCT::SetRunParams(OneFSContext struFSRunParams)
{
m_struFSRunParams = struFSRunParams;
}
int MakeDCT::Initialize()
{
m_pctrlFS = new CAbsFSController;
m_pctrlFS->SetContext(m_struFSRunParams);
m_pctrlFS->Initialize();
while (!m_pctrlFS->m_iFlagInit)
{
Delay_MSec(1000);
}
m_pctrlFS->GetDeviceAttr(m_struDeviceAttr);
m_struFSRunParams.usPixels = m_struDeviceAttr.iPixels;
return 0;
}
int MakeDCT::Initialize_Part()
{
if (m_struFSRunParams.ucDeviceModel== DeviceModel::IS1)
{
m_struFSRunParams.usPixels = 512;
}
if (m_struFSRunParams.ucDeviceModel == DeviceModel::FLAME)
{
m_struFSRunParams.usPixels = 2048;
}
return 0;
}
int MakeDCT::MakeTable()
{
DataFrame struSingleFrame;
long long llAverage[4096] = {0};
m_vecDataFrame.clear();
for (int i = 0; i < 10; i++)
{
memset(llAverage,0,4096*sizeof(long long));
int iExposureTime = i + 1;
m_pctrlFS->SetExposureTime(iExposureTime);//1-10
qDebug() << "Smapling Time:" << iExposureTime;
for (int i = 0; i < 10; i++)
{
m_pctrlFS->SingleShot(struSingleFrame);
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
llAverage[j] += struSingleFrame.lData[j];
}
}
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
struSingleFrame.lData[j] = (long)((double)llAverage[j] / (double)10);
}
m_vecDataFrame.push_back(struSingleFrame);
}
for (int i = 0; i < 9; i++)
{
memset(llAverage, 0, 4096 * sizeof(long long));
int iExposureTime = (i+2) *10;//20 - 100
m_pctrlFS->SetExposureTime(iExposureTime);
qDebug() << "Smapling Time:" << iExposureTime;
for (int i = 0; i < 10; i++)
{
m_pctrlFS->SingleShot(struSingleFrame);
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
llAverage[j] += struSingleFrame.lData[j];
}
}
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
struSingleFrame.lData[j] = (long)((double)llAverage[j] / (double)10);
}
m_vecDataFrame.push_back(struSingleFrame);
}
for (int i = 0; i < 9; i++)
{
memset(llAverage, 0, 4096 * sizeof(long long));
int iExposureTime = (i + 2) * 100;//200-1000
m_pctrlFS->SetExposureTime(iExposureTime);
qDebug() << "Smapling Time:" << iExposureTime;
for (int i = 0; i < 10; i++)
{
m_pctrlFS->SingleShot(struSingleFrame);
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
llAverage[j] += struSingleFrame.lData[j];
}
}
for (int j = 0; j < m_struFSRunParams.usPixels; j++)
{
struSingleFrame.lData[j] = (long)((double)llAverage[j] / (double)10);
}
m_vecDataFrame.push_back(struSingleFrame);
}
QFile qfData(m_qstrDarkCurrentTable);
bool bRes = qfData.open(QFile::WriteOnly | QFile::Text | QIODevice::Truncate);
if (!bRes)
{
qDebug() << "WriteData open Failed.";
return 0;
}
QString qstrTemp;
for (int i=0;i<m_vecDataFrame.size();i++)
{
if (i<=9)
{
qstrTemp = QString::number(i+1);
qfData.write(qstrTemp.toLatin1());
}
else if (i>=10&&i<=18)
{
qstrTemp = QString::number((i-8)*10);
qfData.write(qstrTemp.toLatin1());
}
else
{
qstrTemp = QString::number((i-17) * 100);
qfData.write(qstrTemp.toLatin1());
}
for (int j=0;j<m_struFSRunParams.usPixels;j++)
{
qfData.write(",");
qstrTemp = QString::number(m_vecDataFrame[i].lData[j]);
qfData.write(qstrTemp.toLatin1());
}
qfData.write("\n");
}
qfData.flush();
qfData.close();
return 0;
//m_pctrlFS->SingleShot();
}
int MakeDCT::LoadTable()
{
m_vecDataFrame.clear();
DataFrame dfTemp;
QFile qfData(m_qstrDarkCurrentTable);
bool bRes = qfData.open(QFile::ReadOnly);
if (!bRes)
{
qDebug() << "LoadTable open Failed.";
return 1;
}
QString qstrTemp;
QStringList qsList;
while (!qfData.atEnd())
{
QString data;
data = qfData.readLine();
qsList = data.split(',');
dfTemp.usExposureTimeInMS = qsList[0].toInt();
for (int i=0;i< qsList.size()-1;i++)
{
dfTemp.lData[i] = qsList[i + 1].toInt();
qDebug() << qsList[i] << ";";
}
m_vecDataFrame.push_back(dfTemp);
qDebug() << qsList.size() << endl;
}
return 0;
}
void MakeDCT::GetDCTable(std::vector<DataFrame>& vecDataFrame)
{
vecDataFrame = m_vecDataFrame;
}
void MakeDCT::Delay_MSec(ZZ_U16 usMS)
{
QEventLoop qeLoop;
QTimer::singleShot(usMS, &qeLoop, SLOT(quit()));
qeLoop.exec();
}

27
Source/Calibration/MakeDarkCurrentTable.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include "pch.h"
#include "AbsFSController.h"
class MakeDCT :public QObject
{
Q_OBJECT
public:
MakeDCT(QObject* parent = nullptr);
virtual ~MakeDCT();
public:
void SetRunParams(OneFSContext struFSRunParams);
int Initialize();
int Initialize_Part();
int MakeTable();
int LoadTable();
void GetDCTable(std::vector<DataFrame> &vecDataFrame);
private:
void Delay_MSec(ZZ_U16 usMS);
private:
QString m_qstrDarkCurrentTable = "/home/data/Data/DCTable.txt";
OneFSContext m_struFSRunParams;
CAbsFSController* m_pctrlFS;
DeviceAttribute m_struDeviceAttr;
std::vector<DataFrame> m_vecDataFrame;
};

396
Source/Capture/AbsFSController.cpp Normal file
View File

@ -0,0 +1,396 @@
#include "AbsFSController.h"
#include "ZZ_Math_HDRONLY.h"
CAbsFSController::CAbsFSController(QObject* parent /*= nullptr*/)
{
m_iFlagInit = 0;
#ifdef _DEBUG
m_qstrWaveLengthPath = "E:/WorkSpace/TowerOptoSifAndSpectral/Data/WaveLengthInfo.txt";
#else
m_qstrWaveLengthPath = "/home/data/Data/WaveLengthInfo.txt";
#endif // DEBUG
}
CAbsFSController::~CAbsFSController()
{
}
void CAbsFSController::SetContext(OneFSContext struFSParam)
{
m_struFSParam = struFSParam;
}
int CAbsFSController::Initialize()
{
using namespace ZZ_MISCDEF::IRIS;
m_iFlagInit = 0;
switch (m_struFSParam.ucDeviceModel)
{
case DeviceModel::FLAME:
m_pFSCtrl = new OceanOptics_lib;
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "Flame Not Opened";
return 1;
}
break;
case DeviceModel::OSIFAlpha:
m_pFSCtrl = new OceanOptics_lib;
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "OSIFAlpha Not Opened";
return 2;
}
break;
case DeviceModel::OSIFBeta:
m_pFSCtrl = new OceanOptics_lib;
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "OSIFBeta Not Opened";
return 2;
}
break;
case DeviceModel::ISIF:
m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
//m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, NULL);
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "ISIF Not Opened";
return 3;
}
break;
case DeviceModel::IS1:
m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
//m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, NULL);
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "IS1 Not Opened";
return 3;
}
break;
case DeviceModel::IS2:
m_pFSCtrl = new ZZ_ATPControl_Serial_Qt;
//m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, NULL);
if (m_pFSCtrl->Initialize(false, m_struFSParam.strInterface, m_struFSParam.strSN) != 0)
{
qDebug() << "IS2 Not Opened";
return 3;
}
break;
default:
break;
}
int iRes = m_pFSCtrl->GetDeviceAttribute(m_struDeviceAttr);
if (iRes != 0)
{
qDebug() << "GetDeviceAttribute Failed" << iRes;
return 4;
}
iRes = m_pFSCtrl->SetDeviceTemperature(0);
if (iRes != 0)
{
qDebug() << "SetDeviceTemperature Failed" << iRes;
//return 5;
}
m_iFlagInit = 1;
return 0;
}
int CAbsFSController::Initialize_Self()
{
return 0;
}
int CAbsFSController::SetExposureTime(int iMilliSec)
{
return m_pFSCtrl->SetExposureTime(iMilliSec);
}
int CAbsFSController::GetExposureTime(int& iMilliSec)
{
return m_pFSCtrl->GetExposureTime(iMilliSec);
}
int CAbsFSController::SingleShot(DataFrame& struSingleFrame)
{
using namespace ZZ_MISCDEF::IRIS;
int iRes = m_pFSCtrl->SingleShot(m_struSingleFrame);
if (iRes != 0)
{
qDebug() << "Err. SingleShot";
return 1;
}
if (m_struFSParam.ucDeviceModel == DeviceModel::FLAME)
{
int iRes = m_pFSCtrl->SingleShot(m_struSingleFrame);
if (iRes != 0)
{
qDebug() << "Err. SingleShot";
return 1;
}
}
if (m_struFSParam.ucDeviceModel == DeviceModel::ISIF)
{
float fTemp;
m_pFSCtrl->GetDeviceTemperature(fTemp);
m_struSingleFrame.fTemperature = fTemp;
}
else if (m_struFSParam.ucDeviceModel == DeviceModel::IS2)
{
float fTemp;
m_pFSCtrl->GetDeviceTemperature(fTemp);
m_struSingleFrame.fTemperature = fTemp;
}
else if (m_struFSParam.ucDeviceModel == DeviceModel::IS1)
{
m_struSingleFrame.fTemperature = 1000;
}
else if (m_struFSParam.ucDeviceModel == DeviceModel::FLAME)
{
m_struSingleFrame.fTemperature = 1000;
}
QDateTime qdtTime = QDateTime::currentDateTime();
m_struSingleFrame.dTimes = qdtTime.toMSecsSinceEpoch();
struSingleFrame = m_struSingleFrame;
return 0;
}
int CAbsFSController::PerformAutoExposure()
{
qDebug() << "--------------------------Starting PerformAutoExposure";
using namespace ZZ_MATH;
float fPredictedExposureTime;
int iDeviceDepth = (int)m_struFSParam.lDepth;
qDebug() << "MAX---Min" << m_struFSParam.fMaxFactor << "---" << m_struFSParam.fMinFactor ;
bool bFlagIsOverTrying = false;
bool bFlagIsLowerMinExposureTime = false;
bool bFlagIsOverMaxExposureTime = false;
bool bFlagIsAutoExposureOK = false;
bool bFlagIsAutoExposureFailed = false;
bool bIsValueOverflow = false;
bool bIsLastValueOverflow = false;
int iExposureTime = 0;
float fTempExposureTime = 0;
double fLastExposureTime = 0.1;
int iRepeatCount = 0;
while (!bFlagIsAutoExposureOK && !bFlagIsAutoExposureFailed)
{
DataFrame dfTemp;
if (iRepeatCount++ > 30)
{
bFlagIsAutoExposureFailed = true;
bFlagIsOverTrying = true;
break;
}
m_pFSCtrl->GetExposureTime(iExposureTime);
qDebug() << "Current ExpTime:" << iExposureTime;
fTempExposureTime = iExposureTime;
int iRes = m_pFSCtrl->SingleShot(dfTemp);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:2";
return 2;
}
HeapSort(dfTemp.lData, m_struDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_struDeviceAttr.iPixels / 200;
for (int i = 0; i < iCount; i++)
{
dSum += dfTemp.lData[i];
}
double dTemp = dSum / iCount;
qDebug() << "Avg " << dTemp ;
if (dTemp >= iDeviceDepth * 0.99)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
iExposureTime = (float)(fLastExposureTime + iExposureTime) / 2;
}
else
{
iExposureTime = iExposureTime / 2;
}
}
else if (iDeviceDepth * m_struFSParam.fMaxFactor >= dTemp && dTemp >= iDeviceDepth * m_struFSParam.fMinFactor)
{
qDebug() << "trace bFlagIsAutoExposureOK =1 " << iExposureTime;
bFlagIsAutoExposureOK = 1;
}
else if (dTemp > iDeviceDepth * m_struFSParam.fMaxFactor)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
iExposureTime = (float)(fLastExposureTime + iExposureTime) / 2;
}
else
{
iExposureTime = iExposureTime * 3 / 4;
}
}
else if (dTemp < iDeviceDepth * m_struFSParam.fMinFactor)
{
bIsValueOverflow = false;
if (bIsLastValueOverflow)
{
iExposureTime = (float)(fLastExposureTime + iExposureTime) / 2;
}
else
{
double dFactor;
dFactor = dTemp / (iDeviceDepth * m_struFSParam.fMaxFactor);
iExposureTime = (float)(iExposureTime / dFactor);
}
}
bIsLastValueOverflow = bIsValueOverflow;
fLastExposureTime = fTempExposureTime;
if (iExposureTime <= m_struDeviceAttr.iMinIntegrationTimeInMS)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
bFlagIsLowerMinExposureTime = true;
iRes = m_pFSCtrl->SetExposureTime(m_struDeviceAttr.iMinIntegrationTimeInMS);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:3" ;
return 3;
}
else
{
qDebug() << "Warning:PerformAutoExposure lower than min integration time.Will be limited to " << m_struDeviceAttr.iMinIntegrationTimeInMS << "MS";
}
break;
}
if (iExposureTime > m_struDeviceAttr.iMaxIntegrationTimeInMS - 1)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
bFlagIsOverMaxExposureTime = true;
iRes = m_pFSCtrl->SetExposureTime(m_struDeviceAttr.iMaxIntegrationTimeInMS - 1);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:3";
return 3;
}
else
{
qDebug() << "Warning:PerformAutoExposure exceed max integration time.Will be limited to " << m_struDeviceAttr.iMaxIntegrationTimeInMS - 1 << "MS";
}
break;
}
iRes = m_pFSCtrl->SetExposureTime((int)iExposureTime);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:4" ;
return 3;
}
else
{
qDebug() << "Success:PerformAutoExposure. Value" << iExposureTime ;
}
}
fPredictedExposureTime = iExposureTime;
qDebug() << "--------------------------Stop PerformAutoExposure";
return 0;
}
int CAbsFSController::CheckAndAdjust_Fast()
{
using namespace ZZ_MATH;
int iExposureTime = 0;
int iRes = m_pFSCtrl->GetExposureTime(iExposureTime);
if (iRes != 0)
{
qDebug() << "Err. SingleShot";
return 1;
}
HeapSort(m_struSingleFrame.lData, m_struDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_struDeviceAttr.iPixels / 200;
for (int i = 0; i < iCount; i++)
{
dSum += m_struSingleFrame.lData[i];
}
double dTemp = dSum / iCount;
if (dTemp >= m_struFSParam.lDepth * 0.99)
{
iExposureTime = iExposureTime / 2;
}
else
{
double dFactor;
dFactor = dTemp / (float)(m_struFSParam.lDepth * m_struFSParam.fMaxFactor);
iExposureTime = (float)(iExposureTime / dFactor);
}
return 0;
}
void CAbsFSController::GetDeviceAttr(DeviceAttribute& struDeviceAttr)
{
struDeviceAttr = m_struDeviceAttr;
}
// int CAbsFSController::CreateWavelengthFile()
// {
// QDir qdirPath(qstrTemp);
// if (!qdirPath.exists())
// {
// bool bRes = qdirPath.mkdir(qstrTemp);
// if (!bRes)
// {
// qDebug() << "DataFileProcessor mkdir Failed.";
// }
// }
// m_qstrWaveLengthPath
// temp1 = "wavelength = ";
// file.Write(temp1, temp1.GetLength());
// file.Write("{", 1);
// return 0;
// }

44
Source/Capture/AbsFSController.h Normal file
View File

@ -0,0 +1,44 @@
#pragma once
#include "pch.h"
#include "ATPControl_Serial_QT.h"
#include "OControl_USB.h"
#include <atomic>
#include <vector>
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::MISC_DETECTOR;
using namespace ZZ_MISCDEF::IRIS;
class CAbsFSController :public QObject
{
Q_OBJECT
public:
CAbsFSController(QObject* parent = nullptr);
virtual ~CAbsFSController();
public:
//call first
virtual void SetContext(OneFSContext struFSParam);
virtual int Initialize();
virtual int Initialize_Self();
int SetExposureTime(int iMilliSec);
int GetExposureTime(int& iMilliSec);
int SingleShot(DataFrame &struSingleFrame);
int PerformAutoExposure();
int CheckAndAdjust_Fast();
void GetDeviceAttr(DeviceAttribute &struDeviceAttr);
public:
std::atomic_int m_iFlagInit;
private:
DeviceAttribute m_struDeviceAttr;
CIrisFSBase* m_pFSCtrl;
OneFSContext m_struFSParam;
DataFrame m_struSingleFrame;
QString m_qstrWaveLengthPath;
private:
//int CreateWavelengthFile();
public slots:
signals:
};

221
Source/Capture/MainGrabber.cpp Normal file
View File

@ -0,0 +1,221 @@
#include "MainGrabber.h"
#include "ZZ_Math_HDRONLY.h"
CMainGrabber::CMainGrabber(QObject* parent /*= nullptr*/)
{
m_pctrlFS = NULL;
m_pctrlGPS = NULL;
m_dfpDataSaver = NULL;
m_iFlagIsCapture = 0;
connect(this, &CMainGrabber::Signal_InitSelf, this, &CMainGrabber::Initialize_Self);
}
CMainGrabber::~CMainGrabber()
{
}
void CMainGrabber::SetRunParams(OneFSContext struFSRunParams)
{
m_struFSRunParams = struFSRunParams;
}
int CMainGrabber::SetContext(BD357Controller &pctrlGPS, DataFileProcessor &dfpDataSaver)
{
if (&pctrlGPS == NULL)
{
qDebug() << "GPS Not Initialized";
return 1;
}
m_pctrlGPS = &pctrlGPS;
m_dfpDataSaver = &dfpDataSaver;
}
int CMainGrabber::Initialize()
{
emit Signal_InitSelf();
return 0;
}
int CMainGrabber::StartGrab()
{
m_pctrlFS->PerformAutoExposure();
DataFrame dfTemp;
m_iFlagIsCapture = 1;
while (m_iFlagIsCapture)
{
QTime qtTime;
qtTime.start();
////////////
m_pctrlFS->SingleShot(dfTemp);
RemoveBackground(dfTemp);
CheckExposureTime(dfTemp);
m_dfpDataSaver->WriteData(dfTemp);
////////////
//int iMillisec = qtTime.elapsed();
int iSleep =m_struFSRunParams.dMinSamplingInterval - qtTime.elapsed();
if (iSleep>0)
{
Delay_MSec(iSleep);
}
qDebug() << "Delay_MSec"<<iSleep;
}
}
int CMainGrabber::Initialize_Self()
{
InitializeWorkers();
SetupMsgPipelines();
LoadDCT();
emit Signal_InitFinished();
}
void CMainGrabber::Delay_MSec(ZZ_U16 usMS)
{
QEventLoop qeLoop;
QTimer::singleShot(usMS, &qeLoop, SLOT(quit()));
qeLoop.exec();
}
int CMainGrabber::InitializeWorkers()
{
if (m_pctrlFS == NULL)
{
m_pctrlFS = new CAbsFSController;
}
else
{
//???
}
m_pctrlFS->SetContext(m_struFSRunParams);
m_pctrlFS->Initialize();
while (!m_pctrlFS->m_iFlagInit)
{
Delay_MSec(1000);
}
m_pctrlFS->GetDeviceAttr(m_struDeviceAttr);
m_dfpDataSaver->GenerateFilePath();
m_dfpDataSaver->WriteWavelengthInfo(m_struDeviceAttr.fWaveLengthInNM, m_struDeviceAttr.iPixels);
return 0;
}
int CMainGrabber::SetupMsgPipelines()
{
bool bRes = connect(m_pctrlGPS,&BD357Controller::Signal_StartCapture, this, &CMainGrabber::StartGrab);
return 0;
}
int CMainGrabber::LoadDCT()
{
m_vecDataFrame.clear();
m_DCTable.SetRunParams(m_struFSRunParams);
m_DCTable.Initialize_Part();
m_DCTable.LoadTable();
m_DCTable.GetDCTable(m_vecDataFrame);
}
int CMainGrabber::CheckExposureTime(DataFrame dfTemp)
{
using namespace ZZ_MATH;
double dExpTimeMS;
int idExpTimeMS;
m_pctrlFS->GetExposureTime(idExpTimeMS);
qDebug() << "GetExposureTime" << idExpTimeMS;
dExpTimeMS = idExpTimeMS;
HeapSort(dfTemp.lData, m_struDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_struDeviceAttr.iPixels / 200;
for (int i = 0; i < iCount; i++)
{
dSum += dfTemp.lData[i];
}
double dTemp = dSum / iCount;
if (dTemp >= m_struFSRunParams.lDepth * 0.99)
{
dExpTimeMS = dExpTimeMS /2;
}
else if (m_struFSRunParams.lDepth*m_struFSRunParams.fMaxFactor >= dTemp && dTemp >= m_struFSRunParams.lDepth * m_struFSRunParams.fMinFactor)
{
qDebug() << "SetExposureTime" << dExpTimeMS;
return 0;
}
else
{
double dFactor;
dFactor = dTemp / (m_struFSRunParams.lDepth * m_struFSRunParams.fMaxFactor);
dExpTimeMS = (float)(dExpTimeMS / dFactor);
}
if ((dExpTimeMS <= m_struDeviceAttr.iMinIntegrationTimeInMS)|| (dExpTimeMS > m_struDeviceAttr.iMaxIntegrationTimeInMS - 1))
{
qDebug() << "SetExposureTime out of range";
return 1;
}
m_pctrlFS->SetExposureTime((int)dExpTimeMS);
qDebug() << "SetExposureTime" << dExpTimeMS;
return 0;
}
int CMainGrabber::RemoveBackground(DataFrame& dfTemp)
{
int iA = dfTemp.usExposureTimeInMS / 10;
int iB = dfTemp.usExposureTimeInMS % 10;
qDebug() << "iA" << iA;
qDebug() << "iB" << iB;
if (iA == 0)
{
m_dfBackground = m_vecDataFrame[iB];
}
else
{
if (iA>100)
{
m_dfBackground = m_vecDataFrame[m_vecDataFrame.size()-1];
}
else if(iA<=9&&iA>=1)
{
m_dfBackground = m_vecDataFrame[8 + iA];
}
else
{
int iAA= dfTemp.usExposureTimeInMS / 100;
int iBB= dfTemp.usExposureTimeInMS % 100;
DataFrame dfTempX1, dfTempX2;
dfTempX1 = m_vecDataFrame[17 + iAA];
dfTempX2 = m_vecDataFrame[18 + iAA];
for (int i=0;i< m_struDeviceAttr.iPixels;i++)
{
m_dfBackground.lData[i] = dfTempX1.lData[i] + (dfTempX2.lData[i] - dfTempX1.lData[i]) * (double)iBB / (double)100;
}
}
}
for (int i = 0; i < m_struDeviceAttr.iPixels; i++)
{
dfTemp.lData[i] = dfTemp.lData[i] - m_dfBackground.lData[i];
}
return 0;
}

48
Source/Capture/MainGrabber.h Normal file
View File

@ -0,0 +1,48 @@
#pragma once
#include "pch.h"
#include "AbsFSController.h"
#include "DataFileProcessor.h"
#include "BD357Ctrl.h"
#include "MakeDarkCurrentTable.h"
#include <atomic>
#include <vector>
class CMainGrabber :public QObject
{
Q_OBJECT
public:
CMainGrabber(QObject* parent = nullptr);
~CMainGrabber();
public:
void SetRunParams(OneFSContext struFSRunParams);
int SetContext(BD357Controller &pctrlGPS, DataFileProcessor &dfpDataSaver);
int Initialize();
public:
atomic_int m_iFlagIsCapture;
private:
MakeDCT m_DCTable;
OneFSContext m_struFSRunParams;
DataFileProcessor *m_dfpDataSaver;
CAbsFSController *m_pctrlFS;
BD357Controller *m_pctrlGPS;
std::vector<DataFrame> m_vecDataFrame;
DataFrame m_dfBackground;
DeviceAttribute m_struDeviceAttr;
private:
void Delay_MSec(ZZ_U16 usMS);
int InitializeWorkers();
int SetupMsgPipelines();
int LoadDCT();
int CheckExposureTime(DataFrame dfTemp);
int RemoveBackground (DataFrame &dfTemp);
public slots:
int StartGrab();
int Initialize_Self();
signals:
void Signal_InitSelf();
void Signal_InitFinished();
};

784
Source/FS/ATPControl_Serial_QT.cpp Normal file
View File

@ -0,0 +1,784 @@
#include "pch.h"
#include "ATPControl_Serial_QT.h"
#include "ZZ_Math_HDRONLY.h"
ZZ_ATPControl_Serial_Qt::ZZ_ATPControl_Serial_Qt(QObject* parent /*= nullptr*/)
{
m_pSerialPort = new QSerialPort;
m_iBaudRate = 115200;
//emit SignalInit_Self();
}
ZZ_ATPControl_Serial_Qt::~ZZ_ATPControl_Serial_Qt()
{
if (m_pSerialPort != NULL)
{
delete m_pSerialPort;
}
}
// int ZZ_ATPControl_Serial_Qt::ReInit()
// {
// m_pSerialPort->close();
// delete m_pSerialPort;
//
// m_pSerialPort = new QSerialPort;
//
// m_pSerialPort->setPortName("COM7");
// m_pSerialPort->setReadBufferSize(512);
// bool bRes = m_pSerialPort->setBaudRate(m_iBaudRate);
// bRes = m_pSerialPort->open(QIODevice::ReadWrite);
// }
// int ZZ_ATPControl_Serial_Qt::SetBaudRate(int iBaud)
// {
// m_iBaudRate = iBaud;
// return 0;
// }
int ZZ_ATPControl_Serial_Qt::Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
//connect(this, &ZZ_ATPControl_Serial_Qt::SignalInit_Self, this, &ZZ_ATPControl_Serial_Qt::Init_Self);
//emit SignalInit_Self();
QString qstrPortName = QString::fromStdString(ucPortNumber);
m_pSerialPort->setPortName(qstrPortName);
m_pSerialPort->setReadBufferSize(512);
bool bRes = m_pSerialPort->setBaudRate(m_iBaudRate);
if (!bRes)
{
qDebug() << "Err:setBaudRate Failed.Exit Code:1";
//std::cout << "Err.setBaudRate Failed" << std::endl;
return 1;
}
bRes = m_pSerialPort->open(QIODevice::ReadWrite);
if (!bRes)
{
qDebug() << "Err:open Failed.Exit Code:2";
//std::cout << "Err.open Failed" << std::endl;
return 2;
}
// int testi;
// GetDeviceAttribute(m_daDeviceAttr);
// GetExposureTime(testi);
// SetExposureTime(10000);
// DataFrame test;
// SingleShot(test);
GetDeviceInfo(m_diDeviceInfo);
GetExposureTime_Init();
std::string::size_type szPostion = m_diDeviceInfo.strSN.find(strDeviceName);
if (szPostion == std::string::npos)
{
qDebug() << "Err:FS serial number not match.Exit Code:3";
//return 3;
}
else
{
return 0;
}
return 0;
}
void ZZ_ATPControl_Serial_Qt::Close()
{
m_pSerialPort->close();
}
int ZZ_ATPControl_Serial_Qt::GetDeviceInfo(DeviceInfo& Info)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_PN_NUMBER);
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
m_diDeviceInfo.strPN = qbRecv.data();
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_SN_NUMBER);
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
m_diDeviceInfo.strSN = qbRecv.data();
Info = m_diDeviceInfo;
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetDeviceAttribute(DeviceAttribute& Attr)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_MIN_INTEGRATION_TIME);
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
m_daDeviceAttr.iMinIntegrationTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_MAX_INTEGRATION_TIME);
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
m_daDeviceAttr.iMaxIntegrationTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
///
int iTempExpTime = 0;
GetExposureTime(iTempExpTime);
iRes = SetExposureTime(m_daDeviceAttr.iMinIntegrationTimeInMS);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Call SetExposureTime error.Exit Code:2";
//return 2;
}
iRes = SingleShot(m_daDeviceAttr.iPixels);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Call SingleShot error.Exit Code:3";
return 3;
}
SetExposureTime(iTempExpTime);
///
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_WAVELENGTH_CALIBRATION_COEF);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
float fWaveLengthCoef[4];
memcpy(fWaveLengthCoef, qbRecv.data() + 16, 4 * sizeof(float));
for (int i = 0; i < m_daDeviceAttr.iPixels; i++)
{
m_daDeviceAttr.fWaveLengthInNM[i] = fWaveLengthCoef[0] * i * i * i + fWaveLengthCoef[1] * i * i + fWaveLengthCoef[2] * i + fWaveLengthCoef[3];
}
Attr = m_daDeviceAttr;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SetDeviceTemperature(float fTemperature)
{
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetExposureTime_Init()
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_INTEGRATION_TIME);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:3";
return 3;
}
m_iExposureTime = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SendCommand(QByteArray qbCommand)
{
int iSize = qbCommand.size() + 3;
QByteArray qbSend;
qbSend.resize(4);
qbSend[0] = (ZZ_U8)0xAA;
qbSend[1] = 0x55;
qbSend[2] = iSize / 256;
qbSend[3] = iSize % 256;
qbSend.append(qbCommand);
int iSum = 0;
for (int i = 0; i < iSize - 1; i++)
{
iSum = iSum + qbSend[i + 2];
}
qbSend.append(iSum % 256);
qint64 qi64Write = m_pSerialPort->write(qbSend);
if (qi64Write != qbSend.size())
{
qDebug() << "Err:write Failed.Exit Code:1" << qi64Write;
return 1;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::RecvData(QByteArray& qbData)
{
qbData.clear();
qbData = m_pSerialPort->readAll();
int iCounter = 0;
while (qbData.size() < 4)
{
m_pSerialPort->waitForReadyRead(1000);
QByteArray qbTemp = m_pSerialPort->readAll();
qbData.append(qbTemp);
if (iCounter > 150)
{
qDebug() << "Err:RecvData Failed,Not Enough Data.Exit Code:1" << qbData.size();
return 1;
}
iCounter++;
}
if ((ZZ_U8)qbData[0] != (ZZ_U8)0xaa || (ZZ_U8)qbData[1] != (ZZ_U8)0x55)
{
qDebug() << "Err:RecvData Failed,Wrong Header.Exit Code:2" << qbData.size();
return 2;
}
iCounter = 0;
int iLength = qbData[2] * 256 + qbData[3] + 2;
while (qbData.size() < iLength)
{
m_pSerialPort->waitForReadyRead(5000);
qbData.append(m_pSerialPort->readAll());
if (iCounter > 200)
{
qDebug() << "Err:RecvData Failed,Incomplete Data.Exit Code:3" << qbData.size();
return 3;
}
iCounter++;
}
if (qbData.size() > iLength)
{
qbData.remove(iLength - 1, qbData.size() - iLength);
}
int iCheckSumLength = iLength - 3;
ZZ_U16 usCheckSum = 0;
for (int i = 0; i < iCheckSumLength; i++)
{
usCheckSum += qbData[i + 2];
}
usCheckSum = usCheckSum % 256;
ZZ_U8 ucTemp = qbData[qbData.size() - 1];
if ((ZZ_U8)usCheckSum != ucTemp)
{
/*char cTemp[5];
cTemp[0] = qbData[1026];
qDebug()<< cTemp[0];
cTemp[1] = qbData[1027];
qDebug()<< cTemp[1];
cTemp[2] = qbData[1028];
qDebug()<< cTemp[2];
cTemp[3] = qbData[1029];
qDebug()<< cTemp[3];
cTemp[4] = qbData[1030];
qDebug()<< cTemp[4];*/
qDebug() << "Err:RecvData Failed,Incorrect Check Sum.Exit Code:4" << "Total Recv:" << qbData.size() << "Check Sum:" << usCheckSum << "Not Equal To" << ucTemp;
//qbData.clear();
//return 4;
return 0;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::ParseData(QByteArray& qbData)
{
if (qbData.size() < 6)
{
qDebug() << "Err:ParseData Failed,Not Enough Data.Exit Code:1" << qbData.size();
return 1;
}
qbData.remove(0, 5);
qbData.remove(qbData.size() - 1, 1);
return 0;
}
int ZZ_ATPControl_Serial_Qt::Init_Self()
{
m_pSerialPort = new QSerialPort;
return 0;
}
int ZZ_ATPControl_Serial_Qt::PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float& fPredictedExposureTime)
{
using namespace ZZ_MATH;
int iDeviceDepth = 65535;
bool bFlagIsOverTrying = false;
bool bFlagIsLowerMinExposureTime = false;
bool bFlagIsOverMaxExposureTime = false;
bool bFlagIsAutoExposureOK = false;
bool bFlagIsAutoExposureFailed = false;
bool bIsValueOverflow = false;
bool bIsLastValueOverflow = false;
float fExposureTime = 0;
float fTempExposureTime = 0;
double fLastExposureTime = 0.1;
int iRepeatCount = 0;
int iRes = SetExposureTime(2000);//need change to load from files
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:1";
return 1;
}
while (!bFlagIsAutoExposureOK && !bFlagIsAutoExposureFailed)
{
DataFrame dfTemp;
if (iRepeatCount++ > 30)
{
bFlagIsAutoExposureFailed = true;
bFlagIsOverTrying = true;
break;
}
fExposureTime = (float)m_daDeviceAttr.iMinIntegrationTimeInMS;
fTempExposureTime = fExposureTime;
iRes = SingleShot(dfTemp);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:2";
return 2;
}
HeapSort(dfTemp.lData, m_daDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_daDeviceAttr.iPixels / 100;
for (int i = 0; i < iCount; i++)
{
dSum += dfTemp.lData[i];
}
double dTemp = dSum / iCount;
if (dTemp >= iDeviceDepth * 0.99)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
fExposureTime = fExposureTime / 2;
}
}
else if (iDeviceDepth * fMaxScaleFactor >= dTemp && dTemp >= iDeviceDepth * fMinScaleFactor)
{
bFlagIsAutoExposureOK = 1;
}
else if (dTemp > iDeviceDepth * fMaxScaleFactor)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
fExposureTime = fExposureTime * 3 / 4;
}
}
else if (dTemp < iDeviceDepth * fMinScaleFactor)
{
bIsValueOverflow = false;
if (bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
double dFactor;
dFactor = dTemp / (iDeviceDepth * fMaxScaleFactor);
fExposureTime = (float)(fExposureTime / dFactor);
}
if (/*fExposureTime > 100 || */fExposureTime < 10)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
bFlagIsLowerMinExposureTime = true;
}
}
bIsLastValueOverflow = bIsValueOverflow;
fLastExposureTime = fTempExposureTime;
if (fExposureTime > 13000)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
fPredictedExposureTime = 13000;
iRes = SetExposureTime(13000);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:3";
return 3;
}
bFlagIsOverMaxExposureTime = true;
break;
}
iRes = SetExposureTime((int)fExposureTime);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:4";
return 3;
}
}
fPredictedExposureTime = fExposureTime;
return 0;
}
// int ZZ_ATPControl_Serial_Qt::SetExtShutter(int iShutterUP0, int iShutterDOWN1, int iShutterDOWN2, int iShutterDOWN3)
// {
// qDebug() << "stub code not implemented";
// return -1;
// }
int ZZ_ATPControl_Serial_Qt::SetExposureTime(int iExposureTimeInMS)
{
m_iExposureTime = iExposureTimeInMS;
QByteArray qbExposureTime, qbRecv;
//qbExposureTime.append(SET_INTEGRATION_TIME);
qbExposureTime.resize(3);
qbExposureTime[0] = SET_INTEGRATION_TIME;
qbExposureTime[1] = iExposureTimeInMS >> 8;
qbExposureTime[2] = iExposureTimeInMS & 0xFF;
int iRes = SendCommand(qbExposureTime);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:2";
return 2;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:3";
return 3;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:4";
return 4;
}
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:1";
return 1;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetExposureTime(int& iExposureTimeInMS)
{
// QByteArray qbSend, qbRecv;
// qbSend.clear();
// qbRecv.clear();
// qbSend.append(GET_INTEGRATION_TIME);
// qbSend.resize(3);
// qbSend[1] = 0x00;
// qbSend[2] = 0x01;
// int iRes = SendCommand(qbSend);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:1";
// return 1;
// }
// iRes = RecvData(qbRecv);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:2";
// return 2;
// }
// iRes = ParseData(qbRecv);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:3";
// return 3;
// }
//
// iExposureTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
iExposureTimeInMS = m_iExposureTime;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShot(DataFrame& dfData)
{
dfData.usExposureTimeInMS = m_iExposureTime;
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SYNC_GET_DATA);
qbSend.resize(3);
// qbSend[1] = 0x00;
// qbSend[2] = 0x01;
qbSend[1] = m_iExposureTime >> 8;;
qbSend[2] = m_iExposureTime & 0xFF;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:3";
return 3;
}
ZZ_U16 usData[4096] = { 0 };
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
else
{
//int aaa = qbRecv.size();
int iDataSizeInPixel = (qbRecv.size() - 1) / 2;
memcpy(usData, qbRecv.data() + 1, iDataSizeInPixel * 2);
for (size_t i = 0; i < iDataSizeInPixel; i++)
{
dfData.lData[i] = qToBigEndian(usData[i]);
}
// for (int i = 0; i < iDataSizeInPixel; i++)
// {
// dfData.lData[i] = usData[i];
// }
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShot(int& iPixels)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SYNC_GET_DATA);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:3";
return 3;
}
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:4";
return 4;
}
else
{
iPixels = (qbRecv.size() - 1) / 2;
}
return 0;
}
// int ZZ_ATPControl_Serial_Qt::SingleShotDark(ATPDataFrame &dfData)
// {
// SetExtShutter(0,0,0,0);
// SingleShot(dfData);
// return 0;
// }
int ZZ_ATPControl_Serial_Qt::GetDeviceTemperature(float& fTemperature)
{
fTemperature = 0;
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_TEC_TEMP);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:3";
return 3;
}
QString qstrTemp = qbRecv.data();
fTemperature = qstrTemp.toFloat();
return 0;
}
//void ZZ_ATPControl_Serial_Qt::ReadMessage()
//{
// QByteArray qbTemp, qbTemp1;
// qbTemp = m_pSerialPort->readAll();
// while (qbTemp.size()<2)
// {
// m_pSerialPort->waitForReadyRead(50);
// qbTemp1 = m_pSerialPort->readAll();
// qbTemp.append(qbTemp1);
// }
//return;
// }

94
Source/FS/ATPControl_Serial_QT.h Normal file
View File

@ -0,0 +1,94 @@
//////////////////////////////////////////////////////////////////////////
//ATP<54><50><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
#include "IrisFiberSpectrometerBase.h"
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::ATP;
using namespace ZZ_MISCDEF::IRIS::FS;
class ZZ_ATPControl_Serial_Qt :public CIrisFSBase
{
Q_OBJECT
public:
ZZ_ATPControl_Serial_Qt(QObject* parent = nullptr);
virtual ~ZZ_ATPControl_Serial_Qt();
public:
//do not call
//int ReInit();
//<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
//int SetBaudRate(int iBaud);
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
int Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);
//<2F>ر<EFBFBD><D8B1>豸
void Close();
//<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(DataFrame& 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(DeviceInfo& Info);
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int GetDeviceAttribute(DeviceAttribute& Attr);
//int GetDeviceListInfo(); //use type name to enum
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int SetDeviceTemperature(float fTemperature);
//<2F><>ȡ<EFBFBD><EFBFBD>
int GetDeviceTemperature(float& fTemperature);
//<2F>Զ<EFBFBD><D4B6>ع<EFBFBD>
int PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float& fPredictedExposureTime);
#ifdef _DEBUG
public:
#else //
private:
#endif
//port
int m_iBaudRate;
QSerialPort* m_pSerialPort;
//ATP
DeviceInfo m_diDeviceInfo;
DeviceAttribute m_daDeviceAttr;
//Attr
int m_iExposureTime;
//////////////////////////////////////////////////////////////////////////shutter control stub code s
//int SetExtShutter(int iShutterUP0, int iShutterDOWN1,int iShutterDOWN2,int iShutterDOWN3); //0:close 1:open
//////////////////////////////////////////////////////////////////////////shutter control stub code e
int GetExposureTime_Init();
int SendCommand(QByteArray qbCommand);
int RecvData(QByteArray& qbData);
int ParseData(QByteArray& qbData);
public slots:
int Init_Self();
signals:
void SignalInit_Self();
//private slots :
//void ReadMessage();
};

112
Source/FS/DataFileProcessor.cpp Normal file
View File

@ -0,0 +1,112 @@
#include "DataFileProcessor.h"
DataFileProcessor::DataFileProcessor(QObject* parent /*= nullptr*/)
{
#ifdef _DEBUG
m_qstrFilePath = "E:/WorkSpace/TowerOptoSifAndSpectral/Data";
#else
m_qstrFilePath = "/home/data/Data";
m_qstrWavelengthInfoFileName = "/home/data/Data/WavelengthInfo.txt";
#endif // DEBUG
}
DataFileProcessor::~DataFileProcessor()
{
}
int DataFileProcessor::WriteWavelengthInfo(float *pfWaveLength, int iLength)
{
QFileInfo qfFileInfo(m_qstrWavelengthInfoFileName);
if (qfFileInfo.isFile())
{
return 0;
}
else
{
bool bRes = true;
QFile qfData(m_qstrWavelengthInfoFileName);
bRes = qfData.open(QFile::WriteOnly | QFile::Text | QFile::Truncate);
if (!bRes)
{
qDebug() << "WriteEnvironmentInfo open Failed.";
return 1;
}
QString qstrTemp = "wavelength = ";
qfData.write(qstrTemp.toLatin1());
qfData.write("{ ");
for (int i=0;i< iLength;i++)
{
qstrTemp =QString::number(pfWaveLength[i], 'f', 2);
if (i== (iLength-1))
{
qfData.write(qstrTemp.toLatin1());
}
else
{
qfData.write(qstrTemp.toLatin1());
qfData.write(", ");
}
}
qfData.write("}");
qfData.close();
}
return 0;
}
int DataFileProcessor::WriteData(DataFrame dfDataFrame)
{
QFile qfData(m_qstrFullFileName);
bool bRes = qfData.open(QFile::WriteOnly| QIODevice::Append);
if (!bRes)
{
qDebug() << "WriteData open Failed.";
return 0;
}
qfData.write((char*)&dfDataFrame, sizeof(DataFrame));
return 0;
}
void DataFileProcessor::LoadSingleDataFile(QString qstrFileName)
{
qstrFileName;
return;
}
void DataFileProcessor::GenerateFilePath()
{
m_qdtTime = QDateTime::currentDateTime();
QString qstrAddYMD = m_qdtTime.toString("/yyyy_MM_dd");
QString qstrAddHMS = m_qdtTime.toString("hh_mm_ss");
m_qstrFullFileName = m_qstrFilePath + qstrAddYMD;
QString qstrTemp= m_qstrFullFileName;
m_qstrFullFileName= m_qstrFullFileName+"/"+ qstrAddHMS+".dat";
QDir qdirPathTemp(m_qstrFilePath);
if (!qdirPathTemp.exists())
{
bool bRes = qdirPathTemp.mkdir(m_qstrFilePath);
if (!bRes)
{
qDebug() << "DataFileProcessor mkdir Failed.";
}
}
QDir qdirPathTempA(qstrTemp);
if (!qdirPathTempA.exists())
{
bool bRes = qdirPathTempA.mkdir(qstrTemp);
if (!bRes)
{
qDebug() << "DataFileProcessor mkdir Failed.";
}
}
}

41
Source/FS/DataFileProcessor.h Normal file
View File

@ -0,0 +1,41 @@
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::IRIS::FS;
class DataFileProcessor :public QObject
{
Q_OBJECT
public:
DataFileProcessor(QObject* parent = nullptr);
virtual ~DataFileProcessor();
public:
public:
void GenerateFilePath();
int WriteWavelengthInfo(float *pfWaveLength, int iLength);
int WriteData(DataFrame dfDataFrame);
void LoadSingleDataFile(QString qstrFileName);
//void SetEnvironmentContex(EContext struEC);
//void SetManmadeEnviromentalContext(MEContext struMEC);
//void SetDeviceInfo(FSContext struDeviceContext);
//void SetData(std::vector<std::vector<DataFrame>> vecData);
//bool WriteDataFile();
private:
//bool WriteEnvironmentInfo();
//void WriteDeviceInfo();
//bool WriteData();
public:
private:
QString m_qstrWavelengthInfoFileName;
QString m_qstrFullFileName;
QString m_qstrFileName;
QString m_qstrFilePath;
QDateTime m_qdtTime;
};

45
Source/FS/IrisFiberSpectrometerBase.h Normal file
View File

@ -0,0 +1,45 @@
#include <string>
#include "ZZ_Types.h"
#include "pch.h"
#pragma once
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class CIrisFSBase:public QObject
{
public:
//CIrisFSBase();
//virtual ~CIrisFSBase()= 0;
private:
//int m_iMaxDepth = 65535;
public:
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
//<2F>˴<EFBFBD>stringΪָ<CEAA><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸ<EFBFBD>ocean<61><6E><EFBFBD><EFBFBD><EFBFBD>ǵIJ<C7B5><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>и<EFBFBD><D0B8><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>c/c++<2B><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
//0Ϊ<30>޴<EFBFBD><DEB4>󣬲<EFBFBD>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD><EFBFBD>뷵<EFBFBD>ز<EFBFBD>ֵͬ
virtual int Initialize(bool bIsUSBMode, std::string ucPortNumber,std::string strDeviceName) = 0;
//<2F>ر<EFBFBD><D8B1>豸
virtual void Close() = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
virtual int SingleShot(DataFrame &dfData) = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
virtual int SetExposureTime(int iExposureTimeInMS) = 0;
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
virtual int GetExposureTime(int &iExposureTimeInMS) = 0;
//<2F><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
virtual int SetDeviceTemperature(float fTemperature) = 0;
//<2F><>ȡ<EFBFBD><EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD>
virtual int GetDeviceTemperature(float &fTemperature) = 0;
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
virtual int GetDeviceInfo(DeviceInfo &Info) = 0;
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
virtual int GetDeviceAttribute(DeviceAttribute &Attr) = 0;
};

560
Source/FS/OControl_USB.cpp Normal file
View File

@ -0,0 +1,560 @@
#include "OControl_USB.h"
#include <iostream>
#include <cstring>
OceanOptics_lib::OceanOptics_lib()
{
m_iSpectralmeterHandle = -100;
}
OceanOptics_lib::~OceanOptics_lib()
{
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
int OceanOptics_lib::Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
int flag;
int error;
//char type[16];
int device_count = 0;
int i;
for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
{
// printf("\nOpening spectrometer %d.\n", i);
flag = seabreeze_open_spectrometer(i, &error);
// printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
if (0 == flag)
{
device_count++;
}
else
{
continue;
}
string sn = GetSerialNumber(i);
if (strcmp(sn.c_str(), strDeviceName.c_str()) == 0)
{
m_iSpectralmeterHandle = i;
// printf("\nfind!!!!!!!!!!!!\n");
break;
}
else
{
// printf("\nClosing spectrometer %d.\n", i);
flag = seabreeze_close_spectrometer(i, &error);
// printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
}
}
if (m_iSpectralmeterHandle == -100)
{
// printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
long test = seabreeze_get_buffer_capacity_minimum(m_iSpectralmeterHandle, &error);
seabreeze_set_buffer_capacity(m_iSpectralmeterHandle, &error, test);
//seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
//seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
// printf("seabreeze_set_trigger_mode: Result is [%s]\n", get_error_string(error));
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
// printf("\n-------------------û<>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");
return 1;
}
if (minimum_time < 0) {
/* If there was an error, reset to a time that is supported widely. */
minimum_time = 15000;
return 1;
}
SetExposureTime(minimum_time / 1000);
return 0;
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
int OceanOptics_lib::Initialize()
{
int flag;
int error;
//char type[16];
int device_count = 0;
int i;
for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
{
printf("\nOpening spectrometer %d.\n", i);
flag = seabreeze_open_spectrometer(i, &error);
//printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
if (0 == flag)
{
m_iSpectralmeterHandle = i;
printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
break;
}
else
{
continue;
}
}
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
// printf("seabreeze_set_trigger_mode: Result is [%s]\n", get_error_string(error));
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
// printf("\n-------------------û<>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");
return 1;
}
if (minimum_time < 0) {
/* If there was an error, reset to a time that is supported widely. */
minimum_time = 15000;
return 1;
}
SetExposureTime(minimum_time / 1000);
return 0;
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/seabreezeapi/SeaBreezeAPI.h"
//int OceanOptics_lib::Initialize(bool bIsUSBMode,ZZ_U8 ucPortNumber,std::string strDeviceName)
//{
// int number_of_devices;
// long *device_ids;
// int i;
// int flag;
// int error = 0;
// char nameBuffer[80];
// char *serialNumber;
//
//
//// /* Give the driver a chance to initialize itself */
//// sbapi_initialize();
//
// printf("Probing for devices...\n"); fflush(stdout);
// sbapi_probe_devices();
//
// printf("Getting device count...\n"); fflush(stdout);
// number_of_devices = sbapi_get_number_of_device_ids();
// std::cout<<"Device count is "<< number_of_devices <<std::endl;
// if(0 == number_of_devices) {
// return 0;
// }
//
// printf("Getting device IDs...\n");
// device_ids = (long *)calloc(number_of_devices, sizeof(long));
// number_of_devices = sbapi_get_device_ids(device_ids, number_of_devices);
// printf("Got %d device ID%s.\n", number_of_devices, number_of_devices == 1 ? "" : "s"); fflush(stdout);
//
//
// for(i = 0; i < number_of_devices; i++)
// {
// printf("%d: Device 0x%02lX:\n", i, device_ids[i]);
//// printf("\tGetting device type...\n");
// flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
// if(flag > 0) {
// printf("\tDevice type: [%s]\n", nameBuffer);
// }
//
// serialNumber = GetSerialNumber(device_ids[i]);
// serialNumber = GetSerialNumber(device_ids[i]);
//
// printf("\tSerial number tc: [%s]\n", serialNumber);
//
//// /* Open the device */
//// printf("\tAttempting to open:\n");
//// flag = sbapi_open_device(device_ids[i], &error);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
////
//// // jump to the next iteration if there was a problem
//// if(flag != 0) {
//// continue;
//// }
////
//// // log deviations
//// unsupportedFeatureCount=0;
//// testFailureCount=0;
////
//// /* Test the device */
//// for(test_index = 0; test_index < __test_function_count; test_index++) {
//// /* Invoke each of the test functions against this device */
//// __test_functions[test_index](device_ids[i], &unsupportedFeatureCount, &testFailureCount);
//// }
////
//// /* Close the device */
//// printf("\tAttempting to close:\n");
//// sbapi_close_device(device_ids[i], &error);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
//// printf("%d: Device 0x%02lX: \n\tNumber of unsupported features = %d\n\tNumber of test failures = %d\n", i, device_ids[i], unsupportedFeatureCount, testFailureCount);
// }
//
// flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
//
// return 1;
//}
//<2F>ر<EFBFBD><D8B1>豸
void OceanOptics_lib::Close()
{
int flag;
int error;
flag = seabreeze_close_spectrometer(m_iSpectralmeterHandle, &error);
// printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
int OceanOptics_lib::SingleShot(DataFrame &dfData)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
int flag;
int spec_length;
double *spectrum = 0;
bool ret;
// printf("\n\nGetting formatted spectrum length.\n");
spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
//printf("Get formatted spectrum_length result is (%d) [%s]\n", spec_length, get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
if (spec_length > 0)
{
spectrum = (double *)calloc((size_t)spec_length, sizeof(double));
seabreeze_clear_buffer(m_iSpectralmeterHandle, &error);
printf("\nGetting a formatted spectrum.\n");
flag = seabreeze_get_formatted_spectrum(m_iSpectralmeterHandle, &error, spectrum, spec_length);
printf("\nGetting a formatted spectrum------------------------------.\n");
// printf("Get formatted spectrum result is (%d) [%s]\n", flag, get_error_string(error));
// printf("\tPixel value 20 is %1.2f\n", spectrum[20]);
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
for (int tmp = 0; tmp < spec_length; tmp++)
{
dfData.lData[tmp] = spectrum[tmp];
}
int exposureTimeInMS;
GetExposureTime(exposureTimeInMS);
dfData.usExposureTimeInMS = exposureTimeInMS;
float temperature;
GetDeviceTemperature(temperature);
dfData.fTemperature = temperature;
free(spectrum);
}
return 0;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int OceanOptics_lib::SetExposureTime(int iExposureTimeInMS)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
seabreeze_set_integration_time_microsec(m_iSpectralmeterHandle, &error, iExposureTimeInMS * 1000);
printf("Set integration time result is [%s]\n", get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
m_iExposureTime = iExposureTimeInMS;
// //----------------------------------------------------------------------------------------------------------------
// int error;
// long *spectrometer_ids;
// int number_of_spectrometers;
//
// number_of_spectrometers = sbapi_get_number_of_spectrometer_features(m_iSpectralmeterHandle, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_spectrometers, sbapi_get_error_string(error));
// spectrometer_ids = (long *)calloc(number_of_spectrometers, sizeof(long));
// number_of_spectrometers = sbapi_get_spectrometer_features(m_iSpectralmeterHandle, &error, spectrometer_ids, number_of_spectrometers);
// printf("\t\t\tResult is %d [%s]\n", number_of_spectrometers, sbapi_get_error_string(error));
//
// sbapi_spectrometer_set_integration_time_micros(m_iSpectralmeterHandle, spectrometer_ids[0], &error, iExposureTimeInMS*1000);
// printf("\t\t\t\tResult is [%s]\n", sbapi_get_error_string(error));
return 0;
}
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetExposureTime(int &iExposureTimeInMS)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
iExposureTimeInMS = m_iExposureTime;
return 0;
}
//<2F><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
int OceanOptics_lib::SetDeviceTemperature(float fTemperature)
{
bool ret;
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
// printf("\nSetting TEC temperature to -5C\n");
seabreeze_set_tec_temperature(m_iSpectralmeterHandle, &error, fTemperature);
// printf("Set tec temperature result is [%s]\n", get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
// printf("\nSetting TEC enable to true\n");
seabreeze_set_tec_enable(m_iSpectralmeterHandle, &error, 1);
// printf("Set tec enable result is [%s]\n", get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
return 0;
}
//<2F><>ȡ<EFBFBD><EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetDeviceTemperature(float &fTemperature)
{
fTemperature = 0;
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
double temp;
int error;
// usleep(1000000);
// printf("\nGetting TEC temperature\n");
temp = seabreeze_read_tec_temperature(m_iSpectralmeterHandle, &error);
// printf("Read tec temperature result is %1.2f C [%s]\n", temp, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
fTemperature = temp;
return 0;
}
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
int OceanOptics_lib::GetDeviceInfo(DeviceInfo &Info)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
string deviceType = GetDeviceType(m_iSpectralmeterHandle);
string SN = GetSerialNumber(m_iSpectralmeterHandle);
Info.strPN = deviceType;
Info.strSN = SN;
return 0;
}
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetDeviceAttribute(DeviceAttribute &Attr)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
int flag;
int spec_length;
double *wls = 0;
// printf("\n\nGetting formatted spectrum length.\n");
spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
// printf("Get formatted spectrum length result is (%d) [%s]\n", spec_length, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
Attr.iPixels = spec_length;
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
Attr.iMinIntegrationTimeInMS = (int)((double)minimum_time / (double)1000);
Attr.iMaxIntegrationTimeInMS = 60000;
if (spec_length > 0) {
wls = (double *)calloc((size_t)spec_length, sizeof(double));
// printf("\nGetting wavelengths.\n");
flag = seabreeze_get_wavelengths(m_iSpectralmeterHandle, &error, wls, spec_length);
// printf("Get wavelengths result is (%d) [%s]\n", flag, get_error_string(error));
// printf("\tPixel 20 is wavelength %1.2f nm\n", wls[20]);
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
for (int tmp = 0; tmp < spec_length; tmp++)
{
Attr.fWaveLengthInNM[tmp] = wls[tmp];
}
free(wls);
}
return 0;
}
bool OceanOptics_lib::isSuccess(char* resultStr)
{
if (strstr(resultStr, "Success") == NULL)//<2F><>a<EFBFBD>в<EFBFBD><D0B2><EFBFBD>b<EFBFBD><62><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>
{
//cout << "not found\n";//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return false;
}
else//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڡ<EFBFBD>
{
//cout <<"found\n"; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return true;
}
}
const char* OceanOptics_lib::get_error_string(int error)
{
static char buffer[32];
seabreeze_get_error_string(error, buffer, sizeof(buffer));
return buffer;
}
string OceanOptics_lib::GetDeviceType(int index)
{
char type[16];
int error;
seabreeze_get_model(index, &error, type, sizeof(type));
// printf("...Result is (%s) [%s]\n", type, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return "";
}
type[15] = '\0';
string deviceType = type;
return deviceType;
}
string OceanOptics_lib::GetSerialNumber(int index)
{
static char serial_number[32];//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>static<69><63><EFBFBD>˱<EFBFBD><CBB1><EFBFBD><EFBFBD>ᶨ<EFBFBD><E1B6A8><EFBFBD><EFBFBD>stack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>غ󣬾<D8BA><F3A3ACBE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int flag;
int error;
// printf("\n\nGetting serial number.\n");
flag = seabreeze_get_serial_number(index, &error, serial_number, 32);
// printf("Get serial number result is (%d) [%s]\n", flag, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return "";
}
serial_number[31] = '\0';
if (flag > 0) {
printf("\tSerial number: [%s]\n", serial_number);
}
string sn = serial_number;
return sn;
}

57
Source/FS/OControl_USB.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include "api/SeaBreezeWrapper.h"
#include "IrisFiberSpectrometerBase.h"
using namespace std;
class OceanOptics_lib :public CIrisFSBase
{
public:
OceanOptics_lib();
virtual ~OceanOptics_lib();
public:
//初始化设备
//此处string为指明连接哪个ocean光谱仪的参数，可自行更换为其他c/c++标准类型
//0为无错误，不同错误请返回不同值(不能确定：当不成功时SeaBreeze返回的错误代码error不为0 → 不敢将error直接返回)
int Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);//ok
int Initialize();//ok
//关闭设备
void Close();//ok
//单次数据采集
int SingleShot(DataFrame &dfData);
//设置曝光时间
int SetExposureTime(int iExposureTimeInMS);//ok
//获取曝光时间设置
int GetExposureTime(int &iExposureTimeInMS);//ok
//设置目标温度
int SetDeviceTemperature(float fTemperature);//ok
//获取温度设置
int GetDeviceTemperature(float &fTemperature);//ok
//获取设备信息
int GetDeviceInfo(DeviceInfo &Info);//ok
//获取设备特征数据
int GetDeviceAttribute(DeviceAttribute &Attr);//ok
//tc
static const char* get_error_string(int error);
private:
int m_iSpectralmeterHandle;
DeviceInfo m_deviceInfo;
int m_iExposureTime;
bool isSuccess(char* resultStr);
string GetDeviceType(int index);
string GetSerialNumber(int index);
};

390
Source/FS/ZZ_Types.h Normal file
View File

@ -0,0 +1,390 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include <string>
#define MAX_DEVICENUMBER_FS 2
#define MAX_LINEARSHUTTER_POSITION 12
#define ZZ_Enum2String(x) #x
namespace ZZ_MISCDEF
{
typedef unsigned char ZZ_U8;
typedef unsigned short int ZZ_U16;
typedef unsigned int ZZ_U32;
typedef int ZZ_S32;
namespace IRIS
{
//Fiber Spectrometer
namespace FS
{
typedef struct tagDataFrame
{
ZZ_U32 usExposureTimeInMS;
ZZ_S32 lData[4096];
float fTemperature = 0;
double dTimes = 0;
}DataFrame;
typedef struct tagDeviceInfo
{
std::string strPN;
std::string strSN;
}DeviceInfo;
typedef struct tagDeviceAttribute
{
int iPixels;
int iMaxIntegrationTimeInMS;
int iMinIntegrationTimeInMS;
float fWaveLengthInNM[4096];
}DeviceAttribute;
// inline DataFrame GetIndex(DataFrame dfDark, DataFrame dfSignal)
// {
//
// }
}
enum DeviceModel
{
OSIFAlpha = 0,
OSIFBeta,
FLAME,
QEP,
ISIF,
IS1,
IS2
};
inline std::string GetDeviceModelName(int iModel)
{
switch (iModel)
{
case DeviceModel::OSIFAlpha: return "OSIFAlpha"; break;
case DeviceModel::OSIFBeta: return "OSIFBeta"; break;
case DeviceModel::FLAME: return "FLAME"; break;
case DeviceModel::QEP: return "QEP"; break;
case DeviceModel::ISIF: return "ISIF"; break;
case DeviceModel::IS1: return "IS1"; break;
case DeviceModel::IS2: return "IS2"; break;
default: return "error"; break;
}
}
inline int GetIndex(std::string strDeviceModelName)
{
if (strDeviceModelName == "OSIFAlpha")
{
return DeviceModel::OSIFAlpha;
}
else if (strDeviceModelName == "OSIFBeta")
{
return DeviceModel::OSIFBeta;
}
else if (strDeviceModelName == "FLAME")
{
return DeviceModel::FLAME;
}
else if (strDeviceModelName == "QEP")
{
return DeviceModel::QEP;
}
else if (strDeviceModelName == "ISIF")
{
return DeviceModel::ISIF;
}
else if (strDeviceModelName == "IS1")
{
return DeviceModel::IS1;
}
else if (strDeviceModelName == "IS2")
{
return DeviceModel::IS2;
}
else
{
return -1;
}
}
};
//ATPָ<50><D6B8>ת<EFBFBD><D7AA>
namespace ATP
{
const int MAX_SPECTRUM_SIZE = 4096;
const int GET_MODULECIRCUIT_TEMP = 0x01;
const int GET_PN_NUMBER = 0x03;
const int GET_SN_NUMBER = 0x04;
const int GET_MANUFACTURE_DATA = 0x06;
const int GET_MANUFACTURE_INFO = 0x09;
const int GET_PIXEL_LENGTH = 0x0a;
const int GET_TEC_TEMP = 0x13;
const int SET_TEC_TEMP = 0x12;
const int GET_OPTICS_TEMP = 0x35;
const int GET_CIRCUITBOARD_TEMP = 0x36;
const int SET_INTEGRATION_TIME = 0x14;
const int GET_INTEGRATION_TIME = 0x41;
const int GET_MAX_INTEGRATION_TIME = 0x42;
const int GET_MIN_INTEGRATION_TIME = 0x43;
const int ASYNC_COLLECT_DARK = 0x23;
const int ASYNC_START_COLLECTION = 0x16;
const int ASYNC_READ_DATA = 0x17;
const int SET_AVERAGE_NUMBER = 0x28;
const int SYNC_GET_DATA = 0x1e;
const int SYNC_GET_DARK = 0x2f;
const int EXTERNAL_TRIGGER_ENABLE = 0x1f;
const int SET_XENON_LAMP_DELAY_TIME = 0x24;
const int GET_WAVELENGTH_CALIBRATION_COEF = 0x55;
const int GET_STAT_LAMPOUT = 0x60;
const int SET_GPIO = 0x61;
//const int SYNCHRONIZATION_GET_DARK = 0x23
//////////////////////////////////////////////////////////////////////////device
enum Model
{
ATP1010 = 0,
ATP6500
};
//<2F><><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>
typedef struct tagATPDataFrame
{
unsigned short usExposureTime;
ZZ_U16 usData[4096];
float fTemperature;
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;
int iMaxIntegrationTime;
int iMinIntegrationTime;
float fWaveLength[4096];
}ATPDeviceAttribute;
//////////////////////////////////////////////////////////////////////////config file
}
//<2F><><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
namespace ZZ_RUNPARAMS
{
typedef struct tagErrorInfo
{
int iDataTransferErr = -1000;
float fTecTempErr = -1000;
int iShutterErr = -1000;
float fChassisTempErr = -1000;
}ErrInfo;
typedef struct tagFiberSpecContext
{
ZZ_U8 ucDeviceNumber;
ZZ_U8 ucDeviceModel[MAX_DEVICENUMBER_FS];
std::string strInterface[MAX_DEVICENUMBER_FS];
std::string strSN[MAX_DEVICENUMBER_FS];
long lDepth[MAX_DEVICENUMBER_FS];
float fMinFactor[MAX_DEVICENUMBER_FS];
float fMaxFactor[MAX_DEVICENUMBER_FS];
ZZ_U16 usPixels[MAX_DEVICENUMBER_FS];
float fWavelength[MAX_DEVICENUMBER_FS][4096];
}FSContext;
typedef struct tagOneFiberSpecContext
{
ZZ_U8 ucDeviceNumber = 1;
ZZ_U8 ucDeviceModel;
std::string strInterface;
std::string strSN;
long lDepth;
float fMinFactor;
float fMaxFactor;
ZZ_U16 usPixels;
float fWavelength[4096];
double dMinSamplingInterval;//in millisec
}OneFSContext;
typedef struct tagLinearShutterContext
{
std::string strInterface;
ZZ_U8 ucProtocolType;
ZZ_U8 ucCmdID;
}LSContext;
typedef struct tagAcquisitionTimeSettings
{
QTime qtStartTime;
QTime qtStopTime;
QTime qtInterval;
}AcqTimeSettings;
typedef struct tagAcquisitionPositionSettings
{
int iTotalPosition;
int iPosition[MAX_LINEARSHUTTER_POSITION];
}AcqPosSettings;
typedef struct tagRunTimeGrabberParams
{
LSContext lscParam;
FSContext fscParams;
AcqTimeSettings atsParams;
AcqPosSettings apsParams;
}RunTimeGrabberParams;
typedef struct tagATPCalibrationSettings
{
//Up0 Down1,2,3
QString qsISIF_CalibrationFilePath[4];
QString qsIS1_CalibrationFilePath[4];
}ATPCalibrationSettings;
// typedef struct tagFODISRuntimeParams
// {
// int iMinScanIntervalInMS;//millisecond
// }FodisRP;
}
//ϵͳ<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;
QString qstrDEV_SN;
}EContext;
typedef struct tagManmadeEnviromentalContext
{
QString qstrOriFileName;
QString qstrInstallationTime;
QString qstrISIFCalibrationTime;
QString qstrIS1CalibrationTime;
QString qstrNameOfMaintenanceStaff;
QString qstrPhoneNumberOfMaintenanceStaff;
QString qstrDownloadUserID;
QString qstrDownlaodAddress;
QString qstrHTTPServer;
}MEContext;
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
{
}ATPDataHeader;
typedef struct tagCalibrationFrame
{
ZZ_U32 uiExposureTimeInMS;
float fTemperature;
int iPixels;
float fWaveLength[4096] = { 0 };
double dCal_Gain[4096] = { 0 };
double dCal_Offset[4096] = { 0 };
}CalFrame;
typedef struct tagCalDataFrame
{
ZZ_U32 usExposureTimeInMS;
float fTemperature = 0;
int iPixels;
float fData[4096];
QString qstrGrabDate;
}CalDataFrame;
}
//misc detector
namespace MISC_DETECTOR
{
typedef struct tagHumitureDeviceInfo
{
QString qstrInterfaceName;
}HumitureDeviceInfo;
typedef struct tagGPSDeviceInfo
{
QString qstrInterfaceName;
int iBaud;
}GPSInfo;
}
};

251
Source/GPS/BD357Ctrl.cpp Normal file
View File

@ -0,0 +1,251 @@
#include "BD357Ctrl.h"
#include "MainGrabber.h"
#include "lwgps.h"
#include "lwrb.h"
#include "time.h"
BD357Controller::BD357Controller(QObject* parent /*= nullptr*/)
{
m_iFlagIsGPSValid = 0;
m_iFlagIsContinuousUpdating = 0;
m_pSerialPort = NULL;
//connect(m_pSerialPort, &QSerialPort::readyRead, this, &BD357Controller::HandleReadyRead);
connect(this, &BD357Controller::Signal_InitSelf, this, &BD357Controller::Slot_InitSelf);
//connect(m_pMainGrabber,&CMainGrabber::Signal_InitFinished,this, &BD357Controller::Slot_SyncDateOnce);
}
BD357Controller::~BD357Controller()
{
if (m_pSerialPort != NULL)
{
m_pSerialPort->close();
delete m_pSerialPort;
}
}
int BD357Controller::SetContext(CMainGrabber& pMainGrabber)
{
m_pMainGrabber = &pMainGrabber;
}
int BD357Controller::SetupMessagePipeline()
{
connect(m_pMainGrabber, &CMainGrabber::Signal_InitFinished, this, &BD357Controller::Slot_SyncDateOnce);
return 0;
}
int BD357Controller::SyncDateOnce()
{
using namespace ZZ_MISCDEF;
bool bFlagFinish = false;
size_t uiCount = 0;
ZZ_U8 u8Rx,u8Tx;
while (!bFlagFinish)
{
m_qbReadData.clear();
while (m_qbReadData.size()< 1000)
{
m_pSerialPort->waitForReadyRead(1000);
m_qbReadData.append(m_pSerialPort->readAll());
}
qDebug() << m_qbReadData.size() << endl;
lwgps_process(&m_hLWGPS, m_qbReadData, m_qbReadData.size());
m_qbReadData.clear();
if (uiCount<2)
{
uiCount++;
continue;
}
else
{
/*if (m_hLWGPS.is_valid)
{
bFlagFinish = 1;
}*/
}
//need to disable
//qDebug() << "one status :"<< m_hLWGPS.is_valid << m_hLWGPS .sats_in_use<< m_hLWGPS .year<<"-" << m_hLWGPS .month<<"-" << m_hLWGPS.date << "-" << m_hLWGPS.hours << ":" << m_hLWGPS.minutes << ":" << m_hLWGPS.seconds << ":" << endl;
int iRes = ZZ_FormatTime(m_hLWGPS.year, m_hLWGPS.month, m_hLWGPS.date, m_hLWGPS.hours, m_hLWGPS.minutes, m_hLWGPS.seconds);
if (iRes != 0)
{
continue;
}
else
{
bFlagFinish = 1;
time_t stdtime = m_qdtDateTime.toTime_t();
time_t stdtimeUTC = m_qdtDateTimeUTC.toTime_t();
stime(&stdtimeUTC);
system("gpio write 4 1");
qDebug() << "system(gpio write 4 1)";
//
//m_qdtDateTime.currentMSecsSinceEpoch
//m_qdtDateTime.currentMSecsSinceEpoch();
}
//bFlagFinish = 1;
}
emit Signal_StartCapture();
return 0;
}
int BD357Controller::StartContinuousUpdating()
{
m_iFlagIsContinuousUpdating = 1;
while (m_iFlagIsContinuousUpdating)
{
m_qbReadData.clear();
while (m_qbReadData.size() < 1000)
{
m_pSerialPort->waitForReadyRead(1000);
m_qbReadData.append(m_pSerialPort->readAll());
}
//qDebug() << m_qbReadData.size() << endl;
lwgps_process(&m_hLWGPS, m_qbReadData, m_qbReadData.size());
if (m_hLWGPS.is_valid&&(!m_iFlagIsGPSValid))
{
emit Signal_UpdateStatus(1);
}
if ((!m_hLWGPS.is_valid)&& m_iFlagIsGPSValid)
{
emit Signal_UpdateStatus(0);
}
m_qbReadData.clear();
}
return 0;
}
int BD357Controller::Initialize(GPSInfo &struGPSI)
{
m_struGPSInfo = struGPSI;
emit Signal_InitSelf();
}
int BD357Controller::ZZ_FormatTime(ZZ_U8 u8Year, ZZ_U8 u8Month, ZZ_U8 u8Day, ZZ_U8 u8Hour, ZZ_U8 u8Minute, ZZ_U8 u8Second)
{
int iYear = u8Year + 2000;
QDateTime qdtTestDate(QDate(iYear, u8Month, u8Day), QTime(u8Hour, u8Minute, u8Second));
if (qdtTestDate.isValid())
{
qDebug() << qdtTestDate;
m_qdtDateTime = qdtTestDate;
m_qdtDateTimeUTC = qdtTestDate;
//UTC+0 to UTC+8
m_qdtDateTime.addSecs(3600 * 8);
return 0;
}
else
{
return -1;
}
return -2;
//bool b1 = startDate.isValid();
//QString end = startDate.toString("yyyy.MM.dd hh:mm:ss");
//qDebug() << end;
//QString qstrSyncDate = QString("%1-%2-%3-%4-%5-%6").arg(iYear, 4, 10, QLatin1Char('0')).arg(u8Month, 2, 10, QLatin1Char('0'))
// .arg(u8Day, 2, 10, QLatin1Char('0')).arg(u8Hour, 2, 10, QLatin1Char('0'))
// .arg(u8Minute, 2, 10, QLatin1Char('0')).arg(u8Second, 2, 10, QLatin1Char('0'));
//
//m_qdtDateTime.fromString(qstrSyncDate, "yyyy-MM-dd-hh-mm-ss");
//qDebug() << qstrSyncDate;
//bool b = m_qdtDateTime.isValid();
//QString begin = m_qdtDateTime.toString("yyyy.MM.dd hh:mm:ss");
//qDebug() << begin;
/*qstrSyncDate = "20" + QString::number(m_hLWGPS.year) + "-"
+ QString::number(m_hLWGPS.month) + "-"
+ QString::number(m_hLWGPS.date) + "-"
+ QString::number(m_hLWGPS.hours) + "-"
+ QString::number(m_hLWGPS.minutes) + "-"
+ QString::number(m_hLWGPS.seconds);
qdtSync.fromString(qstrSyncDate, "yyyy-MM-dd-hh-mm-ss");
qDebug() << qstrSyncDate;
bool b = qdtSync.isValid();
QString begin = qdtSync.toString("yyyy.MM.dd hh:mm:ss");
std::string strtime = begin.toStdString();
qDebug() << begin;*/
}
int BD357Controller::Slot_InitSelf()
{
m_qbReadData.clear();
//QString qstrPortName = struGPSI.qstrInterfaceName;
if (m_pSerialPort != NULL)
{
m_pSerialPort->close();
delete m_pSerialPort;
}
m_pSerialPort = new QSerialPort;
m_pSerialPort->setPortName(m_struGPSInfo.qstrInterfaceName);
//m_pSerialPort->setReadBufferSize(512); in this project 0 seems a better param.
bool bRes = m_pSerialPort->setBaudRate(m_struGPSInfo.iBaud);
if (!bRes)
{
qDebug() << "Err:setBaudRate Failed.Exit Code:1";
//std::cout << "Err.setBaudRate Failed" << std::endl;
return 1;
}
bRes = m_pSerialPort->open(QIODevice::ReadWrite);
if (!bRes)
{
qDebug() << "Err:open Failed.Exit Code:2";
//std::cout << "Err.open Failed" << std::endl;
return 2;
}
/////
lwgps_init(&m_hLWGPS);
lwrb_init(&m_hlwrbBuffer, m_u8GPSDataBuffer, sizeof(m_u8GPSDataBuffer));
}
int BD357Controller::Slot_SyncDateOnce()
{
SyncDateOnce();
return 0;
}
//
// int BD357Controller::HandleReadyRead()
// {
// size_t uiSize = 0;
// m_qbReadData.append(m_pSerialPort->readAll());
// if (m_qbReadData.size()<2048)
// {
// lwrb_write(&m_hlwrbBuffer, &m_qbReadData, m_qbReadData.size());
// m_qbReadData.clear();
// }
// else
// {
// m_qbReadData.clear();
// }
//
// return 0;
// }

50
Source/GPS/BD357Ctrl.h Normal file
View File

@ -0,0 +1,50 @@
#pragma once
#include "ZZ_Types.h"
#include "pch.h"
#include "lwgps.h"
#include "lwrb.h"
#include <atomic>
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::MISC_DETECTOR;
class CMainGrabber;
class BD357Controller :public QObject
{
Q_OBJECT
public:
BD357Controller(QObject* parent = nullptr);
~BD357Controller();
private:
std::atomic<int> m_iFlagIsGPSValid;
std::atomic<int> m_iFlagIsContinuousUpdating;
std::atomic<int> m_iFlagIsConnected;
public:
int SetContext(CMainGrabber &pMainGrabber);
int SetupMessagePipeline();
int SyncDateOnce();
int StartContinuousUpdating();
int Initialize(GPSInfo &struGPSI);
private:
int ZZ_FormatTime(ZZ_U8 u8Year,ZZ_U8 u8Month, ZZ_U8 u8Day, ZZ_U8 u8Hour, ZZ_U8 u8Minute, ZZ_U8 u8Second);
public slots:
int Slot_InitSelf();
int Slot_SyncDateOnce();
private slots:
//int HandleReadyRead();
signals:
void Signal_InitSelf();
void Signal_StartCapture();
void Signal_UpdateStatus(int iValid);
void Signal_UpdateDate(QTime qDate);
private:
QDateTime m_qdtDateTime, m_qdtDateTimeUTC;
GPSInfo m_struGPSInfo;
ZZ_U8 m_u8GPSDataBuffer[10];
lwgps_t m_hLWGPS;
lwrb_t m_hlwrbBuffer;
int m_iBaudRate;
QSerialPort* m_pSerialPort;
QByteArray m_qbReadData;
CMainGrabber* m_pMainGrabber;
};

606
Source/GPS/lwgps.cpp Normal file
View File

@ -0,0 +1,606 @@
/**
* \file lwgps.c
* \brief GPS main file
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwGPS - Lightweight GPS NMEA parser library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v2.1.0
*/
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "lwgps.h"
#define FLT(x) ((lwgps_float_t)(x))
#define D2R(x) FLT(FLT(x) * FLT(0.01745329251994)) /*!< Degrees to radians */
#define R2D(x) FLT(FLT(x) * FLT(57.29577951308232))/*!< Radians to degrees */
#define EARTH_RADIUS FLT(6371.0) /*!< Earth radius in units of kilometers */
#define CRC_ADD(_gh, ch) (_gh)->p.crc_calc ^= (uint8_t)(ch)
#define TERM_ADD(_gh, ch) do { \
if ((_gh)->p.term_pos < (sizeof((_gh)->p.term_str) - 1)) { \
(_gh)->p.term_str[(_gh)->p.term_pos] = (ch);\
(_gh)->p.term_str[++(_gh)->p.term_pos] = 0; \
} \
} while (0)
#define TERM_NEXT(_gh) do { (_gh)->p.term_str[((_gh)->p.term_pos = 0)] = 0; ++(_gh)->p.term_num; } while (0)
#define CIN(x) ((x) >= '0' && (x) <= '9')
#define CIHN(x) (((x) >= '0' && (x) <= '9') || ((x) >= 'a' && (x) <= 'f') || ((x) >= 'A' && (x) <= 'F'))
#define CTN(x) ((x) - '0')
#define CHTN(x) (((x) >= '0' && (x) <= '9') ? ((x) - '0') : (((x) >= 'a' && (x) <= 'z') ? ((x) - 'a' + 10) : (((x) >= 'A' && (x) <= 'Z') ? ((x) - 'A' + 10) : 0)))
/**
* \brief Parse number as integer
* \param[in] gh: GPS handle
* \param[in] t: Text to parse. Set to `NULL` to parse current GPS term
* \return Parsed integer
*/
static int32_t
prv_parse_number(lwgps_t* gh, const char* t) {
int32_t res = 0;
uint8_t minus;
if (t == NULL) {
t = gh->p.term_str;
}
for (; t != NULL && *t == ' '; ++t) {} /* Strip leading spaces */
minus = (*t == '-' ? (++t, 1) : 0);
for (; t != NULL && CIN(*t); ++t) {
res = 10 * res + CTN(*t);
}
return minus ? -res : res;
}
/**
* \brief Parse number as double and convert it to \ref lwgps_float_t
* \param[in] gh: GPS handle
* \param[in] t: Text to parse. Set to `NULL` to parse current GPS term
* \return Parsed double in \ref lwgps_float_t format
*/
static lwgps_float_t
prv_parse_float_number(lwgps_t* gh, const char* t) {
lwgps_float_t res;
if (t == NULL) {
t = gh->p.term_str;
}
for (; t != NULL && *t == ' '; ++t) {} /* Strip leading spaces */
#if LWGPS_CFG_DOUBLE
res = strtod(t, NULL); /* Parse string to double */
#else /* LWGPS_CFG_DOUBLE */
res = strtof(t, NULL); /* Parse string to float */
#endif /* !LWGPS_CFG_DOUBLE */
return FLT(res); /* Return casted value, based on float size */
}
/**
* \brief Parse latitude/longitude NMEA format to double
*
* NMEA output for latitude is ddmm.sss and longitude is dddmm.sss
* \param[in] gh: GPS handle
* \return Latitude/Longitude value in degrees
*/
static lwgps_float_t
prv_parse_lat_long(lwgps_t* gh) {
lwgps_float_t ll, deg, min;
ll = prv_parse_float_number(gh, NULL); /* Parse value as double */
deg = FLT((int)((int)ll / 100)); /* Get absolute degrees value, interested in integer part only */
min = ll - (deg * FLT(100)); /* Get remaining part from full number, minutes */
ll = deg + (min / FLT(60.0)); /* Calculate latitude/longitude */
return ll;
}
/**
* \brief Parse received term
* \param[in] gh: GPS handle
* \return `1` on success, `0` otherwise
*/
static uint8_t
prv_parse_term(lwgps_t* gh) {
if (gh->p.term_num == 0) { /* Check string type */
if (0) {
#if LWGPS_CFG_STATEMENT_GPGGA
} else if (!strncmp(gh->p.term_str, "$GPGGA", 6) || !strncmp(gh->p.term_str, "$GNGGA", 6)) {
gh->p.stat = STAT_GGA;
#endif /* LWGPS_CFG_STATEMENT_GPGGA */
#if LWGPS_CFG_STATEMENT_GPGSA
} else if (!strncmp(gh->p.term_str, "$GPGSA", 6) || !strncmp(gh->p.term_str, "$GNGSA", 6)) {
gh->p.stat = STAT_GSA;
#endif /* LWGPS_CFG_STATEMENT_GPGSA */
#if LWGPS_CFG_STATEMENT_GPGSV
} else if (!strncmp(gh->p.term_str, "$GPGSV", 6) || !strncmp(gh->p.term_str, "$GNGSV", 6)) {
gh->p.stat = STAT_GSV;
#endif /* LWGPS_CFG_STATEMENT_GPGSV */
#if LWGPS_CFG_STATEMENT_GPRMC
} else if (!strncmp(gh->p.term_str, "$GPRMC", 6) || !strncmp(gh->p.term_str, "$GNRMC", 6)) {
gh->p.stat = STAT_RMC;
#endif /* LWGPS_CFG_STATEMENT_GPRMC */
#if LWGPS_CFG_STATEMENT_PUBX
} else if (!strncmp(gh->p.term_str, "$PUBX", 5)) {
gh->p.stat = STAT_UBX;
#endif /* LWGPS_CFG_STATEMENT_PUBX */
} else {
gh->p.stat = STAT_UNKNOWN; /* Invalid statement for library */
}
return 1;
}
/* Start parsing terms */
if (gh->p.stat == STAT_UNKNOWN) {
#if LWGPS_CFG_STATEMENT_GPGGA
} else if (gh->p.stat == STAT_GGA) { /* Process GPGGA statement */
switch (gh->p.term_num) {
case 1: /* Process UTC time */
gh->p.data.gga.hours = 10 * CTN(gh->p.term_str[0]) + CTN(gh->p.term_str[1]);
gh->p.data.gga.minutes = 10 * CTN(gh->p.term_str[2]) + CTN(gh->p.term_str[3]);
gh->p.data.gga.seconds = 10 * CTN(gh->p.term_str[4]) + CTN(gh->p.term_str[5]);
break;
case 2: /* Latitude */
gh->p.data.gga.latitude = prv_parse_lat_long(gh); /* Parse latitude */
break;
case 3: /* Latitude north/south information */
if (gh->p.term_str[0] == 'S' || gh->p.term_str[0] == 's') {
gh->p.data.gga.latitude = -gh->p.data.gga.latitude;
}
break;
case 4: /* Longitude */
gh->p.data.gga.longitude = prv_parse_lat_long(gh); /* Parse longitude */
break;
case 5: /* Longitude east/west information */
if (gh->p.term_str[0] == 'W' || gh->p.term_str[0] == 'w') {
gh->p.data.gga.longitude = -gh->p.data.gga.longitude;
}
break;
case 6: /* Fix status */
gh->p.data.gga.fix = (uint8_t)prv_parse_number(gh, NULL);
break;
case 7: /* Satellites in use */
gh->p.data.gga.sats_in_use = (uint8_t)prv_parse_number(gh, NULL);
break;
case 9: /* Altitude */
gh->p.data.gga.altitude = prv_parse_float_number(gh, NULL);
break;
case 11: /* Altitude above ellipsoid */
gh->p.data.gga.geo_sep = prv_parse_float_number(gh, NULL);
break;
default:
break;
}
#endif /* LWGPS_CFG_STATEMENT_GPGGA */
#if LWGPS_CFG_STATEMENT_GPGSA
} else if (gh->p.stat == STAT_GSA) { /* Process GPGSA statement */
switch (gh->p.term_num) {
case 2: /* Process fix mode */
gh->p.data.gsa.fix_mode = (uint8_t)prv_parse_number(gh, NULL);
break;
case 15: /* Process PDOP */
gh->p.data.gsa.dop_p = prv_parse_float_number(gh, NULL);
break;
case 16: /* Process HDOP */
gh->p.data.gsa.dop_h = prv_parse_float_number(gh, NULL);
break;
case 17: /* Process VDOP */
gh->p.data.gsa.dop_v = prv_parse_float_number(gh, NULL);
break;
default:
/* Parse satellite IDs */
if (gh->p.term_num >= 3 && gh->p.term_num <= 14) {
gh->p.data.gsa.satellites_ids[gh->p.term_num - 3] = (uint8_t)prv_parse_number(gh, NULL);
}
break;
}
#endif /* LWGPS_CFG_STATEMENT_GPGSA */
#if LWGPS_CFG_STATEMENT_GPGSV
} else if (gh->p.stat == STAT_GSV) { /* Process GPGSV statement */
switch (gh->p.term_num) {
case 2: /* Current GPGSV statement number */
gh->p.data.gsv.stat_num = (uint8_t)prv_parse_number(gh, NULL);
break;
case 3: /* Process satellites in view */
gh->p.data.gsv.sats_in_view = (uint8_t)prv_parse_number(gh, NULL);
break;
default:
#if LWGPS_CFG_STATEMENT_GPGSV_SAT_DET
if (gh->p.term_num >= 4 && gh->p.term_num <= 19) { /* Check current term number */
uint8_t index, term_num = gh->p.term_num - 4; /* Normalize term number from 4-19 to 0-15 */
uint16_t value;
index = ((gh->p.data.gsv.stat_num - 1) << 0x02) + (term_num >> 2); /* Get array index */
if (index < sizeof(gh->sats_in_view_desc) / sizeof(gh->sats_in_view_desc[0])) {
value = (uint16_t)prv_parse_number(gh, NULL); /* Parse number as integer */
switch (term_num & 0x03) {
case 0:
gh->sats_in_view_desc[index].num = value;
break;
case 1:
gh->sats_in_view_desc[index].elevation = value;
break;
case 2:
gh->sats_in_view_desc[index].azimuth = value;
break;
case 3:
gh->sats_in_view_desc[index].snr = value;
break;
default:
break;
}
}
}
#endif /* LWGPS_CFG_STATEMENT_GPGSV_SAT_DET */
break;
}
#endif /* LWGPS_CFG_STATEMENT_GPGSV */
#if LWGPS_CFG_STATEMENT_GPRMC
} else if (gh->p.stat == STAT_RMC) { /* Process GPRMC statement */
switch (gh->p.term_num) {
case 2: /* Process valid status */
gh->p.data.rmc.is_valid = (gh->p.term_str[0] == 'A');
break;
case 7: /* Process ground speed in knots */
gh->p.data.rmc.speed = prv_parse_float_number(gh, NULL);
break;
case 8: /* Process true ground coarse */
gh->p.data.rmc.course = prv_parse_float_number(gh, NULL);
break;
case 9: /* Process date */
gh->p.data.rmc.date = (uint8_t)(10 * CTN(gh->p.term_str[0]) + CTN(gh->p.term_str[1]));
gh->p.data.rmc.month = (uint8_t)(10 * CTN(gh->p.term_str[2]) + CTN(gh->p.term_str[3]));
gh->p.data.rmc.year = (uint8_t)(10 * CTN(gh->p.term_str[4]) + CTN(gh->p.term_str[5]));
break;
case 10: /* Process magnetic variation */
gh->p.data.rmc.variation = prv_parse_float_number(gh, NULL);
break;
case 11: /* Process magnetic variation east/west */
if (gh->p.term_str[0] == 'W' || gh->p.term_str[0] == 'w') {
gh->p.data.rmc.variation = -gh->p.data.rmc.variation;
}
break;
default:
break;
}
#endif /* LWGPS_CFG_STATEMENT_GPRMC */
#if LWGPS_CFG_STATEMENT_PUBX
} else if (gh->p.stat == STAT_UBX) { /* Disambiguate generic PUBX statement */
if (gh->p.term_str[0] == '0' && gh->p.term_str[1] == '4') {
gh->p.stat = STAT_UBX_TIME;
}
#if LWGPS_CFG_STATEMENT_PUBX_TIME
} else if (gh->p.stat == STAT_UBX_TIME) { /* Process PUBX (uBlox) TIME statement */
switch (gh->p.term_num) {
case 2: /* Process UTC time; ignore fractions of seconds */
gh->p.data.time.hours = 10 * CTN(gh->p.term_str[0]) + CTN(gh->p.term_str[1]);
gh->p.data.time.minutes = 10 * CTN(gh->p.term_str[2]) + CTN(gh->p.term_str[3]);
gh->p.data.time.seconds = 10 * CTN(gh->p.term_str[4]) + CTN(gh->p.term_str[5]);
break;
case 3: /* Process UTC date */
gh->p.data.time.date = 10 * CTN(gh->p.term_str[0]) + CTN(gh->p.term_str[1]);
gh->p.data.time.month = 10 * CTN(gh->p.term_str[2]) + CTN(gh->p.term_str[3]);
gh->p.data.time.year = 10 * CTN(gh->p.term_str[4]) + CTN(gh->p.term_str[5]);
break;
case 4: /* Process UTC TimeOfWeek */
gh->p.data.time.utc_tow = prv_parse_float_number(gh, NULL);
break;
case 5: /* Process UTC WeekNumber */
gh->p.data.time.utc_wk = prv_parse_number(gh, NULL);
break;
case 6: /* Process UTC leap seconds */
/*
* Accomodate a 2- or 3-digit leap second count
* a trailing 'D' means this is the firmware's default value.
*/
if (gh->p.term_str[2] == 'D' || gh->p.term_str[2] == '\0') {
gh->p.data.time.leap_sec = 10 * CTN(gh->p.term_str[0])
+ CTN(gh->p.term_str[1]);
} else {
gh->p.data.time.leap_sec = 100 * CTN(gh->p.term_str[0])
+ 10 * CTN(gh->p.term_str[1])
+ CTN(gh->p.term_str[2]);
}
break;
case 7: /* Process clock bias */
gh->p.data.time.clk_bias = prv_parse_number(gh, NULL);
break;
case 8: /* Process clock drift */
gh->p.data.time.clk_drift = prv_parse_float_number(gh, NULL);
break;
case 9: /* Process time pulse granularity */
gh->p.data.time.tp_gran = prv_parse_number(gh, NULL);
break;
default:
break;
}
#endif /* LWGPS_CFG_STATEMENT_PUBX_TIME */
#endif /* LWGPS_CFG_STATEMENT_PUBX */
}
return 1;
}
/**
* \brief Compare calculated CRC with received CRC
* \param[in] gh: GPS handle
* \return `1` on success, `0` otherwise
*/
static uint8_t
prv_check_crc(lwgps_t* gh) {
uint8_t crc;
crc = (uint8_t)((CHTN(gh->p.term_str[0]) & 0x0F) << 0x04) | (CHTN(gh->p.term_str[1]) & 0x0F); /* Convert received CRC from string (hex) to number */
return gh->p.crc_calc == crc; /* They must match! */
}
/**
* \brief Copy temporary memory to user memory
* \param[in] gh: GPS handle
* \return `1` on success, `0` otherwise
*/
static uint8_t
prv_copy_from_tmp_memory(lwgps_t* gh) {
if (0) {
#if LWGPS_CFG_STATEMENT_GPGGA
} else if (gh->p.stat == STAT_GGA) {
gh->latitude = gh->p.data.gga.latitude;
gh->longitude = gh->p.data.gga.longitude;
gh->altitude = gh->p.data.gga.altitude;
gh->geo_sep = gh->p.data.gga.geo_sep;
gh->sats_in_use = gh->p.data.gga.sats_in_use;
gh->fix = gh->p.data.gga.fix;
gh->hours = gh->p.data.gga.hours;
gh->minutes = gh->p.data.gga.minutes;
gh->seconds = gh->p.data.gga.seconds;
#endif /* LWGPS_CFG_STATEMENT_GPGGA */
#if LWGPS_CFG_STATEMENT_GPGSA
} else if (gh->p.stat == STAT_GSA) {
gh->dop_h = gh->p.data.gsa.dop_h;
gh->dop_p = gh->p.data.gsa.dop_p;
gh->dop_v = gh->p.data.gsa.dop_v;
gh->fix_mode = gh->p.data.gsa.fix_mode;
memcpy(gh->satellites_ids, gh->p.data.gsa.satellites_ids, sizeof(gh->satellites_ids));
#endif /* LWGPS_CFG_STATEMENT_GPGSA */
#if LWGPS_CFG_STATEMENT_GPGSV
} else if (gh->p.stat == STAT_GSV) {
gh->sats_in_view = gh->p.data.gsv.sats_in_view;
#endif /* LWGPS_CFG_STATEMENT_GPGSV */
#if LWGPS_CFG_STATEMENT_GPRMC
} else if (gh->p.stat == STAT_RMC) {
gh->course = gh->p.data.rmc.course;
gh->is_valid = gh->p.data.rmc.is_valid;
gh->speed = gh->p.data.rmc.speed;
gh->variation = gh->p.data.rmc.variation;
gh->date = gh->p.data.rmc.date;
gh->month = gh->p.data.rmc.month;
gh->year = gh->p.data.rmc.year;
#endif /* LWGPS_CFG_STATEMENT_GPRMC */
#if LWGPS_CFG_STATEMENT_PUBX_TIME
} else if (gh->p.stat == STAT_UBX_TIME) {
gh->hours = gh->p.data.time.hours;
gh->minutes = gh->p.data.time.minutes;
gh->seconds = gh->p.data.time.seconds;
gh->date = gh->p.data.time.date;
gh->month = gh->p.data.time.month;
gh->year = gh->p.data.time.year;
gh->utc_tow = gh->p.data.time.utc_tow;
gh->utc_wk = gh->p.data.time.utc_wk;
gh->leap_sec = gh->p.data.time.leap_sec;
gh->clk_bias = gh->p.data.time.clk_bias;
gh->clk_drift = gh->p.data.time.clk_drift;
gh->tp_gran = gh->p.data.time.tp_gran;
#endif /* LWGPS_CFG_STATEMENT_PUBX_TIME */
}
return 1;
}
/**
* \brief Init GPS handle
* \param[in] gh: GPS handle structure
* \return `1` on success, `0` otherwise
*/
uint8_t
lwgps_init(lwgps_t* gh) {
memset(gh, 0x00, sizeof(*gh)); /* Reset structure */
return 1;
}
/**
* \brief Process NMEA data from GPS receiver
* \param[in] gh: GPS handle structure
* \param[in] data: Received data
* \param[in] len: Number of bytes to process
* \param[in] evt_fn: Event function to notify application layer.
* This parameter is available only if \ref LWGPS_CFG_STATUS is enabled
* \return `1` on success, `0` otherwise
*/
uint8_t
#if LWGPS_CFG_STATUS || __DOXYGEN__
lwgps_process(lwgps_t* gh, const void* data, size_t len, lwgps_process_fn evt_fn) {
#else /* LWGPS_CFG_STATUS */
lwgps_process(lwgps_t* gh, const void* data, size_t len) {
#endif /* !LWGPS_CFG_STATUS */
const uint8_t* d =(uint8_t*) data;
for (; len > 0; ++d, --len) { /* Process all bytes */
if (*d == '$') { /* Check for beginning of NMEA line */
memset(&gh->p, 0x00, sizeof(gh->p));/* Reset private memory */
TERM_ADD(gh, *d); /* Add character to term */
} else if (*d == ',') { /* Term separator character */
prv_parse_term(gh); /* Parse term we have currently in memory */
CRC_ADD(gh, *d); /* Add character to CRC computation */
TERM_NEXT(gh); /* Start with next term */
} else if (*d == '*') { /* Start indicates end of data for CRC computation */
prv_parse_term(gh); /* Parse term we have currently in memory */
gh->p.star = 1; /* STAR detected */
TERM_NEXT(gh); /* Start with next term */
} else if (*d == '\r') {
if (prv_check_crc(gh)) { /* Check for CRC result */
/* CRC is OK, in theory we can copy data from statements to user data */
prv_copy_from_tmp_memory(gh); /* Copy memory from temporary to user memory */
#if LWGPS_CFG_STATUS
if (evt_fn != NULL) {
evt_fn(gh->p.stat);
}
} else if (evt_fn != NULL) {
evt_fn(STAT_CHECKSUM_FAIL);
#endif /* LWGPS_CFG_STATUS */
}
} else {
if (!gh->p.star) { /* Add to CRC only if star not yet detected */
CRC_ADD(gh, *d); /* Add to CRC */
}
TERM_ADD(gh, *d); /* Add character to term */
}
}
return 1;
}
/**
* \brief Calculate distance and bearing between `2` latitude and longitude coordinates
* \param[in] las: Latitude start coordinate, in units of degrees
* \param[in] los: Longitude start coordinate, in units of degrees
* \param[in] lae: Latitude end coordinate, in units of degrees
* \param[in] loe: Longitude end coordinate, in units of degrees
* \param[out] d: Pointer to output distance in units of meters
* \param[out] b: Pointer to output bearing between start and end coordinate in relation to north in units of degrees
* \return `1` on success, `0` otherwise
*/
uint8_t
lwgps_distance_bearing(lwgps_float_t las, lwgps_float_t los, lwgps_float_t lae, lwgps_float_t loe, lwgps_float_t* d, lwgps_float_t* b) {
lwgps_float_t df, dfi, a;
if (d == NULL && b == NULL) {
return 0;
}
/* Convert degrees to radians */
df = D2R(lae - las);
dfi = D2R(loe - los);
las = D2R(las);
los = D2R(los);
lae = D2R(lae);
loe = D2R(loe);
/*
* Calculate distance
*
* Calculated distance is absolute value in meters between 2 points on earth.
*/
if (d != NULL) {
/*
* a = sin(df / 2)^2 + cos(las) * cos(lae) * sin(dfi / 2)^2
* *d = RADIUS * 2 * atan(sqrt(a) / sqrt(1 - a)) * 1000 (for meters)
*/
#if LWGPS_CFG_DOUBLE
a = FLT(sin(df * 0.5) * sin(df * 0.5) + sin(dfi * 0.5) * sin(dfi * 0.5) * cos(las) * cos(lae));
*d = FLT(EARTH_RADIUS * 2.0 * atan2(sqrt(a), sqrt(1.0 - a)) * 1000.0);
#else /* LWGPS_CFG_DOUBLE */
a = FLT(sinf(df * 0.5f) * sinf(df * 0.5f) + sinf(dfi * 0.5f) * sinf(dfi * 0.5f) * cosf(las) * cosf(lae));
*d = FLT(EARTH_RADIUS * 2.0f * atan2f(sqrtf(a), sqrtf(1.0f - a)) * 1000.0f);
#endif /* !LWGPS_CFG_DOUBLE */
}
/*
* Calculate bearing
*
* Bearing is calculated from point 1 to point 2.
* Result will tell us in which direction (according to north) we should move,
* to reach point 2.
*
* Example:
* Bearing is 0 => move to north
* Bearing is 90 => move to east
* Bearing is 180 => move to south
* Bearing is 270 => move to west
*/
if (b != NULL) {
#if LWGPS_CFG_DOUBLE
df = FLT(sin(loe - los) * cos(lae));
dfi = FLT(cos(las) * sin(lae) - sin(las) * cos(lae) * cos(loe - los));
*b = R2D(atan2(df, dfi)); /* Calculate bearing and convert to degrees */
#else /* LWGPS_CFG_DOUBLE */
df = FLT(sinf(loe - los) * cosf(lae));
dfi = FLT(cosf(las) * sinf(lae) - sinf(las) * cosf(lae) * cosf(loe - los));
*b = R2D(atan2f(df, dfi)); /* Calculate bearing and convert to degrees */
#endif /* !LWGPS_CFG_DOUBLE */
if (*b < 0) { /* Check for negative angle */
*b += FLT(360); /* Make bearing always positive */
}
}
return 1;
}
/**
* \brief Convert NMEA GPS speed (in knots = nautical mile per hour) to different speed format
* \param[in] sik: Speed in knots, received from GPS NMEA statement
* \param[in] ts: Target speed to convert to from knots
* \return Speed calculated from knots
*/
lwgps_float_t
lwgps_to_speed(lwgps_float_t sik, lwgps_speed_t ts) {
switch (ts) {
case lwgps_speed_kps:
return FLT(sik * FLT(0.000514));
case lwgps_speed_kph:
return FLT(sik * FLT(1.852));
case lwgps_speed_mps:
return FLT(sik * FLT(0.5144));
case lwgps_speed_mpm:
return FLT(sik * FLT(30.87));
case lwgps_speed_mips:
return FLT(sik * FLT(0.0003197));
case lwgps_speed_mph:
return FLT(sik * FLT(1.151));
case lwgps_speed_fps:
return FLT(sik * FLT(1.688));
case lwgps_speed_fpm:
return FLT(sik * FLT(101.3));
case lwgps_speed_mpk:
return FLT(sik * FLT(32.4));
case lwgps_speed_spk:
return FLT(sik * FLT(1944.0));
case lwgps_speed_sp100m:
return FLT(sik * FLT(194.4));
case lwgps_speed_mipm:
return FLT(sik * FLT(52.14));
case lwgps_speed_spm:
return FLT(sik * FLT(3128.0));
case lwgps_speed_sp100y:
return FLT(sik * FLT(177.7));
case lwgps_speed_smph:
return FLT(sik * FLT(1.0));
default:
return 0;
}
}

289
Source/GPS/lwgps.h Normal file
View File

@ -0,0 +1,289 @@
/**
* \file lwgps.h
* \brief GPS main file
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwGPS - Lightweight GPS NMEA parser library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v2.1.0
*/
#ifndef LWGPS_HDR_H
#define LWGPS_HDR_H
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#include "lwgps_opt.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* \defgroup LWGPS Lightweight GPS NMEA parser
* \brief Lightweight GPS NMEA parser
* \{
*/
/**
* \brief GPS float definition, can be either `float` or `double`
* \note Check for \ref LWGPS_CFG_DOUBLE configuration
*/
#if LWGPS_CFG_DOUBLE || __DOXYGEN__
typedef double lwgps_float_t;
#else
typedef float lwgps_float_t;
#endif
/**
* \brief Satellite descriptor
*/
typedef struct {
uint8_t num; /*!< Satellite number */
uint8_t elevation; /*!< Elevation value */
uint16_t azimuth; /*!< Azimuth in degrees */
uint8_t snr; /*!< Signal-to-noise ratio */
} lwgps_sat_t;
/**
* \brief ENUM of possible GPS statements parsed
*/
typedef enum {
STAT_UNKNOWN = 0, /*!< Unknown NMEA statement */
STAT_GGA = 1, /*!< GPGGA statement */
STAT_GSA = 2, /*!< GPGSA statement */
STAT_GSV = 3, /*!< GPGSV statement */
STAT_RMC = 4, /*!< GPRMC statement */
STAT_UBX = 5, /*!< UBX statement (uBlox specific) */
STAT_UBX_TIME = 6, /*!< UBX TIME statement (uBlox specific) */
STAT_CHECKSUM_FAIL = UINT8_MAX /*!< Special case, used when checksum fails */
} lwgps_statement_t;
/**
* \brief GPS main structure
*/
typedef struct {
#if LWGPS_CFG_STATEMENT_GPGGA || __DOXYGEN__
/* Information related to GPGGA statement */
lwgps_float_t latitude; /*!< Latitude in units of degrees */
lwgps_float_t longitude; /*!< Longitude in units of degrees */
lwgps_float_t altitude; /*!< Altitude in units of meters */
lwgps_float_t geo_sep; /*!< Geoid separation in units of meters */
uint8_t sats_in_use; /*!< Number of satellites in use */
uint8_t fix; /*!< Fix status. `0` = invalid, `1` = GPS fix, `2` = DGPS fix, `3` = PPS fix */
uint8_t hours; /*!< Hours in UTC */
uint8_t minutes; /*!< Minutes in UTC */
uint8_t seconds; /*!< Seconds in UTC */
#endif /* LWGPS_CFG_STATEMENT_GPGGA || __DOXYGEN__ */
#if LWGPS_CFG_STATEMENT_GPGSA || __DOXYGEN__
/* Information related to GPGSA statement */
lwgps_float_t dop_h; /*!< Dolution of precision, horizontal */
lwgps_float_t dop_v; /*!< Dolution of precision, vertical */
lwgps_float_t dop_p; /*!< Dolution of precision, position */
uint8_t fix_mode; /*!< Fix mode. `1` = NO fix, `2` = 2D fix, `3` = 3D fix */
uint8_t satellites_ids[12]; /*!< List of satellite IDs in use. Valid range is `0` to `sats_in_use` */
#endif /* LWGPS_CFG_STATEMENT_GPGSA || __DOXYGEN__ */
#if LWGPS_CFG_STATEMENT_GPGSV || __DOXYGEN__
/* Information related to GPGSV statement */
uint8_t sats_in_view; /*!< Number of satellites in view */
#if LWGPS_CFG_STATEMENT_GPGSV_SAT_DET || __DOXYGEN__
lwgps_sat_t sats_in_view_desc[12];
#endif /* LWGPS_CFG_STATEMENT_GPGSV_SAT_DET || __DOXYGEN__ */
#endif /* LWGPS_CFG_STATEMENT_GPGSV || __DOXYGEN__ */
#if LWGPS_CFG_STATEMENT_GPRMC || __DOXYGEN__
/* Information related to GPRMC statement */
uint8_t is_valid; /*!< GPS valid status */
lwgps_float_t speed; /*!< Ground speed in knots */
lwgps_float_t course; /*!< Ground coarse */
lwgps_float_t variation; /*!< Magnetic variation */
uint8_t date; /*!< Fix date */
uint8_t month; /*!< Fix month */
uint8_t year; /*!< Fix year */
#endif /* LWGPS_CFG_STATEMENT_GPRMC || __DOXYGEN__ */
#if LWGPS_CFG_STATEMENT_PUBX_TIME || __DOXYGEN__
#if !LWGPS_CFG_STATEMENT_GPGGA && !__DOXYGEN__
/* rely on time fields from GPGGA if possible */
uint8_t hours;
uint8_t minutes;
uint8_t seconds;
#endif /* !LWGPS_CFG_STATEMENT_GPGGA && !__DOXYGEN__ */
#if !LWGPS_CFG_STATEMENT_GPRMC && !__DOXYGEN__
/* rely on date fields from GPRMC if possible */
uint8_t date;
uint8_t month;
uint8_t year;
#endif /* !LWGPS_CFG_STATEMENT_GPRMC && !__DOXYGEN__ */
/* fields only available in PUBX_TIME */
lwgps_float_t utc_tow; /*!< UTC TimeOfWeek, eg 113851.00 */
uint16_t utc_wk; /*!< UTC week number, continues beyond 1023 */
uint8_t leap_sec; /*!< UTC leap seconds; UTC + leap_sec = TAI */
uint32_t clk_bias; /*!< Receiver clock bias, eg 1930035 */
lwgps_float_t clk_drift; /*!< Receiver clock drift, eg -2660.664 */
uint32_t tp_gran; /*!< Time pulse granularity, eg 43 */
#endif /* LWGPS_CFG_STATEMENT_PUBX_TIME || __DOXYGEN__ */
#if !__DOXYGEN__
struct {
lwgps_statement_t stat; /*!< Statement index */
char term_str[13]; /*!< Current term in string format */
uint8_t term_pos; /*!< Current index position in term */
uint8_t term_num; /*!< Current term number */
uint8_t star; /*!< Star detected flag */
uint8_t crc_calc; /*!< Calculated CRC string */
union {
uint8_t dummy; /*!< Dummy byte */
#if LWGPS_CFG_STATEMENT_GPGGA
struct {
lwgps_float_t latitude; /*!< GPS latitude position in degrees */
lwgps_float_t longitude; /*!< GPS longitude position in degrees */
lwgps_float_t altitude; /*!< GPS altitude in meters */
lwgps_float_t geo_sep; /*!< Geoid separation in units of meters */
uint8_t sats_in_use; /*!< Number of satellites currently in use */
uint8_t fix; /*!< Type of current fix, `0` = Invalid, `1` = GPS fix, `2` = Differential GPS fix */
uint8_t hours; /*!< Current UTC hours */
uint8_t minutes; /*!< Current UTC minutes */
uint8_t seconds; /*!< Current UTC seconds */
} gga; /*!< GPGGA message */
#endif /* LWGPS_CFG_STATEMENT_GPGGA */
#if LWGPS_CFG_STATEMENT_GPGSA
struct {
lwgps_float_t dop_h; /*!< Horizontal dilution of precision */
lwgps_float_t dop_v; /*!< Vertical dilution of precision */
lwgps_float_t dop_p; /*!< Position dilution of precision */
uint8_t fix_mode; /*!< Fix mode, `1` = No fix, `2` = 2D fix, `3` = 3D fix */
uint8_t satellites_ids[12]; /*!< IDs of satellites currently in use */
} gsa; /*!< GPGSA message */
#endif /* LWGPS_CFG_STATEMENT_GPGSA */
#if LWGPS_CFG_STATEMENT_GPGSV
struct {
uint8_t sats_in_view; /*!< Number of stallites in view */
uint8_t stat_num; /*!< Satellite line number during parsing GPGSV data */
} gsv; /*!< GPGSV message */
#endif /* LWGPS_CFG_STATEMENT_GPGSV */
#if LWGPS_CFG_STATEMENT_GPRMC
struct {
uint8_t is_valid; /*!< Status whether GPS status is valid or not */
uint8_t date; /*!< Current UTC date */
uint8_t month; /*!< Current UTC month */
uint8_t year; /*!< Current UTC year */
lwgps_float_t speed; /*!< Current spead over the ground in knots */
lwgps_float_t course; /*!< Current course over ground */
lwgps_float_t variation; /*!< Current magnetic variation in degrees */
} rmc; /*!< GPRMC message */
#endif /* LWGPS_CFG_STATEMENT_GPRMC */
#if LWGPS_CFG_STATEMENT_PUBX_TIME
struct {
uint8_t hours; /*!< Current UTC hours */
uint8_t minutes; /*!< Current UTC minutes */
uint8_t seconds; /*!< Current UTC seconds */
uint8_t date; /*!< Current UTC date */
uint8_t month; /*!< Current UTC month */
uint8_t year; /*!< Current UTC year */
lwgps_float_t utc_tow; /*!< UTC TimeOfWeek, eg 113851.00 */
uint16_t utc_wk; /*!< UTC week number, continues beyond 1023 */
uint8_t leap_sec; /*!< UTC leap seconds; UTC + leap_sec = TAI */
uint32_t clk_bias; /*!< Receiver clock bias, eg 1930035 */
lwgps_float_t clk_drift; /*!< Receiver clock drift, eg -2660.664 */
uint32_t tp_gran; /*!< Time pulse granularity, eg 43 */
} time; /*!< PUBX TIME message */
#endif /* LWGPS_CFG_STATEMENT_PUBX_TIME */
} data; /*!< Union with data for each information */
} p; /*!< Structure with private data */
#endif /* !__DOXYGEN__ */
} lwgps_t;
/**
* \brief List of optional speed transformation from GPS values (in knots)
*/
typedef enum {
/* Metric values */
lwgps_speed_kps, /*!< Kilometers per second */
lwgps_speed_kph, /*!< Kilometers per hour */
lwgps_speed_mps, /*!< Meters per second */
lwgps_speed_mpm, /*!< Meters per minute */
/* Imperial values */
lwgps_speed_mips, /*!< Miles per second */
lwgps_speed_mph, /*!< Miles per hour */
lwgps_speed_fps, /*!< Foots per second */
lwgps_speed_fpm, /*!< Foots per minute */
/* Optimized for runners/joggers */
lwgps_speed_mpk, /*!< Minutes per kilometer */
lwgps_speed_spk, /*!< Seconds per kilometer */
lwgps_speed_sp100m, /*!< Seconds per 100 meters */
lwgps_speed_mipm, /*!< Minutes per mile */
lwgps_speed_spm, /*!< Seconds per mile */
lwgps_speed_sp100y, /*!< Seconds per 100 yards */
/* Nautical values */
lwgps_speed_smph, /*!< Sea miles per hour */
} lwgps_speed_t;
/**
* \brief Signature for caller-suplied callback function from gps_process
* \param[in] res: statement type of recently parsed statement
*/
typedef void (*lwgps_process_fn)(lwgps_statement_t res);
/**
* \brief Check if current GPS data contain valid signal
* \note \ref LWGPS_CFG_STATEMENT_GPRMC must be enabled and `GPRMC` statement must be sent from GPS receiver
* \param[in] _gh: GPS handle
* \return `1` on success, `0` otherwise
*/
#if LWGPS_CFG_STATEMENT_GPRMC || __DOXYGEN__
#define lwgps_is_valid(_gh) ((_gh)->is_valid)
#else
#define lwgps_is_valid(_gh) (0)
#endif /* LWGPS_CFG_STATEMENT_GPRMC || __DOXYGEN__ */
uint8_t lwgps_init(lwgps_t* gh);
#if LWGPS_CFG_STATUS || __DOXYGEN__
uint8_t lwgps_process(lwgps_t* gh, const void* data, size_t len, lwgps_process_fn evt_fn);
#else /* LWGPS_CFG_STATUS */
uint8_t lwgps_process(lwgps_t* gh, const void* data, size_t len);
#endif /* !LWGPS_CFG_STATUS */
uint8_t lwgps_distance_bearing(lwgps_float_t las, lwgps_float_t los, lwgps_float_t lae, lwgps_float_t loe, lwgps_float_t* d, lwgps_float_t* b);
lwgps_float_t lwgps_to_speed(lwgps_float_t sik, lwgps_speed_t ts);
/**
* \}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LWGPS_HDR_H */

171
Source/GPS/lwgps_opt.h Normal file
View File

@ -0,0 +1,171 @@
/**
* \file lwgps_opt.h
* \brief LwGPS options
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwGPS - Lightweight GPS NMEA parser library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: $2.1.0$
*/
#ifndef LWGPS_HDR_OPT_H
#define LWGPS_HDR_OPT_H
/* Include application options */
#ifndef LWGPS_IGNORE_USER_OPTS
#include "lwgps_opts.h"
#endif /* LWGPS_IGNORE_USER_OPTS */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* \defgroup LWGPS_OPT Configuration
* \brief Default configuration setup
* \{
*/
/**
* \brief Enables `1` or disables `0` `double precision` for floating point
* values such as latitude, longitude, altitude.
*
* `double` is used as variable type when enabled, `float` when disabled.
*/
#ifndef LWGPS_CFG_DOUBLE
#define LWGPS_CFG_DOUBLE 1
#endif
/**
* \brief Enables `1` or disables `0` status reporting callback
* by \ref lwgps_process
*
* \note This is an extension, so not enabled by default.
*/
#ifndef LWGPS_CFG_STATUS
#define LWGPS_CFG_STATUS 0
#endif
/**
* \brief Enables `1` or disables `0` `GGA` statement parsing.
*
* \note This statement must be enabled to parse:
* - Latitude, Longitude, Altitude
* - Number of satellites in use, fix (no fix, GPS, DGPS), UTC time
*/
#ifndef LWGPS_CFG_STATEMENT_GPGGA
#define LWGPS_CFG_STATEMENT_GPGGA 1
#endif
/**
* \brief Enables `1` or disables `0` `GSA` statement parsing.
*
* \note This statement must be enabled to parse:
* - Position/Vertical/Horizontal dilution of precision
* - Fix mode (no fix, 2D, 3D fix)
* - IDs of satellites in use
*/
#ifndef LWGPS_CFG_STATEMENT_GPGSA
#define LWGPS_CFG_STATEMENT_GPGSA 1
#endif
/**
* \brief Enables `1` or disables `0` `RMC` statement parsing.
*
* \note This statement must be enabled to parse:
* - Validity of GPS signal
* - Ground speed in knots and coarse in degrees
* - Magnetic variation
* - UTC date
*/
#ifndef LWGPS_CFG_STATEMENT_GPRMC
#define LWGPS_CFG_STATEMENT_GPRMC 1
#endif
/**
* \brief Enables `1` or disables `0` `GSV` statement parsing.
*
* \note This statement must be enabled to parse:
* - Number of satellites in view
* - Optional details of each satellite in view. See \ref LWGPS_CFG_STATEMENT_GPGSV_SAT_DET
*/
#ifndef LWGPS_CFG_STATEMENT_GPGSV
#define LWGPS_CFG_STATEMENT_GPGSV 1
#endif
/**
* \brief Enables `1` or disables `0` detailed parsing of each
* satellite in view for `GSV` statement.
*
* \note When this feature is disabled, only number of "satellites in view" is parsed
*/
#ifndef LWGPS_CFG_STATEMENT_GPGSV_SAT_DET
#define LWGPS_CFG_STATEMENT_GPGSV_SAT_DET 0
#endif
/**
* \brief Enables `1` or disables `0` parsing and generation
* of PUBX (uBlox) messages
*
* PUBX are a nonstandard ublox-specific extensions,
* so disabled by default.
*/
#ifndef LWGPS_CFG_STATEMENT_PUBX
#define LWGPS_CFG_STATEMENT_PUBX 0
#endif
/**
* \brief Enables `1` or disables `0` parsing and generation
* of PUBX (uBlox) TIME messages.
*
* \note TIME messages can be used to obtain:
* - UTC time of week
* - UTC week number
* - Leap seconds (allows conversion to eg. TAI)
*
* This is a nonstandard ublox-specific extension,
* so disabled by default.
*
* This configure option requires LWGPS_CFG_STATEMENT_PUBX
*/
#ifndef LWGPS_CFG_STATEMENT_PUBX_TIME
#define LWGPS_CFG_STATEMENT_PUBX_TIME 0
#endif
/* Guard against accidental parser breakage */
#if LWGPS_CFG_STATEMENT_PUBX_TIME && !LWGPS_CFG_STATEMENT_PUBX
#error LWGPS_CFG_STATEMENT_PUBX must be enabled when enabling LWGPS_CFG_STATEMENT_PUBX_TIME
#endif /* LWGPS_CFG_STATEMENT_PUBX_TIME && !LWGPS_CFG_STATEMENT_PUBX */
/**
* \}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LWGPS_HDR_OPT_H */

44
Source/GPS/lwgps_opts.h Normal file
View File

@ -0,0 +1,44 @@
/**
* \file lwgps_opts_template.h
* \brief LwGPS configuration file
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwGPS - Lightweight GPS NMEA parser library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v2.1.0
*/
#ifndef LWGPS_HDR_OPTS_H
#define LWGPS_HDR_OPTS_H
/* Rename this file to "lwgps_opts.h" for your application */
/*
* Open "include/lwgps/lwgps_opt.h" and
* copy & replace here settings you want to change values
*/
#endif /* LWGPS_HDR_OPTS_H */

495
Source/GPS/lwrb.cpp Normal file
View File

@ -0,0 +1,495 @@
/**
* \file lwrb.c
* \brief Lightweight ring buffer
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwRB - Lightweight ring buffer library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v2.0.3
*/
#include "lwrb.h"
/* Memory set and copy functions */
#define BUF_MEMSET memset
#define BUF_MEMCPY memcpy
#define BUF_MAGIC1 (0xDEADBEEF)
#define BUF_MAGIC2 (~0xDEADBEEF)
#if LWRB_USE_MAGIC
#define BUF_IS_VALID(b) ((b) != NULL && (b)->magic1 == BUF_MAGIC1 && (b)->magic2 == BUF_MAGIC2 && (b)->buff != NULL && (b)->size > 0)
#else
#define BUF_IS_VALID(b) ((b) != NULL && (b)->buff != NULL && (b)->size > 0)
#endif /* LWRB_USE_MAGIC */
#define BUF_MIN(x, y) ((x) < (y) ? (x) : (y))
#define BUF_MAX(x, y) ((x) > (y) ? (x) : (y))
#define BUF_SEND_EVT(b, type, bp) do { if ((b)->evt_fn != NULL) { (b)->evt_fn((b), (type), (bp)); } } while (0)
/**
* \brief Initialize buffer handle to default values with size and buffer data array
* \param[in] buff: Buffer handle
* \param[in] buffdata: Pointer to memory to use as buffer data
* \param[in] size: Size of `buffdata` in units of bytes
* Maximum number of bytes buffer can hold is `size - 1`
* \return `1` on success, `0` otherwise
*/
uint8_t
lwrb_init(lwrb_t* buff, void* buffdata, size_t size) {
if (buff == NULL || buffdata == NULL || size == 0) {
return 0;
}
BUF_MEMSET((void*)buff, 0x00, sizeof(*buff));
buff->size = size;
buff->buff = (uint8_t*)buffdata;
#if LWRB_USE_MAGIC
buff->magic1 = BUF_MAGIC1;
buff->magic2 = BUF_MAGIC2;
#endif /* LWRB_USE_MAGIC */
return 1;
}
/**
* \brief Check if buff is initialized and ready to use
* \param[in] buff: Buffer handle
* \return `1` if ready, `0` otherwise
*/
uint8_t
lwrb_is_ready(lwrb_t* buff) {
return BUF_IS_VALID(buff);
}
/**
* \brief Free buffer memory
* \note Since implementation does not use dynamic allocation,
* it just sets buffer handle to `NULL`
* \param[in] buff: Buffer handle
*/
void
lwrb_free(lwrb_t* buff) {
if (BUF_IS_VALID(buff)) {
buff->buff = NULL;
}
}
/**
* \brief Set event function callback for different buffer operations
* \param[in] buff: Buffer handle
* \param[in] evt_fn: Callback function
*/
void
lwrb_set_evt_fn(lwrb_t* buff, lwrb_evt_fn evt_fn) {
if (BUF_IS_VALID(buff)) {
buff->evt_fn = evt_fn;
}
}
/**
* \brief Write data to buffer.
* Copies data from `data` array to buffer and marks buffer as full for maximum `btw` number of bytes
*
* \param[in] buff: Buffer handle
* \param[in] data: Pointer to data to write into buffer
* \param[in] btw: Number of bytes to write
* \return Number of bytes written to buffer.
* When returned value is less than `btw`, there was no enough memory available
* to copy full data array
*/
size_t
lwrb_write(lwrb_t* buff, const void* data, size_t btw) {
size_t tocopy, free;
volatile size_t buff_w_ptr;
const uint8_t* d = (uint8_t*)data;
if (!BUF_IS_VALID(buff) || data == NULL || btw == 0) {
return 0;
}
/* Calculate maximum number of bytes available to write */
free = lwrb_get_free(buff);
btw = BUF_MIN(free, btw);
if (btw == 0) {
return 0;
}
/* Step 1: Write data to linear part of buffer */
buff_w_ptr = buff->w;
tocopy = BUF_MIN(buff->size - buff_w_ptr, btw);
BUF_MEMCPY(&buff->buff[buff_w_ptr], d, tocopy);
buff_w_ptr += tocopy;
btw -= tocopy;
/* Step 2: Write data to beginning of buffer (overflow part) */
if (btw > 0) {
BUF_MEMCPY(buff->buff, &d[tocopy], btw);
buff_w_ptr = btw;
}
/* Step 3: Check end of buffer */
if (buff_w_ptr >= buff->size) {
buff_w_ptr = 0;
}
/*
* Write final value to the actual running variable.
* This is to ensure no read operation can access intermediate data
*/
buff->w = buff_w_ptr;
BUF_SEND_EVT(buff, LWRB_EVT_WRITE, tocopy + btw);
return tocopy + btw;
}
/**
* \brief Read data from buffer.
* Copies data from buffer to `data` array and marks buffer as free for maximum `btr` number of bytes
*
* \param[in] buff: Buffer handle
* \param[out] data: Pointer to output memory to copy buffer data to
* \param[in] btr: Number of bytes to read
* \return Number of bytes read and copied to data array
*/
size_t
lwrb_read(lwrb_t* buff, void* data, size_t btr) {
size_t tocopy, full;
volatile size_t buff_r_ptr;
uint8_t* d = (uint8_t*)data;
if (!BUF_IS_VALID(buff) || data == NULL || btr == 0) {
return 0;
}
/* Calculate maximum number of bytes available to read */
full = lwrb_get_full(buff);
btr = BUF_MIN(full, btr);
if (btr == 0) {
return 0;
}
/* Step 1: Read data from linear part of buffer */
buff_r_ptr = buff->r;
tocopy = BUF_MIN(buff->size - buff_r_ptr, btr);
BUF_MEMCPY(d, &buff->buff[buff_r_ptr], tocopy);
buff_r_ptr += tocopy;
btr -= tocopy;
/* Step 2: Read data from beginning of buffer (overflow part) */
if (btr > 0) {
BUF_MEMCPY(&d[tocopy], buff->buff, btr);
buff_r_ptr = btr;
}
/* Step 3: Check end of buffer */
if (buff_r_ptr >= buff->size) {
buff_r_ptr = 0;
}
/*
* Write final value to the actual running variable.
* This is to ensure no write operation can access intermediate data
*/
buff->r = buff_r_ptr;
BUF_SEND_EVT(buff, LWRB_EVT_READ, tocopy + btr);
return tocopy + btr;
}
/**
* \brief Read from buffer without changing read pointer (peek only)
* \param[in] buff: Buffer handle
* \param[in] skip_count: Number of bytes to skip before reading data
* \param[out] data: Pointer to output memory to copy buffer data to
* \param[in] btp: Number of bytes to peek
* \return Number of bytes peeked and written to output array
*/
size_t
lwrb_peek(lwrb_t* buff, size_t skip_count, void* data, size_t btp) {
size_t full, tocopy;
volatile size_t r;
uint8_t* d = (uint8_t*)data;
if (!BUF_IS_VALID(buff) || data == NULL || btp == 0) {
return 0;
}
r = buff->r;
/* Calculate maximum number of bytes available to read */
full = lwrb_get_full(buff);
/* Skip beginning of buffer */
if (skip_count >= full) {
return 0;
}
r += skip_count;
full -= skip_count;
if (r >= buff->size) {
r -= buff->size;
}
/* Check maximum number of bytes available to read after skip */
btp = BUF_MIN(full, btp);
if (btp == 0) {
return 0;
}
/* Step 1: Read data from linear part of buffer */
tocopy = BUF_MIN(buff->size - r, btp);
BUF_MEMCPY(d, &buff->buff[r], tocopy);
btp -= tocopy;
/* Step 2: Read data from beginning of buffer (overflow part) */
if (btp > 0) {
BUF_MEMCPY(&d[tocopy], buff->buff, btp);
}
return tocopy + btp;
}
/**
* \brief Get available size in buffer for write operation
* \param[in] buff: Buffer handle
* \return Number of free bytes in memory
*/
size_t
lwrb_get_free(lwrb_t* buff) {
size_t size;
volatile size_t w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/* Use temporary values in case they are changed during operations */
w = buff->w;
r = buff->r;
if (w == r) {
size = buff->size;
} else if (r > w) {
size = r - w;
} else {
size = buff->size - (w - r);
}
/* Buffer free size is always 1 less than actual size */
return size - 1;
}
/**
* \brief Get number of bytes currently available in buffer
* \param[in] buff: Buffer handle
* \return Number of bytes ready to be read
*/
size_t
lwrb_get_full(lwrb_t* buff) {
size_t size;
volatile size_t w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/* Use temporary values in case they are changed during operations */
w = buff->w;
r = buff->r;
if (w == r) {
size = 0;
} else if (w > r) {
size = w - r;
} else {
size = buff->size - (r - w);
}
return size;
}
/**
* \brief Resets buffer to default values. Buffer size is not modified
* \note This function is not thread safe.
* When used, application must ensure there is no active read/write operation
* \param[in] buff: Buffer handle
*/
void
lwrb_reset(lwrb_t* buff) {
if (BUF_IS_VALID(buff)) {
buff->w = 0;
buff->r = 0;
BUF_SEND_EVT(buff, LWRB_EVT_RESET, 0);
}
}
/**
* \brief Get linear address for buffer for fast read
* \param[in] buff: Buffer handle
* \return Linear buffer start address
*/
void*
lwrb_get_linear_block_read_address(lwrb_t* buff) {
if (!BUF_IS_VALID(buff)) {
return NULL;
}
return &buff->buff[buff->r];
}
/**
* \brief Get length of linear block address before it overflows for read operation
* \param[in] buff: Buffer handle
* \return Linear buffer size in units of bytes for read operation
*/
size_t
lwrb_get_linear_block_read_length(lwrb_t* buff) {
size_t len;
volatile size_t w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/* Use temporary values in case they are changed during operations */
w = buff->w;
r = buff->r;
if (w > r) {
len = w - r;
} else if (r > w) {
len = buff->size - r;
} else {
len = 0;
}
return len;
}
/**
* \brief Skip (ignore; advance read pointer) buffer data
* Marks data as read in the buffer and increases free memory for up to `len` bytes
*
* \note Useful at the end of streaming transfer such as DMA
* \param[in] buff: Buffer handle
* \param[in] len: Number of bytes to skip and mark as read
* \return Number of bytes skipped
*/
size_t
lwrb_skip(lwrb_t* buff, size_t len) {
size_t full;
volatile size_t r;
if (!BUF_IS_VALID(buff) || len == 0) {
return 0;
}
full = lwrb_get_full(buff);
len = BUF_MIN(len, full);
r = buff->r + len;
if (r >= buff->size) {
r -= buff->size;
}
buff->r = r;
BUF_SEND_EVT(buff, LWRB_EVT_READ, len);
return len;
}
/**
* \brief Get linear address for buffer for fast read
* \param[in] buff: Buffer handle
* \return Linear buffer start address
*/
void*
lwrb_get_linear_block_write_address(lwrb_t* buff) {
if (!BUF_IS_VALID(buff)) {
return NULL;
}
return &buff->buff[buff->w];
}
/**
* \brief Get length of linear block address before it overflows for write operation
* \param[in] buff: Buffer handle
* \return Linear buffer size in units of bytes for write operation
*/
size_t
lwrb_get_linear_block_write_length(lwrb_t* buff) {
size_t len;
volatile size_t w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/* Use temporary values in case they are changed during operations */
w = buff->w;
r = buff->r;
if (w >= r) {
len = buff->size - w;
/*
* When read pointer is 0,
* maximal length is one less as if too many bytes
* are written, buffer would be considered empty again (r == w)
*/
if (r == 0) {
/*
* Cannot overflow:
* - If r is not 0, statement does not get called
* - buff->size cannot be 0 and if r is 0, len is greater 0
*/
--len;
}
} else {
len = r - w - 1;
}
return len;
}
/**
* \brief Advance write pointer in the buffer.
* Similar to skip function but modifies write pointer instead of read
*
* \note Useful when hardware is writing to buffer and application needs to increase number
* of bytes written to buffer by hardware
* \param[in] buff: Buffer handle
* \param[in] len: Number of bytes to advance
* \return Number of bytes advanced for write operation
*/
size_t
lwrb_advance(lwrb_t* buff, size_t len) {
size_t free;
volatile size_t w;
if (!BUF_IS_VALID(buff) || len == 0) {
return 0;
}
/* Use local variables before writing back to main structure */
free = lwrb_get_free(buff);
len = BUF_MIN(len, free);
w = buff->w + len;
if (w >= buff->size) {
w -= buff->size;
}
buff->w = w;
BUF_SEND_EVT(buff, LWRB_EVT_WRITE, len);
return len;
}

139
Source/GPS/lwrb.h Normal file
View File

@ -0,0 +1,139 @@
/**
* \file lwrb.h
* \brief LwRB - Lightweight ring buffer
*/
/*
* Copyright (c) 2020 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwRB - Lightweight ring buffer library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v2.0.3
*/
#ifndef LWRB_HDR_H
#define LWRB_HDR_H
#include <string.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* \defgroup LWRB Lightweight ring buffer manager
* \brief Lightweight ring buffer manager
* \{
*/
/**
* \brief Enable buffer structure pointer parameters as volatile
* To use this feature, uncomment keyword below, or define in global compiler settings
*/
#ifndef LWRB_VOLATILE
#define LWRB_VOLATILE /* volatile */
#endif
/**
* \brief Adds 2 magic words to make sure if memory is corrupted
* application can detect wrong data pointer and maximum size
*/
#ifndef LWRB_USE_MAGIC
#define LWRB_USE_MAGIC 1
#endif
/**
* \brief Event type for buffer operations
*/
typedef enum {
LWRB_EVT_READ, /*!< Read event */
LWRB_EVT_WRITE, /*!< Write event */
LWRB_EVT_RESET, /*!< Reset event */
} lwrb_evt_type_t;
/**
* \brief Buffer structure forward declaration
*/
struct lwrb;
/**
* \brief Event callback function type
* \param[in] buff: Buffer handle for event
* \param[in] evt: Event type
* \param[in] bp: Number of bytes written or read (when used), depends on event type
*/
typedef void (*lwrb_evt_fn)(struct lwrb* buff, lwrb_evt_type_t evt, size_t bp);
/**
* \brief Buffer structure
*/
typedef struct lwrb {
#if LWRB_USE_MAGIC
uint32_t magic1; /*!< Magic 1 word */
#endif /* LWRB_USE_MAGIC */
uint8_t* buff; /*!< Pointer to buffer data.
Buffer is considered initialized when `buff != NULL` and `size > 0` */
LWRB_VOLATILE size_t size; /*!< Size of buffer data. Size of actual buffer is `1` byte less than value holds */
LWRB_VOLATILE size_t r; /*!< Next read pointer. Buffer is considered empty when `r == w` and full when `w == r - 1` */
LWRB_VOLATILE size_t w; /*!< Next write pointer. Buffer is considered empty when `r == w` and full when `w == r - 1` */
lwrb_evt_fn evt_fn; /*!< Pointer to event callback function */
#if LWRB_USE_MAGIC
uint32_t magic2; /*!< Magic 2 word */
#endif /* LWRB_USE_MAGIC */
} lwrb_t;
uint8_t lwrb_init(lwrb_t* buff, void* buffdata, size_t size);
uint8_t lwrb_is_ready(lwrb_t* buff);
void lwrb_free(lwrb_t* buff);
void lwrb_reset(lwrb_t* buff);
void lwrb_set_evt_fn(lwrb_t* buff, lwrb_evt_fn fn);
/* Read/Write functions */
size_t lwrb_write(lwrb_t* buff, const void* data, size_t btw);
size_t lwrb_read(lwrb_t* buff, void* data, size_t btr);
size_t lwrb_peek(lwrb_t* buff, size_t skip_count, void* data, size_t btp);
/* Buffer size information */
size_t lwrb_get_free(lwrb_t* buff);
size_t lwrb_get_full(lwrb_t* buff);
/* Read data block management */
void* lwrb_get_linear_block_read_address(lwrb_t* buff);
size_t lwrb_get_linear_block_read_length(lwrb_t* buff);
size_t lwrb_skip(lwrb_t* buff, size_t len);
/* Write data block management */
void* lwrb_get_linear_block_write_address(lwrb_t* buff);
size_t lwrb_get_linear_block_write_length(lwrb_t* buff);
size_t lwrb_advance(lwrb_t* buff, size_t len);
/**
* \}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LWRB_HDR_H */

90
Source/Logger/Logger.h Normal file
View File

@ -0,0 +1,90 @@
//
// Created by xin on 2021/8/17.
//edit by zz.
//fixed code page problem;added a new initialize function; --20211101
#pragma once
#include <QFile>
#include <QTextStream>
#include <QDateTime>
#include "qmutex.h"
#include "QtMsgHandler"
namespace QT_LOG
{
static int m_LogLevel = 1;
static QString m_LogFile = QString("%1.log").arg(QDateTime::currentDateTime().toString("yyyyMMddhhmmss"));
QMutex m_LogMutex;
void customMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
if (type < m_LogLevel)
{
return;
}
QString log_info;
switch (type)
{
case QtDebugMsg:
log_info = QString("%1:%2").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"),msg);
break;
case QtWarningMsg:
log_info = QString("%1[Warning]:%2").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"),msg);
break;
case QtCriticalMsg:
log_info = QString("%1[Critical]:%2").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"),msg);
break;
case QtFatalMsg:
log_info = QString("%1[Fatal]:%2").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"),msg);
abort();
}
m_LogMutex.lock();
QFile outFile(m_LogFile);
outFile.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text);
QTextStream ts(&outFile);
ts << log_info << endl;
outFile.close();
m_LogMutex.unlock();
}
void logInit(QString logFile = "",int logLevel = 0)
{
#ifndef DEBUG
if ((logLevel < 0) || (logLevel > 3))
{
m_LogLevel = 1;
}
else
{
m_LogLevel = logLevel;
}
if (!logFile.isEmpty())
{
m_LogFile = logFile+"/"+m_LogFile;
}
qInstallMessageHandler(customMessageHandler);
//qInstallMsgHandler(customMessageHandler);
#endif
}
//added by IRIS_ZZ initialize from main
void ZZ_InitLogger(QString qstrDir)
{
QDir qdLogFolder;
qdLogFolder.mkdir(qstrDir);
qDebug() << QT_LOG::m_LogFile;
QT_LOG::logInit(qstrDir);
}
};

BIN
Source/OSIF/DLib/SeaBreeze.dll Normal file
View File

Binary file not shown.

BIN
Source/OSIF/DLib/SeaBreeze.lib Normal file
View File

Binary file not shown.

63
Source/OSIF/include/api/DeviceFactory.h Normal file
View File

@ -0,0 +1,63 @@
/***************************************************//**
* @file DeviceFactory.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* Notes:
*
* This class allows Device class instances to be created
* using just the name of the class as a string.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef SEABREEZE_DEVICE_FACTORY_H
#define SEABREEZE_DEVICE_FACTORY_H
#include <string>
#include <map>
#include "common/devices/Device.h"
namespace seabreeze {
class DeviceFactory {
public:
static DeviceFactory* getInstance();
static DeviceFactory* instance;
static void shutdown();
Device *create(const std::string& name);
Device *create(int index);
int getNumberOfDeviceTypes();
private:
typedef Device *(*creatorFunction)(void);
DeviceFactory();
std::map<std::string, creatorFunction> nameToCreator;
};
}
#endif

56
Source/OSIF/include/api/DllDecl.h Normal file
View File

@ -0,0 +1,56 @@
/***************************************************//**
* @file DllDecl.h
* @date September 2012
* @author Ocean Optics, Inc.
*
* This class provides the DLL import/export decorations
* required for Windows DLLs. It is encapsulated to
* reduce copy-paste and to allow a single point of
* maintenance.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
******************************************************/
#ifndef SEABREEZE_DLL_DECL_H
#define SEABREEZE_DLL_DECL_H
#ifdef _WINDOWS
#ifdef BUILD_DLL
#define DLL_DECL __declspec(dllexport)
#else
#define DLL_DECL __declspec(dllimport)
#endif
// "STL member 'seabreeze::api::Foo::foo' needs to have dll-interface
// to be used by clients of class 'seabreeze::api::Foo'"
#pragma warning (disable: 4251)
// "non dll-interface class 'seabreeze::Foo' used as base for dll-interface
// class 'seabreeze::api::Bar'"
#pragma warning (disable: 4275)
#else
#define DLL_DECL
#endif
#endif

864
Source/OSIF/include/api/SeaBreezeWrapper.h Normal file
View File

@ -0,0 +1,864 @@
/***************************************************//**
* @file SeaBreezeWrapper.h
* @date July 2009
* @author Ocean Optics, Inc.
*
* This is a trivial interface to SeaBreeze that allows
* the user to connect to devices over USB.
* This is intended as a usable and extensible API.
*
* This provides a C interface to help with linkage.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_WRAPPER_H
#define SEABREEZE_WRAPPER_H
#define SEABREEZE_API_VERSION "3.0.11" //!< current version of the SeaBreezeWrapper API
#define SEABREEZE_MAX_DEVICES 32 //!< how many different spectrometer types we support
#include "api/DllDecl.h"
#ifdef __cplusplus
/**
* @brief Encapsulates all SeaBreeze classes
*/
namespace seabreeze {
class Device;
}
/**
Original interface to SeaBreeze. SeaBreezeAPI represents a proposed architecture for
future development.
*/
class DLL_DECL SeaBreezeWrapper {
public:
//! get handle to Singleton
static SeaBreezeWrapper *getInstance();
//! free some static memory under Microsoft profiler
static void shutdown();
// lifecycle
int openSpectrometer (int index, int *errorCode);
int closeSpectrometer (int index, int *errorCode);
// metadata
int getModel (int index, int *errorCode, char *buf, int len);
int getSerialNumber (int index, int *errorCode, char *buf, int len);
// basic acquisitions
void setIntegrationTimeMicrosec(int index, int *errorCode, unsigned long integration_time_micros);
int getWavelengths (int index, int *errorCode, double *wavelengths, int length);
int getFormattedSpectrum (int index, int *errorCode, double* buffer, int buffer_length);
int getUnformattedSpectrum (int index, int *errorCode, unsigned char *buffer, int buffer_length);
int getFormattedSpectrumLength(int index, int *errorCode);
int getUnformattedSpectrumLength(int index, int *errorCode);
long getMinIntegrationTimeMicrosec(int index, int *errorCode);
long getMaxIntegrationTimeMicrosec(int index, int *errorCode);
int getMaximumIntensity(int index, int *errorCode);
// advanced features
int getElectricDarkPixelIndices(int index, int *errorCode, int *indices, int length);
void setTriggerMode (int index, int *errorCode, int mode);
void setStrobeEnable (int index, int *errorCode, unsigned char strobe_enable);
void setShutterOpen (int index, int *errorCode, unsigned char opened);
void setContinuousStrobePeriodMicrosec(int index, int *errorCode, unsigned short strobe_id, unsigned long period_usec);
void setAcquisitionDelayMicrosec(int index, int *errorCode, unsigned long delay_usec);
// Buffering features
void clearBuffer (int index, int *errorCode);
unsigned long getBufferElementCount(int index, int *errorCode);
unsigned long getBufferCapacity (int index, int *errorCode);
unsigned long getBufferCapacityMaximum(int index, int *errorCode);
unsigned long getBufferCapacityMinimum(int index, int *errorCode);
void setBufferCapacity (int index, int *errorCode, unsigned long capacity);
// EEPROM access
int readEEPROMSlot (int index, int *errorCode, int slot_number, unsigned char *buffer, int buffer_length);
int writeEEPROMSlot (int index, int *errorCode, int slot_number, unsigned char *buffer, int buffer_length);
// irradiance calibration
int readIrradCalibration (int index, int *errorCode, float *buffer, int buffer_length);
int writeIrradCalibration (int index, int *errorCode, float *buffer, int buffer_length);
int hasIrradCollectionArea (int index, int *errorCode);
float readIrradCollectionArea (int index, int *errorCode);
void writeIrradCollectionArea (int index, int *errorCode, float area);
// thermal-electric cooler
double readTECTemperature (int index, int *errorCode);
void setTECTemperature (int index, int *errorCode, double temperature_degrees_celsius);
void setTECEnable (int index, int *errorCode, unsigned char tec_enable);
void setTECFanEnable (int index, int *errorCode, unsigned char tec_fan_enable);
// Wrapper features
void setVerbose (bool flag);
void setLogfile (char *path, int length);
int getAPIVersionString (char *buffer, int length);
int getErrorString (int errorCode, char *buffer, int buffer_length);
// raw USB access
int writeUSB (int index, int *errorCode, unsigned char endpoint, unsigned char *buffer, unsigned int length);
int readUSB (int index, int *errorCode, unsigned char endpoint, unsigned char *buffer, unsigned int length);
int getUSBDescriptorString (int index, int *errorCode, int id, unsigned char *buffer, int length);
// light sources (JAZ?)
int getLightSourceCount (int index, int *errorCode);
void setLightSourceEnable (int index, int *errorCode, int lightIndex, unsigned char enable);
void setLightSourceIntensity (int index, int *errorCode, int lightIndex, double intensity);
private:
SeaBreezeWrapper();
virtual ~SeaBreezeWrapper();
//! Singleton
static SeaBreezeWrapper *instance;
//! types of supported Ocean Optics devices (not actual devices found enumerated on the USB bus)
seabreeze::Device *devices[SEABREEZE_MAX_DEVICES];
};
extern "C" {
#endif /* __cplusplus */
/* All of these C functions start with seabreeze_ to prevent namespace
* collisions.
*/
/**
* @brief This function opens a device attached to the system.
* @param index (Input) The index of a USB device to try to open.
* Valid values will range from 0 to N-1 for N connected devices.
* @param error_code (Output) A pointer to an integer that can be used
* for storing error codes.
* @return int: The function will return an integer of 0 if it opened a
* device successfully, or 1 if no device was opened (in which
* case the error_code variable will be set).
*
* This can be called repeatedly with incrementing index values (until
* it returns 1) to open all connected devices.
*
* Note that the index used to open a device with this function should also
* be used to communicate with that same device in the other functions
* provided here.
*/
DLL_DECL int
seabreeze_open_spectrometer(int index, int *error_code);
/**
* @brief This function closes the spectrometer attached to the system.
* @param index (Input) The index of a device previously opened with
* open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used
* for storing error codes.
* @return int: This function will return 1 no matter what! (MZ)
*/
DLL_DECL int
seabreeze_close_spectrometer(int index, int *error_code);
/**
* @brief This function returns a description of the error denoted by
* error_code.
* @param error_code (Input) The integer error code to look up. Error
* codes not be zero, but can be any non-zero integer (positive or
* negative).
* @param buffer (Output) A character buffer allocated to contain at least
* 'buffer_length' bytes, which will be populated with the string
* description of the given error code.
* @param buffer_length (Input) allocated size of the output buffer
* @return int: Number of bytes written to buffer.
*/
DLL_DECL int
seabreeze_get_error_string(int error_code, char *buffer, int buffer_length);
/**
* @brief This function returns a string denoting the type of the device.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes. This may be NULL.
* @param buffer (Output) A character buffer allocated to contain at least
* 'buffer_length' bytes, which will be populated with the
* spectrometer type.
* @param buffer_length (Input) allocated size of the buffer
* @return int: Number of bytes written to the buffer.
*
* The populated buffer will hold one of the following strings:
*
* \verbatim
* NONE: Used if no spectrometer is found (error_code will also be set)
* HR2000: Represents an HR2000 Spectrometer
* HR2000PLUS: Represents an HR2000+ Spectrometer
* HR4000: Represents an HR4000 Spectrometer
* JAZ: Represents a Jaz Spectrometer
* MAYA2000: Represents a Maya2000 Spectrometer
* MAYALSL: Represents a Maya-LSL Spectrometer
* MAYA2000PRO: Represents a Maya2000 Pro Spectrometer
* NIRQUEST256: Represents an NIRQuest256 Spectrometer
* NIRQUEST512: Represents an NIRQuest512 Spectrometer
* QE65000: Represents a QE65000 Spectrometer
* QE-PRO: Represents a QE-Pro Spectrometer
* STS: Represents an STS Spectrometer
* TORUS: Represents a Torus Spectrometer
* USB2000: Represents a USB2000 Spectrometer
* USB2000PLUS: Represents a USB2000+ Spectrometer
* USB4000: Represents a USB4000 Spectrometer
* \endverbatim
*/
DLL_DECL int
seabreeze_get_model(int index, int *error_code, char *buffer, int buffer_length);
/**
* @brief This function sets the trigger mode for the specified device.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param mode (Input) a trigger mode (0 = normal, 1 = software, 2 = synchronization,
* 3 = external hardware, etc.)
*
* Note that requesting an unsupported mode will result in an error.
*/
DLL_DECL void
seabreeze_set_trigger_mode(int index, int *error_code, int mode);
/**
* @brief This function sets the integration time for the specified device.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param integration_time_micros (Input) The new integration time in units of
* microseconds
*
* This function does not automatically perform a stability scan.
* If your application requires a stability scan following a change
* in integration time, you need to command that yourself.
*/
DLL_DECL void
seabreeze_set_integration_time_microsec(int index, int *error_code,
unsigned long integration_time_micros);
/**
* @brief This function returns the smallest integration time setting,
* in microseconds, that is valid for the spectrometer.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return Returns minimum legal integration time in microseconds if > 0.
* On error, returns -1 and error_code will be set accordingly.
*/
DLL_DECL long
seabreeze_get_min_integration_time_microsec(int index, int *error_code);
/**
* @brief This function sets the shutter state on the spectrometer.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param opened (Input) A logical boolean used for denoting the desired
* state (opened/closed) of the shutter. If the value of opened is
* non-zero, then the shutter will open. If the value of opened is
* zero, then the shutter will close.
*/
DLL_DECL void
seabreeze_set_shutter_open(int index, int *error_code, unsigned char opened);
/**
* @brief This function sets the strobe enable on the spectrometer. Note that
* this refers to a particular set of one or more digital pins on the
* device: lamp enable, single strobe, and continuous strobe may all
* be affected by this setting, and these generally control lamps
* that are external to the device. Note that this is related to, but
* different from, the light source interface which allows the intensity
* and/or enable status of individual light sources (e.g. lamp bulbs,
* LEDs, or lasers) in attached modules to be controlled. Refer to
* the seabreeze_xxx_light_source_ functions for finer control of
* certain light source modules that are more closely integrated with
* the spectrometer.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param strobe_enable (Input) A logical boolean used for denoting the
* desired value (high/low) of the strobe-enable pin. If the value of
* strobe_enable is zero, then the pin should be set low. If the value
* of strobe_enable is non-zero, then the pin should be set high.
*/
DLL_DECL void
seabreeze_set_strobe_enable(int index, int *error_code, unsigned char strobe_enable);
/**
* @brief This function gets the number of attached light sources that can
* be programmatically controlled.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return The number of light sources that can be controlled
*/
DLL_DECL int
seabreeze_get_light_source_count(int index, int *error_code);
/**
* @brief This function sets the enable status on a connected light source.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param light_index (Input) The index of the light source. This will
* usually be zero, but if the light module contains multiple LEDs,
* bulbs, lasers, etc. then this may be higher. Use
* seabreeze_get_light_source_count() to bound the maximum value .
* @param enable (Input) A logical boolean used for denoting whether to enable
* the indicated light source. If the value of
* enable is zero, then the light source should be disabled. If the value
* of enable is non-zero, then the light source should be enabled.
*/
DLL_DECL void
seabreeze_set_light_source_enable(int index, int *error_code,
int light_index, unsigned char enable);
/**
* @brief This function sets the intensity of a connected light source.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param light_index (Input) The index of the light source. This will
* usually be zero, but if the light module contains multiple LEDs,
* bulbs, lasers, etc. then this may be higher. Use
* seabreeze_get_light_source_count() to bound the maximum value.
* @param intensity (Input) The desired intensity of the light source. The
* range of intensities is normalized over [0, 1], where 0 is the
* minimum controllable intensity of the light source, and 1 is the
* maximum.
*
* @warning SETTING THE INTENSITY TO ZERO MAY NOT CAUSE THE LIGHT SOURCE
* TO TURN OFF COMPLETELY. The light source will go to the
* dimmest level it can reach without changing its enable status.
* To switch the light source off, try using the
* seabreeze_set_light_source_enable() function or provide the
* operator with another way to disable or block the light source.
*/
DLL_DECL void
seabreeze_set_light_source_intensity(int index, int *error_code,
int light_index, double intensity);
/**
* @brief This function reads a string out of the spectrometer's EEPROM slot
* and returns the result.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param slot_number (Input) The number of the slot to read out. Possible
* values are 0 through 16*.
* @param buffer (Output) A buffer (with memory already allocated) to hold the
* value read out of the EEPROM slot
* @param buffer_length (Input) The length of the allocated output buffer (typically 16)
* @return int: The number of bytes read from the EEPROM slot into the buffer
*
* (*) Actual maximum slot count varies by spectrometer model. For the number of supported
* slots on your spectrometer, see EEPROMSlotFeature instantiation in appropriate
* device file under src/vendors/OceanOptics/devices.
*/
DLL_DECL int
seabreeze_read_eeprom_slot(int index, int *error_code, int slot_number, unsigned char *buffer,
int buffer_length);
/**
* @brief This function writes a string to a spectrometer's EEPROM slot
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer for storing error codes.
* @param slot_number (Input) The number of the slot being written (e.g. 0-16*).
* @param buffer (Input) A buffer containing the text to write to the slot.
* @param buffer_length (Input) The length of the text to write (typically 15)
* @return number of bytes written
*
* @warning CARELESS USE OF THIS FUNCTION CAN RENDER YOUR SPECTROMETER INOPERABLE,
* POSSIBLY REQUIRING R.M.A. OR REFLASHING TO RESTORE FUNCTIONALITY.
* PLEASE READ YOUR SPECTROMETER'S DATA SHEET CAREFULLY BEFORE USE.
*
* (*) See note in seabreeze_read_eeprom_slot() regarding per-device slot limits.
*/
DLL_DECL int
seabreeze_write_eeprom_slot(int index, int *error_code, int slot_number, unsigned char *buffer,
int buffer_length);
/**
* @brief This function reads out an irradiance calibration from the spectrometer's
* internal memory if that feature is supported.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param buffer (Output) array of floating point values into which calibration values are stored
* @param buffer_length (Input) maximum number of values to copy from the device into buffer
* @return int: the number of floats read from the device into the buffer
*/
DLL_DECL int
seabreeze_read_irrad_calibration(int index, int *error_code, float *buffer,
int buffer_length);
/**
* @brief This function writes an irradiance calibration to the spectrometer's
* internal memory if that feature is supported.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param buffer (Output) array of floating point values to store into the device
* @param buffer_length (Input) number of calibration factors to write
* @return int: the number of floats written from the buffer to the device
*/
DLL_DECL int
seabreeze_write_irrad_calibration(int index, int *error_code, float *buffer,
int buffer_length);
/**
* @brief This function checks for an irradiance collection area in the spectrometer's
* internal memory if that feature is supported.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return int: 0 if no collection area available, 1 if available.
*/
DLL_DECL int
seabreeze_has_irrad_collection_area(int index, int *error_code);
/**
* @brief This function reads an irradiance collection area from the spectrometer's
* internal memory if that feature is supported.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return float: collection area (typically in units of cm^2) read from device
*/
DLL_DECL float
seabreeze_read_irrad_collection_area(int index, int *error_code);
/**
* @brief This function writes an irradiance collection area to the spectrometer's
* internal memory if that feature is supported.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param area (Input) collection area to save to the EEPROM (presumably cm^2)
*/
DLL_DECL void
seabreeze_write_irrad_collection_area(int index, int *error_code, float area);
/**
* @brief This function reads the value of the TEC and returns the value in
* degrees celsius.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return int: The TEC temperature in degrees Celsius.
*/
DLL_DECL double
seabreeze_read_tec_temperature(int index, int *error_code);
/**
* @brief This function sets the TEC temperature.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param temperature_degrees_celsius (Input) The desired temperature, in degrees
* Celsius.
*/
DLL_DECL void
seabreeze_set_tec_temperature(int index, int *error_code,
double temperature_degrees_celsius);
/**
* @brief This function enables the TEC feature on the spectrometer.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param tec_enable (Input) A logical boolean that denotes the desired TEC enable
* state. If the value of tec_enable is zero, the TEC should be disabled.
* If the value of tec_enable is non-zero, the TEC should be enabled.
*/
DLL_DECL void
seabreeze_set_tec_enable(int index, int *error_code, unsigned char tec_enable);
/**
* @brief This function enables the TEC Fan on the spectrometer.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param tec_fan_enable (Input) A logical boolean that denotes the desired TEC fan enable
* state. If the value of tec_fan_enable is zero, the TEC fan should be disabled.
* If the value of tec_fan_enable is non-zero, the TEC fan should be enabled.
*/
DLL_DECL void
seabreeze_set_tec_fan_enable(int index, int *error_code, unsigned char tec_fan_enable);
/**
* @brief This acquires a spectrum and returns the answer in raw, unformatted bytes.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param buffer (Output) A buffer (with memory already allocated) to hold the
* spectral data
* @param buffer_length (Input) The length of the buffer in bytes (not pixels)
* @return int: The number of bytes read into the buffer
* @see sample-code/c/demo-unformatted-spectrum.c
*
* An unformatted spectrum is the raw sequence of bytes returned by the spectrometer to
* the PC over USB. The bytes have not been broken down into pixels, they're in the
* original endianness, absolutely nothing has been done to them. The caller is expected
* to know how many bytes are returned by each spectrometer model, which bytes indicate
* synchronization points or whatever, etc.
*/
DLL_DECL int
seabreeze_get_unformatted_spectrum(int index, int *error_code,
unsigned char *buffer, int buffer_length);
/**
* @brief This acquires a spectrum and returns the answer in formatted
* floats. In this mode, auto-nulling should be automatically
* performed for devices that support it.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param buffer (Output) A buffer (with memory already allocated) to hold the
* spectral data
* @param buffer_length (Input) The length of the buffer in floats (not bytes)
* @return int: The number of floats read into the buffer
*
* A formatted spectrum returns exactly one double-precision floating-point IEEE value
* per pixel, as opposed to a raw byte stream. It has also had autonulling (gain control)
* applied, meaning it has been scaled up to the spectrometer's full dynamic range using
* the gain setting recorded in that spectrometer’s EEPROM.
*/
DLL_DECL int
seabreeze_get_formatted_spectrum(int index, int *error_code,
double* buffer, int buffer_length);
/**
* @brief This returns an integer denoting the length of a raw spectrum
* (as returned by get_unformatted_spectrum(...)).
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return int: An integer denoting the length of an unformatted spectrum in bytes
*
* The caller is expected to know the number of bytes per pixel and the endian
* ordering, but it will normally be 2 bytes per pixel, LSB-MSB order.
*/
DLL_DECL int
seabreeze_get_unformatted_spectrum_length(int index, int *error_code);
/**
* @brief This returns an integer denoting the number of pixels in a
* formatted spectrum (as returned by get_formatted_spectrum(...)).
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @return int: An integer denoting the length of a formatted spectrum (in pixels)
*/
DLL_DECL int
seabreeze_get_formatted_spectrum_length(int index, int *error_code);
/**
* @brief This computes the wavelengths for the spectrometer and fills in the
* provided array (up to the given length) with those values.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param wavelengths (Output) A pre-allocated array of doubles into which the
* wavelengths will be copied
* @param length (Input) The number of values to copy into the wavelength array (this should
* be no larger than the number of doubles allocated in the wavelengths
* array)
* @return int: An integer denoting the number of wavelengths written to the buffer
*/
DLL_DECL int
seabreeze_get_wavelengths(int index, int *error_code, double *wavelengths, int length);
/**
* @brief This reads the device's serial number and fills the
* provided array (up to the given length) with it.
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param buffer (Output) A pre-allocated array of characters into which the serial number
* will be copied
* @param buffer_length (Input) The number of values to copy into the buffer (this should
* be no larger than the number of chars allocated in the buffer) (typically 16)
* @return int: An integer denoting the number of bytes written into the buffer
*
* Note that "serial numbers" may include both digits and letters
*/
DLL_DECL int
seabreeze_get_serial_number(int index, int *error_code, char *buffer, int buffer_length);
/**
* @brief This fills in the provided array (up to the given length) with the indices
* of the pixels that are electrically active but optically masked
* (a.k.a. electric dark pixels).
* @param index (Input) The index of a device previously opened with open_spectrometer().
* @param error_code (Output) A pointer to an integer that can be used for storing
* error codes.
* @param indices (Output) A pre-allocated array of ints into which the pixel indices
* will be copied
* @param length (Input) The number of values to copy into the indices array (this should
* be no larger than the number of ints allocated in the indices array)
* @return int: An integer denoting the number of indices written into the indices buffer
*
* Note that not all detectors have optically masked pixels; in that case,
* this function will return zero.
*/
DLL_DECL int
seabreeze_get_electric_dark_pixel_indices(int index, int *error_code,
int *indices, int length);
/**
* @brief Shutdown SeaBreeze completely, releasing all resources and destroying
* any cached device handles.
*
* This function is not normally needed (Singletons are destroyed automatically
* at process end), but calling this explicitly can resolve some spurious warnings
* in highly paranoid memory leak profilers.
*/
DLL_DECL void
seabreeze_shutdown();
/**
* @brief Write a raw array of bytes to a USB spectrometer.
* @param index (Input) index of an opened spectrometer
* @param errorCode (Output) pointer to an allocated integer field for receiving error codes
* @param endpoint (Input) USB endpoint for write operation
* (see src/vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeature.cpp)
* @param buffer (Input) array of bytes to send to USB spectrometer
* @param length (Input) number of bytes to write from buffer to spectrometer
* @return number of bytes written
*
* Write the bytes in the buffer according to the two command bytes at the
* start of the buffer.
*
* \section Endpoints
*
* You may wonder why the caller needs to specify an explicit endpoint for
* raw read and write operations; does not SeaBreeze already know the appro-
* priate endpoints for any open spectrometer, for example. Yes it does,
* but currently there is no easy way to extract endpoints from a generic
* spectrometer, due to the fact that OOIUSBCypressEndpointMap and
* OOIUSBSTSEndpointMap do not share a common base class (see
* OOIUSBEndpointMaps.h).
*
* We could attempt to extract them from the TransferHelpers held by
* OOIUSBInterface, but without a Hint to use as a key, we would likely
* obtain unmatched or inappropriate versions for control exchanges.
* As ControlHint and OBPControlHint share no common ancestor or type data
* to associate them while distinguishing from other hint types, we cannot
* automatically infer appropriate control endpoints.
*
* And finally, we have no way of knowing that the user really wants to
* use control endpoints anyway: they may actually desire high-speed
* spectral retrieval. So really, this needs to remain a manual external
* operation until such time as we provide a much richer, generic query
* interface over our internal endpoint lookup tables.
*
* \section Example
*
* For instance, for most USB spectrometers, the hex values <tt>05 00</tt> in
* the buffer means 'read EEPROM slot 0'. Writing this command, and following
* it with the \c seabreeze_read_usb command and the same hex <tt>05 00</tt>
* in the buffer, will result in the spectrometer's serial number, in ASCII
* characters, being delivered to the subsequent bytes in the buffer array.
* This would appear in the output buffer as:
*
* \code
* 05 00 55 53 42 32 2B 48 30 31 34 31 36 00 00 00 00 (hex)
* \endcode
*
* (<tt>USB2+H01416</tt> ASCII, skipping the two command bytes)
*
* A C or C++ program could use the data as-is, but a C# program could
* append to a string, each byte, cast as char, stopping on the first null
* character:
*
* \code
* string serial = "";
* for (int i = 0; i < length && buffer[i] != '\0'; i++)
* serial += (char)buffer[i];
* \endcode
*
* This is equivalent to:
*
* \code
* string serial = System.Text.ASCIIEncoding.ASCII.GetString(buffer).Trim('\0');
* \endcode
*
* For C# and VB.NET, the trailing zero-fill must be removed. Those null
* characters would not print or display on a screen but would make a file
* name invalid.
*/
DLL_DECL int
seabreeze_write_usb(int index, int *errorCode, unsigned char endpoint, unsigned char* buffer, unsigned int length);
/**
* @brief Read a raw array of bytes from a USB spectrometer.
* @param index (Input) index of a previously opened spectrometer
* @param errorCode (Output) pointer to an allocated integer field for receiving error codes
* @param endpoint (Input) USB endpoint for read operation
* (see src/vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeature.cpp)
* @param buffer (Input) array of allocated bytes at which to recieve USB data
* @param length (Input) maximum number of bytes to read from spectrometer
* @return number of received bytes written to buffer
*
* Read bytes from the spectrometer into the buffer. The buffer starts with
* two bytes of command information that will be followed by the transferred
* bytes. The read and write USB functions allow low-level control of the
* spectrometer via USB commands. The higher-level SeaBreeze functions issue
* USB commands internally.
*
* Reading USB data takes two steps. First a seabreeze_write_usb call requests
* the transfer, then a seabreeze_read_usb call delivers the data. Writing a buffer
* to USB takes one step. The operating system handle for the spectrometer is
* managed by SeaBreeze. USB has a concept of "end points". These are implicitly
* addressed by the seabreeze_read_usb and seabreeze_write_usb functions.
*/
DLL_DECL int
seabreeze_read_usb(int index, int *errorCode, unsigned char endpoint, unsigned char* buffer, unsigned int length);
/**
* @brief Get the SeaBreeze library's internal version identifier.
* @param buffer (Output) pointer to an allocated character array
* to hold the returned version string
* @param len (Input) size of the allocated buffer
* @return number of bytes written to buffer
*/
DLL_DECL int
seabreeze_get_api_version_string(char *buffer, int len);
/**
* @brief Get a USB descriptor string by number
* @param index (Input) Which spectrometer to set
* @param errorCode (Output) pointer to allocated integer to receive error code
* @param id (Input) numeric ID of the desired USB descriptor string
* @param buffer (Output) pointer to an allocated character array to hold
* the returned descriptor string
* @param len (Input) size of the allocated buffer
* @return number of bytes written to buffer
*/
DLL_DECL int
seabreeze_get_usb_descriptor_string(int index, int *errorCode, int id, unsigned char *buffer, int len);
/**
* @brief Set the continuous strobe period in microseconds
* @param index (Input) Which spectrometer to set
* @param errorCode (Output) pointer to allocated integer to receive error code
* @param strobe_id (Input) index of the strobe generator (currently always zero)
* @param period_usec (Input) total period of the strobe, in microseconds
* @return zero (on success or failure; check errorCode)
*
* The resolution is 0.1 milliseconds (100 microseconds).
*/
DLL_DECL void
seabreeze_set_continuous_strobe_period_microsec(int index, int *errorCode,
unsigned short strobe_id, unsigned long period_usec);
/**
* @brief Set the acquisition delay (trigger delay) in microseconds. This
* controls the amount of time between a particular event
* (usually a request for spectrum or an external trigger pulse)
* and the start of acquisition.
*/
DLL_DECL void
seabreeze_set_acquisition_delay_microsec(int index,
int *errorCode, unsigned long delay_usec);
/**
* @brief Clear the spectrum buffer (if equipped)
* @param index (Input) Which spectrometer should have its buffer cleared
* @param error_code (Output) Pointer to allocated integer to receive error code
*/
DLL_DECL void
seabreeze_clear_buffer(int index, int *error_code);
/**
* @brief Get the number of spectra presently in the buffer (if equipped)
* @param index (Input) Which spectrometer should have its buffer queried
* @param error_code (Output) Pointer to allocated integer to receive error code
* @return Number of spectra in the buffer
*/
DLL_DECL unsigned long
seabreeze_get_buffer_element_count(int index, int *error_code);
/**
* @brief Get the currently configured size of the data buffer (if equipped)
* @param index (Input) Which spectrometer should have its buffer queried
* @param error_code (Output) Pointer to allocated integer to receive error code
* @return The present limit on the number of spectra that will be retained.
*/
DLL_DECL unsigned long
seabreeze_get_buffer_capacity(int index, int *error_code);
/**
* @brief Get the maximum possible configurable size for the data buffer (if equipped)
* @param index (Input) Which spectrometer should have its buffer queried
* @param error_code (Output) Pointer to allocated integer to receive error code
* @return Maximum allowed value for the buffer size
*/
DLL_DECL unsigned long
seabreeze_get_buffer_capacity_maximum(int index, int *error_code);
/**
* @brief Get the minimum possible configurable size for the data buffer (if equipped)
* @param index (Input) Which spectrometer should have its buffer queried
* @param error_code (Output) Pointer to allocated integer to receive error code
* @return Minimum allowed value for the buffer size
*/
DLL_DECL unsigned long
seabreeze_get_buffer_capacity_minimum(int index, int *error_code);
/**
* @brief Set the number of spectra that the buffer should keep
* @param index (Input) Which spectrometer should have its buffer modified
* @param error_code (Output) Pointer to allocated integer to receive error code
* @param capacity (Input) Limit on number of spectra to store.
* Note that this must be within the range defined by the capacity minimum
* and maximum values.
*/
DLL_DECL void
seabreeze_set_buffer_capacity(int index, int *error_code, unsigned long capacity);
/**
* @brief Programmatically enable debug outputs to stderr
* @param flag (Input) zero to disable (default), non-zero to enable
*/
DLL_DECL void
seabreeze_set_verbose(int flag);
/**
* @brief redirect verbose logging to named file
* @param flag (Input) NULL for default behavior (stderr), non-null for valid OS path
*/
DLL_DECL void
seabreeze_set_logfile(char* pathname, int len);
#ifdef __cplusplus
};
#endif /* __cplusplus */
#endif /* SEABREEZE_WRAPPER_H */

63
Source/OSIF/include/api/seabreezeapi/AcquisitionDelayFeatureAdapter.h Normal file
View File

@ -0,0 +1,63 @@
/***************************************************//**
* @file AcquisitionDelayFeatureAdapter.h
* @date November 2015
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows access to SeaBreeze
* DataBufferFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H
#define SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/acquisition_delay/AcquisitionDelayFeatureInterface.h"
namespace seabreeze {
namespace api {
class AcquisitionDelayFeatureAdapter
: public FeatureAdapterTemplate<AcquisitionDelayFeatureInterface> {
public:
AcquisitionDelayFeatureAdapter(AcquisitionDelayFeatureInterface *intf,
const FeatureFamily &f, Protocol *p, Bus *b,
unsigned short instanceIndex);
virtual ~AcquisitionDelayFeatureAdapter();
/* Acquisition delay functions */
unsigned long getAcquisitionDelayIncrementMicroseconds(int *errorCode);
unsigned long getAcquisitionDelayMaximumMicroseconds(int *errorCode);
unsigned long getAcquisitionDelayMinimumMicroseconds(int *errorCode);
unsigned long getAcquisitionDelayMicroseconds(int *errorCode);
void setAcquisitionDelayMicroseconds(int *errorCode, const unsigned long delay_usec);
};
} /* end namespace api */
} /* end namespace seabreeze */
#endif /* SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H */

56
Source/OSIF/include/api/seabreezeapi/ContinuousStrobeFeatureAdapter.h Normal file
View File

@ -0,0 +1,56 @@
/***************************************************//**
* @file ContinuousStrobeFeatureAdapter.h
* @date October 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows access to SeaBreeze
* ContinuousStrobeFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_CONTINUOUS_STROBE_FEATURE_ADAPTER_H
#define SEABREEZE_CONTINUOUS_STROBE_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/continuous_strobe/ContinuousStrobeFeatureInterface.h"
namespace seabreeze {
namespace api {
class ContinuousStrobeFeatureAdapter
: public FeatureAdapterTemplate<ContinuousStrobeFeatureInterface> {
public:
ContinuousStrobeFeatureAdapter(ContinuousStrobeFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~ContinuousStrobeFeatureAdapter();
void setContinuousStrobePeriodMicroseconds(int *errorCode, unsigned long period_usec);
void setContinuousStrobeEnable(int *errorCode, bool enable);
};
}
}
#endif

63
Source/OSIF/include/api/seabreezeapi/DataBufferFeatureAdapter.h Normal file
View File

@ -0,0 +1,63 @@
/***************************************************//**
* @file DataBufferFeatureAdapter.h
* @date October 2015
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows access to SeaBreeze
* DataBufferFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H
#define SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/data_buffer/DataBufferFeatureInterface.h"
namespace seabreeze {
namespace api {
class DataBufferFeatureAdapter
: public FeatureAdapterTemplate<DataBufferFeatureInterface> {
public:
DataBufferFeatureAdapter(DataBufferFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~DataBufferFeatureAdapter();
/* Data buffer functions */
void clearBuffer(int *errorCode);
unsigned long getNumberOfElements(int *errorCode);
unsigned long getBufferCapacity(int *errorCode);
unsigned long getBufferCapacityMaximum(int *errorCode);
unsigned long getBufferCapacityMinimum(int *errorCode);
void setBufferCapacity(int *errorCode, unsigned long capacity);
};
} /* end namespace api */
} /* end namespace seabreeze */
#endif /* SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H */

308
Source/OSIF/include/api/seabreezeapi/DeviceAdapter.h Normal file
View File

@ -0,0 +1,308 @@
/***************************************************//**
* @file DeviceAdapter.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a wrapper that allows
* access to SeaBreeze Device instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef DEVICEADAPTER_H
#define DEVICEADAPTER_H
/* Includes */
#include "common/devices/Device.h"
#include "common/buses/DeviceLocatorInterface.h"
#include "api/seabreezeapi/EEPROMFeatureAdapter.h"
#include "api/seabreezeapi/IrradCalFeatureAdapter.h"
#include "api/seabreezeapi/RawUSBBusAccessFeatureAdapter.h"
#include "api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.h"
#include "api/seabreezeapi/TemperatureFeatureAdapter.h"
#include "api/seabreezeapi/RevisionFeatureAdapter.h"
#include "api/seabreezeapi/OpticalBenchFeatureAdapter.h"
#include "api/seabreezeapi/SpectrumProcessingFeatureAdapter.h"
#include "api/seabreezeapi/SerialNumberFeatureAdapter.h"
#include "api/seabreezeapi/ShutterFeatureAdapter.h"
#include "api/seabreezeapi/SpectrometerFeatureAdapter.h"
#include "api/seabreezeapi/StrayLightCoeffsFeatureAdapter.h"
#include "api/seabreezeapi/StrobeLampFeatureAdapter.h"
#include "api/seabreezeapi/ContinuousStrobeFeatureAdapter.h"
#include "api/seabreezeapi/ThermoElectricCoolerFeatureAdapter.h"
#include "api/seabreezeapi/LightSourceFeatureAdapter.h"
#include "api/seabreezeapi/PixelBinningFeatureAdapter.h"
#include "api/seabreezeapi/DataBufferFeatureAdapter.h"
#include "api/seabreezeapi/AcquisitionDelayFeatureAdapter.h"
#include <vector>
namespace seabreeze {
namespace api {
class DeviceAdapter {
public:
DeviceAdapter(Device *dev, unsigned long id);
~DeviceAdapter();
int open(int *errorCode);
void close();
DeviceLocatorInterface *getLocation();
/* An for weak association to this object */
unsigned long getID();
/* Get a string that describes the type of device */
int getDeviceType(int *errorCode, char *buffer, unsigned int maxLength);
/* Get a usb endpoint for the device according to the enumerator */
/* endpointType. A 0 is returned if the endpoint requested is not in use. */
unsigned char getDeviceEndpoint(int *errorCode, usbEndpointType anEndpointType);
/* Get one or more raw USB access features */
int getNumberOfRawUSBBusAccessFeatures();
int getRawUSBBusAccessFeatures(long *buffer, int maxFeatures);
int rawUSBBusAccessRead(long featureID,
int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
int rawUSBBusAccessWrite(long featureID,
int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
/* Get one or more serial number features */
int getNumberOfSerialNumberFeatures();
int getSerialNumberFeatures(long *buffer, int maxFeatures);
int getSerialNumber(long featureID, int *errorCode,
char *buffer, int bufferLength);
unsigned char getSerialNumberMaximumLength(long featureID, int *errorCode);
/* Get one or more spectrometer acquisition features */
int getNumberOfSpectrometerFeatures();
int getSpectrometerFeatures(long *buffer, int maxFeatures);
void spectrometerSetTriggerMode(long spectrometerFeatureID, int *errorCode, int mode);
void spectrometerSetIntegrationTimeMicros(long spectrometerFeatureID, int *errorCode,
unsigned long integrationTimeMicros);
unsigned long spectrometerGetMinimumIntegrationTimeMicros(
long spectrometerFeatureID, int *errorCode);
unsigned long spectrometerGetMaximumIntegrationTimeMicros(
long spectrometerFeatureID, int *errorCode);
double spectrometerGetMaximumIntensity(
long spectrometerFeatureID, int *errorCode);
int spectrometerGetUnformattedSpectrumLength(
long spectrometerFeatureID, int *errorCode);
int spectrometerGetUnformattedSpectrum(long spectrometerFeatureID,
int *errorCode, unsigned char *buffer, int bufferLength);
int spectrometerGetFormattedSpectrumLength(
long spectrometerFeatureID, int *errorCode);
int spectrometerGetFormattedSpectrum(long spectrometerFeatureID, int *errorCode,
double *buffer, int bufferLength);
int spectrometerGetWavelengths(long spectrometerFeatureID, int *errorCode,
double *wavelengths, int length);
int spectrometerGetElectricDarkPixelCount(
long spectrometerFeatureID, int *errorCode);
int spectrometerGetElectricDarkPixelIndices(
long spectrometerFeatureID, int *errorCode, int *indices, int length);
/* Get one or more pixel binning features */
int getNumberOfPixelBinningFeatures();
int getPixelBinningFeatures(long *buffer, int maxFeatures);
void binningSetPixelBinningFactor(long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
unsigned char binningGetPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
void binningSetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
void binningSetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
unsigned char binningGetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
unsigned char binningGetMaxPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
/* Get one or more TEC features */
int getNumberOfThermoElectricFeatures();
int getThermoElectricFeatures(long *buffer, int maxFeatures);
double tecReadTemperatureDegreesC(long featureID, int *errorCode);
void tecSetTemperatureSetpointDegreesC(long featureID, int *errorCode,
double temperatureDegreesCelsius);
void tecSetEnable(long featureID, int *errorCode, bool tecEnable);
/* Get one or more irradiance calibration features */
int getNumberOfIrradCalFeatures();
int getIrradCalFeatures(long *buffer, int maxFeatures);
int irradCalibrationRead(long featureID,
int *errorCode, float *buffer, int bufferLength);
int irradCalibrationWrite(long featureID,
int *errorCode, float *buffer, int bufferLength);
int irradCalibrationHasCollectionArea(long featureID, int *errorCode);
float irradCalibrationReadCollectionArea(long featureID, int *errorCode);
void irradCalibrationWriteCollectionArea(long featureID,
int *errorCode, float area);
/* Get one or more EEPROM features */
int getNumberOfEEPROMFeatures();
int getEEPROMFeatures(long *buffer, int maxFeatures);
int eepromReadSlot(long featureID, int *errorCode, int slotNumber,
unsigned char *buffer, int length);
/* Get one or more light source features */
int getNumberOfLightSourceFeatures();
int getLightSourceFeatures(long *buffer, int maxFeatures);
int lightSourceGetCount(long featureID, int *errorCode);
bool lightSourceHasEnable(long featureID, int *errorCode,
int lightSourceIndex);
bool lightSourceIsEnabled(long featureID, int *errorCode,
int lightSourceIndex);
void lightSourceSetEnable(long featureID, int *errorCode,
int lightSourceIndex, bool enable);
bool lightSourceHasVariableIntensity(long featureID, int *errorCode,
int lightSourceIndex);
double lightSourceGetIntensity(long featureID, int *errorCode,
int lightSourceIndex);
void lightSourceSetIntensity(long featureID, int *errorCode,
int lightSourceIndex, double intensity);
/* Get one or more strobe lamp enable features */
int getNumberOfStrobeLampFeatures();
int getStrobeLampFeatures(long *buffer, int maxFeatures);
void lampSetStrobeEnable(long featureID, int *errorCode, bool strobeEnable);
/* Get one or more continuous strobe features */
int getNumberOfContinuousStrobeFeatures();
int getContinuousStrobeFeatures(long *buffer, int maxFeatures);
void continuousStrobeSetPeriodMicroseconds(long featureID, int *errorCode,
unsigned long period_usec);
void continuousStrobeSetEnable(long featureID, int *errorCode, bool enable);
/* Get one or more shutter features */
int getNumberOfShutterFeatures();
int getShutterFeatures(long *buffer, int maxFeatures);
void shutterSetShutterOpen(long featureID, int *errorCode, bool opened);
/* Get one or more nonlinearity coefficients features */
int getNumberOfNonlinearityCoeffsFeatures();
int getNonlinearityCoeffsFeatures(long *buffer, int maxFeatures);
int nonlinearityCoeffsGet(long featureID, int *errorCode,
double *buffer, int bufferLength);
/* Get one or more temperature features */
int getNumberOfTemperatureFeatures();
int getTemperatureFeatures(long *buffer, int maxFeatures);
unsigned char temperatureCountGet(long temperatureFeatureID, int *errorCode);
double temperatureGet(long temperatureFeatureID, int *errorCode, int index);
int temperatureGetAll(long temperatureFeatureID, int *errorCode,
double *buffer, int bufferLength);
/* Get one or more revision features */
int getNumberOfRevisionFeatures();
int getRevisionFeatures(long *buffer, int maxFeatures);
unsigned char revisionHardwareGet(long revisionFeatureID, int *errorCode);
unsigned short int revisionFirmwareGet(long revisionFeatureID, int *errorCode);
/* Get one or more spectrum processing features */
int getNumberOfSpectrumProcessingFeatures();
int getSpectrumProcessingFeatures(long *buffer, int maxFeatures);
unsigned short int spectrumProcessingScansToAverageGet(long spectrumProcessingFeatureID, int *errorCode);
unsigned char spectrumProcessingBoxcarWidthGet(long spectrumProcessingFeatureID, int *errorCode);
void spectrumProcessingBoxcarWidthSet(long featureID, int *errorCode, unsigned char boxcarWidth);
void spectrumProcessingScansToAverageSet(long featureID, int *errorCode, unsigned short int scansToAverage);
/* Get one or more optical bench features */
int getNumberOfOpticalBenchFeatures();
int getOpticalBenchFeatures(long *buffer, int maxFeatures);
unsigned short int opticalBenchGetFiberDiameterMicrons(long opticalBenchFeatureID, int *errorCode);
unsigned short int opticalBenchGetSlitWidthMicrons(long opticalBenchFeatureID, int *errorCode);
int opticalBenchGetID(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
int opticalBenchGetSerialNumber(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
int opticalBenchGetCoating(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
int opticalBenchGetFilter(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
int opticalBenchGetGrating(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
/* Get one or more stray light coefficients features */
int getNumberOfStrayLightCoeffsFeatures();
int getStrayLightCoeffsFeatures(long *buffer, int maxFeatures);
int strayLightCoeffsGet(long featureID, int *errorCode,
double *buffer, int bufferLength);
/* Get one or more data buffer features */
int getNumberOfDataBufferFeatures();
int getDataBufferFeatures(long *buffer, int maxFeatures);
void dataBufferClear(long featureID, int *errorCode);
unsigned long dataBufferGetNumberOfElements(long featureID, int *errorCode);
unsigned long dataBufferGetBufferCapacity(long featureID, int *errorCode);
unsigned long dataBufferGetBufferCapacityMaximum(long featureID, int *errorCode);
unsigned long dataBufferGetBufferCapacityMinimum(long featureID, int *errorCode);
void dataBufferSetBufferCapacity(long featureID, int *errorCode, unsigned long capacity);
/* Get one or more acquisition delay features */
int getNumberOfAcquisitionDelayFeatures();
int getAcquisitionDelayFeatures(long *buffer, int maxFeatures);
void acquisitionDelaySetDelayMicroseconds(long featureID, int *errorCode,
unsigned long delay_usec);
unsigned long acquisitionDelayGetDelayMicroseconds(long featureID, int *errorCode);
unsigned long acquisitionDelayGetDelayIncrementMicroseconds(long featureID, int *errorCode);
unsigned long acquisitionDelayGetDelayMaximumMicroseconds(long featureID, int *errorCode);
unsigned long acquisitionDelayGetDelayMinimumMicroseconds(long featureID, int *errorCode);
protected:
unsigned long instanceID;
seabreeze::Device *device;
std::vector<RawUSBBusAccessFeatureAdapter *> rawUSBBusAccessFeatures;
std::vector<SerialNumberFeatureAdapter *> serialNumberFeatures;
std::vector<SpectrometerFeatureAdapter *> spectrometerFeatures;
std::vector<ThermoElectricCoolerFeatureAdapter *> tecFeatures;
std::vector<IrradCalFeatureAdapter *> irradCalFeatures;
std::vector<EEPROMFeatureAdapter *> eepromFeatures;
std::vector<LightSourceFeatureAdapter *> lightSourceFeatures;
std::vector<StrobeLampFeatureAdapter *> strobeLampFeatures;
std::vector<ContinuousStrobeFeatureAdapter *> continuousStrobeFeatures;
std::vector<ShutterFeatureAdapter *> shutterFeatures;
std::vector<NonlinearityCoeffsFeatureAdapter *> nonlinearityFeatures;
std::vector<TemperatureFeatureAdapter *> temperatureFeatures;
std::vector<RevisionFeatureAdapter *> revisionFeatures;
std::vector<OpticalBenchFeatureAdapter *> opticalBenchFeatures;
std::vector<SpectrumProcessingFeatureAdapter *> spectrumProcessingFeatures;
std::vector<StrayLightCoeffsFeatureAdapter *> strayLightFeatures;
std::vector<PixelBinningFeatureAdapter *> pixelBinningFeatures;
std::vector<DataBufferFeatureAdapter *> dataBufferFeatures;
std::vector<AcquisitionDelayFeatureAdapter *> acquisitionDelayFeatures;
RawUSBBusAccessFeatureAdapter *getRawUSBBusAccessFeatureByID(long featureID);
SerialNumberFeatureAdapter *getSerialNumberFeatureByID(long featureID);
SpectrometerFeatureAdapter *getSpectrometerFeatureByID(long featureID);
ThermoElectricCoolerFeatureAdapter *getTECFeatureByID(long featureID);
IrradCalFeatureAdapter *getIrradCalFeatureByID(long featureID);
EEPROMFeatureAdapter *getEEPROMFeatureByID(long featureID);
LightSourceFeatureAdapter *getLightSourceFeatureByID(long featureID);
StrobeLampFeatureAdapter *getStrobeLampFeatureByID(long featureID);
ContinuousStrobeFeatureAdapter *getContinuousStrobeFeatureByID(long featureID);
ShutterFeatureAdapter *getShutterFeatureByID(long featureID);
NonlinearityCoeffsFeatureAdapter *getNonlinearityCoeffsFeatureByID(long featureID);
TemperatureFeatureAdapter *getTemperatureFeatureByID(long featureID);
RevisionFeatureAdapter *getRevisionFeatureByID(long featureID);
OpticalBenchFeatureAdapter *getOpticalBenchFeatureByID(long featureID);
SpectrumProcessingFeatureAdapter *getSpectrumProcessingFeatureByID(long featureID);
StrayLightCoeffsFeatureAdapter *getStrayLightCoeffsFeatureByID(long featureID);
PixelBinningFeatureAdapter *getPixelBinningFeatureByID(long featureID);
DataBufferFeatureAdapter *getDataBufferFeatureByID(long featureID);
AcquisitionDelayFeatureAdapter *getAcquisitionDelayFeatureByID(long featureID);
};
}
}
#endif

57
Source/OSIF/include/api/seabreezeapi/EEPROMFeatureAdapter.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************//**
* @file EEPROMFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze EEPROMFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_EEPROMFEATUREADAPTER_H
#define SEABREEZE_EEPROMFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/eeprom_slots/EEPROMSlotFeatureInterface.h"
namespace seabreeze {
namespace api {
class EEPROMFeatureAdapter
: public FeatureAdapterTemplate<EEPROMSlotFeatureInterface> {
public:
EEPROMFeatureAdapter(EEPROMSlotFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~EEPROMFeatureAdapter();
/* EEPROM functions */
int readEEPROMSlot(int *errorCode, int slotNumber,
unsigned char *buffer, int bufferLength);
};
}
}
#endif

57
Source/OSIF/include/api/seabreezeapi/FeatureAdapterInterface.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************//**
* @file FeatureAdapterInterface.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This interface allows device features to be treated
* consistently regardless of the actual capabilities.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_FEATUREADAPTERINTERFACE_H
#define SEABREEZE_FEATUREADAPTERINTERFACE_H
#include "common/features/FeatureFamily.h"
namespace seabreeze {
namespace api {
class FeatureAdapterInterface {
public:
virtual ~FeatureAdapterInterface() = 0;
/* This gets a semi-unique integer ID for this feature instance */
virtual long getID() = 0;
/* Gets the general category of the feature, if any */
virtual FeatureFamily &getFeatureFamily() = 0;
};
/* Default empty destructor for otherwise abstract class */
inline FeatureAdapterInterface::~FeatureAdapterInterface() { }
}
}
#endif

87
Source/OSIF/include/api/seabreezeapi/FeatureAdapterTemplate.h Normal file
View File

@ -0,0 +1,87 @@
/***************************************************//**
* @file FeatureAdapterTemplate.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a templated wrapper around SeaBreeze Feature
* instances. This should make it easier to obtain a
* particular Feature to call methods against.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef FEATUREADAPTERTEMPLATE_H
#define FEATUREADAPTERTEMPLATE_H
#include "api/seabreezeapi/FeatureAdapterInterface.h"
#include "common/buses/Bus.h"
#include "common/exceptions/IllegalArgumentException.h"
#include "common/features/FeatureFamily.h"
#include "common/protocols/Protocol.h"
#include <string>
namespace seabreeze {
namespace api {
template <class T> class FeatureAdapterTemplate
: public FeatureAdapterInterface {
public:
FeatureAdapterTemplate(T *featureInterface, const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex) {
this->feature = featureInterface;
this->family = f;
this->protocol = p;
this->bus = b;
this->index = instanceIndex;
/* Create a unique ID based on the feature type and index. This
* might be expanded in the future to use one of the bytes for
* the feature type or index as a module number.
*/
this->ID = (family.getType() << 16) | (instanceIndex & 0x00FFFF);
if(0 == this->feature || 0 == this->protocol || 0 == this->bus) {
std::string error("Null feature interface, protocol, or bus is not allowed.");
throw IllegalArgumentException(error);
}
}
virtual ~FeatureAdapterTemplate() { /* Do nothing -- others delete feature */ }
T *getFeature() { return this->feature; }
virtual FeatureFamily &getFeatureFamily() { return this->family; }
virtual long getID() { return this->ID; }
protected:
T *feature;
FeatureFamily family;
Protocol *protocol;
Bus *bus;
unsigned short index;
unsigned long ID;
};
}
}
#endif

200
Source/OSIF/include/api/seabreezeapi/FeatureFamilies.h Normal file
View File

@ -0,0 +1,200 @@
/***************************************************//**
* @file FeatureFamilies.h
* @date February 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This provides a way to get references to different kinds
* of features (e.g. spectrometer, TEC) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_FEATUREFAMILIES_H
#define SEABREEZE_FEATUREFAMILIES_H
#include "common/features/FeatureFamily.h"
#include <vector>
namespace seabreeze {
namespace api {
class UndefinedFeatureFamily : public FeatureFamily {
public:
UndefinedFeatureFamily();
virtual ~UndefinedFeatureFamily();
};
class SerialNumberFeatureFamily : public FeatureFamily {
public:
SerialNumberFeatureFamily();
virtual ~SerialNumberFeatureFamily();
};
class SpectrometerFeatureFamily : public FeatureFamily {
public:
SpectrometerFeatureFamily();
virtual ~SpectrometerFeatureFamily();
};
class ThermoElectricFeatureFamily : public FeatureFamily {
public:
ThermoElectricFeatureFamily();
virtual ~ThermoElectricFeatureFamily();
};
class IrradCalFeatureFamily : public FeatureFamily {
public:
IrradCalFeatureFamily();
virtual ~IrradCalFeatureFamily();
};
class EEPROMFeatureFamily : public FeatureFamily {
public:
EEPROMFeatureFamily();
virtual ~EEPROMFeatureFamily();
};
class LightSourceFeatureFamily : public FeatureFamily {
public:
LightSourceFeatureFamily();
virtual ~LightSourceFeatureFamily();
};
class StrobeLampFeatureFamily : public FeatureFamily {
public:
StrobeLampFeatureFamily();
virtual ~StrobeLampFeatureFamily();
};
class ContinuousStrobeFeatureFamily : public FeatureFamily {
public:
ContinuousStrobeFeatureFamily();
virtual ~ContinuousStrobeFeatureFamily();
};
class ShutterFeatureFamily : public FeatureFamily {
public:
ShutterFeatureFamily();
virtual ~ShutterFeatureFamily();
};
class WaveCalFeatureFamily : public FeatureFamily {
public:
WaveCalFeatureFamily();
virtual ~WaveCalFeatureFamily();
};
class NonlinearityCoeffsFeatureFamily : public FeatureFamily {
public:
NonlinearityCoeffsFeatureFamily();
virtual ~NonlinearityCoeffsFeatureFamily();
};
class TemperatureFeatureFamily : public FeatureFamily {
public:
TemperatureFeatureFamily();
virtual ~TemperatureFeatureFamily();
};
class RevisionFeatureFamily : public FeatureFamily {
public:
RevisionFeatureFamily();
virtual ~RevisionFeatureFamily();
};
class OpticalBenchFeatureFamily : public FeatureFamily {
public:
OpticalBenchFeatureFamily();
virtual ~OpticalBenchFeatureFamily();
};
class SpectrumProcessingFeatureFamily : public FeatureFamily {
public:
SpectrumProcessingFeatureFamily();
virtual ~SpectrumProcessingFeatureFamily();
};
class StrayLightCoeffsFeatureFamily : public FeatureFamily {
public:
StrayLightCoeffsFeatureFamily();
virtual ~StrayLightCoeffsFeatureFamily();
};
class RawUSBBusAccessFeatureFamily : public FeatureFamily {
public:
RawUSBBusAccessFeatureFamily();
virtual ~RawUSBBusAccessFeatureFamily();
};
class DataBufferFeatureFamily : public FeatureFamily {
public:
DataBufferFeatureFamily();
virtual ~DataBufferFeatureFamily();
};
class AcquisitionDelayFeatureFamily : public FeatureFamily {
public:
AcquisitionDelayFeatureFamily();
virtual ~AcquisitionDelayFeatureFamily();
};
class PixelBinningFeatureFamily : public FeatureFamily {
public:
PixelBinningFeatureFamily();
virtual ~PixelBinningFeatureFamily();
};
class FeatureFamilies {
public:
const UndefinedFeatureFamily UNDEFINED;
const SerialNumberFeatureFamily SERIAL_NUMBER;
const SpectrometerFeatureFamily SPECTROMETER;
const ThermoElectricFeatureFamily THERMOELECTRIC;
const IrradCalFeatureFamily IRRAD_CAL;
const EEPROMFeatureFamily EEPROM;
const LightSourceFeatureFamily LIGHT_SOURCE;
const StrobeLampFeatureFamily STROBE_LAMP_ENABLE;
const ContinuousStrobeFeatureFamily CONTINUOUS_STROBE;
const ShutterFeatureFamily SHUTTER;
const WaveCalFeatureFamily WAVELENGTH_CAL;
const NonlinearityCoeffsFeatureFamily NONLINEARITY_COEFFS;
const TemperatureFeatureFamily TEMPERATURE;
const RevisionFeatureFamily REVISION;
const OpticalBenchFeatureFamily OPTICAL_BENCH;
const SpectrumProcessingFeatureFamily SPECTRUM_PROCESSING;
const StrayLightCoeffsFeatureFamily STRAY_LIGHT_COEFFS;
const RawUSBBusAccessFeatureFamily RAW_USB_BUS_ACCESS;
const DataBufferFeatureFamily DATA_BUFFER;
const AcquisitionDelayFeatureFamily ACQUISITION_DELAY;
const PixelBinningFeatureFamily PIXEL_BINNING;
FeatureFamilies();
~FeatureFamilies();
std::vector<FeatureFamily *> getAllFeatureFamilies();
};
}
}
#endif

62
Source/OSIF/include/api/seabreezeapi/IrradCalFeatureAdapter.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file IrradCalFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze IrradCalFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_IRRADCALFEATUREADAPTER_H
#define SEABREEZE_IRRADCALFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/irradcal/IrradCalFeatureInterface.h"
namespace seabreeze {
namespace api {
class IrradCalFeatureAdapter
: public FeatureAdapterTemplate<IrradCalFeatureInterface> {
public:
IrradCalFeatureAdapter(IrradCalFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~IrradCalFeatureAdapter();
int readIrradCalibration(int *errorCode, float *buffer,
int bufferLength);
int writeIrradCalibration(int *errorCode, float *buffer,
int bufferLength);
int hasIrradCollectionArea(int *errorCode);
float readIrradCollectionArea(int *errorCode);
void writeIrradCollectionArea(int *errorCode, float area);
};
}
}
#endif

69
Source/OSIF/include/api/seabreezeapi/LightSourceFeatureAdapter.h Normal file
View File

@ -0,0 +1,69 @@
/***************************************************//**
* @file LightSourceFeatureAdapter.h
* @date May 2013
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze LightSourceFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_LIGHTSOURCEFEATUREADAPTER_H
#define SEABREEZE_LIGHTSOURCEFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/light_source/LightSourceFeatureInterface.h"
namespace seabreeze {
namespace api {
class LightSourceFeatureAdapter
: public FeatureAdapterTemplate<LightSourceFeatureInterface> {
public:
LightSourceFeatureAdapter(LightSourceFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~LightSourceFeatureAdapter();
int getLightSourceCount(int *errorCode);
bool hasLightSourceEnable(int *errorCode, int lightSourceIndex);
bool isLightSourceEnabled(int *errorCode, int lightSourceIndex);
void setLightSourceEnable(int *errorCode, int lightSourceIndex,
bool enable);
/* The intensity is normalized over the range [0, 1] where 0 is
* the minimum programmable intensity and 1 is the maximum
*/
bool hasVariableIntensity(int *errorCode, int lightSourceIndex);
double getLightSourceIntensity(int *errorCode, int lightSourceIndex);
void setLightSourceIntensity(int *errorCode, int lightSourceIndex,
double intensity);
};
}
}
#endif

57
Source/OSIF/include/api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************//**
* @file NonlinearityCoeffsFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze NonlinearityCoeffFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_NONLINEARITYCOEFFSFEATUREADAPTER_H
#define SEABREEZE_NONLINEARITYCOEFFSFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/nonlinearity/NonlinearityCoeffsFeatureInterface.h"
namespace seabreeze {
namespace api {
class NonlinearityCoeffsFeatureAdapter
: public FeatureAdapterTemplate<NonlinearityCoeffsFeatureInterface> {
public:
NonlinearityCoeffsFeatureAdapter(NonlinearityCoeffsFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~NonlinearityCoeffsFeatureAdapter();
int readNonlinearityCoeffs(int *errorCode, double *buffer,
int bufferLength);
};
}
}
#endif

62
Source/OSIF/include/api/seabreezeapi/OpticalBenchFeatureAdapter.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file OpticalBenchFeatureAdapter.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a wrapper that allows
* access to SeaBreeze TemperatureFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_OPTICALBENCHFEATUREADAPTER_H
#define SEABREEZE_OPTICALBENCHFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/optical_bench/OpticalBenchFeatureInterface.h"
namespace seabreeze {
namespace api {
class OpticalBenchFeatureAdapter
: public FeatureAdapterTemplate<OpticalBenchFeatureInterface> {
public:
OpticalBenchFeatureAdapter(OpticalBenchFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~OpticalBenchFeatureAdapter();
unsigned short int readOpticalBenchFiberDiameterMicrons(int *errorCode);
unsigned short int readOpticalBenchSlitWidthMicrons(int *errorCode);
int readOpticalBenchID(int *errorCode, char *buffer, int buffer_length);
int readOpticalBenchSerialNumber(int *errorCode, char *buffer, int buffer_length);
int readOpticalBenchCoating(int *errorCode, char *buffer, int buffer_length);
int readOpticalBenchFilter(int *errorCode, char *buffer, int buffer_length);
int readOpticalBenchGrating(int *errorCode, char *buffer, int buffer_length);
};
}
}
#endif

68
Source/OSIF/include/api/seabreezeapi/PixelBinningFeatureAdapter.h Normal file
View File

@ -0,0 +1,68 @@
/***************************************************//**
* @file PixelBinningFeatureAdapter.h
* @date October 2015
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows access to SeaBreeze
* TECFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PIXEL_BINNING_FEATURE_ADAPTER_H
#define SEABREEZE_PIXEL_BINNING_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/pixel_binning/PixelBinningFeatureInterface.h"
namespace seabreeze {
namespace api {
class PixelBinningFeatureAdapter
: public FeatureAdapterTemplate<PixelBinningFeatureInterface> {
public:
PixelBinningFeatureAdapter(PixelBinningFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~PixelBinningFeatureAdapter();
/* Thermoelectric cooler functions */
unsigned char getPixelBinningFactor(int *errorCode);
void setPixelBinningFactor(int *errorCode,
const unsigned char binningFactor);
unsigned char getDefaultPixelBinningFactor(int *errorCode);
void setDefaultPixelBinningFactor(int *errorCode,
const unsigned char binningFactor);
void setDefaultPixelBinningFactor(int *errorCode);
unsigned char getMaxPixelBinningFactor(int *errorCode);
};
}
}
#endif

87
Source/OSIF/include/api/seabreezeapi/ProtocolFamilies.h Normal file
View File

@ -0,0 +1,87 @@
/***************************************************//**
* @file ProtocolFamilies.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This provides a way to describe different kinds
* protocols (e.g. OOI, OBP) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOLFAMILIES_H
#define SEABREEZE_PROTOCOLFAMILIES_H
#include "common/protocols/ProtocolFamily.h"
#include <vector>
namespace seabreeze {
namespace api {
class UndefinedProtocolFamily : public ProtocolFamily {
public:
UndefinedProtocolFamily();
virtual ~UndefinedProtocolFamily();
};
class OOIProtocolFamily : public ProtocolFamily {
public:
OOIProtocolFamily();
virtual ~OOIProtocolFamily();
};
class OceanBinaryProtocolFamily : public ProtocolFamily {
public:
OceanBinaryProtocolFamily();
virtual ~OceanBinaryProtocolFamily();
};
class JazMessagingProtocolFamily : public ProtocolFamily {
public:
JazMessagingProtocolFamily();
virtual ~JazMessagingProtocolFamily();
};
class VirtualProtocolFamily : public ProtocolFamily {
public:
VirtualProtocolFamily();
virtual ~VirtualProtocolFamily();
};
class ProtocolFamilies {
public:
const UndefinedProtocolFamily UNDEFINED_PROTOCOL;
const OOIProtocolFamily OOI_PROTOCOL;
const OceanBinaryProtocolFamily OCEAN_BINARY_PROTOCOL;
const JazMessagingProtocolFamily JAZ_MESSAGING_PROTOCOL;
const VirtualProtocolFamily VIRTUAL_PROTOCOL;
ProtocolFamilies();
~ProtocolFamilies();
std::vector<ProtocolFamily *> getAllProtocolFamilies();
};
}
}
#endif

57
Source/OSIF/include/api/seabreezeapi/RawUSBBusAccessFeatureAdapter.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************//**
* @file RawUSBBusAccessFeatureAdapter.h
* @date February 2015
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze RawUSBBusAccessFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_RAWUSBBUSACCESSFEATUREADAPTER_H
#define SEABREEZE_RAWUSBBUSACCESSFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeatureInterface.h"
namespace seabreeze {
namespace api {
class RawUSBBusAccessFeatureAdapter
: public FeatureAdapterTemplate<RawUSBBusAccessFeatureInterface> {
public:
RawUSBBusAccessFeatureAdapter(RawUSBBusAccessFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~RawUSBBusAccessFeatureAdapter();
int readUSB(int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char usbEndpoint);
int writeUSB(int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char usbEndpoint);
};
}
}
#endif

58
Source/OSIF/include/api/seabreezeapi/RevisionFeatureAdapter.h Normal file
View File

@ -0,0 +1,58 @@
/***************************************************//**
* @file RevisionFeatureAdapter.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a wrapper that allows
* access to SeaBreeze RevisionFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_REVISIONFEATUREADAPTER_H
#define SEABREEZE_REVISIONFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/revision/RevisionFeatureInterface.h"
namespace seabreeze {
namespace api {
class RevisionFeatureAdapter
: public FeatureAdapterTemplate<RevisionFeatureInterface> {
public:
RevisionFeatureAdapter(RevisionFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~RevisionFeatureAdapter();
unsigned char readHardwareRevision(int *errorCode);
unsigned short int readFirmwareRevision(int *errorCode);
};
}
}
#endif

2481
Source/OSIF/include/api/seabreezeapi/SeaBreezeAPI.h Normal file
View File

File diff suppressed because it is too large Load Diff

55
Source/OSIF/include/api/seabreezeapi/SeaBreezeAPIConstants.h Normal file
View File

@ -0,0 +1,55 @@
/***************************************************//**
* @file SeaBreezeAPIConstants.h
* @date January 2015
* @author Ocean Optics, Inc.
*
* This file defines constants for use with SeaBreeze API
* implementations.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZEAPICONSTANTS_H
#define SEABREEZEAPICONSTANTS_H
/* Macros and constants */
#define SET_ERROR_CODE(code) do { if(NULL != errorCode) { *errorCode = code; } } while(0)
#ifdef ERROR_SUCCESS
#undef ERROR_SUCCESS
#endif
/* Constants */
#define ERROR_SUCCESS 0
#define ERROR_INVALID_ERROR 1
#define ERROR_NO_DEVICE 2
#define ERROR_FAILED_TO_CLOSE 3
#define ERROR_NOT_IMPLEMENTED 4
#define ERROR_FEATURE_NOT_FOUND 5
#define ERROR_TRANSFER_ERROR 6
#define ERROR_BAD_USER_BUFFER 7
#define ERROR_INPUT_OUT_OF_BOUNDS 8
#define ERROR_SPECTROMETER_SATURATED 9
#define ERROR_VALUE_NOT_FOUND 10
#endif /* SEABREEZEAPICONSTANTS_H */

58
Source/OSIF/include/api/seabreezeapi/SerialNumberFeatureAdapter.h Normal file
View File

@ -0,0 +1,58 @@
/***************************************************//**
* @file SerialNumberFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze SerialNumberFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_SERIALNUMBERFEATUREADAPTER_H
#define SEABREEZE_SERIALNUMBERFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/serial_number/SerialNumberFeatureInterface.h"
namespace seabreeze {
namespace api {
class SerialNumberFeatureAdapter
: public FeatureAdapterTemplate<SerialNumberFeatureInterface> {
public:
SerialNumberFeatureAdapter(SerialNumberFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~SerialNumberFeatureAdapter();
int getSerialNumber(int *errorCode, char *buffer, int buffer_length);
unsigned char getSerialNumberMaximumLength(int *errorCode);
};
}
}
#endif

56
Source/OSIF/include/api/seabreezeapi/ShutterFeatureAdapter.h Normal file
View File

@ -0,0 +1,56 @@
/***************************************************//**
* @file ShutterFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze ShutterFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_SHUTTERFEATUREADAPTER_H
#define SEABREEZE_SHUTTERFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/shutter/ShutterFeatureInterface.h"
namespace seabreeze {
namespace api {
class ShutterFeatureAdapter
: public FeatureAdapterTemplate<ShutterFeatureInterface> {
public:
ShutterFeatureAdapter(ShutterFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~ShutterFeatureAdapter();
void setShutterOpen(int *errorCode, bool open);
};
}
}
#endif

74
Source/OSIF/include/api/seabreezeapi/SpectrometerFeatureAdapter.h Normal file
View File

@ -0,0 +1,74 @@
/***************************************************//**
* @file SpectrometerFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze OOISpectrometerFeature instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_SPECTROMETER_FEATURE_ADAPTER_H
#define SEABREEZE_SPECTROMETER_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "common/buses/Bus.h"
#include "common/protocols/Protocol.h"
#include "vendors/OceanOptics/features/spectrometer/OOISpectrometerFeatureInterface.h"
namespace seabreeze {
namespace api {
class SpectrometerFeatureAdapter : public FeatureAdapterTemplate<OOISpectrometerFeatureInterface> {
public:
SpectrometerFeatureAdapter(
OOISpectrometerFeatureInterface *spec,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~SpectrometerFeatureAdapter();
/* Spectrometer commands */
int getUnformattedSpectrum(int *errorCode,
unsigned char *buffer, int bufferLength);
int getFormattedSpectrum(int *errorCode,
double* buffer, int bufferLength);
int getUnformattedSpectrumLength(int *errorCode);
int getFormattedSpectrumLength(int *errorCode);
void setTriggerMode(int *errorCode, int mode);
int getWavelengths(int *errorCode, double *wavelengths, int length);
int getElectricDarkPixelCount(int *errorCode);
int getElectricDarkPixelIndices(int *errorCode,
int *indices, int length);
void setIntegrationTimeMicros(int *errorCode,
unsigned long integrationTimeMicros);
long getMinimumIntegrationTimeMicros(int *errorCode);
long getMaximumIntegrationTimeMicros(int *errorCode);
double getMaximumIntensity(int *errorCode);
};
}
}
#endif

60
Source/OSIF/include/api/seabreezeapi/SpectrumProcessingFeatureAdapter.h Normal file
View File

@ -0,0 +1,60 @@
/***************************************************//**
* @file SpectrumProcessingFeatureAdapter.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a wrapper that allows
* access to SeaBreeze SpectrumProcessingFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_SPECTRUMPROCESSINGFEATUREADAPTER_H
#define SEABREEZE_SPECTRUMPROCESSINGFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/spectrum_processing/SpectrumProcessingFeatureInterface.h"
namespace seabreeze {
namespace api {
class SpectrumProcessingFeatureAdapter
: public FeatureAdapterTemplate<SpectrumProcessingFeatureInterface> {
public:
SpectrumProcessingFeatureAdapter(SpectrumProcessingFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~SpectrumProcessingFeatureAdapter();
unsigned char readSpectrumProcessingBoxcarWidth(int *errorCode);
unsigned short int readSpectrumProcessingScansToAverage(int *errorCode);
void writeSpectrumProcessingBoxcarWidth(int *errorCode, unsigned char boxcarWidth);
void writeSpectrumProcessingScansToAverage(int *errorCode, unsigned short int scansToAverage);
};
}
}
#endif

57
Source/OSIF/include/api/seabreezeapi/StrayLightCoeffsFeatureAdapter.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************//**
* @file StrayLightCoeffsFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze StrayLightCoeffFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_STRAYLIGHTCOEFFSFEATUREADAPTER_H
#define SEABREEZE_STRAYLIGHTCOEFFSFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/stray_light/StrayLightCoeffsFeatureInterface.h"
namespace seabreeze {
namespace api {
class StrayLightCoeffsFeatureAdapter
: public FeatureAdapterTemplate<StrayLightCoeffsFeatureInterface> {
public:
StrayLightCoeffsFeatureAdapter(StrayLightCoeffsFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~StrayLightCoeffsFeatureAdapter();
int readStrayLightCoeffs(int *errorCode, double *buffer,
int bufferLength);
};
}
}
#endif

56
Source/OSIF/include/api/seabreezeapi/StrobeLampFeatureAdapter.h Normal file
View File

@ -0,0 +1,56 @@
/***************************************************//**
* @file StrobeLampFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows
* access to SeaBreeze StrobeLampFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_STROBELAMPFEATUREADAPTER_H
#define SEABREEZE_STROBELAMPFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/light_source/StrobeLampFeatureInterface.h"
namespace seabreeze {
namespace api {
class StrobeLampFeatureAdapter
: public FeatureAdapterTemplate<StrobeLampFeatureInterface> {
public:
StrobeLampFeatureAdapter(StrobeLampFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~StrobeLampFeatureAdapter();
void setStrobeLampEnable(int *errorCode, bool enable);
};
}
}
#endif

58
Source/OSIF/include/api/seabreezeapi/TemperatureFeatureAdapter.h Normal file
View File

@ -0,0 +1,58 @@
/***************************************************//**
* @file TemperatureFeatureAdapter.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a wrapper that allows
* access to SeaBreeze TemperatureFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2015, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_TEMPERATUREFEATUREADAPTER_H
#define SEABREEZE_TEMPERATUREFEATUREADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/temperature/TemperatureFeatureInterface.h"
namespace seabreeze {
namespace api {
class TemperatureFeatureAdapter
: public FeatureAdapterTemplate<TemperatureFeatureInterface> {
public:
TemperatureFeatureAdapter(TemperatureFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~TemperatureFeatureAdapter();
unsigned char readTemperatureCount(int *errorCode);
double readTemperature(int *errorCode, int index);
int readAllTemperatures(int *errorCode, double *buffer, int bufferLength);
};
}
}
#endif

61
Source/OSIF/include/api/seabreezeapi/ThermoElectricCoolerFeatureAdapter.h Normal file
View File

@ -0,0 +1,61 @@
/***************************************************//**
* @file ThermoElectricCoolerFeatureAdapter.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This is a wrapper that allows access to SeaBreeze
* TECFeatureInterface instances.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_THERMO_ELECTRIC_COOLER_FEATURE_ADAPTER_H
#define SEABREEZE_THERMO_ELECTRIC_COOLER_FEATURE_ADAPTER_H
#include "api/seabreezeapi/FeatureAdapterTemplate.h"
#include "vendors/OceanOptics/features/thermoelectric/ThermoElectricFeatureInterface.h"
namespace seabreeze {
namespace api {
class ThermoElectricCoolerFeatureAdapter
: public FeatureAdapterTemplate<ThermoElectricFeatureInterface> {
public:
ThermoElectricCoolerFeatureAdapter(ThermoElectricFeatureInterface *intf,
const FeatureFamily &f,
Protocol *p, Bus *b, unsigned short instanceIndex);
virtual ~ThermoElectricCoolerFeatureAdapter();
/* Thermoelectric cooler functions */
double readTECTemperature(int *errorCode);
void setTECTemperature(int *errorCode,
double temperature_degrees_celsius);
void setTECEnable(int *errorCode, bool tecEnable);
void setTECFanEnable(int *errorCode, bool tecFanEnable);
};
}
}
#endif

63
Source/OSIF/include/common/ByteVector.h Normal file
View File

@ -0,0 +1,63 @@
/***************************************************//**
* @file ByteVector.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_BYTEVECTOR_H
#define SEABREEZE_BYTEVECTOR_H
#include "common/SeaBreeze.h"
#include "common/Data.h"
#include <vector>
namespace seabreeze {
class ByteVector : public Data {
public:
ByteVector();
/* Constructor that makes a copy of the given vector for internal use */
ByteVector(const std::vector<byte> &that);
virtual ~ByteVector();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
/* Get the data associated with this instance */
std::vector<byte> &getByteVector();
private:
std::vector<byte> *data;
};
}
#endif

62
Source/OSIF/include/common/Data.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file Data.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a sort of a wrapper class that can encapsulate
* different kinds of data that may be returned as the
* result of a protocol transfer. The idea is that the
* data being passed back up from the device probably needs
* to be in some specific form, but we need to be able
* to convert it to whatever the receiver can use.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_DATA_H
#define SEABREEZE_DATA_H
#include "common/SeaBreeze.h"
#include "common/UnitDescriptor.h"
#include <vector>
namespace seabreeze {
class Data {
public:
Data();
virtual ~Data();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
};
}
#endif

62
Source/OSIF/include/common/DoubleVector.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file DoubleVector.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_DOUBLEVECTOR_H
#define SEABREEZE_DOUBLEVECTOR_H
#include <vector>
#include "common/SeaBreeze.h"
#include "common/Data.h"
namespace seabreeze {
class DoubleVector : public Data {
public:
DoubleVector();
DoubleVector(const std::vector<double> &that);
virtual ~DoubleVector();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
/* Get the data associated with this instance */
std::vector<double> &getDoubleVector();
private:
std::vector<double> *data;
};
}
#endif

62
Source/OSIF/include/common/FloatVector.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file FloatVector.h
* @date March 2010
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_FLOATVECTOR_H
#define SEABREEZE_FLOATVECTOR_H
#include <vector>
#include "common/SeaBreeze.h"
#include "common/Data.h"
namespace seabreeze {
class FloatVector : public Data {
public:
FloatVector();
FloatVector(const std::vector<float> &that);
virtual ~FloatVector();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
/* Get the data associated with this instance */
std::vector<float> &getFloatVector();
private:
std::vector<float> *data;
};
}
#endif

132
Source/OSIF/include/common/Log.h Normal file
View File

@ -0,0 +1,132 @@
/**
@file Log.h
@brief Interface to Log
@author Mark Zieg <mark.zieg@oceanoptics.com>
LICENSE:
SeaBreeze Copyright (C) 2014, Ocean Optics Inc
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject
to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef SEABREEZE_LOG_H
#define SEABREEZE_LOG_H
#include "api/DllDecl.h"
#include <string>
#include <stack>
#include <stdio.h>
#include <stdarg.h>
#ifdef OOI_DEBUG
#define OOI_LOG_PRINT 1
#else
#define OOI_LOG_PRINT 0
#endif
#ifdef __cplusplus
/**
* @brief instantiate logger in the current function
* @param s (Input) function name (typically __FUNCTION__)
*/
#define LOG(s) Log logger(s);
/**
* @brief log a printf string (and optional arguments) if debugging is enabled
* @note double parens: call as LOG_DEBUG(("variable x is %d, y is %f", x, y));
* @see http://stackoverflow.com/questions/1644868/c-define-macro-for-debug-printing
*/
#define LOG_DEBUG(s) do { if (OOI_LOG_PRINT) logger.debug s; } while (0)
//! @see LOG_DEBUG
#define LOG_INFO(s) do { if (OOI_LOG_PRINT) logger.info s; } while (0)
//! @see LOG_DEBUG
#define LOG_WARN(s) do { if (OOI_LOG_PRINT) logger.warn s; } while (0)
//! @see LOG_DEBUG
#define LOG_ERROR(s) do { if (OOI_LOG_PRINT) logger.error s; } while (0)
#define OOI_LOG_LEVEL_NEVER 0
#define OOI_LOG_LEVEL_ERROR 1
#define OOI_LOG_LEVEL_WARN 2
#define OOI_LOG_LEVEL_INFO 3
#define OOI_LOG_LEVEL_DEBUG 4
#define OOI_LOG_LEVEL_TRACE 5
/**
* @brief Simple logger for OOI applications.
* @todo Provide better thread support (hard to tell what thread model
* the caller may be using...)
* @todo Provide flat C interface (e.g. for NativeUSBWinUSB.c, test apps)
*
* Provides automatic heirarchical call-stack indentation.
*/
class DLL_DECL Log
{
public:
Log(const char *s);
~Log();
// public class methods
static void setLogLevel(int lvl);
static void setLogLevel(const std::string& s);
static void setLogFile(void *f);
// public instance methods
void debug(const char *fmt, ...);
void info (const char *fmt, ...);
void warn (const char *fmt, ...);
void error(const char *fmt, ...);
// these must be public for C interface to work
static unsigned logLevel;
void formatAndSend(int lvl, const char *lvlName,
const char *separator, const char *fmt, va_list args);
private:
// private class attributes
static FILE *logFile;
static std::stack<std::string>* callstack;
// private instance methods
void trace(const char *fmt, ...);
};
extern "C" {
#endif /* __cplusplus */
// We need the flattened C interface if we want to call from Cygwin (mainly
// to set log level)...see http://cygwin.com/ml/cygwin/2006-04/msg00251.html
void DLL_DECL seabreeze_log_set_level_int(int lvl);
void DLL_DECL seabreeze_log_set_level_string(const char *s);
void DLL_DECL seabreeze_log_debug(const char *fmt, ...);
void DLL_DECL seabreeze_log_info (const char *fmt, ...);
void DLL_DECL seabreeze_log_warn (const char *fmt, ...);
void DLL_DECL seabreeze_log_error(const char *fmt, ...);
#ifdef __cplusplus
};
#endif /* __cplusplus */
#endif

45
Source/OSIF/include/common/SeaBreeze.h Normal file
View File

@ -0,0 +1,45 @@
/***************************************************//**
* @file SeaBreeze.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This provides some project-wide constants and definitions.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_H
#define SEABREEZE_H
typedef unsigned char byte;
#ifdef WINDOWS
/* Visual studio does not implement declared exception
* specification but accepts it with a warning. This
* suppresses the warning (4290).
*/
#pragma warning( disable : 4290 )
#endif /* WINDOWS */
#endif /* SEABREEZE_H */

77
Source/OSIF/include/common/U32Vector.h Normal file
View File

@ -0,0 +1,77 @@
/***************************************************//**
* @file U32Vector.h
* @date September 2013
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_U32VECTOR_H
#define SEABREEZE_U32VECTOR_H
#include <vector>
#include "common/SeaBreeze.h"
#include "common/Data.h"
/* This class requires a 32-bit integer type. This will need a little help
* to know what the target machine is, so this tries to work it out.
*/
#ifdef _MSC_VER
/* Visual Studio */
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
#else
/* C99 compatible */
#include <stdint.h>
#endif
namespace seabreeze {
class U32Vector : public Data {
public:
U32Vector();
/* Constructor that makes a copy of the given vector for internal use */
U32Vector(const std::vector<uint32_t> &that);
U32Vector(unsigned int length);
virtual ~U32Vector();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
/* Get the data associated with this instance */
std::vector<uint32_t> &getU32Vector();
private:
std::vector<uint32_t> *data;
};
}
#endif

64
Source/OSIF/include/common/UShortVector.h Normal file
View File

@ -0,0 +1,64 @@
/***************************************************//**
* @file UShortVector.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_USHORTVECTOR_H
#define SEABREEZE_USHORTVECTOR_H
#include <vector>
#include "common/SeaBreeze.h"
#include "common/Data.h"
namespace seabreeze {
class UShortVector : public Data {
public:
UShortVector();
/* Constructor that makes a copy of the given vector for internal use */
UShortVector(const std::vector<unsigned short> &that);
UShortVector(unsigned int length);
virtual ~UShortVector();
/* Dimensionality of data. 0 for scalar, 1 for vector,
* 2 for a pair of related vectors (e.g. [X, Y] or matrix),
* 3 for 3D, etc.
*/
virtual int getNumberOfDimensions();
/* Get all of the unit descriptors associated with this Data. */
virtual std::vector<UnitDescriptor *> *getUnits();
/* Get the data associated with this instance */
std::vector<unsigned short> &getUShortVector();
private:
std::vector<unsigned short> *data;
};
}
#endif

46
Source/OSIF/include/common/UnitDescriptor.h Normal file
View File

@ -0,0 +1,46 @@
/***************************************************//**
* @file UnitDescriptor.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_UNITDESCRIPTOR_H
#define SEABREEZE_UNITDESCRIPTOR_H
namespace seabreeze {
class UnitDescriptor {
public:
UnitDescriptor();
~UnitDescriptor();
/* FIXME: need to define unit property getters */
};
}
#endif

66
Source/OSIF/include/common/buses/Bus.h Normal file
View File

@ -0,0 +1,66 @@
/***************************************************//**
* @file Bus.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This provides a base class for all sorts of buses. A bus
* is a mechanism for transferring a stream of data from one
* point to another. The bus does not concern itself with the
* contents of the data stream. At most, it may use hints to
* determine how a particular message will be moved if this
* is necessary to complete the operation.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_BUS_H
#define SEABREEZE_BUS_H
#include "common/protocols/ProtocolHint.h"
#include "common/buses/TransferHelper.h"
#include "common/buses/BusFamily.h"
#include "common/buses/DeviceLocatorInterface.h"
#include "common/exceptions/IllegalArgumentException.h"
namespace seabreeze {
class Bus {
public:
Bus();
virtual ~Bus();
virtual TransferHelper *getHelper(const std::vector<ProtocolHint *> &hints) const = 0;
virtual BusFamily getBusFamily() const = 0;
/* Associate this Bus instance with a particular device location.
* This MUST be done before open or close can be used.
*/
virtual void setLocation(const DeviceLocatorInterface &location)
throw (IllegalArgumentException) = 0;
virtual bool open() = 0;
virtual void close() = 0;
virtual DeviceLocatorInterface *getLocation() = 0;
};
}
#endif

86
Source/OSIF/include/common/buses/BusFamilies.h Normal file
View File

@ -0,0 +1,86 @@
/***************************************************//**
* @file BusFamilies.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This provides a way to get references to different kinds of buses
* (e.g. USB, Ethernet, serial) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef BUSFAMILIES_H
#define BUSFAMILIES_H
#include "common/buses/BusFamily.h"
#include <vector>
namespace seabreeze {
class USBBusFamily : public BusFamily {
public:
USBBusFamily();
virtual ~USBBusFamily();
};
class EthernetBusFamily : public BusFamily {
public:
EthernetBusFamily();
virtual ~EthernetBusFamily();
};
class RS232BusFamily : public BusFamily {
public:
RS232BusFamily();
virtual ~RS232BusFamily();
};
class TCPIPv4BusFamily : public BusFamily {
public:
TCPIPv4BusFamily();
virtual ~TCPIPv4BusFamily();
};
class UDPIPv4BusFamily : public BusFamily {
public:
UDPIPv4BusFamily();
virtual ~UDPIPv4BusFamily();
};
class BusFamilies {
public:
const USBBusFamily USB;
const EthernetBusFamily ETHERNET;
const RS232BusFamily RS232;
const TCPIPv4BusFamily TCPIPv4;
const UDPIPv4BusFamily UDPIPv4;
BusFamilies();
~BusFamilies();
std::vector<BusFamily *> getAllBusFamilies();
};
}
#endif /* BUSFAMILIES_H */

54
Source/OSIF/include/common/buses/BusFamily.h Normal file
View File

@ -0,0 +1,54 @@
/***************************************************//**
* @file BusFamily.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This provides a way to describe different kinds of buses
* (e.g. USB, Ethernet, serial) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef BUSFAMILY_H
#define BUSFAMILY_H
#include <string>
namespace seabreeze {
class BusFamily {
public:
virtual ~BusFamily();
virtual std::string getName() const;
virtual bool equals(const BusFamily &that);
protected:
BusFamily(std::string name, int id);
private:
std::string busName;
int type;
};
}
#endif /* BUSFAMILY_H */

58
Source/OSIF/include/common/buses/DeviceLocationProberInterface.h Normal file
View File

@ -0,0 +1,58 @@
/***************************************************//**
* @file DeviceLocationProberInterface.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* DeviceLocatorInterface provides a base interface for
* classes that allow the location of a device to be
* probed in a bus-specific way.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef DEVICELOCATIONPROBERINTERFACE_H
#define DEVICELOCATIONPROBERINTERFACE_H
#include <vector>
#include "common/buses/DeviceLocatorInterface.h"
namespace seabreeze {
class DeviceLocationProberInterface {
public:
virtual ~DeviceLocationProberInterface() = 0;
/* Report how many devices of this type are available */
virtual std::vector<DeviceLocatorInterface *> *probeDevices() = 0;
protected:
DeviceLocationProberInterface();
};
/* Default implementation for (otherwise) pure virtual destructor */
inline DeviceLocationProberInterface::~DeviceLocationProberInterface() {}
}
#endif /* DEVICELOCATIONPROBERINTERFACE_H */

82
Source/OSIF/include/common/buses/DeviceLocatorInterface.h Normal file
View File

@ -0,0 +1,82 @@
/***************************************************//**
* @file DeviceLocatorInterface.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* DeviceLocatorInterface provides a base interface for
* classes that allow the location of a device to be
* specified in a bus-specific way. For instance, a
* USB DeviceLocator might include a device path or
* index, and a socket DeviceLocator might include an
* IP address and port number. This allows
* devices that cannot be identified by probing to still
* be found easily.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef DEVICELOCATORINTERFACE_H
#define DEVICELOCATORINTERFACE_H
#include <string>
#include "common/buses/BusFamily.h"
namespace seabreeze {
class DeviceLocatorInterface {
public:
virtual ~DeviceLocatorInterface() = 0;
/**
* Get a unique identifier for this location. This can be any value
* as long as it is globally unique.
*/
virtual unsigned long getUniqueLocation() const = 0;
/**
* Determine whether this DeviceLocator refers to the same device
* as another.
*/
virtual bool equals(DeviceLocatorInterface &that) = 0;
/**
* Get a human-readable string that describes the location
*/
virtual std::string getDescription() = 0;
/**
* Get a description of the type of bus that the device is associated with
*/
virtual BusFamily getBusFamily() const = 0;
/* Get an exact copy of this instance */
virtual DeviceLocatorInterface *clone() const = 0;
};
/* Default implementation for (otherwise) pure virtual destructor */
inline DeviceLocatorInterface::~DeviceLocatorInterface() {}
}
#endif /* DEVICELOCATORINTERFACE_H */

58
Source/OSIF/include/common/buses/TransferHelper.h Normal file
View File

@ -0,0 +1,58 @@
/***************************************************//**
* @file TransferHelper.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is effectively an interface for wrappers around bus
* activity. These wrappers may be selected from a Bus
* based on certain hints provided by a Protocol or its
* various Exchanges. All that this specifies is that a
* given object must be able to send() and receive() data
* across its particular (encapsulated) Bus.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_TRANSFERHELPER_H
#define SEABREEZE_TRANSFERHELPER_H
#include "common/SeaBreeze.h"
#include "common/exceptions/BusTransferException.h"
#include <vector>
namespace seabreeze {
class TransferHelper {
public:
TransferHelper();
virtual ~TransferHelper();
virtual int receive(std::vector<byte> &buffer, unsigned int length)
throw (BusTransferException) = 0;
virtual int send(const std::vector<byte> &buffer, unsigned int length) const
throw (BusTransferException) = 0;
};
}
#endif

75
Source/OSIF/include/common/buses/network/IPv4NetworkProtocol.h Normal file
View File

@ -0,0 +1,75 @@
/***************************************************//**
* @file IPv4NetworkProtocol.h
* @date February 2016
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2016, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_IPV4NETWORKPROTOCOL_H
#define SEABREEZE_IPV4NETWORKPROTOCOL_H
#include <string>
#include <vector>
namespace seabreeze {
class IPv4NetworkProtocol {
public:
virtual ~IPv4NetworkProtocol();
virtual std::string getName() const;
virtual bool equals(const IPv4NetworkProtocol &that) const;
protected:
IPv4NetworkProtocol(std::string name, int id);
private:
std::string protocolName;
int type;
};
class TCP_IPv4 : public IPv4NetworkProtocol {
public:
TCP_IPv4();
virtual ~TCP_IPv4();
};
class UDP_IPv4 : public IPv4NetworkProtocol {
public:
UDP_IPv4();
virtual ~UDP_IPv4();
};
class IPv4NetworkProtocols {
public:
const TCP_IPv4 TCP_IP4;
const UDP_IPv4 UDP_IP4;
IPv4NetworkProtocols();
~IPv4NetworkProtocols();
std::vector<IPv4NetworkProtocol *> getAllIPv4NetworkProtocols();
};
}
#endif /* SEABREEZE_IPV4NETWORKPROTOCOL_H */

66
Source/OSIF/include/common/buses/network/IPv4SocketDeviceLocator.h Normal file
View File

@ -0,0 +1,66 @@
/***************************************************//**
* @file IPv4SocketDeviceLocator.h
* @date February 2016
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2016, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_IPV4SOCKETDEVICELOCATOR_H
#define SEABREEZE_IPV4SOCKETDEVICELOCATOR_H
#include "common/buses/DeviceLocatorInterface.h"
#include "common/buses/network/IPv4NetworkProtocol.h"
#include <string>
namespace seabreeze {
class IPv4SocketDeviceLocator : public DeviceLocatorInterface {
public:
IPv4SocketDeviceLocator(const IPv4NetworkProtocol &proto, std::string ip,
int portNumber);
virtual ~IPv4SocketDeviceLocator();
std::string getIPv4Address();
int getPort();
IPv4NetworkProtocol getIPv4NetworkProtocol();
/* Inherited from DeviceLocatorInterface */
virtual unsigned long getUniqueLocation() const;
virtual bool equals(DeviceLocatorInterface &that);
virtual std::string getDescription();
virtual BusFamily getBusFamily() const;
virtual DeviceLocatorInterface *clone() const;
protected:
unsigned long computeLocationHash();
IPv4NetworkProtocol protocol;
std::string ipAddr;
int port;
unsigned long locationHash;
};
}
#endif /* SEABREEZE_IPV4SOCKETDEVICELOCATOR_H */

75
Source/OSIF/include/common/buses/network/TCPIPv4SocketBus.h Normal file
View File

@ -0,0 +1,75 @@
/***************************************************//**
* @file TCPIPv4SocketBus.h
* @date February 2016
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2016, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_TCPIPV4SOCKETBUS_H
#define SEABREEZE_TCPIPV4SOCKETBUS_H
#include "common/buses/Bus.h"
#include "common/exceptions/IllegalArgumentException.h"
#include "native/network/Socket.h"
#include <vector>
namespace seabreeze {
class TCPIPv4SocketBus : public Bus {
public:
TCPIPv4SocketBus();
virtual ~TCPIPv4SocketBus();
virtual Socket *getSocketDescriptor();
virtual BusFamily getBusFamily() const;
virtual void setLocation(const DeviceLocatorInterface &location)
throw (IllegalArgumentException);
virtual DeviceLocatorInterface *getLocation();
virtual TransferHelper *getHelper(
const std::vector<ProtocolHint *> &hints) const;
/* Pure virtual methods */
virtual bool open() = 0;
virtual void close() = 0;
protected:
void addHelper(ProtocolHint *hint, TransferHelper *helper);
void clearHelpers();
Socket *socket;
DeviceLocatorInterface *deviceLocator;
/* These vectors should really be in a map, but that didn't want to
* work easily. Since there will likely be about 2 entries in here,
* storing in a pair of vectors for now won't hurt anything.
*/
std::vector<ProtocolHint *> helperKeys;
std::vector<TransferHelper *> helperValues;
};
}
#endif /* SEABREEZE_TCPIPV4SOCKETBUS_H */

52
Source/OSIF/include/common/buses/network/TCPIPv4SocketTransferHelper.h Normal file
View File

@ -0,0 +1,52 @@
/***************************************************//**
* @file TCPIPv4SocketTransferHelper.h
* @date February 2016
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2016, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H
#define SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H
#include "common/buses/TransferHelper.h"
#include "native/network/Socket.h"
namespace seabreeze {
class TCPIPv4SocketTransferHelper : public TransferHelper {
public:
TCPIPv4SocketTransferHelper(Socket *sock);
virtual ~TCPIPv4SocketTransferHelper();
virtual int receive(std::vector<byte> &buffer, unsigned int length)
throw (BusTransferException);
virtual int send(const std::vector<byte> &buffer, unsigned int length) const
throw (BusTransferException);
protected:
Socket *socket;
};
}
#endif /* SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H */

65
Source/OSIF/include/common/buses/rs232/RS232DeviceLocator.h Normal file
View File

@ -0,0 +1,65 @@
/***************************************************//**
* @file RS232DeviceLocator.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This class encapsulates the information needed to open
* a device on an RS232 bus.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef RS232DEVICELOCATOR_H
#define RS232DEVICELOCATOR_H
#include "common/buses/DeviceLocatorInterface.h"
#include <string>
namespace seabreeze {
class RS232DeviceLocator : public DeviceLocatorInterface {
public:
RS232DeviceLocator(std::string devicePath, int baudRate);
virtual ~RS232DeviceLocator();
std::string &getDevicePath();
int getBaudRate();
/* Inherited from DeviceLocatorInterface */
virtual unsigned long getUniqueLocation() const;
virtual bool equals(DeviceLocatorInterface &that);
virtual std::string getDescription();
virtual BusFamily getBusFamily() const;
virtual DeviceLocatorInterface *clone() const;
private:
void computeLocationHash();
std::string devicePath;
int baudRate;
unsigned long locationHash;
};
}
#endif /* RS232DEVICELOCATOR_H */

63
Source/OSIF/include/common/buses/rs232/RS232Interface.h Normal file
View File

@ -0,0 +1,63 @@
/***************************************************//**
* @file RS232Interface.h
* @date April 2011
* @author Ocean Optics, Inc.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef RS232INTERFACE_H
#define RS232INTERFACE_H
#include "common/buses/Bus.h"
#include "native/rs232/NativeRS232.h"
#include "native/rs232/RS232.h"
#include "common/exceptions/IllegalArgumentException.h"
namespace seabreeze {
class RS232Interface : public Bus {
public:
RS232Interface();
virtual ~RS232Interface();
virtual RS232 *getRS232Descriptor();
virtual DeviceLocatorInterface *getLocation();
virtual void setLocation(const DeviceLocatorInterface &location)
throw (IllegalArgumentException);
virtual BusFamily getBusFamily() const;
/* Pure virtual methods */
virtual TransferHelper *getHelper(
const std::vector<ProtocolHint *> &hints) const = 0;
virtual bool open() = 0;
virtual void close() = 0;
protected:
RS232 *rs232;
DeviceLocatorInterface *deviceLocator;
};
}
#endif /* RS232INTERFACE_H */

65
Source/OSIF/include/common/buses/rs232/RS232TransferHelper.h Normal file
View File

@ -0,0 +1,65 @@
/***************************************************//**
* @file RS232TransferHelper.h
* @date April 2011
* @author Ocean Optics, Inc.
*
* This provides an abstraction around the RS232 bus.
* RS232 is pretty simple once the port is opened and
* configured, so this mostly just takes care of ensuring
* that all bytes are sent and received as required.
*
* This will effectively block on reads and writes until
* they are complete. A non-blocking transfer helper
* could be created to complement this if there was
* some need, but it is not clear who would be responsible
* for delayed reads or retransmits.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef RS232TRANSFERHELPER_H
#define RS232TRANSFERHELPER_H
#include "common/buses/TransferHelper.h"
#include "native/rs232/RS232.h"
namespace seabreeze {
class RS232TransferHelper : public TransferHelper {
public:
RS232TransferHelper(RS232 *rs232Descriptor);
virtual ~RS232TransferHelper();
virtual int receive(std::vector<byte> &buffer, unsigned int length)
throw (BusTransferException);
virtual int send(const std::vector<byte> &buffer, unsigned int length) const
throw (BusTransferException);
protected:
RS232 *rs232;
};
}
#endif /* USBTRANSFERHELPER_H */

59
Source/OSIF/include/common/buses/usb/USBDeviceLocator.h Normal file
View File

@ -0,0 +1,59 @@
/***************************************************//**
* @file USBDeviceLocator.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This class encapsulates the information needed to open
* a device on a USB bus.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef USBDEVICELOCATOR_H
#define USBDEVICELOCATOR_H
#include "common/buses/DeviceLocatorInterface.h"
#include <string>
namespace seabreeze {
class USBDeviceLocator : public DeviceLocatorInterface {
public:
USBDeviceLocator(unsigned long ID);
virtual ~USBDeviceLocator();
/* Inherited from DeviceLocatorInterface */
virtual unsigned long getUniqueLocation() const;
virtual bool equals(DeviceLocatorInterface &that);
virtual std::string getDescription();
virtual BusFamily getBusFamily() const;
virtual DeviceLocatorInterface *clone() const;
private:
unsigned long deviceID;
};
}
#endif /* USBDEVICELOCATOR_H */

64
Source/OSIF/include/common/buses/usb/USBInterface.h Normal file
View File

@ -0,0 +1,64 @@
/***************************************************//**
* @file USBInterface.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is an abstract base class intended to be an interface
* for USB control objects. This allows USB devices to
* be opened generically (just by providing the index of
* the device on the bus) without any concern for
* the vendor ID, product ID, or underlying USB implementation.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef USBINTERFACE_H
#define USBINTERFACE_H
#include "common/buses/Bus.h"
#include "native/usb/NativeUSB.h"
#include "native/usb/USB.h"
#include "common/exceptions/IllegalArgumentException.h"
namespace seabreeze {
class USBInterface : public Bus {
public:
USBInterface();
virtual ~USBInterface();
virtual USB *getUSBDescriptor() const;
virtual DeviceLocatorInterface *getLocation();
virtual void setLocation(const DeviceLocatorInterface &location) throw (IllegalArgumentException);
virtual BusFamily getBusFamily() const;
virtual bool open() = 0;
virtual void close() = 0;
protected:
USB *usb;
DeviceLocatorInterface *deviceLocator;
};
}
#endif /* USBINTERFACE_H */

66
Source/OSIF/include/common/buses/usb/USBTransferHelper.h Normal file
View File

@ -0,0 +1,66 @@
/***************************************************//**
* @file USBTransferHelper.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a TransferHelper intended for USB communications.
* Each USBTransferHelper must specify a sending and
* receiving endpoint, which will tend to vary according to
* the type of data transfer being conducted. This adapts
* the send() and receive() methods required of a TransferHelper
* according to a particular type of transfer, which may be
* inferred from a ProtocolHint.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef USBTRANSFERHELPER_H
#define USBTRANSFERHELPER_H
#include "common/buses/TransferHelper.h"
#include "native/usb/USB.h"
namespace seabreeze {
class USBTransferHelper : public TransferHelper {
public:
USBTransferHelper(USB *usbDescriptor, int sendEndpoint,
int receiveEndpoint);
USBTransferHelper(USB *usbDescriptor);
virtual ~USBTransferHelper();
virtual int receive(std::vector<byte> &buffer, unsigned int length)
throw (BusTransferException);
virtual int send(const std::vector<byte> &buffer, unsigned int length) const
throw (BusTransferException);
protected:
USB *usb;
int sendEndpoint;
int receiveEndpoint;
};
}
#endif /* USBTRANSFERHELPER_H */

129
Source/OSIF/include/common/devices/Device.h Normal file
View File

@ -0,0 +1,129 @@
/***************************************************//**
* @file Device.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a base class for all sorts of devices. A
* device is really just an aggregation of features
* with the protocols and buses required to access them.
* A Device is intended to represent a single discrete
* piece of equipment that may have several capabilities
* (features) inside. The device may communicate to the
* outside world via seqences of bytes (a protocol) that
* are transferred across a physical medium (the bus).
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef DEVICE_H
#define DEVICE_H
#include <vector>
#include <string>
#include "common/buses/Bus.h"
#include "common/buses/BusFamily.h"
#include "common/buses/DeviceLocatorInterface.h"
#include "common/features/Feature.h"
#include "common/features/FeatureFamily.h"
#include "common/protocols/Protocol.h"
// usb endpoints are associated with a particular device.
typedef enum usbEndpointType
{
kEndpointTypePrimaryOut, // slow speed
kEndpointTypePrimaryIn, // slow speed
kEndpointTypeSecondaryOut, // could be high speed
kEndpointTypeSecondaryIn, // could be high speed
kEndpointTypeSecondaryIn2 // generally high speed
} usbEndpointType;
namespace seabreeze {
class Device {
public:
Device();
virtual ~Device();
std::vector<Bus *> &getBuses();
std::vector<Feature *> &getFeatures();
std::vector<Protocol *> &getProtocols();
std::string &getName();
// get the usb endpoints, according to the endpointType enumerator,
// if the endpoint type is not used, a 0 is returned
// TODO: this should be delegated down into a Bus instance
// (e.g. found by getBusesByFamily()) for USB. It is inappropriate here.
unsigned char getEndpoint(int *errorCode, usbEndpointType endpointType);
/* This will allow the driver to probe the device and initialize itself
* based on what it finds there. This should be called shortly after
* open(). The Device instance should use the indicated Bus instance to
* communicate with the hardware and get everything set up. It can
* use any appropriate protocol or protocols that are valid for the Bus.
*/
virtual bool initialize(const Bus &bus);
/* Each instance of a device is assumed to be associated with a unique
* location on a bus. If the device is connected via multiple buses, then
* a special DeviceLocator and TransferHelper will have to hide those
* details. Otherwise, each connection to the device will be considered
* independent of all others.
*/
virtual DeviceLocatorInterface *getLocation();
virtual void setLocation(const DeviceLocatorInterface &loc);
virtual int open();
virtual void close();
virtual std::vector<Bus *> getBusesByFamily(BusFamily &family);
virtual seabreeze::ProtocolFamily getSupportedProtocol(
seabreeze::FeatureFamily family, BusFamily bus) = 0;
virtual std::vector<Protocol *> getProtocolsByFamily(
seabreeze::ProtocolFamily &family);
virtual Bus *getOpenedBus();
protected:
std::vector<Bus *> buses;
std::vector<Feature *> features;
std::vector<Protocol *> protocols;
std::string name;
unsigned char usbEndpoint_primary_out;
unsigned char usbEndpoint_primary_in;
unsigned char usbEndpoint_secondary_out;
unsigned char usbEndpoint_secondary_in;
unsigned char usbEndpoint_secondary_in2;
DeviceLocatorInterface *location;
Bus *openedBus;
};
}
#endif /* DEVICE_H */

49
Source/OSIF/include/common/exceptions/BusConnectException.h Normal file
View File

@ -0,0 +1,49 @@
/***************************************************//**
* @file BusConnectException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when an error is
* encountered when trying to connect to a bus,
* generally a failed open() or socket connect() call, or
* a failed read() or write() due to an EOF.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef BUSCONNECTEXCEPTION_H
#define BUSCONNECTEXCEPTION_H
#include "common/exceptions/BusException.h"
namespace seabreeze {
class BusConnectException : public BusException {
public:
BusConnectException(const std::string &error);
};
}
#endif /* BUSCONNECTEXCEPTION_H */

50
Source/OSIF/include/common/exceptions/BusException.h Normal file
View File

@ -0,0 +1,50 @@
/***************************************************//**
* @file BusException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a base class for a family of exceptions that
* arise from errors in bus transfers. These may be thrown
* at the bus layer, and all exceptions thrown at
* that layer must extend this class so that they can be
* uniformly handled.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_BUSEXCEPTION_H
#define SEABREEZE_BUSEXCEPTION_H
#include <stdexcept>
namespace seabreeze {
class BusException : public std::runtime_error {
public:
BusException(const std::string &error);
};
}
#endif

48
Source/OSIF/include/common/exceptions/BusTransferException.h Normal file
View File

@ -0,0 +1,48 @@
/***************************************************//**
* @file BusTransferException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when an error is
* encountered when trying to read from or write to
* a bus.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef BUSTRANSFEREXCEPTION_H
#define BUSTRANSFEREXCEPTION_H
#include "common/exceptions/BusException.h"
namespace seabreeze {
class BusTransferException : public BusException {
public:
BusTransferException(const std::string &error);
};
}
#endif /* BUSTRANSFEREXCEPTION_H */

47
Source/OSIF/include/common/exceptions/FeatureControlException.h Normal file
View File

@ -0,0 +1,47 @@
/***************************************************//**
* @file FeatureControlException.h
* @date March 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when an error is
* encountered when trying to interact with a feature.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef FEATURECONTROLEXCEPTION_H
#define FEATURECONTROLEXCEPTION_H
#include "common/exceptions/FeatureException.h"
namespace seabreeze {
class FeatureControlException : public FeatureException {
public:
FeatureControlException(const std::string &error);
};
}
#endif /* FEATURECONTROLEXCEPTION_H */

50
Source/OSIF/include/common/exceptions/FeatureException.h Normal file
View File

@ -0,0 +1,50 @@
/***************************************************//**
* @file FeatureException.h
* @date March 2009
* @author Ocean Optics, Inc.
*
* This is a base class for a family of exceptions that
* arise from errors in feature interaction. These may be thrown
* at the feature layer, and all exceptions thrown at
* that layer must extend this class so that they can be
* uniformly handled.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_FEATUREEXCEPTION_H
#define SEABREEZE_FEATUREEXCEPTION_H
#include <stdexcept>
namespace seabreeze {
class FeatureException : public std::runtime_error {
public:
FeatureException(const std::string &error);
};
}
#endif

48
Source/OSIF/include/common/exceptions/FeatureProtocolNotFoundException.h Normal file
View File

@ -0,0 +1,48 @@
/***************************************************//**
* @file FeatureProtocolNotFoundException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when a protocol is
* specified, but no matching implementation of that
* protocol can be found for a particular feature.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef FEATUREPROTOCOLNOTFOUNDEXCEPTION_H
#define FEATUREPROTOCOLNOTFOUNDEXCEPTION_H
#include "common/exceptions/FeatureException.h"
namespace seabreeze {
class FeatureProtocolNotFoundException : public FeatureException {
public:
FeatureProtocolNotFoundException(const std::string &error);
};
}
#endif /* FEATUREPROTOCOLNOTFOUNDEXCEPTION_H */

50
Source/OSIF/include/common/exceptions/IllegalArgumentException.h Normal file
View File

@ -0,0 +1,50 @@
/***************************************************//**
* @file IllegalArgumentException.h
* @date March 2009
* @author Ocean Optics, Inc.
*
* This is an exception for use when a value is passed to
* a method that is not permitted. This may include
* specifying a parameter that is out of bounds or of
* the wrong type.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_ILLEGALARGUMENTEXCEPTION_H
#define SEABREEZE_ILLEGALARGUMENTEXCEPTION_H
#include <stdexcept>
#include <string>
namespace seabreeze {
class IllegalArgumentException : public std::invalid_argument {
public:
IllegalArgumentException(const std::string &error);
};
}
#endif

49
Source/OSIF/include/common/exceptions/NumberFormatException.h Normal file
View File

@ -0,0 +1,49 @@
/***************************************************//**
* @file NumberFormatException.h
* @date March 2009
* @author Ocean Optics, Inc.
*
* This is an exception for use when a string is to be
* parsed into a number but the string does not contain
* a recognizable number.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_NUMBERFORMATEXCEPTION_H
#define SEABREEZE_NUMBERFORMATEXCEPTION_H
#include <stdexcept>
#include <string>
namespace seabreeze {
class NumberFormatException : public std::runtime_error {
public:
NumberFormatException(const std::string &error);
};
}
#endif

49
Source/OSIF/include/common/exceptions/ProtocolBusMismatchException.h Normal file
View File

@ -0,0 +1,49 @@
/***************************************************//**
* @file ProtocolBusMismatchException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when a protocol is
* specified, but the bus and protocol are not suited to
* each other (e.g. there is no bus helper for the hints
* the protocol can provide).
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef PROTOCOLBUSMISMATCHEXCEPTION_H
#define PROTOCOLBUSMISMATCHEXCEPTION_H
#include "common/exceptions/ProtocolException.h"
namespace seabreeze {
class ProtocolBusMismatchException : public ProtocolException {
public:
ProtocolBusMismatchException(const std::string &error);
};
}
#endif /* PROTOCOLBUSMISMATCHEXCEPTION_H */

51
Source/OSIF/include/common/exceptions/ProtocolException.h Normal file
View File

@ -0,0 +1,51 @@
/***************************************************//**
* @file ProtocolException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a base class for a family of exceptions that
* arise from errors in protocols. These may be thrown
* at the protocol layer, and all exceptions thrown at
* that layer must extend this class so that they can be
* uniformly handled.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOLEXCEPTION_H
#define SEABREEZE_PROTOCOLEXCEPTION_H
#include <stdexcept>
#include <string>
namespace seabreeze {
class ProtocolException : public std::runtime_error {
public:
ProtocolException(const std::string &error);
};
}
#endif

50
Source/OSIF/include/common/exceptions/ProtocolFormatException.h Normal file
View File

@ -0,0 +1,50 @@
/***************************************************//**
* @file ProtocolFormatException.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This exception should be used when a protocol message
* cannot be decoded, fails a checksum, or otherwise is
* out of spec. This may indicate that the driver is now
* out of synch with this code and that measures should be
* taken to re-establish communications.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef PROTOCOLFORMATEXCEPTION_H
#define PROTOCOLFORMATEXCEPTION_H
#include "common/exceptions/ProtocolException.h"
namespace seabreeze {
class ProtocolFormatException : public ProtocolException {
public:
ProtocolFormatException(const std::string &error);
};
}
#endif /* PROTOCOLFORMATEXCEPTION_H */

51
Source/OSIF/include/common/exceptions/ProtocolTransactionException.h Normal file
View File

@ -0,0 +1,51 @@
/***************************************************//**
* @file ProtocolTransactionException.h
* @date January 2015
* @author Ocean Optics, Inc., Kirk Clendinning, Heliospectra
*
* This is a base class for a family of exceptions that
* arise from errors in during OBPTransactions. These may be thrown
* at the protocol layer, and all exceptions thrown at
* that layer must extend this class so that they can be
* uniformly handled.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOLTRANSACTIONEXCEPTION_H
#define SEABREEZE_PROTOCOLTRANSACTIONEXCEPTION_H
#include <stdexcept>
#include <string>
namespace seabreeze {
class ProtocolTransactionException : public std::runtime_error {
public:
ProtocolTransactionException(const std::string &error);
};
}
#endif

71
Source/OSIF/include/common/features/Feature.h Normal file
View File

@ -0,0 +1,71 @@
/***************************************************//**
* @file Feature.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is an abstract interface that other feature types will
* implement. A Feature is taken to be some capability of
* a Device that is relatively self-contained. For instance,
* an analog output voltage would be a Feature. Features can
* also contain multiple functions; for instance, a TEC may
* be able to report a temperature, take a temperature as a
* set point, and turn on or off. These capabilities are
* interrelated, and would be considered a single feature.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef FEATURE_H
#define FEATURE_H
#include "common/SeaBreeze.h"
#include "common/buses/Bus.h"
#include "common/features/FeatureFamily.h"
#include "common/exceptions/FeatureException.h"
#include "common/protocols/Protocol.h"
#include <vector>
namespace seabreeze {
class Feature {
public:
virtual ~Feature() = 0;
/* Allow the object that represents a given feature to initialize
* itself by reading from the corresponding feature on the real
* device, and/or put the real device feature into a known state.
* This should return true if the feature is ready to be used, and false
* otherwise.
*/
virtual bool initialize(const Protocol &protocol, const Bus &bus)
throw (FeatureException) = 0;
virtual FeatureFamily getFeatureFamily() = 0;
};
/* Default implementation for (otherwise) pure virtual destructor */
inline Feature::~Feature() {}
}
#endif /* FEATURE_H */

56
Source/OSIF/include/common/features/FeatureFamily.h Normal file
View File

@ -0,0 +1,56 @@
/***************************************************//**
* @file FeatureFamily.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This provides a way to describe different kinds
* features (e.g. spectrometer, TEC) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_FEATUREFAMILY_H
#define SEABREEZE_FEATUREFAMILY_H
#include <string>
namespace seabreeze {
class FeatureFamily {
public:
FeatureFamily();
virtual ~FeatureFamily();
virtual std::string getName();
virtual bool equals(const FeatureFamily &that);
virtual unsigned short getType();
protected:
FeatureFamily(std::string name, unsigned short id);
private:
std::string featureName;
unsigned short type;
};
}
#endif

88
Source/OSIF/include/common/features/FeatureImpl.h Normal file
View File

@ -0,0 +1,88 @@
/***************************************************//**
* @file FeatureImpl.h
* @date March 2016
* @author Ocean Optics, Inc.
*
* This is a simple base class that other feature types will
* extend. A Feature is taken to be some capability of
* a Device that is relatively self-contained. For instance,
* an analog output voltage would be a Feature. Features can
* also contain multiple functions; for instance, a TEC may
* be able to report a temperature, take a temperature as a
* set point, and turn on or off. These capabilities are
* interrelated, and would be considered a single feature.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2016, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef FEATUREIMPL_H
#define FEATUREIMPL_H
#include "common/SeaBreeze.h"
#include "common/exceptions/FeatureProtocolNotFoundException.h"
#include "common/features/Feature.h"
#include "common/protocols/ProtocolHelper.h"
#include <vector>
namespace seabreeze {
/* This does virtual inheritance from Feature because it is assumed that
* in some cases there will be diamond inheritance. This will generally
* only happen where one top-level Feature is implemented by deriving from
* another Feature.
*/
class FeatureImpl : public virtual Feature {
public:
FeatureImpl();
virtual ~FeatureImpl();
/* Allow the object that represents a given feature to initialize
* itself by reading from the corresponding feature on the real
* device, and/or put the real device feature into a known state.
* Overriding this is not required. This should return true if
* the feature is ready to be used, and false otherwise.
*/
virtual bool initialize(const Protocol &protocol, const Bus &bus)
throw (FeatureException);
virtual FeatureFamily getFeatureFamily() = 0;
protected:
std::vector<ProtocolHelper *> protocols;
/* Protocols are described by their base class (Protocol)
* and may be designated that way. However, different
* functionality within a given command set may be broken
* into different implementation types, all of which extend
* the base Protocol class. This is a simple lookup mechanism
* to use the Protocol that some anonymous caller might
* provide as a point of reference to then find the extended
* Protocol class that can be used to access certain features.
*/
ProtocolHelper *lookupProtocolImpl(const Protocol &protocol)
throw (FeatureProtocolNotFoundException);
};
}
#endif /* FEATUREIMPL_H */

65
Source/OSIF/include/common/globals.h Normal file
View File

@ -0,0 +1,65 @@
/**
* @file globals.h
* @author Mark Zieg <mark.zieg@oceanoptics.com>
* @date Sep 26, 2012
* @brief Provides a single point of maintenance for anything you want
* included, defined, or set across every file in the application
* (such as memory profiling, etc). Normally empty.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef SEABREEZE_GLOBALS_H
#define SEABREEZE_GLOBALS_H
// change to "#if 1" to enable memory heap debugging under Visual Studio
#if 0
#ifdef _WINDOWS
// For these to work right, you need to #define _CRTDBG_MAP_ALLOC and
// _CRTDBG_MAP_ALLOC_NEW in your Visual Studio project (i.e., Project
// -> Configuration Properties -> C/C++ -> Preprocessor -> Preprocessor
// Definitions). #Defining them here in your header files DOES NOT
// WORK, because Visual Studio will internally include many system
// headers (including stdafx.h) long before you get here.
//
// @see http://msdn.microsoft.com/en-us/library/e5ewb1h3%28v=vs.80%29.aspx
// @see http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/ebc7dd7a-f3c6-49f1-8a60-e381052f21b6,
#pragma message(" (Windows memory debugging enabled)")
// these will provide leak profiling for C malloc(), etc
#include <stdlib.h>
#include <crtdbg.h>
// these will provide leak profiling for C++ 'new'
#ifndef DBG_NEW
#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
#define new DBG_NEW
#endif
#endif
#endif
#endif

59
Source/OSIF/include/common/protocols/Exchange.h Normal file
View File

@ -0,0 +1,59 @@
/***************************************************//**
* @file Exchange.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is simply an interface that other classes will
* extend to have a common transfer() and getHints methods
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_EXCHANGE_H
#define SEABREEZE_EXCHANGE_H
#include <vector>
#include "common/buses/TransferHelper.h"
#include "common/protocols/ProtocolHint.h"
#include "common/Data.h"
#include "common/exceptions/ProtocolException.h"
namespace seabreeze {
class Exchange {
public:
Exchange();
Exchange(std::vector<ProtocolHint *> *hints);
virtual ~Exchange();
virtual Data *transfer(TransferHelper *helper) throw (ProtocolException) = 0;
virtual const std::vector<ProtocolHint *> &getHints();
protected:
std::vector<ProtocolHint *> *hints;
};
}
#endif /* SEABREEZE_EXCHANGE_H */

62
Source/OSIF/include/common/protocols/Protocol.h Normal file
View File

@ -0,0 +1,62 @@
/***************************************************//**
* @file Protocol.h
* @date February 2009
* @author Ocean Optics, Inc.
*
* This is a simple identifier cookie that will allow two
* objects to agree on whether they support a given command
* set (protocol). Each will hold Protocol objects that they
* can then compare to see if they agree. This allows a loose
* binding between sets of Exchanges (elsewhere called protocols)
* and buses.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOL_H
#define SEABREEZE_PROTOCOL_H
#include "common/protocols/ProtocolFamily.h"
namespace seabreeze {
class Protocol {
public:
Protocol(int id);
/* Copy constructor */
Protocol(Protocol const &that);
virtual ~Protocol();
bool equals(Protocol const &that);
virtual ProtocolFamily getProtocolFamily() = 0;
protected:
/* Protected for derived classes to use. */
Protocol();
int id;
};
}
#endif

55
Source/OSIF/include/common/protocols/ProtocolFamily.h Normal file
View File

@ -0,0 +1,55 @@
/***************************************************//**
* @file ProtocolFamily.h
* @date February 2012
* @author Ocean Optics, Inc.
*
* This provides a way to describe different kinds
* protocols (e.g. OOI, OBP) generically.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOLFAMILY_H
#define SEABREEZE_PROTOCOLFAMILY_H
#include <string>
namespace seabreeze {
class ProtocolFamily {
public:
virtual ~ProtocolFamily();
virtual std::string getName();
virtual bool equals(const ProtocolFamily &that);
virtual unsigned short getType();
protected:
ProtocolFamily(std::string name, unsigned short id);
private:
std::string protocolName;
unsigned short type;
};
}
#endif

60
Source/OSIF/include/common/protocols/ProtocolHelper.h Normal file
View File

@ -0,0 +1,60 @@
/***************************************************//**
* @file ProtocolHelper.h
* @date July 2009
* @author Ocean Optics, Inc.
*
* Feature instances may look up an implementation object
* that matches a particular Protocol. All such implementations
* should in some way derive from ProtocolHelper so that
* Feature's look up mechanism can return them. It is
* expected that each Feature will have a corresponding
* interface at the Protocol layer; those interface classes
* should derive from this class, and their implementations
* will thus extend this as well.
*
* LICENSE:
*
* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************/
#ifndef SEABREEZE_PROTOCOLHELPER_H
#define SEABREEZE_PROTOCOLHELPER_H
#include "common/protocols/Protocol.h"
namespace seabreeze {
class ProtocolHelper {
public:
ProtocolHelper(Protocol *proto);
virtual ~ProtocolHelper();
Protocol &getProtocol();
protected:
/* Protected for derived classes to use. */
ProtocolHelper();
Protocol *protocol;
};
}
#endif

Some files were not shown because too many files have changed in this diff Show More