bool ScopeSim::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { // Slew mode if (strcmp(name, SlewRateSP.name) == 0) { if (IUUpdateSwitch(&SlewRateSP, states, names, n) < 0) return false; SlewRateSP.s = IPS_OK; IDSetSwitch(&SlewRateSP, nullptr); return true; } if (strcmp(name, "PE_NS") == 0) { IUUpdateSwitch(&PEErrNSSP, states, names, n); PEErrNSSP.s = IPS_OK; if (PEErrNSS[DIRECTION_NORTH].s == ISS_ON) { EqPEN[DEC_AXIS].value += TRACKRATE_SIDEREAL/3600.0 * GuideRateN[DEC_AXIS].value; DEBUGF(INDI::Logger::DBG_DEBUG, "Simulating PE in NORTH direction for value of %g", TRACKRATE_SIDEREAL/3600.0); } else { EqPEN[DEC_AXIS].value -= TRACKRATE_SIDEREAL/3600.0 * GuideRateN[DEC_AXIS].value; DEBUGF(INDI::Logger::DBG_DEBUG, "Simulating PE in SOUTH direction for value of %g", TRACKRATE_SIDEREAL/3600.0); } IUResetSwitch(&PEErrNSSP); IDSetSwitch(&PEErrNSSP, nullptr); IDSetNumber(&EqPENV, nullptr); return true; } if (strcmp(name, "PE_WE") == 0) { IUUpdateSwitch(&PEErrWESP, states, names, n); PEErrWESP.s = IPS_OK; if (PEErrWES[DIRECTION_WEST].s == ISS_ON) { EqPEN[RA_AXIS].value -= TRACKRATE_SIDEREAL/3600.0 / 15. * GuideRateN[RA_AXIS].value; DEBUGF(INDI::Logger::DBG_DEBUG, "Simulator PE in WEST direction for value of %g", TRACKRATE_SIDEREAL/3600.0); } else { EqPEN[RA_AXIS].value += TRACKRATE_SIDEREAL/3600.0 / 15. * GuideRateN[RA_AXIS].value; DEBUGF(INDI::Logger::DBG_DEBUG, "Simulator PE in EAST direction for value of %g", TRACKRATE_SIDEREAL/3600.0); } IUResetSwitch(&PEErrWESP); IDSetSwitch(&PEErrWESP, nullptr); IDSetNumber(&EqPENV, nullptr); return true; } } // Nobody has claimed this, so, ignore it return INDI::Telescope::ISNewSwitch(dev, name, states, names, n); }
bool QSICCD::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { if(strcmp(dev,getDeviceName())==0) { /* Readout Speed */ if (!strcmp(name, ReadOutSP.name)) { if (IUUpdateSwitch(&ReadOutSP, states, names, n) < 0) return false; if (ReadOutS[0].s == ISS_ON) { try { QSICam.put_ReadoutSpeed(QSICamera::HighImageQuality); } catch (std::runtime_error err) { IUResetSwitch(&ReadOutSP); ReadOutSP.s = IPS_ALERT; DEBUGF(INDI::Logger::DBG_ERROR, "put_ReadoutSpeed() failed. %s.", err.what()); IDSetSwitch(&ReadOutSP, NULL); return false; } } else { try { QSICam.put_ReadoutSpeed(QSICamera::FastReadout); } catch (std::runtime_error err) { IUResetSwitch(&ReadOutSP); ReadOutSP.s = IPS_ALERT; DEBUGF(INDI::Logger::DBG_ERROR, "put_ReadoutSpeed() failed. %s.", err.what()); IDSetSwitch(&ReadOutSP, NULL); return false; } ReadOutSP.s = IPS_OK; IDSetSwitch(&ReadOutSP, NULL); } ReadOutSP.s = IPS_OK; IDSetSwitch(&ReadOutSP, NULL); return true; } /* Cooler */ if (!strcmp (name, CoolerSP.name)) { if (IUUpdateSwitch(&CoolerSP, states, names, n) < 0) return false; if (CoolerS[0].s == ISS_ON) activateCooler(true); else activateCooler(false); return true; } /* Shutter */ if (!strcmp (name, ShutterSP.name)) { if (IUUpdateSwitch(&ShutterSP, states, names, n) < 0) return false; shutterControl(); return true; } if (!strcmp(name, GainSP.name)) { int prevGain = IUFindOnSwitchIndex(&GainSP); IUUpdateSwitch(&GainSP, states, names, n); int targetGain = IUFindOnSwitchIndex(&GainSP); if (prevGain == targetGain) { GainSP.s = IPS_OK; IDSetSwitch(&GainSP, NULL); return true; } try { QSICam.put_CameraGain( ((QSICamera::CameraGain) targetGain)); } catch (std::runtime_error err) { IUResetSwitch(&GainSP); GainS[prevGain].s = ISS_ON; GainSP.s = IPS_ALERT; DEBUGF(INDI::Logger::DBG_ERROR, "put_CameraGain failed. %s.", err.what()); IDSetSwitch(&GainSP, NULL); return false; } GainSP.s = IPS_OK; IDSetSwitch(&GainSP, NULL); return true; } if (!strcmp(name, FanSP.name)) { int prevFan = IUFindOnSwitchIndex(&FanSP); IUUpdateSwitch(&FanSP, states, names, n); int targetFan = IUFindOnSwitchIndex(&FanSP); if (prevFan == targetFan) { FanSP.s = IPS_OK; IDSetSwitch(&FanSP, NULL); return true; } try { QSICam.put_FanMode( ((QSICamera::FanMode) targetFan)); } catch (std::runtime_error err) { IUResetSwitch(&FanSP); FanS[prevFan].s = ISS_ON; FanSP.s = IPS_ALERT; DEBUGF(INDI::Logger::DBG_ERROR, "put_FanMode failed. %s.", err.what()); IDSetSwitch(&FanSP, NULL); return false; } FanSP.s = IPS_OK; IDSetSwitch(&FanSP, NULL); return true; } if (!strcmp(name, ABSP.name)) { int prevAB = IUFindOnSwitchIndex(&ABSP); IUUpdateSwitch(&ABSP, states, names, n); int targetAB = IUFindOnSwitchIndex(&ABSP); if (prevAB == targetAB) { ABSP.s = IPS_OK; IDSetSwitch(&ABSP, NULL); return true; } try { QSICam.put_AntiBlooming( ((QSICamera::AntiBloom) targetAB)); } catch (std::runtime_error err) { IUResetSwitch(&ABSP); ABS[prevAB].s = ISS_ON; ABSP.s = IPS_ALERT; DEBUGF(INDI::Logger::DBG_ERROR, "put_AntiBlooming failed. %s.", err.what()); IDSetSwitch(&ABSP, NULL); return false; } ABSP.s = IPS_OK; IDSetSwitch(&ABSP, NULL); return true; } /* Filter Wheel */ if (!strcmp (name, FilterSP.name)) { if (IUUpdateSwitch(&FilterSP, states, names, n) < 0) return false; turnWheel(); return true; } } // Nobody has claimed this, so, ignore it return INDI::CCD::ISNewSwitch(dev,name,states,names,n); }
bool LX200_16::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { int index; if(strcmp(dev,getDeviceName())==0) { if (!strcmp(name, FanStatusSP.name)) { IUResetSwitch(&FanStatusSP); IUUpdateSwitch(&FanStatusSP, states, names, n); index = IUFindOnSwitchIndex(&FanStatusSP); if (index == 0) { if (turnFanOn(PortFD) < 0) { FanStatusSP.s = IPS_ALERT; IDSetSwitch(&FanStatusSP, "Error changing fan status."); return false; } } else { if (turnFanOff(PortFD) < 0) { FanStatusSP.s = IPS_ALERT; IDSetSwitch(&FanStatusSP, "Error changing fan status."); return false; } } FanStatusSP.s = IPS_OK; IDSetSwitch (&FanStatusSP, index == 0 ? "Fan is ON" : "Fan is OFF"); return true; } if (!strcmp(name, HomeSearchSP.name)) { IUResetSwitch(&HomeSearchSP); IUUpdateSwitch(&HomeSearchSP, states, names, n); index = IUFindOnSwitchIndex(&HomeSearchSP); if (index == 0) seekHomeAndSave(PortFD); else seekHomeAndSet(PortFD); HomeSearchSP.s = IPS_BUSY; IDSetSwitch (&HomeSearchSP, index == 0 ? "Seek Home and Save" : "Seek Home and Set"); return true; } if (!strcmp(name, FieldDeRotatorSP.name)) { IUResetSwitch(&FieldDeRotatorSP); IUUpdateSwitch(&FieldDeRotatorSP, states, names, n); index = IUFindOnSwitchIndex(&FieldDeRotatorSP); if (index == 0) turnFieldDeRotatorOn(PortFD); else turnFieldDeRotatorOff(PortFD); FieldDeRotatorSP.s = IPS_OK; IDSetSwitch (&FieldDeRotatorSP, index == 0 ? "Field deRotator is ON" : "Field deRotator is OFF"); return true; } } return LX200GPS::ISNewSwitch (dev, name, states, names, n); }
bool ioptronHC8406::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { // Sync type if (!strcmp(name, SyncCMRSP.name)) { IUResetSwitch(&SyncCMRSP); IUUpdateSwitch(&SyncCMRSP, states, names, n); IUFindOnSwitchIndex(&SyncCMRSP); SyncCMRSP.s = IPS_OK; IDSetSwitch(&SyncCMRSP, nullptr); return true; } // Cursor move type if (!strcmp(name, CursorMoveSpeedSP.name)) { int currentSwitch = IUFindOnSwitchIndex(&CursorMoveSpeedSP); IUUpdateSwitch(&CursorMoveSpeedSP, states, names, n); if (setioptronHC8406CursorMoveSpeed(IUFindOnSwitchIndex(&CursorMoveSpeedSP)) == TTY_OK) CursorMoveSpeedSP.s = IPS_OK; else { IUResetSwitch(&CursorMoveSpeedSP); CursorMoveSpeedS[currentSwitch].s = ISS_ON; CursorMoveSpeedSP.s = IPS_ALERT; } return true; } // Guide Rate if (!strcmp(GuideRateSP.name, name)) { int currentSwitch = IUFindOnSwitchIndex(&GuideRateSP); IUUpdateSwitch(&GuideRateSP, states, names, n); if (setioptronHC8406GuideRate(IUFindOnSwitchIndex(&GuideRateSP)) == TTY_OK) { GuideRateSP.s = IPS_OK; //Shows guide speed selected CursorMoveSpeedS[USE_GUIDE_SPEED].s = ISS_ON; CursorMoveSpeedS[USE_CENTERING_SPEED].s = ISS_OFF; CursorMoveSpeedSP.s = IPS_OK; IDSetSwitch(&CursorMoveSpeedSP, nullptr); } else { IUResetSwitch(&GuideRateSP); GuideRateS[currentSwitch].s = ISS_ON; GuideRateSP.s = IPS_ALERT; } IDSetSwitch(&GuideRateSP, nullptr); return true; } // Center Rate if (!strcmp(CenterRateSP.name, name)) { int currentSwitch = IUFindOnSwitchIndex(&CenterRateSP); IUUpdateSwitch(&CenterRateSP, states, names, n); if (setioptronHC8406CenterRate(IUFindOnSwitchIndex(&CenterRateSP)) == TTY_OK) { CenterRateSP.s = IPS_OK; //Shows centering speed selected CursorMoveSpeedS[USE_GUIDE_SPEED].s = ISS_OFF; CursorMoveSpeedS[USE_CENTERING_SPEED].s = ISS_ON; CursorMoveSpeedSP.s = IPS_OK; IDSetSwitch(&CursorMoveSpeedSP, nullptr); } else { IUResetSwitch(&CenterRateSP); CenterRateS[currentSwitch].s = ISS_ON; CenterRateSP.s = IPS_ALERT; } IDSetSwitch(&CenterRateSP, nullptr); return true; } // Slew Rate if (!strcmp(SlewRateSP.name, name)) { int currentSwitch = IUFindOnSwitchIndex(&SlewRateSP); IUUpdateSwitch(&SlewRateSP, states, names, n); if (setioptronHC8406SlewRate(IUFindOnSwitchIndex(&SlewRateSP)) == TTY_OK) SlewRateSP.s = IPS_OK; else { IUResetSwitch(&SlewRateSP); SlewRateS[currentSwitch].s = ISS_ON; SlewRateSP.s = IPS_ALERT; } IDSetSwitch(&SlewRateSP, nullptr); return true; } } return LX200Generic::ISNewSwitch(dev, name, states, names, n); }
bool IEQPro::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { if (!strcmp (getDeviceName(), dev)) { if (!strcmp(name, HomeSP.name)) { IUUpdateSwitch(&HomeSP, states, names, n); IEQ_HOME_OPERATION operation = (IEQ_HOME_OPERATION) IUFindOnSwitchIndex(&HomeSP); IUResetSwitch(&HomeSP); switch (operation) { case IEQ_FIND_HOME: if (firmwareInfo.Model.find("CEM") == std::string::npos) { HomeSP.s = IPS_IDLE; IDSetSwitch(&HomeSP, NULL); DEBUG(INDI::Logger::DBG_WARNING, "Home search is not supported in this model."); return true; } if (find_ieqpro_home(PortFD) == false) { HomeSP.s = IPS_ALERT; IDSetSwitch(&HomeSP, NULL); return false; } HomeSP.s = IPS_OK; IDSetSwitch(&HomeSP, NULL); DEBUG(INDI::Logger::DBG_SESSION, "Searching for home position..."); return true; break; case IEQ_SET_HOME: if (set_ieqpro_current_home(PortFD) == false) { HomeSP.s = IPS_ALERT; IDSetSwitch(&HomeSP, NULL); return false; } HomeSP.s = IPS_OK; IDSetSwitch(&HomeSP, NULL); DEBUG(INDI::Logger::DBG_SESSION, "Home position set to current coordinates."); return true; break; case IEQ_GOTO_HOME: if (goto_ieqpro_home(PortFD) == false) { HomeSP.s = IPS_ALERT; IDSetSwitch(&HomeSP, NULL); return false; } HomeSP.s = IPS_OK; IDSetSwitch(&HomeSP, NULL); DEBUG(INDI::Logger::DBG_SESSION, "Slewing to home position..."); return true; break; } return true; } if (!strcmp(name, TrackModeSP.name)) { IUUpdateSwitch(&TrackModeSP, states, names, n); TelescopeTrackMode mode = (TelescopeTrackMode) IUFindOnSwitchIndex(&TrackModeSP); IEQ_TRACK_RATE rate; switch (mode) { case TRACK_SIDEREAL: rate = TR_SIDEREAL; break; case TRACK_SOLAR: rate = TR_SOLAR; break; case TRACK_LUNAR: rate = TR_LUNAR; break; case TRACK_CUSTOM: rate = TR_CUSTOM; break; } if (set_ieqpro_track_mode(PortFD, rate)) { if (TrackState == SCOPE_TRACKING) TrackModeSP.s = IPS_BUSY; else TrackModeSP.s = IPS_OK; } else TrackModeSP.s = IPS_ALERT; } } return INDI::Telescope::ISNewSwitch (dev, name, states, names, n); }
bool FocuserInterface::processSwitch(const char * dev, const char * name, ISState * states, char * names[], int n) { INDI_UNUSED(dev); // This one is for focus motion if (!strcmp(name, FocusMotionSP.name)) { // Record last direction and state. FocusDirection prevDirection = FocusMotionS[FOCUS_INWARD].s == ISS_ON ? FOCUS_INWARD : FOCUS_OUTWARD; IPState prevState = FocusMotionSP.s; IUUpdateSwitch(&FocusMotionSP, states, names, n); FocusDirection targetDirection = FocusMotionS[FOCUS_INWARD].s == ISS_ON ? FOCUS_INWARD : FOCUS_OUTWARD; if (CanRelMove() || CanAbsMove() || HasVariableSpeed()) { FocusMotionSP.s = IPS_OK; } // If we are dealing with a simple dumb DC focuser, we move in a specific direction in an open-loop fashion until stopped. else { // If we are reversing direction let's issue abort first. if (prevDirection != targetDirection && prevState == IPS_BUSY) AbortFocuser(); FocusMotionSP.s = MoveFocuser(targetDirection, 0, 0); } IDSetSwitch(&FocusMotionSP, nullptr); return true; } // Abort Focuser if (!strcmp(name, FocusAbortSP.name)) { IUResetSwitch(&FocusAbortSP); if (AbortFocuser()) { FocusAbortSP.s = IPS_OK; if (CanAbsMove() && FocusAbsPosNP.s != IPS_IDLE) { FocusAbsPosNP.s = IPS_IDLE; IDSetNumber(&FocusAbsPosNP, nullptr); } if (CanRelMove() && FocusRelPosNP.s != IPS_IDLE) { FocusRelPosNP.s = IPS_IDLE; IDSetNumber(&FocusRelPosNP, nullptr); } } else FocusAbortSP.s = IPS_ALERT; IDSetSwitch(&FocusAbortSP, nullptr); return true; } // Reverse Motion if (!strcmp(name, FocusReverseSP.name)) { bool enabled = !strcmp("ENABLED", IUFindOnSwitchName(states, names, n)); if (ReverseFocuser(enabled)) { IUUpdateSwitch(&FocusReverseSP, states, names, n); FocusReverseSP.s = IPS_OK; } else { FocusReverseSP.s = IPS_ALERT; } IDSetSwitch(&FocusReverseSP, nullptr); return true; } return false; }
bool LX200GPS::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { int index = 0; char msg[64]; if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { /* GPS Power */ if (!strcmp(name, GPSPowerSP.name)) { int ret = 0; if (IUUpdateSwitch(&GPSPowerSP, states, names, n) < 0) return false; index = IUFindOnSwitchIndex(&GPSPowerSP); if (index == 0) ret = turnGPSOn(PortFD); else ret = turnGPSOff(PortFD); GPSPowerSP.s = IPS_OK; IDSetSwitch(&GPSPowerSP, index == 0 ? "GPS System is ON" : "GPS System is OFF"); return true; } /* GPS Status Update */ if (!strcmp(name, GPSStatusSP.name)) { int ret = 0; if (IUUpdateSwitch(&GPSStatusSP, states, names, n) < 0) return false; index = IUFindOnSwitchIndex(&GPSStatusSP); if (index == 0) { ret = gpsSleep(PortFD); strncpy(msg, "GPS system is in sleep mode.", 64); } else if (index == 1) { ret = gpsWakeUp(PortFD); strncpy(msg, "GPS system is reactivated.", 64); } else { ret = gpsRestart(PortFD); strncpy(msg, "GPS system is restarting...", 64); sendScopeTime(); sendScopeLocation(); } GPSStatusSP.s = IPS_OK; IDSetSwitch(&GPSStatusSP, "%s", msg); return true; } /* GPS Update */ if (!strcmp(name, GPSUpdateSP.name)) { if (IUUpdateSwitch(&GPSUpdateSP, states, names, n) < 0) return false; index = IUFindOnSwitchIndex(&GPSUpdateSP); GPSUpdateSP.s = IPS_OK; if (index == 0) { IDSetSwitch(&GPSUpdateSP, "Updating GPS system. This operation might take few minutes to complete..."); if (updateGPS_System(PortFD)) { IDSetSwitch(&GPSUpdateSP, "GPS system update successful."); sendScopeTime(); sendScopeLocation(); } else { GPSUpdateSP.s = IPS_IDLE; IDSetSwitch(&GPSUpdateSP, "GPS system update failed."); } } else { sendScopeTime(); sendScopeLocation(); IDSetSwitch(&GPSUpdateSP, "Client time and location is synced to LX200 GPS Data."); } return true; } /* Alt Dec Periodic Error correction */ if (!strcmp(name, AltDecPecSP.name)) { int ret = 0; if (IUUpdateSwitch(&AltDecPecSP, states, names, n) < 0) return false; index = IUFindOnSwitchIndex(&AltDecPecSP); if (index == 0) { ret = enableDecAltPec(PortFD); strncpy(msg, "Alt/Dec Compensation Enabled.", 64); } else { ret = disableDecAltPec(PortFD); strncpy(msg, "Alt/Dec Compensation Disabled.", 64); } AltDecPecSP.s = IPS_OK; IDSetSwitch(&AltDecPecSP, "%s", msg); return true; } /* Az RA periodic error correction */ if (!strcmp(name, AzRaPecSP.name)) { int ret = 0; if (IUUpdateSwitch(&AzRaPecSP, states, names, n) < 0) return false; index = IUFindOnSwitchIndex(&AzRaPecSP); if (index == 0) { ret = enableRaAzPec(PortFD); strncpy(msg, "Ra/Az Compensation Enabled.", 64); } else { ret = disableRaAzPec(PortFD); strncpy(msg, "Ra/Az Compensation Disabled.", 64); } AzRaPecSP.s = IPS_OK; IDSetSwitch(&AzRaPecSP, "%s", msg); return true; } if (!strcmp(name, AltDecBacklashSP.name)) { int ret = 0; ret = activateAltDecAntiBackSlash(PortFD); AltDecBacklashSP.s = IPS_OK; IDSetSwitch(&AltDecBacklashSP, "Alt/Dec Anti-backlash enabled"); return true; } if (!strcmp(name, AzRaBacklashSP.name)) { int ret = 0; ret = activateAzRaAntiBackSlash(PortFD); AzRaBacklashSP.s = IPS_OK; IDSetSwitch(&AzRaBacklashSP, "Az/Ra Anti-backlash enabled"); return true; } if (!strcmp(name, OTAUpdateSP.name)) { IUResetSwitch(&OTAUpdateSP); if (getOTATemp(PortFD, &OTATempNP.np[0].value) < 0) { OTAUpdateSP.s = IPS_ALERT; OTATempNP.s = IPS_ALERT; IDSetNumber(&OTATempNP, "Error: OTA temperature read timed out."); return false; } else { OTAUpdateSP.s = IPS_OK; OTATempNP.s = IPS_OK; IDSetNumber(&OTATempNP, nullptr); IDSetSwitch(&OTAUpdateSP, nullptr); return true; } } } return LX200Autostar::ISNewSwitch(dev, name, states, names, n); }
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); } }
bool TCFS::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { //LOGF_DEBUG("%s %s",__FUNCTION__, me); if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { char response[TCFS_MAX_CMD] = { 0 }; if (!strcmp(FocusPowerSP.name, name)) { IUUpdateSwitch(&FocusPowerSP, states, names, n); bool sleep = false; ISwitch *sp = IUFindOnSwitch(&FocusPowerSP); // Sleep if (!strcmp(sp->name, "FOCUS_SLEEP")) { dispatch_command(FSLEEP); sleep = true; } // Wake Up else dispatch_command(FWAKUP); if (read_tcfs(response) == false) { IUResetSwitch(&FocusPowerSP); FocusPowerSP.s = IPS_ALERT; IDSetSwitch(&FocusPowerSP, "Error reading TCF-S reply."); return true; } if (sleep) { if (isSimulation()) strncpy(response, "ZZZ", TCFS_MAX_CMD); if (strcmp(response, "ZZZ") == 0) { FocusPowerSP.s = IPS_OK; IDSetSwitch(&FocusPowerSP, "Focuser is set into sleep mode."); FocusAbsPosNP.s = IPS_IDLE; IDSetNumber(&FocusAbsPosNP, nullptr); // if (FocusTemperatureNP) { FocusTemperatureNP.s = IPS_IDLE; IDSetNumber(&FocusTemperatureNP, nullptr); } return true; } else { FocusPowerSP.s = IPS_ALERT; IDSetSwitch(&FocusPowerSP, "Focuser sleep mode operation failed. Response: %s.", response); return true; } } else { if (isSimulation()) strncpy(response, "WAKE", TCFS_MAX_CMD); if (strcmp(response, "WAKE") == 0) { FocusPowerSP.s = IPS_OK; IDSetSwitch(&FocusPowerSP, "Focuser is awake."); FocusAbsPosNP.s = IPS_OK; IDSetNumber(&FocusAbsPosNP, nullptr); // if (FocusTemperatureNP) { FocusTemperatureNP.s = IPS_OK; IDSetNumber(&FocusTemperatureNP, nullptr); } return true; } else { FocusPowerSP.s = IPS_ALERT; IDSetSwitch(&FocusPowerSP, "Focuser wake up operation failed. Response: %s", response); return true; } } } // Do not process any command if focuser is asleep if (isConnected() && FocusPowerSP.sp[0].s == ISS_ON) { ISwitchVectorProperty *svp = getSwitch(name); if (svp) { svp->s = IPS_IDLE; LOG_WARN("Focuser is still in sleep mode. Wake up in order to issue commands."); IDSetSwitch(svp, nullptr); } return true; } if (!strcmp(FocusModeSP.name, name)) { IUUpdateSwitch(&FocusModeSP, states, names, n); FocusModeSP.s = IPS_OK; ISwitch *sp = IUFindOnSwitch(&FocusModeSP); if (!strcmp(sp->name, "Manual")) { if (!isSimulation() && !SetManualMode()) { IUResetSwitch(&FocusModeSP); FocusModeSP.s = IPS_ALERT; IDSetSwitch(&FocusModeSP, "Error switching to manual mode. No reply from TCF-S. Try again."); return true; } } else if (!strcmp(sp->name, "Auto A")) { dispatch_command(FAMODE); read_tcfs(response); if (!isSimulation() && strcmp(response, "A") != 0) { IUResetSwitch(&FocusModeSP); FocusModeSP.s = IPS_ALERT; IDSetSwitch(&FocusModeSP, "Error switching to Auto Mode A. No reply from TCF-S. Try again."); return true; } LOG_INFO("Entered Auto Mode A"); currentMode = MODE_A; } else { dispatch_command(FBMODE); read_tcfs(response); if (!isSimulation() && strcmp(response, "B") != 0) { IUResetSwitch(&FocusModeSP); FocusModeSP.s = IPS_ALERT; IDSetSwitch(&FocusModeSP, "Error switching to Auto Mode B. No reply from TCF-S. Try again."); return true; } LOG_INFO("Entered Auto Mode B"); currentMode = MODE_B; } IDSetSwitch(&FocusModeSP, nullptr); return true; } if (!strcmp(FocusGotoSP.name, name)) { if (FocusModeSP.sp[0].s != ISS_ON) { FocusGotoSP.s = IPS_IDLE; IDSetSwitch(&FocusGotoSP, nullptr); LOG_WARN("The focuser can only be moved in Manual mode."); return false; } IUUpdateSwitch(&FocusGotoSP, states, names, n); FocusGotoSP.s = IPS_BUSY; ISwitch *sp = IUFindOnSwitch(&FocusGotoSP); // Min if (!strcmp(sp->name, "FOCUS_MIN")) { targetTicks = currentPosition; MoveRelFocuser(FOCUS_INWARD, currentPosition); IDSetSwitch(&FocusGotoSP, "Moving focuser to minimum position..."); } // Center else if (!strcmp(sp->name, "FOCUS_CENTER")) { dispatch_command(FCENTR); FocusAbsPosNP.s = FocusRelPosNP.s = IPS_BUSY; IDSetNumber(&FocusAbsPosNP, nullptr); IDSetNumber(&FocusRelPosNP, nullptr); IDSetSwitch(&FocusGotoSP, "Moving focuser to center position %d...", isTCFS3 ? 5000 : 3500); return true; } // Max else if (!strcmp(sp->name, "FOCUS_MAX")) { unsigned int delta = 0; delta = FocusAbsPosN[0].max - currentPosition; MoveRelFocuser(FOCUS_OUTWARD, delta); IDSetSwitch(&FocusGotoSP, "Moving focuser to maximum position %g...", FocusAbsPosN[0].max); } // Home else if (!strcmp(sp->name, "FOCUS_HOME")) { dispatch_command(FHOME); read_tcfs(response); if (isSimulation()) strncpy(response, "DONE", TCFS_MAX_CMD); if (strcmp(response, "DONE") == 0) { IUResetSwitch(&FocusGotoSP); FocusGotoSP.s = IPS_OK; IDSetSwitch(&FocusGotoSP, "Moving focuser to new calculated position based on temperature..."); return true; } else { IUResetSwitch(&FocusGotoSP); FocusGotoSP.s = IPS_ALERT; IDSetSwitch(&FocusGotoSP, "Failed to move focuser to home position!"); return true; } } IDSetSwitch(&FocusGotoSP, nullptr); return true; } // handle quiet mode on/off if (!strcmp(FocusTelemetrySP.name, name)) { IUUpdateSwitch(&FocusTelemetrySP, states, names, n); bool quiet = false; ISwitch *sp = IUFindOnSwitch(&FocusTelemetrySP); // Telemetry off if (!strcmp(sp->name, "FOCUS_TELEMETRY_OFF")) { dispatch_command(FQUIET, 1); quiet = true; } // Telemetry On else dispatch_command(FQUIET, 0); if (read_tcfs(response) == false) { IUResetSwitch(&FocusTelemetrySP); FocusTelemetrySP.s = IPS_ALERT; IDSetSwitch(&FocusTelemetrySP, "Error reading TCF-S reply."); return true; } if (isSimulation()) strncpy(response, "DONE", TCFS_MAX_CMD); if (strcmp(response, "DONE") == 0) { FocusTelemetrySP.s = IPS_OK; IDSetSwitch(&FocusTelemetrySP, quiet ? "Focuser Telemetry is off." : "Focuser Telemetry is on."); // if (FocusTemperatureNP) { FocusTemperatureNP.s = quiet?IPS_IDLE:IPS_OK; IDSetNumber(&FocusTemperatureNP, nullptr); } return true; } else { FocusTelemetrySP.s = IPS_ALERT; IDSetSwitch(&FocusTelemetrySP, "Focuser telemetry mode failed. Response: %s.", response); return true; } } } return INDI::Focuser::ISNewSwitch(dev, name, states, names, n); }
bool INDI::CCD::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { if(strcmp(dev,getDeviceName())==0) { if(strcmp(name,PrimaryCCD.AbortExposureSP->name)==0) { IUResetSwitch(PrimaryCCD.AbortExposureSP); if (AbortExposure()) { PrimaryCCD.AbortExposureSP->s = IPS_OK; PrimaryCCD.ImageExposureNP->s = IPS_IDLE; PrimaryCCD.ImageExposureN[0].value = 0; } else { PrimaryCCD.AbortExposureSP->s = IPS_ALERT; PrimaryCCD.ImageExposureNP->s = IPS_ALERT; } IDSetSwitch(PrimaryCCD.AbortExposureSP, NULL); IDSetNumber(PrimaryCCD.ImageExposureNP, NULL); return true; } if(strcmp(name,GuideCCD.AbortExposureSP->name)==0) { IUResetSwitch(GuideCCD.AbortExposureSP); if (AbortGuideExposure()) { GuideCCD.AbortExposureSP->s = IPS_OK; GuideCCD.ImageExposureNP->s = IPS_IDLE; GuideCCD.ImageExposureN[0].value = 0; } else { GuideCCD.AbortExposureSP->s = IPS_ALERT; GuideCCD.ImageExposureNP->s = IPS_ALERT; } IDSetSwitch(GuideCCD.AbortExposureSP, NULL); IDSetNumber(GuideCCD.ImageExposureNP, NULL); return true; } if(strcmp(name,PrimaryCCD.CompressSP->name)==0) { IUUpdateSwitch(PrimaryCCD.CompressSP,states,names,n); IDSetSwitch(PrimaryCCD.CompressSP,NULL); if(PrimaryCCD.CompressS[0].s==ISS_ON ) { PrimaryCCD.SendCompressed=true; } else { PrimaryCCD.SendCompressed=false; } return true; } if(strcmp(name,GuideCCD.CompressSP->name)==0) { IUUpdateSwitch(GuideCCD.CompressSP,states,names,n); IDSetSwitch(GuideCCD.CompressSP,NULL); if(GuideCCD.CompressS[0].s==ISS_ON ) { GuideCCD.SendCompressed=true; } else { GuideCCD.SendCompressed=false; } return true; } if(strcmp(name,PrimaryCCD.FrameTypeSP->name)==0) { // Compression Update IUUpdateSwitch(PrimaryCCD.FrameTypeSP,states,names,n); PrimaryCCD.FrameTypeSP->s=IPS_OK; if(PrimaryCCD.FrameTypeS[0].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::LIGHT_FRAME); else if(PrimaryCCD.FrameTypeS[1].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::BIAS_FRAME); else if(PrimaryCCD.FrameTypeS[2].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::DARK_FRAME); else if(PrimaryCCD.FrameTypeS[3].s==ISS_ON) PrimaryCCD.setFrameType(CCDChip::FLAT_FRAME); if (updateCCDFrameType(PrimaryCCD.getFrameType()) == false) PrimaryCCD.FrameTypeSP->s = IPS_ALERT; IDSetSwitch(PrimaryCCD.FrameTypeSP,NULL); return true; } } // let the default driver have a crack at it return DefaultDevice::ISNewSwitch(dev, name, states, names, n); }
bool AAGCloudWatcher::sendData() { CloudWatcherData data; int r = cwc->getAllData(&data); if (!r) { return false; } int N_DATA = 11; double values[N_DATA]; char *names[N_DATA]; names[0] = const_cast<char *>("supply"); values[0] = data.supply; names[1] = const_cast<char *>("sky"); values[1] = data.sky; names[2] = const_cast<char *>("sensor"); values[2] = data.sensor; names[3] = const_cast<char *>("ambient"); values[3] = data.ambient; names[4] = const_cast<char *>("rain"); values[4] = data.rain; names[5] = const_cast<char *>("rainHeater"); values[5] = data.rainHeater; names[6] = const_cast<char *>("rainTemp"); values[6] = data.rainTemperature; names[7] = const_cast<char *>("LDR"); values[7] = data.ldr; names[8] = const_cast<char *>("readCycle"); values[8] = data.readCycle; lastReadPeriod = data.readCycle; names[9] = const_cast<char *>("windSpeed"); values[9] = data.windSpeed; names[10] = const_cast<char *>("totalReadings"); values[10] = data.totalReadings; INumberVectorProperty *nvp = getNumber("readings"); IUUpdateNumber(nvp, values, names, N_DATA); nvp->s = IPS_OK; IDSetNumber(nvp, NULL); int N_ERRORS = 5; double valuesE[N_ERRORS]; char *namesE[N_ERRORS]; namesE[0] = const_cast<char *>("internalErrors"); valuesE[0] = data.internalErrors; namesE[1] = const_cast<char *>("firstAddressByteErrors"); valuesE[1] = data.firstByteErrors; namesE[2] = const_cast<char *>("commandByteErrors"); valuesE[2] = data.commandByteErrors; namesE[3] = const_cast<char *>("secondAddressByteErrors"); valuesE[3] = data.secondByteErrors; namesE[4] = const_cast<char *>("pecByteErrors"); valuesE[4] = data.pecByteErrors; INumberVectorProperty *nvpE = getNumber("unitErrors"); IUUpdateNumber(nvpE, valuesE, namesE, N_ERRORS); nvpE->s = IPS_OK; IDSetNumber(nvpE, NULL); int N_SENS = 8; double valuesS[N_SENS]; char *namesS[N_SENS]; float skyTemperature = float(data.sky) / 100.0; namesS[0] = const_cast<char *>("infraredSky"); valuesS[0] = skyTemperature; namesS[1] = const_cast<char *>("infraredSensor"); valuesS[1] = float(data.sensor) / 100.0; namesS[2] = const_cast<char *>("rainSensor"); valuesS[2] = data.rain; float rainSensorTemperature = data.rainTemperature; if (rainSensorTemperature > 1022) { rainSensorTemperature = 1022; } if (rainSensorTemperature < 1) { rainSensorTemperature = 1; } rainSensorTemperature = constants.rainPullUpResistance / ((1023.0 / rainSensorTemperature) - 1.0); rainSensorTemperature = log(rainSensorTemperature / constants.rainResistanceAt25); rainSensorTemperature = 1.0 / (rainSensorTemperature / constants.rainBetaFactor + 1.0 / (ABS_ZERO + 25.0) ) - ABS_ZERO; namesS[3] = const_cast<char *>("rainSensorTemperature"); valuesS[3] = rainSensorTemperature; float rainSensorHeater = data.rainHeater; rainSensorHeater = 100.0 * rainSensorHeater / 1023.0; namesS[4] = const_cast<char *>("rainSensorHeater"); valuesS[4] = rainSensorHeater; float ambientLight = float(data.ldr); if (ambientLight > 1022.0) { ambientLight = 1022.0; } if (ambientLight < 1) { ambientLight = 1.0; } ambientLight = constants.ldrPullUpResistance / ((1023.0 / ambientLight) - 1.0); namesS[5] = const_cast<char *>("brightnessSensor"); valuesS[5] = ambientLight; float ambientTemperature = data.ambient; if (ambientTemperature == -10000) { ambientTemperature = float(data.sensor) / 100.0; } else { if (ambientTemperature > 1022) { ambientTemperature = 1022; } if (ambientTemperature < 1) { ambientTemperature = 1; } ambientTemperature = constants.ambientPullUpResistance / ((1023.0 / ambientTemperature) - 1.0); ambientTemperature = log(ambientTemperature / constants.ambientResistanceAt25); ambientTemperature = 1.0 / (ambientTemperature / constants.ambientBetaFactor + 1.0 / (ABS_ZERO + 25.0)) - ABS_ZERO; } namesS[6] = const_cast<char *>("ambientTemperatureSensor"); valuesS[6] = ambientTemperature; INumberVectorProperty *nvpSky = getNumber("skyCorrection"); float k1 = getNumberValueFromVector(nvpSky, "k1"); float k2 = getNumberValueFromVector(nvpSky, "k2"); float k3 = getNumberValueFromVector(nvpSky, "k3"); float k4 = getNumberValueFromVector(nvpSky, "k4"); float k5 = getNumberValueFromVector(nvpSky, "k5"); float correctedTemperature = skyTemperature - ( (k1 / 100.0) * (ambientTemperature - k2 / 10.0) + (k3 / 100.0) * pow(exp(k4 / 1000 * ambientTemperature), (k5 / 100.0)) ); namesS[7] = const_cast<char *>("correctedInfraredSky"); valuesS[7] = correctedTemperature; INumberVectorProperty *nvpS = getNumber("sensors"); IUUpdateNumber(nvpS, valuesS, namesS, N_SENS); nvpS->s = IPS_OK; IDSetNumber(nvpS, NULL); ISState states[2]; char * namesSw[2]; namesSw[0] = const_cast<char *>("open"); namesSw[1] = const_cast<char *>("close"); //IDLog("%d\n", data.switchStatus); if (data.switchStatus == 1) { states[0] = ISS_OFF; states[1] = ISS_ON; } else { states[0] = ISS_ON; states[1] = ISS_OFF; } ISwitchVectorProperty *svpSw = getSwitch("deviceSwitch"); IUUpdateSwitch(svpSw, states, namesSw, 2); svpSw->s = IPS_OK; IDSetSwitch(svpSw, NULL); INumberVectorProperty *nvpLimits = getNumber("limitsCloud"); int clearLimit = getNumberValueFromVector(nvpLimits, "clear"); int cloudyLimit = getNumberValueFromVector(nvpLimits, "cloudy"); int overcastLimit = getNumberValueFromVector(nvpLimits, "overcast"); ISState statesCloud[4]; char * namesCloud[4]; namesCloud[0] = const_cast<char *>("clear"); namesCloud[1] = const_cast<char *>("cloudy"); namesCloud[2] = const_cast<char *>("overcast"); namesCloud[3] = const_cast<char *>("unknown"); statesCloud[0] = ISS_OFF; statesCloud[1] = ISS_OFF; statesCloud[2] = ISS_OFF; statesCloud[3] = ISS_OFF; //IDLog("%d\n", data.switchStatus); if (correctedTemperature < clearLimit) { statesCloud[0] = ISS_ON; } else if (correctedTemperature < cloudyLimit) { statesCloud[1] = ISS_ON; } else if (correctedTemperature < overcastLimit) { statesCloud[2] = ISS_ON; } else { statesCloud[3] = ISS_ON; } ISwitchVectorProperty *svpCC = getSwitch("cloudConditions"); IUUpdateSwitch(svpCC, statesCloud, namesCloud, 4); svpCC->s = IPS_OK; IDSetSwitch(svpCC, NULL); nvpLimits = getNumber("limitsRain"); int dryLimit = getNumberValueFromVector(nvpLimits, "dry"); int wetLimit = getNumberValueFromVector(nvpLimits, "wet"); int rainLimit = getNumberValueFromVector(nvpLimits, "rain"); ISState statesRain[4]; char * namesRain[4]; namesRain[0] = const_cast<char *>("dry"); namesRain[1] = const_cast<char *>("wet"); namesRain[2] = const_cast<char *>("rain"); namesRain[3] = const_cast<char *>("unknown"); statesRain[0] = ISS_OFF; statesRain[1] = ISS_OFF; statesRain[2] = ISS_OFF; statesRain[3] = ISS_OFF; //IDLog("%d\n", data.switchStatus); if (data.rain < rainLimit) { statesRain[3] = ISS_ON; } else if (data.rain < wetLimit) { statesRain[2] = ISS_ON; } else if (data.rain < dryLimit) { statesRain[1] = ISS_ON; } else { statesRain[0] = ISS_ON; } ISwitchVectorProperty *svpRC = getSwitch("rainConditions"); IUUpdateSwitch(svpRC, statesRain, namesRain, 4); svpRC->s = IPS_OK; IDSetSwitch(svpRC, NULL); nvpLimits = getNumber("limitsBrightness"); int darkLimit = getNumberValueFromVector(nvpLimits, "dark"); int lightLimit = getNumberValueFromVector(nvpLimits, "light"); int veryLightLimit = getNumberValueFromVector(nvpLimits, "veryLight"); ISState statesBrightness[3]; char * namesBrightness[3]; namesBrightness[0] = const_cast<char *>("dark"); namesBrightness[1] = const_cast<char *>("light"); namesBrightness[2] = const_cast<char *>("veryLight"); statesBrightness[0] = ISS_OFF; statesBrightness[1] = ISS_OFF; statesBrightness[2] = ISS_OFF; //IDLog("%d\n", data.switchStatus); if (ambientLight > darkLimit) { statesBrightness[0] = ISS_ON; } else if (ambientLight > lightLimit) { statesBrightness[1] = ISS_ON; } else { statesBrightness[2] = ISS_ON; } ISwitchVectorProperty *svpBC = getSwitch("brightnessConditions"); IUUpdateSwitch(svpBC, statesBrightness, namesBrightness, 3); svpBC->s = IPS_OK; IDSetSwitch(svpBC, NULL); int windSpeed = data.windSpeed; nvpLimits = getNumber("limitsWind"); int calmLimit = getNumberValueFromVector(nvpLimits, "calm"); int moderateWindLimit = getNumberValueFromVector(nvpLimits, "moderateWind"); INumberVectorProperty *consts = getNumber("constants"); int anemometerStatus = getNumberValueFromVector(consts, "anemometerStatus"); ISState statesWind[4]; char * namesWind[4]; namesWind[0] = const_cast<char *>("calm"); namesWind[1] = const_cast<char *>("moderateWind"); namesWind[2] = const_cast<char *>("strongWind"); namesWind[3] = const_cast<char *>("unknown"); statesWind[0] = ISS_OFF; statesWind[1] = ISS_OFF; statesWind[2] = ISS_OFF; statesWind[3] = ISS_OFF; //IDLog("%d\n", data.switchStatus); if (anemometerStatus) { if (windSpeed < calmLimit) { statesWind[0] = ISS_ON; } else if (windSpeed < moderateWindLimit) { statesWind[1] = ISS_ON; } else { statesWind[2] = ISS_ON; } } else { statesWind[3] = ISS_ON; } ISwitchVectorProperty *svpWC = getSwitch("windConditions"); IUUpdateSwitch(svpWC, statesWind, namesWind, 4); svpWC->s = IPS_OK; IDSetSwitch(svpWC, NULL); }
bool AAGCloudWatcher::heatingAlgorithm() { INumberVectorProperty *heaterParameters = getNumber("heaterParameters"); float tempLow = getNumberValueFromVector(heaterParameters, "tempLow"); float tempHigh = getNumberValueFromVector(heaterParameters, "tempHigh"); float deltaLow = getNumberValueFromVector(heaterParameters, "deltaLow"); float deltaHigh = getNumberValueFromVector(heaterParameters, "deltaHigh"); float heatImpulseTemp = getNumberValueFromVector(heaterParameters, "heatImpulseTemp"); float heatImpulseDuration = getNumberValueFromVector(heaterParameters, "heatImpulseDuration"); float heatImpulseCycle = getNumberValueFromVector(heaterParameters, "heatImpulseCycle"); float min = getNumberValueFromVector(heaterParameters, "min"); INumberVectorProperty *sensors = getNumber("sensors"); float ambient = getNumberValueFromVector(sensors, "ambientTemperatureSensor"); float rainSensorTemperature = getNumberValueFromVector(sensors, "rainSensorTemperature"); INumberVectorProperty *ref = getNumber("refresh"); float refresh = getNumberValueFromVector(ref, "refreshPeriod"); if (globalRainSensorHeater == -1) { // If not already setted globalRainSensorHeater = getNumberValueFromVector(sensors, "rainSensorHeater"); } time_t currentTime = time(NULL); if ((isWetRain()) && (heatingStatus == normal)) { // We check if sensor is wet. if (wetStartTime == -1) { // First moment wet wetStartTime = time(NULL); } else { // We have been wet for a while if (currentTime - wetStartTime >= heatImpulseCycle) { // We have been a cycle wet. Apply pulse wetStartTime = -1; heatingStatus = increasingToPulse; pulseStartTime = -1; } } } else { // is not wet wetStartTime = -1; } if (heatingStatus == pulse) { if (currentTime - pulseStartTime > heatImpulseDuration) { // Pulse ends heatingStatus = normal; wetStartTime = -1; pulseStartTime = -1; } } if (heatingStatus == normal) { // Compute desired temperature if (ambient < tempLow) { desiredSensorTemperature = deltaLow; } else if (ambient > tempHigh) { desiredSensorTemperature = ambient + deltaHigh; } else { // Between tempLow and tempHigh float delt = ((((ambient - tempLow) / (tempHigh - tempLow)) * (deltaHigh - deltaLow)) + deltaLow); desiredSensorTemperature = ambient + delt; if (desiredSensorTemperature < tempLow) { desiredSensorTemperature = deltaLow; } } } else { desiredSensorTemperature = ambient + heatImpulseTemp; } if (heatingStatus == increasingToPulse) { if (rainSensorTemperature < desiredSensorTemperature) { globalRainSensorHeater = 100.0; } else { // the pulse starts pulseStartTime = time(NULL); heatingStatus = pulse; } } if ( (heatingStatus == normal) || (heatingStatus == pulse) ) { // Check desired temperature and act accordingly // Obtain the difference in temperature and modifier float dif = fabs(desiredSensorTemperature - rainSensorTemperature); float refreshModifier = sqrt(refresh / 10.0); float modifier = 1; if (dif > 8) { modifier = (1.4 / refreshModifier); } else if (dif > 4) { modifier = (1.2 / refreshModifier); } else if (dif > 3) { modifier = (1.1 / refreshModifier); } else if (dif > 2) { modifier = (1.06 / refreshModifier); } else if (dif > 1) { modifier = (1.04 / refreshModifier); } else if (dif > 0.5) { modifier = (1.02 / refreshModifier); } else if (dif > 0.3) { modifier = (1.01 / refreshModifier); } if (rainSensorTemperature > desiredSensorTemperature) { // Lower heating // IDLog("Temp: %f, Desired: %f, Lowering: %f %f -> %f\n", rainSensorTemperature, desiredSensorTemperature, modifier, globalRainSensorHeater, globalRainSensorHeater / modifier); globalRainSensorHeater /= modifier; } else { // increase heating // IDLog("Temp: %f, Desired: %f, Increasing: %f %f -> %f\n", rainSensorTemperature, desiredSensorTemperature, modifier, globalRainSensorHeater, globalRainSensorHeater * modifier); globalRainSensorHeater *= modifier; } } if (globalRainSensorHeater < min) { globalRainSensorHeater = min; } if (globalRainSensorHeater > 100.0) { globalRainSensorHeater = 100.0; } int rawSensorHeater = int(globalRainSensorHeater * 1023.0 / 100.0); cwc->setPWMDutyCycle(rawSensorHeater); // Sending heater status to clients char *namesSw[3]; ISState statesSw[3]; statesSw[0] = ISS_OFF; statesSw[1] = ISS_OFF; statesSw[2] = ISS_OFF; namesSw[0] = const_cast<char *>("normal"); namesSw[1] = const_cast<char *>("increasing"); namesSw[2] = const_cast<char *>("pulse"); if (heatingStatus == normal) { statesSw[0] = ISS_ON; } else if (heatingStatus == increasingToPulse) { statesSw[1] = ISS_ON; } else if (heatingStatus == pulse) { statesSw[2] = ISS_ON; } ISwitchVectorProperty *svp = getSwitch("heaterStatus"); IUUpdateSwitch(svp, statesSw, namesSw, 3); svp->s = IPS_OK; IDSetSwitch(svp, NULL); }
bool AAGCloudWatcher::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { // ignore if not ours // if (strcmp (dev, getDefaultName())) { return false; } if (INDI::DefaultDevice::ISNewSwitch(dev, name, states, names, n) == true) { return true; } ISwitchVectorProperty *svp = getSwitch(name); if (!svp) { return false; } int error = 0; if (!strcmp(svp->name, "deviceSwitch")) { char * namesSw[2]; ISState statesSw[2]; statesSw[0] = ISS_ON; statesSw[1] = ISS_OFF; namesSw[0] = const_cast<char *>("open"); namesSw[1] = const_cast<char *>("close"); ISState openState; if (strcmp(names[0], "open") == 0) { openState = states[0]; } else { openState = states[1]; } if (openState == ISS_ON) { if (isConnected()) { bool r = cwc->openSwitch(); if (!r) { statesSw[0] = ISS_OFF; statesSw[1] = ISS_ON; } } else { statesSw[0] = ISS_ON; statesSw[1] = ISS_OFF; error = 1; } } else { if (isConnected()) { bool r = cwc->closeSwitch(); if (r) { statesSw[0] = ISS_OFF; statesSw[1] = ISS_ON; } } else { statesSw[0] = ISS_ON; statesSw[1] = ISS_OFF; error = 1; } } IUUpdateSwitch(svp, statesSw, namesSw, 2); if (error) { svp->s = IPS_IDLE; } else { svp->s = IPS_OK; } IDSetSwitch(svp, NULL); return true; } return DefaultDevice::ISNewSwitch(dev, name, states, names, n); }
bool ASICCD::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { ASI_ERROR_CODE errCode = ASI_SUCCESS; if(!strcmp(dev,getDeviceName())) { if (!strcmp(name, ControlSP.name)) { IUUpdateSwitch(&ControlSP, states, names, n); for (int i=0; i < ControlSP.nsp; i++) { ASI_CONTROL_TYPE swType = *((ASI_CONTROL_TYPE *) ControlS[i].aux); ASI_BOOL swAuto = (ControlS[i].s == ISS_ON) ? ASI_TRUE : ASI_FALSE; for (int j=0; j < ControlNP.nnp; j++) { ASI_CONTROL_TYPE nType = *((ASI_CONTROL_TYPE *) ControlN[j].aux0); if (swType == nType) { DEBUGF(INDI::Logger::DBG_DEBUG, "ISNewSwitch->SetControlValue %d %.2f", nType, ControlN[j].value); if ( (errCode = ASISetControlValue(m_camInfo->CameraID, nType, ControlN[j].value, swAuto )) != ASI_SUCCESS) { DEBUGF(INDI::Logger::DBG_ERROR, "ASISetControlValue (%s=%g) error (%d)", ControlN[j].name, ControlN[j].value, errCode); ControlNP.s = IPS_ALERT; ControlSP.s = IPS_ALERT; IDSetNumber(&ControlNP, NULL); IDSetSwitch(&ControlSP, NULL); return false; } *((ASI_BOOL *) ControlN[j].aux1) = swAuto; break; } } } ControlSP.s = IPS_OK; IDSetSwitch(&ControlSP, NULL); return true; } /* Cooler */ if (!strcmp (name, CoolerSP.name)) { if (IUUpdateSwitch(&CoolerSP, states, names, n) < 0) return false; bool rc=false; if (CoolerS[0].s == ISS_ON) activateCooler(true); else activateCooler(false); return true; } if (!strcmp(name, VideoFormatSP.name)) { #if !defined(OSX_EMBEDED_MODE) && !defined(__CYGWIN__) if (streamer->isBusy()) { VideoFormatSP.s = IPS_ALERT; DEBUG(INDI::Logger::DBG_ERROR, "Cannot change format while streaming/recording."); IDSetSwitch(&VideoFormatSP, NULL); return true; } #endif IUUpdateSwitch(&VideoFormatSP, states, names, n); ASI_IMG_TYPE type = getImageType(); switch (type) { case ASI_IMG_RAW16: PrimaryCCD.setBPP(16); break; default: PrimaryCCD.setBPP(8); break; } UpdateCCDFrame(PrimaryCCD.getSubX(), PrimaryCCD.getSubY(), PrimaryCCD.getSubW(), PrimaryCCD.getSubH()); updateRecorderFormat(); VideoFormatSP.s = IPS_OK; IDSetSwitch(&VideoFormatSP, NULL); return true; } } return INDI::CCD::ISNewSwitch(dev,name,states,names,n); }
/************************************************************************************ * * ***********************************************************************************/ bool BaaderDome::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { if (strcmp(name, CalibrateSP.name) == 0) { IUResetSwitch(&CalibrateSP); if (status == DOME_READY) { CalibrateSP.s = IPS_OK; DEBUG(INDI::Logger::DBG_SESSION, "Dome is already calibrated."); IDSetSwitch(&CalibrateSP, nullptr); return true; } if (CalibrateSP.s == IPS_BUSY) { Abort(); DEBUG(INDI::Logger::DBG_SESSION, "Calibration aborted."); status = DOME_UNKNOWN; CalibrateSP.s = IPS_IDLE; IDSetSwitch(&CalibrateSP, nullptr); return true; } status = DOME_CALIBRATING; DEBUG(INDI::Logger::DBG_SESSION, "Starting calibration procedure..."); calibrationStage = CALIBRATION_STAGE1; calibrationStart = DomeAbsPosN[0].value; // Goal of procedure is to reach south point to hit sensor calibrationTarget1 = calibrationStart + 179; if (calibrationTarget1 > 360) calibrationTarget1 -= 360; if (MoveAbs(calibrationTarget1) == IPS_IDLE) { CalibrateSP.s = IPS_ALERT; DEBUG(INDI::Logger::DBG_ERROR, "Calibration failue due to dome motion failure."); status = DOME_UNKNOWN; IDSetSwitch(&CalibrateSP, nullptr); return false; } DomeAbsPosNP.s = IPS_BUSY; CalibrateSP.s = IPS_BUSY; DEBUGF(INDI::Logger::DBG_SESSION, "Calibration is in progress. Moving to position %g.", calibrationTarget1); IDSetSwitch(&CalibrateSP, nullptr); return true; } if (strcmp(name, DomeFlapSP.name) == 0) { int ret = 0; int prevStatus = IUFindOnSwitchIndex(&DomeFlapSP); IUUpdateSwitch(&DomeFlapSP, states, names, n); int FlapDome = IUFindOnSwitchIndex(&DomeFlapSP); // No change of status, let's return if (prevStatus == FlapDome) { DomeFlapSP.s = IPS_OK; IDSetSwitch(&DomeFlapSP, nullptr); } // go back to prev status in case of failure IUResetSwitch(&DomeFlapSP); DomeFlapS[prevStatus].s = ISS_ON; if (FlapDome == 0) ret = ControlDomeFlap(FLAP_OPEN); else ret = ControlDomeFlap(FLAP_CLOSE); if (ret == 0) { DomeFlapSP.s = IPS_OK; IUResetSwitch(&DomeFlapSP); DomeFlapS[FlapDome].s = ISS_ON; IDSetSwitch(&DomeFlapSP, "Flap is %s.", (FlapDome == 0 ? "open" : "closed")); return true; } else if (ret == 1) { DomeFlapSP.s = IPS_BUSY; IUResetSwitch(&DomeFlapSP); DomeFlapS[FlapDome].s = ISS_ON; IDSetSwitch(&DomeFlapSP, "Flap is %s...", (FlapDome == 0 ? "opening" : "closing")); return true; } DomeFlapSP.s = IPS_ALERT; IDSetSwitch(&DomeFlapSP, "Flap failed to %s.", (FlapDome == 0 ? "open" : "close")); return false; } } return INDI::Dome::ISNewSwitch(dev, name, states, names, n); }
bool GPhotoCCD::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (strcmp(dev, getDeviceName()) == 0) { if (!strcmp(name, mIsoSP.name)) { if (IUUpdateSwitch(&mIsoSP, states, names, n) < 0) return false; for (int i = 0; i < mIsoSP.nsp; i++) { if (mIsoS[i].s == ISS_ON) { if (sim == false) gphoto_set_iso(gphotodrv, i); mIsoSP.s = IPS_OK; IDSetSwitch(&mIsoSP, NULL); break; } } } if (!strcmp(name, mFormatSP.name)) { int prevSwitch = IUFindOnSwitchIndex(&mFormatSP); if (IUUpdateSwitch(&mFormatSP, states, names, n) < 0) return false; ISwitch *sp = IUFindOnSwitch(&mFormatSP); if (sp) { if (strstr(sp->label, "+")) { DEBUGF(INDI::Logger::DBG_ERROR, "%s format is not supported.", sp->label); IUResetSwitch(&mFormatSP); mFormatSP.s = IPS_ALERT; mFormatSP.sp[prevSwitch].s = ISS_ON; IDSetSwitch(&mFormatSP, NULL); return false; } } for (int i = 0; i < mFormatSP.nsp; i++) { if (mFormatS[i].s == ISS_ON) { if (sim == false) gphoto_set_format(gphotodrv, i); mFormatSP.s = IPS_OK; IDSetSwitch(&mFormatSP, NULL); // We need to get frame W and H if format changes frameInitialized = false; break; } } } if (!strcmp(name, transferFormatSP.name)) { IUUpdateSwitch(&transferFormatSP, states, names, n); transferFormatSP.s = IPS_OK; IDSetSwitch(&transferFormatSP, NULL); // We need to get frame W and H if transfer format changes frameInitialized = false; return true; } if (!strcmp(name, autoFocusSP.name)) { IUResetSwitch(&autoFocusSP); if (gphoto_auto_focus(gphotodrv) == GP_OK) autoFocusSP.s = IPS_OK; else autoFocusSP.s = IPS_ALERT; IDSetSwitch(&autoFocusSP, NULL); return true; } if (!strcmp(name, UploadSP.name)) { IUUpdateSwitch(&UploadSP, states, names, n); UploadSP.s = IPS_OK; IDSetSwitch(&UploadSP, NULL); if (!sim) gphoto_set_upload_settings(gphotodrv, IUFindOnSwitchIndex(&UploadSP)); return true; } if (!strcmp(name, livePreviewSP.name)) { IUUpdateSwitch(&livePreviewSP, states, names, n); if (livePreviewS[0].s == ISS_ON) { livePreviewSP.s = IPS_BUSY; SetTimer(STREAMPOLLMS); } else livePreviewSP.s = IPS_IDLE; IDSetSwitch(&livePreviewSP, NULL); return true; } if (strstr(name, "FOCUS")) { return processFocuserSwitch(dev, name, states, names, n); } if(CamOptions.find(name) != CamOptions.end()) { cam_opt *opt = CamOptions[name]; if (opt->widget->type != GP_WIDGET_RADIO && opt->widget->type != GP_WIDGET_MENU && opt->widget->type != GP_WIDGET_TOGGLE) { DEBUGF(INDI::Logger::DBG_ERROR, "ERROR: Property '%s'is not a switch (%d)", name, opt->widget->type); return false; } if (opt->widget->readonly) { DEBUGF(INDI::Logger::DBG_WARNING, "WARNING: Property %s is read-only", name); IDSetSwitch(&opt->prop.sw, NULL); return false; } if (IUUpdateSwitch(&opt->prop.sw, states, names, n) < 0) return false; if (opt->widget->type == GP_WIDGET_TOGGLE) { gphoto_set_widget_num(gphotodrv, opt->widget, opt->item.sw[ON_S].s == ISS_ON); } else { for (int i = 0; i < opt->prop.sw.nsp; i++) { if (opt->item.sw[i].s == ISS_ON) { gphoto_set_widget_num(gphotodrv, opt->widget, i); break; } } } opt->prop.sw.s = IPS_OK; IDSetSwitch(&opt->prop.sw, NULL); return true; } } return INDI::CCD::ISNewSwitch(dev, name, states, names, n); }
/************************************************************************************ * * ***********************************************************************************/ bool ScopeDome::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { if (strcmp(name, FindHomeSP.name) == 0) { if (status != DOME_HOMING) { LOG_INFO("Finding home sensor"); status = DOME_HOMING; IUResetSwitch(&FindHomeSP); DomeAbsPosNP.s = IPS_BUSY; FindHomeSP.s = IPS_BUSY; IDSetSwitch(&FindHomeSP, nullptr); writeCmd(FindHome); } return true; } if (strcmp(name, DerotateSP.name) == 0) { if (status != DOME_DEROTATING) { LOG_INFO("De-rotating started"); status = DOME_DEROTATING; IUResetSwitch(&DerotateSP); DomeAbsPosNP.s = IPS_BUSY; DerotateSP.s = IPS_BUSY; IDSetSwitch(&DerotateSP, nullptr); } return true; } if (strcmp(name, StartCalibrationSP.name) == 0) { if (status != DOME_CALIBRATING) { LOG_INFO("Calibration started"); status = DOME_CALIBRATING; IUResetSwitch(&StartCalibrationSP); DomeAbsPosNP.s = IPS_BUSY; StartCalibrationSP.s = IPS_BUSY; IDSetSwitch(&StartCalibrationSP, nullptr); writeCmd(FullSystemCal); } return true; } if (strcmp(name, PowerRelaysSP.name) == 0) { IUUpdateSwitch(&PowerRelaysSP, states, names, n); setOutputState(OUT_CCD, PowerRelaysS[0].s); setOutputState(OUT_SCOPE, PowerRelaysS[1].s); setOutputState(OUT_LIGHT, PowerRelaysS[2].s); setOutputState(OUT_FAN, PowerRelaysS[3].s); IDSetSwitch(&PowerRelaysSP, nullptr); return true; } if (strcmp(name, RelaysSP.name) == 0) { IUUpdateSwitch(&RelaysSP, states, names, n); setOutputState(OUT_RELAY1, RelaysS[0].s); setOutputState(OUT_RELAY2, RelaysS[1].s); setOutputState(OUT_RELAY3, RelaysS[2].s); setOutputState(OUT_RELAY4, RelaysS[3].s); IDSetSwitch(&RelaysSP, nullptr); return true; } if (strcmp(name, ParkShutterSP.name) == 0) { IUUpdateSwitch(&ParkShutterSP, states, names, n); ParkShutterSP.s = IPS_OK; IDSetSwitch(&ParkShutterSP, nullptr); return true; } } return INDI::Dome::ISNewSwitch(dev, name, states, names, n); }
bool NStep::ISNewSwitch(const char * dev, const char * name, ISState * states, char * names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { // Temperature Compensation Mode if (!strcmp(name, CompensationModeSP.name)) { int prevIndex = IUFindOnSwitchIndex(&CompensationModeSP); IUUpdateSwitch(&CompensationModeSP, states, names, n); int mode = IUFindOnSwitchIndex(&CompensationModeSP); if (setCompensationMode(mode)) { CompensationModeSP.s = IPS_OK; // If it was set to one shot, we put it back to off? switch (mode) { case COMPENSATION_MODE_OFF: LOG_INFO("Temperature compensation is disabled."); break; case COMPENSATION_MODE_ONE_SHOT: IUResetSwitch(&CompensationModeSP); CompensationModeS[COMPENSATION_MODE_OFF].s = ISS_ON; LOG_INFO("One shot compensation applied."); break; case COMPENSATION_MODE_AUTO: LOG_INFO("Automatic temperature compensation is enabled."); break; } } else { IUResetSwitch(&CompensationModeSP); CompensationModeS[prevIndex].s = ISS_ON; CompensationModeSP.s = IPS_ALERT; LOG_ERROR("Failed to change temperature compnensation mode."); } IDSetSwitch(&CompensationModeSP, nullptr); return true; } // Manual Prime if (!strcmp(name, PrimeManualSP.name)) { sendCommand(":TI"); PrimeManualSP.s = IPS_OK; IDSetSwitch(&PrimeManualSP, nullptr); LOG_INFO("Prime for manual complete. Click One Shot to apply manual compensation once."); return true; } // Stepping Mode if (!strcmp(name, SteppingModeSP.name)) { IUUpdateSwitch(&SteppingModeSP, states, names, n); SteppingModeSP.s = IPS_OK; IDSetSwitch(&SteppingModeSP, nullptr); return true; } // Coil Status after Move is done if (!strcmp(name, CoilStatusSP.name)) { int prevIndex = IUFindOnSwitchIndex(&CoilStatusSP); IUUpdateSwitch(&CoilStatusSP, states, names, n); int state = IUFindOnSwitchIndex(&CoilStatusSP); if (setCoilStatus(state)) { CoilStatusSP.s = IPS_OK; if (state == COIL_ENERGIZED_ON) LOG_WARN("Coil shall be kept energized after motion is complete. Watch for motor heating!"); else LOG_INFO("Coil shall be de-energized after motion is complete."); } else { IUResetSwitch(&CoilStatusSP); CoilStatusS[prevIndex].s = ISS_ON; CoilStatusSP.s = IPS_ALERT; LOG_ERROR("Failed to update coil energization status."); } IDSetSwitch(&CoilStatusSP, nullptr); return true; } } return INDI::Focuser::ISNewSwitch(dev, name, states, names, n); }
bool ATIKCCD::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && !strcmp(dev, getDeviceName())) { // Gain/Offset Presets if (!strcmp(name, ControlPresetsSP.name)) { int prevIndex = IUFindOnSwitchIndex(&ControlPresetsSP); IUUpdateSwitch(&ControlPresetsSP, states, names, n); int targetIndex = IUFindOnSwitchIndex(&ControlPresetsSP); uint16_t value = static_cast<uint16_t>(targetIndex + 2); uint8_t *data = reinterpret_cast<uint8_t*>(&value); int rc = ArtemisCameraSpecificOptionSetData(hCam, ID_AtikHorizonGOPresetMode, data, 2); if (rc != ARTEMIS_OK) { ControlPresetsSP.s = IPS_ALERT; IUResetSwitch(&ControlPresetsSP); ControlPresetsS[prevIndex].s = ISS_ON; } else ControlPresetsSP.s = IPS_OK; IDSetSwitch(&ControlPresetsSP, nullptr); return true; } // Cooler controler if (!strcmp(name, CoolerSP.name)) { if (IUUpdateSwitch(&CoolerSP, states, names, n) < 0) { CoolerSP.s = IPS_ALERT; IDSetSwitch(&CoolerSP, nullptr); return true; } bool enabled = (CoolerS[COOLER_ON].s == ISS_ON); // If user turns on cooler, but the requested temperature is higher than current temperature // then we set temperature to zero degrees. If that was still higher than current temperature // we return an error if (enabled && TemperatureRequest > TemperatureN[0].value) { TemperatureRequest = 0; // If current temperature is still lower than zero, then we shouldn't risk // setting temperature to any arbitrary value. Instead, we report an error and ask // user to explicitly set the requested temperature. if (TemperatureRequest > TemperatureN[0].value) { CoolerS[COOLER_ON].s = ISS_OFF; CoolerS[COOLER_OFF].s = ISS_OFF; CoolerSP.s = IPS_ALERT; LOGF_WARN("Cannot manually activate cooler since current temperature is %.2f. To activate cooler, request a lower temperature.", TemperatureN[0].value); IDSetSwitch(&CoolerSP, nullptr); return true; } SetTemperature(0); return true; } return activateCooler(enabled); } } return INDI::CCD::ISNewSwitch(dev, name, states, names, n); }