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::StartExposure(float duration)
{
unsigned int ret = QHYCCD_ERROR;
if (Streamer->isBusy())
{
DEBUG(INDI::Logger::DBG_ERROR, "Cannot take exposure while streaming/recording is active.");
return false;
}
//AbortPrimaryFrame = false;
/*
if (duration < MINIMUM_CCD_EXPOSURE)
{
DEBUGF(INDI::Logger::DBG_WARNING,
"Exposure shorter than minimum duration %g s requested. Setting exposure time to %g s.", duration,
MINIMUM_CCD_EXPOSURE);
duration = MINIMUM_CCD_EXPOSURE;
}*/
imageFrameType = PrimaryCCD.getFrameType();
/*if (imageFrameType == CCDChip::BIAS_FRAME)
{
duration = MINIMUM_CCD_EXPOSURE;
DEBUGF(INDI::Logger::DBG_SESSION, "Bias Frame (s) : %g", duration);
}
else*/
if (GetCCDCapability() & CCD_HAS_SHUTTER)
{
if (imageFrameType == INDI::CCDChip::DARK_FRAME || imageFrameType == INDI::CCDChip::BIAS_FRAME)
ControlQHYCCDShutter(camhandle, MACHANICALSHUTTER_CLOSE);
else
ControlQHYCCDShutter(camhandle, MACHANICALSHUTTER_FREE);
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Current exposure time is %f us", duration * 1000 * 1000);
ExposureRequest = duration;
PrimaryCCD.setExposureDuration(duration);
if (sim)
ret = QHYCCD_SUCCESS;
else
{
if (LastExposureRequest != ExposureRequest)
{
ret = SetQHYCCDParam(camhandle, CONTROL_EXPOSURE, ExposureRequest * 1000 * 1000);
if (ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Set expose time failed (%d).", ret);
return false;
}
LastExposureRequest = ExposureRequest;
}
}
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDBinMode(camhandle, camxbin, camybin);
if (ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD Bin mode failed (%d)", ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDBinMode (%dx%d).", camxbin, camybin);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDResolution(camhandle, camroix, camroiy, camroiwidth, camroiheight);
if (ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD ROI resolution (%d,%d) (%d,%d) failed (%d)", camroix, camroiy,
camroiwidth, camroiheight, ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDResolution camroix %d camroiy %d camroiwidth %d camroiheight %d", camroix,
camroiy, camroiwidth, camroiheight);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = ExpQHYCCDSingleFrame(camhandle);
if (ret == QHYCCD_ERROR)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Begin QHYCCD expose failed (%d)", ret);
return false;
}
gettimeofday(&ExpStart, NULL);
DEBUGF(INDI::Logger::DBG_DEBUG, "Taking a %g seconds frame...", ExposureRequest);
InExposure = true;
// if (ExposureRequest*1000 < POLLMS)
// SetTimer(ExposureRequest*1000);
// else
SetTimer(POLLMS);
return true;
}
bool QHYCCD::ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n)
{
// first check if it's for our device
//IDLog("INDI::CCD::ISNewNumber %s\n",name);
if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)
{
if (strcmp(name, FilterSlotNP.name) == 0)
{
INDI::FilterInterface::processNumber(dev, name, values, names, n);
return true;
}
if (strcmp(name, GainNP.name) == 0)
{
IUUpdateNumber(&GainNP, values, names, n);
GainRequest = GainN[0].value;
if (LastGainRequest != GainRequest)
{
SetQHYCCDParam(camhandle, CONTROL_GAIN, GainN[0].value);
LastGainRequest = GainRequest;
}
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", GainNP.name, GainN[0].value);
GainNP.s = IPS_OK;
IDSetNumber(&GainNP, NULL);
return true;
}
if (strcmp(name, OffsetNP.name) == 0)
{
IUUpdateNumber(&OffsetNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_OFFSET, OffsetN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", OffsetNP.name, OffsetN[0].value);
OffsetNP.s = IPS_OK;
IDSetNumber(&OffsetNP, NULL);
saveConfig(true, OffsetNP.name);
return true;
}
if (strcmp(name, SpeedNP.name) == 0)
{
IUUpdateNumber(&SpeedNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_SPEED, SpeedN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", SpeedNP.name, SpeedN[0].value);
SpeedNP.s = IPS_OK;
IDSetNumber(&SpeedNP, NULL);
saveConfig(true, SpeedNP.name);
return true;
}
if (strcmp(name, USBTrafficNP.name) == 0)
{
IUUpdateNumber(&USBTrafficNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_USBTRAFFIC, USBTrafficN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", USBTrafficNP.name, USBTrafficN[0].value);
USBTrafficNP.s = IPS_OK;
IDSetNumber(&USBTrafficNP, NULL);
saveConfig(true, USBTrafficNP.name);
return true;
}
}
// if we didn't process it, continue up the chain, let somebody else
// give it a shot
return INDI::CCD::ISNewNumber(dev, name, values, names, n);
}
bool Camera_QHY::Capture(int duration, usImage& img, int options, const wxRect& subframe)
{
bool useSubframe = UseSubframes && !subframe.IsEmpty();
if (Binning != m_curBin)
{
FullSize = wxSize(m_maxSize.GetX() / Binning, m_maxSize.GetY() / Binning);
m_curBin = Binning;
useSubframe = false; // subframe may be out of bounds now
}
if (img.Init(FullSize))
{
DisconnectWithAlert(CAPT_FAIL_MEMORY);
return true;
}
wxRect frame = useSubframe ? subframe : wxRect(FullSize);
if (useSubframe)
img.Clear();
wxRect roi;
if (useSubframe)
{
// Use a larger ROI around the subframe to avoid changing the ROI as the centroid
// wobbles around. Changing the ROI introduces a lag of several seconds.
// This also satifies the constraint that ROI width and height must be multiples of 4.
enum { PAD = 1 << 5 };
roi.SetLeft(round_down(subframe.GetLeft(), PAD));
roi.SetRight(round_up(subframe.GetRight() + 1, PAD) - 1);
roi.SetTop(round_down(subframe.GetTop(), PAD));
roi.SetBottom(round_up(subframe.GetBottom() + 1, PAD) - 1);
}
else
{
roi = frame;
}
uint32_t ret = QHYCCD_ERROR;
// lzr from QHY says this needs to be set for every exposure
ret = SetQHYCCDBinMode(m_camhandle, Binning, Binning);
if (ret != QHYCCD_SUCCESS)
{
Debug.Write(wxString::Format("SetQHYCCDBinMode failed! ret = %d\n", (int)ret));
}
if (m_roi != roi)
{
// when roi changes, must call this
ret = CancelQHYCCDExposingAndReadout(m_camhandle);
if (ret == QHYCCD_SUCCESS)
{
Debug.Write("CancelQHYCCDExposingAndReadout success\n");
}
else
{
Debug.Write("CancelQHYCCDExposingAndReadout failed\n");
}
ret = SetQHYCCDResolution(m_camhandle, roi.GetLeft(), roi.GetTop(), roi.GetWidth(), roi.GetHeight());
if (ret == QHYCCD_SUCCESS)
{
m_roi = roi;
}
else
{
Debug.Write(wxString::Format("SetQHYCCDResolution(%d,%d,%d,%d) failed! ret = %d\n",
roi.GetLeft(), roi.GetTop(), roi.GetWidth(), roi.GetHeight(), (int)ret));
}
}
if (duration != m_curExposure)
{
ret = SetQHYCCDParam(m_camhandle, CONTROL_EXPOSURE, duration * 1000.0); // QHY duration is usec
if (ret == QHYCCD_SUCCESS)
{
m_curExposure = duration;
}
else
{
Debug.Write(wxString::Format("QHY set exposure ret %d\n", (int)ret));
pFrame->Alert(_("Failed to set camera exposure"));
}
}
if (GuideCameraGain != m_curGain)
{
double gain = m_gainMin + GuideCameraGain * (m_gainMax - m_gainMin) / 100.0;
gain = floor(gain / m_gainStep) * m_gainStep;
Debug.Write(wxString::Format("QHY set gain %g (%g..%g incr %g)\n", gain, m_gainMin, m_gainMax, m_gainStep));
ret = SetQHYCCDParam(m_camhandle, CONTROL_GAIN, gain);
if (ret == QHYCCD_SUCCESS)
{
m_curGain = GuideCameraGain;
}
else
{
Debug.Write(wxString::Format("QHY set gain ret %d\n", (int)ret));
pFrame->Alert(_("Failed to set camera gain"));
}
}
ret = ExpQHYCCDSingleFrame(m_camhandle);
if (ret == QHYCCD_ERROR)
{
Debug.Write(wxString::Format("QHY exp single frame ret %d\n", (int)ret));
DisconnectWithAlert(_("QHY exposure failed"), NO_RECONNECT);
return true;
}
if (ret == QHYCCD_SUCCESS)
{
Debug.Write(wxString::Format("QHY: 200ms delay needed\n"));
WorkerThread::MilliSleep(200);
}
if (ret == QHYCCD_READ_DIRECTLY)
{
//Debug.Write("QHYCCD_READ_DIRECTLY\n");
}
uint32_t w, h, bpp, channels;
ret = GetQHYCCDSingleFrame(m_camhandle, &w, &h, &bpp, &channels, RawBuffer);
if (ret != QHYCCD_SUCCESS || (bpp != 8 && bpp != 16))
{
Debug.Write(wxString::Format("QHY get single frame ret %d bpp %u\n", ret, bpp));
// users report that reconnecting the camera after this failure allows
// them to resume guiding so we'll try to reconnect automatically
DisconnectWithAlert(_("QHY get frame failed"), RECONNECT);
return true;
}
if (useSubframe)
{
img.Subframe = frame;
int xofs = subframe.GetLeft() - roi.GetLeft();
int yofs = subframe.GetTop() - roi.GetTop();
int dxr = w - frame.width - xofs;
if (bpp == 8)
{
const unsigned char *src = RawBuffer + yofs * w;
unsigned short *dst = img.ImageData + frame.GetTop() * FullSize.GetWidth() + frame.GetLeft();
for (int y = 0; y < frame.height; y++)
{
unsigned short *d = dst;
src += xofs;
for (int x = 0; x < frame.width; x++)
*d++ = (unsigned short) *src++;
src += dxr;
dst += FullSize.GetWidth();
}
}
else // bpp == 16
{
const unsigned short *src = (const unsigned short *) RawBuffer + yofs * w;
unsigned short *dst = img.ImageData + frame.GetTop() * FullSize.GetWidth() + frame.GetLeft();
for (int y = 0; y < frame.height; y++)
{
src += xofs;
memcpy(dst, src, frame.width * sizeof(unsigned short));
src += frame.width + dxr;
dst += FullSize.GetWidth();
}
}
}
else
{
if (bpp == 8)
{
const unsigned char *src = RawBuffer;
unsigned short *dst = img.ImageData;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
*dst++ = (unsigned short) *src++;
}
}
}
else // bpp == 16
{
memcpy(img.ImageData, RawBuffer, w * h * sizeof(unsigned short));
}
}
if (options & CAPTURE_SUBTRACT_DARK)
SubtractDark(img);
if (Color && Binning == 1 && (options & CAPTURE_RECON))
QuickLRecon(img);
return false;
}
bool QHYCCD::StartExposure(float duration)
{
int ret = QHYCCD_ERROR;
#ifndef OSX_EMBEDED_MODE
if (streamer->isBusy())
{
DEBUG(INDI::Logger::DBG_ERROR, "Cannot take exposure while streaming/recording is active.");
return false;
}
#endif
//AbortPrimaryFrame = false;
if (duration < MINIMUM_CCD_EXPOSURE)
{
DEBUGF(INDI::Logger::DBG_WARNING, "Exposure shorter than minimum duration %g s requested. Setting exposure time to %g s.", duration, MINIMUM_CCD_EXPOSURE);
duration = MINIMUM_CCD_EXPOSURE;
}
imageFrameType = PrimaryCCD.getFrameType();
if (imageFrameType == CCDChip::BIAS_FRAME)
{
duration = MINIMUM_CCD_EXPOSURE;
DEBUGF(INDI::Logger::DBG_SESSION, "Bias Frame (s) : %g", duration);
}
else if(imageFrameType == CCDChip::DARK_FRAME)
{
ControlQHYCCDShutter(camhandle,MACHANICALSHUTTER_CLOSE);
}
else
{
ControlQHYCCDShutter(camhandle,MACHANICALSHUTTER_FREE);
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Current exposure time is %f us",duration * 1000 * 1000);
ExposureRequest = duration;
PrimaryCCD.setExposureDuration(duration);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDParam(camhandle,CONTROL_EXPOSURE,ExposureRequest * 1000 * 1000);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Set expose time failed (%d).", ret);
return false;
}
// lzr: we need to call the following apis every single exposure,the usleep(200000) is important
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDBinMode(camhandle,camxbin,camybin);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD Bin mode failed (%d)", ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDBinMode %dx%d", camxbin, camybin);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDResolution(camhandle,camroix,camroiy,camroiwidth,camroiheight);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD ROI resolution failed (%d)", ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDResolution camroix %d camroiy %d camroiwidth %d camroiheight %d", camroix,camroiy,camroiwidth,camroiheight);
// JM 2016-05-08: Some QHY cameras needs 200ms before you can exposure a frame. Asked QHY to try to minimize this!
//usleep(200000);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = ExpQHYCCDSingleFrame(camhandle);
if(ret == QHYCCD_ERROR)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Begin QHYCCD expose failed (%d)", ret);
return false;
}
gettimeofday(&ExpStart, NULL);
DEBUGF(INDI::Logger::DBG_DEBUG, "Taking a %g seconds frame...", ExposureRequest);
InExposure = true;
// if (ExposureRequest*1000 < POLLMS)
// SetTimer(ExposureRequest*1000);
// else
SetTimer(POLLMS);
return true;
}
bool QHYCCD::StartExposure(float duration)
{
int ret = QHYCCD_ERROR;
if (streamer->isBusy())
{
DEBUG(INDI::Logger::DBG_ERROR, "Cannot take exposure while streaming/recording is active.");
return false;
}
//AbortPrimaryFrame = false;
if (duration < MINIMUM_CCD_EXPOSURE)
{
DEBUGF(INDI::Logger::DBG_WARNING, "Exposure shorter than minimum duration %g s requested. Setting exposure time to %g s.", duration, MINIMUM_CCD_EXPOSURE);
duration = MINIMUM_CCD_EXPOSURE;
}
imageFrameType = PrimaryCCD.getFrameType();
if (imageFrameType == CCDChip::BIAS_FRAME)
{
duration = MINIMUM_CCD_EXPOSURE;
DEBUGF(INDI::Logger::DBG_SESSION, "Bias Frame (s) : %g", duration);
}
else if(imageFrameType == CCDChip::DARK_FRAME)
{
ControlQHYCCDShutter(camhandle,MACHANICALSHUTTER_CLOSE);
}
else
{
ControlQHYCCDShutter(camhandle,MACHANICALSHUTTER_FREE);
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Current exposure time is %f us",duration * 1000 * 1000);
ExposureRequest = duration;
PrimaryCCD.setExposureDuration(duration);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDParam(camhandle,CONTROL_EXPOSURE,ExposureRequest * 1000 * 1000);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Set expose time failed (%d).", ret);
return false;
}
// lzr: we need to call the following apis every single exposure,the usleep(200000) is important
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDBinMode(camhandle,camxbin,camybin);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD Bin mode failed (%d)", ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDBinMode %dx%d", camxbin, camybin);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = SetQHYCCDResolution(camhandle,camroix,camroiy,camroiwidth,camroiheight);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Set QHYCCD ROI resolution failed (%d)", ret);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "SetQHYCCDResolution camroix %d camroiy %d camroiwidth %d camroiheight %d", camroix,camroiy,camroiwidth,camroiheight);
// Jasem: Removed QHY 300ms delay that was added without specifying the reason. It seems any delay less than 100ms results in QHY Frame error. Again no reason. This renders
// exposures less than 100ms useless, but there is nothing I can do about that.
usleep(100000);
if (sim)
ret = QHYCCD_SUCCESS;
else
ret = ExpQHYCCDSingleFrame(camhandle);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Begin QHYCCD expose failed (%d)", ret);
return false;
}
gettimeofday(&ExpStart, NULL);
DEBUGF(INDI::Logger::DBG_DEBUG, "Taking a %g seconds frame...", ExposureRequest);
InExposure = true;
// if (ExposureRequest*1000 < POLLMS)
// SetTimer(ExposureRequest*1000);
// else
SetTimer(POLLMS);
return true;
}
int main(void)
{
int num = 0;
qhyccd_handle *camhandle;
int ret;
char id[32];
char camtype[16];
int found = 0;
int ch = '0';
ret = InitQHYCCDResource();
if(ret == QHYCCD_SUCCESS)
{
printf("Init SDK success!\n");
}
else
{
goto failure;
}
num = ScanQHYCCD();
if(num > 0)
{
printf("Yes!Found QHYCCD,the num is %d \n",num);
}
else
{
printf("Not Found QHYCCD,please check the usblink or the power\n");
}
for(int i = 0;i < num;i++)
{
ret = GetQHYCCDId(i,id);
if(ret == QHYCCD_SUCCESS)
{
strncpy(camtype,id,6);
if(!strcmp(camtype,"IC8300"))
{
found = 1;
break;
}
}
}
if(found == 1)
{
camhandle = OpenQHYCCD(id);
if(camhandle != NULL)
{
printf("Open IC8300 success!\n");
}
printf("Please enter the command you want to control:\n");
printf("Choice is 0 - 63\n");
scanf("%d",&ch);
getchar();
if(ch >= 0 && ch <= 63)
{
ret = SetQHYCCDParam(camhandle,CONTROL_GAIN,ch);
if(ret != QHYCCD_SUCCESS)
{
printf("Control the color filter wheel failure \n");
goto failure;
}
}
}
else
{
printf("The camera is not IC8300 or other error \n");
goto failure;
}
ret = CloseQHYCCD(camhandle);
if(ret == QHYCCD_SUCCESS)
{
printf("Close IC8300 success!\n");
}
else
{
goto failure;
}
ret = ReleaseQHYCCDResource();
if(ret == QHYCCD_SUCCESS)
{
printf("Rlease SDK Resource success!\n");
}
else
{
goto failure;
}
return 0;
failure:
printf("some fatal error happened\n");
return 1;
}
