bool MICCD::Connect()
{
uint32_t cap = 0;
if (isSimulation())
{
LOGF_INFO("Connected to %s", name);
cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_SHUTTER | CCD_HAS_COOLER;
SetCCDCapability(cap);
numFilters = 5;
return true;
}
if (!cameraHandle)
{
if (isEth)
cameraHandle = gxccd_initialize_eth(cameraId);
else
cameraHandle = gxccd_initialize_usb(cameraId);
}
if (!cameraHandle)
{
LOGF_ERROR("Error connecting to %s.", name);
return false;
}
LOGF_INFO("Connected to %s.", name);
bool value;
cap = CCD_CAN_ABORT | CCD_CAN_BIN;
gxccd_get_boolean_parameter(cameraHandle, GBP_SUB_FRAME, &value);
if (value)
cap |= CCD_CAN_SUBFRAME;
gxccd_get_boolean_parameter(cameraHandle, GBP_GUIDE, &value);
if (value)
cap |= CCD_HAS_ST4_PORT;
gxccd_get_boolean_parameter(cameraHandle, GBP_SHUTTER, &value);
if (value)
cap |= CCD_HAS_SHUTTER;
gxccd_get_boolean_parameter(cameraHandle, GBP_COOLER, &value);
if (value)
cap |= CCD_HAS_COOLER;
gxccd_get_boolean_parameter(cameraHandle, GBP_GAIN, &hasGain);
gxccd_get_boolean_parameter(cameraHandle, GBP_PREFLASH, &canDoPreflash);
SetCCDCapability(cap);
return true;
}
bool MICCD::Connect()
{
uint32_t cap = 0;
if (isSimulation())
{
DEBUGF(INDI::Logger::DBG_SESSION, "Connected to %s", name);
cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_SHUTTER | CCD_HAS_COOLER;
SetCCDCapability(cap);
numFilters = 5;
return true;
}
if (!cameraHandle) {
if (isEth)
cameraHandle = gxccd_initialize_eth(cameraId);
else
cameraHandle = gxccd_initialize_usb(cameraId);
}
if (!cameraHandle) {
DEBUGF(INDI::Logger::DBG_ERROR, "Error connecting to %s.", name);
return false;
}
DEBUGF(INDI::Logger::DBG_SESSION, "Connected to %s.", name);
bool value;
cap = CCD_CAN_ABORT | CCD_CAN_BIN;
gxccd_get_boolean_parameter(cameraHandle, GBP_SUB_FRAME, &value);
if (value)
cap |= CCD_CAN_SUBFRAME;
gxccd_get_boolean_parameter(cameraHandle, GBP_GUIDE, &value);
if (value)
cap |= CCD_HAS_ST4_PORT;
gxccd_get_boolean_parameter(cameraHandle, GBP_SHUTTER, &value);
if (value)
cap |= CCD_HAS_SHUTTER;
gxccd_get_boolean_parameter(cameraHandle, GBP_COOLER, &value);
if (value)
cap |= CCD_HAS_COOLER;
gxccd_get_boolean_parameter(cameraHandle, GBP_GAIN, &hasGain);
SetCCDCapability(cap);
return true;
}
bool ASICCD::initProperties()
{
INDI::CCD::initProperties();
IUFillNumber(&CoolerN[0], "CCD_COOLER_VALUE", "Cooling Power (%)", "%+06.2f", 0., 1., .2, 0.0);
IUFillNumberVector(&CoolerNP, CoolerN, 1, getDeviceName(), "CCD_COOLER_POWER", "Cooling Power", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
IUFillNumberVector(&ControlNP, NULL, 0, getDeviceName(), "CCD_CONTROLS", "Controls", CONTROL_TAB, IP_RW, 60, IPS_IDLE);
IUFillSwitchVector(&ControlSP, NULL, 0, getDeviceName(), "CCD_CONTROLS_MODE", "Set Auto", CONTROL_TAB, IP_RW, ISR_NOFMANY, 60, IPS_IDLE);
IUFillSwitchVector(&VideoFormatSP, NULL, 0, getDeviceName(), "CCD_VIDEO_FORMAT", "Format", CONTROL_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUSaveText(&BayerT[2], getBayerString());
int maxBin=1;
for (int i=0; i < 16; i++)
{
if (m_camInfo->SupportedBins[i] != 0)
maxBin = m_camInfo->SupportedBins[i];
else
break;
}
PrimaryCCD.setResolution(m_camInfo->MaxWidth, m_camInfo->MaxHeight);
PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", MIN_DURATION, 3600, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "HOR_BIN", 1, maxBin, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "VER_BIN", 1, maxBin, 1, false);
uint32_t cap =0;
cap |= CCD_CAN_ABORT;
if (maxBin > 1)
cap |= CCD_CAN_BIN;
cap |= CCD_CAN_SUBFRAME;
if (m_camInfo->IsCoolerCam)
cap |= CCD_HAS_COOLER;
if (m_camInfo->MechanicalShutter)
cap |= CCD_HAS_SHUTTER;
if (m_camInfo->ST4Port)
cap |= CCD_HAS_ST4_PORT;
if (m_camInfo->IsColorCam)
cap |= CCD_HAS_BAYER;
#ifndef OSX_EMBEDED_MODE
cap |= CCD_HAS_STREAMING;
#endif
SetCCDCapability(cap);
addAuxControls();
return true;
}
FFMVCCD::FFMVCCD()
{
InExposure = false;
capturing = false;
setVersion(FFMV_VERSION_MAJOR, FFMV_VERSION_MINOR);
SetCCDCapability(CCD_CAN_ABORT);
}
bool GPhotoCCD::initProperties()
{
// Init parent properties first
INDI::CCD::initProperties();
initFocuserProperties(getDeviceName(), FOCUS_TAB);
IUFillText(&mPortT[0], "PORT" , "Port", "");
IUFillTextVector(&PortTP, mPortT, NARRAY(mPortT), getDeviceName(), "DEVICE_PORT" , "Shutter Release", MAIN_CONTROL_TAB, IP_RW, 0, IPS_IDLE);
IUFillNumber(&mMirrorLockN[0], "MIRROR_LOCK_SECONDS" , "Seconds", "%1.0f", 0, 10, 1, 0);
IUFillNumberVector(&mMirrorLockNP, mMirrorLockN, 1, getDeviceName(), "MIRROR_LOCK" , "Mirror Lock", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
//We don't know how many items will be in the switch yet
IUFillSwitchVector(&mIsoSP, NULL, 0, getDeviceName(), "CCD_ISO", "ISO", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUFillSwitchVector(&mFormatSP, NULL, 0, getDeviceName(), "CAPTURE_FORMAT", "Capture Format", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUFillSwitch(&autoFocusS[0], "Set", "", ISS_OFF);
IUFillSwitchVector(&autoFocusSP, autoFocusS, 1, getDeviceName(), "Auto Focus", "", FOCUS_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
IUFillSwitch(&transferFormatS[0], "FITS", "", ISS_ON);
IUFillSwitch(&transferFormatS[1], "Native", "", ISS_OFF);
IUFillSwitchVector(&transferFormatSP, transferFormatS, 2, getDeviceName(), "Transfer Format", "", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
IUFillSwitch(&livePreviewS[0], "Enable", "", ISS_OFF);
IUFillSwitch(&livePreviewS[1], "Disable", "", ISS_ON);
IUFillSwitchVector(&livePreviewSP, livePreviewS, 2, getDeviceName(), "VIDEO_STREAM", "Preview", MAIN_CONTROL_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", 0.001, 3600, 1, false);
// Most cameras have this by default, so let's set it as default.
IUSaveText(&BayerT[2], "RGGB");
SetCCDCapability(CCD_CAN_SUBFRAME | CCD_HAS_BAYER);
SetFocuserCapability(FOCUSER_HAS_VARIABLE_SPEED);
FocusSpeedN[0].min=0;
FocusSpeedN[0].max=3;
FocusSpeedN[0].step=1;
FocusSpeedN[0].value=1;
/* JM 2014-05-20 Make PrimaryCCD.ImagePixelSizeNP writable since we can't know for now the pixel size and bit depth from gphoto */
PrimaryCCD.getCCDInfo()->p = IP_RW;
setDriverInterface(getDriverInterface() | FOCUSER_INTERFACE);
gphoto_set_debug(getDeviceName());
gphoto_read_set_debug(getDeviceName());
return true;
}
bool INovaCCD::Connect()
{
const char *Sn;
if(iNovaSDK_MaxCamera() > 0)
{
Sn = iNovaSDK_OpenCamera(1);
LOGF_DEBUG("Serial Number: %s", Sn);
if(Sn[0] >= '0' && Sn[0] < '3')
{
iNovaSDK_InitST4();
LOGF_INFO("Camera model is %s", iNovaSDK_GetName());
iNovaSDK_InitCamera(RESOLUTION_FULL);
//maxW = iNovaSDK_GetImageWidth();
//maxH = iNovaSDK_GetImageHeight();
iNovaSDK_SetFrameSpeed(FRAME_SPEED_LOW);
iNovaSDK_CancelLongExpTime();
iNovaSDK_OpenVideo();
CameraPropertiesNP.s = IPS_IDLE;
// Set camera capabilities
uint32_t cap = CCD_CAN_ABORT | CCD_CAN_BIN | CCD_CAN_SUBFRAME | (iNovaSDK_HasST4() ? CCD_HAS_ST4_PORT : 0);
SetCCDCapability(cap);
if(iNovaSDK_HasColorSensor())
{
IUSaveText(&BayerT[2], "RGGB");
IDSetText(&BayerTP, nullptr);
SetCCDCapability(GetCCDCapability() | CCD_HAS_BAYER);
}
return true;
}
iNovaSDK_CloseCamera();
}
LOG_ERROR("No cameras opened.");
return false;
}
/*******************************************************************************
** Client is asking us to establish connection to the device
*******************************************************************************/
bool DSICCD::Connect()
{
uint32_t cap=0;
string ccd;
dsi = DSI::DeviceFactory::getInstance(NULL);
if (!dsi) {
/* The vendor and product ID for all DSI's (I/II/III) are the same.
* When the Cypress FX2 firmware hasn't been loaded, the PID will
* be 0x0100. Once the fw is loaded, the PID becomes 0x0101.
*/
DEBUG(INDI::Logger::DBG_SESSION,
"Unable to find DSI. Has the firmware been loaded?");
return false;
}
ccd = dsi->getCcdChipName();
if (ccd == "ICX254AL") {
DEBUG(INDI::Logger::DBG_SESSION, "Found a DSI Pro!");
} else if (ccd == "ICX429ALL") {
DEBUG(INDI::Logger::DBG_SESSION, "Found a DSI Pro II!");
} else if (ccd == "ICX429AKL") {
DEBUG(INDI::Logger::DBG_SESSION, "Found a DSI Color II!");
} else if (ccd == "ICX404AK") {
DEBUG(INDI::Logger::DBG_SESSION, "Found a DSI Color!");
} else if (ccd == "ICX285AL") {
DEBUG(INDI::Logger::DBG_SESSION, "Found a DSI Pro III!");
} else {
DEBUGF(INDI::Logger::DBG_SESSION, "Found a DSI with an unknown CCD: %s", ccd.c_str());
}
cap |= CCD_CAN_ABORT;
if (dsi->isBinnable())
cap |= CCD_CAN_BIN;
if (dsi->isColor())
cap |= CCD_HAS_BAYER;
SetCCDCapability(cap);
if (dsi->hasTempSensor())
{
CCDTempN[0].value = dsi->ccdTemp();
IDSetNumber(&CCDTempNP, NULL);
}
return true;
}
bool FishCampCCD::initProperties()
{
// Init parent properties first
INDI::CCD::initProperties();
IUFillNumber(&GainN[0], "Range", "", "%g", 1, 15, 1., 4.);
IUFillNumberVector(&GainNP, GainN, 1, getDeviceName(), "Gain", "", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
IUFillNumber(&CoolerN[0], "Power %", "", "%g", 1, 100, 0, 0.0);
IUFillNumberVector(&CoolerNP, CoolerN, 1, getDeviceName(), "Cooler", "", MAIN_CONTROL_TAB, IP_RO, 0, IPS_IDLE);
char *strBuf = new char[MAXINDINAME];
IUFillText(&CamInfoT[0], "Name", "", name);
IUFillText(&CamInfoT[1], "Serial #", "", (char *)&camInfo.camSerialStr);
snprintf(strBuf, MAXINDINAME, "%d", camInfo.boardVersion);
IUFillText(&CamInfoT[2], "Board version", "", strBuf);
snprintf(strBuf, MAXINDINAME, "%d", camInfo.boardRevision);
IUFillText(&CamInfoT[3], "Board revision", "", strBuf);
snprintf(strBuf, MAXINDINAME, "%d", camInfo.fpgaVersion);
IUFillText(&CamInfoT[4], "FPGA version", "", strBuf);
snprintf(strBuf, MAXINDINAME, "%d", camInfo.fpgaRevision);
IUFillText(&CamInfoT[5], "FPGA revision", "", strBuf);
IUFillTextVector(&CamInfoTP, CamInfoT, 6, getDeviceName(), "Camera Info", "", MAIN_CONTROL_TAB, IP_RO, 0, IPS_IDLE);
SetCCDParams(camInfo.width, camInfo.height, 16, camInfo.pixelWidth / 10.0, camInfo.pixelHeight / 10.0);
int nbuf;
nbuf = PrimaryCCD.getXRes() * PrimaryCCD.getYRes() * PrimaryCCD.getBPP() / 8; // this is pixel cameraCount
nbuf += 512; // leave a little extra at the end
PrimaryCCD.setFrameBufferSize(nbuf);
SetCCDCapability(CCD_CAN_ABORT | CCD_CAN_SUBFRAME | CCD_HAS_COOLER | CCD_HAS_ST4_PORT);
delete[] strBuf;
return true;
}
bool QSICCD::Connect()
{
bool connected;
DEBUG(INDI::Logger::DBG_SESSION, "Attempting to find QSI CCD...");
try
{
QSICam.get_Connected(&connected);
} catch (std::runtime_error err)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: get_Connected() failed. %s.", err.what());
return false;
}
if(!connected)
{
try
{
QSICam.put_Connected(true);
} catch (std::runtime_error err)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: put_Connected(true) failed. %s.", err.what());
return false;
}
}
bool hasST4Port=false;
try
{
QSICam.get_CanPulseGuide(&hasST4Port);
}
catch (std::runtime_error err)
{
DEBUGF(INDI::Logger::DBG_ERROR, "get_canPulseGuide() failed. %s.", err.what());
return false;
}
try
{
QSICam.get_CanAbortExposure(&canAbort);
} catch (std::runtime_error err)
{
DEBUGF(INDI::Logger::DBG_ERROR, "get_CanAbortExposure() failed. %s.", err.what());
return false;
}
uint32_t cap= CCD_CAN_BIN | CCD_CAN_SUBFRAME | CCD_HAS_COOLER | CCD_HAS_SHUTTER;
if (canAbort)
cap |= CCD_CAN_ABORT;
if (hasST4Port)
cap |= CCD_HAS_ST4_PORT;
SetCCDCapability(cap);
/* Success! */
DEBUG(INDI::Logger::DBG_SESSION, "CCD is online. Retrieving basic data.");
return true;
}
bool QHYCCD::Connect()
{
unsigned int ret = 0;
uint32_t cap;
sim = isSimulation();
if (sim)
{
cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_COOLER | CCD_HAS_ST4_PORT;
SetCCDCapability(cap);
HasUSBTraffic = true;
HasUSBSpeed = true;
HasGain = true;
HasOffset = true;
HasFilters = true;
return true;
}
// Query the current CCD cameras. This method makes the driver more robust and
// it fixes a crash with the new QHC SDK when the INDI driver reopens the same camera
// with OpenQHYCCD() without a ScanQHYCCD() call before.
// 2017-12-15 JM: No this method ReleaseQHYCCDResource which ends up clearing handles for multiple
// cameras
/*std::vector<std::string> devices = GetDevicesIDs();
// The CCD device is not available anymore
if (std::find(devices.begin(), devices.end(), std::string(camid)) == devices.end())
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: Camera %s is not connected", camid);
return false;
}*/
camhandle = OpenQHYCCD(camid);
if (camhandle != NULL)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Connected to %s.", camid);
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME | CCD_HAS_STREAMING;
// Disable the stream mode before connecting
ret = SetQHYCCDStreamMode(camhandle, 0);
if (ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: Can not disable stream mode (%d)", ret);
}
ret = InitQHYCCD(camhandle);
if (ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: Init Camera failed (%d)", ret);
return false;
}
ret = IsQHYCCDControlAvailable(camhandle, CAM_MECHANICALSHUTTER);
if (ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_SHUTTER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Shutter Control: %s", cap & CCD_HAS_SHUTTER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_COOLER);
if (ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_COOLER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Cooler Control: %s", cap & CCD_HAS_COOLER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_ST4PORT);
if (ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_ST4_PORT;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Guider Port Control: %s", cap & CCD_HAS_ST4_PORT ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_SPEED);
if (ret == QHYCCD_SUCCESS)
{
HasUSBSpeed = true;
// Force a certain speed on initialization of QHY5PII-C:
// CONTROL_SPEED = 2 - Fastest, but the camera gets stuck with long exposure times.
// CONTROL_SPEED = 1 - This is safe with the current driver.
// CONTROL_SPEED = 0 - This is safe, but slower than 1.
if (isQHY5PIIC())
SetQHYCCDParam(camhandle, CONTROL_SPEED, 1);
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Speed Control: %s", HasUSBSpeed ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_GAIN);
if (ret == QHYCCD_SUCCESS)
{
HasGain = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Gain Control: %s", HasGain ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_OFFSET);
if (ret == QHYCCD_SUCCESS)
{
HasOffset = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Offset Control: %s", HasOffset ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_CFWPORT);
if (ret == QHYCCD_SUCCESS)
{
HasFilters = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Has Filters: %s", HasFilters ? "True" : "False");
// Using software binning
cap |= CCD_CAN_BIN;
camxbin = 1;
camybin = 1;
// Always use INDI software binning
//useSoftBin = true;
ret = IsQHYCCDControlAvailable(camhandle,CAM_BIN1X1MODE);
if(ret == QHYCCD_SUCCESS)
{
camxbin = 1;
camybin = 1;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Bin 1x1: %s", (ret == QHYCCD_SUCCESS) ? "True" : "False");
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN2X2MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN3X3MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN4X4MODE);
// Only use software binning if NOT supported by hardware
//useSoftBin = !(ret == QHYCCD_SUCCESS);
DEBUGF(INDI::Logger::DBG_DEBUG, "Binning Control: %s", cap & CCD_CAN_BIN ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CONTROL_USBTRAFFIC);
if (ret == QHYCCD_SUCCESS)
{
HasUSBTraffic = true;
// Force the USB traffic value to 30 on initialization of QHY5PII-C otherwise
// the camera has poor transfer speed.
if (isQHY5PIIC())
SetQHYCCDParam(camhandle, CONTROL_USBTRAFFIC, 30);
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Traffic Control: %s", HasUSBTraffic ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle, CAM_COLOR);
//if(ret != QHYCCD_ERROR && ret != QHYCCD_ERROR_NOTSUPPORT)
if (ret != QHYCCD_ERROR)
{
if (ret == BAYER_GB)
IUSaveText(&BayerT[2], "GBRG");
else if (ret == BAYER_GR)
IUSaveText(&BayerT[2], "GRBG");
else if (ret == BAYER_BG)
IUSaveText(&BayerT[2], "BGGR");
else
IUSaveText(&BayerT[2], "RGGB");
DEBUGF(INDI::Logger::DBG_DEBUG, "Color CCD: %s", BayerT[2].text);
cap |= CCD_HAS_BAYER;
}
SetCCDCapability(cap);
terminateThread = false;
pthread_create(&primary_thread, NULL, &streamVideoHelper, this);
return true;
}
DEBUGF(INDI::Logger::DBG_ERROR, "Connecting to CCD failed (%s)", camid);
return false;
}
bool QHYCCD::Connect()
{
sim = isSimulation();
int ret;
uint32_t cap;
if (sim)
{
cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_COOLER | CCD_HAS_ST4_PORT;
SetCCDCapability(cap);
HasUSBTraffic = true;
HasUSBSpeed = true;
HasGain = true;
HasOffset = true;
HasFilters = true;
return true;
}
camhandle = OpenQHYCCD(camid);
if(camhandle != NULL)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Connected to %s.",camid);
#ifdef OSX_EMBEDED_MODE
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME;
#else
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME | CCD_HAS_STREAMING;
#endif
ret = InitQHYCCD(camhandle);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: Init Camera failed (%d)", ret);
return false;
}
ret = IsQHYCCDControlAvailable(camhandle,CAM_MECHANICALSHUTTER);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_SHUTTER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Shutter Control: %s", cap & CCD_HAS_SHUTTER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_COOLER);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_COOLER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Cooler Control: %s", cap & CCD_HAS_COOLER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_ST4PORT);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_ST4_PORT;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Guider Port Control: %s", cap & CCD_HAS_ST4_PORT ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_SPEED);
if(ret == QHYCCD_SUCCESS)
{
HasUSBSpeed = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Speed Control: %s", HasUSBSpeed ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_GAIN);
if(ret == QHYCCD_SUCCESS)
{
HasGain = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Gain Control: %s", HasGain ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_OFFSET);
if(ret == QHYCCD_SUCCESS)
{
HasOffset = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Offset Control: %s", HasOffset ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_CFWPORT);
if(ret == QHYCCD_SUCCESS)
{
HasFilters = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Has Filters: %s", HasFilters ? "True" : "False");
// Using software binning
cap |= CCD_CAN_BIN;
camxbin = 1;
camybin = 1;
ret = IsQHYCCDControlAvailable(camhandle,CAM_BIN1X1MODE);
if(ret == QHYCCD_SUCCESS)
{
camxbin = 1;
camybin = 1;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Bin 1x1: %s", (ret == QHYCCD_SUCCESS) ? "True" : "False");
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN2X2MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN3X3MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN4X4MODE);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_CAN_BIN;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Binning Control: %s", cap & CCD_CAN_BIN ? "True" : "False");
ret= IsQHYCCDControlAvailable(camhandle, CONTROL_USBTRAFFIC);
if (ret == QHYCCD_SUCCESS)
{
HasUSBTraffic = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Traffic Control: %s", HasUSBTraffic ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CAM_COLOR);
//if(ret != QHYCCD_ERROR && ret != QHYCCD_ERROR_NOTSUPPORT)
if(ret != QHYCCD_ERROR)
{
if(ret == BAYER_GB)
IUSaveText(&BayerT[2], "GBGR");
else if (ret == BAYER_GR)
IUSaveText(&BayerT[2], "GRGB");
else if (ret == BAYER_BG)
IUSaveText(&BayerT[2], "BGGR");
else
IUSaveText(&BayerT[2], "RGGB");
DEBUGF(INDI::Logger::DBG_DEBUG, "Color CCD: %s", BayerT[2].text);
cap |= CCD_HAS_BAYER;
}
SetCCDCapability(cap);
#ifndef OSX_EMBEDED_MODE
pthread_create( &primary_thread, NULL, &streamVideoHelper, this);
#endif
return true;
}
DEBUGF(INDI::Logger::DBG_ERROR, "Connecting to CCD failed (%s)",camid);
return false;
}
bool ATIKCCD::setupParams()
{
ARTEMISPROPERTIES pProp;
int rc = ArtemisProperties(hCam, &pProp);
if (rc != ARTEMIS_OK)
{
LOGF_ERROR("Failed to inquire camera properties (%d)", rc);
return false;
}
// Camera & Pixel properties
// FIXME is it always 16bit depth?
SetCCDParams(pProp.nPixelsX, pProp.nPixelsY, 16, pProp.PixelMicronsX, pProp.PixelMicronsY);
// Set frame buffer size
PrimaryCCD.setFrameBufferSize(PrimaryCCD.getXRes() * PrimaryCCD.getYRes() * PrimaryCCD.getBPP() / 8, false);
m_CameraFlags = pProp.cameraflags;
LOGF_DEBUG("Camera flags: %d", m_CameraFlags);
int binX = 1, binY = 1;
rc = ArtemisGetMaxBin(hCam, &binX, &binY);
if (rc != ARTEMIS_OK)
{
LOGF_ERROR("Failed to inquire camera max binning (%d)", rc);
}
PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", 0.001, 3600, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "HOR_BIN", 1, binX, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "VER_BIN", 1, binY, 1, false);
IUSaveText(&VersionInfoS[VERSION_FIRMWARE], std::to_string(pProp.Protocol).c_str());
LOGF_INFO("Detected camera %s %s with firmware %s", pProp.Manufacturer, pProp.Description, std::to_string(pProp.Protocol).c_str());
uint32_t cap = 0;
// All Atik cameras can abort and subframe
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME;
// Can we bin?
if (binX > 1)
{
cap |= CCD_CAN_BIN;
LOG_DEBUG("Camera can bin.");
}
// Do we have color or mono camera?
ARTEMISCOLOURTYPE colorType;
rc = ArtemisColourProperties(hCam, &colorType, &normalOffsetX, &normalOffsetY, &previewOffsetX, &previewOffsetY);
if (rc != ARTEMIS_OK)
{
LOGF_ERROR("Failed to inquire camera color (%d). Assuming Mono.", rc);
}
if (colorType == ARTEMIS_COLOUR_RGGB)
{
cap |= CCD_HAS_BAYER;
IUSaveText(&BayerT[0], std::to_string(normalOffsetX).c_str());
IUSaveText(&BayerT[1], std::to_string(normalOffsetY).c_str());
}
LOGF_DEBUG("Camera is %s.", colorType == ARTEMIS_COLOUR_RGGB ? "Color" : "Mono");
// Do we have temperature?
rc = ArtemisTemperatureSensorInfo(hCam, 0, &m_TemperatureSensorsCount);
LOGF_DEBUG("Camera has %d temperature sensor(s).", m_TemperatureSensorsCount);
if (m_TemperatureSensorsCount > 0)
{
// Do we have cooler control?
int flags, level, minlvl, maxlvl, setpoint;
rc = ArtemisCoolingInfo(hCam, &flags, &level, &minlvl, &maxlvl, &setpoint);
if (flags & 0x1)
{
LOG_DEBUG("Camera supports cooling control.");
cap |= CCD_HAS_COOLER;
}
genTimerID = SetTimer(TEMP_TIMER_MS);
}
// Do we have mechanical shutter?
if (m_CameraFlags & ARTEMIS_PROPERTIES_CAMERAFLAGS_HAS_SHUTTER)
{
LOG_DEBUG("Camera has mechanical shutter.");
cap |= CCD_HAS_SHUTTER;
}
// Do we have guide port?
if (m_CameraFlags & ARTEMIS_PROPERTIES_CAMERAFLAGS_HAS_GUIDE_PORT)
{
LOG_DEBUG("Camera has guide port.");
cap |= CCD_HAS_ST4_PORT;
}
// Done with the capabilities!
SetCCDCapability(cap);
// Check if camra has internal filter wheel
if (m_CameraFlags & ARTEMIS_PROPERTIES_CAMERAFLAGS_HAS_FILTERWHEEL)
{
int numFilters, moving, currentPos, targetPos;
rc = ArtemisFilterWheelInfo(hCam, &numFilters, &moving, ¤tPos, &targetPos);
if (rc != ARTEMIS_OK)
{
LOGF_ERROR("Failed to inquire internal filter wheel info (%d). Filter wheel functions are disabled.", rc);
}
else
{
setDriverInterface(getDriverInterface() | FILTER_INTERFACE);
FilterSlotN[0].min = 1;
FilterSlotN[0].max = numFilters;
LOGF_INFO("Detected %d-position internal filter wheel.", numFilters);
}
}
// Check if we have Horizon camera
m_isHorizon = ArtemisHasCameraSpecificOption(hCam, 1);
if (m_isHorizon)
{
uint8_t data[2] = {0};
int len = 0, index = 0;
ArtemisCameraSpecificOptionGetData(hCam, ID_AtikHorizonGOPresetMode, data, 2, &len);
index = *(reinterpret_cast<uint16_t*>(&data));
LOGF_DEBUG("Horizon current GO mode: data[0] %d data[1] %d index %d", data[0], data[1], index);
IUResetSwitch(&ControlPresetsSP);
ControlPresetsS[index].s = ISS_ON;
// Get Gain & Offset valuse
ArtemisCameraSpecificOptionGetData(hCam, ID_AtikHorizonGOCustomGain, data, 2, &len);
index = *(reinterpret_cast<uint16_t*>(&data));
LOGF_DEBUG("Horizon current gain: data[0] %d data[1] %d value %d", data[0], data[1], index);
ArtemisCameraSpecificOptionGetData(hCam, ID_AtikHorizonGOCustomOffset, data, 2, &len);
index = *(reinterpret_cast<uint16_t*>(&data));
LOGF_DEBUG("Horizon current offset: data[0] %d data[1] %d value %d", data[0], data[1], index);
}
// Create imaging thread
threadRequest = StateIdle;
threadState = StateNone;
int stat = pthread_create(&imagingThread, nullptr, &imagingHelper, this);
if (stat != 0)
{
LOGF_ERROR("Error creating imaging thread (%d)", stat);
return false;
}
pthread_mutex_lock(&condMutex);
while (threadState == StateNone)
{
pthread_cond_wait(&cv, &condMutex);
}
pthread_mutex_unlock(&condMutex);
return true;
}
