// Disconnect from given device.
// Returns true if disconnected as requested
bool ArtDrvSim::Disconnect()
{
AbortExposure();
m_connected=false;
//m_warmingUp = (m_coolingOn) ? true:false; // switch to warmup if cooler was on
wxASSERT(m_pSimThread);
m_pSimThread->AbortThread();
::wxMilliSleep(500); // allow some time to end thread
m_camState = CAMERA_IDLE;
return !m_connected;
}
bool INDI::CCD::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(strcmp(dev,getDeviceName())==0)
{
// This is for our device
// Now lets see if it's something we process here
if(strcmp(name,"CCD_EXPOSURE")==0)
{
float n;
int rc;
n=values[0];
PrimaryCCD.ImageExposureN[0].value=n;
if (PrimaryCCD.ImageExposureNP->s==IPS_BUSY)
AbortExposure();
PrimaryCCD.ImageExposureNP->s=IPS_BUSY;
// now we have a new number, this is our requested exposure time
// Tell the clients we are busy with this exposure
// And now call the physical hardware layer to start the exposure
rc=StartExposure(n);
switch(rc)
{
case 0: // normal case, exposure running on timers, callbacks when it's finished
PrimaryCCD.ImageExposureNP->s=IPS_BUSY;
break;
case 1: // Short exposure, it's already done
PrimaryCCD.ImageExposureNP->s=IPS_OK;
break;
case -1: // error condition
PrimaryCCD.ImageExposureNP->s=IPS_ALERT;
break;
}
IDSetNumber(PrimaryCCD.ImageExposureNP,NULL);
return true;
}
if(strcmp(name,"GUIDER_EXPOSURE")==0)
{
float n;
int rc;
n=values[0];
GuideCCD.ImageExposureN[0].value=n;
GuideCCD.ImageExposureNP->s=IPS_BUSY;
// now we have a new number, this is our requested exposure time
// Tell the clients we are busy with this exposure
// And now call the physical hardware layer to start the exposure
// change of plans, this is just changing exposure time
// the start/stop stream buttons do the rest
rc=StartGuideExposure(n);
//rc=1; // set it to ok
switch(rc) {
case 0: // normal case, exposure running on timers, callbacks when it's finished
GuideCCD.ImageExposureNP->s=IPS_BUSY;
break;
case 1: // Short exposure, it's already done
GuideCCD.ImageExposureNP->s=IPS_OK;
break;
case -1: // error condition
GuideCCD.ImageExposureNP->s=IPS_ALERT;
break;
}
IDSetNumber(GuideCCD.ImageExposureNP,NULL);
return true;
}
if(strcmp(name,"CCD_BINNING")==0)
{
// We are being asked to set camera binning
PrimaryCCD.ImageBinNP->s=IPS_OK;
IUUpdateNumber(PrimaryCCD.ImageBinNP,values,names,n);
if (updateCCDBin(PrimaryCCD.ImageBinN[0].value, PrimaryCCD.ImageBinN[1].value) == false)
{
PrimaryCCD.ImageBinNP->s = IPS_ALERT;
IDSetNumber (PrimaryCCD.ImageBinNP, NULL);
}
return true;
}
if(strcmp(name,"CCD_FRAME")==0)
{
// We are being asked to set camera binning
PrimaryCCD.ImageFrameNP->s=IPS_OK;
IUUpdateNumber(PrimaryCCD.ImageFrameNP,values,names,n);
if (updateCCDFrame(PrimaryCCD.ImageFrameN[0].value, PrimaryCCD.ImageFrameN[1].value, PrimaryCCD.ImageFrameN[2].value,
PrimaryCCD.ImageFrameN[3].value) == false)
{
PrimaryCCD.ImageFrameNP->s = IPS_ALERT;
IDSetNumber(PrimaryCCD.ImageFrameNP, NULL);
}
return true;
}
if(strcmp(name,"GUIDER_FRAME")==0)
{
// We are being asked to set camera binning
GuideCCD.ImageFrameNP->s=IPS_OK;
IUUpdateNumber(GuideCCD.ImageFrameNP,values,names,n);
// Update client display
//IDSetNumber(GuiderFrameNP,NULL);
if (isDebug())
IDLog("GuiderFrame set to %4.0f,%4.0f %4.0f x %4.0f\n",
GuideCCD.ImageFrameN[0].value,GuideCCD.ImageFrameN[1].value,GuideCCD.ImageFrameN[2].value,GuideCCD.ImageFrameN[3].value);
//GSubX=GuiderFrameN[0].value;
//GSubY=GuiderFrameN[1].value;
//GSubW=GuiderFrameN[2].value;
//GSubH=GuiderFrameN[3].value;
GuideCCD.setFrame(GuideCCD.ImageFrameN[0].value, GuideCCD.ImageFrameN[1].value,
GuideCCD.ImageFrameN[2].value,GuideCCD.ImageFrameN[3].value);
return true;
}
if (!strcmp(name,GuideNSP.name) || !strcmp(name,GuideEWP.name))
{
processGuiderProperties(name, values, names, n);
return true;
}
}
// if we didn't process it, continue up the chain, let somebody else
// give it a shot
return DefaultDevice::ISNewNumber(dev,name,values,names,n);
}
bool INDI::CCD::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
{
if(strcmp(dev,getDeviceName())==0)
{
if(strcmp(name,PrimaryCCD.AbortExposureSP->name)==0)
{
IUResetSwitch(PrimaryCCD.AbortExposureSP);
if (AbortExposure())
{
PrimaryCCD.AbortExposureSP->s = IPS_OK;
PrimaryCCD.ImageExposureNP->s = IPS_IDLE;
PrimaryCCD.ImageExposureN[0].value = 0;
}
else
{
PrimaryCCD.AbortExposureSP->s = IPS_ALERT;
PrimaryCCD.ImageExposureNP->s = IPS_ALERT;
}
IDSetSwitch(PrimaryCCD.AbortExposureSP, NULL);
IDSetNumber(PrimaryCCD.ImageExposureNP, NULL);
return true;
}
if(strcmp(name,GuideCCD.AbortExposureSP->name)==0)
{
IUResetSwitch(GuideCCD.AbortExposureSP);
if (AbortGuideExposure())
{
GuideCCD.AbortExposureSP->s = IPS_OK;
GuideCCD.ImageExposureNP->s = IPS_IDLE;
GuideCCD.ImageExposureN[0].value = 0;
}
else
{
GuideCCD.AbortExposureSP->s = IPS_ALERT;
GuideCCD.ImageExposureNP->s = IPS_ALERT;
}
IDSetSwitch(GuideCCD.AbortExposureSP, NULL);
IDSetNumber(GuideCCD.ImageExposureNP, NULL);
return true;
}
if(strcmp(name,PrimaryCCD.CompressSP->name)==0)
{
IUUpdateSwitch(PrimaryCCD.CompressSP,states,names,n);
IDSetSwitch(PrimaryCCD.CompressSP,NULL);
if(PrimaryCCD.CompressS[0].s==ISS_ON )
{
PrimaryCCD.SendCompressed=true;
} else
{
PrimaryCCD.SendCompressed=false;
}
return true;
}
if(strcmp(name,GuideCCD.CompressSP->name)==0)
{
IUUpdateSwitch(GuideCCD.CompressSP,states,names,n);
IDSetSwitch(GuideCCD.CompressSP,NULL);
if(GuideCCD.CompressS[0].s==ISS_ON )
{
GuideCCD.SendCompressed=true;
} else
{
GuideCCD.SendCompressed=false;
}
return true;
}
if(strcmp(name,PrimaryCCD.FrameTypeSP->name)==0)
{
// Compression Update
IUUpdateSwitch(PrimaryCCD.FrameTypeSP,states,names,n);
PrimaryCCD.FrameTypeSP->s=IPS_OK;
if(PrimaryCCD.FrameTypeS[0].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::LIGHT_FRAME);
else if(PrimaryCCD.FrameTypeS[1].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::BIAS_FRAME);
else if(PrimaryCCD.FrameTypeS[2].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::DARK_FRAME);
else if(PrimaryCCD.FrameTypeS[3].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::FLAT_FRAME);
if (updateCCDFrameType(PrimaryCCD.getFrameType()) == false)
PrimaryCCD.FrameTypeSP->s = IPS_ALERT;
IDSetSwitch(PrimaryCCD.FrameTypeSP,NULL);
return true;
}
}
// let the default driver have a crack at it
return DefaultDevice::ISNewSwitch(dev, name, states, names, n);
}
bool Camera_ASCOMLateClass::Capture(int duration, usImage& img, int options, const wxRect& subframeArg)
{
bool retval = false;
bool takeSubframe = UseSubframes;
wxRect subframe(subframeArg);
if (subframe.width <= 0 || subframe.height <= 0)
{
takeSubframe = false;
}
bool binning_changed = false;
if (Binning != m_curBin)
{
FullSize = wxSize(m_maxSize.x / Binning, m_maxSize.y / Binning);
binning_changed = true;
}
// Program the size
if (!takeSubframe)
{
subframe = wxRect(0, 0, FullSize.GetWidth(), FullSize.GetHeight());
}
if (img.Init(FullSize))
{
pFrame->Alert(_("Cannot allocate memory to download image from camera"));
return true;
}
GITObjRef cam(m_gitEntry);
EXCEPINFO excep;
if (binning_changed)
{
if (ASCOM_SetBin(cam.IDisp(), Binning, &excep))
{
pFrame->Alert(_("The ASCOM camera failed to set binning. See the debug log for more information."));
return true;
}
m_curBin = Binning;
}
if (subframe != m_roi)
{
ASCOM_SetROI(cam.IDisp(), subframe, &excep);
m_roi = subframe;
}
bool takeDark = HasShutter && ShutterClosed;
// Start the exposure
if (ASCOM_StartExposure(cam.IDisp(), (double)duration / 1000.0, takeDark, &excep))
{
Debug.AddLine(ExcepMsg("ASCOM_StartExposure failed", excep));
pFrame->Alert(ExcepMsg(_("ASCOM error -- Cannot start exposure with given parameters"), excep));
return true;
}
CameraWatchdog watchdog(duration, GetTimeoutMs());
if (duration > 100)
{
// wait until near end of exposure
if (WorkerThread::MilliSleep(duration - 100, WorkerThread::INT_ANY) &&
(WorkerThread::TerminateRequested() || AbortExposure()))
{
return true;
}
}
while (true) // wait for image to finish and d/l
{
wxMilliSleep(20);
bool ready;
EXCEPINFO excep;
if (ASCOM_ImageReady(cam.IDisp(), &ready, &excep))
{
Debug.AddLine(ExcepMsg("ASCOM_ImageReady failed", excep));
pFrame->Alert(ExcepMsg(_("Exception thrown polling camera"), excep));
return true;
}
if (ready)
break;
if (WorkerThread::InterruptRequested() &&
(WorkerThread::TerminateRequested() || AbortExposure()))
{
return true;
}
if (watchdog.Expired())
{
DisconnectWithAlert(CAPT_FAIL_TIMEOUT);
return true;
}
}
// Get the image
if (ASCOM_Image(cam.IDisp(), img, takeSubframe, subframe, &excep))
{
Debug.AddLine(ExcepMsg(_T("ASCOM_Image failed"), excep));
pFrame->Alert(ExcepMsg(_("Error reading image"), excep));
return true;
}
if (options & CAPTURE_SUBTRACT_DARK)
SubtractDark(img);
if (Color && Binning == 1 && (options & CAPTURE_RECON))
QuickLRecon(img);
return false;
}
