org.minetti.astrodevice.common.orb
Interface CameraOrbProcess

All Superinterfaces:
DeviceOrbProcess, Remote

public interface CameraOrbProcess
extends DeviceOrbProcess, Remote

ORB process on cameras.

Author:
Jean-Philippe MINETTI

Method Summary
 void abortExposure(long cameraId)
          Aborts the current exposure, if any, and returns the camera to Idle state.
 short getBinX(long cameraId)
          Returns the binning factor for the X axis.
 short getBinY(long cameraId)
          Returns the binning factor for the Y axis.
 CameraStatus getCameraStatus(long cameraId)
          Returns the current camera operational state.
 CameraCapabilities getCapabilities(long cameraId)
          Returns all capabilities of a camera.
 double getCcdTemperature(long cameraId)
          Returns the current CCD temperature.
 CameraCharacteristics getCharacteristics(long cameraId)
          Returns all characteristics of a camera.
 double getCoolerPower(long cameraId)
          Returns the present cooler power level.
 double getElectronsPerAdu(long cameraId)
          Returns the gain of the camera in photoelectrons per A/D unit.
 double getFullWellCapacity(long cameraId)
          Returns the full well capacity of the camera, at the current camera settings (binning, SetupDialog settings, etc...).
 short getGain(long cameraId)
          Returns, versus the type of gain capabilities: an index into the getCapabilities(long).getGain().getGains() array for the selected camera gain.
 double getHeatSinkTemperature(long cameraId)
          Returns the current heat sink temperature (called "ambient temperature" by some manufacturers).
 Object getImageArray(long cameraId)
          Returns a safearray of int of size getNumX(long) * getNumY(long) containing the pixel values from the last exposure.
 Object getImageArrayVariant(long cameraId)
          Returns a safearray of Variant of size getNumX(long) * getNumY(long) containing the pixel values from the last exposure.
 double getLastExposureDuration(long cameraId)
          Returns the last exposure duration (i.e. shutter open time).
 Date getLastExposureStartTime(long cameraId)
          Returns the last exposure start time.
 int getNumX(long cameraId)
          Returns the subframe width.
 int getNumY(long cameraId)
          Returns the subframe height.
 short getPercentCompleted(long cameraId)
          Returns a value between 0 and 100% indicating the completeness of this operation.
 short getReadoutMode(long cameraId)
          Returns an index into the getCapabilities(long).getReadoutModes() array of string readout mode names indicating the camera's current readout mode.
 SensorType getSensorType(long cameraId)
          Returns the type of colour information returned by the the camera sensor.
 double getSetCcdTemperature(long cameraId)
          Returns the camera cooler setpoint.
 int getStartX(long cameraId)
          Returns the subframe start position for the X axis (0 based).
 int getStartY(long cameraId)
          Returns the subframe start position for the Y axis (0 based).
 boolean isCoolerOn(long cameraId)
          Returns TRUE if the camera cooler is on.
 boolean isFastReadout(long cameraId)
          Returns TRUE for fast readout mode, FALSE for normal mode.
 boolean isImageReady(long cameraId)
          Returns TRUE if the image is ready to be downloaded fom the camera.
 boolean isPulseGuiding(long cameraId)
          Returns TRUE if the camera is currrently in a pulseGuide operation.
 void pulseGuide(long cameraId, TelescopeGuideDirection direction, int duration)
          Activates the camera's mount control sytem to instruct the mount to move in a particular direction for a given period of time.
 void setBinX(long cameraId, short binX)
          Sets the binning factor for the X axis.
 void setBinY(long cameraId, short binY)
          Sets the binning factor for the Y axis.
 void setCoolerOn(long cameraId, boolean coolerOn)
          Sets TRUE if the camera cooler is on.
 void setFastReadout(long cameraId, boolean fastReadout)
          Sets TRUE for fast readout mode, FALSE for normal mode.
 void setGain(long cameraId, short gain)
          Sets, versus the type of gain capabilities: the index into the getCapabilities(long).getGain().getGains() array for the selected camera gain.
 void setNumX(long cameraId, int numX)
          Sets the subframe width.
 void setNumY(long cameraId, int numY)
          Sets the subframe height.
 void setSetCcdTemperature(long cameraId, double setCcdTemperature)
          Sets the the camera cooler setpoint.
 void setStartX(long cameraId, int startX)
          Sets the subframe start position for the X axis (0 based).
 void setStartY(long cameraId, int startY)
          Sets the subframe start position for the Y axis (0 based).
 void startExposure(long cameraId, double duration, boolean light)
          Starts an exposure.
 void stopExposure(long cameraId)
          Stops the current exposure, if any.
 
Methods inherited from interface org.minetti.astrodevice.common.orb.DeviceOrbProcess
action, commandBlind, commandBoolean, commandString, getDescription, getDeviceList, getDeviceName, getDriverInfo, getDriverVersion, getInterfaceVersion, getPluginName, getSupportedActions, isConnected, setConnected, showSetupDialog
 

Method Detail

getCharacteristics

CameraCharacteristics getCharacteristics(long cameraId)
                                         throws RemoteException
Returns all characteristics of a camera.

Parameters:
cameraId - Camera identifier.
Returns:
Object representing all characteristics of a camera.
Throws:
RemoteException - Exception if an error occurred.

getCapabilities

CameraCapabilities getCapabilities(long cameraId)
                                   throws RemoteException
Returns all capabilities of a camera.

Parameters:
cameraId - Camera identifier.
Returns:
Object representing all capabilities of a camera.
Throws:
RemoteException - Exception if an error occurred.

getCameraStatus

CameraStatus getCameraStatus(long cameraId)
                             throws RemoteException
Returns the current camera operational state.

Parameters:
cameraId - Camera identifier.
Returns:
State of the camera.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must return an exception if the camera status is unavailable.

getGain

short getGain(long cameraId)
              throws RemoteException
Returns, versus the type of gain capabilities:

The driver must default camera gain to a valid value.

Parameters:
cameraId - Camera identifier.
Returns:
Index into the getGains() array or value representing the gain.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw an exception if the information is not available (Some drivers may require an active connection in order to retrieve necessary information from the camera).
PropertyNotImplementedException - Must throw an exception if gain is not supported.

setGain

void setGain(long cameraId,
             short gain)
             throws RemoteException
Sets, versus the type of gain capabilities:

This method can be used to adjust the gain setting of the camera, if supported. There are two typical usage scenarios:

Please note that getReadoutMode(long) may in some cases affect the gain of the camera; if so the driver must be written such that the two settings do not conflict if both are used.

Parameters:
cameraId - Camera identifier.
gain - Index into the getGains() array or value representing the gain.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw an exception if the information is not available (Some drivers may require an active connection in order to retrieve necessary information from the camera).
InvalidValueException - Must throw an exception if not valid.
PropertyNotImplementedException - Must throw an exception if gain is not supported.

getBinX

short getBinX(long cameraId)
              throws RemoteException
Returns the binning factor for the X axis.

Should default to 1 when the camera connection is established.

Parameters:
cameraId - Camera identifier.
Returns:
Binning factor for the X axis.
Throws:
RemoteException - Exception if an error occurred.

setBinX

void setBinX(long cameraId,
             short binX)
             throws RemoteException
Sets the binning factor for the X axis.

Should default to 1 when the camera connection is established.

Note: driver does not check for compatible subframe values when this value is set; rather they are checked upon startExposure(long, double, boolean).

Parameters:
cameraId - Camera identifier.
binX - Binning factor for the X axis.
Throws:
RemoteException - Exception if an error occurred.
InvalidValueException - Must throw an exception for illegal binning values.

getBinY

short getBinY(long cameraId)
              throws RemoteException
Returns the binning factor for the Y axis.

Should default to 1 when the camera connection is established.

Parameters:
cameraId - Camera identifier.
Returns:
Binning factor for the Y axis.
Throws:
RemoteException - Exception if an error occurred.

setBinY

void setBinY(long cameraId,
             short binY)
             throws RemoteException
Sets the binning factor for the Y axis.

Should default to 1 when the camera connection is established.

Note: driver does not check for compatible subframe values when this value is set; rather they are checked upon startExposure(long, double, boolean).

Parameters:
cameraId - Camera identifier.
binY - Binning factor for the Y axis.
Throws:
RemoteException - Exception if an error occurred.
InvalidValueException - Must throw an exception for illegal binning values.

getNumX

int getNumX(long cameraId)
            throws RemoteException
Returns the subframe width.

If binning is active, value is in binned pixels. No error check is performed when the value is set. Should default to getCharacteristics(long).getCameraXSize().

Parameters:
cameraId - Camera identifier.
Returns:
Subframe width.
Throws:
RemoteException - Exception if an error occurred.

setNumX

void setNumX(long cameraId,
             int numX)
             throws RemoteException
Sets the subframe width.

If binning is active, value is in binned pixels. No error check is performed when the value is set. Should default to getCharacteristics(long).getCameraXSize().

Parameters:
cameraId - Camera identifier.
numX - Subframe width.
Throws:
RemoteException - Exception if an error occurred.

getNumY

int getNumY(long cameraId)
            throws RemoteException
Returns the subframe height.

If binning is active, value is in binned pixels. No error check is performed when the value is set. Should default to getCharacteristics(long).getCameraYSize().

Parameters:
cameraId - Camera identifier.
Returns:
Subframe height.
Throws:
RemoteException - Exception if an error occurred.

setNumY

void setNumY(long cameraId,
             int numY)
             throws RemoteException
Sets the subframe height.

If binning is active, value is in binned pixels. No error check is performed when the value is set. Should default to getCharacteristics(long).getCameraYSize().

Parameters:
cameraId - Camera identifier.
numY - Subframe height.
Throws:
RemoteException - Exception if an error occurred.

getStartX

int getStartX(long cameraId)
              throws RemoteException
Returns the subframe start position for the X axis (0 based).

If binning is active, value is in binned pixels.

Parameters:
cameraId - Camera identifier.
Returns:
Subframe start position for the X axis (0 based).
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected.

setStartX

void setStartX(long cameraId,
               int startX)
               throws RemoteException
Sets the subframe start position for the X axis (0 based).

If binning is active, value is in binned pixels.

Parameters:
cameraId - Camera identifier.
startX - Subframe start position for the X axis (0 based).
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected.

getStartY

int getStartY(long cameraId)
              throws RemoteException
Returns the subframe start position for the Y axis (0 based).

If binning is active, value is in binned pixels.

Parameters:
cameraId - Camera identifier.
Returns:
Subframe start position for the Y axis (0 based).
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected.

setStartY

void setStartY(long cameraId,
               int startY)
               throws RemoteException
Sets the subframe start position for the Y axis (0 based).

If binning is active, value is in binned pixels.

Parameters:
cameraId - Camera identifier.
startY - Subframe start position for the Y axis (0 based).
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected.

isFastReadout

boolean isFastReadout(long cameraId)
                      throws RemoteException
Returns TRUE for fast readout mode, FALSE for normal mode.

Must thrown an exception if no connection is established to the camera. Must throw an exception if getCapabilities(long).canFastReadout() returns FALSE.

Many cameras have a "fast mode" intended for use in focusing. When set to TRUE, the camera will operate in Fast mode; when set FALSE, the camera will operate normally. This mode should default to FALSE.

Please note that this function may in some cases interact with getCapabilities(long).getReadoutModes(); for example, there may be modes where the Fast/Normal switch is meaningless. In this case, it may be preferable to use the getCapabilities(long).getReadoutModes() function to control fast/normal switching.

If this feature is not available, then getCapabilities(long).canFastReadout() must return FALSE.

Parameters:
cameraId - Camera identifier.
Returns:
TRUE for fast readout mode, FALSE for normal mode.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected and a connection is required to obtain this information.
PropertyNotImplementedException - Thrown if getCapabilities(long).canFastReadout() is FALSE.

setFastReadout

void setFastReadout(long cameraId,
                    boolean fastReadout)
                    throws RemoteException
Sets TRUE for fast readout mode, FALSE for normal mode.

Must thrown an exception if no connection is established to the camera. Must throw an exception if getCapabilities(long).canFastReadout() returns FALSE.

Many cameras have a "fast mode" intended for use in focusing. When set to TRUE, the camera will operate in Fast mode; when set FALSE, the camera will operate normally. This mode should default to FALSE.

Please note that this function may in some cases interact with getCapabilities(long).getReadoutModes(); for example, there may be modes where the Fast/Normal switch is meaningless. In this case, it may be preferable to use the getCapabilities(long).getReadoutModes() function to control fast/normal switching.

If this feature is not available, then getCapabilities(long).canFastReadout() must return FALSE.

Parameters:
cameraId - Camera identifier.
fastReadout - TRUE for fast readout mode, FALSE for normal mode.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected and a connection is required to obtain this information.
PropertyNotImplementedException - Thrown if getCapabilities(long).canFastReadout() is FALSE.

getReadoutMode

short getReadoutMode(long cameraId)
                     throws RemoteException
Returns an index into the getCapabilities(long).getReadoutModes() array of string readout mode names indicating the camera's current readout mode.

Return value is an index into the array getCapabilities(long).getReadoutModes(), and selects the desired readout mode for the camera. Defaults to 0 if not set. Throws an exception if the selected mode is not available.

It is strongly recommended, but not required, that driver authors make the 0-index mode suitable for standard imaging operations, since it is the default.

Please see getCapabilities(long).getReadoutModes() for additional information.

Parameters:
cameraId - Camera identifier.
Returns:
Index into the getCapabilities(long).getReadoutModes().
Throws:
RemoteException - Exception if an error occurred.
InvalidValueException - Must throw an exception if set to an illegal or unavailable mode.
NotConnectedException - Must throw an exception if the information is not available (Some drivers may require an active connection in order to retrieve necessary information from the camera).

startExposure

void startExposure(long cameraId,
                   double duration,
                   boolean light)
                   throws RemoteException
Starts an exposure. Use isImageReady(long) to check when the exposure is complete.

A dark frame or bias exposure may be shorter than the getCapabilities(long).getExposureMin() value and for a bias frame can be zero. Check the value of light and allow exposures down to 0 seconds if light is FALSE. If the hardware will not support an exposure duration of zero then, for dark and bias frames, set it to the minimum that is possible.

Some applications will set an exposure time of zero for bias frames so it's important that the driver allows this.

Parameters:
cameraId - Camera identifier.
duration - Duration of exposure in seconds, can be zero if light is FALSE.
light - TRUE for light frame, FALSE for dark frame (ignored if no shutter).
Throws:
RemoteException - Exception if an error occurred.
InvalidValueException - getNumX(long), getNumY(long), getBinX(long), getBinY(long), getStartX(long), getStartY(long), or duration parameters are invalid.
InvalidOperationException - getCapabilities(long).canAsymmetricBin() is FALSE and getBinX(long) != getBinY(long).
NotConnectedException - The exposure cannot be started for any reason, such as a hardware or communications error.

stopExposure

void stopExposure(long cameraId)
                  throws RemoteException
Stops the current exposure, if any.

If an exposure is in progress, the readout process is initiated. Ignored if readout is already in process.

Parameters:
cameraId - Camera identifier.
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Must throw an exception if getCapabilities(long).canStopExposure() is FALSE.
NotConnectedException - Must throw an exception if the camera or connection has an error condition.
DriverException - Must throw an exception if for any reason no image readout will be available.

abortExposure

void abortExposure(long cameraId)
                   throws RemoteException
Aborts the current exposure, if any, and returns the camera to Idle state.

Parameters:
cameraId - Camera identifier.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Thrown if the driver is not connected.
InvalidOperationException - Thrown if abort is not currently possible (e.g. during download).
DriverException - Thrown if a communications error occurs, or if the abort fails.

getPercentCompleted

short getPercentCompleted(long cameraId)
                          throws RemoteException
Returns a value between 0 and 100% indicating the completeness of this operation.

If valid, returns an integer between 0 and 100, where 0 indicates 0% progress (function just started) and 100 indicates 100% progress (i.e. completion).

At the discretion of the driver author, getPercentCompleted may optionally be valid when getCameraStatus(long) is in any or all of the following states: EXPOSING, WAITING, READING or DOWNLOAD. In all other states an exception shall be thrown.

Typically the application user interface will show a progress bar based on the return value by getPercentCompleted.

Please note that client applications are not required to use this value, and in some cases may display status information based on other information, such as time elapsed.

Parameters:
cameraId - Camera identifier.
Returns:
Value between 0 and 100% indicating the completeness of this operation.
Throws:
RemoteException - Exception if an error occurred.
InvalidOperationException - Thrown when it is inappropriate to call getPercentCompleted.

getLastExposureStartTime

Date getLastExposureStartTime(long cameraId)
                              throws RemoteException
Returns the last exposure start time.

Parameters:
cameraId - Camera identifier.
Returns:
Last exposure start time.
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Must throw an exception if not supported.
InvalidOperationException - If called before any exposure has been taken.

getLastExposureDuration

double getLastExposureDuration(long cameraId)
                               throws RemoteException
Returns the last exposure duration (i.e. shutter open time).

This may differ from the exposure time requested due to shutter latency, camera timing precision, etc...

Parameters:
cameraId - Camera identifier.
Returns:
Last exposure duration in seconds (s).
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Must throw an exception if not supported.
InvalidOperationException - If called before any exposure has been taken.

isImageReady

boolean isImageReady(long cameraId)
                     throws RemoteException
Returns TRUE if the image is ready to be downloaded fom the camera.

If TRUE, there is an image from the camera available. If FALSE, no image is available and attempts to use the getImageArray(long) method will produce an exception.

Parameters:
cameraId - Camera identifier.
Returns:
TRUE if the image is ready to be downloaded fom the camera.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Hardware or communications connection error has occurred.

getImageArray

Object getImageArray(long cameraId)
                     throws RemoteException
Returns a safearray of int of size getNumX(long) * getNumY(long) containing the pixel values from the last exposure.

The application must inspect the Safearray parameters to determine the dimensions.

Note: if getNumX(long) or getNumY(long) is changed after a call to startExposure(long, double, boolean) it will have no effect on the size of this array. This is the preferred method for programs (not scripts) to download iamges since it requires much less memory.

For color or multispectral cameras, will produce an array of getNumX(long) * getNumY(long) * numPlanes. If the application cannot handle multispectral images, it should use just the first plane.

Parameters:
cameraId - Camera identifier.
Returns:
Image array from the last exposure.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw exception if data unavailable.

getImageArrayVariant

Object getImageArrayVariant(long cameraId)
                            throws RemoteException
Returns a safearray of Variant of size getNumX(long) * getNumY(long) containing the pixel values from the last exposure.

The application must inspect the Safearray parameters to determine the dimensions.

Note: if getNumX(long) or getNumY(long) is changed after a call to startExposure(long, double, boolean) it will have no effect on the size of this array. This method should only be used from scripts due to the extremely high memory utilization on large image arrays (26 bytes per pixel). Pixels values should be in short, int, or double format.

For color or multispectral cameras, will produce an array of getNumX(long) * getNumY(long) * numPlanes. If the application cannot handle multispectral images, it should use just the first plane.

Parameters:
cameraId - Camera identifier.
Returns:
Image array from the last exposure.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw exception if data unavailable.

getSensorType

SensorType getSensorType(long cameraId)
                         throws RemoteException
Returns the type of colour information returned by the the camera sensor.

Return value can possibly change between exposures, for example if getReadoutMode(long) is changed, and should always be checked after each exposure.

It is recommended that this function be called only after a connection is established with the camera hardware, to ensure that the driver is aware of the capabilities of the specific camera model.

Parameters:
cameraId - Camera identifier.
Returns:
Type of colour information returned by the the camera sensor.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw an exception if the information is not available (Some drivers may require an active connection in order to retrieve necessary information from the camera).

isPulseGuiding

boolean isPulseGuiding(long cameraId)
                       throws RemoteException
Returns TRUE if the camera is currrently in a pulseGuide operation.

If TRUE, pulse guiding is in progress. Required if the pulseGuide method (which is non-blocking) is implemented. See the pulseGuide(long, TelescopeGuideDirection, int) method.

Parameters:
cameraId - Camera identifier.
Returns:
TRUE if the camera is currrently in a pulseGuide(long, TelescopeGuideDirection, int) operation.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Hardware or communications connection error has occurred.

pulseGuide

void pulseGuide(long cameraId,
                TelescopeGuideDirection direction,
                int duration)
                throws RemoteException
Activates the camera's mount control sytem to instruct the mount to move in a particular direction for a given period of time.

This method returns only after the move has completed.

The (symbolic) values for TelescopeGuideDirection are:

Note: directions are nominal and may depend on exact mount wiring. NORTH must be opposite SOUTH, and EAST must be opposite WEST.

Parameters:
cameraId - Camera identifier.
direction - Direction.
duration - Duration.
Throws:
RemoteException - Exception if an error occurred.
MethodNotImplementedException - PulseGuide command is unsupported.
DriverException - PulseGuide command is unsuccessful.
NotConnectedException - Thrown if the driver is not connected.

isCoolerOn

boolean isCoolerOn(long cameraId)
                   throws RemoteException
Returns TRUE if the camera cooler is on.

Parameters:
cameraId - Camera identifier.
Returns:
TRUE if the camera cooler is on.
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Not supported.
NotConnectedException - An error condition such as connection failure is present.

setCoolerOn

void setCoolerOn(long cameraId,
                 boolean coolerOn)
                 throws RemoteException
Sets TRUE if the camera cooler is on.

Warning: turning the cooler off when the cooler is operating at high delta-T (typically >20C below ambient) may result in thermal shock. Repeated thermal shock may lead to damage to the sensor or cooler stack. Please consult the documentation supplied with the camera for further information.

Parameters:
cameraId - Camera identifier.
coolerOn - TRUE if the camera cooler is on.
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Not supported.
NotConnectedException - An error condition such as connection failure is present.

getCoolerPower

double getCoolerPower(long cameraId)
                      throws RemoteException
Returns the present cooler power level.

Returns zero if isCoolerOn(long) is FALSE.

Parameters:
cameraId - Camera identifier.
Returns:
Present cooler power level, in percent (%).
Throws:
RemoteException - Exception if an error occurred.
PropertyNotImplementedException - Not supported.
NotConnectedException - An error condition such as connection failure is present.

getCcdTemperature

double getCcdTemperature(long cameraId)
                         throws RemoteException
Returns the current CCD temperature.

Only valid if getCapabilities(long).canSetCcdTemperature() is TRUE.

Parameters:
cameraId - Camera identifier.
Returns:
Current CCD temperature in degrees Celsius (°C).
Throws:
RemoteException - Exception if an error occurred.
InvalidValueException - Must throw exception if data unavailable.

getSetCcdTemperature

double getSetCcdTemperature(long cameraId)
                            throws RemoteException
Returns the camera cooler setpoint.

Parameters:
cameraId - Camera identifier.
Returns:
Camera cooler setpoint in degrees Celsius (°C).
Throws:
RemoteException - Exception if an error occurred.
DriverException - Must throw exception if command not successful.
Must - throw exception if getCapabilities(long).canSetCcdTemperature() is FALSE.
NotConnectedException - Thrown if the driver is not connected.

setSetCcdTemperature

void setSetCcdTemperature(long cameraId,
                          double setCcdTemperature)
                          throws RemoteException
Sets the the camera cooler setpoint.

The driver should throw an InvalidValueException if an attempt is made to call setSetCCDTemperature outside the valid range for the camera. As an assitance to driver authors, to protect equipment and prevent harm to individuals, Conform will report an issue if it is possible to set SetCCDTemperature below -280C or above +100C.

Note: Camera hardware and/or driver should perform cooler ramping, to prevent thermal shock and potential damage to the CCD array or cooler stack.

Parameters:
cameraId - Camera identifier.
setCcdTemperature - Camera cooler setpoint in degrees Celsius (°C).
Throws:
RemoteException - Exception if an error occurred.
DriverException - Must throw exception if command not successful.
InvalidValueException - Must throw an InvalidValueException if an attempt is made to set a value is outside the camera's valid termperature setpoint range.
Must - throw exception if getCapabilities(long).canSetCcdTemperature() is FALSE.
NotConnectedException - Thrown if the driver is not connected.

getHeatSinkTemperature

double getHeatSinkTemperature(long cameraId)
                              throws RemoteException
Returns the current heat sink temperature (called "ambient temperature" by some manufacturers).

Only valid if getCapabilities(long).canSetCcdTemperature() is TRUE.

Parameters:
cameraId - Camera identifier.
Returns:
Heat sink temperature in degrees Celsius (°C).
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw exception if data unavailable.

getFullWellCapacity

double getFullWellCapacity(long cameraId)
                           throws RemoteException
Returns the full well capacity of the camera, at the current camera settings (binning, SetupDialog settings, etc...).

Parameters:
cameraId - Camera identifier.
Returns:
Full well capacity of the camera in electrons.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw exception if data unavailable.

getElectronsPerAdu

double getElectronsPerAdu(long cameraId)
                          throws RemoteException
Returns the gain of the camera in photoelectrons per A/D unit.

Some cameras have multiple gain modes; these should be selected via the DeviceOrbProcess.showSetupDialog(long) and thus are static during a session.

Parameters:
cameraId - Camera identifier.
Returns:
Gain of the camera in photoelectrons per A/D unit.
Throws:
RemoteException - Exception if an error occurred.
NotConnectedException - Must throw exception if data unavailable.


Copyright © 2012 astroDevice. All Rights Reserved.