/*
* On success return number of bytes received
*/
int tty_read_timeout(unsigned char *buf, size_t size, int timeout)
{
int rc;
bool rd = FALSE;
tty_status = TTY_SUCCESS;
DEB((D_TTYIO, "tty_read_timeout: want read %d byte(s), timeout = %d", size, timeout));
if( timeout > 0 )
{
if( (rc = tty_select(&rd, NULL, timeout)) < 0 )
return rc;
if( rd )
{
if( (rc = tty_read(buf, size)) == 0 )
return TTY_ERROR;
return rc;
}
return TTY_TIMEOUT;
}
return tty_read(buf, size);
}
bool SynscanMount::Goto(double ra,double dec)
{
char str[20];
int n1,n2;
int numread, bytesWritten, bytesRead;
// not fleshed in yet
tty_write(PortFD,"Ka",2, &bytesWritten); // test for an echo
tty_read(PortFD,str,2,2, &bytesRead); // Read 2 bytes of response
if(str[1] != '#') {
// this is not a correct echo
// so we are not talking to a mount properly
return false;
}
// Ok, mount is alive and well
// so, lets format up a goto command
n1=ra*0x1000000/24;
n2=dec*0x1000000/360;
n1=n1<<8;
n2=n2<<8;
sprintf((char *)str,"r%08X,%08X",n1,n2);
tty_write(PortFD,str,18, &bytesWritten);
TrackState=SCOPE_SLEWING;
numread=tty_read(PortFD,str,1,60, &bytesRead);
if (bytesRead!=1||str[0]!='#')
{
if (isDebug())
IDLog("Timeout waiting for scope to complete slewing.");
return false;
}
return true;
}
bool SynscanMount::Abort()
{
char str[20];
int bytesWritten, bytesRead;
// Hmmm twice only stops it
tty_write(PortFD,"M",1, &bytesWritten);
tty_read(PortFD,str,1,1, &bytesRead); // Read 1 bytes of response
tty_write(PortFD,"M",1, &bytesWritten);
tty_read(PortFD,str,1,1, &bytesRead); // Read 1 bytes of response
return true;
}
static int
serial_read(device_t dev, char *buf, size_t *nbyte, int blkno)
{
struct serial_softc *sc = device_private(dev);
return tty_read(&sc->tty, buf, nbyte);
}
/*
* writes count bytes from the buffer (buf) to the
* scpi instrument referred to by the descriptor *scpi.
*
* On success, the number of bytes written is returned
* (zero indicates nothing was written).
* On error, -1 is returned
*/
static ssize_t scpi_write(struct scpi_instrument *scpi, const void *buf, size_t count)
{
int retval = -1;
if (!scpi->network && !scpi->serial)
return -ENOENT;
if (scpi->network && !scpi->control_socket)
return -ENXIO;
else if (scpi->network) {
retval = send(scpi->control_socket, buf, count, 00);
if (retval == count && memchr(buf, '?', count)) {
memset(scpi->response, 0, SOCKETS_BUFFER_SIZE);
scpi_network_read(scpi);
}
}
if (scpi->serial && scpi->ttyfd < 0)
return -ENXIO;
else if (scpi->serial) {
retval = write(scpi->ttyfd, buf, count);
if (retval == count) {
if (memchr(buf, '?', count)) {
memset(scpi->response, 0, SOCKETS_BUFFER_SIZE);
tty_read(scpi);
}
} else
fprintf(stderr, "SCPI:%s tty didn't write the entire buffer\n", __func__);
tcflush(scpi->ttyfd, TCIOFLUSH);
}
return retval;
}
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;
}
void tty_input (HANDLE fd, short events, void *udata)
{
char ch;
unsigned n;
ARG_NOT_USED (fd)
ARG_NOT_USED (events)
ARG_NOT_USED (udata)
DDS_continue ();
n = tty_read (&ch, 1);
if (!n)
return;
if (full) {
printf ("\a");
return;
}
tty_queue [wp++] = ch;
if (wp >= MAX_QUEUE)
wp = 0;
empty = 0;
if (wp == rp)
full = 1;
}
int ioptronHC8406::slewioptronHC8406()
{
DEBUGF(DBG_SCOPE, "<%s>", __FUNCTION__);
char slewNum[2];
int error_type;
int nbytes_write = 0, nbytes_read = 0;
DEBUGF(DBG_SCOPE, "CMD <%s>", ":MS#");
if ((error_type = tty_write_string(PortFD, ":MS#", &nbytes_write)) != TTY_OK)
return error_type;
error_type = tty_read(PortFD, slewNum, 1, 3, &nbytes_read);
if (nbytes_read < 1)
{
DEBUGF(DBG_SCOPE, "RES ERROR <%d>", error_type);
return error_type;
}
/* We don't need to read the string message, just return corresponding error code */
tcflush(PortFD, TCIFLUSH);
DEBUGF(DBG_SCOPE, "RES <%c>", slewNum[0]);
return slewNum[0];
}
int tty_get(char *buf, int size, int tot)
{
int result=0;
if (left >= size) {
memcpy(buf,next,size);
next += size;
left -= size;
return 0;
}
if (left > 0) {
memcpy(buf,next,left);
buf += left;
next += left;
size -= left;
left=0;
}
while ((result=tty_read(buf,size,tot)) > 0) {
buf += result;
size -= result;
}
return result;
}
bool LX200SS2000PC::setCalenderDate(int year, int month, int day) {
// This method differs from the setCalenderDate function in lx200driver.cpp
// in that it reads and checks the complete respons from the SkySensor2000PC.
// In addition, this method only sends the date when it differs from the date
// of the SkySensor2000PC because the resulting update of the planetary data
// takes quite some time.
bool result = true;
int ss_year, ss_month, ss_day;
const bool send_to_skysensor = (!getCalenderDate(ss_year,ss_month,ss_day) || year != ss_year || month != ss_month || day != ss_day );
DEBUGF(INDI::Logger::DBG_DEBUG, "LX200SS2000PC::setCalenderDate(): Driver date %02d/%02d/%02d, SS2000PC date %02d/%02d/%02d.", month, day, year, ss_month, ss_day, ss_year);
if (send_to_skysensor) {
char buffer[64];
int nbytes_written = 0;
snprintf(buffer, sizeof(buffer), ":SC %02d/%02d/%02d#", month, day, (year%100));
result = ( tty_write_string(PortFD, buffer, &nbytes_written) == TTY_OK && nbytes_written == strlen(buffer) );
if (result) {
int nbytes_read = 0;
result = ( tty_read(PortFD, buffer, 1, ShortTimeOut, &nbytes_read) == TTY_OK && nbytes_read == 1 && buffer[0] == '1' );
if (result) {
if (tty_read_section(PortFD, buffer, '#', ShortTimeOut, &nbytes_read) != TTY_OK || strncmp(buffer,"Updating planetary data#",24) != 0) {
DEBUGF(INDI::Logger::DBG_ERROR, "LX200SS2000PC::setCalenderDate(): Received unexpected first line '%s'.", buffer);
result = false;
}
else if (tty_read_section(PortFD, buffer, '#', LongTimeOut, &nbytes_read) != TTY_OK && strncmp(buffer," #",24) != 0) {
DEBUGF(INDI::Logger::DBG_ERROR, "LX200SS2000PC::setCalenderDate(): Received unexpected second line '%s'.", buffer);
result = false;
}
}
}
}
return result;
}
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 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;
}
static int
tty_rename(ARCHD *arcn)
{
char tmpname[PAXPATHLEN+2];
int res;
/*
* prompt user for the replacement name for a file, keep trying until
* we get some reasonable input. Archives may have more than one file
* on them with the same name (from updates etc). We print verbose info
* on the file so the user knows what is up.
*/
tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0);
for (;;) {
ls_tty(arcn);
tty_prnt("Input new name, or a \".\" to keep the old name, ");
tty_prnt("or a \"return\" to skip this file.\n");
tty_prnt("Input > ");
if (tty_read(tmpname, sizeof(tmpname)) < 0)
return(-1);
if (strcmp(tmpname, "..") == 0) {
tty_prnt("Try again, illegal file name: ..\n");
continue;
}
if (strlen(tmpname) > PAXPATHLEN) {
tty_prnt("Try again, file name too long\n");
continue;
}
break;
}
/*
* empty file name, skips this file. a "." leaves it alone
*/
if (tmpname[0] == '\0') {
tty_prnt("Skipping file.\n");
return(1);
}
if ((tmpname[0] == '.') && (tmpname[1] == '\0')) {
tty_prnt("Processing continues, name unchanged.\n");
return(0);
}
/*
* ok the name changed. We may run into links that point at this
* file later. we have to remember where the user sent the file
* in order to repair any links.
*/
tty_prnt("Processing continues, name changed to: %s\n", tmpname);
res = add_name(arcn->name, arcn->nlen, tmpname);
arcn->nlen = strlcpy(arcn->name, tmpname, sizeof(arcn->name));
if (arcn->nlen >= sizeof(arcn->name))
arcn->nlen = sizeof(arcn->name) - 1; /* XXX truncate? */
if (res < 0)
return(-1);
return(0);
}
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_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 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;
}
/************************************************************************************
*
* ***********************************************************************************/
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;
}
/************************************************************************************
*
* ***********************************************************************************/
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 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 NFocus::ReadResponse(char *buf, int nbytes, int timeout)
{
char nfocus_error[MAXRBUF];
int bytesRead = 0;
int totalBytesRead = 0;
int err_code;
if (isDebug())
IDLog("##########################################\n")
;
while (totalBytesRead < nbytes)
{
if ( (err_code = tty_read(PortFD, buf+totalBytesRead, nbytes-totalBytesRead, timeout, &bytesRead)) != TTY_OK)
{
tty_error_msg(err_code, nfocus_error, MAXRBUF);
if (isDebug())
{
IDLog("TTY error detected: %s\n", nfocus_error);
IDMessage(getDeviceName(), "TTY error detected: %s\n", nfocus_error);
}
return -1;
}
if (isDebug())
IDLog("Bytes Read: %d\n", bytesRead);
if (bytesRead < 0 )
{
if (isDebug())
IDLog("Bytesread < 1\n");
return -1;
}
totalBytesRead += bytesRead;
}
tcflush(PortFD, TCIOFLUSH);
if (isDebug())
{
fprintf(stderr, "READ : (%s,%d), %d\n", buf, 9, totalBytesRead) ;
fprintf(stderr, "READ : ") ;
for(int i=0; i < 9; i++)
{
fprintf(stderr, "0x%2x ", (unsigned char)buf[i]) ;
}
fprintf(stderr, "\n") ;
}
return 9;
}
/*
Reads a response from MAX DOME II
It verifies message sintax and checksum
@param fd File descriptor
@param cMessage Pointer to a buffer to receive the message
@return 0 if message is Ok. -1 if no response or no start caracter found. -2 invalid declared message length. -3 message too short. -4 checksum error
*/
int ReadResponse_MaxDomeII(int fd, char *cMessage)
{
int nBytesRead;
int nLen = MAX_BUFFER;
int nErrorType = TTY_OK;
char nChecksum;
*cMessage = 0x00;
cMessage[13] = 0x00;
// Look for a 0x01 starting character, until time out occurs or MAX_BUFFER characters was read
while (*cMessage != 0x01 && nErrorType == TTY_OK)
{
nErrorType = tty_read(fd, cMessage, 1, MAXDOME_TIMEOUT, &nBytesRead);
//fprintf(stderr,"\nIn 1: %ld %02x\n", nBytesRead, (int)cMessage[0]);
}
if (nErrorType != TTY_OK || *cMessage != 0x01)
return -1;
// Read message length
nErrorType = tty_read(fd, cMessage + 1, 1, MAXDOME_TIMEOUT, &nBytesRead);
//fprintf(stderr,"\nInLen: %d\n",(int) cMessage[1]);
if (nErrorType != TTY_OK || cMessage[1] < 0x02 || cMessage[1] > 0x0E)
return -2;
nLen = cMessage[1];
// Read the rest of the message
nErrorType = tty_read(fd, cMessage + 2, nLen, MAXDOME_TIMEOUT, &nBytesRead);
//fprintf(stderr,"\nIn: %s\n", cMessage);
if (nErrorType != TTY_OK || nBytesRead != nLen)
return -3;
nChecksum = checksum_MaxDomeII(cMessage, nLen + 2);
if (nChecksum != 0x00)
return -4;
return 0;
}
void tty_read(void *data,size_t size,int timeout)
{
const uint8_t *start = data;
size_t left = size;
while (left) {
fd_set set;
struct timeval to = { .tv_sec = timeout, .tv_usec = 0 };
int res;
ssize_t got;
FD_ZERO(&set);
FD_SET(fd,&set);
res = select(fd+1,&set,NULL,NULL,&to);
if (res < 0) {
perror("select");
exit(1);
}
if (!res) {
fprintf(stderr,"timeout reading from programmer\n");
exit(1);
}
got = read(fd,data,left);
if (got < 0) {
perror("read from serial port");
exit(1);
}
if (!got) {
perror("EOF on serial port");
exit(1);
}
left -= got;
data += got;
}
if (verbose > 2) {
int i;
fprintf(stderr,"TTY READ:");
for (i = 0; i != size; i++)
fprintf(stderr," %02x",start[i]);
putc('\n',stderr);
}
}
uint8_t tty_read_byte(int timeout)
{
uint8_t c;
tty_read(&c,1,timeout);
return c;
}
static ssize_t ttym_read(dev_cookie _cookie, void *buf, off_t pos, ssize_t len)
{
tty_master_cookie *cookie = (tty_master_cookie *)_cookie;
ssize_t ret;
TRACE(("ttym_read: tty %d cookie %p, buf %p, len %d\n", cookie->tty->index, cookie, buf, len));
ret = tty_read(cookie->tty, buf, len, ENDPOINT_MASTER_READ);
TRACE(("ttym_read: tty %d returns %d\n", cookie->tty->index, ret));
return ret;
}
bool SynscanMount::Park()
{
char str[20];
int numread, bytesWritten, bytesRead;
memset(str,0,3);
tty_write(PortFD,"Ka",2, &bytesWritten); // test for an echo
tty_read(PortFD,str,2,2, &bytesRead); // Read 2 bytes of response
if(str[1] != '#')
{
// this is not a correct echo
// so we are not talking to a mount properly
return false;
}
// Now we stop tracking
tty_write(PortFD,"T0",2, &bytesWritten);
numread=tty_read(PortFD,str,1,60, &bytesRead);
if (bytesRead!=1||str[0]!='#')
{
if (isDebug())
IDLog("Timeout waiting for scope to stop tracking.");
return false;
}
//sprintf((char *)str,"b%08X,%08X",0x0,0x40000000);
tty_write(PortFD,"B0000,4000",10, &bytesWritten);
numread=tty_read(PortFD,str,1,60, &bytesRead);
if (bytesRead!=1||str[0]!='#')
{
if (isDebug())
IDLog("Timeout waiting for scope to respond to park.");
return false;
}
TrackState=SCOPE_PARKING;
IDMessage(getDeviceName(),"Parking Telescope...");
return true;
}
void get_term_title(char *title)
{
int n;
static char buffer[BUFSIZ];
char temp[20];
snprintf(temp,sizeof(temp),"\033[%dt",21);
raw_print(temp);
n = tty_read(buffer,sizeof(buffer));
if(n==0)
goto read_failure;
if(n==1)
{
int n2 = tty_read(buffer+1,sizeof(buffer)-1);
if(n2==0)
goto read_failure;
n+=n2;
}
// n+= tty_read(buffer+1,sizeof(buffer)-1);
while( !(buffer[n-2] == '\033' && buffer[n-1] == '\\') ) {
// n += tty_read(buffer+n,sizeof(buffer)-n);
int n2 = tty_read(buffer+1,sizeof(buffer)-1);
if(n2==0)
goto read_failure;
n+=n2;
}
buffer[n-2]= '\0';
snprintf((char *)title,sizeof(buffer),"%s",buffer+3);
return;
read_failure:
sprintf((char *)title,"xterm");
}
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_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;
}
/************************************************************************************
*
* ***********************************************************************************/
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 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;
}
