int read_dcraw(const char *filename, uint8_t **memptr, size_t *memsize, int *n_axis, int *w, int *h, int *bitsperpixel) { struct dcraw_header header; FILE *handle = NULL; char *cmd; if (dcraw_parse_header_info(filename, &header) || ! header.width || ! header.height) { DEBUGDEVICE(device, INDI::Logger::DBG_DEBUG, "read_file_from_dcraw: failed to parse header"); return -1; } DEBUGFDEVICE(device, INDI::Logger::DBG_DEBUG, "Reading exposure %d x %d", header.width, header.height); asprintf(&cmd, "%s -c -t 0 -4 -D %s", dcraw_cmd, filename); DEBUGFDEVICE(device, INDI::Logger::DBG_DEBUG, "%s", cmd); handle = popen(cmd, "r"); free(cmd); if (handle == NULL) { DEBUGDEVICE(device, INDI::Logger::DBG_DEBUG, "read_file_from_dcraw: failed to run dcraw"); return -1; } int rc= read_ppm(handle, &header, memptr, memsize, n_axis, w, h, bitsperpixel); pclose(handle); return rc; }
bool EQModError::DefaultHandleException(EQMod *device) { switch (severity) { case EQModError::ErrInvalidCmd: case EQModError::ErrCmdFailed: case EQModError::ErrInvalidParameter: DEBUGFDEVICE(device->getDeviceName(), INDI::Logger::DBG_WARNING, "Warning: %s -> %s", severityString(), message); return true; case EQModError::ErrDisconnect: DEBUGFDEVICE(device->getDeviceName(), INDI::Logger::DBG_ERROR, "Error: %s -> %s", severityString(), message); //device->Disconnect(); device->abnormalDisconnect(); return false; default: DEBUGFDEVICE(device->getDeviceName(), INDI::Logger::DBG_ERROR, "Unhandled exception: %s -> %s", severityString(), message); //device->Disconnect(); device->abnormalDisconnect(); return false; //break; } }
bool stop_ieqpro_motion(int fd, IEQ_DIRECTION dir) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; switch (dir) { case IEQ_N: case IEQ_S: strcpy(cmd, ":qD#"); break; case IEQ_W: case IEQ_E: strcpy(cmd, ":qR#"); break; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool get_ieqpro_radec_firmware(int fd, FirmwareInfo *info) { char cmd[] = ":FW2#"; int errcode = 0; char errmsg[MAXRBUF]; char response[16]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strcpy(response, "140324140101#"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read_section(fd, response, '#', IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); if (nbytes_read == 13) { char ra[6], dec[6]; strncpy(ra, response, 6); strncpy(dec, response + 6, 6); info->RAFirmware.assign(ra, 6); info->DEFirmware.assign(dec, 6); tcflush(fd, TCIFLUSH); return true; } } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 13.", nbytes_read); return false; }
bool set_ieqpro_dec(int fd, double dec) { char cmd[32]; char sign; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; if (dec >= 0) sign = '+'; else sign = '-'; // Send as 0.01 arcseconds resolution int ieqValue = fabs(dec) * 60 * 60 * 100; snprintf(cmd, 32, ":Sd%c%08d#", sign, ieqValue); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { simData.dec = dec; strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool slew_ieqpro(int fd) { char cmd[] = ":MS#"; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { simInfo.systemStatus = ST_SLEWING; strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); if (!strcmp(response, "1")) { tcflush(fd, TCIFLUSH); return true; } else { DEBUGDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Requested object is below horizon."); tcflush(fd, TCIFLUSH); return false; } } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool get_ieqpro_status(int fd, IEQInfo *info) { char cmd[] = ":GAS#"; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_EXTRA_1, "CMD (%s)", cmd); if (ieqpro_simulation) { snprintf(response, 8, "%d%d%d%d%d%d#", simInfo.gpsStatus, simInfo.systemStatus, simInfo.trackRate, simInfo.slewRate+1, simInfo.timeSource+1, simInfo.hemisphere); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read_section(fd, response, '#', IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_EXTRA_1, "RES (%s)", response); if (nbytes_read == 7) { info->gpsStatus = (IEQ_GPS_STATUS) (response[0] - '0'); info->systemStatus = (IEQ_SYSTEM_STATUS) (response[1] - '0'); info->trackRate = (IEQ_TRACK_RATE) (response[2] - '0'); info->slewRate = (IEQ_SLEW_RATE) (response[3] - '0' - 1); info->timeSource = (IEQ_TIME_SOURCE) (response[4] - '0' - 1); info->hemisphere = (IEQ_HEMISPHERE) (response[5] - '0'); tcflush(fd, TCIFLUSH); return true; } } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 7.", nbytes_read); return false; }
bool set_ieqpro_utc_offset(int fd, double offset) { char cmd[16]; char sign; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; if (offset >= 0) sign = '+'; else sign = '-'; int offset_minutes = fabs(offset) * 60.0; snprintf(cmd, 16, ":SG%c%03d#", sign, offset_minutes); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool Driver::sendCommand(const char *command, int count, char *response, uint8_t timeout, uint8_t debugLog) { int errCode = 0; int nbytes_read = 0; int nbytes_written = 0; char errMsg[MAXRBUF]; char res[IOP_BUFFER] = {0}; DEBUGFDEVICE(m_DeviceName, debugLog, "CMD <%s>", command); if (m_Simulation) return true; tcflush(PortFD, TCIOFLUSH); if ((errCode = tty_write(PortFD, command, strlen(command), &nbytes_written)) != TTY_OK) { tty_error_msg(errCode, errMsg, MAXRBUF); DEBUGFDEVICE(m_DeviceName, INDI::Logger::DBG_ERROR, "Write Command Error: %s", errMsg); return false; } if (count == 0) return true; if (count == -1) errCode = tty_read_section(PortFD, res, '#', timeout, &nbytes_read); else errCode = tty_read(PortFD, res, count, timeout, &nbytes_read); if (errCode != TTY_OK) { tty_error_msg(errCode, errMsg, MAXRBUF); DEBUGFDEVICE(m_DeviceName, INDI::Logger::DBG_ERROR, "Read Command Error: %s", errMsg); return false; } // Remove the extra # if (count == -1) res[nbytes_read-1] = 0; DEBUGFDEVICE(m_DeviceName, debugLog, "RES <%s>", res); tcflush(PortFD, TCIOFLUSH); // Copy response to buffer if (response) strncpy(response, res, IOP_BUFFER); if (count == -1 || (count == 1 && res[0] == '1') || count == nbytes_read) return true; return false; }
int dcraw_parse_header_info(const char *filename, struct dcraw_header *header) { FILE *handle; char line[256], cfa[80]; char *cmd, timestr[10], month[10], daystr[10]; int day, year; float r, g, b, gp; memset(header, 0, sizeof(struct dcraw_header)); asprintf(&cmd, "%s -i -t 0 -v %s 2> /dev/null", dcraw_cmd, filename); DEBUGFDEVICE(device, INDI::Logger::DBG_DEBUG, "%s", cmd); handle = popen(cmd, "r"); free(cmd); if (handle == NULL) { return 1; } while (fgets(line, sizeof(line), handle)) { DEBUGFDEVICE(device, INDI::Logger::DBG_DEBUG, "%s", line); if (sscanf(line, "Timestamp: %s %s %d %s %d", daystr, month, &day, timestr, &year) ) header->time = dcraw_parse_time(month, day, year, timestr); else if (sscanf(line, "Shutter: 1/%f sec", &header->exposure) ) header->exposure = 1.0 / header->exposure; else if (sscanf(line, "Shutter: %f sec", &header->exposure) ) ; /*#ifdef USE_THUMB_SIZE else if (sscanf(line, "Thumb size: %d x %d", &header->width, &header->height) ) ; #else*/ else if (sscanf(line, "Output size: %d x %d", &header->width, &header->height) ) ; //#endif else if (sscanf(line, "Filter pattern: %s", cfa) ) { if(strncmp(cfa, "RGGBRGGBRGGBRGGB", sizeof(cfa)) == 0) { header->cfa_type = CFA_RGGB; } } else if (sscanf(line, "Camera multipliers: %f %f %f %f", &r, &g, &b, &gp) && r > 0.0) { header->wbr = 1.0; header->wbg = g/r; header->wbgp = gp/r; header->wbb = b/r; } } pclose(handle); return 0; }
bool check_ieqpro_connection(int fd) { char initCMD[] = ":V#"; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; DEBUGDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "Initializing IOptron using :V# CMD..."); for (int i=0; i < 2; i++) { if (ieqpro_simulation) { strcpy(response, "V1.00#"); nbytes_read= strlen(response); } else { if ( (errcode = tty_write(fd, initCMD, 3, &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); usleep(50000); continue; } if ( (errcode = tty_read_section(fd, response, '#', IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); usleep(50000); continue; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); if (!strcmp(response, "V1.00#")) return true; } usleep(50000); } return false; }
bool set_ieqpro_daylight_saving(int fd, bool enabled) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; if (enabled) strcpy(cmd, ":SDS1#"); else strcpy(cmd, ":SDS0#"); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool set_ieqpro_guide_rate(int fd, double rate) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; int num = rate * 100; snprintf(cmd, 16, ":RG%03d#", num ); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { simData.guide_rate = rate; strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool start_ieqpro_guide(int fd, IEQ_DIRECTION dir, int ms) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; char dir_c; switch (dir) { case IEQ_N: dir_c = 'n'; break; case IEQ_S: dir_c = 's'; break; case IEQ_W: dir_c = 'w'; break; case IEQ_E: dir_c = 'e'; break; } snprintf(cmd, 16, ":M%c%05d#", dir_c, ms ); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) return true; else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } tcflush(fd, TCIFLUSH); 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); }
TTYBase::TTY_RESPONSE TTYBase::write(const uint8_t *buffer, uint32_t nbytes, uint32_t *nbytes_written) { #ifdef _WIN32 return TTY_ERRNO; #else if (m_PortFD == -1) return TTY_ERRNO; int bytes_w = 0; *nbytes_written = 0; while (nbytes > 0) { bytes_w = ::write(m_PortFD, buffer + (*nbytes_written), nbytes); if (bytes_w < 0) return TTY_WRITE_ERROR; for (uint32_t i = *nbytes_written; i < bytes_w+*nbytes_written; i++) DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%s: buffer[%d]=%#X (%c)", __FUNCTION__, i, buffer[i], buffer[i]); *nbytes_written += bytes_w; nbytes -= bytes_w; } return TTY_OK; #endif }
bool unpark_ieqpro(int fd) { char cmd[] = ":MP0#"; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { set_sim_system_status(ST_STOPPED); strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
TTYBase::TTY_RESPONSE TTYBase::read(uint8_t *buffer, uint32_t nbytes, uint8_t timeout, uint32_t *nbytes_read) { #ifdef _WIN32 return TTY_ERRNO; #else if (m_PortFD == -1) return TTY_ERRNO; uint32_t numBytesToRead = nbytes; int bytesRead = 0; TTY_RESPONSE timeoutResponse = TTY_OK; *nbytes_read = 0; if (nbytes <= 0) return TTY_PARAM_ERROR; DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%s: Request to read %d bytes with %d timeout for m_PortFD %d", __FUNCTION__, nbytes, timeout, m_PortFD); while (numBytesToRead > 0) { if ((timeoutResponse = checkTimeout(timeout))) return timeoutResponse; bytesRead = ::read(m_PortFD, buffer + (*nbytes_read), numBytesToRead); if (bytesRead < 0) return TTY_READ_ERROR; DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%d bytes read and %d bytes remaining...", bytesRead, numBytesToRead - bytesRead); for (uint32_t i = *nbytes_read; i < (*nbytes_read + bytesRead); i++) DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%s: buffer[%d]=%#X (%c)", __FUNCTION__, i, buffer[i], buffer[i]); *nbytes_read += bytesRead; numBytesToRead -= bytesRead; } return TTY_OK; #endif }
TTYBase::TTY_RESPONSE TTYBase::readSection(uint8_t *buffer, uint32_t nsize, uint8_t stop_byte, uint8_t timeout, uint32_t *nbytes_read) { #ifdef _WIN32 return TTY_ERRNO; #else if (m_PortFD == -1) return TTY_ERRNO; int bytesRead = 0; TTY_RESPONSE timeoutResponse = TTY_OK; *nbytes_read = 0; memset(buffer, 0, nsize); uint8_t *read_char = nullptr; DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%s: Request to read until stop char '%#02X' with %d timeout for m_PortFD %d", __FUNCTION__, stop_byte, timeout, m_PortFD); for (;;) { if ((timeoutResponse = checkTimeout(timeout))) return timeoutResponse; read_char = reinterpret_cast<uint8_t*>(buffer + *nbytes_read); bytesRead = ::read(m_PortFD, read_char, 1); if (bytesRead < 0) return TTY_READ_ERROR; DEBUGFDEVICE(m_DriverName, m_DebugChannel, "%s: buffer[%d]=%#X (%c)", __FUNCTION__, (*nbytes_read), *read_char, *read_char); (*nbytes_read)++; if (*read_char == stop_byte) return TTY_OK; else if (*nbytes_read >= nsize) return TTY_OVERFLOW; } #endif }
bool start_ieqpro_motion(int fd, IEQ_DIRECTION dir) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; int nbytes_written=0; switch (dir) { case IEQ_N: strcpy(cmd, ":mn#"); break; case IEQ_S: strcpy(cmd, ":ms#"); break; case IEQ_W: strcpy(cmd, ":mw#"); break; case IEQ_E: strcpy(cmd, ":me#"); break; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) return true; if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } tcflush(fd, TCIFLUSH); return true; }
bool get_ieqpro_guide_rate(int fd, double *rate) { char cmd[] = ":AG#"; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { snprintf(response, 8, "%3d#", (int) (simData.guide_rate * 100)); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 4, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); int rate_num; if (sscanf(response, "%d#", &rate_num) > 0) { *rate = rate_num / 100.0; tcflush(fd, TCIFLUSH); return true; } else { DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Error: Malformed result (%s).", response); return false; } } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
bool RotatorInterface::processNumber(const char *dev, const char *name, double values[], char *names[], int n) { INDI_UNUSED(names); INDI_UNUSED(n); if (dev != nullptr && strcmp(dev, m_defaultDevice->getDeviceName()) == 0) { //////////////////////////////////////////// // Move Absolute Angle //////////////////////////////////////////// if (strcmp(name, GotoRotatorNP.name) == 0) { if (values[0] == GotoRotatorN[0].value) { GotoRotatorNP.s = IPS_OK; IDSetNumber(&GotoRotatorNP, nullptr); return true; } GotoRotatorNP.s = MoveRotator(values[0]); IDSetNumber(&GotoRotatorNP, nullptr); if (GotoRotatorNP.s == IPS_BUSY) DEBUGFDEVICE(m_defaultDevice->getDeviceName(), Logger::DBG_SESSION, "Rotator moving to %.2f degrees...", values[0]); return true; } //////////////////////////////////////////// // Sync //////////////////////////////////////////// else if (strcmp(name, SyncRotatorNP.name) == 0) { if (values[0] == GotoRotatorN[0].value) { SyncRotatorNP.s = IPS_OK; IDSetNumber(&SyncRotatorNP, nullptr); return true; } bool rc = SyncRotator(values[0]); SyncRotatorNP.s = rc ? IPS_OK : IPS_ALERT; if (rc) SyncRotatorN[0].value = values[0]; IDSetNumber(&SyncRotatorNP, nullptr); return true; } } return false; }
bool Controller::ISNewText (const char * dev, const char * name, char * texts[], char * names[], int n) { if(strcmp(dev,device->getDeviceName())==0) { if (!strcmp(name, "JOYSTICKSETTINGS") && n <= JoystickSettingTP.ntp) { for (int i=0; i < JoystickSettingTP.ntp; i++) { IText * tp = IUFindText(&JoystickSettingTP, names[i]); if (tp) { ControllerType cType = getControllerType(texts[i]); ControllerType myType = *((ControllerType *) JoystickSettingT[i].aux0); if (cType != myType) { JoystickSettingTP.s = IPS_ALERT; IDSetText(&JoystickSettingTP, NULL); DEBUGFDEVICE(dev, INDI::Logger::DBG_ERROR, "Cannot change controller type to %s.", texts[i]); return false; } } } IUUpdateText(&JoystickSettingTP, texts, names, n); for (int i=0; i < n; i++) { if (strstr(JoystickSettingT[i].text, "JOYSTICK_")) IDSnoopDevice("Joystick", JoystickSettingT[i].text); } JoystickSettingTP.s = IPS_OK; IDSetText(&JoystickSettingTP, NULL); return true; } } return false; }
bool RotatorInterface::processSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { INDI_UNUSED(states); INDI_UNUSED(names); INDI_UNUSED(n); if (dev != nullptr && strcmp(dev, m_defaultDevice->getDeviceName()) == 0) { //////////////////////////////////////////// // Abort //////////////////////////////////////////// if (strcmp(name, AbortRotatorSP.name) == 0) { AbortRotatorSP.s = AbortRotator() ? IPS_OK : IPS_ALERT; IDSetSwitch(&AbortRotatorSP, nullptr); if (AbortRotatorSP.s == IPS_OK) { if (GotoRotatorNP.s != IPS_OK) { GotoRotatorNP.s = IPS_OK; IDSetNumber(&GotoRotatorNP, nullptr); } } return true; } //////////////////////////////////////////// // Home //////////////////////////////////////////// else if (strcmp(name, HomeRotatorSP.name) == 0) { HomeRotatorSP.s = HomeRotator(); IUResetSwitch(&HomeRotatorSP); if (HomeRotatorSP.s == IPS_BUSY) HomeRotatorS[0].s = ISS_ON; IDSetSwitch(&HomeRotatorSP, nullptr); return true; } //////////////////////////////////////////// // Reverse Rotator //////////////////////////////////////////// else if (strcmp(name, ReverseRotatorSP.name) == 0) { bool rc = false; bool enabled = (!strcmp(IUFindOnSwitchName(states, names, n), "ENABLED")); rc = ReverseRotator(enabled); if (rc) { IUUpdateSwitch(&ReverseRotatorSP, states, names, n); ReverseRotatorSP.s = IPS_OK; DEBUGFDEVICE(m_defaultDevice->getDeviceName(), Logger::DBG_SESSION, "Rotator direction is %s.", (enabled ? "reversed" : "normal")); } else { ReverseRotatorSP.s = IPS_ALERT; DEBUGDEVICE(m_defaultDevice->getDeviceName(), Logger::DBG_SESSION, "Rotator reverse direction failed."); } IDSetSwitch(&ReverseRotatorSP, nullptr); return true; } } return false; }
bool set_ieqpro_track_mode(int fd, IEQ_TRACK_RATE rate) { char cmd[16]; int errcode = 0; char errmsg[MAXRBUF]; char response[8]; int nbytes_read=0; int nbytes_written=0; switch (rate) { case TR_SIDEREAL: strcpy(cmd, ":RT0#"); break; case TR_LUNAR: strcpy(cmd, ":RT1#"); break; case TR_SOLAR: strcpy(cmd, ":RT2#"); break; case TR_KING: strcpy(cmd, ":RT3#"); case TR_CUSTOM: strcpy(cmd, ":RT4#"); break; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { simInfo.trackRate = rate; strcpy(response, "1"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 1, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); tcflush(fd, TCIFLUSH); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
void MathPluginManagement::ProcessSwitchProperties(Telescope* pTelescope, const char *name, ISState *states, char *names[], int n) { DEBUGFDEVICE(pTelescope->getDeviceName(), INDI::Logger::DBG_DEBUG, "ProcessSwitchProperties - name(%s)", name); if (strcmp(name, AlignmentSubsystemMathPluginsV.name) == 0) { int CurrentPlugin = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV); IUUpdateSwitch(&AlignmentSubsystemMathPluginsV, states, names, n); AlignmentSubsystemMathPluginsV.s = IPS_OK; // Assume OK for the time being int NewPlugin = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV); if (NewPlugin != CurrentPlugin) { // New plugin requested // Unload old plugin if required if (0 != CurrentPlugin) { typedef void Destroy_t(MathPlugin *); Destroy_t* Destroy = (Destroy_t*)dlsym(LoadedMathPluginHandle, "Destroy"); if (NULL != Destroy) { Destroy(pLoadedMathPlugin); pLoadedMathPlugin = NULL; if (0 == dlclose(LoadedMathPluginHandle)) { LoadedMathPluginHandle = NULL; } else { IDLog("MathPluginManagement - dlclose failed on loaded plugin - %s\n", dlerror()); AlignmentSubsystemMathPluginsV.s = IPS_ALERT; } } else { IDLog("MathPluginManagement - cannot get Destroy function - %s\n", dlerror()); AlignmentSubsystemMathPluginsV.s = IPS_ALERT; } } // Load the requested plugin if required if (0 != NewPlugin) { std::string PluginPath(MathPluginFiles[NewPlugin - 1]); if (NULL != (LoadedMathPluginHandle = dlopen(PluginPath.c_str(), RTLD_NOW))) { typedef MathPlugin* Create_t(); Create_t* Create = (Create_t*)dlsym(LoadedMathPluginHandle, "Create"); if (NULL != Create) { pLoadedMathPlugin = Create(); IUSaveText(&AlignmentSubsystemCurrentMathPlugin, PluginPath.c_str()); } else { IDLog("MathPluginManagement - cannot get Create function - %s\n", dlerror()); AlignmentSubsystemMathPluginsV.s = IPS_ALERT; } } else { IDLog("MathPluginManagement - cannot load plugin %s error %s\n", PluginPath.c_str(), dlerror()); AlignmentSubsystemMathPluginsV.s = IPS_ALERT; } } else { // It is in built plugin just set up the pointers pLoadedMathPlugin = &BuiltInPlugin; } } // Update client IDSetSwitch(&AlignmentSubsystemMathPluginsV, NULL); } else if (strcmp(name, AlignmentSubsystemMathPluginInitialiseV.name) == 0) { AlignmentSubsystemMathPluginInitialiseV.s = IPS_OK; IUResetSwitch(&AlignmentSubsystemMathPluginInitialiseV); // Update client display IDSetSwitch(&AlignmentSubsystemMathPluginInitialiseV, NULL); // Initialise or reinitialise the current math plugin Initialise(CurrentInMemoryDatabase); } else if (strcmp(name, AlignmentSubsystemActiveV.name) == 0) { AlignmentSubsystemActiveV.s=IPS_OK; if (0 == IUUpdateSwitch(&AlignmentSubsystemActiveV, states, names, n)) // Update client IDSetSwitch(&AlignmentSubsystemActiveV, NULL); } }
bool get_ieqpro_model (int fd, FirmwareInfo *info) { char cmd[] = ":MountInfo#"; int errcode = 0; char errmsg[MAXRBUF]; char response[16]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strcpy(response, "0045"); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read(fd, response, 4, IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); if (nbytes_read == 4) { if (!strcmp(response, "0060")) info->Model = "CEM60"; else if (!strcmp(response, "0061")) info->Model = "CEM60-EC"; else if (!strcmp(response, "0045")) info->Model = "iEQ45 Pro"; else if (!strcmp(response, "0046")) info->Model = "iEQ45 Pro AA"; else if (!strcmp(response, "0025")) info->Model = "CEM25"; else info->Model = "Unknown"; tcflush(fd, TCIFLUSH); return true; } } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 4.", nbytes_read); return false; }
bool get_ieqpro_utc_date_time(int fd, double *utc_hours, int *yy, int *mm, int *dd, int *hh, int *minute, int *ss) { char cmd[] = ":GLT#"; int errcode = 0; char errmsg[MAXRBUF]; char response[32]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd); if (ieqpro_simulation) { strncpy(response, "+180150331173000#" , 32); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read_section(fd, response, '#', IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { tcflush(fd, TCIFLUSH); response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "RES (%s)", response); char utc_str[4], yy_str[2], mm_str[2], dd_str[2], hh_str[2], minute_str[2], ss_str[2]; strncpy(utc_str, response, 4); strncpy(yy_str, response+4, 2); strncpy(mm_str, response+6, 2); strncpy(dd_str, response+8, 2); strncpy(hh_str, response+10, 2); strncpy(minute_str, response+12, 2); strncpy(ss_str, response+14, 2); *utc_hours = atoi(utc_str) / 60.0; *yy = atoi(yy_str) + 2000; *mm = atoi(mm_str); *dd = atoi(dd_str); *hh = atoi(hh_str); *minute = atoi(minute_str); *ss = atoi(ss_str); ln_zonedate localTime; ln_date utcTime; localTime.years = *yy; localTime.months = *mm; localTime.days = *dd; localTime.hours = *hh; localTime.minutes = *minute; localTime.seconds = *ss; localTime.gmtoff = *utc_hours * 3600; ln_zonedate_to_date(&localTime, &utcTime); *yy = utcTime.years; *mm = utcTime.months; *dd = utcTime.days; *hh = utcTime.hours; *minute = utcTime.minutes; *ss = utcTime.seconds; return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }
void MathPluginManagement::ProcessTextProperties(Telescope* pTelescope, const char *name, char *texts[], char *names[], int n) { DEBUGFDEVICE(pTelescope->getDeviceName(), INDI::Logger::DBG_DEBUG, "ProcessTextProperties - name(%s)", name); if (strcmp(name, AlignmentSubsystemCurrentMathPluginV.name) == 0) { AlignmentSubsystemCurrentMathPluginV.s=IPS_OK; IUUpdateText(&AlignmentSubsystemCurrentMathPluginV, texts, names, n); if (0 != strcmp(AlignmentSubsystemMathPlugins.get()[0].label, AlignmentSubsystemCurrentMathPlugin.text)) { // Unload old plugin if required if (NULL != LoadedMathPluginHandle) { 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; } } // It is not the built in so try to load it if (NULL != (LoadedMathPluginHandle = dlopen(AlignmentSubsystemCurrentMathPlugin.text, RTLD_NOW))) { typedef MathPlugin* Create_t(); Create_t* Create = (Create_t*)dlsym(LoadedMathPluginHandle, "Create"); if (NULL != Create) { pLoadedMathPlugin = Create(); // TODO - Update the client to reflect the new plugin int i; for (i = 0; i < MathPluginFiles.size(); i++) { if (0 == strcmp(AlignmentSubsystemCurrentMathPlugin.text, MathPluginFiles[i].c_str())) break; } if (i < MathPluginFiles.size()) { IUResetSwitch(&AlignmentSubsystemMathPluginsV); (AlignmentSubsystemMathPlugins.get() + i + 1)->s = ISS_ON; // Update client IDSetSwitch(&AlignmentSubsystemMathPluginsV, NULL); } else { IDLog("MathPluginManagement - cannot find %s in list of plugins\n", MathPluginFiles[i].c_str()); } } else { IDLog("MathPluginManagement - cannot get Create function - %s\n", dlerror()); } } else { IDLog("MathPluginManagement - cannot load plugin %s error %s\n", AlignmentSubsystemCurrentMathPlugin.text, dlerror()); } } else { // It is the inbuilt plugin // Unload old plugin if required if (NULL != LoadedMathPluginHandle) { 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; } } pLoadedMathPlugin = &BuiltInPlugin; IUResetSwitch(&AlignmentSubsystemMathPluginsV); AlignmentSubsystemMathPlugins.get()->s = ISS_ON; // Update client IDSetSwitch(&AlignmentSubsystemMathPluginsV, NULL); } } }
bool get_ieqpro_coords(int fd, double *ra, double *dec) { char cmd[] = ":GEC#"; int errcode = 0; char errmsg[MAXRBUF]; char response[32]; int nbytes_read=0; int nbytes_written=0; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_EXTRA_1, "CMD (%s)", cmd); if (ieqpro_simulation) { char ra_str[16], dec_str[16]; char sign; if (simData.dec >= 0) sign = '+'; else sign = '-'; int ieqDEC = fabs(simData.dec) * 60 * 60 * 100; snprintf(dec_str, 16, "%c%08d", sign, ieqDEC); int ieqRA = simData.ra * 60 * 60 * 1000; snprintf(ra_str, 16, "%08d", ieqRA); snprintf(response, 32, "%s%s#", dec_str, ra_str); nbytes_read = strlen(response); } else { if ( (errcode = tty_write(fd, cmd, strlen(cmd), &nbytes_written)) != TTY_OK) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } if ( (errcode = tty_read_section(fd, response, '#', IEQPRO_TIMEOUT, &nbytes_read))) { tty_error_msg(errcode, errmsg, MAXRBUF); DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "%s", errmsg); return false; } } if (nbytes_read > 0) { tcflush(fd, TCIFLUSH); response[nbytes_read] = '\0'; DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_EXTRA_1, "RES (%s)", response); char ra_str[16], dec_str[16]; strncpy(dec_str, response, 9); strncpy(ra_str, response+9, 8); int ieqDEC = atoi(dec_str); int ieqRA = atoi(ra_str); *ra = ieqRA / (60.0 * 60.0 * 1000.0); *dec = ieqDEC / (60.0 * 60.0 * 100.0); return true; } DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_ERROR, "Only received #%d bytes, expected 1.", nbytes_read); return false; }