自学教程：C++ tty_error_msg函数代码示例

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

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

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