void SynscanDriver::sendStatus()
{
bool BasicMountInfoHasChanged = false;
if (std::string(StatusT[MI_GOTO_STATUS].text) != m_MountInfo[MI_GOTO_STATUS])
{
IUSaveText(&StatusT[MI_GOTO_STATUS], m_MountInfo[MI_GOTO_STATUS].c_str());
BasicMountInfoHasChanged = true;
}
if (std::string(StatusT[MI_POINT_STATUS].text) != m_MountInfo[MI_POINT_STATUS])
{
IUSaveText(&StatusT[MI_POINT_STATUS], m_MountInfo[MI_POINT_STATUS].c_str());
BasicMountInfoHasChanged = true;
}
if (std::string(StatusT[MI_TRACK_MODE].text) != m_MountInfo[MI_TRACK_MODE])
{
IUSaveText(&StatusT[MI_TRACK_MODE], m_MountInfo[MI_TRACK_MODE].c_str());
BasicMountInfoHasChanged = true;
}
if (BasicMountInfoHasChanged)
{
StatusTP.s = IPS_OK;
IDSetText(&StatusTP, nullptr);
}
}
/********************************************************************************************
** INDI is asking us to update the properties because there is a change in CONNECTION status
** This fucntion is called whenever the device is connected or disconnected.
*********************************************************************************************/
bool INovaCCD::updateProperties()
{
// Call parent update properties
INDI::CCD::updateProperties();
if (isConnected())
{
// Define our properties
IUSaveText(&iNovaInformationT[0], iNovaSDK_GetName());
IUSaveText(&iNovaInformationT[1], iNovaSDK_SensorName());
IUSaveText(&iNovaInformationT[2], iNovaSDK_SerialNumber());
IUSaveText(&iNovaInformationT[3], (iNovaSDK_HasST4() ? "Yes" : "No"));
IUSaveText(&iNovaInformationT[4], (iNovaSDK_HasColorSensor() ? "Yes" : "No"));
defineText(&iNovaInformationTP);
defineNumber(&CameraPropertiesNP);
// Let's get parameters now from CCD
setupParams();
// Start the timer
SetTimer(POLLMS);
}
else
// We're disconnected
{
deleteProperty(iNovaInformationTP.name);
deleteProperty(CameraPropertiesNP.name);
}
return true;
}
bool JoyStick::updateProperties()
{
INDI::DefaultDevice::updateProperties();
char buf[8];
if (isConnected())
{
// Name
IUSaveText(&JoystickInfoT[0], driver->getName());
// Version
snprintf(buf, 8, "%d", driver->getVersion());
IUSaveText(&JoystickInfoT[1], buf);
// # of Joysticks
snprintf(buf, 8, "%d", driver->getNumOfJoysticks());
IUSaveText(&JoystickInfoT[2], buf);
// # of Axes
snprintf(buf, 8, "%d", driver->getNumOfAxes());
IUSaveText(&JoystickInfoT[3], buf);
// # of buttons
snprintf(buf, 8, "%d", driver->getNumrOfButtons());
IUSaveText(&JoystickInfoT[4], buf);
defineText(&JoystickInfoTP);
for (int i=0; i < driver->getNumOfJoysticks(); i++)
defineNumber(&JoyStickNP[i]);
defineNumber(&AxisNP);
defineSwitch(&ButtonSP);
// N.B. Only set callbacks AFTER we define our properties above
// because these calls backs otherwise can be called asynchronously
// and they mess up INDI XML output
driver->setJoystickCallback(joystickHelper);
driver->setAxisCallback(axisHelper);
driver->setButtonCallback(buttonHelper);
}
else
{
deleteProperty(JoystickInfoTP.name);
for (int i=0; i < driver->getNumOfJoysticks(); i++)
deleteProperty(JoyStickNP[i].name);
deleteProperty(AxisNP.name);
deleteProperty(ButtonSP.name);
delete [] JoyStickNP;
delete [] JoyStickN;
delete [] AxisN;
delete [] ButtonS;
}
return true;
}
bool ArmPlat::echo()
{
int rc = -1;
char cmd[SLP_SEND_BUF_SIZE]={0};
sprintf( cmd, "!seletek version#" );
if ( slpSendRxInt( cmd, &rc ) )
{
const char *operative[ OPERATIVES + 1 ] = { "", "Bootloader", "Error" };
const char *models[ MODELS + 1 ] = { "Error", "Seletek", "Armadillo", "Platypus", "Dragonfly" };
int fwmaj, fwmin, model, oper;
char txt[ 80 ];
oper = rc / 10000; // 0 normal, 1 bootloader
model = ( rc / 1000 ) % 10; // 1 seletek, etc.
fwmaj = ( rc / 100 ) % 10;
fwmin = ( rc % 100 );
if ( oper >= OPERATIVES ) oper = OPERATIVES;
if ( model >= MODELS ) model = 0;
sprintf( txt, "%s %s fwv %d.%d", operative[ oper ], models[ model ], fwmaj, fwmin );
if ( strcmp( models[ model ], CONTROLLER_NAME ) )
DEBUGF( INDI::Logger::DBG_WARNING, "Actual model (%s) and driver (" CONTROLLER_NAME ") mismatch - can lead to limited operability", models[model] );
IUSaveText( &FirmwareVersionT[0], txt );
LOGF_INFO("Setting version to [%s]", txt );
return true;
}
return false;
}
bool SynscanDriver::readFirmware()
{
// Read the handset version
char res[SYN_RES] = {0};
if (sendCommand("V", res))
{
m_FirmwareVersion = static_cast<double>(hexStrToInteger(std::string(&res[0], 2)));
m_FirmwareVersion += static_cast<double>(hexStrToInteger(std::string(&res[2], 2))) / 100;
m_FirmwareVersion += static_cast<double>(hexStrToInteger(std::string(&res[4], 2))) / 10000;
LOGF_INFO("Firmware version: %lf", m_FirmwareVersion);
m_MountInfo[MI_FW_VERSION] = std::to_string(m_FirmwareVersion);
IUSaveText(&StatusT[MI_FW_VERSION], m_MountInfo[MI_FW_VERSION].c_str());
if (m_FirmwareVersion < 3.38 || (m_FirmwareVersion >= 4.0 && m_FirmwareVersion < 4.38))
{
LOGF_WARN("Firmware version is too old. Update Synscan firmware to %s",
m_FirmwareVersion < 3.38 ? "v3.38+" : "v4.38+");
return false;
}
else
return true;
}
else
LOG_WARN("Firmware version is too old. Update Synscan firmware to v4.38+");
return false;
}
bool QikFlat::getFirmwareVersion()
{
DEBUG(INDI::Logger::DBG_SESSION, "GetFW version");
IUSaveText(&FirmwareT[0], sf->firmata_name);
IDSetText(&FirmwareTP, NULL);
return true;
}
bool ASICCD::initProperties()
{
INDI::CCD::initProperties();
IUFillNumber(&CoolerN[0], "CCD_COOLER_VALUE", "Cooling Power (%)", "%+06.2f", 0., 1., .2, 0.0);
IUFillNumberVector(&CoolerNP, CoolerN, 1, getDeviceName(), "CCD_COOLER_POWER", "Cooling Power", MAIN_CONTROL_TAB, IP_RO, 60, IPS_IDLE);
IUFillNumberVector(&ControlNP, NULL, 0, getDeviceName(), "CCD_CONTROLS", "Controls", CONTROL_TAB, IP_RW, 60, IPS_IDLE);
IUFillSwitchVector(&ControlSP, NULL, 0, getDeviceName(), "CCD_CONTROLS_MODE", "Set Auto", CONTROL_TAB, IP_RW, ISR_NOFMANY, 60, IPS_IDLE);
IUFillSwitchVector(&VideoFormatSP, NULL, 0, getDeviceName(), "CCD_VIDEO_FORMAT", "Format", CONTROL_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUSaveText(&BayerT[2], getBayerString());
int maxBin=1;
for (int i=0; i < 16; i++)
{
if (m_camInfo->SupportedBins[i] != 0)
maxBin = m_camInfo->SupportedBins[i];
else
break;
}
PrimaryCCD.setResolution(m_camInfo->MaxWidth, m_camInfo->MaxHeight);
PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", MIN_DURATION, 3600, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "HOR_BIN", 1, maxBin, 1, false);
PrimaryCCD.setMinMaxStep("CCD_BINNING", "VER_BIN", 1, maxBin, 1, false);
uint32_t cap =0;
cap |= CCD_CAN_ABORT;
if (maxBin > 1)
cap |= CCD_CAN_BIN;
cap |= CCD_CAN_SUBFRAME;
if (m_camInfo->IsCoolerCam)
cap |= CCD_HAS_COOLER;
if (m_camInfo->MechanicalShutter)
cap |= CCD_HAS_SHUTTER;
if (m_camInfo->ST4Port)
cap |= CCD_HAS_ST4_PORT;
if (m_camInfo->IsColorCam)
cap |= CCD_HAS_BAYER;
#ifndef OSX_EMBEDED_MODE
cap |= CCD_HAS_STREAMING;
#endif
SetCCDCapability(cap);
addAuxControls();
return true;
}
void INDI_E::updateTP()
{
if (tp == NULL)
return;
IUSaveText(tp, write_w->text().toLatin1().constData());
}
bool XAGYLWheel::getFirmwareInfo()
{
char resp[XAGYL_MAXBUF];
bool rc1 = getCommand(INFO_PRODUCT_NAME, resp);
if (rc1)
IUSaveText(&FirmwareInfoT[0], resp);
bool rc2 = getCommand(INFO_FIRMWARE_VERSION, resp);
if (rc2)
IUSaveText(&FirmwareInfoT[1], resp);
bool rc3 = getCommand(INFO_SERIAL_NUMBER, resp);
if (rc3)
IUSaveText(&FirmwareInfoT[2], resp);
return (rc1 && rc2 && rc3);
}
bool SynscanDriver::readModel()
{
// extended list of mounts
std::map<int, std::string> models =
{
{0, "EQ6 GOTO Series"},
{1, "HEQ5 GOTO Series"},
{2, "EQ5 GOTO Series"},
{3, "EQ3 GOTO Series"},
{4, "EQ8 GOTO Series"},
{5, "AZ-EQ6 GOTO Series"},
{6, "AZ-EQ5 GOTO Series"},
{160, "AllView GOTO Series"},
{165, "AZ-GTi GOTO Series"}
};
// Read the handset version
char res[SYN_RES] = {0};
if (!sendCommand("m", res))
return false;
m_MountModel = res[0];
// 128 - 143 --> AZ Goto series
if (m_MountModel >= 128 && m_MountModel <= 143)
IUSaveText(&StatusT[MI_MOUNT_MODEL], "AZ GOTO Series");
// 144 - 159 --> DOB Goto series
else if (m_MountModel >= 144 && m_MountModel <= 159)
IUSaveText(&StatusT[MI_MOUNT_MODEL], "Dob GOTO Series");
else if (models.count(m_MountModel) > 0)
IUSaveText(&StatusT[MI_MOUNT_MODEL], models[m_MountModel].c_str());
else
IUSaveText(&StatusT[MI_MOUNT_MODEL], "Unknown model");
m_isAltAz = m_MountModel > 4;
LOGF_INFO("Driver is running in %s mode.", m_isAltAz ? "Alt-Az" : "Equatorial");
LOGF_INFO("Detected mount: %s. Mount must be aligned from the handcontroller before using the driver.", StatusT[MI_MOUNT_MODEL].text);
return true;
}
bool FlipFlat::getFirmwareVersion()
{
if (isSimulation())
{
IUSaveText(&FirmwareT[0], "Simulation");
IDSetText(&FirmwareTP, nullptr);
return true;
}
char response[FLAT_RES]={0};
if (!sendCommand(">V000", response))
return false;
char versionString[4] = { 0 };
snprintf(versionString, 4, "%s", response + 4);
IUSaveText(&FirmwareT[0], versionString);
IDSetText(&FirmwareTP, nullptr);
return true;
}
bool GPhotoCCD::initProperties()
{
// Init parent properties first
INDI::CCD::initProperties();
initFocuserProperties(getDeviceName(), FOCUS_TAB);
IUFillText(&mPortT[0], "PORT" , "Port", "");
IUFillTextVector(&PortTP, mPortT, NARRAY(mPortT), getDeviceName(), "DEVICE_PORT" , "Shutter Release", MAIN_CONTROL_TAB, IP_RW, 0, IPS_IDLE);
IUFillNumber(&mMirrorLockN[0], "MIRROR_LOCK_SECONDS" , "Seconds", "%1.0f", 0, 10, 1, 0);
IUFillNumberVector(&mMirrorLockNP, mMirrorLockN, 1, getDeviceName(), "MIRROR_LOCK" , "Mirror Lock", MAIN_CONTROL_TAB, IP_RW, 60, IPS_IDLE);
//We don't know how many items will be in the switch yet
IUFillSwitchVector(&mIsoSP, NULL, 0, getDeviceName(), "CCD_ISO", "ISO", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUFillSwitchVector(&mFormatSP, NULL, 0, getDeviceName(), "CAPTURE_FORMAT", "Capture Format", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
IUFillSwitch(&autoFocusS[0], "Set", "", ISS_OFF);
IUFillSwitchVector(&autoFocusSP, autoFocusS, 1, getDeviceName(), "Auto Focus", "", FOCUS_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
IUFillSwitch(&transferFormatS[0], "FITS", "", ISS_ON);
IUFillSwitch(&transferFormatS[1], "Native", "", ISS_OFF);
IUFillSwitchVector(&transferFormatSP, transferFormatS, 2, getDeviceName(), "Transfer Format", "", IMAGE_SETTINGS_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
IUFillSwitch(&livePreviewS[0], "Enable", "", ISS_OFF);
IUFillSwitch(&livePreviewS[1], "Disable", "", ISS_ON);
IUFillSwitchVector(&livePreviewSP, livePreviewS, 2, getDeviceName(), "VIDEO_STREAM", "Preview", MAIN_CONTROL_TAB, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
PrimaryCCD.setMinMaxStep("CCD_EXPOSURE", "CCD_EXPOSURE_VALUE", 0.001, 3600, 1, false);
// Most cameras have this by default, so let's set it as default.
IUSaveText(&BayerT[2], "RGGB");
SetCCDCapability(CCD_CAN_SUBFRAME | CCD_HAS_BAYER);
SetFocuserCapability(FOCUSER_HAS_VARIABLE_SPEED);
FocusSpeedN[0].min=0;
FocusSpeedN[0].max=3;
FocusSpeedN[0].step=1;
FocusSpeedN[0].value=1;
/* JM 2014-05-20 Make PrimaryCCD.ImagePixelSizeNP writable since we can't know for now the pixel size and bit depth from gphoto */
PrimaryCCD.getCCDInfo()->p = IP_RW;
setDriverInterface(getDriverInterface() | FOCUSER_INTERFACE);
gphoto_set_debug(getDeviceName());
gphoto_read_set_debug(getDeviceName());
return true;
}
bool StarbookDriver::getFirmwareVersion() {
starbook::VersionResponse res;
starbook::ResponseCode rc = cmd_interface->Version(res);
if (rc != starbook::OK) {
LogResponse("Get version", rc);
return false;
}
if (res.major_minor < 2.7) {
LOGF_WARN("Get version [OK]: %s (< 2.7) not well supported", res.full_str.c_str());
} else {
LOGF_INFO("Get version [OK]: %s", res.full_str.c_str());
}
IUSaveText(&VersionT[0], res.full_str.c_str());
IDSetText(&VersionTP, nullptr);
return true;
}
// Called by Weather::TimerHit every UpdatePeriodN[0].value seconds if we return IPS_OK or every 5 seconds otherwise
IPState WeatherSafetyProxy::updateWeather()
{
IPState ret = IPS_ALERT;
if (ScriptOrCurlS[WSP_USE_SCRIPT].s == ISS_ON)
{
ret = executeScript();
}
else
{
ret = executeCurl();
}
if (ret != IPS_OK)
{
if (Safety == WSP_SAFE)
{
SofterrorCount++;
LOGF_WARN("Soft error %d occured during SAFE conditions, counting", SofterrorCount);
if (SofterrorCount > softErrorHysteresisN[WSP_SOFT_ERROR_MAX].value)
{
char Warning[] = "Max softerrors reached while Weather was SAFE";
LOG_WARN(Warning);
Safety = WSP_UNSAFE;
setParameterValue("WEATHER_SAFETY", WSP_UNSAFE);
IUSaveText(&reasonsT[0], Warning);
reasonsTP.s = IPS_OK;
IDSetText(&reasonsTP, nullptr);
SofterrorRecoveryMode = true;
ret = IPS_OK; // So that indiweather actually syncs the CriticalParameters we just set
}
}
else
{
LOG_WARN("Soft error occured during UNSAFE conditions, ignore");
SofterrorCount = 0;
SofterrorRecoveryCount = 0;
}
}
else
{
SofterrorCount = 0;
}
return ret;
}
bool SestoSenso::Ack()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[16]={0};
DEBUG(INDI::Logger::DBG_DEBUG, "CMD <#QF!>");
if (isSimulation())
{
strncpy(resp, "1.0 Simulation", 16);
nbytes_read = strlen(resp) + 1;
}
else
{
tcflush(PortFD, TCIOFLUSH);
if ((rc = tty_write(PortFD, "#QF!", 4, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr);
return false;
}
if ((rc = tty_read_section(PortFD, resp, 0xD, SESTOSENSO_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr);
return false;
}
tcflush(PortFD, TCIOFLUSH);
}
resp[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES <%s>", resp);
IUSaveText(&FirmwareT[0], resp);
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;
}
void INDI::BaseClientQt::sendNewText (const char * deviceName, const char * propertyName, const char * elementName, const char * text)
{
INDI::BaseDevice * drv = getDevice(deviceName);
if (drv == NULL)
return;
ITextVectorProperty * tvp = drv->getText(propertyName);
if (tvp == NULL)
return;
IText * tp = IUFindText(tvp, elementName);
if (tp == NULL)
return;
IUSaveText(tp, text);
sendNewText(tvp);
}
void INDI_E::setText(const QString &newText)
{
if (tp == NULL)
return;
switch(dataProp->getPermission())
{
case IP_RO:
read_w->setText(newText);
break;
case IP_WO:
case IP_RW:
text = newText;
IUSaveText(tp, newText.toLatin1().constData());
read_w->setText(newText);
write_w->setText(newText);
break;
}
}
bool FlipFlat::getFirmwareVersion()
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[FLAT_CMD];
char response[FLAT_RES];
tcflush(PortFD, TCIOFLUSH);
strncpy(command, ">V000", FLAT_CMD);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
command[FLAT_CMD-1] = 0xA;
if ( (rc = tty_write(PortFD, command, FLAT_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if ( (rc = tty_read_section(PortFD, response, 0xA, FLAT_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s: %s.", command, errstr);
return false;
}
response[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
char versionString[4];
snprintf(versionString, 4, "%s", response+4 );
IUSaveText(&FirmwareT[0], versionString);
IDSetText(&FirmwareTP, NULL);
return true;
}
bool INovaCCD::Connect()
{
const char *Sn;
if(iNovaSDK_MaxCamera() > 0)
{
Sn = iNovaSDK_OpenCamera(1);
LOGF_DEBUG("Serial Number: %s", Sn);
if(Sn[0] >= '0' && Sn[0] < '3')
{
iNovaSDK_InitST4();
LOGF_INFO("Camera model is %s", iNovaSDK_GetName());
iNovaSDK_InitCamera(RESOLUTION_FULL);
//maxW = iNovaSDK_GetImageWidth();
//maxH = iNovaSDK_GetImageHeight();
iNovaSDK_SetFrameSpeed(FRAME_SPEED_LOW);
iNovaSDK_CancelLongExpTime();
iNovaSDK_OpenVideo();
CameraPropertiesNP.s = IPS_IDLE;
// Set camera capabilities
uint32_t cap = CCD_CAN_ABORT | CCD_CAN_BIN | CCD_CAN_SUBFRAME | (iNovaSDK_HasST4() ? CCD_HAS_ST4_PORT : 0);
SetCCDCapability(cap);
if(iNovaSDK_HasColorSensor())
{
IUSaveText(&BayerT[2], "RGGB");
IDSetText(&BayerTP, nullptr);
SetCCDCapability(GetCCDCapability() | CCD_HAS_BAYER);
}
return true;
}
iNovaSDK_CloseCamera();
}
LOG_ERROR("No cameras opened.");
return false;
}
bool SynscanDriver::sendTime()
{
LOG_DEBUG("Reading mount time...");
if (isSimulation())
{
char timeString[MAXINDINAME] = {0};
time_t now = time (nullptr);
strftime(timeString, MAXINDINAME, "%T", gmtime(&now));
IUSaveText(&TimeT[0], "3");
IUSaveText(&TimeT[1], timeString);
TimeTP.s = IPS_OK;
IDSetText(&TimeTP, nullptr);
return true;
}
char res[SYN_RES] = {0};
if (sendCommand("h", res))
{
ln_zonedate localTime;
ln_date utcTime;
int offset, daylightflag;
localTime.hours = res[0];
localTime.minutes = res[1];
localTime.seconds = res[2];
localTime.months = res[3];
localTime.days = res[4];
localTime.years = res[5];
offset = static_cast<int>(res[6]);
// Negative GMT offset is read. It needs special treatment
if (offset > 200)
offset -= 256;
localTime.gmtoff = offset;
// this is the daylight savings flag in the hand controller, needed if we did not set the time
daylightflag = res[7];
localTime.years += 2000;
localTime.gmtoff *= 3600;
// now convert to utc
ln_zonedate_to_date(&localTime, &utcTime);
// now we have time from the hand controller, we need to set some variables
int sec;
char utc[100];
char ofs[10];
sec = static_cast<int>(utcTime.seconds);
sprintf(utc, "%04d-%02d-%dT%d:%02d:%02d", utcTime.years, utcTime.months, utcTime.days, utcTime.hours,
utcTime.minutes, sec);
if (daylightflag == 1)
offset = offset + 1;
sprintf(ofs, "%d", offset);
IUSaveText(&TimeT[0], utc);
IUSaveText(&TimeT[1], ofs);
TimeTP.s = IPS_OK;
IDSetText(&TimeTP, nullptr);
LOGF_INFO("Mount UTC Time %s Offset %d", utc, offset);
return true;
}
return false;
}
/************************************************************************************
*
* ***********************************************************************************/
bool FocusLynxF1::getHubConfig()
{
char cmd[32]={0};
int errcode = 0;
char errmsg[MAXRBUF];
char response[32]={0};
int nbytes_read = 0;
int nbytes_written = 0;
char key[16]={0};
char text[32]={0};
/* Answer from the HUB
<FHGETHUBINFO>!
HUB INFO
Hub FVer = 2.0.4
Sleeping = 0
Wired IP = 169.254.190.196
DHCPisOn = 1
WF Atchd = 0
WF Conn = 0
WF FVer = 0.0.0
WF FV OK = 0
WF SSID =
WF IP = 0.0.0.0
WF SecMd = A
WF SecKy =
WF WepKI = 0
END
* */
memset(response, 0, sizeof(response));
strncpy(cmd, "<FHGETHUBINFO>", 16);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd);
if (isSimulation())
{
strncpy(response, "HUB INFO\n", 16);
nbytes_read = strlen(response);
}
else
{
if ((errcode = tty_write(PortFD, cmd, strlen(cmd), &nbytes_written)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
if (isResponseOK() == false)
return false;
if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
}
if (nbytes_read > 0)
{
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
if (strcmp(response, "HUB INFO"))
return false;
}
memset(response, 0, sizeof(response));
// Hub Version
if (isSimulation())
{
strncpy(response, "Hub FVer = 2.0.4\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
int rc = sscanf(response, "%16[^=]=%16[^\n]s", key, text);
if (rc == 2)
{
HubTP.s = IPS_OK;
IUSaveText(&HubT[0], text);
IDSetText(&HubTP, nullptr);
//Save localy the Version of the firmware's Hub
strncpy(version, text, sizeof(version));
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// Sleeping status
if (isSimulation())
{
strncpy(response, "Sleeping = 0\n", 16);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
HubTP.s = IPS_OK;
IUSaveText(&HubT[1], text);
IDSetText(&HubTP, nullptr);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// Wired IP address
if (isSimulation())
{
strncpy(response, "Wired IP = 169.168.1.10\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WiredTP.s = IPS_OK;
IUSaveText(&WiredT[0], text);
IDSetText(&WiredTP, nullptr);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// DHCP on/off
if (isSimulation())
{
strncpy(response, "DHCPisOn = 1\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%16[^\n]s", key, text);
if (rc == 2)
{
WiredTP.s = IPS_OK;
IUSaveText(&WiredT[1], text);
IDSetText(&WiredTP, nullptr);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// Is WIFI module present
if (isSimulation())
{
strncpy(response, "WF Atchd = 1\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[0], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// Is WIFI connected
if (isSimulation())
{
strncpy(response, "WF Conn = 1\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[1], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI Version firmware
if (isSimulation())
{
strncpy(response, "WF FVer = 1.0.0\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[2], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI OK
if (isSimulation())
{
strncpy(response, "WF FV OK = 1\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[3], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI SSID
if (isSimulation())
{
strncpy(response, "WF SSID = FocusLynxConfig\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%32[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[4], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI IP adress
if (isSimulation())
{
strncpy(response, "WF IP = 192.168.1.11\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[5], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI Security mode
if (isSimulation())
{
strncpy(response, "WF SecMd = A\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]= %s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[6], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WF Security key
if (isSimulation())
{
strncpy(response, "WF SecKy =\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[7], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// WIFI Wep
if (isSimulation())
{
strncpy(response, "WF WepKI = 0\n", 32);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
response[nbytes_read - 1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
rc = sscanf(response, "%16[^=]=%s", key, text);
if (rc == 2)
{
WifiTP.s = IPS_OK;
IUSaveText(&WifiT[8], text);
DEBUGF(INDI::Logger::DBG_DEBUG, "Text = %s, Key = %s", text, key);
}
else if (rc != 1)
return false;
memset(response, 0, sizeof(response));
memset(text, 0, sizeof(text));
// Set the light to ILDE if no module WIFI detected
if (!strcmp(WifiT[0].text, "0"))
{
DEBUGF(INDI::Logger::DBG_SESSION, "Wifi module = %s", WifiT[0].text);
WifiTP.s = IPS_IDLE;
}
IDSetText(&WifiTP, nullptr);
// END is reached
if (isSimulation())
{
strncpy(response, "END\n", 16);
nbytes_read = strlen(response);
}
else if ( (errcode = tty_read_section(PortFD, response, 0xA, LYNXFOCUS_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
return false;
}
if (nbytes_read > 0)
{
response[nbytes_read - 1] = '\0';
// Display the response to be sure to have read the complet TTY Buffer.
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
if (strcmp(response, "END"))
return false;
}
tcflush(PortFD, TCIFLUSH);
configurationComplete = true;
int a, b, c, temp;
temp = getVersion(&a, &b, &c);
if (temp != 0)
DEBUGF(INDI::Logger::DBG_SESSION, "Version major: %d, minor: %d, subversion: %d", a, b, c);
else
DEBUG(INDI::Logger::DBG_SESSION, "Couldn't get version information");
return true;
}
bool QHYCCD::Connect()
{
sim = isSimulation();
int ret;
uint32_t cap;
if (sim)
{
cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_COOLER | CCD_HAS_ST4_PORT;
SetCCDCapability(cap);
HasUSBTraffic = true;
HasUSBSpeed = true;
HasGain = true;
HasOffset = true;
HasFilters = true;
return true;
}
camhandle = OpenQHYCCD(camid);
if(camhandle != NULL)
{
DEBUGF(INDI::Logger::DBG_SESSION, "Connected to %s.",camid);
#ifdef OSX_EMBEDED_MODE
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME;
#else
cap = CCD_CAN_ABORT | CCD_CAN_SUBFRAME | CCD_HAS_STREAMING;
#endif
ret = InitQHYCCD(camhandle);
if(ret != QHYCCD_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Error: Init Camera failed (%d)", ret);
return false;
}
ret = IsQHYCCDControlAvailable(camhandle,CAM_MECHANICALSHUTTER);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_SHUTTER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Shutter Control: %s", cap & CCD_HAS_SHUTTER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_COOLER);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_COOLER;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Cooler Control: %s", cap & CCD_HAS_COOLER ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_ST4PORT);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_HAS_ST4_PORT;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Guider Port Control: %s", cap & CCD_HAS_ST4_PORT ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_SPEED);
if(ret == QHYCCD_SUCCESS)
{
HasUSBSpeed = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Speed Control: %s", HasUSBSpeed ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_GAIN);
if(ret == QHYCCD_SUCCESS)
{
HasGain = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Gain Control: %s", HasGain ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_OFFSET);
if(ret == QHYCCD_SUCCESS)
{
HasOffset = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Offset Control: %s", HasOffset ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CONTROL_CFWPORT);
if(ret == QHYCCD_SUCCESS)
{
HasFilters = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Has Filters: %s", HasFilters ? "True" : "False");
// Using software binning
cap |= CCD_CAN_BIN;
camxbin = 1;
camybin = 1;
ret = IsQHYCCDControlAvailable(camhandle,CAM_BIN1X1MODE);
if(ret == QHYCCD_SUCCESS)
{
camxbin = 1;
camybin = 1;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Bin 1x1: %s", (ret == QHYCCD_SUCCESS) ? "True" : "False");
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN2X2MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN3X3MODE);
ret &= IsQHYCCDControlAvailable(camhandle,CAM_BIN4X4MODE);
if(ret == QHYCCD_SUCCESS)
{
cap |= CCD_CAN_BIN;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "Binning Control: %s", cap & CCD_CAN_BIN ? "True" : "False");
ret= IsQHYCCDControlAvailable(camhandle, CONTROL_USBTRAFFIC);
if (ret == QHYCCD_SUCCESS)
{
HasUSBTraffic = true;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "USB Traffic Control: %s", HasUSBTraffic ? "True" : "False");
ret = IsQHYCCDControlAvailable(camhandle,CAM_COLOR);
//if(ret != QHYCCD_ERROR && ret != QHYCCD_ERROR_NOTSUPPORT)
if(ret != QHYCCD_ERROR)
{
if(ret == BAYER_GB)
IUSaveText(&BayerT[2], "GBGR");
else if (ret == BAYER_GR)
IUSaveText(&BayerT[2], "GRGB");
else if (ret == BAYER_BG)
IUSaveText(&BayerT[2], "BGGR");
else
IUSaveText(&BayerT[2], "RGGB");
DEBUGF(INDI::Logger::DBG_DEBUG, "Color CCD: %s", BayerT[2].text);
cap |= CCD_HAS_BAYER;
}
SetCCDCapability(cap);
#ifndef OSX_EMBEDED_MODE
pthread_create( &primary_thread, NULL, &streamVideoHelper, this);
#endif
return true;
}
DEBUGF(INDI::Logger::DBG_ERROR, "Connecting to CCD failed (%s)",camid);
return false;
}
void MathPluginManagement::ProcessSwitchProperties(Telescope* pTelescope, const char *name, ISState *states, char *names[], int n)
{
DEBUGFDEVICE(pTelescope->getDeviceName(), INDI::Logger::DBG_DEBUG, "ProcessSwitchProperties - name(%s)", name);
if (strcmp(name, AlignmentSubsystemMathPluginsV.name) == 0)
{
int CurrentPlugin = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV);
IUUpdateSwitch(&AlignmentSubsystemMathPluginsV, states, names, n);
AlignmentSubsystemMathPluginsV.s = IPS_OK; // Assume OK for the time being
int NewPlugin = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV);
if (NewPlugin != CurrentPlugin)
{
// New plugin requested
// Unload old plugin if required
if (0 != CurrentPlugin)
{
typedef void Destroy_t(MathPlugin *);
Destroy_t* Destroy = (Destroy_t*)dlsym(LoadedMathPluginHandle, "Destroy");
if (NULL != Destroy)
{
Destroy(pLoadedMathPlugin);
pLoadedMathPlugin = NULL;
if (0 == dlclose(LoadedMathPluginHandle))
{
LoadedMathPluginHandle = NULL;
}
else
{
IDLog("MathPluginManagement - dlclose failed on loaded plugin - %s\n", dlerror());
AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
}
}
else
{
IDLog("MathPluginManagement - cannot get Destroy function - %s\n", dlerror());
AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
}
}
// Load the requested plugin if required
if (0 != NewPlugin)
{
std::string PluginPath(MathPluginFiles[NewPlugin - 1]);
if (NULL != (LoadedMathPluginHandle = dlopen(PluginPath.c_str(), RTLD_NOW)))
{
typedef MathPlugin* Create_t();
Create_t* Create = (Create_t*)dlsym(LoadedMathPluginHandle, "Create");
if (NULL != Create)
{
pLoadedMathPlugin = Create();
IUSaveText(&AlignmentSubsystemCurrentMathPlugin, PluginPath.c_str());
}
else
{
IDLog("MathPluginManagement - cannot get Create function - %s\n", dlerror());
AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
}
}
else
{
IDLog("MathPluginManagement - cannot load plugin %s error %s\n", PluginPath.c_str(), dlerror());
AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
}
}
else
{
// It is in built plugin just set up the pointers
pLoadedMathPlugin = &BuiltInPlugin;
}
}
// Update client
IDSetSwitch(&AlignmentSubsystemMathPluginsV, NULL);
}
else if (strcmp(name, AlignmentSubsystemMathPluginInitialiseV.name) == 0)
{
AlignmentSubsystemMathPluginInitialiseV.s = IPS_OK;
IUResetSwitch(&AlignmentSubsystemMathPluginInitialiseV);
// Update client display
IDSetSwitch(&AlignmentSubsystemMathPluginInitialiseV, NULL);
// Initialise or reinitialise the current math plugin
Initialise(CurrentInMemoryDatabase);
}
else if (strcmp(name, AlignmentSubsystemActiveV.name) == 0)
{
AlignmentSubsystemActiveV.s=IPS_OK;
if (0 == IUUpdateSwitch(&AlignmentSubsystemActiveV, states, names, n))
// Update client
IDSetSwitch(&AlignmentSubsystemActiveV, NULL);
}
}
void ioptronHC8406::sendScopeTime()
{
char cdate[32]={0};
double ctime;
int h, m, s;
int utc_h, utc_m, utc_s;
double lx200_utc_offset = 0;
char utc_offset_res[32]={0};
int day, month, year, result;
struct tm ltm;
struct tm utm;
time_t time_epoch;
if (isSimulation())
{
snprintf(cdate, 32, "%d-%02d-%02dT%02d:%02d:%02d", 1979, 6, 25, 3, 30, 30);
IDLog("Telescope ISO date and time: %s\n", cdate);
IUSaveText(&TimeT[0], cdate);
IUSaveText(&TimeT[1], "3");
IDSetText(&TimeTP, nullptr);
return;
}
//getCommandSexa(PortFD, &lx200_utc_offset, ":GG#");
//tcflush(PortFD, TCIOFLUSH);
getCommandString(PortFD, utc_offset_res, ":GG#");
f_scansexa(utc_offset_res,&lx200_utc_offset);
result = sscanf(utc_offset_res, "%d%*c%d%*c%d", &utc_h, &utc_m, &utc_s);
if (result != 3)
{
DEBUG(INDI::Logger::DBG_ERROR, "Error reading UTC offset from Telescope.");
return;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "<VAL> UTC offset: %d:%d:%d --->%g",utc_h,utc_m, utc_s, lx200_utc_offset);
// LX200 TimeT Offset is defined at the number of hours added to LOCAL TIME to get TimeT. This is contrary to the normal definition.
DEBUGF(INDI::Logger::DBG_DEBUG, "<VAL> UTC offset str: %s",utc_offset_res);
IUSaveText(&TimeT[1], utc_offset_res);
//IUSaveText(&TimeT[1], lx200_utc_offset);
getLocalTime24(PortFD, &ctime);
getSexComponents(ctime, &h, &m, &s);
getCalendarDate(PortFD, cdate);
result = sscanf(cdate, "%d%*c%d%*c%d", &year, &month, &day);
if (result != 3)
{
DEBUG(INDI::Logger::DBG_ERROR, "Error reading date from Telescope.");
return;
}
// Let's fill in the local time
ltm.tm_sec = s;
ltm.tm_min = m;
ltm.tm_hour = h;
ltm.tm_mday = day;
ltm.tm_mon = month - 1;
ltm.tm_year = year - 1900;
// Get time epoch
time_epoch = mktime(<m);
// Convert to TimeT
//time_epoch -= (int)(atof(TimeT[1].text) * 3600.0);
time_epoch -= (int)(lx200_utc_offset * 3600.0);
// Get UTC (we're using localtime_r, but since we shifted time_epoch above by UTCOffset, we should be getting the real UTC time
localtime_r(&time_epoch, &utm);
/* Format it into ISO 8601 */
strftime(cdate, 32, "%Y-%m-%dT%H:%M:%S", &utm);
IUSaveText(&TimeT[0], cdate);
DEBUGF(INDI::Logger::DBG_DEBUG, "Mount controller Local Time: %02d:%02d:%02d", h, m, s);
DEBUGF(INDI::Logger::DBG_DEBUG, "Mount controller UTC Time: %s", TimeT[0].text);
// Let's send everything to the client
IDSetText(&TimeTP, nullptr);
}
void TCP::setDefaultPort(uint32_t addressPort)
{
char portStr[8];
snprintf(portStr, 8, "%d", addressPort);
IUSaveText(&AddressT[1], portStr);
}
void TCP::setDefaultHost(const char *addressHost)
{
IUSaveText(&AddressT[0], addressHost);
}
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;
}
void StarbookDriver::setStarbookState(const starbook::StarbookState &state) {
IUSaveText(&StateT[0], starbook::STATE_TO_STR.at(state).c_str());
StateTP.s = IPS_OK;
IDSetText(&StateTP, nullptr);
}
bool FlipFlat::getStatus()
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[FLAT_CMD];
char response[FLAT_RES];
tcflush(PortFD, TCIOFLUSH);
strncpy(command, ">S000", FLAT_CMD);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
command[FLAT_CMD-1] = 0xA;
if ( (rc = tty_write(PortFD, command, FLAT_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if ( (rc = tty_read_section(PortFD, response, 0xA, FLAT_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s: %s.", command, errstr);
return false;
}
response[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
char motorStatus = *(response+4) - '0';
char lightStatus = *(response+5) - '0';
char coverStatus = *(response+6) - '0';
bool statusUpdated = false;
if (coverStatus != prevCoverStatus)
{
prevCoverStatus = coverStatus;
statusUpdated = true;
switch (coverStatus)
{
case 0:
IUSaveText(&StatusT[0], "Not Open/Closed");
break;
case 1:
IUSaveText(&StatusT[0], "Closed");
if (ParkCapSP.s == IPS_BUSY || ParkCapSP.s == IPS_IDLE)
{
IUResetSwitch(&ParkCapSP);
ParkCapS[0].s = ISS_ON;
ParkCapSP.s = IPS_OK;
DEBUG(INDI::Logger::DBG_SESSION, "Cover closed.");
IDSetSwitch(&ParkCapSP, NULL);
}
break;
case 2:
IUSaveText(&StatusT[0], "Open");
if (ParkCapSP.s == IPS_BUSY || ParkCapSP.s == IPS_IDLE)
{
IUResetSwitch(&ParkCapSP);
ParkCapS[1].s = ISS_ON;
ParkCapSP.s = IPS_OK;
DEBUG(INDI::Logger::DBG_SESSION, "Cover open.");
IDSetSwitch(&ParkCapSP, NULL);
}
break;
case 3:
IUSaveText(&StatusT[0], "Timed out");
break;
}
}
if (lightStatus != prevLightStatus)
{
prevLightStatus = lightStatus;
statusUpdated = true;
switch (lightStatus)
{
case 0:
IUSaveText(&StatusT[1], "Off");
if (LightS[0].s == ISS_ON)
{
LightS[0].s = ISS_OFF;
LightS[1].s = ISS_ON;
IDSetSwitch(&LightSP, NULL);
}
break;
case 1:
IUSaveText(&StatusT[1], "On");
if (LightS[1].s == ISS_ON)
{
LightS[0].s = ISS_ON;
LightS[1].s = ISS_OFF;
IDSetSwitch(&LightSP, NULL);
}
break;
}
}
if (motorStatus != prevMotorStatus)
{
prevMotorStatus = motorStatus;
statusUpdated = true;
switch (motorStatus)
{
case 0:
IUSaveText(&StatusT[2], "Stopped");
break;
case 1:
IUSaveText(&StatusT[2], "Running");
break;
}
}
if (statusUpdated)
IDSetText(&StatusTP, NULL);
return true;
}
