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

first commnit

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

52
othersoft/calibration_console/CMakeLists.txt Normal file
View File

@ -0,0 +1,52 @@
cmake_minimum_required(VERSION 3.5)
project(ocean_optics_calibration_console)#ocean_optics_calibration_console
#编译32位的程序
#option(USE_32BITS "Compile for 32bits processors(linux only)" OFF)
#
#
#if(USE_32BITS)
# message(STATUS "using 32bits")
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
#
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
#else()
#endif(USE_32BITS)
set(CMAKE_CXX_STANDARD 14)
SET(CMAKE_INSTALL_PREFIX < /home/pi/bin >)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_PREFIX_PATH "/home/iris-xport/Qt5.9.0/5.9/gcc_64/")#tc_add: https://blog.csdn.net/aiyun5666/article/details/101915628
set(QT Core Network SerialPort)
set(TEMPLATE app)
set(TARGET ximeaImageRecorder)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
find_package(Qt5 REQUIRED ${QT})
#include_directories(/home/iris-xport/projects/ocean/seabreeze-3.0.11/SeaBreeze/include/)
#LINK_DIRECTORIES(/home/iris-xport/projects/ocean/seabreeze-3.0.11/SeaBreeze/lib/)
include_directories(/home/pi/SeaBrease/include/)
LINK_DIRECTORIES(/home/pi/SeaBrease/lib/)
include_directories(.)#包含头文件
include_directories(/usr/include/eigen3)#包含头文件，安装eigen：sudo apt-get install libeigen3-dev
file(GLOB_RECURSE SRC_h ./Header_Files/*.h)
file(GLOB_RECURSE SRC_CPP ./Source_Files/*.cpp)
add_executable(${CMAKE_PROJECT_NAME} ${SRC_h} ${SRC_CPP})
qt5_use_modules(${CMAKE_PROJECT_NAME} ${QT})
TARGET_LINK_LIBRARIES(${CMAKE_PROJECT_NAME}
seabreeze
usb
)

102
othersoft/calibration_console/Header_Files/ATPControl_Serial_QT.h Normal file
View File

@ -0,0 +1,102 @@
//////////////////////////////////////////////////////////////////////////
//ATP<54><50><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
//#include "pch.h"
#include "ZZ_Types.h"
#include "ZZ_Math.h"
#include <QSerialPort>
#include <QtEndian>
#include <QDebug>
#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);
private:
int SetAvgTimes(int iTimes = 1);
#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 RecvData_ShortLag(QByteArray &qbData);
int ParseData(QByteArray &qbData);
public slots:
int Init_Self();
signals:
void SignalInit_Self();
//private slots :
//void ReadMessage();
};

61
othersoft/calibration_console/Header_Files/FiberSpectrometerOperationBase.h Normal file
View File

@ -0,0 +1,61 @@
//
// Created by tangchao on 2022/1/11.
//
#ifndef OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H
#define OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H
#include "ZZ_Types.h"
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class FiberSpectrometerOperationBase
{
public:
// FiberSpectrometerOperationBase();
// ~FiberSpectrometerOperationBase();
virtual void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo) = 0;
virtual void disconnectFiberSpectrometer() = 0;
virtual void getDeviceAttribute(DeviceAttribute& deviceAttribute) = 0;
virtual void getDeviceInfo(DeviceInfo& deviceInfo) = 0;
virtual void setExposureTime(int iExposureTimeInMS) = 0;
virtual void getExposureTime(int &iExposureTimeInMS) = 0;
virtual void getDeviceTemperature(float &fTemperature) = 0;
virtual void singleShot(DataFrame &dfData) = 0;
// typedef struct coeffs
// {
// ZZ_U32 coeffsCounter;
// double coeffs[100];
// }coeffsFrame;
virtual void getNonlinearityCoeffs(coeffsFrame &coeffs) = 0;
// ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number) = 0;
DataFrame m_IntegratingSphereData;
DataFrame m_DarkData;
protected:
ZZ_U32 m_MaxValueOfFiberSpectrometer;
private:
public slots:
virtual void recordDark(QString path) = 0;
virtual void recordTarget(int recordTimes, QString path) = 0;
virtual void autoExpose() = 0;
signals:
void sendExposureTimeSignal(int exposureTime);
};
#endif //OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H

43
othersoft/calibration_console/Header_Files/IrisFiberSpectrometerBase.h Normal file
View File

@ -0,0 +1,43 @@
#include "QObject"
#include <string>
#include "ZZ_Types.h"
#pragma once
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class CIrisFSBase:public QObject
{
public:
//CIrisFSBase();
//virtual ~CIrisFSBase()= 0;
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;
};

121
othersoft/calibration_console/Header_Files/ZZ_Math.h Normal file
View File

@ -0,0 +1,121 @@
#include <utility>
#include <vector>
#//#include "Dense"
#include "Eigen/Dense"
#include <unsupported/Eigen/Splines>
#pragma once
namespace ZZ_MATH
{
template<typename T>
void MinHeapify(T*arry, int size, int element)
{
int lchild = element * 2 + 1, rchild = lchild + 1;
while (rchild < size)
{
if (arry[element] <= arry[lchild] && arry[element] <= arry[rchild])
{
return;
}
if (arry[lchild] <= arry[rchild])
{
std::swap(arry[element], arry[lchild]);
element = lchild;
}
else
{
std::swap(arry[element], arry[rchild]);
element = rchild;
}
lchild = element * 2 + 1;
rchild = lchild + 1;
}
if (lchild < size&&arry[lchild] < arry[element])
{
std::swap(arry[lchild], arry[element]);
}
return;
}
template<typename T>
void MaxHeapify(T*arry, int size, int element)
{
int lchild = element * 2 + 1, rchild = lchild + 1;
while (rchild < size)
{
if (arry[element] >= arry[lchild] && arry[element] >= arry[rchild])
{
return;
}
if (arry[lchild] >= arry[rchild])
{
std::swap(arry[element], arry[lchild]);
element = lchild;
}
else
{
std::swap(arry[element], arry[rchild]);
element = rchild;
}
lchild = element * 2 + 1;
rchild = lchild + 1;
}
if (lchild<size&&arry[lchild]>arry[element])
{
std::swap(arry[lchild], arry[element]);
}
return;
}
template<typename T>
void HeapSort(T*arry, int size)
{
int i;
for (i = size - 1; i >= 0; i--)
{
MinHeapify(arry, size, i);
}
while (size > 0)
{
std::swap(arry[size - 1], arry[0]);
size--;
MinHeapify(arry, size, 0);
}
return;
}
namespace PolyFit
{
void Eigen_Polyfit(const std::vector<double> &xv, const std::vector<double> &yv, std::vector<double> &coeff, int order);
double Eigen_Polyeval(std::vector<double> coeffs, double x);
};
namespace SplineFit
{
using namespace Eigen;
VectorXd Eigen_Normalize(const VectorXd &x);
void Test(std::vector<double> const &x_vec, std::vector<double> const &y_vec);// do not call
class SplineInterpolation
{
public:
SplineInterpolation(Eigen::VectorXd const &x_vec,Eigen::VectorXd const &y_vec);
double operator()(double x) const;
private:
double x_min;
double x_max;
double scaled_value(double x) const;
Eigen::RowVectorXd scaled_values(Eigen::VectorXd const &x_vec) const;
Eigen::Spline<double, 1> spline_;
};
};
};

354
othersoft/calibration_console/Header_Files/ZZ_Types.h Normal file
View File

@ -0,0 +1,354 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include <string>
#include <QTime>
#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 coeffs//tc<74><63><EFBFBD><EFBFBD>-----------------------
{
ZZ_U32 coeffsCounter;
double coeffs[100];
}coeffsFrame;
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,
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::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 == "ISIF")
{
return DeviceModel::ISIF;
}
else if (strDeviceModelName == "IS1")
{
return DeviceModel::IS1;
}
else if (strDeviceModelName == "IS2")
{
return DeviceModel::IS2;
}
else
{
return -1;
}
}
};
//ATP????<3F><>???
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
};
//???????<3F><>??
typedef struct tagATPDataFrame
{
unsigned short usExposureTime;
ZZ_U16 usData[4096];
float fTemperature;
double dTimes = 0;
}ATPDataFrame;
//?<3F><><EFBFBD><EFBFBD>??????<3F><>??
typedef struct tagATPDeviceInfo
{
std::string strPN;
std::string strSN;
}ATPDeviceInfo;
//?<3F><><EFBFBD><EFBFBD>????<3F><>?<3F><>??
typedef struct tagATPDeviceAttribute
{
int iPixels;
int iMaxIntegrationTime;
int iMinIntegrationTime;
float fWaveLength[4096];
}ATPDeviceAttribute;
//////////////////////////////////////////////////////////////////////////config file
}
//????????
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 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;
}
//?????????????<3F><>??
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;
}
};

53
othersoft/calibration_console/Header_Files/atpFiberImager.h Normal file
View File

@ -0,0 +1,53 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "ATPControl_Serial_QT.h"
#include "FiberSpectrometerOperationBase.h"
class ATPFiberImager :public QObject,public FiberSpectrometerOperationBase
{
Q_OBJECT
public:
ATPFiberImager(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);
~ATPFiberImager();
ZZ_ATPControl_Serial_Qt * m_FiberSpectrometer;
void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo);
void disconnectFiberSpectrometer();
void getDeviceAttribute(DeviceAttribute& deviceAttribute);
void getDeviceInfo(DeviceInfo& deviceInfo);
void setExposureTime(int iExposureTimeInMS);
void getExposureTime(int &iExposureTimeInMS);//ok
void getDeviceTemperature(float &fTemperature);//ok
void singleShot(DataFrame &dfData);
void getNonlinearityCoeffs(coeffsFrame &coeffs);
ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number);
// DataFrame m_IntegratingSphereData;
// DataFrame m_DarkData;
protected:
private:
std::string mUcPortNumber;
// ZZ_U32 m_MaxValueOfFiberSpectrometer;
public slots:
void recordDark(QString path);
void recordTarget(int recordTimes, QString path);
void autoExpose();
signals:
void sendExposureTimeSignal(int exposureTime);
};

51
othersoft/calibration_console/Header_Files/calibration.h Normal file
View File

@ -0,0 +1,51 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QFile>
#include <QDataStream>
#include <QFileInfo>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "ZZ_Types.h"
#include "ZZ_Math.h"
//#include "Dense"
#include "Eigen/Dense"
#include "unsupported/Eigen/Splines"
using namespace ZZ_MISCDEF::IRIS::FS;
class CalibrationAlgorithm :public QObject
{
Q_OBJECT
public:
CalibrationAlgorithm();
~CalibrationAlgorithm();
void readAndResample_StandardLightFile(QString filePath, int integratingSphereDetectorValue, DeviceAttribute deviceAttribute, DeviceInfo deviceInfo);//
void produceCalfile(QString calFilePath, DeviceAttribute deviceAttribute, DataFrame integratingSphereData, DataFrame darkData);
protected:
private:
double m_dStandardLightDataBase;//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC>Ļ<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
double * m_dStandardLightWavelength;
double * m_dStandardLightData;
double * m_dStandardLightWavelengthResampled;
double * m_dStandardLightDataResampled;
double * m_gain;
double * m_offset;
public slots:
signals:
};

71
othersoft/calibration_console/Header_Files/library.h Normal file
View File

@ -0,0 +1,71 @@
#ifndef OCEAN_LIB_LIBRARY_H
#define OCEAN_LIB_LIBRARY_H
#include <cstdio>
#include <cstdlib>
#include <ctime>
//#include <unistd.h>
#include <chrono>
#include "api/SeaBreezeWrapper.h"
#include "IrisFiberSpectrometerBase.h"
#include "api/seabreezeapi/SeaBreezeAPI.h"
#include "api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.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);
void test_nonlinearity_coeffs_feature();
private:
int m_iSpectralmeterHandle;
DeviceInfo m_deviceInfo;
int m_iExposureTime;
bool isSuccess(char* resultStr);
string GetDeviceType(int index);
string GetSerialNumber(int index);
};
#endif //OCEAN_LIB_LIBRARY_H

58
othersoft/calibration_console/Header_Files/oceanOpticsFiberImager.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "library.h"
#include "FiberSpectrometerOperationBase.h"
class OceanOpticsFiberImager :public QObject,public FiberSpectrometerOperationBase
{
Q_OBJECT
public:
OceanOpticsFiberImager(double * nonlinearityCoeffs, int numberOfCoeffs);
~OceanOpticsFiberImager();
OceanOptics_lib * m_FiberSpectrometer;
void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo);
void disconnectFiberSpectrometer();
void getDeviceAttribute(DeviceAttribute& deviceAttribute);
void getDeviceInfo(DeviceInfo& deviceInfo);
void setExposureTime(int iExposureTimeInMS);
void getExposureTime(int &iExposureTimeInMS);//ok
void getDeviceTemperature(float &fTemperature);//ok
void singleShot(DataFrame &dfData);
void getNonlinearityCoeffs(coeffsFrame &coeffs);
ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD>ζ<EFBFBD><CEB6><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
DeviceInfo m_deviceInfo;
DeviceAttribute m_deviceAttribute;
// DataFrame m_IntegratingSphereData;
// DataFrame m_DarkData;
protected:
private:
double * m_nonlinearityCoeffs;
int m_iNumberOfNonlinearityCoeffs;
// ZZ_U32 m_MaxValueOfFiberSpectrometer;
public slots:
void recordDark(QString path);
void recordTarget(int recordTimes, QString path);
void autoExpose();
signals:
void sendExposureTimeSignal(int exposureTime);
};

886
othersoft/calibration_console/Source_Files/ATPControl_Serial_QT.cpp Normal file
View File

@ -0,0 +1,886 @@
//#include "pch.h"
#include "Header_Files/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();
SetAvgTimes(1);
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::SetAvgTimes(int iTimes /*= 1*/)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SET_AVERAGE_NUMBER);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:3";
return 3;
}
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(5000);
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)
{
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::RecvData_ShortLag(QByteArray &qbData)
{
qbData.clear();
qbData = m_pSerialPort->readAll();
int iCounter = 0;
while (qbData.size() < 4)
{
m_pSerialPort->waitForReadyRead(100);
QByteArray qbTemp = m_pSerialPort->readAll();
qbData.append(qbTemp);
if (iCounter > 6)
{
qDebug() << "Err:RecvData_ShortLag 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_ShortLag 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(100);
qbData.append(m_pSerialPort->readAll());
if (iCounter > 6)
{
qDebug() << "Err:RecvData_ShortLag 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)
{
qDebug() << "Err:RecvData_ShortLag 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(m_daDeviceAttr.iMinIntegrationTimeInMS);//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;
qDebug() << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>30<EFBFBD><EFBFBD>"<<endl;
break;
}
// fExposureTime = (float)m_daDeviceAttr.iMinIntegrationTimeInMS;
int tc_tmp;
GetExposureTime(tc_tmp);
fExposureTime=tc_tmp;
fTempExposureTime = fExposureTime;
iRes = SingleShot(dfTemp);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:2"<<endl;
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;
qDebug() << "1111111111111111111111111111111" << dTemp << endl;
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;
continue;
}
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 < m_daDeviceAttr.iMinIntegrationTimeInMS)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
bFlagIsLowerMinExposureTime = true;
qDebug() << "lower-----------------------"<<endl;
}
}
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)
{
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;
qDebug() << "-------------"<<m_iExposureTime<<endl;
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];
// }
}
dfData.usExposureTimeInMS = m_iExposureTime;
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_ShortLag(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;
// }

113
othersoft/calibration_console/Source_Files/ZZ_Math.cpp Normal file
View File

@ -0,0 +1,113 @@
//#include "pch.h"
#include "Header_Files/ZZ_Math.h"
void ZZ_MATH::PolyFit::Eigen_Polyfit(const std::vector<double> &xv, const std::vector<double> &yv, std::vector<double> &coeff, int order)
{
Eigen::MatrixXd A(xv.size(), order + 1);
Eigen::VectorXd yv_mapped = Eigen::VectorXd::Map(&yv.front(), yv.size());
Eigen::VectorXd result;
assert(xv.size() == yv.size());
assert(xv.size() >= order + 1);
for (size_t i = 0; i < xv.size(); i++)
{
for (size_t j = 0; j < order + 1; j++)
{
A(i, j) = pow(xv.at(i), j);
}
}
result = A.householderQr().solve(yv_mapped);
coeff.resize(order + 1);
for (size_t i = 0; i < order + 1; i++)
{
coeff[i] = result[i];
}
}
double ZZ_MATH::PolyFit::Eigen_Polyeval(std::vector<double> coeffs, double x)
{
double result = 0.0;
for (int i = 0; i < coeffs.size(); i++)
{
result += coeffs[i] * pow(x, i);
}
return result;
}
Eigen::VectorXd ZZ_MATH::SplineFit::Eigen_Normalize(const Eigen::VectorXd &x)
{
using namespace Eigen;
VectorXd x_norm;
x_norm.resize(x.size());
const double min = x.minCoeff();
const double max = x.maxCoeff();
for (int k = 0; k < x.size(); k++)
{
x_norm(k) = (x(k) - min) / (max - min);
}
return x_norm;
}
void ZZ_MATH::SplineFit::Test(std::vector<double> const &x_vec, std::vector<double> const &y_vec)
{
typedef Spline<double, 1> Spline1D;
typedef SplineFitting<Spline1D> Spline1DFitting;
//VectorXd vx,vy;
//vx.resize(x_vec.size());
//vy.resize(y_vec.size());
//vx.Map(&x_vec.front(), x_vec.size());
//vy.Map(&y_vec.front(), y_vec.size());
Eigen::VectorXd vx = Eigen::VectorXd::Map(&x_vec.front(), 5/*x_vec.size()*/);
Eigen::VectorXd vy = Eigen::VectorXd::Map(&y_vec.front(), 5/*y_vec.size()*/);
const double scale = 1 / (vx.maxCoeff() - vx.minCoeff());
const double scale_sq = scale * scale;
//VectorXd knots = Eigen_Normalize(vx);
//Spline1D spline = Spline1DFitting::Interpolate(vy.transpose(),3, knots);
//double a;
// a = spline.derivatives(0,1)(0);
//Eigen::VectorXd xvals(5);
//Eigen::VectorXd yvals(xvals.rows());
//xvals << 0, 1, 2,3,4;
//yvals << 0, 1, 4,9,16;
SplineInterpolation s(vx, vy);
}
ZZ_MATH::SplineFit::SplineInterpolation::SplineInterpolation(Eigen::VectorXd const &x_vec, Eigen::VectorXd const &y_vec):
x_min(x_vec.minCoeff()), x_max(x_vec.maxCoeff()),
spline_(Eigen::SplineFitting<Eigen::Spline<double, 1>>::
Interpolate(y_vec.transpose(), 3, scaled_values(x_vec)))
{
}
double ZZ_MATH::SplineFit::SplineInterpolation::operator()(double x) const
{
return spline_(scaled_value(x))(0);
}
double ZZ_MATH::SplineFit::SplineInterpolation::scaled_value(double x) const
{
return (x - x_min) / (x_max - x_min);
}
Eigen::RowVectorXd ZZ_MATH::SplineFit::SplineInterpolation::scaled_values(Eigen::VectorXd const &x_vec) const
{
return x_vec.unaryExpr([this](double x) { return scaled_value(x); }).transpose();
}

194
othersoft/calibration_console/Source_Files/atpFiberImager.cpp Normal file
View File

@ -0,0 +1,194 @@
#include "Header_Files/atpFiberImager.h"
ATPFiberImager::ATPFiberImager(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
m_FiberSpectrometer = NULL;
mUcPortNumber=ucPortNumber;
}
ATPFiberImager::~ATPFiberImager()
{
}
void ATPFiberImager::connectFiberSpectrometer(QString& SN, QString& pixelCount, QString& wavelengthInfo)
{
using namespace std;
m_FiberSpectrometer = new ZZ_ATPControl_Serial_Qt();
m_FiberSpectrometer->Initialize(false, mUcPortNumber, "OPTOSKY");
DeviceInfo deviceInfo;//
DeviceAttribute deviceAttribute;
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SN = QString::fromStdString(deviceInfo.strSN);
pixelCount = QString::number(deviceAttribute.iPixels);
wavelengthInfo = QString::number(deviceAttribute.fWaveLengthInNM[0]) + "--" + QString::number(deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1]);
m_FiberSpectrometer->SetDeviceTemperature(-10);
//<2F><><EFBFBD><EFBFBD>dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>
string qepro = "QEP";//?????????????????????????????????????????????????????????????????????????????????????????
string flame = "FLMS";//?????????????????????????????????????????????????????????????????????????????????????????
if (deviceInfo.strSN.find(qepro) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 200000;
}
else if (deviceInfo.strSN.find(flame) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 65535;
}
else//û<><C3BB><EFBFBD>ҵ<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
{
}
}
void ATPFiberImager::disconnectFiberSpectrometer()
{
m_FiberSpectrometer->Close();
}
void ATPFiberImager::getDeviceAttribute(DeviceAttribute& deviceAttribute)
{
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);
}
void ATPFiberImager::getDeviceInfo(DeviceInfo& deviceInfo)
{
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
}
void ATPFiberImager::setExposureTime(int iExposureTimeInMS)
{
m_FiberSpectrometer->SetExposureTime(iExposureTimeInMS);
}
void ATPFiberImager::getExposureTime(int &iExposureTimeInMS)
{
m_FiberSpectrometer->GetExposureTime(iExposureTimeInMS);
}
void ATPFiberImager::getDeviceTemperature(float &fTemperature)
{
m_FiberSpectrometer->GetDeviceTemperature(fTemperature);
}
void ATPFiberImager::singleShot(DataFrame &dfData)
{
m_FiberSpectrometer->SingleShot(dfData);
}
void ATPFiberImager::getNonlinearityCoeffs(coeffsFrame &coeffs)
{
printf("This is ATPFiberImager.\n");
}
void ATPFiberImager::recordDark(QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
singleShot(m_DarkData);
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_darkSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_DarkData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_DarkData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void ATPFiberImager::recordTarget(int recordTimes, QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
DataFrame integratingSphereData_tmp;
for (int i = 0; i < recordTimes; i++)
{
singleShot(integratingSphereData_tmp);
if (i == 0)//<2F><>integratingSphereData_tmp<6D>е<EFBFBD><D0B5>ع<EFBFBD>ʱ<EFBFBD>䡢<EFBFBD>¶ȵ<C2B6><C8B5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>m_IntegratingSphereData
{
m_IntegratingSphereData = integratingSphereData_tmp;
}
else
{
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] += integratingSphereData_tmp.lData[i];
}
}
}
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] = m_IntegratingSphereData.lData[i] / recordTimes;
}
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_integratingSphereSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_IntegratingSphereData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_IntegratingSphereData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void ATPFiberImager::autoExpose()
{
float fPredictedExposureTime;
m_FiberSpectrometer->PerformAutoExposure(0.6,0.9,fPredictedExposureTime);
}
ZZ_S32 ATPFiberImager::GetMaxValue(ZZ_S32 * dark, int number)
{
ZZ_S32 max = 0;
for (size_t i = 0; i < number; i++)
{
if (dark[i] > max)
{
max = dark[i];
}
}
//std::cout << "<22><>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>ֵΪ" << max << std::endl;
return max;
}

246
othersoft/calibration_console/Source_Files/calibration.cpp Normal file
View File

@ -0,0 +1,246 @@
#include "Header_Files/calibration.h"
CalibrationAlgorithm::CalibrationAlgorithm()
{
}
CalibrationAlgorithm::~CalibrationAlgorithm()
{
}
void CalibrationAlgorithm::readAndResample_StandardLightFile(QString filePath, int integratingSphereDetectorValue, DeviceAttribute deviceAttribute, DeviceInfo deviceInfo)
{
QFile file(filePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
std::cout << "<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>" << std::endl;
return;
}
//<2F><>ȡ<EFBFBD><C8A1>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int lineCount = 0;
while (!file.atEnd())
{
QByteArray tmp = file.readLine();
lineCount++;
}
double * StandardLightWavelength_tmp = new double[lineCount - 1];
double * StandardLightData_tmp = new double[lineCount - 1];
file.seek(0);
for (size_t i = 0; i < lineCount; i++)
{
QByteArray line = file.readLine();
QString str(line);
//cout << str.section('\t', 1).trimmed().toStdString() << endl;
if (i == 0)
{
QString first = str.section('\t', 0, 0);
m_dStandardLightDataBase = first.toDouble();
}
else
{
QString first = str.section('\t', 0, 0);
QString second = str.section('\t', 1, 1);
StandardLightWavelength_tmp[i - 1] = first.toDouble();
StandardLightData_tmp[i - 1] = second.toDouble();
//if (i== lineCount-1)//<2F>鿴<EFBFBD><E9BFB4><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD>ȷ
//{
// double xx = first.toDouble();
// double yy = second.toDouble();
// std::cout << "xx<78><78>" << xx <<std::endl;
// std::cout << "yy<79><79>" << yy << std::endl;
//}
}
}
//<2F><>ȡ<EFBFBD><C8A1>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>Ч<EFBFBD><D0A7>
int startPos, endPos;
int buffer = 3;//<2F><>Ҫ<EFBFBD><D2AA><EFBFBD>DZ<EFBFBD>׼<EFBFBD><D7BC>ԭʼ<D4AD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//QString biaozhundengfanwei = QString::number(StandardLightWavelength_tmp[0]) + "--" + QString::number(StandardLightWavelength_tmp[lineCount - 2]);
if (deviceAttribute.fWaveLengthInNM[0] < StandardLightWavelength_tmp[0])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>Χδ<CEA7><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
{
startPos = 0;
}
else
{
for (size_t i = 0; i < lineCount - 1; i++)
{
if (deviceAttribute.fWaveLengthInNM[0] < StandardLightWavelength_tmp[i])
{
startPos = i - buffer;
break;
}
}
}
if (deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1] > StandardLightWavelength_tmp[lineCount - 2])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>Χδ<CEA7><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>󲨳<EFBFBD>
{
endPos = lineCount - 2;
}
else
{
for (size_t i = 0; i < lineCount - 1; i++)
{
if (deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1] < StandardLightWavelength_tmp[i])
{
endPos = i + buffer;//??
break;
}
}
}
m_dStandardLightWavelength = new double[endPos - startPos];
m_dStandardLightData = new double[endPos - startPos];
for (size_t i = 0; i < endPos - startPos; i++)
{
m_dStandardLightWavelength[i] = StandardLightWavelength_tmp[i + startPos];
m_dStandardLightData[i] = StandardLightData_tmp[i + startPos];
}
// //<2F><><EFBFBD>ضϱ<D8B6>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QFileInfo fileInfo(filePath);
// QString standardLightFileFolder = fileInfo.path();
// QString standardLightFileName = fileInfo.fileName();
//
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString tmp = standardLightFileFolder + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) +"_"+ standardLightFileName + "_truncation.csv";
//
// std::ofstream outfile1(tmp.toStdString().c_str());
//
// for (size_t i = 0; i < endPos - startPos; i++)
// {
// if (i == 0)
// {
// outfile1 << m_dStandardLightDataBase << std::endl;
// }
//
// outfile1 << m_dStandardLightWavelength[i] << "," << m_dStandardLightData[i] << std::endl;
// }
// outfile1.close();
//<2F>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Eigen::VectorXd vx = Eigen::VectorXd::Map(m_dStandardLightWavelength, endPos - startPos/*x_vec.size()*/);
Eigen::VectorXd vy = Eigen::VectorXd::Map(m_dStandardLightData, endPos - startPos/*y_vec.size()*/);
using namespace ZZ_MATH::SplineFit;
SplineInterpolation m_sfLine(vx, vy);
m_dStandardLightWavelengthResampled = new double[deviceAttribute.iPixels];
m_dStandardLightDataResampled = new double[deviceAttribute.iPixels];
double dTemp,scaleFactor;
if(integratingSphereDetectorValue <= 0)
scaleFactor=1;
else
scaleFactor=integratingSphereDetectorValue/m_dStandardLightDataBase;
for (size_t i = 0; i < deviceAttribute.iPixels; i++)
{
if (deviceAttribute.fWaveLengthInNM[i] < StandardLightWavelength_tmp[0])//<2F>˲<EFBFBD><CBB2><EFBFBD> < <20><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
{
dTemp = m_sfLine(StandardLightWavelength_tmp[0]);//???????????????
}
else if (StandardLightWavelength_tmp[lineCount - 2] < deviceAttribute.fWaveLengthInNM[i])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>󲨳<EFBFBD> < <20>˲<EFBFBD><CBB2><EFBFBD>
{
dTemp = m_sfLine(StandardLightWavelength_tmp[lineCount - 2]);//???????????????
}
else
{
dTemp = m_sfLine(deviceAttribute.fWaveLengthInNM[i]);//?????
}
//double dTemp2 = m_sfLine(deviceAttribute.fWaveLengthInNM[i]);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ʹ<EFBFBD><CAB9>
m_dStandardLightWavelengthResampled[i] = deviceAttribute.fWaveLengthInNM[i];
m_dStandardLightDataResampled[i] = dTemp * scaleFactor;
}
// //<2F><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD>ı<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QString outputName = standardLightFileFolder + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_" + standardLightFileName + "_resample.csv";
// std::ofstream outfile2(outputName.toStdString().c_str());
// for (size_t i = 0; i < deviceAttribute.iPixels; i++)
// {
// if (i == 0)
// {
// outfile2 << m_dStandardLightDataBase << std::endl;
// }
//
// outfile2 << deviceAttribute.fWaveLengthInNM[i] << "," << m_dStandardLightDataResampled[i] << std::endl;
// }
// outfile2.close();
}
void CalibrationAlgorithm::produceCalfile(QString calFilePath, DeviceAttribute deviceAttribute, DataFrame integratingSphereData, DataFrame darkData)
{
using namespace ZZ_MISCDEF;//ZZ_U32
int errorCode;
size_t writeCounter;
double* m_gain = new double[deviceAttribute.iPixels];//double*
double* m_offset = new double[deviceAttribute.iPixels];//double*
for (size_t i = 0; i < deviceAttribute.iPixels; i++)
{
if (integratingSphereData.lData[i] - darkData.lData[i] == 0)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸΪ<C4B8><CEAA>
{
m_gain[i] = 0;
}
else
{
m_gain[i] = m_dStandardLightDataResampled[i] / (integratingSphereData.lData[i] - darkData.lData[i]);
}
m_offset[i] = 0;
}
//д<>뵽<EFBFBD><EBB5BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
FILE * calFileHandle = fopen(calFilePath.toStdString().c_str(), "wb");
writeCounter = fwrite(&integratingSphereData.usExposureTimeInMS,sizeof(ZZ_U32), 1, calFileHandle);//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1>
writeCounter = fwrite(&integratingSphereData.fTemperature, sizeof(float), 1, calFileHandle);//<2F><EFBFBD>
writeCounter = fwrite(&deviceAttribute.iPixels, sizeof(int), 1, calFileHandle);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
writeCounter = fwrite(&deviceAttribute.fWaveLengthInNM, sizeof(float), deviceAttribute.iPixels, calFileHandle);//<2F><><EFBFBD><EFBFBD>
writeCounter = fwrite(m_gain, sizeof(double), deviceAttribute.iPixels, calFileHandle);//gain
writeCounter = fwrite(m_offset, sizeof(double), deviceAttribute.iPixels, calFileHandle);//offset
fclose(calFileHandle);
//д<>뵽CSV<53>ļ<EFBFBD>
QString calFile_csv = calFilePath.split(".")[0] + ".csv";
std::ofstream outfile(calFile_csv.toStdString().c_str());
for (int i = 0; i < deviceAttribute.iPixels; i++)
{
if (i==0)
{
outfile << integratingSphereData.usExposureTimeInMS << std::endl;
}
outfile << deviceAttribute.fWaveLengthInNM[i] << "," << m_gain[i] << std::endl;
}
outfile.close();
delete[] m_gain;
}

635
othersoft/calibration_console/Source_Files/library.cpp Normal file
View File

@ -0,0 +1,635 @@
#include "Header_Files/library.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);
// 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;
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);
long test = seabreeze_get_buffer_capacity_minimum(m_iSpectralmeterHandle, &error);
printf("seabreeze_get_buffer_capacity_minimum: Result is [%s]\n", get_error_string(error));
seabreeze_set_buffer_capacity(m_iSpectralmeterHandle, &error, test);
printf("seabreeze_set_buffer_capacity: Result is [%s]\n", get_error_string(error));
// 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);
auto startTime = std::chrono::high_resolution_clock::now();
flag = seabreeze_get_formatted_spectrum(m_iSpectralmeterHandle, &error, spectrum, spec_length);
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> fp_ms = endTime - startTime;
std::cout << "<EFBFBD>ɼ<EFBFBD><EFBFBD><EFBFBD>ʱΪ<EFBFBD><EFBFBD>" << fp_ms.count() / 1000 << "s." << std::endl;
// 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_trigger_mode(m_iSpectralmeterHandle, &error, 0); // trigger to normal
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)
{
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 = minimum_time/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;
}
void OceanOptics_lib::test_nonlinearity_coeffs_feature()
{
using namespace seabreeze;
using namespace seabreeze::api;
using namespace std;
NonlinearityCoeffsFeatureAdapter tmp();
// int error = 0;
// int number_of_nonlinearity_coeff_features;
// long *nonlinearity_coeff_feature_ids = 0;
// double buffer[10];
// int i;
// int length;
//
// printf("\n\tTesting nonlinearity coefficient features:\n");
//
// printf("\t\tGetting number of nonlinearity coefficient features:\n");
// number_of_nonlinearity_coeff_features =
// sbapi_get_number_of_nonlinearity_coeffs_features(m_iSpectralmeterHandle, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
//
// if(0 == number_of_nonlinearity_coeff_features) {
// printf("\tNo nonlinearity coefficient capabilities found.\n");
//// tallyUnsupportedFeatures(unsupportedFeatureCount);
//
// return;
// }
//
// nonlinearity_coeff_feature_ids =
// (long *)calloc(number_of_nonlinearity_coeff_features, sizeof(long));
// printf("\t\tGetting nonlinearity coefficient feature IDs...\n");
// number_of_nonlinearity_coeff_features = sbapi_get_nonlinearity_coeffs_features(
// m_iSpectralmeterHandle, &error, nonlinearity_coeff_feature_ids,
// number_of_nonlinearity_coeff_features);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
//
// for(i = 0; i < number_of_nonlinearity_coeff_features; i++) {
// printf("\t\t%d: Testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, m_iSpectralmeterHandle, nonlinearity_coeff_feature_ids[i]);
//
// printf("\t\t\tAttempting to get nonlinearity coefficients...\n");
// memset(buffer, (int)0, sizeof(buffer));
// length = sbapi_nonlinearity_coeffs_get(m_iSpectralmeterHandle,
// nonlinearity_coeff_feature_ids[i], &error, buffer, 10);
// printf("\t\t\t\tResult is %d [%s]\n", length, sbapi_get_error_string(error));
//
// if(0 == error && length > 0) {
// printf("\t\t\t\tFirst calibration term: %1.2e\n", buffer[0]);
// }
//
// printf("\t\t%d: Finished testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, m_iSpectralmeterHandle, nonlinearity_coeff_feature_ids[i]);
// }
// free(nonlinearity_coeff_feature_ids);
//
// printf("\tFinished testing nonlinearity coefficient capabilities.\n");
}
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;
}

683
othersoft/calibration_console/Source_Files/main.cpp Normal file
View File

@ -0,0 +1,683 @@
#include <QtCore/QCoreApplication>
#include <QTextStream>
#include <QCommandLineParser>
#include <QDir>
#include <iostream>
#include "Header_Files/oceanOpticsFiberImager.h"
#include "Header_Files/atpFiberImager.h"
#include "Header_Files/calibration.h"
enum CommandLineParseResult
{
CommandLineOk,
CommandLineError,
CommandLineVersionRequested,
CommandLineHelpRequested
};
enum DeviceType
{
OPTOSKY,
OceanOptics,
UnknownDevice
};
struct TcQuery
{
DeviceType deviceType;
QString serialPort;
int sleepTimeinSecond;//<2F><>Ĭ<EFBFBD><C4AC>ֵ
int averageTimes;
int position;
int integratingSphereDetectorValue;
QString calFileOutputDirectory;//<2F><>Ĭ<EFBFBD><C4AC>ֵ
QString calFileOutputName;
QString standardLightFilePath;
bool justRecord;
};
CommandLineParseResult parseCommandLine2(QCommandLineParser &parser, TcQuery *query, QString *errorMessage);
bool copyFileToPath(QString sourceDir ,QString toDir, bool coverFileIfExist);
void logout(QString str);
void createDirectory(QString fullPath);
bool isFileExist(QString fullFileName);
int getNonlinearityCoeffs2(long deviceID, double * nonlinearityCoeffs);
int getNonlinearityCoeffs1(double * nonlinearityCoeffs);
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QCoreApplication::setApplicationName("Ocean optics radiance calibration software");
QCoreApplication::setApplicationVersion("1.0");
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
QCommandLineParser parser;
parser.setApplicationDescription("This software is used for doing radiance calibration for ocean optics fiber imager.");
TcQuery query;
QString errorMessage;
switch (parseCommandLine2(parser, &query, &errorMessage))
{
case CommandLineOk:
break;
case CommandLineError:
errorMessage = "<br><b style=\"color:red\">" + errorMessage + "s!</b>";
logout(errorMessage);
// fputs(qPrintable(errorMessage), stderr);
fputs("\n\n", stderr);
fputs(qPrintable(parser.helpText()), stderr);
return 1;
case CommandLineVersionRequested:
printf("%s %s\n", qPrintable(QCoreApplication::applicationName()),
qPrintable(QCoreApplication::applicationVersion()));
return 0;
case CommandLineHelpRequested:
parser.showHelp();
Q_UNREACHABLE();
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƕ<EFBFBD><C7B6><EFBFBD>
FiberSpectrometerOperationBase * m_FiberSpectrometer;
bool isOcean = false;
double * nonlinearityCoeffs;
int numberOfNonlinearityCoeffs;
switch (query.deviceType)
{
case OPTOSKY:
m_FiberSpectrometer = new ATPFiberImager(false,query.serialPort.toStdString(),"OPTOSKY");
break;
case OceanOptics:
{
//ʹ<><CAB9>sbapi<70><69>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѧ<EFBFBD><D1A7><EFBFBD><EFBFBD><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
nonlinearityCoeffs = new double[100];
numberOfNonlinearityCoeffs = getNonlinearityCoeffs1(nonlinearityCoeffs);
m_FiberSpectrometer = new OceanOpticsFiberImager(nonlinearityCoeffs, numberOfNonlinearityCoeffs);
isOcean = true;
break;
}
case UnknownDevice:
parser.showHelp();
Q_UNREACHABLE();
}
//<2F><><EFBFBD>ӹ<EFBFBD><D3B9><EFBFBD><EFBFBD><EFBFBD>
QString message;
QString SN;
QString pixelCount;
QString wavelengthInfo;
logout("<br><b style=\"color:red\">Connectting the fiber spectrometer!</b>");
m_FiberSpectrometer->connectFiberSpectrometer(SN, pixelCount, wavelengthInfo);
//<2F>Զ<EFBFBD><D4B6>ع<EFBFBD>
logout("<br><b style=\"color:red\">AutoExpose!</b>");
m_FiberSpectrometer->autoExpose();//
int iExposureTime;
m_FiberSpectrometer->getExposureTime(iExposureTime);
message="<br><b style=\"color:red\">ExposureTime: " + QString::number(iExposureTime) + "</b>";
logout(message);
//<2F><><EFBFBD><EFBFBD>sleep<65><70><EFBFBD>ȴ<EFBFBD><C8B4>رտ<D8B1><D5BF><EFBFBD>
message="<br><b style=\"color:red\">Please close the lamp in " + QString::number(query.sleepTimeinSecond) + "s!</b>";
logout(message);
QThread::sleep(query.sleepTimeinSecond);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
logout("<br><b style=\"color:red\">Record dark frame!</b>");
m_FiberSpectrometer->recordDark(query.calFileOutputDirectory);
//<2F><><EFBFBD><EFBFBD>sleep<65><70><EFBFBD>ȴ<EFBFBD><C8B4>򿪿<EFBFBD><F2BFAABF><EFBFBD>
message="<br><b style=\"color:red\">Please open the lamp in " + QString::number(query.sleepTimeinSecond) + "s!</b>";
logout(message);
QThread::sleep(query.sleepTimeinSecond);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
logout("<br><b style=\"color:red\">Record integrating sphere frame!</b>");
m_FiberSpectrometer->recordTarget(query.averageTimes, query.calFileOutputDirectory);
//׼<><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
logout("<br><b style=\"color:red\">readAndResample_StandardLightFile!</b>");
DeviceAttribute deviceAttribute;
DeviceInfo deviceInfo;
m_FiberSpectrometer->getDeviceAttribute(deviceAttribute);
m_FiberSpectrometer->getDeviceInfo(deviceInfo);
CalibrationAlgorithm * m_CalibrationAlgorithm = new CalibrationAlgorithm();
m_CalibrationAlgorithm->readAndResample_StandardLightFile(query.standardLightFilePath,query.integratingSphereDetectorValue, deviceAttribute, deviceInfo);
//<2F><><EFBFBD>ɷ<EFBFBD><C9B7>䶨<EFBFBD><E4B6A8><EFBFBD>ļ<EFBFBD>
if (query.calFileOutputName.isEmpty())//query->calFileOutputName==""
{
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString calFileName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + ".dat");
query.calFileOutputName=calFileName;
}
logout("<br><b style=\"color:red\">Produce calibration file!</b>");
m_CalibrationAlgorithm->produceCalfile(query.calFileOutputName, deviceAttribute, m_FiberSpectrometer->m_IntegratingSphereData, m_FiberSpectrometer->m_DarkData);
//<2F><><EFBFBD>Ʒ<EFBFBD><C6B7>䶨<EFBFBD><E4B6A8><EFBFBD>ļ<EFBFBD>
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString destName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_" +QString::number(query.position) + ".cal");
copyFileToPath(query.calFileOutputName,destName,true);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѧ<EFBFBD><D1A7><EFBFBD><EFBFBD><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
if (isOcean)
{
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString nonlinearityCoeffsName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + ".nonLinear");
// for (int i = 0; i < numberOfNonlinearityCoeffs; ++i)
// {
// printf("\n");
//
// printf("nonlinearityCoeffs(<28><>%d<><64>): %1.2e\n",i , nonlinearityCoeffs[i]);
//
// printf("\n");
// }
std::ofstream outfile(nonlinearityCoeffsName.toStdString().c_str());
for (int i = 0; i < numberOfNonlinearityCoeffs; i++)
{
outfile << nonlinearityCoeffs[i] << std::endl;
}
outfile.close();
free(nonlinearityCoeffs);
}
//<2F>Ͽ<EFBFBD><CFBF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
m_FiberSpectrometer->disconnectFiberSpectrometer();//Ҫ<><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֮<EFBFBD><D6AE><EFBFBD><EFBFBD>free(nonlinearityCoeffs);
//return a.exec();
}
CommandLineParseResult parseCommandLine2(QCommandLineParser &parser, TcQuery *query, QString *errorMessage)
{
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
QCommandLineOption deviceType("deviceType", "Device type. Options are OPTOSKY and OceanOptics", "deviceType");
parser.addOption(deviceType);
QCommandLineOption serialPort("serialPort", "Serial port.", "serialPort");
parser.addOption(serialPort);
QCommandLineOption sleepTimeinSecond("t", "The time app sleep.", "sleepTimeinSecond");
sleepTimeinSecond.setDefaultValue("30");//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD>
parser.addOption(sleepTimeinSecond);
QCommandLineOption averageTimes("a", "Average times.", "average_times");
averageTimes.setDefaultValue("5");//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD>
parser.addOption(averageTimes);//
QCommandLineOption position("position", "Position.", "position");
parser.addOption(position);
QCommandLineOption integratingSphereDetectorValue("integratingSphereDetectorValue", "integratingSphereDetectorValue.", "integratingSphereDetectorValue");
parser.addOption(integratingSphereDetectorValue);
// parser.addPositionalArgument("name", "The name to look up.");//????????????????????????????????????????????????????????????????????????????
QCommandLineOption helpOption = parser.addHelpOption();//Adds the help option (-h, --help and -? on Windows) This option is handled automatically by QCommandLineParser.
QCommandLineOption versionOption = parser.addVersionOption();//This option is handled automatically by QCommandLineParser.
//// A boolean option with a single name (-p)
//QCommandLineOption showProgressOption("p", QCoreApplication::translate("main", "Show progress during copy"));
//parser.addOption(showProgressOption);
// A boolean option with multiple names (-r, --record)
QCommandLineOption recordOption(QStringList() << "f" << "record",
QCoreApplication::translate("main", "Just record one spectral."));
parser.addOption(recordOption);
//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD>
QCommandLineOption standardLightFilePath(QStringList() << "slfp" << "standard-light-file-path",
QCoreApplication::translate("main", "set standard light file."),
QCoreApplication::translate("main", "file"));
parser.addOption(standardLightFilePath);
QCommandLineOption standardLightFileSelector(QStringList() << "slfs" << "standard-light-file-selector",
QCoreApplication::translate("main", "select standard light file."),
QCoreApplication::translate("main", "file"));
parser.addOption(standardLightFileSelector);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD><C2B7>
// An option with a value
QCommandLineOption calFileOutputDirectory(QStringList() << "cfod" << "calibration-file-output-directory",
QCoreApplication::translate("main", "Save cal file into <directory>."),
QCoreApplication::translate("main", "directory"));
// QString tmpPath1 = QDir::cleanPath(QDir::rootPath() + QDir::separator()+"calFile");
QString tmpPath1 = "/home/data/Cal/";
calFileOutputDirectory.setDefaultValue(tmpPath1);//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD>QCoreApplication::applicationDirPath()<29><>standardLightFile
parser.addOption(calFileOutputDirectory);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
// An option with a value
QCommandLineOption calFileOutputName(QStringList() << "cfon" << "calibration-file-output-name",
QCoreApplication::translate("main", "Cal file name."),
QCoreApplication::translate("main", "fileName"));
parser.addOption(calFileOutputName);
if (!parser.parse(QCoreApplication::arguments()))//Process the actual command line arguments given by the user
{
*errorMessage = parser.errorText();
return CommandLineError;
}
if (parser.isSet(versionOption))
return CommandLineVersionRequested;
if (parser.isSet(helpOption))
return CommandLineHelpRequested;
if (parser.isSet(deviceType))
{
const QString deviceTypeTmp = parser.value(deviceType);
if (deviceTypeTmp=="OPTOSKY")
{
query->deviceType = OPTOSKY;
}
else if(deviceTypeTmp=="OceanOptics")
{
query->deviceType = OceanOptics;
}
else
{
*errorMessage = "DeviceType set error.";
return CommandLineError;
}
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
*errorMessage = "No deviceType set.";
return CommandLineError;
}
if (parser.isSet(serialPort))
{
const QString serialPortTmp = parser.value(serialPort);
query->serialPort = serialPortTmp;
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
if (query->deviceType == OceanOptics)
{
;
} else if (query->deviceType == OPTOSKY)
{
*errorMessage = "No serialPort set.";
return CommandLineError;
}
}
if (parser.isSet(sleepTimeinSecond))
{
const QString timeTmp = parser.value(sleepTimeinSecond);
query->sleepTimeinSecond = timeTmp.toInt();
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = sleepTimeinSecond.defaultValues();
query->sleepTimeinSecond = tmp[0].toInt();
}
if (parser.isSet(averageTimes))
{
const QString averageTimesTmp = parser.value(averageTimes);
string tttt=averageTimesTmp.toStdString();
query->averageTimes = averageTimesTmp.toInt();
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = averageTimes.defaultValues();
query->averageTimes = tmp[0].toInt();
}
if (parser.isSet(position))
{
const QString positionTmp = parser.value(position);
query->position = positionTmp.toInt();
}
else
{
*errorMessage = "No position set.";
return CommandLineError;
}
query->justRecord = parser.isSet(recordOption);
if (!parser.isSet(standardLightFilePath) && !parser.isSet(standardLightFileSelector))//û<><C3BB><EFBFBD><EFBFBD><EFBFBD>ö<EFBFBD><C3B6>걣<EFBFBD><EAB1A3><EFBFBD>ļ<EFBFBD>·<EFBFBD><C2B7>
{
*errorMessage = "No standard light file set.";
return CommandLineError;
}
if (parser.isSet(standardLightFileSelector))//
{
QString selector = parser.value(standardLightFileSelector);
// QString standardLightFilePath_tmp = QDir::cleanPath(QDir::rootPath() + QDir::separator() + "standardLightFile" + QDir::separator() + selector);
QString tmp = "/home/data/Setting/StandardLightFile";
QString standardLightFilePath_tmp = tmp + QDir::separator() + selector;
string xx=standardLightFilePath_tmp.toStdString();
//<2F>ж϶<D0B6><CFB6><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
if (!isFileExist(standardLightFilePath_tmp))
{
*errorMessage = "Standard light file '" + selector + "' does not exist!";
return CommandLineError;
}
query->standardLightFilePath = standardLightFilePath_tmp;
}
if (parser.isSet(standardLightFilePath))//
{
query->standardLightFilePath = parser.value(standardLightFilePath);
}
if (parser.isSet(integratingSphereDetectorValue))
{
if(query->standardLightFilePath.contains("ocean_optics.lmp",Qt::CaseSensitive))
{
query->integratingSphereDetectorValue = -1;
}
else
{
const QString integratingSphereDetectorValueTmp = parser.value(integratingSphereDetectorValue);
query->integratingSphereDetectorValue = integratingSphereDetectorValueTmp.toInt();
}
}
else
{
*errorMessage = "No integratingSphereDetectorValue set.";
return CommandLineError;
}
if (parser.isSet(calFileOutputDirectory))//<2F><><EFBFBD>걣<EFBFBD><EAB1A3><EFBFBD>ļ<EFBFBD>·<EFBFBD><C2B7>
{
query->calFileOutputDirectory = parser.value(calFileOutputDirectory);
createDirectory(query->calFileOutputDirectory);//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>в<EFBFBD><D0B2><EFBFBD><EFBFBD><EFBFBD> <20>򴴽<EFBFBD>
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = calFileOutputDirectory.defaultValues();
QString directory = tmp[0];
createDirectory(directory);//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>в<EFBFBD><D0B2><EFBFBD><EFBFBD><EFBFBD> <20>򴴽<EFBFBD>
query->calFileOutputDirectory = directory;
}
if (parser.isSet(calFileOutputName))//-------
{
QString calFileOutputNameTmp = QDir::cleanPath(query->calFileOutputDirectory + QDir::separator() + parser.value(calFileOutputName));
query->calFileOutputName = calFileOutputNameTmp;
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
query->calFileOutputName = "";//ʹ<>ô˲<C3B4><CBB2><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>query->calFileOutputNameΪ<65><CEAA> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>˱<EFBFBD><CBB1><EFBFBD><EFBFBD><EFBFBD>ֵ
}
// const QStringList positionalArguments = parser.positionalArguments();
// if (positionalArguments.isEmpty())
// {
// *errorMessage = "Argument 'name' missing.";
// return CommandLineError;
// }
// if (positionalArguments.size() > 1)
// {
// *errorMessage = "Several 'name' arguments specified.";
// return CommandLineError;
// }
return CommandLineOk;
}
bool copyFileToPath(QString sourceDir ,QString toDir, bool coverFileIfExist)
{
toDir.replace("\\","/");
if (sourceDir == toDir){
return true;
}
if (!QFile::exists(sourceDir)){
return false;
}
QDir *createfile = new QDir;
bool exist = createfile->exists(toDir);
if (exist){
if(coverFileIfExist){
createfile->remove(toDir);
}
}//end if
if(!QFile::copy(sourceDir, toDir))
{
return false;
}
return true;
}
void logout(QString str)
{
std::cout << str.toStdString() << "<br>";
std::fflush(stdout);
}
void createDirectory(QString fullPath)//
{
QDir dir(fullPath);
if (dir.exists())
{
return;
}
else
{
bool ok = dir.mkdir(fullPath);//ֻ<><D6BB><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>뱣֤<EBB1A3>ϼ<EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD><EFBFBD>
return;
}
}
bool isFileExist(QString fullFileName)
{
QFileInfo fileInfo(fullFileName);
if (fileInfo.isFile())
{
return true;
}
return false;
}
int getNonlinearityCoeffs1(double * nonlinearityCoeffs)
{
int number_of_devices;
long *device_ids;
int i;
int test_index;
int flag;
int error = 0;
char nameBuffer[80];
/* Give the driver a chance to initialize itself */
sbapi_initialize();
// printf("Probing for devices...\n"); fflush(stdout);
sbapi_probe_devices();
//#define RS232_TEST
#ifdef RS232_TEST
printf("Adding an STS at 9600 baud...\n");
/* Uncomment for Linux */
//sbapi_add_RS232_device_location("STS", "/dev/ttyS0", 9600);
//sbapi_add_RS232_device_location("STS", "/dev/ttyUSB0", 9600);
/* Uncomment for Windows */
//sbapi_add_RS232_device_location("STS", "COM1", 9600);
/* Uncomment for e.g. USB-RS232 adapter under OSX */
//sbapi_add_RS232_device_location("STS", "/dev/tty.KeySerial1", 9600);
//sbapi_add_RS232_device_location("STS", "/dev/tty.usbserial", 9600);
#endif
/* This shows how to add network devices (note that most use TCP/IP) */
//sbapi_add_TCPIPv4_device_location("Jaz", "192.168.1.150", 7654);
//sbapi_add_TCPIPv4_device_location("Blaze", "192.168.1.151", 57357);
// printf("Getting device count...\n"); fflush(stdout);
number_of_devices = sbapi_get_number_of_device_ids();
// printf("Device count is %d\n", number_of_devices);
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");
int number;
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);
}
/* 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;
}
number = getNonlinearityCoeffs2(device_ids[i],nonlinearityCoeffs);
/* 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));
}
free(device_ids);
// printf("Finished testing.\n");
/* Clean up memory allocated by the driver */
sbapi_shutdown();
return number;
}//
//<2F><><EFBFBD><EFBFBD>ֵ<EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>ϵ<EFBFBD><CFB5><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD>
int getNonlinearityCoeffs2(long deviceID, double * nonlinearityCoeffs)
{
int error = 0;
int number_of_nonlinearity_coeff_features;
long *nonlinearity_coeff_feature_ids = 0;
double buffer[10];
int i;
int length = 0;
// printf("\n\tTesting nonlinearity coefficient features:\n");
// printf("\t\tGetting number of nonlinearity coefficient features:\n");
number_of_nonlinearity_coeff_features =
sbapi_get_number_of_nonlinearity_coeffs_features(deviceID, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
if(0 == number_of_nonlinearity_coeff_features) {
printf("\tNo nonlinearity coefficient capabilities found.\n");
return 0;
}
nonlinearity_coeff_feature_ids =
(long *)calloc(number_of_nonlinearity_coeff_features, sizeof(long));
// printf("\t\tGetting nonlinearity coefficient feature IDs...\n");
number_of_nonlinearity_coeff_features = sbapi_get_nonlinearity_coeffs_features(
deviceID, &error, nonlinearity_coeff_feature_ids,
number_of_nonlinearity_coeff_features);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
for(i = 0; i < number_of_nonlinearity_coeff_features; i++)
{
// printf("\t\t%d: Testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, deviceID, nonlinearity_coeff_feature_ids[i]);
// printf("\t\t\tAttempting to get nonlinearity coefficients...\n");
memset(nonlinearityCoeffs, (int)0, 20);//----------------------------------------------------------------------------
length = sbapi_nonlinearity_coeffs_get(deviceID,
nonlinearity_coeff_feature_ids[i], &error, nonlinearityCoeffs, 20);
// printf("\t\t\t\tResult is %d [%s]\n", length, sbapi_get_error_string(error));
if(0 == error && length > 0) {
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[0]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[1]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[2]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[3]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[4]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[5]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[6]);
}
// printf("\t\t%d: Finished testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, deviceID, nonlinearity_coeff_feature_ids[i]);
}
free(nonlinearity_coeff_feature_ids);
// printf("\tFinished testing nonlinearity coefficient capabilities.\n");
return length;
}

276
othersoft/calibration_console/Source_Files/oceanOpticsFiberImager.cpp Normal file
View File

@ -0,0 +1,276 @@
#include "Header_Files/oceanOpticsFiberImager.h"
OceanOpticsFiberImager::OceanOpticsFiberImager(double * nonlinearityCoeffs, int numberOfCoeffs)
{
m_FiberSpectrometer = NULL;
m_nonlinearityCoeffs = nonlinearityCoeffs;
m_iNumberOfNonlinearityCoeffs = numberOfCoeffs;
}
OceanOpticsFiberImager::~OceanOpticsFiberImager()
{
}
void OceanOpticsFiberImager::connectFiberSpectrometer(QString& SN, QString& pixelCount, QString& wavelengthInfo)
{
using namespace std;
m_FiberSpectrometer = new OceanOptics_lib();
m_FiberSpectrometer->Initialize();
getDeviceInfo(m_deviceInfo);
// m_FiberSpectrometer->GetDeviceInfo(m_deviceInfo);
getDeviceAttribute(m_deviceAttribute);
// m_FiberSpectrometer->GetDeviceAttribute(m_deviceAttribute);
SN = QString::fromStdString(m_deviceInfo.strSN);
pixelCount = QString::number(m_deviceAttribute.iPixels);
wavelengthInfo = QString::number(m_deviceAttribute.fWaveLengthInNM[0]) + "--" + QString::number(m_deviceAttribute.fWaveLengthInNM[m_deviceAttribute.iPixels - 1]);
m_FiberSpectrometer->SetDeviceTemperature(-10);
//<2F><><EFBFBD><EFBFBD>dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>
string qepro = "QEP";
string flame = "FLMS";
if (m_deviceInfo.strSN.find(qepro) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 200000;
}
else if (m_deviceInfo.strSN.find(flame) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 65535;
}
else//û<><C3BB><EFBFBD>ҵ<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
{
}
}
void OceanOpticsFiberImager::disconnectFiberSpectrometer()
{
m_FiberSpectrometer->Close();
}
void OceanOpticsFiberImager::getDeviceAttribute(DeviceAttribute& deviceAttribute)
{
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);
}
void OceanOpticsFiberImager::getDeviceInfo(DeviceInfo& deviceInfo)
{
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
}
void OceanOpticsFiberImager::setExposureTime(int iExposureTimeInMS)
{
m_FiberSpectrometer->SetExposureTime(iExposureTimeInMS);
}
void OceanOpticsFiberImager::getExposureTime(int &iExposureTimeInMS)
{
m_FiberSpectrometer->GetExposureTime(iExposureTimeInMS);
}
void OceanOpticsFiberImager::getDeviceTemperature(float &fTemperature)
{
m_FiberSpectrometer->GetDeviceTemperature(fTemperature);
}
void OceanOpticsFiberImager::singleShot(DataFrame &dfData)
{
m_FiberSpectrometer->SingleShot(dfData);
if(m_iNumberOfNonlinearityCoeffs==0)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ0<CEAA><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ô<EFBFBD>Ͳ<EFBFBD><CDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
{
return;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
for (int i = 0; i < m_deviceAttribute.iPixels; i++)
{
dfData.lData[i] = dfData.lData[i] / (m_nonlinearityCoeffs[0]
+ m_nonlinearityCoeffs[1] * dfData.lData[i]
+ m_nonlinearityCoeffs[2] * pow(dfData.lData[i], 2)
+ m_nonlinearityCoeffs[3] * pow(dfData.lData[i], 3)
+ m_nonlinearityCoeffs[4] * pow(dfData.lData[i], 4)
+ m_nonlinearityCoeffs[5] * pow(dfData.lData[i], 5)
+ m_nonlinearityCoeffs[6] * pow(dfData.lData[i], 6)
+ m_nonlinearityCoeffs[7] * pow(dfData.lData[i], 7)
);
}
}
void OceanOpticsFiberImager::getNonlinearityCoeffs(coeffsFrame &coeffs)
{
printf("This is OceanOpticsFiberImager.\n");
m_FiberSpectrometer->test_nonlinearity_coeffs_feature();
}
void OceanOpticsFiberImager::recordDark(QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
singleShot(m_DarkData);
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_darkSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_DarkData.usExposureTimeInMS << std::endl;//
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_DarkData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void OceanOpticsFiberImager::recordTarget(int recordTimes, QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
DataFrame integratingSphereData_tmp;
for (int i = 0; i < recordTimes; i++)
{
singleShot(integratingSphereData_tmp);
if (i == 0)//<2F><>integratingSphereData_tmp<6D>е<EFBFBD><D0B5>ع<EFBFBD>ʱ<EFBFBD>䡢<EFBFBD>¶ȵ<C2B6><C8B5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>m_IntegratingSphereData
{
m_IntegratingSphereData = integratingSphereData_tmp;
}
else
{
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] += integratingSphereData_tmp.lData[i];
}
}
}
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] = m_IntegratingSphereData.lData[i] / recordTimes;
}
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_integratingSphereSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)//
// {
// if (i==0)
// {
// outfile << m_IntegratingSphereData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_IntegratingSphereData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void OceanOpticsFiberImager::autoExpose()
{
DeviceAttribute attribute;
getDeviceAttribute(attribute);
int iterations = 0;//<2F><>¼<EFBFBD>Զ<EFBFBD><D4B6>ع<EFBFBD><D8B9>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
int maxIterations = 10;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
ZZ_U32 thresholdValue = m_MaxValueOfFiberSpectrometer * 0.8;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ80%
ZZ_U16 range = 10000;
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int exposureTimeInMS = 200;
setExposureTime(exposureTimeInMS);
emit sendExposureTimeSignal(exposureTimeInMS);
DataFrame integratingSphereData_tmp;
while (true)
{
if (iterations > maxIterations)//<2F>Ƿ񳬹<C7B7><F1B3ACB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
break;
}
singleShot(integratingSphereData_tmp);
ZZ_S32 maxValue = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
if (maxValue < thresholdValue && maxValue < (thresholdValue - range))//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>С
{
double scale = 1 + ((double)(thresholdValue - maxValue) / (double)thresholdValue);
int exposureTime;
m_FiberSpectrometer->GetExposureTime(exposureTime);
m_FiberSpectrometer->SetExposureTime(exposureTime * scale);
emit sendExposureTimeSignal(exposureTime);
ZZ_S32 m = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
std::cout << "<EFBFBD>Զ<EFBFBD><EFBFBD>ع<EFBFBD>-----------" << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵΪ" << m << std::endl;
}
else if (maxValue > thresholdValue && maxValue > (thresholdValue + range))//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
double scale = 1 - ((double)(maxValue - thresholdValue) / (double)thresholdValue);
int exposureTime;
m_FiberSpectrometer->GetExposureTime(exposureTime);
m_FiberSpectrometer->SetExposureTime(exposureTime * scale);
emit sendExposureTimeSignal(exposureTime);
ZZ_S32 m = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
std::cout << "<EFBFBD>Զ<EFBFBD><EFBFBD>ع<EFBFBD>-----------" << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵΪ" << m << std::endl;
}
else//<2F>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD>䣬<EFBFBD><E4A3AC><EFBFBD><EFBFBD>whileѭ<65><D1AD>
{
break;
}
iterations++;
}
}
ZZ_S32 OceanOpticsFiberImager::GetMaxValue(ZZ_S32 * dark, int number)
{
ZZ_S32 max = 0;
for (size_t i = 0; i < number; i++)
{
if (dark[i] > max)
{
max = dark[i];
}
}
//std::cout << "<22><>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>ֵΪ" << max << std::endl;
return max;
}

133
othersoft/findtty.sh Normal file
View File

@ -0,0 +1,133 @@
stty -F /dev/ttyUSB0 raw speed 9600
sleep 1s
stty -F /dev/ttyUSB0 raw speed 9600
echo -e "0 dev\n" > /dev/ttyUSB0
cat /dev/ttyUSB0 > 1.txt &
sleep 1s
pkill cat
if test -s 1.txt;then
echo '/dev/ttyUSB0 may be linermotor'> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB1 raw speed 9600
sleep 1s
stty -F /dev/ttyUSB1 raw speed 9600
echo -e "0 dev\n" > /dev/ttyUSB1
cat /dev/ttyUSB1 > 1.txt &
sleep 1s
pkill cat
if test -s 1.txt;then
echo '/dev/ttyUSB1 may be linermotor'> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB2 raw speed 9600
sleep 1s
stty -F /dev/ttyUSB2 raw speed 9600
echo -e "0 dev\n" > /dev/ttyUSB2
cat /dev/ttyUSB2 > 1.txt &
sleep 1s
pkill cat
if test -s 1.txt;then
echo '/dev/ttyUSB2 may be linermotor'> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB3 raw speed 9600
sleep 1s
stty -F /dev/ttyUSB3 raw speed 9600
echo -e "0 dev\n" > /dev/ttyUSB3
cat /dev/ttyUSB3 > 1.txt &
sleep 1s
pkill cat
if test -s 1.txt;then
echo '/dev/ttyUSB3 may be linermotor'> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyS1 raw speed 115200
sleep 1s
stty -F /dev/ttyS1 raw speed 115200
cat -e /dev/ttyS1 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyS1
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyS1 is ISIF or IS2'>> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyS2 raw speed 115200
sleep 1s
stty -F /dev/ttyS2 raw speed 115200
cat -e /dev/ttyS2 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyS2
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyS2 is ISIF or IS2'>> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB0 raw speed 115200
sleep 1s
stty -F /dev/ttyUSB0 raw speed 115200
cat -e /dev/ttyUSB0 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyUSB0
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyUSB0 is IS1'>> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB1 raw speed 115200
sleep 1s
stty -F /dev/ttyUSB1 raw speed 115200
cat -e /dev/ttyUSB1 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyS1
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyUSB1 is IS1'>> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB2 raw speed 115200
sleep 1s
stty -F /dev/ttyUSB2 raw speed 115200
cat -e /dev/ttyUSB2 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyUSB2
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyUSB2 is IS1'>> /home/data/Setting/tryfindtty.txt
fi
stty -F /dev/ttyUSB3 raw speed 115200
sleep 1s
stty -F /dev/ttyUSB3 raw speed 115200
cat -e /dev/ttyUSB3 > 1.txt &
sleep 1s
echo aa5500040307 | xxd -r -ps > /dev/ttyUSB3
sleep 1s
pkill cat
sleep 1s
if test -s 1.txt;then
echo '/dev/ttyUSB3 is IS1'>> /home/data/Setting/tryfindtty.txt
fi

51
othersoft/install.sh Normal file
View File

@ -0,0 +1,51 @@
mkdir build
cd build
mkdir movingliner
cd movingliner
cmake ../../movingliner
make -j4
mkdir /home/pi/bin
cp ./movingliner /home/pi/bin
echo beging build shuttercali
cd ../
mkdir shuttercali
cd shuttercali
cmake ../../shuttercali/project/LocationCali
make -j4
cp ./shutter_calibrate /home/pi/bin
cd ../
mkdir console
cd console
cmake ../../calibration_console
make -j4
cp ./ocean_optics_calibration_console /home/pi/bin
cd ../
sudo killall Mywathdog.sh
sudo killall TowerOptoSifAndSpectral
cd ../../
cp -r ./html/* /var/www/html
chmod +x /var/www/html/php/*.sh
cd ./build
cp TowerOptoSifAndSpectral /home/pi/bin
cd ../
cp ./root/Mywathdog.sh /root
cp ./root/start.sh /root
chmod +x /root/start.sh
mkdir /home/data
cd ../
rm -rf ./TowerOptoSifAndSpectral
cd /root/filebrew
chmod +x ./filebrowser
./filebrowser config set -a 0.0.0.0
./filebrowser config set -r /home/data
sudo apt-get install -y timedatectl
timedatectl set-timezone Asia/Shanghai
date -R
sudo hwclock -w -f /dev/rtc0
#tc

32
othersoft/movingliner/CMakeLists.txt Normal file
View File

@ -0,0 +1,32 @@
cmake_minimum_required(VERSION 3.0)
project(movingliner)
IF (WIN32)
#MESSAGE(STATUS "Now is windows")
ENDIF ()
set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} C:/Qt/Qt5.12.7/5.12.7/mingw73_64)
#set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} C:/Qt/Qt5.9.0/5.9/msvc2017_64/ )
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(QT Core Gui Network WebSockets SerialPort Widgets)
find_package(Qt5 REQUIRED ${QT})
include_directories("source/LinearShutter")
add_executable(movingliner
main.cpp
source/LinearShutter/VSMD12XControl.cpp
source/LinearShutter/VSMD12XControl.h
source/LinearShutter/ZZ_SeiralPort.cpp
source/LinearShutter/ZZ_SeiralPort.h
)
qt5_use_modules(movingliner ${QT})

27
othersoft/movingliner/DeviceSettings.ini Normal file
View File

@ -0,0 +1,27 @@
[DEVICE INFO]
TotalSpectrometer=1
[FS2]
Model=ISIF
Port=/dev/ttyS1
UID=QEP02975
[FS1]
Model=OSIFAlpha
Port=-1
UID=QEP02975
AEMax=0.85
AEMin=0.80
Depth=200000
[FS3]
Model=Null
[LINEAR SHUTTER]
Port=COM12
Type=1
DCID=1
TotalPosition=5
Position0=10000
Position1=91947
Position2=219299
Position3=347535
Position4=474904
[HUMITURE]
Port=/dev/ttyUSB3

83
othersoft/movingliner/main.cpp Normal file
View File

@ -0,0 +1,83 @@
#include <QCoreApplication>
#include <QDebug>
#include<VSMD12XControl.h>
#include "qtextstream.h"
QTextStream cout1(stdout, QIODevice::WriteOnly);
void logout(QString str){
std::cout<<str.toStdString()<<"<br>";
std::fflush(stdout);
}
int main(int argc, char *argv[]) {
int aaa=1000;
QString str(argv[1]);
QCoreApplication a(argc, argv);
CVSMD12XControl Motercontrol;
QString m_qstrDeviceConfigFilePath;
// cout1<<"adfasdfsadfsd"<<flush;
cout1<<"Your position number is "<<str<<"<br>"<<flush;
#ifdef WIN32
m_qstrDeviceConfigFilePath = ("D:\\03MyGit\\linux\\movingliner\\DeviceSettings.ini");
#else
m_qstrDeviceConfigFilePath = ("/home/data/Setting/DeviceSettings.ini");
#endif
QSettings *m_qsDeviceConfig;
m_qsDeviceConfig = new QSettings(m_qstrDeviceConfigFilePath, QSettings::IniFormat);
long positon =m_qsDeviceConfig->value("LINEAR SHUTTER/Position"+str).toLongLong();
if (positon==0)
{
logout("<b style=\"color:red\">Can not Find the position<\/b>");
return 0;
}
cout1<<"Find Configfile in "<<m_qstrDeviceConfigFilePath<<" <br> The Port of Motor is "<<m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString()<<"<br>"<<flush;
cout1<<"Position Find Value is "<<m_qsDeviceConfig->value("LINEAR SHUTTER/Position"+str).toLongLong()<<"<br>"<<flush;
cout1<<"Configing The Motor <br>"<<flush;
// m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString()
if( m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString()=="GPIO")
{
//cout1<<"ERROR number position"<<flush;
int positionnumber=m_qsDeviceConfig->value("LINEAR SHUTTER/TotalPosition").toInt();
if (str.toInt()>=positionnumber)
{
cout1<<"ERROR number position"<<flush;
return 0;
}
int targetpos=m_qsDeviceConfig->value("LINEAR SHUTTER/Position"+str).toLongLong();
for (int ii = 0; ii < positionnumber; ++ii) {
int tempgpio=m_qsDeviceConfig->value("LINEAR SHUTTER/Position"+QString::number(ii)).toInt();
QString com="gpio mode "+QString::number(tempgpio)+" out";
system(com.toStdString().c_str());
com="gpio write "+QString::number(tempgpio)+" 0";
system(com.toStdString().c_str());
}
QThread::msleep(500);
QString com="gpio write "+QString::number(targetpos)+" 1";
system(com.toStdString().c_str());
QThread::msleep(500);
cout1<<"FINISH Change Shutter <br>"<<flush;
return 0;
}
Motercontrol.ILMES_InitializeComm(m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString());
ControllerParams cpTest;
Motercontrol.ILMES_InitializeParams(cpTest);
logout("Moving to Zero");
Motercontrol.StartBackZero();
//std::cout<<"beging to move position";
logout("Moving to The Position");
Motercontrol.MoveTo(positon);
logout("<b style=\"color:green\">Finish the Task!!!<\/b> <br><b>Thanks For Using<\/b>");
return 0;
// return QCoreApplication::exec();
}

16
othersoft/movingliner/source/LinearShutter/AbstractPort.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "VSMD12XMiscDefines.h"
#include <string>
class CAbstractPort
{
public:
virtual void InitPort(PortInfo portinfo) = 0;
virtual bool SetPort() = 0;
virtual bool Open() = 0;
virtual void Close() = 0;
virtual std::string ReadAll(int waite=5000) = 0;
virtual int Write(const std::string strSend) = 0;
};

1459
othersoft/movingliner/source/LinearShutter/VSMD12XControl.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

146
othersoft/movingliner/source/LinearShutter/VSMD12XControl.h Normal file
View File

@ -0,0 +1,146 @@
#pragma once
#include "pch.h"
#include "AbstractPort.h"
using namespace std;
// #ifdef IRIS_API_EXPORTS
//
// #ifdef __cplusplus
// #define IRIS_API_FUNC extern "C" __declspec(dllexport)
// #else
// #define IRIS_API_FUNC __declspec(dllexport)
// #endif
//
// #else
//
// #ifdef __cplusplus
// #define IRIS_API_FUNC extern "C" __declspec(dllimport)
// #else
// #define IRIS_API_FUNC __declspec(dllimport)
// #endif
//
// #endif
//
//
// #ifdef IRIS_API_EXPORTS
// #define IRIS_API_CLASS __declspec(dllexport)
// #else
// #define IRIS_API_CLASS __declspec(dllimport)
// #endif
#define MAXDISTANCE 1265000
class /*IRIS_API_CLASS*/ CVSMD12XControl
{
public:
CVSMD12XControl();
~CVSMD12XControl();
private:
int *m_piPositionInPulses;
CAbstractPort *m_pAbsPort;
unValue m_unValue;
MSInfo m_stuMSInfo;
ControllerParams m_stuControllerParams;
int m_iProtocolType;
int m_iCID;
std::string m_strCID;
public:
bool m_bIsSyncMove;
//////////////////////////////////////////////////////////////////////////
//for IRIS Linear Motor - Electric Shutter
//Initialize communication setup iPortType(0:RS232 1:RS485) iCID(For RS485 device) bSyncMove(move mode)
bool ILMES_InitializeComm(QString portName,int bandrate=9600, int iPortType = 1, int iCID = 1, bool bSyncMove = true);
//Initialize communication setup iPortType(0:RS232 1:RS485) iCID(For RS485 device) bSyncMove(move mode)
bool ILMES_InitializeComm(PortInfo portinfo,int iPortType = 1,int iCID = 1, bool bSyncMove = true);
//Initialize Controller params
bool ILMES_InitializeParams(ControllerParams cpParams);
//Set the light hole position(pulses)
void ILMES_SetPosition(int *piPositionInPulse,size_t szSize);
bool ILMES_MoveToPos(int iPositionIndex);
bool IsMotionFinished();
public:
int waitetime;
////init port
void SetProtocolType(int iProtocolType = 0);//0:RS232 1:RS485 call before send any command
void SetCID(int iID);//set device id when using RS485 protocol call before send any command
void SetSyncMode(bool bSyncMove = false);
bool InitAndOpenPort(PortInfo portinfo);//Init comport by PortInfo Struct
//////////////////////////////////////////////////////////////////////////for debug or unsupported function
std::string ReadReceive();
int SendCommand(const std::string strSend); // return indicates how many char has been sent
//////////////////////////////////////////////////////////////////////////motor control
////init&misc
bool InitController(); //Init Motor controller hand shake
bool Enable(); //enbale
bool Disable(); //disable
bool GetStatus(MSInfo &stuMotorParam); //load motor status see MSInfo Struct
////motion control
bool Move(int iRelPulse); // relative move mode,pulse (-2147483647<34><37>2147483647)
bool MoveTo(int iAbsPulse);//absolute mode,pulse (-2147483647<34><37>2147483647)
bool Move_NoSyn(int iRelPulse); // relative move mode,pulse (-2147483647<34><37>2147483647)
bool MoveTo_NoSyn(int iAbsPulse);//absolute mode,pulse (-2147483647<34><37>2147483647)
bool SetLogicZero(); //set logic zero
bool StartBackZero();//back zero
bool StopBackZero();// stop back zero & reset register
////Set&Get
bool SetBaudRate(int iBaudRate);//set controller baud rates,default B9600 (2400 <20><> 921600)
int GetBaudRate(); // -1:should retry;
bool SetMicroSteps(int iMicroSteps);//set micro steps (0<><30>5)->(1/2/4/8/16/32)
int GetMicroSteps();
bool SetAccSpeed(float fAccSpd);//set acceleration speed in pulse (0 <20><> 192000000)
float GetAccSpeed();
bool SetRunSpeed(float fRunSpeed);//set normal running speed in pulse (0 <20><> 192000000)
float GetRunSpeed();
bool SetDecSpeed(float fDecSpeed);//set deceleration speed in pulse (0 <20><> 192000000)
float GetDecSpeed();
bool SetSpeed(float fRunSpeed, float fAccSpd, float fDecSpeed);//see above three functions
bool SetHoldCurrent(float fHoldCurrent);//set hold current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetHoldCurrent();
bool SetAccCurrent(float fAccCurrent);//set acceleration current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetAccCurrent();
bool SetRunCurrent(float fRunCurrent);//set normal running current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetRunCurrent();
bool SetCurrent(float fAccCurrent, float fRunCurrent, float fHoldCurrent);//see above three functions
bool SetS1FETE(ZZ_U8 bS1FETE);//S1 register falling edge trigger event,see enum
ZZ_U8 GetS1FETE();
bool SetS1RETE(ZZ_U8 bS1RETE);//S1 register rising edge trigger event
ZZ_U8 GetS1RETE();
bool SetS2FETE(ZZ_U8 bS2FETE);//S2 register falling edge trigger event
ZZ_U8 GetS2FETE();
bool SetS2RETE(ZZ_U8 bS2RETE);//S2 register rising edge trigger event
ZZ_U8 GetS2RETE();
//(ZeroMode 0:off 1:once 2:once + safe position 3:twice 4:twice + safe position) (OpenVoltageLevel 0:Low Level 1:High Level)
//(ZeroSensor 0:S1 1:S2 2:S3 3:S4 4:S5 5:S6)( ZeroVelocity <20><>-192000) <20><><EFBFBD><EFBFBD>192000<30><30>pulse)(SafePosition <20><>-2147483647) <20><><EFBFBD><EFBFBD>2147483647<34><37>)
bool SetZeroParams(ZZ_U8 bZeroMode, ZZ_U8 bSwitchOpenVL, ZZ_U8 bZeroSensor, float fZeroVelocity, int iSafePosition);
ZZ_U8 GetZeroMode();
ZZ_U8 GetSwitchOpenVoltageLevel();
ZZ_U8 GetZeroSensor();
int GetSafePosition();
float GetZeroVelocity();
private:
bool ParseReturnedString(std::string &strRecv,int iType);
bool ParseReturnedParam(std::string &strRecv);
void VSMD_BitShift(ZZ_U8* src, unValue* dst);
char* VSMD_Split(char* cStr, char cSplit);
};

108
othersoft/movingliner/source/LinearShutter/VSMD12XMiscDefines.h Normal file
View File

@ -0,0 +1,108 @@
#pragma once
#include "ZZ_Types.h"
#define MAXBUFFER 10240
#include<qstring.h>
using namespace ZZ_MISCDEF;
typedef struct tagTransportLayerInfomation
{
//Serial
int iPortType;
int iPortNumber;
int indexBaudRate;
int iBaudRate;
int indexParity, indexBytesize, indexStopBits; //Mode
bool Hw;
bool Sw;
bool Dtr, Rts;
QString FullPortName;
tagTransportLayerInfomation() {
iPortType = 0;
indexParity = 0;
iPortNumber = 8;
iBaudRate = 9600;
indexBytesize = 3;
indexStopBits = 0;
FullPortName = "";
}
//Bit
//Stop
//MODEM CONTROL setting
//MODEM LINE STATUS
//TCP UDP
}PortInfo;
typedef struct tagMotorStatusInfo
{
float fVelocity;
int iPosition;
ZZ_U32 uiFlags;
}MSInfo;
typedef struct tagControllerParams
{
int bdr; //baud
int mcs; //microsteps 0:full 1:half 2:4 3:8 4:16 5:32 6:64 7:128 8:256
float spd; //velocity
float acc; //acceleration
float dec; //deceleration
float cra; //acc state current
float crn; //normal state current
float crh; //hold state current
ZZ_U8 s1f;
ZZ_U8 s1r;
ZZ_U8 s2f;
ZZ_U8 s2r;
ZZ_U8 zmd; //zero mode
ZZ_U8 osv; //open state sensor value
ZZ_U8 snr; //zero sensor
ZZ_U8 zsp; //zero safe position
float zsd; //zero velocity
tagControllerParams() {
bdr = 9600;
cra = 0.8;
crh = 0.1;
crn = 0.8;
acc = 100000;
dec = 100000;
spd = 64000;
osv = 0;
snr = 0;
zmd = 3;
zsp = 20;
zsd = 50000;
mcs = 6;
}
}ControllerParams;
typedef union
{
ZZ_U8 byteValue[4];
short i16Value[2];
ZZ_U16 u16Value[2];
int i32Value;
float fValue;
ZZ_U32 u32Value;
}unValue;
enum emVSMDTriggerEvent
{
NoAction =0, //<2F>޶<EFBFBD><DEB6><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>״̬λ S1 <20>仯֪ͨ<CDA8><D6AA>
ResetZeroPosition, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
DecSpdStop, //<2F><><EFBFBD><EFBFBD>ֹͣ
DecSpdStopRZP, //<2F><><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
Stop, //<2F><><EFBFBD><EFBFBD>ֹͣ
StopRZP, //<2F><><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
RunningPosDirect, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD>ٶȣ<D9B6>
RunningNegDirect, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD>ٶȣ<D9B6>
OfflineModeOn, //<2F><><EFBFBD><EFBFBD>ģʽ<C4A3><CABD><EFBFBD><EFBFBD>
OfflineModeOff //<2F><><EFBFBD><EFBFBD>ģʽֹͣ
};

147
othersoft/movingliner/source/LinearShutter/ZZ_SeiralPort.cpp Normal file
View File

@ -0,0 +1,147 @@
#include "pch.h"
#include "ZZ_SeiralPort.h"
CZZ_SeiralPort_QT::CZZ_SeiralPort_QT()
{
m_pSerialPort = new QSerialPort();
}
CZZ_SeiralPort_QT::~CZZ_SeiralPort_QT()
{
if (m_pSerialPort != NULL)
{
delete m_pSerialPort;
}
}
void CZZ_SeiralPort_QT::InitPort(PortInfo portinfo)
{
m_piSettings = portinfo;
}
bool CZZ_SeiralPort_QT::SetPort()
{
bool bRes = true;
// int iRes = sio_ioctl(m_piSettings.iPortNumber, m_piSettings.indexBaudRate,
// m_piSettings.indexParity | m_piSettings.indexBytesize | m_piSettings.indexStopBits);
// if (iRes != SIO_OK)
// {
// bRes = false;
// }
QString qstrPortName;
if (m_piSettings.FullPortName!="")
{
qstrPortName = m_piSettings.FullPortName;
qDebug() << m_piSettings.FullPortName;
}
else {
qstrPortName = QString("COM%1").arg(m_piSettings.iPortNumber);
}
// qstrPortName = "COM4";
// QString qstrPortName = m_piSettings.FullPortName;//QString("COM%1").arg(m_piSettings.iPortNumber);
m_pSerialPort->setPortName(qstrPortName);
m_pSerialPort->setReadBufferSize(512);
bRes = m_pSerialPort->setBaudRate(m_piSettings.iBaudRate);
return bRes;
}
bool CZZ_SeiralPort_QT::Open()
{
bool bRes = true;
// int iRes = sio_open(m_piSettings.iPortNumber);
// if (iRes!=SIO_OK)
// {
// bRes = false;
// }
bRes = m_pSerialPort->open(QIODevice::ReadWrite);
if (!bRes)
{
qDebug() << "Err:open Failed.Exit Code:1";
//std::cout << "Err.open Failed" << std::endl;
return bRes;;
}
return bRes;
}
void CZZ_SeiralPort_QT::Close()
{
m_pSerialPort->close();
}
std::string CZZ_SeiralPort_QT::ReadAll(int waite)
{
if (!m_pSerialPort->waitForReadyRead(waite))
{
return "";
}
if (
m_pSerialPort->bytesAvailable() == 0
)
{
return "";
}
qbaRecv.clear();
qbaRecv = m_pSerialPort->readAll();
std::string strRet(qbaRecv.constData(), qbaRecv.length());
return strRet;
// std::string strRet;
// char cBuf[MAXBUFFER];
// int iRet = sio_read(m_piSettings.iPortNumber,cBuf, MAXBUFFER);
// if (iRet==0)
// {
// strRet = "";
//
// }
// else
// {
// char *pRecv = new char[iRet];
// memcpy(pRecv, cBuf, iRet);
// //std::string strRet(pRecv);
// //delete pRecv;
// //return strRet;
//
// strRet.resize(iRet);
// for (int i=0;i<iRet;i++)
// {
// strRet[i] = pRecv[i];
// }
// delete pRecv;
// }
// return strRet;
}
int CZZ_SeiralPort_QT::Write(const std::string strSend)
{
QByteArray qbaTest(strSend.c_str(),(int)strSend.length());
qint64 qi64Write = m_pSerialPort->write(qbaTest);
m_pSerialPort->waitForBytesWritten(5000);
if (qi64Write != qbaTest.size())
{
qDebug() << "Err:write Failed.Exit Code:1" << qi64Write;
return qi64Write;
}
return 0;
// char* pcSend = (char*)strSend.c_str();
// int iRet = sio_write(m_piSettings.iPortNumber, pcSend, (int)strSend.length());
//
// //delete pcSend;
// if (iRet!= (int)strSend.length())
// {
// return iRet;
// }
// else
// {
// return 0;
// }
// //sio_write();
}

26
othersoft/movingliner/source/LinearShutter/ZZ_SeiralPort.h Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include "VSMD12XMiscDefines.h"
#include "AbstractPort.h"
#include"qobject.h"
class CZZ_SeiralPort_QT :public CAbstractPort,QObject
{
private:
PortInfo m_piSettings;
QByteArray qbaSend, qbaRecv;
QSerialPort *m_pSerialPort;
public:
CZZ_SeiralPort_QT();
virtual ~CZZ_SeiralPort_QT();
public:
virtual void InitPort(PortInfo portinfo);
virtual bool SetPort();
virtual bool Open();
virtual void Close();
virtual std::string ReadAll(int waittime = 5000);
virtual int Write(const std::string strSend);
};

297
othersoft/movingliner/source/LinearShutter/ZZ_Types.h Normal file
View File

@ -0,0 +1,297 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include <string>
#define MAX_DEVICENUMBER_FS 2
#define MAX_LINEARSHUTTER_POSITION 12
namespace ZZ_MISCDEF
{
typedef unsigned char ZZ_U8;
typedef unsigned short int ZZ_U16;
typedef unsigned long int ZZ_U32;
namespace IRIS
{
//Fiber Spectrometer
namespace FS
{
typedef struct tagDataFrame
{
ZZ_U16 usExposureTimeInMS;
ZZ_U16 usData[4096];
float fTemperature;
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;
}
enum DeviceModel
{
OSIFAlpha=0,
OSIFBeta,
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::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 == "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 tagFiberSpecContext
{
ZZ_U8 ucDeviceNumber;
ZZ_U8 ucDeviceModel[MAX_DEVICENUMBER_FS];
int iInterface[MAX_DEVICENUMBER_FS];
std::string strSN[MAX_DEVICENUMBER_FS];
}FSContext;
typedef struct tagLinearShutterContext
{
ZZ_U8 ucPort;
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;
}
//ϵͳ<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;
}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;
}
};

28
othersoft/movingliner/source/LinearShutter/pch.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <iostream>
////////////////////////////setings
#include <QSettings>
#include <QMetaEnum>
////////////////////////////Basic
#include <QtCore/QCoreApplication>
#include <QString>
#include <QDebug>
#include <QDir>
#include <QObject>
////////////////////////////Thread
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
////////////////////////////json
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonParseError>
////////////////////////////time
#include <QtCore/QTime>
#include <QDateTime>
#include <QTimer>
////////////////////////////Serial I/O
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>

191
othersoft/movingliner/source/Settings/SystemConfigger.cpp Normal file
View File

@ -0,0 +1,191 @@
#include "SystemConfigger.h"
ZZ_SysConfigger::ZZ_SysConfigger(QObject *parent /*= nullptr*/)
{
#ifdef _DEBUG
m_qstrDeviceConfigFilePath = "E:/WorkSpace/TowerOptoSifAndSpectral/config/DeviceSettings.ini";
m_qstrJSONConfigFilePath = "E:/WorkSpace/TowerOptoSifAndSpectral/config/config.json";
#else
m_qstrJSONConfigFilePath = ("/home/data/Setting/config.json");
#endif // DEBUG
m_qsDeviceConfig = NULL;
}
ZZ_SysConfigger::~ZZ_SysConfigger()
{
if (qfJConfig.isOpen())
{
qfJConfig.close();
}
}
int ZZ_SysConfigger::Initialize()
{
//////////////////////////////////////////////////////////////////////////load device settings
using namespace ZZ_MISCDEF;
QMetaEnum enumDeviceModel = QMetaEnum::fromType<ConfiggerDeviceModel>();
if (m_qsDeviceConfig!=NULL)
{
delete m_qsDeviceConfig;
}
m_qsDeviceConfig = new QSettings(m_qstrDeviceConfigFilePath, QSettings::IniFormat);
m_struDeviceContext.ucDeviceNumber = m_qsDeviceConfig->value(QString("DEVICE INFO/TotalSpectrometer"),-1).toInt();
if (m_struDeviceContext.ucDeviceNumber == -1)
{
qDebug() << "DEVICE INFO TotalSpectrometer Value Err.";
return 3;
}
for (ZZ_U8 i=0;i< m_struDeviceContext.ucDeviceNumber;i++)
{
QString qstrTemp= m_qsDeviceConfig->value(QString("FS%1/Model").arg(i+1), "Null").toString();
m_struDeviceContext.ucDeviceModel[i]= enumDeviceModel.keysToValue(qstrTemp.toLatin1().data());
int iInterface= m_qsDeviceConfig->value(QString("FS%1/Port").arg(i + 1), -2).toInt();
m_struDeviceContext.iInterface[i] = iInterface;
qstrTemp = m_qsDeviceConfig->value(QString("FS%1/UID").arg(i + 1), "Null").toString();
m_struDeviceContext.strSN[i] = qstrTemp.toStdString();
}
m_struAcqPosition.iTotalPosition = m_qsDeviceConfig->value(QString("LINEAR SHUTTER/TotalPosition"), -1).toInt();
if (m_struAcqPosition.iTotalPosition == -1)
{
qDebug() << "LINEAR SHUTTER TotalPosition Value Err.";
return 4;
}
for (ZZ_U8 i = 0; i < m_struAcqPosition.iTotalPosition; i++)
{
int iPosition = m_qsDeviceConfig->value(QString("LINEAR SHUTTER/Position%1").arg(i), -2).toInt();
m_struAcqPosition.iPosition[i] = iPosition;
}
//////////////////////////////////////////////////////////////////////////load json settings
qfJConfig.setFileName(m_qstrJSONConfigFilePath);
bool bRes = qfJConfig.open(QIODevice::ReadOnly);
if (!bRes)
{
qDebug() << "QFile open config file Err.";
return 1;
}
m_qbaJData = qfJConfig.readAll();
m_qjdJDoc= QJsonDocument::fromJson(m_qbaJData, &m_qjpeJErr);
if (m_qjpeJErr.error != QJsonParseError::NoError)
{
qDebug() << m_qjpeJErr.errorString();
return 2;
}
m_qjoJObj = m_qjdJDoc.object();
return 0;
}
int ZZ_SysConfigger::GetGrabberRunParams(RunTimeGrabberParams &struGrabberRTParams)
{
struGrabberRTParams.atsParams = m_struAcqTime;
struGrabberRTParams.fscParams = m_struDeviceContext;
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_IS1()
{
m_struIS1Info.qstrCalFile_U0 = m_qjoJObj.value("IS1UpCalFile").toString();
m_struIS1Info.qstrCalFile_D1 = m_qjoJObj.value("IS1DownCalFile1").toString();
m_struIS1Info.qstrCalFile_D2 = m_qjoJObj.value("IS1DownCalFile2").toString();
m_struIS1Info.qstrCalFile_D3 = m_qjoJObj.value("IS1DownCalFile3").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_iSIF()
{
m_struISIFInfo.qstrCalFile_U0 = m_qjoJObj.value("SIFUpCalFile").toString();
m_struISIFInfo.qstrCalFile_D1 = m_qjoJObj.value("SIFDownCalFile1").toString();
m_struISIFInfo.qstrCalFile_D2 = m_qjoJObj.value("SIFDownCalFile2").toString();
m_struISIFInfo.qstrCalFile_D3 = m_qjoJObj.value("SIFDownCalFile3").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_System()
{
// QString qstr = m_qjoJObj.value("IntervalTime").toString();
m_struAcqTime.qtStartTime=QTime::fromString(m_qjoJObj.value("BeginTime").toString(), "hh:mm");
if (!m_struAcqTime.qtStartTime.isValid())
{
qDebug() << "Invalid BeginTime";
return 1;
}
#ifdef _DEBUG
m_struAcqTime.qtInterval = QTime::fromString(m_qjoJObj.value("IntervalTime").toString(), "ss");
if (!m_struAcqTime.qtInterval.isValid())
{
qDebug() << "Invalid IntervalTime";
return 1;
}
#else
m_struAcqTime.qtInterval = QTime::fromString(m_qjoJObj.value("IntervalTime").toString(), "mm");
if (!m_struAcqTime.qtInterval.isValid())
{
qDebug() << "Invalid IntervalTime";
return 1;
}
#endif
m_struAcqTime.qtStopTime = QTime::fromString(m_qjoJObj.value("EndTime").toString(), "hh:mm");
if (!m_struAcqTime.qtStopTime.isValid())
{
qDebug() << "Invalid EndTime";
return 1;
}
return 0;
}
int ZZ_SysConfigger::LoadSettingsFromFile_MISC()
{
m_struEC.qstrLocation = m_qjoJObj.value("Location").toString();
m_struEC.qstrGPS_Altitude = m_qjoJObj.value("GPS_Altitude").toString();
m_struEC.qstrGPS_Latitude = m_qjoJObj.value("GPS_Latitude").toString();
m_struEC.qstrGPS_Longtitude = m_qjoJObj.value("GPS_Longtitude").toString();
m_struEC.qstrGPS_North = m_qjoJObj.value("GPS_North").toString();
m_struMEC.qstrInstallationTime = m_qjoJObj.value("InstallationTime").toString();
m_struMEC.qstrISIFCalibrationTime = m_qjoJObj.value("ISIFCalibrationTime").toString();
m_struMEC.qstrIS1CalibrationTime = m_qjoJObj.value("IS1CalibrationTime").toString();
m_struMEC.qstrNameOfMaintenanceStaff = m_qjoJObj.value("NameOfMaintenanceStaff").toString();
m_struMEC.qstrPhoneNumberOfMaintenanceStaff = m_qjoJObj.value("PhoneNumberOfMaintenanceStaff").toString();
m_struMEC.qstrDownloadUserID = m_qjoJObj.value("DownloadUserID").toString();
m_struMEC.qstrDownlaodAddress = m_qjoJObj.value("DownlaodAddress").toString();
return 0;
}
int ZZ_SysConfigger::LoadSettings_Test()
{
QFile qfTest(m_qstrJSONConfigFilePath);
qfTest.open(QFile::ReadOnly);
QByteArray qbJData = qfTest.readAll();
QJsonParseError jerr;
QJsonDocument jdoc(QJsonDocument::fromJson(qbJData, &jerr));
if (jerr.error!= QJsonParseError::NoError)
{
qDebug() << jerr.errorString();
}
QJsonObject rootobj = jdoc.object();
QStringList key = rootobj.keys();
QString qtest1 = rootobj.value(rootobj.keys().at(15)).toString();
return 0;
}

57
othersoft/movingliner/source/Settings/SystemConfigger.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include "pch.h"
#include "ZZ_Types.h"
using namespace ZZ_MISCDEF::ZZ_RUNPARAMS;
using namespace ZZ_MISCDEF::ZZ_DATAFILE;
class ZZ_SysConfigger :public QObject
{
Q_OBJECT
public:
ZZ_SysConfigger(QObject *parent = nullptr);
virtual ~ZZ_SysConfigger();
public:
int Initialize();
int GetGrabberRunParams(RunTimeGrabberParams &struGrabberRTParams);
int LoadSettingsFromFile_IS1();
int LoadSettingsFromFile_iSIF();
int LoadSettingsFromFile_System();
int LoadSettingsFromFile_MISC();
int LoadSettings_Test();
public:
enum ConfiggerDeviceModel
{
OSIFAlpha = 0,
OSIFBeta,
ISIF,
IS1,
IS2,
Null
};
Q_ENUM(ConfiggerDeviceModel);
//////////////////////////////////////////////////////////////////////////run-time settings
AcqTimeSettings m_struAcqTime;
FSContext m_struDeviceContext;
AcqPosSettings m_struAcqPosition;
//////////////////////////////////////////////////////////////////////////
EContext m_struEC;
MEContext m_struMEC;
IS1Info m_struIS1Info;
ISIFInfo m_struISIFInfo;
private:
QString m_qstrDeviceConfigFilePath;
QString m_qstrJSONConfigFilePath;
QFile qfJConfig/*,qfDeviceConfig*/;
QSettings *m_qsDeviceConfig;
QByteArray m_qbaJData;
QJsonParseError m_qjpeJErr;
QJsonObject m_qjoJObj;
QJsonDocument m_qjdJDoc;
};

47
othersoft/shuttercali/project/LocationCali/CMakeLists.txt Normal file
View File

@ -0,0 +1,47 @@
cmake_minimum_required(VERSION 3.3)
project(shutter_calibrate)
set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} C:/Qt/Qt5.12.7/5.12.7/mingw73_64)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
set(QT Core Gui Network WebSockets SerialPort Widgets)
set(CMAKE_CXX_STANDARD 14)
find_package(Qt5 REQUIRED ${QT})
file(GLOB_RECURSE HDR_LIST "../../source/*.h")
file(GLOB_RECURSE SRC_LIST "../../source/*.cpp")
file(GLOB_RECURSE HDR_LIST1 "../../source_rlx/*.h")
file(GLOB_RECURSE SRC_LIST1 "../../source_rlx/*.cpp")
include_directories("../../source")
include_directories("../../source/FS")
include_directories("../../source/Logger")
include_directories("../../source/ZZ_SDK")
include_directories("../../source/Settings")
include_directories("../../source/Thread")
include_directories("../../source/LinearShutter")
include_directories("../../source_rlx/ShutterCali")
include_directories("../../source_rlx/sensor")
include_directories("../../source/OSIF/include")
include_directories("D:/02Raspberry/2020-12-17/SeaBreeze/include")
link_directories("D:/02Raspberry/2020-12-17/SeaBreeze/lib")
link_directories("/home/pi/SeaBrease/lib")
add_executable( shutter_calibrate main.cpp
${HDR_LIST}
${SRC_LIST}
${HDR_LIST1}
${SRC_LIST1}
)
qt5_use_modules(shutter_calibrate ${QT})
#target_link_libraries(shutter_calibrate SeaBreeze)
IF (WIN32)
target_link_libraries(shutter_calibrate SeaBreeze)
#target_link_libraries(shutter_calibrate seabreeze usb stdc++ m)
ELSE ()
target_link_libraries(shutter_calibrate seabreeze usb stdc++ m)
ENDIF ()
set_target_properties(shutter_calibrate PROPERTIES AUTOMOC ON)

BIN
othersoft/shuttercali/project/LocationCali/SeaBreeze.dll Normal file
View File

Binary file not shown.

BIN
othersoft/shuttercali/project/LocationCali/SeaBreeze.lib Normal file
View File

Binary file not shown.

305
othersoft/shuttercali/project/LocationCali/main.cpp Normal file
View File

@ -0,0 +1,305 @@
#include <QtCore/QCoreApplication>
#include<VSMD12XControl.h>
#include "QTextCodec"
#include "SensorMannager.h"
#include"SensorOptoSky.h"
#include"SensorQExPRO.h"
#include <iostream>
#include <fstream>
#include <QTextStream>
#include <QSettings>
QTextStream cout1(stdout, QIODevice::WriteOnly);
void logout(QString str){
cout1<<str<<" <br>"<<flush;
cout1<<endl;
// std::fflush(stdout);
}
vector<int> FindFeng(vector<int > point1ist, vector<float> valuelist);
vector<int> DengJianJu(int position, int distanc, int times = 10);
vector <float> PingHua(vector <float> value, int step = 2);
int main(int argc, char* argv[])
{
if (argc!=4)
{
logout("Some Thing error Please check the input");
logout( "The Correct Should Be application sensor numberofposition");
logout( "apllication Sensor positionneed shutter_time");
logout("Senor: OSIFAlpha QEPRO");
logout("Senor: OSIFBeta QE65");
logout("Senor: ISIF ATP6500");
logout("Senor: IS1 ATP1010");
logout("Senor: IS2 ATP5020");
return 0;
}
// cali;
int bandsnumber=1024;
QString SensorTypestr(argv[1]);
QString PositionNumberstr(argv[2]);
int shuttertime=QString(argv[3]).toInt();
int PositionNumber=PositionNumberstr.toInt();
QCoreApplication aaaaa(argc, argv);
QString m_qstrDeviceConfigFilePath;
#ifdef WIN32
m_qstrDeviceConfigFilePath = ("D:\\03MyGit\\linux\\movingliner\\DeviceSettings.ini");
#else
m_qstrDeviceConfigFilePath = ("/home/data/Setting/DeviceSettings.ini");
#endif
QSettings *m_qsDeviceConfig;
m_qsDeviceConfig = new QSettings(m_qstrDeviceConfigFilePath, QSettings::IniFormat);
int numberofsensor=m_qsDeviceConfig->value("DEVICE INFO/TotalSpectrometer").toInt();
logout("Welcom to use the Auto Locate Application");
string hdrPath = "/home/data/test.csv";
std::ofstream outfile(hdrPath.c_str());
string hdrPath1 = "/home/data/result.csv";
std::ofstream outfile1(hdrPath1.c_str());
logout("Sensor is "+SensorTypestr);
SensorBase* aa= nullptr;
if (SensorTypestr=="OSIFAlpha")
{
aa = new SensorQExPRO(QE65PRO_QE);
} else if (SensorTypestr=="OSIFBeta")
{
aa = new SensorQExPRO(QE65PRO_QE);
}
if(aa== nullptr)
{
QString portname="";
for (int i = 0; i < numberofsensor; ++i) {
QString key="FS"+QString::number(i+1)+"/Model";
qDebug()<<key;
if (m_qsDeviceConfig->value(key).toString()==SensorTypestr)
{
QString portstr=m_qsDeviceConfig->value("FS"+QString::number(i+1)+"/Port").toString();
QStringList strlist=portstr.split('/');
portname=strlist.at(strlist.length()-1);
}
}
// qDebug()<<portname;
if (portname=="")
{
logout("<b style=\"color:red\">Can not find the sensor"+SensorTypestr+"<\/b>");
return 1;
}
logout("Sensor Port is "+portname);
aa=new SensorOptoSky(ATP6500,portname);
}
//SensorBase* aa = new SensorOptoSky(ATP6500,"ttyUSB0");
aa->initSensor();
STRSensorInfo info= aa->SensorInfo;
int bandsshow=info.BandNum/2;
logout("Sensor Bands to Show is "+QString::number(bandsshow));
STROnePlot oneplot;
CVSMD12XControl Motercontrol;
//Motercontrol.ILMES_InitializeComm("COM16");
if ( m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString()!="")
{
logout("Find the motor port:"+m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString());
Motercontrol.ILMES_InitializeComm( m_qsDeviceConfig->value("LINEAR SHUTTER/Port").toString());
} else
{
return 0;
}
logout("The max Postion is "+QString::number(550000/4*PositionNumber));
ControllerParams cpTest;
bool res = Motercontrol.ILMES_InitializeParams(cpTest);
aa->Settingshuttertime(shuttertime);
aa->GetOnePlot(oneplot);
logout("GO TO ZERO");
Motercontrol.StartBackZero();
Motercontrol.SetRunSpeed(10000);
logout("GO TO ZERO OK");
logout("Start Moving to "+QString::number(550000/4*PositionNumber));
Motercontrol.MoveTo_NoSyn(550000/4*PositionNumber);
aa->GetOnePlot(oneplot);
MSInfo temp;
Motercontrol.GetStatus(temp);
vector<int > point1ist;
vector<float> valuelist;
int i = 0;
Motercontrol.GetStatus(temp);
//outfile <<i<<"," << oneplot.Plot[1024] << "," << temp.iPosition << std::endl;
point1ist.push_back(temp.iPosition);
valuelist.push_back(oneplot.Plot[bandsshow]);
while (temp.fVelocity!=0)
{
aa->GetOnePlot(oneplot);
//qDebug() << oneplot.BandNum;
//std::cout << temp.iPosition << std::endl;
Motercontrol.GetStatus(temp);
i++;
outfile << i << "," << oneplot.Plot[bandsshow] << "," << temp.iPosition << std::endl;
point1ist.push_back(temp.iPosition);
valuelist.push_back(oneplot.Plot[bandsshow]);
}
logout("FINISH Moving");
vector<float> valuepinghua1 = PingHua(valuelist, 3);
vector<int>loction1=FindFeng(point1ist, valuepinghua1);
int lenth = loction1.size();
if (lenth!=PositionNumber)
{
logout("<b style=\"color:red\">can not find all position please change the shutter time and try agin<\/b>");
}
cout1<<"First find "<<lenth<<" point "<<"<br>"<<flush;
logout("GO TO ZERO");
Motercontrol.StartBackZero();
logout("GO TO ZERO OK");
logout("Start Moving");
for (size_t i = 0; i < lenth; i++)
{
vector<int> location1point = DengJianJu(loction1[i], 5000, 25);
vector<float> valuepoint;
int lennow = location1point.size();
cout1<<"Detail find "<<i<<" point begin"<<"<br>"<<flush;
for (size_t ii = 0; ii < lennow; ii++)
{
Motercontrol.MoveTo(location1point[ii]);
aa->GetOnePlot(oneplot);
valuepoint.push_back(oneplot.Plot[bandsshow]);
//outfile << ii << "," << oneplot.Plot[1024] << "," << location1point[ii] << std::endl;
}
vector<float> valuepinghua = PingHua(valuepoint,3);
vector<int>loction2 = FindFeng(location1point, valuepinghua);
if (loction2.size() == 1)
{ cout1<<"find "<<i<<"point value is <b color=\'green\'>"<<loction2[0]<<"<\/b><br>"<<flush;
outfile1 <<i+1<<"," << loction2[0]<< std::endl;
}
int cc = 10;
cc++;
}
logout("FINISH Moving");
;
std::cout<<"totle:" << i;
outfile.close();
outfile.close();
if (!res)
{
return 0;
}
return 0;
return aaaaa.exec();
}
vector<int> FindFeng(vector<int > point1ist, vector<float> valuelist)
{
vector<int> ret;
int lenth = point1ist.size();
if (lenth<10)
{
ret.push_back(0);
return ret;
}
for (size_t i = 5; i < lenth-5; i++)
{
if (valuelist[i] > 5000&&valuelist[i]>valuelist[i-1]&& valuelist[i] > valuelist[i - 4]&& valuelist[i] >valuelist[i + 1]&& valuelist[i] > valuelist[i + 4]
&& valuelist[i-1] > 5000 && valuelist[i-4]&& valuelist[i +1] > 5000 && valuelist[i + 4])
{
if (ret.size()!=0)
{
if (point1ist[i]-ret[ret.size()-1]<5000)
{
continue;
}
}
ret.push_back(point1ist[i]);
}
}
return ret;
}
vector<int> DengJianJu(int position, int distanc, int times )
{
int begin = position - distanc;
vector<int> ret;
int eachstep = distanc / times;
for (size_t i = 0; i < 2*times; i++)
{
ret.push_back(begin + i * eachstep);
}
return ret;
}
vector <float> PingHua(vector <float> value,int step)
{
vector <float> ret;
if (value.size()<2*step)
{
return value;
}
int len = value.size();
for (size_t i = 0; i < step; i++)
{
ret.push_back(value[i]);
}
for (size_t i = step; i <len-step; i++)
{
float sumi = 0;
for (size_t ii = 0; ii < 2*step+1; ii++)
{
sumi += value[i - step + ii];
}
ret.push_back(sumi / (2 * step + 1));
}
for (size_t i = len - step; i < len; i++)
{
ret.push_back(value[i]);
}
return ret;
}

591
othersoft/shuttercali/source/FS/ATPControl_Serial_QT.cpp Normal file
View File

@ -0,0 +1,591 @@
#include "pch.h"
#include "ATPControl_Serial_QT.h"
#include "ZZ_Math_HDRONLY.h"
ZZ_ATPControl_Serial_Qt::ZZ_ATPControl_Serial_Qt()
{
m_pSerialPort = new QSerialPort;
//connect(m_pSerialPort, &QSerialPort::readyRead, this, &ZZ_ATPControl_Serial_Qt::ReadMessage);
m_iBaudRate = 115200;
}
ZZ_ATPControl_Serial_Qt::~ZZ_ATPControl_Serial_Qt()
{
if (m_pSerialPort != NULL)
{
delete m_pSerialPort;
}
}
// int ZZ_ATPControl_Serial_Qt::SetBaudRate(int iBaud)
// {
// m_iBaudRate = iBaud;
// return 0;
// }
int ZZ_ATPControl_Serial_Qt::Initialize(bool bIsUSBMode, ZZ_U8 ucPortNumber, std::string strDeviceName)
{
QString qstrPortName = QString("COM%1").arg(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;
}
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;
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;
}
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::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(50);
QByteArray qbTemp = m_pSerialPort->readAll();
qbData.append(qbTemp);
if (iCounter > 10)
{
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(50);
qbData.append(m_pSerialPort->readAll());
if (iCounter > 100)
{
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)
{
qDebug() << "Err:RecvData Failed,Incorrect Check Sum.Exit Code:4" << qbData.size();
qbData.clear();
return 4;
}
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::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.usData, m_daDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_daDeviceAttr.iPixels / 100;
for (int i = 0; i < iCount; i++)
{
dSum += dfTemp.usData[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)
{
QByteArray qbExposureTime,qbRecv;
qbExposureTime.append(SET_INTEGRATION_TIME);
qbExposureTime.resize(3);
qbExposureTime[1] = iExposureTimeInMS >> 8;
qbExposureTime[2] = iExposureTimeInMS & 0xFF;
SendCommand(qbExposureTime);
RecvData(qbRecv);
ParseData(qbRecv);
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;
SendCommand(qbSend);
RecvData(qbRecv);
ParseData(qbRecv);
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShot(DataFrame &dfData)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SYNC_GET_DATA);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
SendCommand(qbSend);
RecvData(qbRecv);
ParseData(qbRecv);
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
else
{
int iDataSizeInPixel = (qbRecv.size() - 1) / 2;
memcpy(dfData.usData, qbRecv.data() + 1, iDataSizeInPixel * 2);
}
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;
SendCommand(qbSend);
RecvData(qbRecv);
ParseData(qbRecv);
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
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)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_TEC_TEMP);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
SendCommand(qbSend);
RecvData(qbRecv);
ParseData(qbRecv);
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;
// }

84
othersoft/shuttercali/source/FS/ATPControl_Serial_QT.h Normal file
View File

@ -0,0 +1,84 @@
//////////////////////////////////////////////////////////////////////////
//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();
virtual ~ZZ_ATPControl_Serial_Qt();
public:
//<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
//int SetBaudRate(int iBaud);
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
int Initialize(bool bIsUSBMode, ZZ_U8 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;
//////////////////////////////////////////////////////////////////////////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 SendCommand(QByteArray qbCommand);
int RecvData(QByteArray &qbData);
int ParseData(QByteArray &qbData);
//private slots :
//void ReadMessage();
};

0
othersoft/shuttercali/source/FS/ATPDataFileProcessor.cpp Normal file
View File

1
othersoft/shuttercali/source/FS/ATPDataFileProcessor.h Normal file
View File

@ -0,0 +1 @@
#pragma once

42
othersoft/shuttercali/source/FS/IrisFiberSpectrometerBase.h Normal file
View File

@ -0,0 +1,42 @@
#include <string>
#include "ZZ_Types.h"
#pragma once
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class CIrisFSBase
{
public:
//CIrisFSBase();
//virtual ~CIrisFSBase()= 0;
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,ZZ_U8 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;
};

297
othersoft/shuttercali/source/FS/ZZ_Types.h Normal file
View File

@ -0,0 +1,297 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include "pch.h"
#include <string>
#define MAX_DEVICENUMBER_FS 2
#define MAX_LINEARSHUTTER_POSITION 12
namespace ZZ_MISCDEF
{
typedef unsigned char ZZ_U8;
typedef unsigned short int ZZ_U16;
typedef unsigned long int ZZ_U32;
namespace IRIS
{
//Fiber Spectrometer
namespace FS
{
typedef struct tagDataFrame
{
ZZ_U16 usExposureTimeInMS;
ZZ_U16 usData[4096];
float fTemperature;
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;
}
enum DeviceModel
{
OSIFAlpha=0,
OSIFBeta,
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::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 == "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 tagFiberSpecContext
{
ZZ_U8 ucDeviceNumber;
ZZ_U8 ucDeviceModel[MAX_DEVICENUMBER_FS];
int iInterface[MAX_DEVICENUMBER_FS];
std::string strSN[MAX_DEVICENUMBER_FS];
}FSContext;
typedef struct tagLinearShutterContext
{
ZZ_U8 ucPort;
ZZ_U8 ucProtocolType;
ZZ_U16 usCmdID;
}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;
}
//ϵͳ<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;
}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;
}
};

16
othersoft/shuttercali/source/LinearShutter/AbstractPort.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "VSMD12XMiscDefines.h"
#include <string>
class CAbstractPort
{
public:
virtual void InitPort(PortInfo portinfo) = 0;
virtual bool SetPort() = 0;
virtual bool Open() = 0;
virtual void Close() = 0;
virtual std::string ReadAll(int waite=5000) = 0;
virtual int Write(const std::string strSend) = 0;
};

1458
othersoft/shuttercali/source/LinearShutter/VSMD12XControl.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

146
othersoft/shuttercali/source/LinearShutter/VSMD12XControl.h Normal file
View File

@ -0,0 +1,146 @@
#pragma once
#include "pch.h"
#include "AbstractPort.h"
using namespace std;
// #ifdef IRIS_API_EXPORTS
//
// #ifdef __cplusplus
// #define IRIS_API_FUNC extern "C" __declspec(dllexport)
// #else
// #define IRIS_API_FUNC __declspec(dllexport)
// #endif
//
// #else
//
// #ifdef __cplusplus
// #define IRIS_API_FUNC extern "C" __declspec(dllimport)
// #else
// #define IRIS_API_FUNC __declspec(dllimport)
// #endif
//
// #endif
//
//
// #ifdef IRIS_API_EXPORTS
// #define IRIS_API_CLASS __declspec(dllexport)
// #else
// #define IRIS_API_CLASS __declspec(dllimport)
// #endif
#define MAXDISTANCE 1265000
class /*IRIS_API_CLASS*/ CVSMD12XControl
{
public:
CVSMD12XControl();
~CVSMD12XControl();
private:
int *m_piPositionInPulses;
CAbstractPort *m_pAbsPort;
unValue m_unValue;
MSInfo m_stuMSInfo;
ControllerParams m_stuControllerParams;
int m_iProtocolType;
int m_iCID;
std::string m_strCID;
public:
bool m_bIsSyncMove;
//////////////////////////////////////////////////////////////////////////
//for IRIS Linear Motor - Electric Shutter
//Initialize communication setup iPortType(0:RS232 1:RS485) iCID(For RS485 device) bSyncMove(move mode)
bool ILMES_InitializeComm(QString portName,int bandrate=9600, int iPortType = 1, int iCID = 1, bool bSyncMove = true);
//Initialize communication setup iPortType(0:RS232 1:RS485) iCID(For RS485 device) bSyncMove(move mode)
bool ILMES_InitializeComm(PortInfo portinfo,int iPortType = 1,int iCID = 1, bool bSyncMove = true);
//Initialize Controller params
bool ILMES_InitializeParams(ControllerParams cpParams);
//Set the light hole position(pulses)
void ILMES_SetPosition(int *piPositionInPulse,size_t szSize);
bool ILMES_MoveToPos(int iPositionIndex);
bool IsMotionFinished();
public:
int waitetime;
////init port
void SetProtocolType(int iProtocolType = 0);//0:RS232 1:RS485 call before send any command
void SetCID(int iID);//set device id when using RS485 protocol call before send any command
void SetSyncMode(bool bSyncMove = false);
bool InitAndOpenPort(PortInfo portinfo);//Init comport by PortInfo Struct
//////////////////////////////////////////////////////////////////////////for debug or unsupported function
std::string ReadReceive();
int SendCommand(const std::string strSend); // return indicates how many char has been sent
//////////////////////////////////////////////////////////////////////////motor control
////init&misc
bool InitController(); //Init Motor controller hand shake
bool Enable(); //enbale
bool Disable(); //disable
bool GetStatus(MSInfo &stuMotorParam); //load motor status see MSInfo Struct
////motion control
bool Move(int iRelPulse); // relative move mode,pulse (-2147483647<34><37>2147483647)
bool MoveTo(int iAbsPulse);//absolute mode,pulse (-2147483647<34><37>2147483647)
bool Move_NoSyn(int iRelPulse); // relative move mode,pulse (-2147483647<34><37>2147483647)
bool MoveTo_NoSyn(int iAbsPulse);//absolute mode,pulse (-2147483647<34><37>2147483647)
bool SetLogicZero(); //set logic zero
bool StartBackZero();//back zero
bool StopBackZero();// stop back zero & reset register
////Set&Get
bool SetBaudRate(int iBaudRate);//set controller baud rates,default B9600 (2400 <20><> 921600)
int GetBaudRate(); // -1:should retry;
bool SetMicroSteps(int iMicroSteps);//set micro steps (0<><30>5)->(1/2/4/8/16/32)
int GetMicroSteps();
bool SetAccSpeed(float fAccSpd);//set acceleration speed in pulse (0 <20><> 192000000)
float GetAccSpeed();
bool SetRunSpeed(float fRunSpeed);//set normal running speed in pulse (0 <20><> 192000000)
float GetRunSpeed();
bool SetDecSpeed(float fDecSpeed);//set deceleration speed in pulse (0 <20><> 192000000)
float GetDecSpeed();
bool SetSpeed(float fRunSpeed, float fAccSpd, float fDecSpeed);//see above three functions
bool SetHoldCurrent(float fHoldCurrent);//set hold current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetHoldCurrent();
bool SetAccCurrent(float fAccCurrent);//set acceleration current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetAccCurrent();
bool SetRunCurrent(float fRunCurrent);//set normal running current ( 0 <20><> 8.0 )Amp? pay attention to your motor specification.
float GetRunCurrent();
bool SetCurrent(float fAccCurrent, float fRunCurrent, float fHoldCurrent);//see above three functions
bool SetS1FETE(ZZ_U8 bS1FETE);//S1 register falling edge trigger event,see enum
ZZ_U8 GetS1FETE();
bool SetS1RETE(ZZ_U8 bS1RETE);//S1 register rising edge trigger event
ZZ_U8 GetS1RETE();
bool SetS2FETE(ZZ_U8 bS2FETE);//S2 register falling edge trigger event
ZZ_U8 GetS2FETE();
bool SetS2RETE(ZZ_U8 bS2RETE);//S2 register rising edge trigger event
ZZ_U8 GetS2RETE();
//(ZeroMode 0:off 1:once 2:once + safe position 3:twice 4:twice + safe position) (OpenVoltageLevel 0:Low Level 1:High Level)
//(ZeroSensor 0:S1 1:S2 2:S3 3:S4 4:S5 5:S6)( ZeroVelocity <20><>-192000) <20><><EFBFBD><EFBFBD>192000<30><30>pulse)(SafePosition <20><>-2147483647) <20><><EFBFBD><EFBFBD>2147483647<34><37>)
bool SetZeroParams(ZZ_U8 bZeroMode, ZZ_U8 bSwitchOpenVL, ZZ_U8 bZeroSensor, float fZeroVelocity, int iSafePosition);
ZZ_U8 GetZeroMode();
ZZ_U8 GetSwitchOpenVoltageLevel();
ZZ_U8 GetZeroSensor();
int GetSafePosition();
float GetZeroVelocity();
private:
bool ParseReturnedString(std::string &strRecv,int iType);
bool ParseReturnedParam(std::string &strRecv);
void VSMD_BitShift(ZZ_U8* src, unValue* dst);
char* VSMD_Split(char* cStr, char cSplit);
};

108
othersoft/shuttercali/source/LinearShutter/VSMD12XMiscDefines.h Normal file
View File

@ -0,0 +1,108 @@
#pragma once
#include "ZZ_Types.h"
#define MAXBUFFER 10240
#include<qstring.h>
using namespace ZZ_MISCDEF;
typedef struct tagTransportLayerInfomation
{
//Serial
int iPortType;
int iPortNumber;
int indexBaudRate;
int iBaudRate;
int indexParity, indexBytesize, indexStopBits; //Mode
bool Hw;
bool Sw;
bool Dtr, Rts;
QString FullPortName;
tagTransportLayerInfomation() {
iPortType = 0;
indexParity = 0;
iPortNumber = 8;
iBaudRate = 9600;
indexBytesize = 3;
indexStopBits = 0;
FullPortName = "";
}
//Bit
//Stop
//MODEM CONTROL setting
//MODEM LINE STATUS
//TCP UDP
}PortInfo;
typedef struct tagMotorStatusInfo
{
float fVelocity;
int iPosition;
ZZ_U32 uiFlags;
}MSInfo;
typedef struct tagControllerParams
{
int bdr; //baud
int mcs; //microsteps 0:full 1:half 2:4 3:8 4:16 5:32 6:64 7:128 8:256
float spd; //velocity
float acc; //acceleration
float dec; //deceleration
float cra; //acc state current
float crn; //normal state current
float crh; //hold state current
ZZ_U8 s1f;
ZZ_U8 s1r;
ZZ_U8 s2f;
ZZ_U8 s2r;
ZZ_U8 zmd; //zero mode
ZZ_U8 osv; //open state sensor value
ZZ_U8 snr; //zero sensor
ZZ_U8 zsp; //zero safe position
float zsd; //zero velocity
tagControllerParams() {
bdr = 9600;
cra = 0.8;
crh = 0.8;
crn = 0.8;
acc = 100000;
dec = 100000;
spd = 64000;
osv = 0;
snr = 0;
zmd = 3;
zsp = 200;
zsd = 50000;
mcs = 6;
}
}ControllerParams;
typedef union
{
ZZ_U8 byteValue[4];
short i16Value[2];
ZZ_U16 u16Value[2];
int i32Value;
float fValue;
ZZ_U32 u32Value;
}unValue;
enum emVSMDTriggerEvent
{
NoAction =0, //<2F>޶<EFBFBD><DEB6><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>״̬λ S1 <20>仯֪ͨ<CDA8><D6AA>
ResetZeroPosition, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
DecSpdStop, //<2F><><EFBFBD><EFBFBD>ֹͣ
DecSpdStopRZP, //<2F><><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
Stop, //<2F><><EFBFBD><EFBFBD>ֹͣ
StopRZP, //<2F><><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹͣ<CDA3><D6B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>λ<EFBFBD><CEBB>
RunningPosDirect, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD>ٶȣ<D9B6>
RunningNegDirect, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD>ٶȣ<D9B6>
OfflineModeOn, //<2F><><EFBFBD><EFBFBD>ģʽ<C4A3><CABD><EFBFBD><EFBFBD>
OfflineModeOff //<2F><><EFBFBD><EFBFBD>ģʽֹͣ
};

147
othersoft/shuttercali/source/LinearShutter/ZZ_SeiralPort.cpp Normal file
View File

@ -0,0 +1,147 @@
#include "pch.h"
#include "ZZ_SeiralPort.h"
CZZ_SeiralPort_QT::CZZ_SeiralPort_QT()
{
m_pSerialPort = new QSerialPort();
}
CZZ_SeiralPort_QT::~CZZ_SeiralPort_QT()
{
if (m_pSerialPort != NULL)
{
delete m_pSerialPort;
}
}
void CZZ_SeiralPort_QT::InitPort(PortInfo portinfo)
{
m_piSettings = portinfo;
}
bool CZZ_SeiralPort_QT::SetPort()
{
bool bRes = true;
// int iRes = sio_ioctl(m_piSettings.iPortNumber, m_piSettings.indexBaudRate,
// m_piSettings.indexParity | m_piSettings.indexBytesize | m_piSettings.indexStopBits);
// if (iRes != SIO_OK)
// {
// bRes = false;
// }
QString qstrPortName;
if (m_piSettings.FullPortName!="")
{
qstrPortName = m_piSettings.FullPortName;
qDebug() << m_piSettings.FullPortName;
}
else {
qstrPortName = QString("COM%1").arg(m_piSettings.iPortNumber);
}
// qstrPortName = "COM4";
// QString qstrPortName = m_piSettings.FullPortName;//QString("COM%1").arg(m_piSettings.iPortNumber);
m_pSerialPort->setPortName(qstrPortName);
m_pSerialPort->setReadBufferSize(512);
bRes = m_pSerialPort->setBaudRate(m_piSettings.iBaudRate);
return bRes;
}
bool CZZ_SeiralPort_QT::Open()
{
bool bRes = true;
// int iRes = sio_open(m_piSettings.iPortNumber);
// if (iRes!=SIO_OK)
// {
// bRes = false;
// }
bRes = m_pSerialPort->open(QIODevice::ReadWrite);
if (!bRes)
{
qDebug() << "Err:open Failed.Exit Code:1";
//std::cout << "Err.open Failed" << std::endl;
return bRes;;
}
return bRes;
}
void CZZ_SeiralPort_QT::Close()
{
m_pSerialPort->close();
}
std::string CZZ_SeiralPort_QT::ReadAll(int waite)
{
if (!m_pSerialPort->waitForReadyRead(waite))
{
return "";
}
if (
m_pSerialPort->bytesAvailable() == 0
)
{
return "";
}
qbaRecv.clear();
qbaRecv = m_pSerialPort->readAll();
std::string strRet(qbaRecv.constData(), qbaRecv.length());
return strRet;
// std::string strRet;
// char cBuf[MAXBUFFER];
// int iRet = sio_read(m_piSettings.iPortNumber,cBuf, MAXBUFFER);
// if (iRet==0)
// {
// strRet = "";
//
// }
// else
// {
// char *pRecv = new char[iRet];
// memcpy(pRecv, cBuf, iRet);
// //std::string strRet(pRecv);
// //delete pRecv;
// //return strRet;
//
// strRet.resize(iRet);
// for (int i=0;i<iRet;i++)
// {
// strRet[i] = pRecv[i];
// }
// delete pRecv;
// }
// return strRet;
}
int CZZ_SeiralPort_QT::Write(const std::string strSend)
{
QByteArray qbaTest(strSend.c_str(),(int)strSend.length());
qint64 qi64Write = m_pSerialPort->write(qbaTest);
m_pSerialPort->waitForBytesWritten(5000);
if (qi64Write != qbaTest.size())
{
qDebug() << "Err:write Failed.Exit Code:1" << qi64Write;
return qi64Write;
}
return 0;
// char* pcSend = (char*)strSend.c_str();
// int iRet = sio_write(m_piSettings.iPortNumber, pcSend, (int)strSend.length());
//
// //delete pcSend;
// if (iRet!= (int)strSend.length())
// {
// return iRet;
// }
// else
// {
// return 0;
// }
// //sio_write();
}

26
othersoft/shuttercali/source/LinearShutter/ZZ_SeiralPort.h Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include "VSMD12XMiscDefines.h"
#include "AbstractPort.h"
#include"qobject.h"
class CZZ_SeiralPort_QT :public CAbstractPort,QObject
{
private:
PortInfo m_piSettings;
QByteArray qbaSend, qbaRecv;
QSerialPort *m_pSerialPort;
public:
CZZ_SeiralPort_QT();
virtual ~CZZ_SeiralPort_QT();
public:
virtual void InitPort(PortInfo portinfo);
virtual bool SetPort();
virtual bool Open();
virtual void Close();
virtual std::string ReadAll(int waittime = 5000);
virtual int Write(const std::string strSend);
};

28
othersoft/shuttercali/source/LinearShutter/pch.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <iostream>
////////////////////////////setings
#include <QSettings>
#include <QMetaEnum>
////////////////////////////Basic
#include <QtCore/QCoreApplication>
#include <QString>
#include <QDebug>
#include <QDir>
#include <QObject>
////////////////////////////Thread
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
////////////////////////////json
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonParseError>
////////////////////////////time
#include <QtCore/QTime>
#include <QDateTime>
#include <QTimer>
////////////////////////////Serial I/O
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>

90
othersoft/shuttercali/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
othersoft/shuttercali/source/OSIF/DLib/SeaBreeze.dll Normal file
View File

Binary file not shown.

BIN
othersoft/shuttercali/source/OSIF/DLib/SeaBreeze.lib Normal file
View File

Binary file not shown.

63
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/source/OSIF/include/api/seabreezeapi/SeaBreezeAPI.h Normal file
View File

File diff suppressed because it is too large Load Diff

55
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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
othersoft/shuttercali/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 */

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