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; }