static ssize_t ttym_write(dev_cookie _cookie, const void *buf, off_t pos, ssize_t len)
{
tty_master_cookie *cookie = (tty_master_cookie *)_cookie;
ssize_t ret;
TRACE(("ttym_write: tty %d cookie %p, buf %p, len %d\n", cookie->tty->index, cookie, buf, len));
ret = tty_write(cookie->tty, buf, len, ENDPOINT_MASTER_WRITE);
TRACE(("ttym_write: tty %d returns %d\n", cookie->tty->index, ret));
return ret;
}
/* Delete ny lines. */
void
screen_write_deleteline(struct screen_write_ctx *ctx, u_int ny)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
if (ny == 0)
ny = 1;
if (s->cy < s->rupper || s->cy > s->rlower) {
if (ny > screen_size_y(s) - s->cy)
ny = screen_size_y(s) - s->cy;
if (ny == 0)
return;
screen_write_initctx(ctx, &ttyctx, 0);
grid_view_delete_lines(s->grid, s->cy, ny);
ttyctx.num = ny;
tty_write(tty_cmd_deleteline, &ttyctx);
return;
}
if (ny > s->rlower + 1 - s->cy)
ny = s->rlower + 1 - s->cy;
if (ny == 0)
return;
screen_write_initctx(ctx, &ttyctx, 0);
if (s->cy < s->rupper || s->cy > s->rlower)
grid_view_delete_lines(s->grid, s->cy, ny);
else
grid_view_delete_lines_region(s->grid, s->rlower, s->cy, ny);
ttyctx.num = ny;
tty_write(tty_cmd_deleteline, &ttyctx);
}
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_ra(int fd, double ra)
{
char cmd[32];
int errcode = 0;
char errmsg[MAXRBUF];
char response[8];
int nbytes_read=0;
int nbytes_written=0;
// Send as milliseconds resolution
int ieqValue = ra * 60 * 60 * 1000;
snprintf(cmd, 32, ":Sr%08d#", ieqValue);
DEBUGFDEVICE(ieqpro_device, INDI::Logger::DBG_DEBUG, "CMD (%s)", cmd);
if (ieqpro_simulation)
{
simData.ra = ra;
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;
}
/*======================================================================*
task_tty
*======================================================================*/
PUBLIC void task_tty()
{
TTY* p_tty;
MSG msg;
init_keyboard();
for (p_tty=TTY_FIRST;p_tty<TTY_END;p_tty++) {
init_tty(p_tty);
}
select_console(0);
//清屏
clear(TTY_FIRST);
//欢迎信息
printf("X-Tinix.\n");
printf("X-Tinix: TTY(TASK) loaded.\n");
//就绪消息
_send(PID_SERVICE_PROC ,MSG_TYPE_TTY_READY);
_recv(MSG_TYPE_PROC_READY);
_send(PID_SERVICE_SHELL,MSG_TYPE_TTY_READY);
//监听消息
while (1) {
if(recv(ANY_MSG_SRC,&msg)!=-1){
SHELL_MSG shell_msg;
memcpy(&shell_msg,msg.msg,sizeof(SHELL_MSG));
switch(msg.type){
case MSG_TYPE_SHELL:
tty_write(TTY_FIRST+shell_msg.tty,shell_msg.command,strlen(shell_msg.command));
break;
case MSG_TYPE_TTY_CLEAR:
p_tty = TTY_FIRST + shell_msg.tty;
clear(p_tty);
break;
default:
break;
}
}
for (p_tty=TTY_FIRST;p_tty<TTY_END;p_tty++) {
tty_do_read(p_tty);
//tty_do_write(p_tty);
}
//clean work
memset(&msg,0x0,sizeof(MSG));
}
}
int ioptronHC8406::SendPulseCmd(int direction, int Tduration_msec)
{
DEBUGF(INDI::Logger::DBG_DEBUG, "<%s>", __FUNCTION__);
int rc = 0, nbytes_written = 0;
char cmd[20];
int duration_msec,Rduration;
if (Tduration_msec >=1000) {
duration_msec=999; //limited to 999
Rduration=Tduration_msec-duration_msec; //pending ms
} else {
duration_msec=Tduration_msec;
Rduration=0;
DEBUGF(INDI::Logger::DBG_DEBUG, "Pulse %d <999 Sent only one",Tduration_msec);
}
switch (direction)
{
case LX200_NORTH:
sprintf(cmd, ":Mn%03d#", duration_msec);
break;
case LX200_SOUTH:
sprintf(cmd, ":Ms%03d#", duration_msec);
break;
case LX200_EAST:
sprintf(cmd, ":Me%03d#", duration_msec);
break;
case LX200_WEST:
sprintf(cmd, ":Mw%03d#", duration_msec);
break;
default:
return 1;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "CMD <%s>", cmd);
if ((rc = tty_write(PortFD, cmd, strlen(cmd), &nbytes_written)) != TTY_OK)
{
char errmsg[256];
tty_error_msg(rc, errmsg, 256);
DEBUGF(INDI::Logger::DBG_ERROR, "Error writing to device %s (%d)", errmsg, rc);
return 1;
}
tcflush(PortFD, TCIFLUSH);
if (Rduration!=0) {
DEBUGF(INDI::Logger::DBG_DEBUG, "pulse guide. Pulse >999. ms left:%d",Rduration);
usleep(1000000); //wait until the previous one has fineshed
return SendPulseCmd(direction,Rduration);
}
return 0;
}
static size_t dev_uart_write(struct file_desc *desc, void *buff, size_t size) {
struct uart *uart_dev = desc->file_info;
struct tty *tty = &uart_dev->tty;
size_t written, left = size;
do {
written = tty_write(tty, buff, left);
left -= written;
buff = (char *) buff + written;
} while (left != 0);
return size;
}
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;
}
int printf(const char *fmt, ...)
{
int i;
char buf[512];
va_list args;
va_start(args, fmt);
i = vsprintf(buf, fmt, args);
tty_write(&tty0, buf, i);
va_end(args);
return i;
}
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 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 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;
}
/* Reverse index (up with scroll). */
void
screen_write_reverseindex(struct screen_write_ctx *ctx)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
screen_write_initctx(ctx, &ttyctx, 0);
if (s->cy == s->rupper)
grid_view_scroll_region_down(s->grid, s->rupper, s->rlower);
else if (s->cy > 0)
s->cy--;
tty_write(tty_cmd_reverseindex, &ttyctx);
}
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 SynscanDriver::passThruCommand(int cmd, int target, int msgsize, int data, int numReturn)
{
char test[20] = {0};
int bytesRead, bytesWritten;
char a, b, c;
int tt = data;
a = tt % 256;
tt = tt >> 8;
b = tt % 256;
tt = tt >> 8;
c = tt % 256;
// format up a passthru command
memset(test, 0, 20);
test[0] = 80; // passhtru
test[1] = msgsize; // set message size
test[2] = target; // set the target
test[3] = cmd; // set the command
test[4] = c; // set data bytes
test[5] = b;
test[6] = a;
test[7] = numReturn;
LOGF_DEBUG("CMD <%s>", test);
tty_write(PortFD, test, 8, &bytesWritten);
memset(test, 0, 20);
tty_read(PortFD, test, numReturn + 1, 2, &bytesRead);
LOGF_DEBUG("RES <%s>", test);
if (numReturn > 0)
{
int retval = 0;
retval = test[0];
if (numReturn > 1)
{
retval = retval << 8;
retval += test[1];
}
if (numReturn > 2)
{
retval = retval << 8;
retval += test[2];
}
return retval;
}
return 0;
}
bool SestoSenso::AbortFocuser()
{
if (isSimulation())
return true;
int nbytes_written;
if (tty_write(PortFD, "#MA!", 4, &nbytes_written) == TTY_OK)
{
FocusAbsPosNP.s = IPS_IDLE;
FocusRelPosNP.s = IPS_IDLE;
IDSetNumber(&FocusAbsPosNP, nullptr);
IDSetNumber(&FocusRelPosNP, nullptr);
}
return isCommandOK("MA");
}
/* Construct a command and send it to the spectrograph. It doesn't return
* anything so we have to sleep until we know it has flipped the switch.
*/
bool ShelyakEshel::calibrationUnitCommand(char command, char parameter)
{
int rc, nbytes_written;
char c[5] = { 0x0D, 0x01, command,
parameter }; // the first 2 bytes are constant, the next 2 are command and parameter
c[4] = 0x100 - (c[0] + c[1] + c[2] + c[3]) % 0x100; // last byte is is related to the sum of the four first
if ((rc = tty_write(PortFD, c, 5, &nbytes_written)) != TTY_OK) // send the bytes to the spectrograph
{
char errmsg[MAXRBUF];
tty_error_msg(rc, errmsg, MAXRBUF);
LOGF_ERROR("error: %s.", errmsg);
return false;
}
sleep(1); // wait for the calibration unit to actually flip the switch
return true;
}
/* Clear to end of line from cursor. */
void
screen_write_clearendofline(struct screen_write_ctx *ctx)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
u_int sx;
screen_write_initctx(ctx, &ttyctx, 0);
sx = screen_size_x(s);
if (s->cx <= sx - 1)
grid_view_clear(s->grid, s->cx, s->cy, sx - s->cx, 1);
tty_write(tty_cmd_clearendofline, &ttyctx);
}
bool abort_ieqpro(int fd)
{
char cmd[] = ":Q#";
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_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;
}
int tty_write_echo(int fd,char byte)
{
char reply;
if(tty_write(fd,byte)==-1) return(-1);
if(tty_read(fd,&reply)==-1) return(-1);
LOGPRINTF(1,"sent: A%u D%01x reply: A%u D%01x",
(((unsigned int) (unsigned char) byte)&0xf0)>>4,
((unsigned int) (unsigned char) byte)&0x0f,
(((unsigned int) (unsigned char) reply)&0xf0)>>4,
((unsigned int) (unsigned char) reply)&0x0f);
if(byte!=reply)
{
logprintf(LOG_ERR,"Command mismatch.");
}
return(1);
}
void printk (const char *fmt, ...)
{
unsigned long eflags;
static char buffer[1024];
va_list args;
eflags = read_flags ();
cli ();
args = va_start (args, fmt);
vsprintf (buffer, fmt, args);
va_end (args);
tty_write (0, buffer, strlen (buffer));
write_flags (eflags);
}
bool ioptronHC8406::checkConnection()
{
if (isSimulation())
return true;
char initCMD[] = ":V#";
int errcode = 0;
char errmsg[MAXRBUF];
char response[8];
int nbytes_read = 0;
int nbytes_written = 0;
DEBUG(INDI::Logger::DBG_DEBUG, "Initializing iOptron using :V# CMD...");
for (int i = 0; i < 2; i++)
{
if ((errcode = tty_write(PortFD, initCMD, 3, &nbytes_written)) != TTY_OK)
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
usleep(50000);
continue;
}
if ((errcode = tty_read_section(PortFD, response, '#', 3, &nbytes_read)))
{
tty_error_msg(errcode, errmsg, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s", errmsg);
usleep(50000);
continue;
}
if (nbytes_read > 0)
{
response[nbytes_read] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
if (!strcmp(response, "V1.00#"))
return true;
}
usleep(50000);
}
return false;
}
bool SestoSenso::updateTemperature()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[16]={0};
DEBUG(INDI::Logger::DBG_DEBUG, "CMD <#QT!>");
if (isSimulation())
{
strncpy(resp, "23.45", 16);
nbytes_read = strlen(resp) + 1;
}
else
{
tcflush(PortFD, TCIOFLUSH);
if ((rc = tty_write(PortFD, "#QT!", 4, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr);
TemperatureNP.s = IPS_ALERT;
return false;
}
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: %s.", __FUNCTION__, errstr);
TemperatureNP.s = IPS_ALERT;
return false;
}
tcflush(PortFD, TCIOFLUSH);
}
resp[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES <%s>", resp);
TemperatureN[0].value = atof(resp);
TemperatureNP.s = (TemperatureN[0].value == 99.00) ? IPS_IDLE : IPS_OK;
return true;
}
bool SestoSenso::updatePosition()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[16]={0};
DEBUG(INDI::Logger::DBG_DEBUG, "CMD <#QP!>");
if (isSimulation())
{
snprintf(resp, 16, "%d", static_cast<uint32_t>(FocusAbsPosN[0].value));
nbytes_read = strlen(resp)+1;
}
else
{
tcflush(PortFD, TCIOFLUSH);
if ((rc = tty_write(PortFD, "#QP!", 4, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "%s error: %s.", __FUNCTION__, errstr);
FocusAbsPosNP.s = IPS_ALERT;
return false;
}
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: %s.", __FUNCTION__, errstr);
FocusAbsPosNP.s = IPS_ALERT;
return false;
}
tcflush(PortFD, TCIOFLUSH);
}
resp[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES <%s>", resp);
FocusAbsPosN[0].value = atoi(resp);
FocusAbsPosNP.s = IPS_OK;
return true;
}
IPState FlipFlat::UnParkCap()
{
int nbytes_written=0, nbytes_read=0, rc=-1;
char errstr[MAXRBUF];
char command[FLAT_CMD];
char response[FLAT_RES];
tcflush(PortFD, TCIOFLUSH);
strncpy(command, ">O000", 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 IPS_ALERT;
}
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 IPS_ALERT;
}
response[nbytes_read-1] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", response);
char expectedResponse[FLAT_RES];
snprintf(expectedResponse, FLAT_RES, "*O%02d000", productID);
if (!strcmp(response, expectedResponse))
{
// Set cover status to random value outside of range to force it to refresh
prevCoverStatus = 10;
return IPS_BUSY;
}
else
return IPS_ALERT;
}
/* Clear to start of line from cursor. */
void
screen_write_clearstartofline(struct screen_write_ctx *ctx)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
u_int sx;
screen_write_initctx(ctx, &ttyctx);
sx = screen_size_x(s);
if (s->cx > sx - 1)
grid_view_clear(s->grid, 0, s->cy, sx, 1);
else
grid_view_clear(s->grid, 0, s->cy, s->cx + 1, 1);
tty_write(tty_cmd_clearstartofline, &ttyctx);
}
/* Clear entire screen. */
void
screen_write_clearscreen(struct screen_write_ctx *ctx)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
screen_write_initctx(ctx, &ttyctx, 0);
/* Scroll into history if it is enabled. */
if (s->grid->flags & GRID_HISTORY)
grid_view_clear_history(s->grid);
else {
grid_view_clear(
s->grid, 0, 0, screen_size_x(s), screen_size_y(s));
}
tty_write(tty_cmd_clearscreen, &ttyctx);
}
/* Flush outstanding cell writes. */
static void
screen_write_flush(struct screen_write_ctx *ctx)
{
struct screen *s = ctx->s;
struct tty_ctx ttyctx;
u_int x, y, offset, cx, cy, dirty;
struct grid_cell gc;
if (ctx->dirty == 0)
return;
dirty = 0;
log_debug("%s: dirty %u", __func__, ctx->dirty);
cx = s->cx;
cy = s->cy;
offset = 0;
for (y = 0; y < screen_size_y(s); y++) {
for (x = 0; x < screen_size_x(s); x++) {
offset++;
if (!bit_test(s->dirty, offset - 1))
continue;
bit_clear(s->dirty, offset - 1);
screen_write_cursormove(ctx, x, y);
grid_view_get_cell(s->grid, x, y, &gc);
screen_write_initctx(ctx, &ttyctx);
ttyctx.cell = &gc;
tty_write(tty_cmd_cell, &ttyctx);
ctx->written++;
if (++dirty == ctx->dirty)
break;
}
if (dirty == ctx->dirty)
break;
}
ctx->dirty = 0;
s->cx = cx;
s->cy = cy;
}
/************************************************************************************
*
* ***********************************************************************************/
bool BaaderDome::Ack()
{
int nbytes_written = 0, nbytes_read = 0, rc = -1;
char errstr[MAXRBUF];
char resp[DOME_BUF];
char status[DOME_BUF];
sim = isSimulation();
tcflush(PortFD, TCIOFLUSH);
if (!sim && (rc = tty_write(PortFD, "d#getflap", DOME_CMD, &nbytes_written)) != TTY_OK)
{
tty_error_msg(rc, errstr, MAXRBUF);
DEBUGF(INDI::Logger::DBG_ERROR, "d#getflap Ack error: %s.", errstr);
return false;
}
DEBUG(INDI::Logger::DBG_DEBUG, "CMD (d#getflap)");
if (sim)
{
strncpy(resp, "d#flapclo", DOME_BUF);
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, "Ack error: %s.", errstr);
return false;
}
resp[nbytes_read] = '\0';
DEBUGF(INDI::Logger::DBG_DEBUG, "RES (%s)", resp);
rc = sscanf(resp, "d#%s", status);
if (rc > 0)
return true;
return false;
}
