bool SestoSenso::initProperties()
{
INDI::Focuser::initProperties();
// Firmware Information
IUFillText(&FirmwareT[0], "VERSION", "Version", "");
IUFillTextVector(&FirmwareTP, FirmwareT, 1, getDeviceName(), "FOCUS_FIRMWARE", "Firmware", MAIN_CONTROL_TAB, IP_RO, 0, IPS_IDLE);
// Focuser temperature
IUFillNumber(&TemperatureN[0], "TEMPERATURE", "Celsius", "%6.2f", -50, 70., 0., 0.);
IUFillNumberVector(&TemperatureNP, TemperatureN, 1, getDeviceName(), "FOCUS_TEMPERATURE", "Temperature", MAIN_CONTROL_TAB, IP_RO, 0, IPS_IDLE);
// Sync
IUFillNumber(&SyncN[0], "FOCUS_SYNC_OFFSET", "Offset", "%6.0f", 0, 60000., 0., 0.);
IUFillNumberVector(&SyncNP, SyncN, 1, getDeviceName(), "FOCUS_SYNC", "Sync", MAIN_CONTROL_TAB, IP_RW, 0, IPS_IDLE);
// Relative and absolute movement
FocusRelPosN[0].min = 0.;
FocusRelPosN[0].max = 50000.;
FocusRelPosN[0].value = 0;
FocusRelPosN[0].step = 1000;
FocusAbsPosN[0].min = 0.;
FocusAbsPosN[0].max = 100000.;
FocusAbsPosN[0].value = 0;
FocusAbsPosN[0].step = 1000;
addAuxControls();
updatePeriodMS = POLLMS;
return true;
}
bool FlipFlat::initProperties()
{
INDI::DefaultDevice::initProperties();
// Status
IUFillText(&StatusT[0], "Cover", "", nullptr);
IUFillText(&StatusT[1], "Light", "", nullptr);
IUFillText(&StatusT[2], "Motor", "", nullptr);
IUFillTextVector(&StatusTP, StatusT, 3, getDeviceName(), "Status", "", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
// Firmware version
IUFillText(&FirmwareT[0], "Version", "", nullptr);
IUFillTextVector(&FirmwareTP, FirmwareT, 1, getDeviceName(), "Firmware", "", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
initDustCapProperties(getDeviceName(), MAIN_CONTROL_TAB);
initLightBoxProperties(getDeviceName(), MAIN_CONTROL_TAB);
LightIntensityN[0].min = 0;
LightIntensityN[0].max = 255;
LightIntensityN[0].step = 10;
// Set DUSTCAP_INTEFACE later on connect after we verify whether it's flip-flat (dust cover + light) or just flip-man (light only)
setDriverInterface(AUX_INTERFACE | LIGHTBOX_INTERFACE);
addAuxControls();
serialConnection = new Connection::Serial(this);
serialConnection->registerHandshake([&]() { return Handshake(); });
registerConnection(serialConnection);
return true;
}
/**************************************************************************************
** INDI is asking us to init our properties.
***************************************************************************************/
bool RadioSim::initProperties()
{
// Must init parent properties first!
INDI::Detector::initProperties();
// We set the Detector capabilities
uint32_t cap = DETECTOR_CAN_ABORT | DETECTOR_HAS_CONTINUUM;
SetDetectorCapability(cap);
IUFillNumber(&DetectorPropertiesN[0], "DETECTOR_SIZE", "Dish size (m)", "%4.0f", 5, MAX_DISH_SIZE_M, 1, 5.0);
IUFillNumberVector(&DetectorPropertiesNP, DetectorPropertiesN, 1, getDeviceName(), "DETECTOR_PROPERTIES", "Control", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
IUFillNumber(&DetectorCoordsN[0], "DETECTOR_RA", "Position (RA)", "%2.3f", 0, FOV_DEG, 1, 0);
IUFillNumber(&DetectorCoordsN[1], "DETECTOR_DEC", "Position (DEC)", "%2.3f", 0, FOV_DEG, 1, FOV_DEG/2);
IUFillNumberVector(&DetectorCoordsNP, DetectorCoordsN, 2, getDeviceName(), "DETECTOR_COORDS", "Coordinates", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
PrimaryDetector.setMinMaxStep("DETECTOR_CAPTURE", "DETECTOR_CAPTURE_VALUE", 0.3, 10, 1, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_FREQUENCY", FREQUENCY, FREQUENCY, 0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_SAMPLERATE", 0, 1.0, 0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_BITSPERSAMPLE", 8, 8, 1, false);
// Add Debug, Simulator, and Configuration controls
addAuxControls();
setDefaultPollingPeriod(500);
return true;
}
void GPhotoCCD::ISGetProperties(const char *dev)
{
INDI::CCD::ISGetProperties(dev);
defineText(&PortTP);
loadConfig(true, "DEVICE_PORT");
if (isConnected())
{
if (mIsoSP.nsp > 0)
defineSwitch(&mIsoSP);
if (mFormatSP.nsp > 0)
defineSwitch(&mFormatSP);
defineSwitch(&transferFormatSP);
defineSwitch(&livePreviewSP);
defineSwitch(&autoFocusSP);
defineSwitch(&FocusMotionSP);
defineNumber(&FocusSpeedNP);
defineNumber(&FocusTimerNP);
ShowExtendedOptions();
ITextVectorProperty *modelTP = getText("model");
if (modelTP && !strcmp(modelTP->label, "model") && strstr(modelTP->tp[0].text, "Canon"))
defineNumber(&mMirrorLockNP);
}
// Add Debug, Simulator, and Configuration controls
addAuxControls();
}
void GPhotoCCD::ISGetProperties(const char *dev)
{
INDI::CCD::ISGetProperties(dev);
defineText(&PortTP);
loadConfig(true, "DEVICE_PORT");
if (isConnected())
{
if(PortTP.tp[0].text && strlen(PortTP.tp[0].text))
{
defineNumber(&mMirrorLockNP);
}
if (mIsoSP.nsp > 0)
defineSwitch(&mIsoSP);
if (mFormatSP.nsp > 0)
defineSwitch(&mFormatSP);
defineSwitch(&transferFormatSP);
defineSwitch(&livePreviewSP);
defineSwitch(&autoFocusSP);
defineSwitch(&FocusMotionSP);
defineNumber(&FocusSpeedNP);
defineNumber(&FocusTimerNP);
ShowExtendedOptions();
}
// Add Debug, Simulator, and Configuration controls
addAuxControls();
}
/**************************************************************************************
** INDI is asking us to init our properties.
***************************************************************************************/
bool RadioSim::initProperties()
{
// Must init parent properties first!
INDI::Detector::initProperties();
// We set the Detector capabilities
uint32_t cap = DETECTOR_CAN_ABORT | DETECTOR_HAS_CONTINUUM | DETECTOR_HAS_SPECTRUM;
SetDetectorCapability(cap);
IUFillNumber(&DetectorPropertiesN[0], "DETECTOR_SIZE", "Dish size (m)", "%4.0f", 5, MAX_DISH_SIZE_M, 1, 5.0);
IUFillNumberVector(&DetectorPropertiesNP, DetectorPropertiesN, 1, getDeviceName(), "DETECTOR_PROPERTIES", "Control", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
PrimaryDetector.setMinMaxStep("DETECTOR_CAPTURE", "DETECTOR_CAPTURE_VALUE", 1.0e-6, 86164.092, 0.001, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_FREQUENCY", 1.0e+6, 50.0e+9, 1.0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_SAMPLERATE", 1.0e+3, 100.0e+3, 1.0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_GAIN", 0.0, 25.0, 1.0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_BANDWIDTH", 1.0e+3, 100.0e+6, 1.0, false);
PrimaryDetector.setMinMaxStep("DETECTOR_SETTINGS", "DETECTOR_BITSPERSAMPLE", -64, -64, -64, false);
PrimaryDetector.setCaptureExtension("fits");
// Add Debug, Simulator, and Configuration controls
addAuxControls();
setDefaultPollingPeriod(500);
return true;
}
bool XAGYLWheel::initProperties()
{
INDI::FilterWheel::initProperties();
// Device port
IUFillText(&PortT[0],"PORT","Port","/dev/ttyUSB0");
IUFillTextVector(&PortTP,PortT,1,getDeviceName(),"DEVICE_PORT","Ports",OPTIONS_TAB,IP_RW,60,IPS_IDLE);
// Firmware info
IUFillText(&FirmwareInfoT[0],"Product","",NULL);
IUFillText(&FirmwareInfoT[1],"Firmware","",NULL);
IUFillText(&FirmwareInfoT[2],"Serial #","",NULL);
IUFillTextVector(&FirmwareInfoTP,FirmwareInfoT,3,getDeviceName(),"Info","",MAIN_CONTROL_TAB,IP_RO,60,IPS_IDLE);
// Settings
IUFillNumber(&SettingsN[0], "Speed", "", "%.f", 0, 100, 10., 0.);
IUFillNumber(&SettingsN[1], "Jitter", "", "%.f", 0, 10, 1., 0.);
IUFillNumber(&SettingsN[2], "Threshold", "", "%.f", 0, 100, 10., 0.);
IUFillNumber(&SettingsN[3], "Pulse Width", "", "%.f", 100, 10000, 100., 0.);
IUFillNumberVector(&SettingsNP, SettingsN, 4, getDeviceName(), "Settings", "", SETTINGS_TAB, IP_RW, 0, IPS_IDLE);
// Reset
IUFillSwitch(&ResetS[0], "Reboot", "", ISS_OFF);
IUFillSwitch(&ResetS[1], "Initialize", "", ISS_OFF);
IUFillSwitch(&ResetS[2], "Clear Calibration", "", ISS_OFF);
IUFillSwitch(&ResetS[3], "Perform Calibration", "", ISS_OFF);
IUFillSwitchVector(&ResetSP, ResetS, 4, getDeviceName(), "Commands", "", MAIN_CONTROL_TAB, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
addAuxControls();
return true;
}
void FishCampCCD::ISGetProperties(const char *dev)
{
INDI::CCD::ISGetProperties(dev);
// Add Debug, Simulator, and Configuration controls
addAuxControls();
}
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;
}
bool NFocus::initProperties()
{
INDI::Focuser::initProperties();
// No speed for nfocus
FocusSpeedN[0].min = FocusSpeedN[0].max = FocusSpeedN[0].value = 1;
IUUpdateMinMax(&FocusSpeedNP);
/* Focuser temperature */
IUFillNumber(&TemperatureN[0], "TEMPERATURE", "Celsius", "%6.2f", 0, 65000., 0., 10000.);
IUFillNumberVector(&TemperatureNP, TemperatureN, 1, getDeviceName(), "FOCUS_TEMPERATURE", "Temperature",
MAIN_CONTROL_TAB, IP_RO, 0, IPS_IDLE);
/* Settings of the Nfocus */
IUFillNumber(&SettingsN[0], "ON time", "ON waiting time", "%6.0f", 10., 250., 0., 73.);
IUFillNumber(&SettingsN[1], "OFF time", "OFF waiting time", "%6.0f", 1., 250., 0., 15.);
IUFillNumber(&SettingsN[2], "Fast Mode Delay", "Fast Mode Delay", "%6.0f", 0., 255., 0., 9.);
IUFillNumberVector(&SettingsNP, SettingsN, 3, getDeviceName(), "FOCUS_SETTINGS", "Settings", OPTIONS_TAB, IP_RW, 0,
IPS_IDLE);
/* tick scaling factor. Inward dir ticks times this factor is considered to
be the same as outward dir tick numbers. This is to compensate for DC motor
incapabilities with regards to exact positioning at least a bit on the mass
dependent path.... */
IUFillNumber(&InOutScalarN[0], "In/Out Scalar", "In/Out Scalar", "%1.2f", 0., 2., 1., 1.0);
IUFillNumberVector(&InOutScalarNP, InOutScalarN, 1, getDeviceName(), "FOCUS_DIRSCALAR", "Direction scaling factor",
OPTIONS_TAB, IP_RW, 0, IPS_IDLE);
/* Nfocus should stay within these limits */
IUFillNumber(&MinMaxPositionN[0], "MINPOS", "Minimum Tick", "%6.0f", -65000., 65000., 0., -65000.);
IUFillNumber(&MinMaxPositionN[1], "MAXPOS", "Maximum Tick", "%6.0f", 1., 65000., 0., 65000.);
IUFillNumberVector(&MinMaxPositionNP, MinMaxPositionN, 2, getDeviceName(), "FOCUS_MINMAXPOSITION", "Extrema",
OPTIONS_TAB, IP_RW, 0, IPS_IDLE);
IUFillNumber(&MaxTravelN[0], "MAXTRAVEL", "Maximum travel", "%6.0f", 1., 64000., 0., 10000.);
IUFillNumberVector(&MaxTravelNP, MaxTravelN, 1, getDeviceName(), "FOCUS_MAXTRAVEL", "Max. travel", OPTIONS_TAB,
IP_RW, 0, IPS_IDLE);
/* Set Nfocus position register to this position */
IUFillNumber(&SyncN[0], "FOCUS_SYNC_OFFSET", "Offset", "%.f", 0, 64000., 0., 0.);
IUFillNumberVector(&SyncNP, SyncN, 1, getDeviceName(), "FOCUS_SYNC", "Sync", MAIN_CONTROL_TAB, IP_RW, 0, IPS_IDLE);
/* Relative and absolute movement */
FocusRelPosN[0].min = 0;
FocusRelPosN[0].max = MinMaxPositionN[1].value;
FocusRelPosN[0].value = 1000;
FocusRelPosN[0].step = 100;
FocusAbsPosN[0].min = MinMaxPositionN[0].min;
FocusAbsPosN[0].max = MinMaxPositionN[0].max;
FocusAbsPosN[0].value = 0;
FocusAbsPosN[0].step = 10000;
addAuxControls();
return true;
}
/************************************************************************************
*
* ***********************************************************************************/
bool RollOff::initProperties()
{
INDI::Dome::initProperties();
SetParkDataType(PARK_NONE);
addAuxControls();
return true;
}
/************************************************************************************
*
* ***********************************************************************************/
bool DomeSim::initProperties()
{
INDI::Dome::initProperties();
SetParkDataType(PARK_AZ);
addAuxControls();
return true;
}
bool MICCD::initProperties()
{
INDI::CCD::initProperties();
INDI::FilterInterface::initProperties(FILTER_TAB);
FilterSlotN[0].min = 1;
FilterSlotN[0].max = numFilters;
// Temp ram
IUFillNumber(&TemperatureRampN[0], "TEMP_RAMP", "Max. dT (C/min)", "%2.0f", 0, 30, 1, 2);
IUFillNumberVector(&TemperatureRampNP, TemperatureRampN, 1, getDeviceName(), "CCD_TEMP_RAMP", "Temp. Ramp",
MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Regulation power
IUFillNumber(&CoolerN[0], "CCD_COOLER_VALUE", "Cooling Power (%)", "%+6.2f", 0.0, 1.0, 0.01, 0.0);
IUFillNumberVector(&CoolerNP, CoolerN, 1, getDeviceName(), "CCD_COOLER_POWER", "Cooling Power", MAIN_CONTROL_TAB,
IP_RO, 60, IPS_IDLE);
// CCD Fan
IUFillNumber(&FanN[0], "FAN", "Fan speed", "%2.0f", 0, maxFanValue, 1, 0);
IUFillNumberVector(&FanNP, FanN, 1, getDeviceName(), "CCD_FAN", "Fan", MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Window heating
IUFillNumber(&WindowHeatingN[0], "WINDOW_HEATING", "Heating Intensity", "%2.0f", 0, maxHeatingValue, 1, 0);
IUFillNumberVector(&WindowHeatingNP, WindowHeatingN, 1, getDeviceName(), "CCD_WINDOW_HEATING", "Window Heating",
MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Gain
IUFillNumber(&GainN[0], "GAIN", "Gain (e-/ADU)", "%2.2f", 0, 100, 1, 0);
IUFillNumberVector(&GainNP, GainN, 1, getDeviceName(), "CCD_GAIN", "Gain", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
// Noise mode
IUFillSwitch(&ReadModeS[0], "PREVIEW", "Preview", ISS_OFF);
IUFillSwitch(&ReadModeS[1], "LOW_NOISE", "Low noise", numReadModes == 2 ? ISS_ON : ISS_OFF);
IUFillSwitch(&ReadModeS[2], "ULTA_LOW_NOISE", "Ultra low noise", numReadModes == 3 ? ISS_ON : ISS_OFF);
IUFillSwitchVector(&ReadModeSP, ReadModeS, numReadModes, getDeviceName(), "CCD_READ_MODE", "Read Mode",
MAIN_CONTROL_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
// NIR Preflash
IUFillNumber(&PreflashN[0], "NIR_EXPOSURE_TIME", "Preflash duration (s)", "%4.3f", 0.0, 65.535, 0.001, 0.0);
IUFillNumber(&PreflashN[1], "NIR_CLEAR_NUM", "Num. clear", "%2.0f", 1, 16, 1, 3);
IUFillNumberVector(&PreflashNP, PreflashN, 2, getDeviceName(), "NIR_PRE_FLASH", "NIR Preflash",
MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
addAuxControls();
setDriverInterface(getDriverInterface() | FILTER_INTERFACE);
return true;
}
/**************************************************************************************
** INDI is asking us to init our properties.
***************************************************************************************/
bool SimpleDetector::initProperties()
{
// Must init parent properties first!
INDI::Detector::initProperties();
// We set the Detector capabilities
uint32_t cap = DETECTOR_CAN_ABORT | DETECTOR_HAS_COOLER | DETECTOR_HAS_SHUTTER | DETECTOR_HAS_CONTINUUM | DETECTOR_HAS_SPECTRUM;
SetDetectorCapability(cap);
// Add Debug, Simulator, and Configuration controls
addAuxControls();
return true;
}
bool QHYCFW2::initProperties()
{
INDI::FilterWheel::initProperties();
IUFillNumber(&MaxFilterN[0], "Count", "Count", "%.f", 1, 16, 1, 5);
IUFillNumberVector(&MaxFilterNP, MaxFilterN, 1, getDeviceName(), "MAX_FILTER", "Filters", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
CurrentFilter = 1;
FilterSlotN[0].min = 1;
FilterSlotN[0].max = MaxFilterN[0].value;
addAuxControls();
return true;
}
/**************************************************************************************
** INDI is asking us to init our properties.
***************************************************************************************/
bool FFMVCCD::initProperties()
{
// Must init parent properties first!
INDI::CCD::initProperties();
// Add Debug, Simulator, and Configuration controls
addAuxControls();
/* Add Gain Vref switch */
IUFillSwitch(&GainS[0], "GAINVREF", "Vref Boost", ISS_OFF);
IUFillSwitch(&GainS[1], "GAIN2X", "2x Digital Boost", ISS_OFF);
IUFillSwitchVector(&GainSP, GainS, 2, getDeviceName(), "GAIN", "Gain", IMAGE_SETTINGS_TAB, IP_WO, ISR_NOFMANY, 0, IPS_IDLE);
return true;
}
bool QHYCCD::initProperties()
{
INDI::CCD::initProperties();
INDI::FilterInterface::initProperties(FILTER_TAB);
FilterSlotN[0].min = 1;
FilterSlotN[0].max = 9;
// CCD Cooler Switch
IUFillSwitch(&CoolerS[0], "COOLER_ON", "On", ISS_OFF);
IUFillSwitch(&CoolerS[1], "COOLER_OFF", "Off", ISS_ON);
IUFillSwitchVector(&CoolerSP, CoolerS, 2, getDeviceName(), "CCD_COOLER", "Cooler", MAIN_CONTROL_TAB, IP_RW,
ISR_1OFMANY, 0, IPS_IDLE);
// CCD Regulation power
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);
// CCD Gain
IUFillNumber(&GainN[0], "GAIN", "Gain", "%3.0f", 0, 100, 1, 11);
IUFillNumberVector(&GainNP, GainN, 1, getDeviceName(), "CCD_GAIN", "Gain", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
// CCD Offset
IUFillNumber(&OffsetN[0], "Offset", "Offset", "%3.0f", 0, 0, 1, 0);
IUFillNumberVector(&OffsetNP, OffsetN, 1, getDeviceName(), "CCD_OFFSET", "Offset", MAIN_CONTROL_TAB, IP_RW, 60,
IPS_IDLE);
// USB Speed
IUFillNumber(&SpeedN[0], "Speed", "Speed", "%3.0f", 0, 0, 1, 0);
IUFillNumberVector(&SpeedNP, SpeedN, 1, getDeviceName(), "USB_SPEED", "USB Speed", MAIN_CONTROL_TAB, IP_RW, 60,
IPS_IDLE);
// USB Traffic
IUFillNumber(&USBTrafficN[0], "Speed", "Speed", "%3.0f", 0, 0, 1, 0);
IUFillNumberVector(&USBTrafficNP, USBTrafficN, 1, getDeviceName(), "USB_TRAFFIC", "USB Traffic", MAIN_CONTROL_TAB,
IP_RW, 60, IPS_IDLE);
// Set minimum exposure speed to 0.001 seconds
//PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", MINIMUM_CCD_EXPOSURE, 3600, 1, false);
addAuxControls();
setDriverInterface(getDriverInterface() | FILTER_INTERFACE);
return true;
}
bool BaaderDome::initProperties()
{
INDI::Dome::initProperties();
IUFillSwitch(&CalibrateS[0], "Start", "", ISS_OFF);
IUFillSwitchVector(&CalibrateSP, CalibrateS, 1, getDeviceName(), "Calibrate", "", MAIN_CONTROL_TAB, IP_RW,
ISR_ATMOST1, 0, IPS_IDLE);
IUFillSwitch(&DomeFlapS[0], "FLAP_OPEN", "Open", ISS_OFF);
IUFillSwitch(&DomeFlapS[1], "FLAP_CLOSE", "Close", ISS_ON);
IUFillSwitchVector(&DomeFlapSP, DomeFlapS, 2, getDeviceName(), "DOME_FLAP", "Flap", MAIN_CONTROL_TAB, IP_RW,
ISR_1OFMANY, 60, IPS_OK);
SetParkDataType(PARK_AZ);
addAuxControls();
return true;
}
bool ATIKCCD::initProperties()
{
INDI::CCD::initProperties();
// Cooler control
IUFillSwitch(&CoolerS[COOLER_ON], "COOLER_ON", "ON", ISS_OFF);
IUFillSwitch(&CoolerS[COOLER_OFF], "COOLER_OFF", "OFF", ISS_ON);
IUFillSwitchVector(&CoolerSP, CoolerS, 2, getDeviceName(), "CCD_COOLER", "Cooler", MAIN_CONTROL_TAB, IP_WO,
ISR_1OFMANY, 2, IPS_IDLE);
// Temperature value
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);
// Version information
IUFillText(&VersionInfoS[VERSION_API], "VERSION_API", "API", std::to_string(ArtemisAPIVersion()).c_str());
IUFillText(&VersionInfoS[VERSION_FIRMWARE], "VERSION_FIRMWARE", "Firmware", "Unknown");
IUFillTextVector(&VersionInfoSP, VersionInfoS, 2, getDeviceName(), "VERSION", "Version", INFO_TAB, IP_RO, 60, IPS_IDLE);
// Gain/Offset Presets
IUFillSwitch(&ControlPresetsS[PRESET_CUSTOM], "PRESET_CUSTOM", "Custom", ISS_ON);
IUFillSwitch(&ControlPresetsS[PRESET_LOW], "PRESET_LOW", "Low", ISS_OFF);
IUFillSwitch(&ControlPresetsS[PRESET_MEDIUM], "PRESET_MEDIUM", "Medium", ISS_OFF);
IUFillSwitch(&ControlPresetsS[PRESET_HIGH], "PRESET_HIGH", "High", ISS_OFF);
IUFillSwitchVector(&ControlPresetsSP, ControlPresetsS, 2, getDeviceName(), "CCD_CONTROL_PRESETS", "GO Presets", CONTROLS_TAB, IP_RW,
ISR_1OFMANY, 4, IPS_IDLE);
// Gain/Offset Controls
IUFillNumber(&ControlN[CONTROL_GAIN], "CONTROL_GAIN", "Gain", "%.f", 0, 60, 5, 30);
IUFillNumber(&ControlN[CONTROL_OFFSET], "CONTROL_OFFSET", "Offset", "%.f", 0, 511, 10, 0);
IUFillNumberVector(&ControlNP, ControlN, 2, getDeviceName(), "CCD_CONTROLS", "GO Controls", CONTROLS_TAB,
IP_RO, 60, IPS_IDLE);
IUSaveText(&BayerT[2], "RGGB");
INDI::FilterInterface::initProperties(FILTER_TAB);
addAuxControls();
return true;
}
bool MICCD::initProperties()
{
INDI::CCD::initProperties();
initFilterProperties(getDeviceName(), FILTER_TAB);
FilterSlotN[0].min = 1;
FilterSlotN[0].max = numFilters;
// Temp ram
IUFillNumber(&TemperatureRampN[0], "TEMP_RAMP", "Max. dT (C/min)", "%2.0f", 0, 30, 1, 2);
IUFillNumberVector(&TemperatureRampNP, TemperatureRampN, 1, getDeviceName(), "CCD_TEMP_RAMP", "Temp. ramp", MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Regulation power
IUFillNumber(&CoolerN[0], "CCD_COOLER_VALUE", "Cooling Power (%)", "%+6.2f", 0.0, 1.0, 0.01, 0.0);
IUFillNumberVector(&CoolerNP, CoolerN, 1, getDeviceName(), "CCD_COOLER_POWER", "Cooling Power", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
// CCD Fan
IUFillNumber(&FanN[0], "FAN", "Fan speed", "%2.0f", 0, maxFanValue, 1, 0);
IUFillNumberVector(&FanNP, FanN, 1, getDeviceName(), "CCD_FAN", "Fan", MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Window heating
IUFillNumber(&WindowHeatingN[0], "WINDOW_HEATING", "Heating intensity", "%2.0f", 0, maxHeatingValue, 1, 0);
IUFillNumberVector(&WindowHeatingNP, WindowHeatingN, 1, getDeviceName(), "CCD_WINDOW_HEATING", "Heating", MAIN_CONTROL_TAB, IP_WO, 60, IPS_IDLE);
// CCD Gain
IUFillNumber(&GainN[0], "GAIN", "Gain (e-/ADU)", "%2.2f", 0, 100, 1, 0);
IUFillNumberVector(&GainNP, GainN, 1, getDeviceName(), "CCD_GAIN", "Gain", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
// Noise mode
IUFillSwitch(&NoiseS[0], "NORMAL_NOISE", "Normal", ISS_ON);
IUFillSwitch(&NoiseS[1], "LOW_NOISE", "Low", ISS_OFF);
IUFillSwitch(&NoiseS[2], "ULTA_LOW_NOISE", "Ultra low", ISS_OFF);
IUFillSwitchVector(&NoiseSP, NoiseS, numReadModes, getDeviceName(), "CCD_NOISE", "Noise", MAIN_CONTROL_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
addAuxControls();
setDriverInterface(getDriverInterface() | FILTER_INTERFACE);
return true;
}
bool Paramount::initProperties()
{
/* Make sure to init parent properties first */
INDI::Telescope::initProperties();
for (int i = 0; i < SlewRateSP.nsp-1; i++)
{
sprintf(SlewRateSP.sp[i].label, "%.fx", slewspeeds[i]);
SlewRateSP.sp[i].aux = (void *)&slewspeeds[i];
}
// Set 64x as default speed
SlewRateSP.sp[5].s = ISS_ON;
/* How fast do we guide compared to sidereal rate */
IUFillNumber(&JogRateN[RA_AXIS], "JOG_RATE_WE", "W/E Rate (arcmin)", "%g", 0, 600, 60, 30);
IUFillNumber(&JogRateN[DEC_AXIS], "JOG_RATE_NS", "N/S Rate (arcmin)", "%g", 0, 600, 60, 30);
IUFillNumberVector(&JogRateNP, JogRateN, 2, getDeviceName(), "JOG_RATE", "Jog Rate", MOTION_TAB, IP_RW, 0,
IPS_IDLE);
/* How fast do we guide compared to sidereal rate */
IUFillNumber(&GuideRateN[RA_AXIS], "GUIDE_RATE_WE", "W/E Rate", "%1.1f", 0.0, 1.0, 0.1, 0.5);
IUFillNumber(&GuideRateN[DEC_AXIS], "GUIDE_RATE_NS", "N/S Rate", "%1.1f", 0.0, 1.0, 0.1, 0.5);
IUFillNumberVector(&GuideRateNP, GuideRateN, 2, getDeviceName(), "GUIDE_RATE", "Guiding Rate", MOTION_TAB, IP_RW, 0,
IPS_IDLE);
// Tracking Mode
#if 0
IUFillSwitch(&TrackModeS[TRACK_SIDEREAL], "TRACK_SIDEREAL", "Sidereal", ISS_OFF);
IUFillSwitch(&TrackModeS[TRACK_SOLAR], "TRACK_SOLAR", "Solar", ISS_OFF);
IUFillSwitch(&TrackModeS[TRACK_LUNAR], "TRACK_LUNAR", "Lunar", ISS_OFF);
IUFillSwitch(&TrackModeS[TRACK_CUSTOM], "TRACK_CUSTOM", "Custom", ISS_OFF);
IUFillSwitchVector(&TrackModeSP, TrackModeS, 4, getDeviceName(), "TELESCOPE_TRACK_MODE", "Track Mode",
MAIN_CONTROL_TAB, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
#endif
AddTrackMode("TRACK_SIDEREAL", "Sidereal", true);
AddTrackMode("TRACK_SOLAR", "Solar");
AddTrackMode("TRACK_LUNAR", "Lunar");
AddTrackMode("TRACK_CUSTOM", "Custom");
// Custom Tracking Rate
#if 0
IUFillNumber(&TrackRateN[0], "TRACK_RATE_RA", "RA (arcsecs/s)", "%.6f", -16384.0, 16384.0, 0.000001, 15.041067);
IUFillNumber(&TrackRateN[1], "TRACK_RATE_DE", "DE (arcsecs/s)", "%.6f", -16384.0, 16384.0, 0.000001, 0);
IUFillNumberVector(&TrackRateNP, TrackRateN, 2, getDeviceName(), "TELESCOPE_TRACK_RATE", "Track Rates",
MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
#endif
// Let's simulate it to be an F/7.5 120mm telescope with 50m 175mm guide scope
ScopeParametersN[0].value = 120;
ScopeParametersN[1].value = 900;
ScopeParametersN[2].value = 50;
ScopeParametersN[3].value = 175;
TrackState = SCOPE_IDLE;
SetParkDataType(PARK_RA_DEC);
initGuiderProperties(getDeviceName(), MOTION_TAB);
setDriverInterface(getDriverInterface() | GUIDER_INTERFACE);
addAuxControls();
double longitude=0, latitude=90;
// Get value from config file if it exists.
IUGetConfigNumber(getDeviceName(), "GEOGRAPHIC_COORD", "LONG", &longitude);
currentRA = get_local_sidereal_time(longitude);
IUGetConfigNumber(getDeviceName(), "GEOGRAPHIC_COORD", "LAT", &latitude);
currentDEC = latitude > 0 ? 90 : -90;
return true;
}
bool SynscanDriver::initProperties()
{
INDI::Telescope::initProperties();
SetTelescopeCapability(TELESCOPE_CAN_PARK | TELESCOPE_CAN_ABORT | TELESCOPE_CAN_SYNC | TELESCOPE_CAN_GOTO |
TELESCOPE_HAS_TIME | TELESCOPE_HAS_LOCATION | TELESCOPE_HAS_PIER_SIDE | TELESCOPE_CAN_CONTROL_TRACK |
TELESCOPE_HAS_TRACK_MODE, 10);
SetParkDataType(PARK_RA_DEC_ENCODER);
// Slew Rates
strncpy(SlewRateS[0].label, "1x", MAXINDILABEL);
strncpy(SlewRateS[1].label, "8x", MAXINDILABEL);
strncpy(SlewRateS[2].label, "16x", MAXINDILABEL);
strncpy(SlewRateS[3].label, "32x", MAXINDILABEL);
strncpy(SlewRateS[4].label, "64x", MAXINDILABEL);
strncpy(SlewRateS[5].label, "128x", MAXINDILABEL);
strncpy(SlewRateS[6].label, "400x", MAXINDILABEL);
strncpy(SlewRateS[7].label, "600x", MAXINDILABEL);
strncpy(SlewRateS[8].label, "Max", MAXINDILABEL);
strncpy(SlewRateS[9].label, "Custom", MAXINDILABEL);
IUResetSwitch(&SlewRateSP);
// Max is the default
SlewRateS[8].s = ISS_ON;
//////////////////////////////////////////////////////////////////////////////////////////////////
/// Mount Info Text Property
//////////////////////////////////////////////////////////////////////////////////////////////////
IUFillText(&StatusT[MI_FW_VERSION], "MI_FW_VERSION", "Firmware", "-");
IUFillText(&StatusT[MI_MOUNT_MODEL], "MI_MOUNT_MODEL", "Model", "-");
IUFillText(&StatusT[MI_GOTO_STATUS], "MI_GOTO_STATUS", "Goto", "-");
IUFillText(&StatusT[MI_POINT_STATUS], "MI_POINT_STATUS", "Pointing", "-");
IUFillText(&StatusT[MI_TRACK_MODE], "MI_TRACK_MODE", "Tracking Mode", "-");
IUFillTextVector(&StatusTP, StatusT, 5, getDeviceName(), "MOUNT_STATUS",
"Status", MOUNT_TAB, IP_RO, 60, IPS_IDLE);
//////////////////////////////////////////////////////////////////////////////////////////////////
/// Custom Slew Rate
//////////////////////////////////////////////////////////////////////////////////////////////////
IUFillNumber(&CustomSlewRateN[AXIS_RA], "AXIS1", "RA/AZ (arcsecs/s)", "%.2f", 0.05, 800, 10, 0);
IUFillNumber(&CustomSlewRateN[AXIS_DE], "AXIS2", "DE/AL (arcsecs/s)", "%.2f", 0.05, 800, 10, 0);
IUFillNumberVector(&CustomSlewRateNP, CustomSlewRateN, 2, getDeviceName(), "CUSTOM_SLEW_RATE", "Custom Slew", MOTION_TAB, IP_RW, 60, IPS_IDLE);
//////////////////////////////////////////////////////////////////////////////////////////////////
/// Guide Rate
//////////////////////////////////////////////////////////////////////////////////////////////////
IUFillNumber(&GuideRateN[AXIS_RA], "GUIDE_RATE_WE", "W/E Rate", "%.2f", 0, 1, 0.1, 0.5);
IUFillNumber(&GuideRateN[AXIS_DE], "GUIDE_RATE_NS", "N/S Rate", "%.2f", 0, 1, 0.1, 0.5);
IUFillNumberVector(&GuideRateNP, GuideRateN, 2, getDeviceName(), "GUIDE_RATE", "Guiding Rate", GUIDE_TAB, IP_RW, 0, IPS_IDLE);
//////////////////////////////////////////////////////////////////////////////////////////////////
/// Horizontal Coords
//////////////////////////////////////////////////////////////////////////////////////////////////
IUFillNumber(&HorizontalCoordsN[AXIS_AZ], "AZ", "Az D:M:S", "%10.6m", 0.0, 360.0, 0.0, 0);
IUFillNumber(&HorizontalCoordsN[AXIS_ALT], "ALT", "Alt D:M:S", "%10.6m", -90., 90.0, 0.0, 0);
IUFillNumberVector(&HorizontalCoordsNP, HorizontalCoordsN, 2, getDeviceName(), "HORIZONTAL_COORD",
"Horizontal Coord", MAIN_CONTROL_TAB, IP_RW, 0, IPS_IDLE);
AddTrackMode("TRACK_ALTAZ", "Alt/Az");
AddTrackMode("TRACK_EQ", "Equatorial", true);
AddTrackMode("TRACK_PEC", "PEC Mode");
SetParkDataType(PARK_AZ_ALT);
// Initialize guiding properties.
initGuiderProperties(getDeviceName(), GUIDE_TAB);
addAuxControls();
//GUIDE Set guider interface.
setDriverInterface(getDriverInterface() | GUIDER_INTERFACE);
return true;
}
bool ScopeDome::initProperties()
{
INDI::Dome::initProperties();
IUFillNumber(&DomeHomePositionN[0], "DH_POSITION", "AZ (deg)", "%6.2f", 0.0, 360.0, 1.0, 0.0);
IUFillNumberVector(&DomeHomePositionNP, DomeHomePositionN, 1, getDeviceName(), "DOME_HOME_POSITION",
"Home sensor position", SITE_TAB, IP_RW, 60, IPS_OK);
IUFillSwitch(&ParkShutterS[0], "ON", "On", ISS_ON);
IUFillSwitch(&ParkShutterS[1], "OFF", "Off", ISS_OFF);
IUFillSwitchVector(&ParkShutterSP, ParkShutterS, 2, getDeviceName(), "PARK_SHUTTER", "Park controls shutter",
OPTIONS_TAB, IP_RW, ISR_1OFMANY, 0, IPS_OK);
IUFillSwitch(&FindHomeS[0], "START", "Start", ISS_OFF);
IUFillSwitchVector(&FindHomeSP, FindHomeS, 1, getDeviceName(), "FIND_HOME", "Find home", MAIN_CONTROL_TAB, IP_RW,
ISR_ATMOST1, 0, IPS_IDLE);
IUFillSwitch(&DerotateS[0], "START", "Start", ISS_OFF);
IUFillSwitchVector(&DerotateSP, DerotateS, 1, getDeviceName(), "DEROTATE", "Derotate", MAIN_CONTROL_TAB, IP_RW,
ISR_ATMOST1, 0, IPS_IDLE);
IUFillSwitch(&PowerRelaysS[0], "CCD", "CCD", ISS_OFF);
IUFillSwitch(&PowerRelaysS[1], "SCOPE", "Telescope", ISS_OFF);
IUFillSwitch(&PowerRelaysS[2], "LIGHT", "Light", ISS_OFF);
IUFillSwitch(&PowerRelaysS[3], "FAN", "Fan", ISS_OFF);
IUFillSwitchVector(&PowerRelaysSP, PowerRelaysS, 4, getDeviceName(), "POWER_RELAYS", "Power relays",
MAIN_CONTROL_TAB, IP_RW, ISR_NOFMANY, 0, IPS_IDLE);
IUFillSwitch(&RelaysS[0], "RELAY_1", "Relay 1 (reset)", ISS_OFF);
IUFillSwitch(&RelaysS[1], "RELAY_2", "Relay 2 (heater)", ISS_OFF);
IUFillSwitch(&RelaysS[2], "RELAY_3", "Relay 3", ISS_OFF);
IUFillSwitch(&RelaysS[3], "RELAY_4", "Relay 4", ISS_OFF);
IUFillSwitchVector(&RelaysSP, RelaysS, 4, getDeviceName(), "RELAYS", "Relays", MAIN_CONTROL_TAB, IP_RW, ISR_NOFMANY,
0, IPS_IDLE);
IUFillSwitch(&AutoCloseS[0], "CLOUD", "Cloud sensor", ISS_OFF);
IUFillSwitch(&AutoCloseS[1], "RAIN", "Rain sensor", ISS_OFF);
IUFillSwitch(&AutoCloseS[2], "FREE", "Free input", ISS_OFF);
IUFillSwitch(&AutoCloseS[3], "NO_POWER", "No power", ISS_OFF);
IUFillSwitch(&AutoCloseS[4], "DOME_LOW", "Low dome battery", ISS_OFF);
IUFillSwitch(&AutoCloseS[5], "SHUTTER_LOW", "Low shutter battery", ISS_OFF);
IUFillSwitch(&AutoCloseS[6], "WEATHER", "Bad weather", ISS_OFF);
IUFillSwitch(&AutoCloseS[7], "LOST_CONNECTION", "Lost connection", ISS_OFF);
IUFillSwitchVector(&AutoCloseSP, AutoCloseS, 8, getDeviceName(), "AUTO_CLOSE", "Close shutter automatically",
SITE_TAB, IP_RW, ISR_NOFMANY, 0, IPS_IDLE);
IUFillNumber(&EnvironmentSensorsN[0], "LINK_STRENGTH", "Shutter link strength", "%3.0f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[1], "SHUTTER_POWER", "Shutter internal power", "%2.2f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[2], "SHUTTER_BATTERY", "Shutter battery power", "%2.2f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[3], "CARD_POWER", "Card internal power", "%2.2f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[4], "CARD_BATTERY", "Card battery power", "%2.2f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[5], "TEMP_DOME_IN", "Temperature in dome", "%2.2f", -100.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[6], "TEMP_DOME_OUT", "Temperature outside dome", "%2.2f", -100.0, 100.0, 1.0,
0.0);
IUFillNumber(&EnvironmentSensorsN[7], "TEMP_DOME_HUMIDITY", "Temperature humidity sensor", "%2.2f", -100.0, 100.0,
1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[8], "HUMIDITY", "Humidity", "%3.2f", 0.0, 100.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[9], "PRESSURE", "Pressure", "%4.1f", 0.0, 2000.0, 1.0, 0.0);
IUFillNumber(&EnvironmentSensorsN[10], "DEW_POINT", "Dew point", "%2.2f", -100.0, 100.0, 1.0, 0.0);
IUFillNumberVector(&EnvironmentSensorsNP, EnvironmentSensorsN, 11, getDeviceName(), "SCOPEDOME_SENSORS",
"Environment sensors", INFO_TAB, IP_RO, 60, IPS_IDLE);
IUFillSwitch(&SensorsS[0], "AZ_COUNTER", "Az counter", ISS_OFF);
IUFillSwitch(&SensorsS[1], "ROTATE_CCW", "Rotate CCW", ISS_OFF);
IUFillSwitch(&SensorsS[2], "HOME", "Dome at home", ISS_OFF);
IUFillSwitch(&SensorsS[3], "OPEN_1", "Shutter 1 open", ISS_OFF);
IUFillSwitch(&SensorsS[4], "CLOSE_1", "Shutter 1 closed", ISS_OFF);
IUFillSwitch(&SensorsS[5], "OPEN_2", "Shutter 2 open", ISS_OFF);
IUFillSwitch(&SensorsS[6], "CLOSE_2", "Shutter 2 closed", ISS_OFF);
IUFillSwitch(&SensorsS[7], "SCOPE_HOME", "Scope at home", ISS_OFF);
IUFillSwitch(&SensorsS[8], "RAIN", "Rain sensor", ISS_OFF);
IUFillSwitch(&SensorsS[9], "CLOUD", "Cloud sensor", ISS_OFF);
IUFillSwitch(&SensorsS[10], "SAFE", "Observatory safe", ISS_OFF);
IUFillSwitch(&SensorsS[11], "LINK", "Rotary link", ISS_OFF);
IUFillSwitch(&SensorsS[12], "FREE", "Free input", ISS_OFF);
IUFillSwitchVector(&SensorsSP, SensorsS, 13, getDeviceName(), "INPUTS", "Input sensors", INFO_TAB, IP_RO,
ISR_NOFMANY, 0, IPS_IDLE);
IUFillNumber(&FirmwareVersionsN[0], "MAIN", "Main part", "%2.2f", 0.0, 99.0, 1.0, 0.0);
IUFillNumber(&FirmwareVersionsN[1], "ROTARY", "Rotary part", "%2.1f", 0.0, 99.0, 1.0, 0.0);
IUFillNumberVector(&FirmwareVersionsNP, FirmwareVersionsN, 2, getDeviceName(), "FIRMWARE_VERSION",
"Firmware versions", INFO_TAB, IP_RO, 60, IPS_IDLE);
SetParkDataType(PARK_AZ);
addAuxControls();
// Set serial parameters
serialConnection->setDefaultBaudRate(Connection::Serial::B_115200);
return true;
}
bool TCFS::initProperties()
{
//LOGF_DEBUG("%s %s",__FUNCTION__, me);
INDI::Focuser::initProperties();
// Set upper limit for TCF-S3 focuser
if (strcmp(me, "indi_tcfs3_focus") == 0)
{
isTCFS3 = true;
FocusAbsPosN[0].max = 9999;
FocusRelPosN[0].max = 2000;
FocusRelPosN[0].step = FocusAbsPosN[0].step = 100;
FocusRelPosN[0].value = 0;
LOG_DEBUG("TCF-S3 detected. Updating maximum position value to 9999.");
}
else
{
isTCFS3 = false;
FocusAbsPosN[0].max = 7000;
FocusRelPosN[0].max = 2000;
FocusRelPosN[0].step = FocusAbsPosN[0].step = 100;
FocusRelPosN[0].value = 0;
LOG_DEBUG("TCF-S detected. Updating maximum position value to 7000.");
}
// setDynamicPropertiesBehavior(false, false);
// buildSkeleton("indi_tcfs_sk.xml");
IUFillSwitch(&FocusModeS[0], "Manual", "", ISS_ON);
IUFillSwitch(&FocusModeS[1], "Auto A", "", ISS_OFF);
IUFillSwitch(&FocusModeS[2], "Auto B", "", ISS_OFF);
IUFillSwitchVector(&FocusModeSP, FocusModeS, 3, getDeviceName(), "FOCUS_MODE", "Mode", "Main Control", IP_RW,
ISR_1OFMANY, 0, IPS_IDLE);
IUFillSwitch(&FocusPowerS[0], "FOCUS_SLEEP", "Sleep", ISS_OFF);
IUFillSwitch(&FocusPowerS[1], "FOCUS_WAKEUP", "Wake up", ISS_OFF);
IUFillSwitchVector(&FocusPowerSP, FocusPowerS, 2, getDeviceName(), "FOCUS_POWER", "Power", "Operation", IP_RW,
ISR_ATMOST1, 0, IPS_IDLE);
IUFillSwitch(&FocusGotoS[0], "FOCUS_MIN", "Min", ISS_OFF);
IUFillSwitch(&FocusGotoS[1], "FOCUS_CENTER", "Center", ISS_OFF);
IUFillSwitch(&FocusGotoS[2], "FOCUS_MAX", "Max", ISS_OFF);
IUFillSwitch(&FocusGotoS[3], "FOCUS_HOME", "Home", ISS_OFF);
IUFillSwitchVector(&FocusGotoSP, FocusGotoS, 4, getDeviceName(), "FOCUS_GOTO", "Go to", "Main Control", IP_RW,
ISR_ATMOST1, 0, IPS_IDLE);
IUFillNumber(&FocusTemperatureN[0], "FOCUS_TEMPERATURE_VALUE", "Temperature (c)", "%.3f", -50.0, 80, 0, 0);
IUFillNumberVector(&FocusTemperatureNP, FocusTemperatureN, 1, getDeviceName(), "FOCUS_TEMPERATURE", "Probe", "Operation", IP_RO, 0, IPS_IDLE);
IUFillSwitch(&FocusTelemetryS[0], "FOCUS_TELEMETRY_ON", "Enable", ISS_ON);
IUFillSwitch(&FocusTelemetryS[1], "FOCUS_TELEMETRY_OFF", "Disable", ISS_OFF);
IUFillSwitchVector(&FocusTelemetrySP, FocusTelemetryS, 2, getDeviceName(), "FOCUS_TELEMETRY", "Telemetry", "Operation", IP_RW,
ISR_1OFMANY, 0, IPS_IDLE);
// Mode parameters
IUFillNumber(&FocusModeAN[0], "FOCUS_SLOPE_A", "Slope A", "%.0f", -999, 999, 10, 0);
IUFillNumber(&FocusModeAN[1], "FOCUS_DELAY_A", "Delay A", "%.2f", 0.00, 9.99, 1.0, 0);
IUFillNumberVector(&FocusModeANP, FocusModeAN, 2, getDeviceName(), "FOCUS_MODE_A", "Mode A", "Presets", IP_RW, 0, IPS_IDLE);
IUFillNumber(&FocusModeBN[0], "FOCUS_SLOPE_B", "Slope B", "%.0f", -999, 999, 10, 0);
IUFillNumber(&FocusModeBN[1], "FOCUS_DELAY_B", "Delay B", "%.2f", 0.00, 9.99, 1.0, 0);
IUFillNumberVector(&FocusModeBNP, FocusModeBN, 2, getDeviceName(), "FOCUS_MODE_B", "Mode B", "Presets", IP_RW, 0, IPS_IDLE);
// Default to 19200
serialConnection->setDefaultBaudRate(Connection::Serial::B_19200);
addAuxControls();
setDefaultPollingPeriod(500);
return true;
}
bool IEQPro::initProperties()
{
INDI::Telescope::initProperties();
/* Firmware */
IUFillText(&FirmwareT[FW_MODEL], "Model", "", 0);
IUFillText(&FirmwareT[FW_BOARD], "Board", "", 0);
IUFillText(&FirmwareT[FW_CONTROLLER], "Controller", "", 0);
IUFillText(&FirmwareT[FW_RA], "RA", "", 0);
IUFillText(&FirmwareT[FW_DEC], "DEC", "", 0);
IUFillTextVector(&FirmwareTP, FirmwareT, 5, getDeviceName(), "Firmware Info", "", MOUNTINFO_TAB, IP_RO, 0, IPS_IDLE);
/* Tracking Mode */
IUFillSwitch(&TrackModeS[TRACK_SIDEREAL], "TRACK_SIDEREAL", "Sidereal", ISS_ON);
IUFillSwitch(&TrackModeS[TRACK_SOLAR], "TRACK_SOLAR", "Solar", ISS_OFF);
IUFillSwitch(&TrackModeS[TRACK_LUNAR], "TRACK_LUNAR", "Lunar", ISS_OFF);
IUFillSwitch(&TrackModeS[TRACK_CUSTOM], "TRACK_CUSTOM", "Custom", ISS_OFF);
IUFillSwitchVector(&TrackModeSP, TrackModeS, 4, getDeviceName(), "TELESCOPE_TRACK_MODE", "Track Mode", MAIN_CONTROL_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
/* Custom Tracking Rate */
IUFillNumber(&CustomTrackRateN[0],"TRACK_RATE_CUSTOM","Rate","%g",-0.0100, 0.0100, 0.005, 0);
IUFillNumberVector(&CustomTrackRateNP, CustomTrackRateN,1,getDeviceName(),"TELESCOPE_TRACK_RATE","Track Rates",MOTION_TAB,IP_RW,60,IPS_IDLE);
/* GPS Status */
IUFillSwitch(&GPSStatusS[GPS_OFF], "Off", "", ISS_ON);
IUFillSwitch(&GPSStatusS[GPS_ON], "On", "", ISS_OFF);
IUFillSwitch(&GPSStatusS[GPS_DATA_OK], "Data OK", "", ISS_OFF);
IUFillSwitchVector(&GPSStatusSP, GPSStatusS, 3, getDeviceName(), "GPS_STATUS", "GPS", MOUNTINFO_TAB, IP_RO, ISR_1OFMANY, 0, IPS_IDLE);
/* Time Source */
IUFillSwitch(&TimeSourceS[TS_RS232], "RS232", "", ISS_ON);
IUFillSwitch(&TimeSourceS[TS_CONTROLLER], "Controller", "", ISS_OFF);
IUFillSwitch(&TimeSourceS[TS_GPS], "GPS", "", ISS_OFF);
IUFillSwitchVector(&TimeSourceSP, TimeSourceS, 3, getDeviceName(), "TIME_SOURCE", "Time Source", MOUNTINFO_TAB, IP_RO, ISR_1OFMANY, 0, IPS_IDLE);
/* Hemisphere */
IUFillSwitch(&HemisphereS[HEMI_SOUTH], "South", "", ISS_OFF);
IUFillSwitch(&HemisphereS[HEMI_NORTH], "North", "", ISS_ON);
IUFillSwitchVector(&HemisphereSP, HemisphereS, 2, getDeviceName(), "HEMISPHERE", "Hemisphere", MOUNTINFO_TAB, IP_RO, ISR_1OFMANY, 0, IPS_IDLE);
/* Home */
IUFillSwitch(&HomeS[IEQ_FIND_HOME], "FindHome", "Find Home", ISS_OFF);
IUFillSwitch(&HomeS[IEQ_SET_HOME], "SetCurrentAsHome", "Set current as Home", ISS_OFF);
IUFillSwitch(&HomeS[IEQ_GOTO_HOME], "GoToHome", "Go to Home", ISS_OFF);
IUFillSwitchVector(&HomeSP, HomeS, 3, getDeviceName(), "HOME", "Home", MAIN_CONTROL_TAB, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
/* How fast do we guide compared to sidereal rate */
IUFillNumber(&GuideRateN[0], "GUIDE_RATE", "x Sidereal", "%g", 0.1, 0.9, 0.1, 0.5);
IUFillNumberVector(&GuideRateNP, GuideRateN, 1, getDeviceName(), "GUIDE_RATE", "Guiding Rate", MOTION_TAB, IP_RW, 0, IPS_IDLE);
TrackState=SCOPE_IDLE;
initGuiderProperties(getDeviceName(), MOTION_TAB);
setDriverInterface(getDriverInterface() | GUIDER_INTERFACE);
SetParkDataType(PARK_RA_DEC);
addAuxControls();
return true;
}