自学教程：C++ IDSetSwitch函数代码示例

/************************************************************************************ ** ***********************************************************************************/bool BaaderDome::SetupParms(){    targetAz = 0;    if (UpdatePosition())        IDSetNumber(&DomeAbsPosNP, nullptr);    if (UpdateShutterStatus())        IDSetSwitch(&DomeShutterSP, nullptr);    if (UpdateFlapStatus())        IDSetSwitch(&DomeFlapSP, nullptr);    if (InitPark())    {        // If loading parking data is successful, we just set the default parking values.        SetAxis1ParkDefault(0);    }    else    {        // Otherwise, we set all parking data to default in case no parking data is found.        SetAxis1Park(0);        SetAxis1ParkDefault(0);    }    return true;}

bool FocuserInterface::processSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    INDI_UNUSED(dev);    //  This one is for us    if (strcmp(name, "FOCUS_MOTION") == 0)    {        // 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;    }    if (strcmp(name, "FOCUS_ABORT_MOTION") == 0)    {        IUResetSwitch(&AbortSP);        if (AbortFocuser())        {            AbortSP.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            AbortSP.s = IPS_ALERT;        IDSetSwitch(&AbortSP, nullptr);        return true;    }    return false;}

void QHYCCD::setCooler(bool enable){    if (enable && coolerEnabled == false)    {        CoolerS[0].s = ISS_ON;        CoolerS[1].s = ISS_OFF;        CoolerSP.s   = IPS_OK;        IDSetSwitch(&CoolerSP, NULL);        CoolerNP.s = IPS_BUSY;        IDSetNumber(&CoolerNP, NULL);        DEBUG(INDI::Logger::DBG_SESSION, "Cooler on.");        coolerEnabled = true;    }    else if (!enable && coolerEnabled == true)    {        coolerEnabled = false;        if (sim == false)            SetQHYCCDParam(camhandle, CONTROL_MANULPWM, 0);        CoolerSP.s   = IPS_IDLE;        CoolerS[0].s = ISS_OFF;        CoolerS[1].s = ISS_ON;        IDSetSwitch(&CoolerSP, NULL);        CoolerNP.s = IPS_IDLE;        IDSetNumber(&CoolerNP, NULL);        TemperatureNP.s = IPS_IDLE;        IDSetNumber(&TemperatureNP, NULL);        DEBUG(INDI::Logger::DBG_SESSION, "Cooler off.");    }}

bool LX200Autostar::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    int index = 0;    if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)    {        // Focus Motion        if (!strcmp(name, FocusMotionSP.name))        {            // If speed is "halt"            if (FocusSpeedN[0].value == 0)            {                FocusMotionSP.s = IPS_IDLE;                IDSetSwitch(&FocusMotionSP, nullptr);                return false;            }            int last_motion = IUFindOnSwitchIndex(&FocusMotionSP);            if (IUUpdateSwitch(&FocusMotionSP, states, names, n) < 0)                return false;            index = IUFindOnSwitchIndex(&FocusMotionSP);            // If same direction and we're busy, stop            if (last_motion == index && FocusMotionSP.s == IPS_BUSY)            {                IUResetSwitch(&FocusMotionSP);                FocusMotionSP.s = IPS_IDLE;                setFocuserSpeedMode(PortFD, 0);                IDSetSwitch(&FocusMotionSP, nullptr);                return true;            }            if (!isSimulation() && setFocuserMotion(PortFD, index) < 0)            {                FocusMotionSP.s = IPS_ALERT;                IDSetSwitch(&FocusMotionSP, "Error setting focuser speed.");                return false;            }            FocusMotionSP.s = IPS_BUSY;            // with a timer            if (FocusTimerNP.np[0].value > 0)            {                FocusTimerNP.s = IPS_BUSY;                if (isDebug())                    IDLog("Starting Focus Timer BUSY/n");                IEAddTimer(50, LX200Generic::updateFocusHelper, this);            }            IDSetSwitch(&FocusMotionSP, nullptr);            return true;        }    }    return LX200Generic::ISNewSwitch(dev, name, states, names, n);}

bool FocusMaster::AbortFocuser(){    uint8_t command[MAX_FM_BUF] = {0};    command[0] = 0x30;    command[1] = 0x30;    LOG_DEBUG("Aborting Focuser...");    bool rc = sendCommand(command);    if (rc)    {        if (FullMotionSP.s == IPS_BUSY)        {            IUResetSwitch(&FullMotionSP);            FullMotionSP.s = IPS_IDLE;            IDSetSwitch(&FullMotionSP, nullptr);        }        if (FocusMotionSP.s == IPS_BUSY)        {            IUResetSwitch(&FocusMotionSP);            FocusMotionSP.s = IPS_IDLE;            IDSetSwitch(&FocusMotionSP, nullptr);        }    }    return rc;}

void ASIEAF::GetFocusParams(){    if (readPosition())        IDSetNumber(&FocusAbsPosNP, nullptr);    if (readReverse())        IDSetSwitch(&FocusReverseSP, nullptr);    if (readBeep())        IDSetSwitch(&BeepSP, nullptr);}

/************************************************************************************ ** ***********************************************************************************/bool ScopeDome::SetupParms(){    targetAz = 0;    readU32(GetImpPerTurn, stepsPerTurn);    LOGF_INFO("Steps per turn read as %d", stepsPerTurn);    StepsPerRevolutionN[0].value = stepsPerTurn;    StepsPerRevolutionNP.s       = IPS_OK;    IDSetNumber(&StepsPerRevolutionNP, nullptr);    readS32(GetHomeSensorPosition, homePosition);    LOGF_INFO("Home position read as %d", homePosition);    if (UpdatePosition())        IDSetNumber(&DomeAbsPosNP, nullptr);    if (UpdateShutterStatus())        IDSetSwitch(&DomeShutterSP, nullptr);    UpdateSensorStatus();    UpdateRelayStatus();    if (InitPark())    {        // If loading parking data is successful, we just set the default parking        // values.        SetAxis1ParkDefault(0);    }    else    {        // Otherwise, we set all parking data to default in case no parking data is        // found.        SetAxis1Park(0);        SetAxis1ParkDefault(0);    }    uint8_t calibrationNeeded = false;    readU8(IsFullSystemCalReq, calibrationNeeded);    CalibrationNeededS[0].s = calibrationNeeded ? ISS_ON : ISS_OFF;    CalibrationNeededSP.s   = IPS_OK;    IDSetSwitch(&CalibrationNeededSP, nullptr);    uint16_t fwVersion;    readU16(GetVersionFirmware, fwVersion);    FirmwareVersionsN[0].value = fwVersion / 100.0;    uint8_t fwVersionRotary;    readU8(GetVersionFirmwareRotary, fwVersionRotary);    FirmwareVersionsN[1].value = (fwVersionRotary + 9) / 10.0;    FirmwareVersionsNP.s       = IPS_OK;    IDSetNumber(&FirmwareVersionsNP, nullptr);    return true;}

bool INDI::Focuser::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n){    if(strcmp(dev,getDeviceName())==0)    {        if (!strcmp(PresetGotoSP.name, name))        {            IUUpdateSwitch(&PresetGotoSP, states, names, n);            int index = IUFindOnSwitchIndex(&PresetGotoSP);            if (PresetN[index].value < FocusAbsPosN[0].min)            {                PresetGotoSP.s = IPS_ALERT;                IDSetSwitch(&PresetGotoSP, NULL);                DEBUGFDEVICE(dev, INDI::Logger::DBG_ERROR, "Requested position out of bound. Focus minimum position is %g", FocusAbsPosN[0].min);                return false;            }            else if (PresetN[index].value > FocusAbsPosN[0].max)            {                PresetGotoSP.s = IPS_ALERT;                IDSetSwitch(&PresetGotoSP, NULL);                DEBUGFDEVICE(dev, INDI::Logger::DBG_ERROR, "Requested position out of bound. Focus maximum position is %g", FocusAbsPosN[0].max);                return false;            }            int rc = MoveAbsFocuser(PresetN[index].value);            if (rc >= 0)            {                PresetGotoSP.s = IPS_OK;                DEBUGF(INDI::Logger::DBG_SESSION, "Moving to Preset %d with position %g.", index+1, PresetN[index].value);                IDSetSwitch(&PresetGotoSP, NULL);                return true;            }            PresetGotoSP.s = IPS_ALERT;            IDSetSwitch(&PresetGotoSP, NULL);            return false;        }        if (strstr(name, "FOCUS_"))            return processFocuserSwitch(dev, name, states, names, n);    }    controller->ISNewSwitch(dev, name, states, names, n);    //  Nobody has claimed this, so, ignore it    return DefaultDevice::ISNewSwitch(dev,name,states,names,n);}

bool ASIEAF::ISNewSwitch(const char * dev, const char * name, ISState * states, char * names[], int n){    if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)    {        // Turn on/off beep        if (!strcmp(name, BeepSP.name))        {            EAF_ERROR_CODE rc = EAF_SUCCESS;            if (!strcmp(BeepS[BEEP_ON].name, IUFindOnSwitchName(states, names, n)))                rc = EAFSetBeep(m_ID, true);            else                rc = EAFSetBeep(m_ID, false);            if (rc == EAF_SUCCESS)            {                IUUpdateSwitch(&BeepSP, states, names, n);                BeepSP.s = IPS_OK;            }            else            {                BeepSP.s = IPS_ALERT;                LOGF_ERROR("Failed to set beep state. Error: %d", rc);            }            IDSetSwitch(&BeepSP, nullptr);            return true;        }    }    return INDI::Focuser::ISNewSwitch(dev, name, states, names, n);}

bool DSICCD::ISNewSwitch (const char *dev, const char *name,                          ISState *states, char *names[], int n){    int index=0;    if(strcmp(dev,getDeviceName())==0)    {        /* Vdd on/off switch for DSI III exposure control (gs) */        if (!strcmp(name,VddExpSP.name))        {            if (IUUpdateSwitch(&VddExpSP, states, names, n) < 0)                return false;            index = IUFindOnSwitchIndex(&VddExpSP);            if (index == 0)                dsi->setVddOn(true);            else                dsi->setVddOn(false);            VddExpSP.s = IPS_OK;            IDSetSwitch (&VddExpSP,                         index == 0 ? "Vdd mode is ON" : "Vdd mode is OFF" );            return true;        }    }    return INDI::CCD::ISNewSwitch (dev, name, states, names,  n);}

bool ASICCD::ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n){    ASI_ERROR_CODE errCode = ASI_SUCCESS;     if(!strcmp(dev,getDeviceName()))     {         if (!strcmp(name, ControlNP.name))         {            double oldValues[ControlNP.nnp];            for (int i=0; i < ControlNP.nnp; i++)                oldValues[i] = ControlN[i].value;            IUUpdateNumber(&ControlNP, values, names, n);            for (int i=0; i < ControlNP.nnp; i++)            {                ASI_BOOL nAuto = *((ASI_BOOL *) ControlN[i].aux1);                ASI_CONTROL_TYPE nType = *((ASI_CONTROL_TYPE *) ControlN[i].aux0);                // If value didn't change or if USB bandwidth control is to change, then only continue if ExposureRequest < 250 ms                if (ControlN[i].value == oldValues[i] || (nType == ASI_BANDWIDTHOVERLOAD && ExposureRequest > 0.25))                    continue;                if ( (errCode = ASISetControlValue(m_camInfo->CameraID, nType, ControlN[i].value, ASI_FALSE)) != ASI_SUCCESS)                {                    DEBUGF(INDI::Logger::DBG_ERROR, "ASISetControlValue (%s=%g) error (%d)", ControlN[i].name, ControlN[i].value, errCode);                    ControlNP.s = IPS_ALERT;                    for (int i=0; i < ControlNP.nnp; i++)                        ControlN[i].value = oldValues[i];                    IDSetNumber(&ControlNP, NULL);                    return false;                }                // If it was set to nAuto value to turn it off                if (nAuto)                {                    for (int j=0; j < ControlSP.nsp; j++)                    {                        ASI_CONTROL_TYPE swType = *((ASI_CONTROL_TYPE *) ControlS[j].aux);                        if (swType == nType)                        {                            ControlS[j].s = ISS_OFF;                            break;                        }                    }                    IDSetSwitch(&ControlSP, NULL);                 }            }            ControlNP.s = IPS_OK;            IDSetNumber(&ControlNP, NULL);            return true;         }     }    return INDI::CCD::ISNewNumber(dev,name,values,names,n);}

bool INDI::LightBoxInterface::processLightBoxSwitch(const char *dev, const char *name, ISState *states, char *names[],                                                    int n){    if (strcmp(dev, device->getDeviceName()) == 0)    {        // Light        if (!strcmp(LightSP.name, name))        {            int prevIndex = IUFindOnSwitchIndex(&LightSP);            IUUpdateSwitch(&LightSP, states, names, n);            bool rc = EnableLightBox(LightS[FLAT_LIGHT_ON].s == ISS_ON ? true : false);            LightSP.s = rc ? IPS_OK : IPS_ALERT;            if (!rc)            {                IUResetSwitch(&LightSP);                LightS[prevIndex].s = ISS_ON;            }            IDSetSwitch(&LightSP, nullptr);            return true;        }    }    return false;}

bool ASICCD::StartStreaming(){    ASI_IMG_TYPE type = getImageType();    if (type != ASI_IMG_Y8 && type != ASI_IMG_RGB24)    {        IUResetSwitch(&VideoFormatSP);        ISwitch *vf = IUFindSwitch(&VideoFormatSP,"ASI_IMG_Y8");        if (vf == NULL)            vf = IUFindSwitch(&VideoFormatSP,"ASI_IMG_RAW8");        if (vf)        {            vf->s = ISS_ON;            DEBUGF(INDI::Logger::DBG_DEBUG, "Switching to %s video format.", vf->label);            PrimaryCCD.setBPP(8);            UpdateCCDFrame(PrimaryCCD.getSubX(), PrimaryCCD.getSubY(), PrimaryCCD.getSubW(), PrimaryCCD.getSubH());            IDSetSwitch(&VideoFormatSP, NULL);        }        else        {            DEBUG(INDI::Logger::DBG_ERROR, "No 8 bit video format found, cannot start stream.");            return false;        }    }    ASIStartVideoCapture(m_camInfo->CameraID);    pthread_mutex_lock(&condMutex);    streamPredicate = 1;    pthread_mutex_unlock(&condMutex);    pthread_cond_signal(&cv);    return true;}

bool MaxDomeII::Abort(){    int error=0;    int nRetry = 3;    while (nRetry)    {            error = Abort_Azimuth_MaxDomeII(PortFD);            handle_driver_error(&error, &nRetry);    }    while (nRetry)    {            error = Abort_Shutter_MaxDomeII(PortFD);            handle_driver_error(&error, &nRetry);    }    DomeAbsPosNP.s = IPS_IDLE;    IDSetNumber(&DomeAbsPosNP, NULL);    // If we abort while in the middle of opening/closing shutter, alert.    if (DomeShutterSP.s == IPS_BUSY)    {        DomeShutterSP.s = IPS_ALERT;        IDSetSwitch(&DomeShutterSP, "Shutter operation aborted.");        return false;    }    return true;}

/********************************************************************************************** Client is asking us to update a switch*********************************************************************************************/bool RainDetector::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)    {        if (strcmp(name, RainSP.name) == 0)        {            IUUpdateSwitch(&RainSP, states, names, n);            if (RainS[0].s == ISS_ON)            {                RainL[0].s = IPS_ALERT;                RainLP.s   = IPS_ALERT;                IDSetLight(&RainLP, "Alert! Alert! Rain detected!");            }            else            {                RainL[0].s = IPS_IDLE;                RainLP.s   = IPS_OK;                IDSetLight(&RainLP, "Rain threat passed. The skies are clear.");            }            RainSP.s = IPS_OK;            IDSetSwitch(&RainSP, nullptr);            return true;        }    }    return INDI::DefaultDevice::ISNewSwitch(dev, name, states, names, n);}

bool QikFlat::Disconnect(){    sf->closePort();    delete sf;	    DEBUG(INDI::Logger::DBG_SESSION, "ARDUINO BOARD DISCONNECTED.");    IDSetSwitch (getSwitch("CONNECTION"),"DISCONNECTED/n");    return true;}

bool ATIKCCD::activateCooler(bool enable){    IUResetSwitch(&CoolerSP);    if (enable)    {        if (TemperatureRequest < TemperatureN[0].value)        {            if (CoolerSP.s != IPS_BUSY)                LOG_INFO("Camera cooler is on.");            CoolerS[COOLER_ON].s = ISS_ON;            CoolerS[COOLER_OFF].s = ISS_OFF;            CoolerSP.s = IPS_BUSY;        }        else        {            CoolerS[COOLER_ON].s = ISS_OFF;            CoolerS[COOLER_OFF].s = ISS_ON;            CoolerSP.s = IPS_IDLE;            LOG_WARN("Cooler cannot be activated manually. Set a lower temperature to activate it.");            IDSetSwitch(&CoolerSP, nullptr);            return false;        }    }    else if (enable == false)    {        int rc = ArtemisCoolerWarmUp(hCam);        if (rc != ARTEMIS_OK)        {            CoolerS[COOLER_ON].s = ISS_ON;            CoolerS[COOLER_OFF].s = ISS_OFF;            CoolerSP.s = IPS_ALERT;            LOGF_ERROR("Failed to warm camera (%d).", rc);            IDSetSwitch(&CoolerSP, nullptr);            return false;        }        CoolerS[COOLER_ON].s = ISS_OFF;        CoolerS[COOLER_OFF].s = ISS_ON;        CoolerSP.s = IPS_IDLE;        LOG_INFO("Camera is warming up...");    }    IDSetSwitch(&CoolerSP, nullptr);    return true;}

/************************************************************************************ ** ***********************************************************************************/bool ScopeDome::UpdateRelayStatus(){    PowerRelaysS[0].s = getInputState(OUT_CCD);    PowerRelaysS[1].s = getInputState(OUT_SCOPE);    PowerRelaysS[2].s = getInputState(OUT_LIGHT);    PowerRelaysS[3].s = getInputState(OUT_FAN);    PowerRelaysSP.s   = IPS_OK;    IDSetSwitch(&PowerRelaysSP, nullptr);    RelaysS[0].s = getInputState(OUT_RELAY1);    RelaysS[0].s = getInputState(OUT_RELAY1);    RelaysS[0].s = getInputState(OUT_RELAY1);    RelaysS[0].s = getInputState(OUT_RELAY1);    RelaysSP.s   = IPS_OK;    IDSetSwitch(&RelaysSP, nullptr);    return true;}

void GPhotoCCD::UpdateWidget(cam_opt *opt){	struct tm *tm;    switch(opt->widget->type)    {	case GP_WIDGET_RADIO:	case GP_WIDGET_MENU:		for (int i = 0; i < opt->widget->choice_cnt; i++)			opt->item.sw[i].s = opt->widget->value.index == i ? ISS_ON : ISS_OFF;		IDSetSwitch(&opt->prop.sw, NULL);		break;	case GP_WIDGET_TEXT:		free(opt->item.text.text);		opt->item.text.text = strdup(opt->widget->value.text);		IDSetText(&opt->prop.text, NULL);		break;	case GP_WIDGET_TOGGLE:		if(opt->widget->value.toggle) {			opt->item.sw[0].s = ISS_ON;			opt->item.sw[0].s = ISS_OFF;        } else        {			opt->item.sw[0].s = ISS_OFF;			opt->item.sw[0].s = ISS_ON;		}		IDSetSwitch(&opt->prop.sw, NULL);		break;	case GP_WIDGET_RANGE:		opt->item.num.value = opt->widget->value.num;		IDSetNumber(&opt->prop.num, NULL);		break;	case GP_WIDGET_DATE:		free(opt->item.text.text);		tm = gmtime((time_t *)&opt->widget->value.date);		opt->item.text.text = strdup(asctime(tm));		IDSetText(&opt->prop.text, NULL);		break;	default:		delete opt;		return;	}}

bool Weather::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)    {        // Refresh        if (!strcmp(name, RefreshSP.name))        {            RefreshS[0].s = ISS_OFF;            RefreshSP.s   = IPS_OK;            IDSetSwitch(&RefreshSP, nullptr);            TimerHit();        }        // Override        if (!strcmp(name, OverrideSP.name))        {            IUUpdateSwitch(&OverrideSP, states, names, n);            if (OverrideS[0].s == ISS_ON)            {                LOG_WARN("Weather override is enabled. Observatory is not safe. Turn off override as soon as possible.");                OverrideSP.s = IPS_BUSY;                critialParametersLP.s = IPS_OK;                IDSetLight(&critialParametersLP, nullptr);            }            else            {                LOG_INFO("Weather override is disabled");                OverrideSP.s = IPS_IDLE;                syncCriticalParameters();            }            IDSetSwitch(&OverrideSP, nullptr);            return true;        }    }    return DefaultDevice::ISNewSwitch(dev, name, states, names, n);}

/* Handle a request to change a switch. */bool ShelyakEshel::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    if (!strcmp(dev, getDeviceName())) // check if the message is for our device    {        if (!strcmp(LampSP.name, name)) // check if its lamp request        {            LampSP.s = IPS_OK; // set state to ok (change later if something goes wrong)            for (int i = 0; i < n; i++)            {                ISwitch *s = IUFindSwitch(&LampSP, names[i]);                if (states[i] != s->s)                { // check if state has changed                    bool rc = calibrationUnitCommand(COMMANDS[states[i]], PARAMETERS[names[i]]);                    if (!rc)                        LampSP.s = IPS_ALERT;                }            }            IUUpdateSwitch(&LampSP, states, names, n); // update lamps            IDSetSwitch(&LampSP, nullptr);                // tell clients to update            return true;        }        else            if (!strcmp(MirrorSP.name, name)) // check if its a mirror request        {            ISState s = MirrorS[0].s;                    // save current mirror state            IUUpdateSwitch(&MirrorSP, states, names, n); // update mirror            MirrorSP.s = IPS_OK;                         // set state to ok (change later if something goes wrong)            if (s != MirrorS[0].s)            { // if mirror state has changed send command                bool rc = calibrationUnitCommand(COMMANDS[MirrorS[0].s], PARAMETERS["MIRROR"]);                if (!rc)                    MirrorSP.s = IPS_ALERT;            }            IDSetSwitch(&MirrorSP, nullptr); // tell clients to update            return true;        }    }    return INDI::DefaultDevice::ISNewSwitch(dev, name, states, names, n); // send it to the parent classes}

bool DomeSim::Abort(){        // If we abort while in the middle of opening/closing shutter, alert.    if (DomeShutterSP.s == IPS_BUSY)    {        DomeShutterSP.s = IPS_ALERT;        IDSetSwitch(&DomeShutterSP, "Shutter operation aborted. Status: unknown.");        return false;    }    return true;}

void JoyStick::buttonEvent(int button_n, int value){    if (!isConnected())        return;    DEBUGF(INDI::Logger::DBG_DEBUG, "buttonEvent[%d]: %s", button_n, value > 0 ? "On" : "Off");    ButtonSP.s          = IPS_OK;    ButtonS[button_n].s = (value == 0) ? ISS_OFF : ISS_ON;    IDSetSwitch(&ButtonSP, nullptr);}

void JoyStick::buttonEvent(int button_n, int value){    if (isConnected() == false)        return;    if (isDebug())        IDLog("buttonEvent[%d]: %s/n", button_n, value > 0 ? "On" : "Off");    ButtonSP.s = IPS_OK;    ButtonS[button_n].s = (value == 0 )? ISS_OFF : ISS_ON;    IDSetSwitch(&ButtonSP, NULL);}

bool StarbookDriver::performStart() {    IUResetSwitch(&StartSP);    if (last_known_state == starbook::INIT) {        if (cmd_interface->Start()) {            StartSP.s = IPS_OK;        }    } else {        LOGF_WARN("Can't initialize in %s state, must be INIT", starbook::STATE_TO_STR.at(last_known_state).c_str());        StartSP.s = IPS_ALERT;    }    IDSetSwitch(&StartSP, nullptr);    return true;}

bool RollOff::Abort(){    MotionRequest=-1;    // If both limit switches are off, then we're neither parked nor unparked.    if (fullOpenLimitSwitch == false && fullClosedLimitSwitch == false)    {        IUResetSwitch(&ParkSP);        ParkSP.s = IPS_IDLE;        IDSetSwitch(&ParkSP, NULL);    }    return true;}

bool Vantage::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n){    if(strcmp(dev,getDeviceName())==0)    {        if (!strcmp(BaudRateSP.name, name))        {            IUUpdateSwitch(&BaudRateSP, states, names, n);            BaudRateSP.s = IPS_OK;            IDSetSwitch(&BaudRateSP, NULL);            return true;        }    }    return INDI::Weather::ISNewSwitch(dev, name, states, names, n);}

bool MICCD::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n){    if (strcmp(dev, getDeviceName()) == 0)    {        if (!strcmp(name, ReadModeSP.name))        {            IUUpdateSwitch(&ReadModeSP, states, names, n);            ReadModeSP.s = IPS_OK;            IDSetSwitch(&ReadModeSP, nullptr);            return true;        }    }    return INDI::CCD::ISNewSwitch(dev, name, states, names, n);}

bool ASICCD::activateCooler(bool enable){    bool rc = (ASISetControlValue(m_camInfo->CameraID, ASI_COOLER_ON, enable ? ASI_TRUE : ASI_FALSE, ASI_FALSE) == ASI_SUCCESS);    if (rc == false)        CoolerSP.s = IPS_ALERT;    else    {        CoolerS[0].s = enable ? ISS_ON : ISS_OFF;        CoolerS[1].s = enable ? ISS_OFF: ISS_ON;        CoolerSP.s = IPS_BUSY;    }    IDSetSwitch(&CoolerSP, NULL);    return rc;}

bool XAGYLWheel::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n){    if(strcmp(dev,getDeviceName())==0)    {        if (!strcmp(ResetSP.name, name))        {            IUUpdateSwitch(&ResetSP, states, names, n);            int value = IUFindOnSwitchIndex(&ResetSP);            IUResetSwitch(&ResetSP);            if (value == 3)                value = 6;            bool rc = reset(value);            if (rc)            {                switch (value)                {                case 0:                    DEBUG(INDI::Logger::DBG_SESSION, "Executing hard reboot...");                    break;                case 1:                    DEBUG(INDI::Logger::DBG_SESSION, "Restarting and moving to filter position #1...");                    break;                case 2:                    DEBUG(INDI::Logger::DBG_SESSION, "Calibration removed.");                    break;                case 6:                    DEBUG(INDI::Logger::DBG_SESSION, "Calibrating...");                    break;                }            }            ResetSP.s = rc ? IPS_OK : IPS_ALERT;            IDSetSwitch(&ResetSP, NULL);            return true;        }    }    return INDI::FilterWheel::ISNewSwitch(dev, name, states, names, n);}