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