bool ArmPlat::slpSendRxInt( char *command, int *rcode )
{
int nbytes_wrrd = 0;
int rc;
char errstr[MAXRBUF];
char res[SLP_SEND_BUF_SIZE]={0};
LOGF_DEBUG("Tx [%s]", command);
//tty_set_debug( 1 );
if ((rc = tty_write_string(PortFD, command, &nbytes_wrrd)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
//IDLog( "ERROR Tx: <%s>\n", errstr );
LOGF_ERROR("Send error: %s.", errstr);
return false;
}
if ((rc = tty_read_section(PortFD, res, '#', ArmPlat_TIMEOUT, &nbytes_wrrd)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
//IDLog( "ERROR Rx: <%s> error msg <%s>\n", res, errstr );
LOGF_ERROR("Echo receiving error: %s.", errstr);
return false;
}
LOGF_DEBUG("Rx [%s]", res);
//if ( ( strstr( command, "getpos" ) == nullptr ) && ( strstr( command, "temps" ) == nullptr ) )
//IDLog( "Rx: <%s>\n", res );
return getIntResultCode( command, res, rcode );
}
bool MoonLite::Ack()
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char resp[5];
short pos=-1;
tcflush(PortFD, TCIOFLUSH);
if ( (rc = tty_write(PortFD, ":GP#", 4, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "updatePostion error: %s.", errstr);
return false;
}
if ( (rc = tty_read(PortFD, resp, 5, 2, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "updatePostion error: %s.", errstr);
return false;
}
rc = sscanf(resp, "%hX#", &pos);
if (rc > 0)
return true;
else
return false;
}
// Send a command to the mount. Return the number of bytes received or 0 if
// case of error
// commands are null terminated, replies end with /n
int QFW::send_command(int fd, const char* cmd, char *resp)
{
int err;
int nbytes = 0;
char errmsg[MAXRBUF];
int cmd_len = strlen(cmd);
char dmp[255];
dump(dmp, cmd);
LOGF_DEBUG("CMD <%s>", dmp);
tcflush(fd, TCIOFLUSH);
if ((err = tty_write(fd, cmd, cmd_len, &nbytes)) != TTY_OK)
{
tty_error_msg(err, errmsg, MAXRBUF);
LOGF_ERROR("Serial write error: %s", errmsg);
return 0;
}
err = tty_read_section(fd, resp, '\n', QUANTUM_TIMEOUT, &nbytes);
if (err)
{
tty_error_msg(err, errmsg, MAXRBUF);
LOGF_ERROR("Serial read error: %s", errmsg);
return 0;
}
resp[nbytes] = 0;
dump(dmp, resp);
LOGF_DEBUG("RES <%s>", dmp);
return nbytes;
}
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 SynscanDriver::sendCommand(const char * cmd, char * res, int cmd_len, int res_len)
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
tcflush(PortFD, TCIOFLUSH);
if (cmd_len > 0)
{
char hex_cmd[SYN_RES * 3] = {0};
hexDump(hex_cmd, cmd, cmd_len);
LOGF_DEBUG("CMD <%s>", hex_cmd);
rc = tty_write(PortFD, cmd, cmd_len, &nbytes_written);
}
else
{
LOGF_DEBUG("CMD <%s>", cmd);
rc = tty_write_string(PortFD, cmd, &nbytes_written);
}
if (rc != TTY_OK)
{
char errstr[MAXRBUF] = {0};
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("Serial write error: %s.", errstr);
return false;
}
if (res == nullptr)
return true;
if (res_len > 0)
rc = tty_read(PortFD, res, res_len, SYN_TIMEOUT, &nbytes_read);
else
rc = tty_nread_section(PortFD, res, SYN_RES, SYN_DEL, SYN_TIMEOUT, &nbytes_read);
if (rc != TTY_OK)
{
char errstr[MAXRBUF] = {0};
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("Serial read error: %s.", errstr);
return false;
}
if (res_len > 0)
{
char hex_res[SYN_RES * 3] = {0};
hexDump(hex_res, res, res_len);
LOGF_DEBUG("RES <%s>", hex_res);
}
else
{
LOGF_DEBUG("RES <%s>", res);
}
tcflush(PortFD, TCIOFLUSH);
return true;
}
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 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 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 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;
}
/************************************************************************************
*
* ***********************************************************************************/
int BaaderDome::ControlDomeFlap(FlapOperation operation)
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char cmd[DOME_BUF];
char resp[DOME_BUF];
memset(cmd, 0, sizeof(cmd));
if (operation == FLAP_OPEN)
{
targetFlap = operation;
strncpy(cmd, "d#opeflap", DOME_CMD);
}
else
{
targetFlap = operation;
strncpy(cmd, "d#cloflap", DOME_CMD);
}
tcflush(PortFD, TCIOFLUSH);
if (!sim && (rc = tty_write(PortFD, cmd, DOME_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s ControlDomeFlap error: %s.", cmd, errstr);
return -1;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd);
if (sim)
{
simFlapTimer = SIM_FLAP_TIMER;
strncpy(resp, "d#gotmess", DOME_CMD);
nbytes_read = DOME_CMD;
}
else if ((rc = tty_read(PortFD, resp, DOME_CMD, DOME_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "ControlDomeFlap error: %s.", errstr);
return -1;
}
resp[nbytes_read] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", resp);
if (strcmp(resp, "d#gotmess") == 0)
{
flapStatus = simFlapStatus = FLAP_MOVING;
return 1;
}
return -1;
}
bool FlipFlat::SetLightBoxBrightness(uint16_t value)
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[FLAT_CMD];
char response[FLAT_RES];
tcflush(PortFD, TCIOFLUSH);
snprintf(command, FLAT_CMD, ">B%03d", value);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
command[FLAT_CMD-1] = 0xA;
if ( (rc = tty_write(PortFD, command, FLAT_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if ( (rc = tty_read_section(PortFD, response, 0xA, FLAT_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s: %s.", command, errstr);
return false;
}
response[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
char brightnessString[4];
snprintf(brightnessString, 4, "%s", response+4 );
int brightnessValue=0;
rc = sscanf(brightnessString, "%d", &brightnessValue);
if (rc <= 0)
{
DEBUGF(INDI::Logger::DBG_ERROR, "Unable to parse brightness value (%s)", response);
return false;
}
if (brightnessValue != prevBrightness)
{
prevBrightness = brightnessValue;
LightIntensityN[0].value = brightnessValue;
IDSetNumber(&LightIntensityNP, NULL);
}
return true;
}
/************************************************************************************
*
* ***********************************************************************************/
IPState BaaderDome::ControlShutter(ShutterOperation operation)
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char cmd[DOME_BUF];
char resp[DOME_BUF];
memset(cmd, 0, sizeof(cmd));
if (operation == SHUTTER_OPEN)
{
targetShutter = operation;
strncpy(cmd, "d#opeshut", DOME_CMD);
}
else
{
targetShutter = operation;
strncpy(cmd, "d#closhut", DOME_CMD);
}
tcflush(PortFD, TCIOFLUSH);
if (!sim && (rc = tty_write(PortFD, cmd, DOME_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s ControlDomeShutter error: %s.", cmd, errstr);
return IPS_ALERT;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd);
if (sim)
{
simShutterTimer = SIM_SHUTTER_TIMER;
strncpy(resp, "d#gotmess", DOME_CMD);
nbytes_read = DOME_CMD;
}
else if ((rc = tty_read(PortFD, resp, DOME_CMD, DOME_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "ControlDomeShutter error: %s.", errstr);
return IPS_ALERT;
}
resp[nbytes_read] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", resp);
if (strcmp(resp, "d#gotmess") == 0)
{
shutterState = simShutterStatus = SHUTTER_MOVING;
return IPS_BUSY;
}
return IPS_ALERT;
}
bool FlipFlat::EnableLightBox(bool enable)
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[FLAT_CMD];
char response[FLAT_RES];
if (isFlipFlat && ParkCapS[1].s == ISS_ON)
{
DEBUG(INDI::Logger::DBG_ERROR, "Cannot control light while cap is unparked.");
return false;
}
tcflush(PortFD, TCIOFLUSH);
if (enable)
strncpy(command, ">L000", FLAT_CMD);
else
strncpy(command, ">D000", FLAT_CMD);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
command[FLAT_CMD-1] = 0xA;
if ( (rc = tty_write(PortFD, command, FLAT_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if ( (rc = tty_read_section(PortFD, response, 0xA, FLAT_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s: %s.", command, errstr);
return false;
}
response[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
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))
return true;
else
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;
}
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 MoonLite::Ack()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[5]={0};
short pos = -1;
tcflush(PortFD, TCIOFLUSH);
//Try to request the position of the focuser
//Test for success on transmission and response
//If either one fails, try again, up to 3 times, waiting 1 sec each time
//If that fails, then return false.
int numChecks = 0;
bool success = false;
while(numChecks < 3 && !success)
{
numChecks++;
sleep(1); //wait 1 second between each test.
bool transmissionSuccess = (rc = tty_write(PortFD, ":GP#", 4, &nbytes_written)) == TTY_OK;
if(!transmissionSuccess)
{
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("Handshake Attempt %i, tty transmission error: %s.", numChecks, errstr);
}
bool responseSuccess = (rc = tty_read(PortFD, resp, 5, MOONLITE_TIMEOUT, &nbytes_read)) == TTY_OK;
if(!responseSuccess)
{
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("Handshake Attempt %i, updatePosition response error: %s.", numChecks, errstr);
}
success = transmissionSuccess && responseSuccess;
}
if(!success)
{
LOG_INFO("Handshake failed after 3 attempts");
return false;
}
tcflush(PortFD, TCIOFLUSH);
rc = sscanf(resp, "%hX#", &pos);
return rc > 0;
}
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;
}
/************************************************************************************
*
* ***********************************************************************************/
IPState BaaderDome::MoveAbs(double az)
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char cmd[DOME_BUF];
char resp[DOME_BUF];
if (status == DOME_UNKNOWN)
{
DEBUG(INDI::Logger::DBG_WARNING, "Dome is not calibrated. Please calibrate dome before issuing any commands.");
return IPS_ALERT;
}
targetAz = az;
snprintf(cmd, DOME_BUF, "d#azi%04d", MountAzToDomeAz(targetAz));
tcflush(PortFD, TCIOFLUSH);
if (!sim && (rc = tty_write(PortFD, cmd, DOME_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s MoveAbsDome error: %s.", cmd, errstr);
return IPS_ALERT;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd);
if (sim)
{
strncpy(resp, "d#gotmess", DOME_CMD);
nbytes_read = DOME_CMD;
}
else if ((rc = tty_read(PortFD, resp, DOME_CMD, DOME_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "MoveAbsDome error: %s.", errstr);
return IPS_ALERT;
}
resp[nbytes_read] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", resp);
if (strcmp(resp, "d#gotmess") == 0)
return IPS_BUSY;
return IPS_ALERT;
}
bool XAGYLWheel::getOffset(int filter)
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[XAGYL_MAXBUF];
char resp[XAGYL_MAXBUF];
tcflush(PortFD, TCIOFLUSH);
snprintf(command, XAGYL_MAXBUF, "O%d", filter+1);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
if (!sim && (rc = tty_write(PortFD, command, strlen(command), &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if (sim)
snprintf(resp, XAGYL_MAXBUF, "P%d Offset %02d", filter+1, simData.offset[filter]);
else
{
if ( (rc = tty_read_section(PortFD, resp, 0xA, XAGYL_MAXBUF, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s: %s.", command, errstr);
return false;
}
resp[nbytes_read-1] = '\0';
}
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", resp);
int filter_num=0, offset=0;
rc = sscanf(resp, "P%d Offset %d", &filter_num, &offset);
if (rc > 0)
{
OffsetN[filter_num-1].value = offset;
return true;
}
else
return false;
}
bool MoonLiteDRO::updateStepDelay()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[3]={0};
char cmd[DRO_CMD]={0};
short speed;
if (m_ID == 1)
strncpy(cmd, ":GD#", DRO_CMD);
else
strncpy(cmd, ":2GD#", DRO_CMD);
LOGF_DEBUG("CMD <%s>", cmd);
tcflush(PortFD, TCIOFLUSH);
if ((rc = tty_write_string(PortFD, cmd, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("updateStepDelay error: %s.", errstr);
return false;
}
if ((rc = tty_read_section(PortFD, resp, '#', MOONLITEDRO_TIMEOUT, &nbytes_read)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
LOGF_ERROR("updateStepDelay error: %s.", errstr);
return false;
}
tcflush(PortFD, TCIOFLUSH);
LOGF_DEBUG("RES <%s>", resp);
rc = sscanf(resp, "%hX", &speed);
if (rc > 0)
{
int focus_speed = -1;
while (speed > 0)
{
speed >>= 1;
focus_speed++;
}
StepDelayN[0].value = focus_speed;
}
int NFocus::SendCommand(char *rf_cmd)
{
int nbytes_written=0, nbytes_read=0, check_ret=0, err_code=0;
char rf_cmd_cks[32],nfocus_error[MAXRBUF];
if (isDebug())
{
fprintf(stderr, "strlen(rf_cmd) %ld\n", strlen(rf_cmd)) ;
fprintf(stderr, "WRITE: ") ;
for(int i=0; i < strlen(rf_cmd); i++)
{
fprintf(stderr, "0x%2x ", (unsigned char) rf_cmd[i]) ;
}
fprintf(stderr, "\n") ;
}
tcflush(PortFD, TCIOFLUSH);
if ( (err_code = tty_write(PortFD, rf_cmd, strlen(rf_cmd)+1, &nbytes_written) != TTY_OK))
{
tty_error_msg(err_code, nfocus_error, MAXRBUF);
if (isDebug())
IDLog("TTY error detected: %s\n", nfocus_error);
return -1;
}
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 NFocus::Connect()
{
int connectrc=0;
char errorMsg[MAXRBUF];
if (isDebug())
IDLog("connecting to %s\n",PortT[0].text);
if ( (connectrc = tty_connect(PortT[0].text, 9600, 8, 0, 1, &PortFD)) != TTY_OK)
{
tty_error_msg(connectrc, errorMsg, MAXRBUF);
if (isDebug())
IDLog("Failed to connect o port %s. Error: %s", PortT[0].text, errorMsg);
IDMessage(getDeviceName(), "Failed to connect to port %s. Error: %s", PortT[0].text, errorMsg);
return false;
}
IDMessage(getDeviceName(), "Nfocus is online. Getting focus parameters...");
return true;
}
bool XAGYLWheel::reset(int value)
{
int nbytes_written=0, rc=-1;
char errstr[MAXRBUF];
char command[XAGYL_MAXBUF];
tcflush(PortFD, TCIOFLUSH);
snprintf(command, XAGYL_MAXBUF, "R%d", value);
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);
if (!sim && (rc = tty_write(PortFD, command, strlen(command), &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", command, errstr);
return false;
}
if (value == 1)
simData.position = 1;
getFilterPosition();
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));
}
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;
}