bool ioptronHC8406::updateLocation(double latitude, double longitude, double elevation) { INDI_UNUSED(elevation); if (isSimulation()) return true; double final_longitude; if (longitude > 180) final_longitude = longitude - 360.0; else final_longitude = longitude; if (!isSimulation() && setioptronHC8406Longitude(final_longitude) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting site longitude coordinates"); return false; } if (!isSimulation() && setioptronHC8406Latitude(latitude) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting site latitude coordinates"); return false; } char l[32], L[32]; fs_sexa(l, latitude, 3, 3600); fs_sexa(L, longitude, 4, 3600); IDMessage(getDeviceName(), "Site location updated to Lat %.32s - Long %.32s", l, L); return true; }
bool LX200SS2000PC::updateTime(ln_date * utc, double utc_offset) { bool result = true; // This method is largely identical to the one in the LX200Generic class. // The difference is that it ensures that updates that require planetary // data to be recomputed by the SkySensor2000PC are only done when really // necessary because this takes quite some time. if (!isSimulation()) { result = false; struct ln_zonedate ltm; ln_date_to_zonedate(utc, <m, static_cast<long>(utc_offset*3600.0+0.5)); DEBUGF(INDI::Logger::DBG_DEBUG, "New zonetime is %04d-%02d-%02d %02d:%02d:%06.3f (offset=%ld)", ltm.years, ltm.months, ltm.days, ltm.hours, ltm.minutes, ltm.seconds, ltm.gmtoff); JD = ln_get_julian_day(utc); DEBUGF(INDI::Logger::DBG_DEBUG, "New JD is %f", JD); if (setLocalTime(PortFD, ltm.hours, ltm.minutes, static_cast<int>(ltm.seconds+0.5)) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting local time."); } else if (!setCalenderDate(ltm.years, ltm.months, ltm.days)) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting local date."); } // Meade defines UTC Offset as the offset ADDED to local time to yield UTC, which // is the opposite of the standard definition of UTC offset! else if (!setUTCOffset(-static_cast<int>(utc_offset))) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting UTC Offset."); } else { DEBUG(INDI::Logger::DBG_SESSION, "Time updated."); result = true; } } return result; }
bool TCFS::Handshake() { LOGF_DEBUG("%s %s",__FUNCTION__, me); if (isSimulation()) { LOG_INFO("TCF-S: Simulating connection."); currentPosition = simulated_position; return true; } char response[TCFS_MAX_CMD] = { 0 }; if(SetManualMode()) { dispatch_command(FWAKUP); read_tcfs(response); tcflush(PortFD, TCIOFLUSH); LOG_INFO("Successfully connected to TCF-S Focuser in Manual Mode."); // Enable temperature readout FocusTemperatureNP.s = IPS_OK; return true; } tcflush(PortFD, TCIOFLUSH); LOG_ERROR("Failed connection to TCF-S Focuser."); return false; }
bool TCFS::read_tcfs(char *response, bool silent) { int err_code = 0, nbytes_read = 0; char err_msg[TCFS_ERROR_BUFFER]; if (isSimulation()) { strncpy(response, "SIMULATION", TCFS_MAX_CMD); return true; } // Read until encountring a CR if ((err_code = tty_read_section(PortFD, response, 0x0D, 2, &nbytes_read)) != TTY_OK) { if (!silent) { tty_error_msg(err_code, err_msg, 32); LOGF_ERROR("TTY error detected: %s", err_msg); } return false; } // Remove LF & CR response[nbytes_read - 2] = '\0'; LOGF_DEBUG("RES <%s>", response); return true; }
int RoboFocus::updateRFPositionAbsolute(double value) { char rf_cmd[32] ; int robofocus_rc ; DEBUGF(INDI::Logger::DBG_DEBUG, "Moving Absolute Position: %g", value); if (isSimulation()) { simulatedPosition = value; return 0; } rf_cmd[0]= 0 ; if(value > 9999) { sprintf( rf_cmd, "FG0%5d", (int) value) ; } else if(value > 999) { sprintf( rf_cmd, "FG00%4d", (int) value) ; } else if(value > 99) { sprintf( rf_cmd, "FG000%3d", (int) value) ; } else if(value > 9) { sprintf( rf_cmd, "FG0000%2d", (int) value) ; } else { sprintf( rf_cmd, "FG00000%1d", (int) value) ; } if ((robofocus_rc= SendCommand( rf_cmd)) < 0) return robofocus_rc; return 0; }
int RoboFocus::updateRFPositionRelativeOutward(double value) { char rf_cmd[32] ; int robofocus_rc ; //float temp ; DEBUGF(INDI::Logger::DBG_DEBUG, "Update Relative Position Outward: %g", value); if (isSimulation()) { simulatedPosition-= value; //value = simulatedPosition; return 0; } rf_cmd[0]= 0 ; if(value > 9999) { sprintf( rf_cmd, "FO0%5d", (int) value) ; } else if(value > 999) { sprintf( rf_cmd, "FO00%4d", (int) value) ; } else if(value > 99) { sprintf( rf_cmd, "FO000%3d", (int) value) ; } else if(value > 9) { sprintf( rf_cmd, "FO0000%2d", (int) value) ; } else { sprintf( rf_cmd, "FO00000%1d", (int) value) ; } if ((robofocus_rc= SendCommand( rf_cmd)) < 0) return robofocus_rc; return 0; }
int RoboFocus::updateRFTemperature(double *value) { DEBUGF(INDI::Logger::DBG_DEBUG, "Update Temperature: %g", value); float temp ; char rf_cmd[32] ; int robofocus_rc ; strcpy(rf_cmd, "FT000000" ) ; if ((robofocus_rc= SendCommand( rf_cmd)) < 0) return robofocus_rc; if (isSimulation()) snprintf(rf_cmd, 32, "FT%6g", simulatedTemperature); else if ((robofocus_rc= ReadResponse(rf_cmd)) < 0) return robofocus_rc; if (sscanf(rf_cmd, "FT%6f", &temp) < 1) return -1; *value = (double) temp/2.- 273.15; return 0; }
bool ioptronHC8406::updateTime(ln_date *utc, double utc_offset) { struct ln_zonedate ltm; if (isSimulation()) return true; ln_date_to_zonedate(utc, <m, utc_offset * 3600.0); JD = ln_get_julian_day(utc); DEBUGF(INDI::Logger::DBG_DEBUG, "New JD is %.2f", JD); // Set Local Time if (setLocalTime(PortFD, ltm.hours, ltm.minutes, ltm.seconds) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting local time."); return false; } if (setCalenderDate(PortFD, ltm.days, ltm.months, ltm.years) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting local date."); return false; } if (setioptronHC8406UTCOffset(utc_offset) < 0) { DEBUG(INDI::Logger::DBG_ERROR, "Error setting UTC Offset."); return false; } return true; }
int RoboFocus::SendCommand(char *rf_cmd) { int nbytes_written=0, nbytes_read=0, check_ret=0, err_code=0; char rf_cmd_cks[32],robofocus_error[MAXRBUF]; unsigned char val= 0 ; val = CalculateSum( rf_cmd ); for(int i=0; i < 8; i++) rf_cmd_cks[i]= rf_cmd[i] ; rf_cmd_cks[8]= (unsigned char) val ; rf_cmd_cks[9]= 0 ; if (isSimulation()) return 0; tcflush(PortFD, TCIOFLUSH); DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%#02X %#02X %#02X %#02X %#02X %#02X %#02X %#02X %#02X)", rf_cmd_cks[0], rf_cmd_cks[1], rf_cmd_cks[2], rf_cmd_cks[3], rf_cmd_cks[4], rf_cmd_cks[5], rf_cmd_cks[6], rf_cmd_cks[7], rf_cmd_cks[8]); if ( (err_code = tty_write(PortFD, rf_cmd_cks, RF_MAX_CMD, &nbytes_written) != TTY_OK)) { tty_error_msg(err_code, robofocus_error, MAXRBUF); DEBUGF(INDI::Logger::DBG_ERROR, "TTY error detected: %s", robofocus_error); return -1; } return nbytes_written; }
bool SestoSenso::isCommandOK(const char *cmd) { int nbytes_read = 0, rc = -1; char errstr[MAXRBUF], resp[16]; char expectedResp[16]; snprintf(expectedResp, 16, "%sok!", cmd); if (isSimulation()) { strncpy(resp, expectedResp, 16); nbytes_read = strlen(resp)+1; } else { 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 for command %s: %s.", __FUNCTION__, cmd, errstr); return false; } } resp[nbytes_read-1] = '\0'; DEBUGF(INDI::Logger::DBG_DEBUG, "RES <%s>", resp); return (!strcmp(resp, expectedResp)); }
IPState SestoSenso::MoveAbsFocuser(uint32_t targetTicks) { targetPos = targetTicks; int nbytes_written = 0, rc = -1; char errstr[MAXRBUF]; char cmd[16]={0}; snprintf(cmd, 16, "#GT%d!", targetTicks); DEBUGF(INDI::Logger::DBG_DEBUG, "CMD <%s>", cmd); if (isSimulation() == false) { if ((rc = tty_write(PortFD, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(rc, errstr, MAXRBUF); DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr); return IPS_ALERT; } } return IPS_BUSY; /*if (isCommandOK("GT")) { FocusAbsPosNP.s = IPS_BUSY; return IPS_BUSY; } return IPS_ALERT; */ }
bool SestoSenso::sync(uint32_t newPosition) { int nbytes_written = 0, rc = -1; char errstr[MAXRBUF]; char cmd[16]={0}; snprintf(cmd, 16, "#SP%d!", newPosition); DEBUGF(INDI::Logger::DBG_DEBUG, "CMD <%s>", cmd); if (isSimulation()) { FocusAbsPosN[0].value = newPosition; } else { tcflush(PortFD, TCIOFLUSH); // Sync if ((rc = tty_write(PortFD, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(rc, errstr, MAXRBUF); DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr); return false; } } return isCommandOK("SP"); }
bool FlipFlat::getBrightness() { if (isSimulation()) { return true; } char response[FLAT_RES]={0}; if (!sendCommand(">J000", response)) return false; char brightnessString[4] = { 0 }; snprintf(brightnessString, 4, "%s", response + 4); int brightnessValue = 0; int rc = sscanf(brightnessString, "%d", &brightnessValue); if (rc <= 0) { LOGF_ERROR("Unable to parse brightness value (%s)", response); return false; } if (brightnessValue != prevBrightness) { prevBrightness = brightnessValue; LightIntensityN[0].value = brightnessValue; IDSetNumber(&LightIntensityNP, nullptr); } return true; }
bool FlipFlat::EnableLightBox(bool enable) { char command[FLAT_CMD]; char response[FLAT_RES]; if (isFlipFlat && ParkCapS[1].s == ISS_ON) { LOG_ERROR("Cannot control light while cap is unparked."); return false; } if (isSimulation()) return true; if (enable) strncpy(command, ">L000", FLAT_CMD); else strncpy(command, ">D000", FLAT_CMD); if (!sendCommand(command, response)) return false; char expectedResponse[FLAT_RES]; if (enable) snprintf(expectedResponse, FLAT_RES, "*L%02d000", productID); else snprintf(expectedResponse, FLAT_RES, "*D%02d000", productID); if (strcmp(response, expectedResponse) == 0) return true; return false; }
IPState FlipFlat::UnParkCap() { if (isSimulation()) { simulationWorkCounter = 3; return IPS_BUSY; } char response[FLAT_RES]; if (!sendCommand(">O000", response)) return IPS_ALERT; char expectedResponse[FLAT_RES]; snprintf(expectedResponse, FLAT_RES, "*O%02d000", productID); if (strcmp(response, expectedResponse) == 0) { // Set cover status to random value outside of range to force it to refresh prevCoverStatus = 10; IERmTimer(unparkTimeoutID); unparkTimeoutID = IEAddTimer(30000, unparkTimeoutHelper, this); return IPS_BUSY; } else return IPS_ALERT; }
int RoboFocus::updateRFPosition(double *value) { float temp ; char rf_cmd[RF_MAX_CMD] ; int robofocus_rc ; DEBUG(INDI::Logger::DBG_DEBUG, "Querying Position..."); if (isSimulation()) { *value = simulatedPosition; return 0; } strcpy(rf_cmd, "FG000000" ) ; if ((robofocus_rc= SendCommand(rf_cmd)) < 0) return robofocus_rc; if ((robofocus_rc= ReadResponse(rf_cmd)) < 0) return robofocus_rc; if (sscanf(rf_cmd, "FD%6f", &temp) < 1) return -1; *value = (double) temp; DEBUGF(INDI::Logger::DBG_DEBUG, "Position: %g", *value); return 0; }
int ioptronHC8406::setMoveRate(int rate,int move_type) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; int nbytes_written = 0; if (isSimulation()) { return 0; } if (rate>=0) { switch (move_type) { case USE_GUIDE_SPEED: snprintf(cmd, 16, ":RG%0d#", rate); break; case USE_CENTERING_SPEED: snprintf(cmd, 16, ":RC%0d#", rate); break; case USE_SLEW_SPEED: snprintf(cmd, 16, ":RS%0d#", rate); //NOT WORK!! break; default: break; } } else { switch (move_type) { case USE_GUIDE_SPEED: snprintf(cmd, 16, ":RG#"); break; case USE_CENTERING_SPEED: snprintf(cmd, 16, ":RC#"); //NOT WORK!! break; case USE_SLEW_SPEED: snprintf(cmd, 16, ":RS#"); //NOT WORK!! break; default: break; } } DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); tcflush(PortFD, TCIFLUSH); 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 errcode; } return 0; }
bool LX200_16::handleAltAzSlew() { char altStr[64], azStr[64]; if (HorizontalCoordsNP.s == IPS_BUSY) { abortSlew(PortFD); // sleep for 100 mseconds usleep(100000); } if (isSimulation() == false && slewToAltAz(PortFD)) { HorizontalCoordsNP.s = IPS_ALERT; IDSetNumber(&HorizontalCoordsNP, "Slew is not possible."); return false; } HorizontalCoordsNP.s = IPS_BUSY; fs_sexa(azStr, targetAZ, 2, 3600); fs_sexa(altStr, targetALT, 2, 3600); TrackState = SCOPE_SLEWING; IDSetNumber(&HorizontalCoordsNP, "Slewing to Alt %s - Az %s", altStr, azStr); return true; }
bool ATIKCCD::Disconnect() { ImageState tState; LOGF_DEBUG("Closing %s...", name); stopTimerNS(); stopTimerWE(); RemoveTimer(genTimerID); genTimerID = -1; pthread_mutex_lock(&condMutex); tState = threadState; threadRequest = StateTerminate; pthread_cond_signal(&cv); pthread_mutex_unlock(&condMutex); pthread_join(imagingThread, nullptr); tState = StateNone; if (isSimulation() == false) { if (tState == StateExposure) ArtemisStopExposure(hCam); ArtemisDisconnect(hCam); } LOG_INFO("Camera is offline."); return true; }
bool SynscanDriver::Sync(double ra, double dec) { char cmd[SYN_RES] = {0}, res[SYN_RES] = {0}; TargetRA = ra; TargetDE = dec; if (isSimulation()) return true; // INDI is JNow. Synscan Controll uses J2000 Epoch ln_equ_posn epochPos { 0, 0 }, J2000Pos { 0, 0 }; epochPos.ra = ra * 15.0; epochPos.dec = dec; // Synscan accepts J2000 coordinates so we need to convert from JNow to J2000 ln_get_equ_prec2(&epochPos, ln_get_julian_from_sys(), JD2000, &J2000Pos); // Mount deals in J2000 coords. uint32_t n1 = J2000Pos.ra / 360 * 0x100000000; uint32_t n2 = J2000Pos.dec / 360 * 0x100000000; LOGF_DEBUG("Sync - JNow RA: %g JNow DE: %g J2000 RA: %g J2000 DE: %g", ra, dec, J2000Pos.ra / 15.0, J2000Pos.dec); snprintf(cmd, SYN_RES, "s%08X,%08X", n1, n2); return sendCommand(cmd, res, 18); }
void MICCD::updateTemperature() { float ccdtemp = 0; float ccdpower = 0; int err = 0; if (isSimulation()) { ccdtemp = TemperatureN[0].value; if (TemperatureN[0].value < TemperatureRequest) ccdtemp += TEMP_THRESHOLD; else if (TemperatureN[0].value > TemperatureRequest) ccdtemp -= TEMP_THRESHOLD; ccdpower = 30; } else { if (gxccd_get_value(cameraHandle, GV_CHIP_TEMPERATURE, &ccdtemp) < 0) { char errorStr[MAX_ERROR_LEN]; gxccd_get_last_error(cameraHandle, errorStr, sizeof(errorStr)); LOGF_ERROR("Getting temperature failed: %s.", errorStr); err |= 1; } if (gxccd_get_value(cameraHandle, GV_POWER_UTILIZATION, &ccdpower) < 0) { char errorStr[MAX_ERROR_LEN]; gxccd_get_last_error(cameraHandle, errorStr, sizeof(errorStr)); LOGF_ERROR("Getting voltage failed: %s.", errorStr); err |= 2; } } TemperatureN[0].value = ccdtemp; CoolerN[0].value = ccdpower * 100.0; if (TemperatureNP.s == IPS_BUSY && fabs(TemperatureN[0].value - TemperatureRequest) <= TEMP_THRESHOLD) { // end of temperature ramp TemperatureN[0].value = TemperatureRequest; TemperatureNP.s = IPS_OK; } if (err) { if (err & 1) TemperatureNP.s = IPS_ALERT; if (err & 2) CoolerNP.s = IPS_ALERT; } else { CoolerNP.s = IPS_OK; } IDSetNumber(&TemperatureNP, nullptr); IDSetNumber(&CoolerNP, nullptr); temperatureID = IEAddTimer(POLLMS, MICCD::updateTemperatureHelper, this); }
bool SynscanDriver::updateTime(ln_date * utc, double utc_offset) { char cmd[SYN_RES] = {0}, res[SYN_RES] = {0}; // start by formatting a time for the hand controller // we are going to set controller to local time struct ln_zonedate ltm; ln_date_to_zonedate(utc, <m, utc_offset * 3600.0); int yr = ltm.years; yr = yr % 100; cmd[0] = 'H'; cmd[1] = ltm.hours; cmd[2] = ltm.minutes; cmd[3] = static_cast<char>(ltm.seconds); cmd[4] = ltm.months; cmd[5] = ltm.days; cmd[6] = yr; // offset from utc so hand controller is running in local time cmd[7] = utc_offset > 0 ? static_cast<uint8_t>(utc_offset) : static_cast<uint8_t>(256 + utc_offset); // and no daylight savings adjustments, it's already included in the offset cmd[8] = 0; LOGF_INFO("Setting mount date/time to %04d-%02d-%02d %d:%02d:%02d UTC Offset: %.2f", ltm.years, ltm.months, ltm.days, ltm.hours, ltm.minutes, static_cast<int>(rint(ltm.seconds)), utc_offset); if (isSimulation()) return true; return sendCommand(cmd, res, 9); }
/* Downloads the image from the CCD. */ int MICCD::grabImage() { unsigned char *image = (unsigned char *) PrimaryCCD.getFrameBuffer(); if (isSimulation()) { int height = PrimaryCCD.getSubH() / PrimaryCCD.getBinY(); int width = PrimaryCCD.getSubW() / PrimaryCCD.getBinX(); uint16_t *buffer = (uint16_t *) image; for (int i = 0; i < height; i++) for (int j = 0; j < width; j++) buffer[i * width + j] = rand() % UINT16_MAX; } else { int ret = 0; if (gxccd_read_image(cameraHandle, image, PrimaryCCD.getFrameBufferSize()) < 0) { char errorStr[MAX_ERROR_LEN]; gxccd_get_last_error(cameraHandle, errorStr, sizeof(errorStr)); DEBUGF(INDI::Logger::DBG_ERROR, "Error getting image: %s.", errorStr); } } if (ExposureRequest > POLLMS * 5) DEBUG(INDI::Logger::DBG_SESSION, "Download complete."); downloading = false; ExposureComplete(&PrimaryCCD); return 0; }
bool MICCD::StartExposure(float duration) { imageFrameType = PrimaryCCD.getFrameType(); useShutter = (imageFrameType == INDI::CCDChip::LIGHT_FRAME || imageFrameType == INDI::CCDChip::FLAT_FRAME); if (!isSimulation()) { // read modes in G2/G3/G4 cameras are in inverse order, we have to calculate correct value int mode, prm; gxccd_get_integer_parameter(cameraHandle, GIP_PREVIEW_READ_MODE, &prm); if (prm == 0) // preview mode == 0 means smaller G0/G1 cameras mode = IUFindOnSwitchIndex(&ReadModeSP); else mode = prm - IUFindOnSwitchIndex(&ReadModeSP); gxccd_set_read_mode(cameraHandle, mode); // send binned coords int x = PrimaryCCD.getSubX() / PrimaryCCD.getBinX(); int y = PrimaryCCD.getSubY() / PrimaryCCD.getBinY(); int w = PrimaryCCD.getSubW() / PrimaryCCD.getBinX(); int d = PrimaryCCD.getSubH() / PrimaryCCD.getBinY(); gxccd_start_exposure(cameraHandle, duration, useShutter, x, y, w, d); } ExposureRequest = duration; PrimaryCCD.setExposureDuration(duration); gettimeofday(&ExpStart, nullptr); InExposure = true; downloading = false; LOGF_DEBUG("Taking a %.3f seconds frame...", ExposureRequest); return true; }
bool ASICCD::Connect() { DEBUGF(INDI::Logger::DBG_DEBUG, "Attempting to open %s...", name); sim = isSimulation(); ASI_ERROR_CODE errCode = ASI_SUCCESS; if (sim == false) errCode = ASIOpenCamera(m_camInfo->CameraID); if (errCode != ASI_SUCCESS) { DEBUGF(INDI::Logger::DBG_ERROR, "Error connecting to the CCD (%d)", errCode); return false; } TemperatureUpdateCounter = 0; #ifndef OSX_EMBEDED_MODE pthread_create( &primary_thread, NULL, &streamVideoHelper, this); #endif /* Success! */ DEBUG(INDI::Logger::DBG_SESSION, "CCD is online. Retrieving basic data."); return true; }
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 FishCampCCD::Connect() { sim = isSimulation(); if (sim) { LOG_INFO("Simulated Fishcamp is online."); return true; } if (fcUsb_haveCamera()) { fcUsb_cmd_setReadMode(cameraNum, fc_classicDataXfr, fc_16b_data); fcUsb_cmd_setCameraGain(cameraNum, GainN[0].value); fcUsb_cmd_setRoi(cameraNum, 0, 0, camInfo.width - 1, camInfo.height - 1); if (fcUsb_cmd_getTECInPowerOK(cameraNum)) CoolerNP.s = IPS_OK; LOG_INFO("Fishcamp CCD is online."); return true; } else { LOG_ERROR("Cannot find Fishcamp CCD. Please check the logfile and try again."); return false; } }
int NFocus::setNFMaxPosition(double *value) { float temp; char rf_cmd[32]; char vl_tmp[6]; int ret_read_tmp; char waste[1]; if (isSimulation()) return 0; if (*value == MAXTRAVEL_READOUT) { strncpy(rf_cmd, "FL000000", 9); } else { rf_cmd[0] = 'F'; rf_cmd[1] = 'L'; rf_cmd[2] = '0'; if (*value > 9999) { snprintf(vl_tmp, 6, "%5d", (int)*value); } else if (*value > 999) { snprintf(vl_tmp, 6, "0%4d", (int)*value); } else if (*value > 99) { snprintf(vl_tmp, 6, "00%3d", (int)*value); } else if (*value > 9) { snprintf(vl_tmp, 6, "000%2d", (int)*value); } else { snprintf(vl_tmp, 6, "0000%1d", (int)*value); } rf_cmd[3] = vl_tmp[0]; rf_cmd[4] = vl_tmp[1]; rf_cmd[5] = vl_tmp[2]; rf_cmd[6] = vl_tmp[3]; rf_cmd[7] = vl_tmp[4]; rf_cmd[8] = 0; } if ((ret_read_tmp = SendCommand(rf_cmd)) < 0) return ret_read_tmp; if (sscanf(rf_cmd, "FL%1c%5f", waste, &temp) < 1) return -1; *value = (double)temp; return 0; }
bool MICCD::Connect() { uint32_t cap = 0; if (isSimulation()) { LOGF_INFO("Connected to %s", name); cap = CCD_CAN_SUBFRAME | CCD_CAN_ABORT | CCD_CAN_BIN | CCD_HAS_SHUTTER | CCD_HAS_COOLER; SetCCDCapability(cap); numFilters = 5; return true; } if (!cameraHandle) { if (isEth) cameraHandle = gxccd_initialize_eth(cameraId); else cameraHandle = gxccd_initialize_usb(cameraId); } if (!cameraHandle) { LOGF_ERROR("Error connecting to %s.", name); return false; } LOGF_INFO("Connected to %s.", name); bool value; cap = CCD_CAN_ABORT | CCD_CAN_BIN; gxccd_get_boolean_parameter(cameraHandle, GBP_SUB_FRAME, &value); if (value) cap |= CCD_CAN_SUBFRAME; gxccd_get_boolean_parameter(cameraHandle, GBP_GUIDE, &value); if (value) cap |= CCD_HAS_ST4_PORT; gxccd_get_boolean_parameter(cameraHandle, GBP_SHUTTER, &value); if (value) cap |= CCD_HAS_SHUTTER; gxccd_get_boolean_parameter(cameraHandle, GBP_COOLER, &value); if (value) cap |= CCD_HAS_COOLER; gxccd_get_boolean_parameter(cameraHandle, GBP_GAIN, &hasGain); gxccd_get_boolean_parameter(cameraHandle, GBP_PREFLASH, &canDoPreflash); SetCCDCapability(cap); return true; }
bool SynscanDriver::Goto(double ra, double dec) { char cmd[SYN_RES] = {0}, res[SYN_RES] = {0}; TargetRA = ra; TargetDE = dec; if (isSimulation()) return true; // INDI is JNow. Synscan Controll uses J2000 Epoch ln_equ_posn epochPos { 0, 0 }, J2000Pos { 0, 0 }; epochPos.ra = ra * 15.0; epochPos.dec = dec; // For Alt/Az mounts, we must issue Goto Alt/Az if (m_isAltAz) { struct ln_lnlat_posn lnobserver; struct ln_hrz_posn lnaltaz; lnobserver.lng = LocationN[LOCATION_LONGITUDE].value; if (lnobserver.lng > 180) lnobserver.lng -= 360; lnobserver.lat = LocationN[LOCATION_LATITUDE].value; ln_get_hrz_from_equ(&epochPos, &lnobserver, ln_get_julian_from_sys(), &lnaltaz); /* libnova measures azimuth from south towards west */ double az = range360(lnaltaz.az + 180); double al = lnaltaz.alt; return GotoAzAlt(az, al); } // Synscan accepts J2000 coordinates so we need to convert from JNow to J2000 ln_get_equ_prec2(&epochPos, ln_get_julian_from_sys(), JD2000, &J2000Pos); // Mount deals in J2000 coords. uint32_t n1 = J2000Pos.ra / 360 * 0x100000000; uint32_t n2 = J2000Pos.dec / 360 * 0x100000000; LOGF_DEBUG("Goto - JNow RA: %g JNow DE: %g J2000 RA: %g J2000 DE: %g", ra, dec, J2000Pos.ra / 15.0, J2000Pos.dec); snprintf(cmd, SYN_RES, "r%08X,%08X", n1, n2); if (sendCommand(cmd, res, 18)) { TrackState = SCOPE_SLEWING; HorizontalCoordsNP.s = IPS_BUSY; IDSetNumber(&HorizontalCoordsNP, nullptr); return true; } return false; }