From 889d89bc652682763a4b6021d988195a1d8acb84 Mon Sep 17 00:00:00 2001 From: iximeow Date: Fri, 14 Aug 2020 20:20:25 -0700 Subject: update qhy sdk --- include/qhy/qhyccd.h | 851 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 790 insertions(+), 61 deletions(-) (limited to 'include/qhy/qhyccd.h') diff --git a/include/qhy/qhyccd.h b/include/qhy/qhyccd.h index 8f709e1..c14044b 100644 --- a/include/qhy/qhyccd.h +++ b/include/qhy/qhyccd.h @@ -1,139 +1,868 @@ -/* - QHYCCD SDK - - Copyright (c) 2014 QHYCCD. - All Rights Reserved. - - This program is free software; you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by the Free - Software Foundation; either version 2 of the License, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, but WITHOUT - ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - more details. - - You should have received a copy of the GNU General Public License along with - this program; if not, write to the Free Software Foundation, Inc., 59 - Temple Place - Suite 330, Boston, MA 02111-1307, USA. - - The full GNU General Public License is included in this distribution in the - file called LICENSE. - */ -#ifndef _QHYCCD_H_ -#define _QHYCCD_H_ -#include "qhycam.h" #include "qhyccderr.h" #include "qhyccdcamdef.h" #include "qhyccdstruct.h" #include "stdint.h" -#include "qhydevice.h" +#include "config.h" +#include + + + -#ifdef WIN32 + +#if defined (_WIN32) #include "cyapi.h" -typedef CCyUSBDevice qhyccd_handle; -#else // Linux & Mac -typedef struct libusb_device_handle qhyccd_handle; -uint32_t DeviceIsQHYCCD(uint32_t index, qhyccd_device *pDevice); -EXPORTC void STDCALL MutexInit(); -EXPORTC void STDCALL MutexDestroy(); -EXPORTC void STDCALL MutexLock(); -EXPORTC void STDCALL MutexUnlock(); -EXPORTC int STDCALL MutexTrylock(); -#endif // WIN32 - -class QHYBASE; -class QhyDevice; - -uint32_t DeviceIsQHYCCD(uint32_t index, uint32_t vid, uint32_t pid); -uint32_t QHYCCDSeriesMatch(uint32_t index, qhyccd_handle *pHandle); -uint32_t GetIdFromCam(qhyccd_handle *pHandle, char *id); - -EXPORTC QhyDevice* STDCALL GetCyDevBasedOnInstance(QHYBASE *pCam); -EXPORTC QhyDevice* STDCALL GetCyDevBasedOnHandle(qhyccd_handle *pHandle); -EXPORTC int GetCyDevIdxBasedOnInstance(QHYBASE *pCam); -EXPORTC int GetCyDevIdxBasedOnHandle(qhyccd_handle *pHandle); -EXPORTC uint32_t STDCALL GetReceivedRawDataLen(QHYBASE *pCam); -EXPORTC bool STDCALL SetReceivedRawDataLen(QHYBASE *pCam, uint32_t value); -EXPORTC bool STDCALL CleanUnlockImageQueue(QHYBASE *pCam); -//EXPORTC bool STDCALL SetUnlockImageQueue(QHYBASE *pCam); -EXPORTC uint32_t STDCALL InitQHYCCDClass(uint32_t camtype, uint32_t index); +#endif + +#ifndef __QHYCCD_H__ +#define __QHYCCD_H__ + +typedef void qhyccd_handle; + + +EXPORTFUNC void STDCALL SetQHYCCDAutoDetectCamera(bool enable); + +EXPORTC void STDCALL SetQHYCCDLogLevel(uint8_t logLevel); + +#if defined(__linux__ )&&!defined (__ANDROID__) + +EXPORTC void STDCALL SetQHYCCDLogFunction(std::function logFunction); +EXPORTC void STDCALL SetQHYCCDBufferNumber(uint32_t BufNumber); + +#endif + +EXPORTC void STDCALL EnableQHYCCDMessage(bool enable); +EXPORTC void STDCALL EnableQHYCCDLogFile(bool enable); + +EXPORTC uint32_t STDCALL SetQHYCCDSingleFrameTimeOut(qhyccd_handle *h,uint32_t time); + + +EXPORTC const char* STDCALL GetTimeStamp(); + +/** \fn uint32_t InitQHYCCDResource() + \brief initialize QHYCCD SDK resource + \return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_INITRESOURCE if the initialize failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL InitQHYCCDResource(void); + +/** \fn uint32_t ReleaseQHYCCDResource() + \brief release QHYCCD SDK resource + \return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_RELEASERESOURCE if the release failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL ReleaseQHYCCDResource(void); + +/** \fn uint32_t ScanQHYCCD() + \brief scan the connected cameras + \return + on success,return the number of connected cameras \n + QHYCCD_ERROR_NO_DEVICE,if no camera connect to computer + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL ScanQHYCCD(void); -EXPORTC uint32_t STDCALL GetQHYCCDId(int index, char *id); + +/** \fn uint32_t GetQHYCCDId(uint32_t index,char *id) + \brief get the id from camera + \param index sequence number of the connected cameras + \param id the id for camera,each camera has only id + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ +EXPORTC uint32_t STDCALL GetQHYCCDId(uint32_t index,char *id); + +/** \fn uint32_t GetQHYCCDModel(char *id, char *model) + \brief get camera model name by id + \param id the id of the camera + \param model the camera model + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code in failure + */ EXPORTC uint32_t STDCALL GetQHYCCDModel(char *id, char *model); + +/** \fn qhyccd_handle *OpenQHYCCD(char *id) + \brief open camera by camera id + \param id the id for camera,each camera has only id + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC qhyccd_handle * STDCALL OpenQHYCCD(char *id); + +/** \fn uint32_t CloseQHYCCD(qhyccd_handle *handle) + \brief close camera by handle + \param handle camera handle + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL CloseQHYCCD(qhyccd_handle *handle); + +/** + @fn uint32_t SetQHYCCDStreamMode(qhyccd_handle *handle,uint8_t mode) + @brief Set the camera's mode to chose the way reading data from camera + @param handle camera control handle + @param mode the stream mode \n + 0x00:default mode,single frame mode \n + 0x01:live mode \n + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDStreamMode(qhyccd_handle *handle,uint8_t mode); + +/** \fn uint32_t InitQHYCCD(qhyccd_handle *handle) + \brief initialization specified camera by camera handle + \param handle camera control handle + \return + on success,return QHYCCD_SUCCESS \n + on failed,return QHYCCD_ERROR_INITCAMERA \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL InitQHYCCD(qhyccd_handle *handle); + +/** @fn uint32_t IsQHYCCDControlAvailable(qhyccd_handle *handle,CONTROL_ID controlId) + @brief check the camera has the queried function or not + @param handle camera control handle + @param controlId function type + @return + on have,return QHYCCD_SUCCESS \n + on do not have,return QHYCCD_ERROR_NOTSUPPORT \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL IsQHYCCDControlAvailable(qhyccd_handle *handle,CONTROL_ID controlId); + +/** \fn uint32_t SetQHYCCDParam(qhyccd_handle *handle,CONTROL_ID controlId,double value) + \brief set params to camera + \param handle camera control handle + \param controlId function type + \param value value to camera + \return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_NOTSUPPORT,if the camera do not have the function \n + QHYCCD_ERROR_SETPARAMS,if set params to camera failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDParam(qhyccd_handle *handle,CONTROL_ID controlId, double value); + +/** \fn double GetQHYCCDParam(qhyccd_handle *handle,CONTROL_ID controlId) + \brief get the params value from camera + \param handle camera control handle + \param controlId function type + \return + on success,return the value\n + QHYCCD_ERROR_NOTSUPPORT,if the camera do not have the function \n + QHYCCD_ERROR_GETPARAMS,if get camera params'value failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC double STDCALL GetQHYCCDParam(qhyccd_handle *handle,CONTROL_ID controlId); + +/** \fn uint32_t GetQHYCCDParamMinMaxStep(qhyccd_handle *handle,CONTROL_ID controlId,double *min,double *max,double *step) + \brief get the params value from camera + \param handle camera control handle + \param controlId function type + \param *min the pointer to the function's min value + \param *max the pointer to the function's max value + \param *step the pointer to the function's single step value + \return + on success,return QHYCCD_SUCCESS\n + QHYCCD_ERROR_NOTSUPPORT,if the camera do not have the function \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDParamMinMaxStep(qhyccd_handle *handle,CONTROL_ID controlId,double *min,double *max,double *step); + +/** @fn uint32_t SetQHYCCDResolution(qhyccd_handle *handle,uint32_t x,uint32_t y,uint32_t xsize,uint32_t ysize) + @brief set camera ouput resolution + @param handle camera control handle + @param x the top left position x + @param y the top left position y + @param xsize the image width + @param ysize the image height + @return + on success,return QHYCCD_SUCCESS\n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDResolution(qhyccd_handle *handle,uint32_t x,uint32_t y,uint32_t xsize,uint32_t ysize); + +/** \fn uint32_t GetQHYCCDMemLength(qhyccd_handle *handle) + \brief get the minimum memory space for image data to save(byte) + \param handle camera control handle + \return + on success,return the total memory space for image data(byte) \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDMemLength(qhyccd_handle *handle); + +/** \fn uint32_t ExpQHYCCDSingleFrame(qhyccd_handle *handle) + \brief start to expose one frame + \param handle camera control handle + \return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_EXPOSING,if the camera is exposing \n + QHYCCD_ERROR_EXPFAILED,if start failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL ExpQHYCCDSingleFrame(qhyccd_handle *handle); + +/** + @fn uint32_t GetQHYCCDSingleFrame(qhyccd_handle *handle,uint32_t *w,uint32_t *h,uint32_t *bpp,uint32_t *channels,uint8_t *imgdata) + @brief get live frame data from camera + @param handle camera control handle + @param *w pointer to width of ouput image + @param *h pointer to height of ouput image + @param *bpp pointer to depth of ouput image + @param *channels pointer to channels of ouput image + @param *imgdata image data buffer + @return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_GETTINGFAILED,if get data failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDSingleFrame(qhyccd_handle *handle,uint32_t *w,uint32_t *h,uint32_t *bpp,uint32_t *channels,uint8_t *imgdata); + +/** + @fn uint32_t CancelQHYCCDExposing(qhyccd_handle *handle) + @param handle camera control handle + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL CancelQHYCCDExposing(qhyccd_handle *handle); + +/** + @fn uint32_t CancelQHYCCDExposingAndReadout(qhyccd_handle *handle) + @brief stop the camera exposing and readout + @param handle camera control handle + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL CancelQHYCCDExposingAndReadout(qhyccd_handle *handle); + +/** \fn uint32_t BeginQHYCCDLive(qhyccd_handle *handle) + \brief start continue exposing + \param handle camera control handle + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL BeginQHYCCDLive(qhyccd_handle *handle); + +/** + @fn uint32_t GetQHYCCDLiveFrame(qhyccd_handle *handle,uint32_t *w,uint32_t *h,uint32_t *bpp,uint32_t *channels,uint8_t *imgdata) + @brief get live frame data from camera + @param handle camera control handle + @param *w pointer to width of ouput image + @param *h pointer to height of ouput image + @param *bpp pointer to depth of ouput image + @param *channels pointer to channels of ouput image + @param *imgdata image data buffer + @return + on success,return QHYCCD_SUCCESS \n + QHYCCD_ERROR_GETTINGFAILED,if get data failed \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDLiveFrame(qhyccd_handle *handle,uint32_t *w,uint32_t *h,uint32_t *bpp,uint32_t *channels,uint8_t *imgdata); + +/** \fn uint32_t StopQHYCCDLive(qhyccd_handle *handle) + \brief stop the camera continue exposing + \param handle camera control handle + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL StopQHYCCDLive(qhyccd_handle *handle); + +/** \ + @fn uint32_t SetQHYCCDBinMode(qhyccd_handle *handle,uint32_t wbin,uint32_t hbin) + @brief set camera's bin mode for ouput image data + @param handle camera control handle + @param wbin width bin mode + @param hbin height bin mode + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SetQHYCCDBinMode(qhyccd_handle *handle,uint32_t wbin,uint32_t hbin); + +/** + @fn uint32_t SetQHYCCDBitsMode(qhyccd_handle *handle,uint32_t bits) + @brief set camera's depth bits for ouput image data + @param handle camera control handle + @param bits image depth + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDBitsMode(qhyccd_handle *handle,uint32_t bits); + +/** \fn uint32_t ControlQHYCCDTemp(qhyccd_handle *handle,double targettemp) + \brief This is a auto temprature control for QHYCCD cameras. \n + To control this,you need call this api every single second + \param handle camera control handle + \param targettemp the target control temprature + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL ControlQHYCCDTemp(qhyccd_handle *handle,double targettemp); + +/** \fn uint32_t ControlQHYCCDGuide(qhyccd_handle *handle,uint32_t direction,uint16_t duration) + \brief control the camera' guide port + \param handle camera control handle + \param direction direction \n + 0: EAST RA+ \n + 3: WEST RA- \n + 1: NORTH DEC+ \n + 2: SOUTH DEC- \n + \param duration duration of the direction + \return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL ControlQHYCCDGuide(qhyccd_handle *handle,uint32_t direction,uint16_t duration); + +/** + @fn uint32_t SendOrder2QHYCCDCFW(qhyccd_handle *handle,char *order,uint32_t length) + @brief control color filter wheel port + @param handle camera control handle + @param order order send to color filter wheel + @param length the order string length + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SendOrder2QHYCCDCFW(qhyccd_handle *handle,char *order,uint32_t length); + +/** + @fn uint32_t GetQHYCCDCFWStatus(qhyccd_handle *handle,char *status) + @brief control color filter wheel port + @param handle camera control handle + @param status the color filter wheel position status + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDCFWStatus(qhyccd_handle *handle,char *status); + +/** + @fn uint32_t IsQHYCCDCFWPlugged(qhyccd_handle *handle) + @brief control color filter wheel port + @param handle camera control handle + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL IsQHYCCDCFWPlugged(qhyccd_handle *handle); + +/** + \fn uint32_t SetQHYCCDTrigerMode(qhyccd_handle *handle,uint32_t trigerMode) + \brief set camera triger mode + \param handle camera control handle + \param trigerMode triger mode + \return +on success,return QHYCCD_SUCCESS \n +another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SetQHYCCDTrigerMode(qhyccd_handle *handle,uint32_t trigerMode); + +/** \fn void Bits16ToBits8(qhyccd_handle *h,uint8_t *InputData16,uint8_t *OutputData8,uint32_t imageX,uint32_t imageY,uint16_t B,uint16_t W) + \brief turn 16bits data into 8bits + \param h camera control handle + \param InputData16 for 16bits data memory + \param OutputData8 for 8bits data memory + \param imageX image width + \param imageY image height + \param B for stretch balck + \param W for stretch white + */ EXPORTC void STDCALL Bits16ToBits8(qhyccd_handle *h,uint8_t *InputData16,uint8_t *OutputData8,uint32_t imageX,uint32_t imageY,uint16_t B,uint16_t W); + +/** + @fn void HistInfo192x130(qhyccd_handle *h,uint32_t x,uint32_t y,uint8_t *InBuf,uint8_t *OutBuf) + @brief make the hist info + @param h camera control handle + @param x image width + @param y image height + @param InBuf for the raw image data + @param OutBuf for 192x130 8bits 3 channels image + */ EXPORTC void STDCALL HistInfo192x130(qhyccd_handle *h,uint32_t x,uint32_t y,uint8_t *InBuf,uint8_t *OutBuf); + + +/** + @fn uint32_t OSXInitQHYCCDFirmware(char *path) + @brief download the firmware to camera.(this api just need call in OSX system) + @param path path to HEX file + */ EXPORTC uint32_t STDCALL OSXInitQHYCCDFirmware(char *path); + +/** + @fn uint32_t OSXInitQHYCCDFirmware(char *path) + @brief download the firmware to camera.(this api just need call in OSX system) + @param path path to HEX file + */ +EXPORTC uint32_t STDCALL OSXInitQHYCCDFirmwareArray(); + + + +EXPORTC uint32_t STDCALL OSXInitQHYCCDAndroidFirmwareArray(int idVendor,int idProduct, + qhyccd_handle *handle); + + + +/** @fn uint32_t GetQHYCCDChipInfo(qhyccd_handle *h,double *chipw,double *chiph,uint32_t *imagew,uint32_t *imageh,double *pixelw,double *pixelh,uint32_t *bpp) + @brief get the camera's ccd/cmos chip info + @param h camera control handle + @param chipw chip size width + @param chiph chip size height + @param imagew chip output image width + @param imageh chip output image height + @param pixelw chip pixel size width + @param pixelh chip pixel size height + @param bpp chip pixel depth + */ EXPORTC uint32_t STDCALL GetQHYCCDChipInfo(qhyccd_handle *h,double *chipw,double *chiph,uint32_t *imagew,uint32_t *imageh,double *pixelw,double *pixelh,uint32_t *bpp); + +/** @fn uint32_t GetQHYCCDEffectiveArea(qhyccd_handle *h,uint32_t *startX, uint32_t *startY, uint32_t *sizeX, uint32_t *sizeY) + @brief get the camera's ccd/cmos chip info + @param h camera control handle + @param startX the Effective area x position + @param startY the Effective area y position + @param sizeX the Effective area x size + @param sizeY the Effective area y size + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDEffectiveArea(qhyccd_handle *h,uint32_t *startX, uint32_t *startY, uint32_t *sizeX, uint32_t *sizeY); + +/** @fn uint32_t GetQHYCCDOverScanArea(qhyccd_handle *h,uint32_t *startX, uint32_t *startY, uint32_t *sizeX, uint32_t *sizeY) + @brief get the camera's ccd/cmos chip info + @param h camera control handle + @param startX the OverScan area x position + @param startY the OverScan area y position + @param sizeX the OverScan area x size + @param sizeY the OverScan area y size + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDOverScanArea(qhyccd_handle *h,uint32_t *startX, uint32_t *startY, uint32_t *sizeX, uint32_t *sizeY); + + +/** @fn uint32_t SetQHYCCDFocusSetting(qhyccd_handle *h,uint32_t focusCenterX, uint32_t focusCenterY) + @brief Set the camera on focus mode + @param h camera control handle + @param focusCenterX + @param focusCenterY + @return + on success,return QHYCCD_SUCCESS \n + + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDFocusSetting(qhyccd_handle *h,uint32_t focusCenterX, uint32_t focusCenterY); + +/** @fn uint32_t GetQHYCCDExposureRemaining(qhyccd_handle *h) + @brief Get remaining ccd/cmos expose time + @param h camera control handle + @return + 100 or less 100,it means exposoure is over \n + another is remaining time + */ EXPORTC uint32_t STDCALL GetQHYCCDExposureRemaining(qhyccd_handle *h); + +/** @fn uint32_t GetQHYCCDFWVersion(qhyccd_handle *h,uint8_t *buf) + @brief Get the QHYCCD's firmware version + @param h camera control handle + @param buf buffer for version info + @return + on success,return QHYCCD_SUCCESS \n + + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDFWVersion(qhyccd_handle *h,uint8_t *buf); +EXPORTC uint32_t STDCALL GetQHYCCDFPGAVersion(qhyccd_handle *h, uint8_t fpga_index, uint8_t *buf); + +/** @fn uint32_t SetQHYCCDInterCamSerialParam(qhyccd_handle *h,uint32_t opt) + @brief Set InterCam serial2 params + @param h camera control handle + @param opt the param \n + opt: \n + 0x00 baud rate 9600bps 8N1 \n + 0x01 baud rate 4800bps 8N1 \n + 0x02 baud rate 19200bps 8N1 \n + 0x03 baud rate 28800bps 8N1 \n + 0x04 baud rate 57600bps 8N1 + @return + on success,return QHYCCD_SUCCESS \n + + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL SetQHYCCDInterCamSerialParam(qhyccd_handle *h,uint32_t opt); + +/** @fn uint32_t QHYCCDInterCamSerialTX(qhyccd_handle *h,char *buf,uint32_t length) + @brief Send data to InterCam serial2 + @param h camera control handle + @param buf buffer for data + @param length to send + @return + on success,return QHYCCD_SUCCESS \n + + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL QHYCCDInterCamSerialTX(qhyccd_handle *h,char *buf,uint32_t length); + +/** @fn uint32_t QHYCCDInterCamSerialRX(qhyccd_handle *h,char *buf) + @brief Get data from InterCam serial2 + @param h camera control handle + @param buf buffer for data + @return + on success,return the data number \n + + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL QHYCCDInterCamSerialRX(qhyccd_handle *h,char *buf); + +/** @fn uint32_t QHYCCDInterCamOledOnOff(qhyccd_handle *handle,uint8_t onoff) + @brief turn off or turn on the InterCam's Oled + @param handle camera control handle + @param onoff on or off the oled \n + 1:on \n + 0:off \n + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL QHYCCDInterCamOledOnOff(qhyccd_handle *handle,uint8_t onoff); + +/** + @fn uint32_t SetQHYCCDInterCamOledBrightness(qhyccd_handle *handle,uint8_t brightness) + @brief send data to show on InterCam's OLED + @param handle camera control handle + @param brightness the oled's brightness + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SetQHYCCDInterCamOledBrightness(qhyccd_handle *handle,uint8_t brightness); + +/** + @fn uint32_t SendFourLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messagetemp,char *messageinfo,char *messagetime,char *messagemode) + @brief spilit the message to two line,send to camera + @param handle camera control handle + @param messagetemp message for the oled's 1st line + @param messageinfo message for the oled's 2nd line + @param messagetime message for the oled's 3rd line + @param messagemode message for the oled's 4th line + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SendFourLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messagetemp,char *messageinfo,char *messagetime,char *messagemode); +/** + @fn uint32_t SendTwoLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messageTop,char *messageBottom) + @brief spilit the message to two line,send to camera + @param handle camera control handle + @param messageTop message for the oled's 1st line + @param messageBottom message for the oled's 2nd line + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SendTwoLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messageTop,char *messageBottom); + +/** + @fn uint32_t SendOneLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messageTop) + @brief spilit the message to two line,send to camera + @param handle camera control handle + @param messageTop message for all the oled + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL SendOneLine2QHYCCDInterCamOled(qhyccd_handle *handle,char *messageTop); + +/** + @fn uint32_t GetQHYCCDCameraStatus(qhyccd_handle *h,uint8_t *buf) + @brief Get the camera statu + @param h camera control handle + @param buf camera's status save space + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures + */ EXPORTC uint32_t STDCALL GetQHYCCDCameraStatus(qhyccd_handle *h,uint8_t *buf); + +/** + @fn uint32_t GetQHYCCDShutterStatus(qhyccd_handle *handle) + @brief get the camera's shutter status + @param handle camera control handle + @return + on success,return status \n + 0x00:shutter turn to right \n + 0x01:shutter from right turn to middle \n + 0x02:shutter from left turn to middle \n + 0x03:shutter turn to left \n + 0xff:IDLE \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL GetQHYCCDShutterStatus(qhyccd_handle *handle); + +/** + @fn uint32_t ControlQHYCCDShutter(qhyccd_handle *handle,uint8_t status) + @brief control camera's shutter + @param handle camera control handle + @param status the shutter status \n + 0x00:shutter turn to right \n + 0x01:shutter from right turn to middle \n + 0x02:shutter from left turn to middle \n + 0x03:shutter turn to left \n + 0xff:IDLE + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL ControlQHYCCDShutter(qhyccd_handle *handle,uint8_t status); + +/** + @fn uint32_t GetQHYCCDHumidity(qhyccd_handle *handle,double *hd) + @brief query cavity's humidity + @param handle control handle + @param hd the humidity value + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ +EXPORTC uint32_t STDCALL GetQHYCCDPressure(qhyccd_handle *handle,double *pressure); +/** + @fn uint32_t GetQHYCCDPressure(qhyccd_handle *handle,double *pressure) + @get the pressure of sensor chamber + @param handle control handle + @param pressure : the sensor chamber pressure . unit is mbar range 0.0-2000.0 + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ + EXPORTC uint32_t STDCALL GetQHYCCDHumidity(qhyccd_handle *handle,double *hd); + + +/** + @fn uint32_t QHYCCDI2CTwoWrite(qhyccd_handle *handle,uint16_t addr,uint16_t value) + @brief Set the value of the addr register in the camera. + @param handle camera control handle + @param addr the address of register + @param value the value of the address + @return + on success,return QHYCCD_SUCCESS \n + another QHYCCD_ERROR code on other failures +*/ EXPORTC uint32_t STDCALL QHYCCDI2CTwoWrite(qhyccd_handle *handle,uint16_t addr,uint16_t value); + +/** + @fn uint32_t QHYCCDI2CTwoRead(qhyccd_handle *handle,uint16_t addr) + @brief Get the value of the addr register in the camera. + @param handle camera control handle + @param addr the address of register + @return value of the addr register +*/ EXPORTC uint32_t STDCALL QHYCCDI2CTwoRead(qhyccd_handle *handle,uint16_t addr); + +/** + @fn double GetQHYCCDReadingProgress(qhyccd_handle *handle) + @brief get reading data from camera progress + @param handle camera control handle + @return current progress +*/ EXPORTC double STDCALL GetQHYCCDReadingProgress(qhyccd_handle *handle); -EXPORTC void STDCALL SetQHYCCDLogLevel(uint8_t logLevel); + + +/** + test pid parameters +*/ EXPORTC uint32_t STDCALL TestQHYCCDPIDParas(qhyccd_handle *h, double p, double i, double d); + EXPORTC uint32_t STDCALL SetQHYCCDTrigerFunction(qhyccd_handle *h,bool value); + EXPORTC uint32_t STDCALL DownloadFX3FirmWare(uint16_t vid,uint16_t pid,char *imgpath); + EXPORTC uint32_t STDCALL GetQHYCCDType(qhyccd_handle *h); + EXPORTC uint32_t STDCALL SetQHYCCDDebayerOnOff(qhyccd_handle *h,bool onoff); + EXPORTC uint32_t STDCALL SetQHYCCDFineTone(qhyccd_handle *h,uint8_t setshporshd,uint8_t shdloc,uint8_t shploc,uint8_t shwidth); + EXPORTC uint32_t STDCALL SetQHYCCDGPSVCOXFreq(qhyccd_handle *handle,uint16_t i); + EXPORTC uint32_t STDCALL SetQHYCCDGPSLedCalMode(qhyccd_handle *handle,uint8_t i); + EXPORTC void STDCALL SetQHYCCDGPSLedCal(qhyccd_handle *handle,uint32_t pos,uint8_t width); + EXPORTC void STDCALL SetQHYCCDGPSPOSA(qhyccd_handle *handle,uint8_t is_slave,uint32_t pos,uint8_t width); + EXPORTC void STDCALL SetQHYCCDGPSPOSB(qhyccd_handle *handle,uint8_t is_slave,uint32_t pos,uint8_t width); + EXPORTC uint32_t STDCALL SetQHYCCDGPSMasterSlave(qhyccd_handle *handle,uint8_t i); + EXPORTC void STDCALL SetQHYCCDGPSSlaveModeParameter(qhyccd_handle *handle,uint32_t target_sec,uint32_t target_us,uint32_t deltaT_sec,uint32_t deltaT_us,uint32_t expTime); + +EXPORTFUNC void STDCALL SetQHYCCDQuit(); + EXPORTC uint32_t STDCALL QHYCCDVendRequestWrite(qhyccd_handle *h,uint8_t req,uint16_t value,uint16_t index1,uint32_t length,uint8_t *data); + EXPORTC uint32_t STDCALL QHYCCDReadUSB_SYNC(qhyccd_handle *pDevHandle, uint8_t endpoint, uint32_t length, uint8_t *data, uint32_t timeout); + EXPORTC uint32_t STDCALL QHYCCDLibusbBulkTransfer(qhyccd_handle *pDevHandle, uint8_t endpoint, uint8_t *data, uint32_t length, int32_t *transferred, uint32_t timeout); + EXPORTC uint32_t STDCALL GetQHYCCDSDKVersion(uint32_t *year,uint32_t *month,uint32_t *day,uint32_t *subday); -EXPORTC void STDCALL print_cydev(const char *pTitle); -EXPORTC const char* STDCALL GetTimeStamp(); -EXPORTC void STDCALL GetQHYCCDControlIdString(CONTROL_ID controlId, char *pStr); -#endif // __QHYCCD_H__ + + + + +//APIs for the Readout Mode. One camera may have more than one readout mode. The different readout mode has different base-resolution. For example +//The QHY42PRO support HDR and STD mode. HDR mode base-resolution is 4096*2048. While the STD mode is 2048*2048. In this case we need to use the +//readout mode to set it. The host application need to get the readout mode and select one to set it. The sequece that call this fucntion need to be(......) + + +EXPORTC uint32_t STDCALL GetQHYCCDNumberOfReadModes(qhyccd_handle *h,uint32_t *numModes); +// Get the maximum resolution for a read mode +EXPORTC uint32_t STDCALL GetQHYCCDReadModeResolution(qhyccd_handle *h,uint32_t modeNumber, uint32_t* width, uint32_t* height); +// Get the name of a read mode +EXPORTC uint32_t STDCALL GetQHYCCDReadModeName(qhyccd_handle *h,uint32_t modeNumber, char* name); +// Set the read mode +EXPORTC uint32_t STDCALL SetQHYCCDReadMode(qhyccd_handle *h,uint32_t modeNumber); +// Get the read mode +EXPORTC uint32_t STDCALL GetQHYCCDReadMode(qhyccd_handle *h,uint32_t* modeNumber); + +EXPORTC uint32_t STDCALL GetQHYCCDBeforeOpenParam( + QHYCamMinMaxStepValue *p, + CONTROL_ID controlId); +/* +EXPORTC uint32_t STDCALL GetQHYCCDBeforeOpenReadMode(QHYCamReadModeInfo *p); +*/ +EXPORTC uint32_t STDCALL EnableQHYCCDBurstMode(qhyccd_handle *h,bool i); +EXPORTC uint32_t STDCALL SetQHYCCDBurstModeStartEnd(qhyccd_handle *h,unsigned short start,unsigned short end); +EXPORTC uint32_t STDCALL EnableQHYCCDBurstCountFun(qhyccd_handle *h,bool i); +EXPORTC uint32_t STDCALL ResetQHYCCDFrameCounter(qhyccd_handle *h); +EXPORTC uint32_t STDCALL SetQHYCCDBurstIDLE(qhyccd_handle *h); +EXPORTC uint32_t STDCALL ReleaseQHYCCDBurstIDLE(qhyccd_handle *h); +EXPORTC uint32_t STDCALL SetQHYCCDBurstModePatchNumber(qhyccd_handle *h,uint32_t value); +EXPORTC uint32_t STDCALL SetQHYCCDEnableLiveModeAntiRBI(qhyccd_handle *h,uint32_t value); +EXPORTC uint32_t STDCALL SetQHYCCDWriteFPGA(qhyccd_handle *h,uint8_t number,uint8_t regindex,uint8_t regvalue); +/** + @fn uint32_t SetQHYCCDWriteFPGA(qhyccd_handle *h,uint8_t number,uint8_t regindex,uint8_t regvalue); + @brief Write FPGA register of the camera directly for advanced control + @param handle camera control handle + @param number: if there is multiple FPGA, this is the sequence number . default is 0. + @param regindex: register index. It is 8bit. + @param regindex: register value. It is 8bit. + @return QHYCCD_SUCCESS or QHYCCD_ERROR. If it is QHYCCD_ERROR, it means (1) this model may have not support this function or (2) the API failur to run. +*/ + + +EXPORTC uint32_t STDCALL SetQHYCCDWriteCMOS(qhyccd_handle *h,uint8_t number,uint16_t regindex,uint16_t regvalue); +/** + @fn uint32_t SetQHYCCDWriteCMOS(qhyccd_handle *h,uint8_t number,uint16_t regindex,uint16_t regvalue); + @brief Write CMOS register of the camera directly for advanced control + @param handle camera control handle + @param number: if there is multiple CMOS, this is the sequence number . default is 0. + @param regindex: register index. It is 16bit. + @param regindex: register value. It is 16bit. + @return QHYCCD_SUCCESS or QHYCCD_ERROR. If it is QHYCCD_ERROR, it means (1) this model may have not support this function or (2) the API failur to run. +*/ + + +EXPORTFUNC uint32_t STDCALL SetQHYCCDTwoChannelCombineParameter(qhyccd_handle *handle, double x,double ah,double bh,double al,double bl); +/** + @fn uint32_t SetQHYCCDTwoChannelCombineParameter(qhyccd_handle *handle, double x,double ah,double bh,double al,double bl); + @brief For the camera with high gain low gain two channel combine to 16bit function, this API can set the combination parameters + @param handle camera control handle + @param x: High gain low gain channel data switch point. (based on the high gain channel data) + @param ah: High gain channel ratio (y=ax+b) + @param bh: High gain channel offset (y=ax+b) + @param al: Low gain channel ratio (y=ax+b) + @param bl: Low gain channel offset (y=ax+b) + @return QHYCCD_SUCCESS or QHYCCD_ERROR. If it is QHYCCD_ERROR, it means (1) this model may have not support this function or (2) the API failur to run. +*/ + +EXPORTC uint32_t STDCALL EnableQHYCCDImageOSD(qhyccd_handle *h,uint32_t i); + +EXPORTC void STDCALL QHYCCDQuit(); + +EXPORTC QHYDWORD STDCALL SetQHYCCDCallBack(QHYCCDProcCallBack ProcCallBack, + int32_t Flag); + +#if 0//PCIE_MODE_TEST + +#include "riffa.h" + + +/** + * Populates the fpga_info_list pointer with all FPGAs registered in the system. + * Returns 0 on success, non-zero on error. + */ +EXPORTC int STDCALL QHYCCD_fpga_list(struct fpga_info_list &list); + +/** + * Initializes the FPGA specified by id. On success, returns a pointer to a + * fpga_t struct. On error, returns NULL. Each FPGA must be opened before any + * channels can be accessed. Once opened, any number of threads can use the + * fpga_t struct. + */ +EXPORTC uint32_t STDCALL QHYCCD_fpga_open(int id); + +/** + * Cleans up memory/resources for the FPGA specified by the fd descriptor. + */ +EXPORTC void STDCALL QHYCCD_fpga_close(); + +/** + * Sends len words (4 byte words) from data to FPGA channel chnl using the + * fpga_t struct. The FPGA channel will be sent len, destoff, and last. If last + * is 1, the channel should interpret the end of this send as the end of a + * transaction. If last is 0, the channel should wait for additional sends + * before the end of the transaction. If timeout is non-zero, this call will + * send data and wait up to timeout ms for the FPGA to respond (between + * packets) before timing out. If timeout is zero, this call may block + * indefinitely. Multiple threads sending on the same channel may result in + * corrupt data or error. This function is thread safe across channels. + * Returns the number of words sent. + */ +EXPORTC int STDCALL QHYCCD_fpga_send(int chnl, void * data, int len, + int destoff, int last, uint64_t timeout); + +/** + * Receives data from the FPGA channel chnl to the data pointer, using the + * fpga_t struct. The FPGA channel can send any amount of data, so the data + * array should be large enough to accommodate. The len parameter specifies the + * actual size of the data buffer in words (4 byte words). The FPGA channel will + * specify an offset which will determine where in the data array the data will + * start being written. If the amount of data (plus offset) exceed the size of + * the data array (len), then that data will be discarded. If timeout is + * non-zero, this call will wait up to timeout ms for the FPGA to respond + * (between packets) before timing out. If timeout is zero, this call may block + * indefinitely. Multiple threads receiving on the same channel may result in + * corrupt data or error. This function is thread safe across channels. + * Returns the number of words received to the data array. + */ +EXPORTC int STDCALL QHYCCD_fpga_recv( int chnl, void * data, int len, + uint64_t timeout); + +/** + * Resets the state of the FPGA and all transfers across all channels. This is + * meant to be used as an alternative to rebooting if an error occurs while + * sending/receiving. Calling this function while other threads are sending or + * receiving will result in unexpected behavior. + */ +EXPORTC void STDCALL QHYCCD_fpga_reset(); +#endif + +#endif -- cgit v1.1