bool lacerta_mfoc::SetTempComp(double values[], char *names[], int n) { LOGF_INFO("-> TEMPCOMP_SETTINGS", 0); char MFOC_cmd[32] = ": D "; char MFOC_res[32] = {0}; int nbytes_read = 0; int nbytes_written = 0; int MFOC_tc_measd = 0; int tc_int = 0; char tc_char[32] = {0}; char MFOC_res_type[32] = "0"; TempCompNP.s = IPS_OK; IUUpdateNumber(&TempCompNP, values, names, n); tc_int = TempCompN[0].value; sprintf(tc_char, "%d", tc_int); strcat(tc_char, " #"); strcat(MFOC_cmd, tc_char); tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); tty_write_string(PortFD, ": U #", &nbytes_written); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf (MFOC_res, "%s %d", MFOC_res_type, &MFOC_tc_measd); LOGF_DEBUG("RES <%s>", MFOC_res); IDSetNumber(&TempCompNP, nullptr); return true; }
bool lacerta_mfoc::SetBacklash(double values[], char *names[], int n) { LOGF_DEBUG("-> BACKLASH_SETTINGS", 0); char MFOC_cmd[32] = ": B "; char MFOC_res[32] = {0}; int nbytes_read = 0; int nbytes_written = 0; int MFOC_tdir_measd = 0; int bl_int = 0; char bl_char[32] = {0}; char MFOC_res_type[32] = "0"; BacklashNP.s = IPS_OK; IUUpdateNumber(&BacklashNP, values, names, n); bl_int = BacklashN[0].value; sprintf(bl_char, "%d", bl_int); strcat(bl_char, " #"); strcat(MFOC_cmd, bl_char); tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); tty_write_string(PortFD, ": J #", &nbytes_written); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf (MFOC_res, "%s %d", MFOC_res_type, &MFOC_tdir_measd); LOGF_DEBUG("RES <%s>", MFOC_res); IDSetNumber(&BacklashNP, nullptr); return true; }
bool lacerta_mfoc::SetFocuserMaxPosition(uint32_t ticks) { char MFOC_cmd[32] = ": G "; char MFOC_res[32] = {0}; int nbytes_read = 0; int nbytes_written = 0; int MFOC_pm_measd = 0; char pm_char[32] = {0}; char MFOC_res_type[32] = "0"; sprintf(pm_char, "%d", ticks); strcat(pm_char, " #"); strcat(MFOC_cmd, pm_char); tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); tty_write_string(PortFD, ": O #", &nbytes_written); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf (MFOC_res, "%s %d", MFOC_res_type, &MFOC_pm_measd); LOGF_DEBUG("RES <%s>", MFOC_res); return true; }
bool lacerta_mfoc::Handshake() { char MFOC_cmd[32] = ": Q #"; char MFOC_res[32] = {0}; char MFOC_res_type[32] = "0"; int MFOC_pos_measd = 0; int nbytes_written = 0; int nbytes_read = 0; tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_INFO("CMD <%s>", MFOC_cmd); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); LOGF_DEBUG("RES <%s>", MFOC_res_type); sscanf(MFOC_res, "%s %d", MFOC_res_type, &MFOC_pos_measd); if (MFOC_res_type[0] == 'P') { FocusAbsPosN[0].value = MFOC_pos_measd; FocusAbsPosNP.s = IPS_OK; return true; } return false; }
int ioptronHC8406::setioptronHC8406TrackMode(int mode) { char cmd[8]; int mmode=0; int error_type=0; int nbytes_write = 0 ; DEBUGF(DBG_SCOPE, "<%s>", __FUNCTION__); if (mode == 0 ) { mmode=2; } else if (mode ==1) { mmode=1; } else if (mode ==2) { mmode=0; } else if (mode ==3) { mmode=9; } snprintf(cmd, 8, ":RT%d#", mmode); DEBUGF(DBG_SCOPE, "CMD <%s>", cmd); //None return value so just write cmd and exit without reading the response if ((error_type = tty_write_string(PortFD, cmd, &nbytes_write)) != TTY_OK) return error_type; return 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 ioptronHC8406::ioptronHC8406SyncCMR(char *matchedObject) { int error_type; int nbytes_write = 0; int nbytes_read = 0; DEBUGF(INDI::Logger::DBG_DEBUG, "CMD <%s>", ":CMR#"); if ((error_type = tty_write_string(PortFD, ":CMR#", &nbytes_write)) != TTY_OK) return error_type; if ((error_type = tty_read_section(PortFD, matchedObject, '#', 3, &nbytes_read)) != TTY_OK) return error_type; matchedObject[nbytes_read - 1] = '\0'; DEBUGF(INDI::Logger::DBG_DEBUG, "RES <%s>", matchedObject); /* Sleep 10ms before flushing. This solves some issues with LX200 compatible devices. */ usleep(10000); tcflush(PortFD, TCIFLUSH); return 0; }
int ioptronHC8406::getCommandString(int fd, char *data, const char *cmd) { char *term; int error_type; int nbytes_write = 0, nbytes_read = 0; if ((error_type = tty_write_string(fd, cmd, &nbytes_write)) != TTY_OK) return error_type; error_type = tty_read_section(fd, data, '#', ioptronHC8406_TIMEOUT, &nbytes_read); tcflush(fd, TCIFLUSH); if (error_type != TTY_OK) return error_type; term = strchr(data, '#'); if (term) *term = '\0'; return 0; }
IPState lacerta_mfoc::MoveAbsFocuser(uint32_t targetTicks) { char MFOC_cmd[32] = ": M "; char abs_pos_char[32] = {0}; int nbytes_written = 0; //int pos = GetAbsFocuserPosition(); sprintf(abs_pos_char, "%d", targetTicks); strcat(abs_pos_char, " #"); strcat(MFOC_cmd, abs_pos_char); tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); //Waiting makes no sense - will be immediatly interrupted by the ekos system... //int ticks = std::abs((int)(targetTicks - pos) * FOCUS_MOTION_DELAY); //LOGF_INFO("sleep for %d ms", ticks); //usleep(ticks + 5000); FocusAbsPosN[0].value = targetTicks; //only for debugging! Maybe there is a bug in the MFOC firmware command "Q #"! GetAbsFocuserPosition(); return IPS_OK; }
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 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 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; }
bool ioptronHC8406::Park() { DEBUGF(DBG_SCOPE, "<%s>", __FUNCTION__); int error_type; int nbytes_write = 0; if ((error_type = tty_write_string(PortFD, ":KA#", &nbytes_write)) != TTY_OK) return error_type; tcflush(PortFD, TCIFLUSH); DEBUG(DBG_SCOPE, "CMD <:KA#>"); EqNP.s = IPS_BUSY; TrackState = SCOPE_PARKING; DEBUG(INDI::Logger::DBG_SESSION, "Parking is in progress..."); return true; }
bool Paramount::Handshake() { if (isSimulation()) return true; int rc = 0, nbytes_written = 0, nbytes_read = 0; char pCMD[MAXRBUF]={0}, pRES[MAXRBUF]={0}; strncpy(pCMD, "/* Java Script */" "var Out;" "sky6RASCOMTele.ConnectAndDoNotUnpark();" "Out = sky6RASCOMTele.IsConnected;", MAXRBUF); LOGF_DEBUG("CMD: %s", pCMD); if ((rc = tty_write_string(PortFD, pCMD, &nbytes_written)) != TTY_OK) { LOG_ERROR("Error writing to TheSky6 TCP server."); return false; } // Should we read until we encounter string terminator? or what? if (static_cast<int>(rc == tty_read_section(PortFD, pRES, '\0', PARAMOUNT_TIMEOUT, &nbytes_read)) != TTY_OK) { LOG_ERROR("Error reading from TheSky6 TCP server."); return false; } LOGF_DEBUG("RES: %s", pRES); int isTelescopeConnected = -1; std::regex rgx(R"((\d+)\|(.+)\. Error = (\d+)\.)"); std::smatch match; std::string input(pRES); if (std::regex_search(input, match, rgx)) isTelescopeConnected = atoi(match.str(1).c_str()); if (isTelescopeConnected <= 0) { LOGF_ERROR("Error connecting to telescope: %s (%d).", match.str(1).c_str(), atoi(match.str(2).c_str())); return false; }
int ioptronHC8406::setCalenderDate(int fd, int dd, int mm, int yy) { char read_buffer[16]; char response[67]; char good_result[] = ioptronHC8406_CALDATE_RESULT; int error_type; int nbytes_write = 0, nbytes_read = 0; yy = yy % 100; snprintf(read_buffer, sizeof(read_buffer), ":SC %02d:%02d:%02d#", mm, dd, yy); DEBUGF(DBG_SCOPE, "CMD <%s>", read_buffer); tcflush(fd, TCIFLUSH); /* Sleep 100ms before flushing. This solves some issues with LX200 compatible devices. */ //usleep(10); if ((error_type = tty_write_string(fd, read_buffer, &nbytes_write)) != TTY_OK) return error_type; error_type = tty_read(fd, response, sizeof(response), ioptronHC8406_TIMEOUT, &nbytes_read); tcflush(fd, TCIFLUSH); if (nbytes_read < 1) { DEBUG(INDI::Logger::DBG_ERROR, "Unable to read response"); return error_type; } response[nbytes_read] = '\0'; DEBUGF(DBG_SCOPE, "RES <%s>", response); if (strncmp(response, good_result, strlen(good_result)) == 0) { return 0; } tcflush(fd, TCIFLUSH); DEBUGF(INDI::Logger::DBG_DEBUG, "Set date failed! Response: <%s>", response); return -1; }
bool QHYCFW2::SelectFilter(int f) { TargetFilter = f; char cmd[8] = {0}, res[8]={0}; int rc = -1, nbytes_written=0, nbytes_read=0; LOGF_DEBUG("CMD <%d>", TargetFilter-1); snprintf(cmd, 2, "%d", TargetFilter-1); if (isSimulation()) snprintf(res, 8, "%d", TargetFilter-1); else { if ((rc = tty_write_string(PortFD, cmd, &nbytes_written)) != TTY_OK) { char error_message[ERRMSG_SIZE]; tty_error_msg(rc, error_message, ERRMSG_SIZE); LOGF_ERROR("Sending command select filter failed: %s", error_message); return false; } if ((rc = tty_read(PortFD, res, 1, 30, &nbytes_read)) != TTY_OK) { char error_message[ERRMSG_SIZE]; tty_error_msg(rc, error_message, ERRMSG_SIZE); LOGF_ERROR("Reading select filter response failed: %s", error_message); return false; } LOGF_DEBUG("RES <%s>", res); } if (atoi(res)+1 == TargetFilter) { CurrentFilter = TargetFilter; SelectFilterDone(CurrentFilter); return true; } return false; }
uint32_t lacerta_mfoc::GetAbsFocuserPosition() { char MFOC_cmd[32] = ": Q #"; char MFOC_res[32] = {0}; char MFOC_res_type[32] = "0"; int MFOC_pos_measd = 0; int nbytes_written = 0; int nbytes_read = 0; do { tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_INFO("CMD <%s>", MFOC_cmd); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf(MFOC_res, "%s %d", MFOC_res_type, &MFOC_pos_measd); } while(strcmp(MFOC_res_type, "P") != 0); LOGF_DEBUG("RES <%s>", MFOC_res_type); LOGF_DEBUG("current position: %d", MFOC_pos_measd); return static_cast<uint32_t>(MFOC_pos_measd); }
int ioptronHC8406::setioptronHC8406StandardProcedure(int fd, const char *data) { char bool_return[2]; int error_type=0; int nbytes_write = 0, nbytes_read = 0; DEBUGF(DBG_SCOPE, "CMD <%s>", data); if ((error_type = tty_write_string(fd, data, &nbytes_write)) != TTY_OK) return error_type; error_type = tty_read(fd, bool_return, 1, 5, &nbytes_read); // JM: Hack from Jon in the INDI forums to fix longitude/latitude settings failure usleep(10000); tcflush(fd, TCIFLUSH); usleep(10000); if (nbytes_read < 1) return error_type; DEBUGF(DBG_SCOPE, "RES <%c>", bool_return[0]); if (bool_return[0] == '0') { DEBUGF(DBG_SCOPE, "CMD <%s> failed.", data); return -1; } DEBUGF(DBG_SCOPE, "CMD <%s> successful.", data); return 0; }
bool lacerta_mfoc::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) { if (dev != nullptr && strcmp(dev, getDeviceName()) == 0) { // Temp. Track Direction if (strcmp(TempTrackDirSP.name, name) == 0) { IUUpdateSwitch(&TempTrackDirSP, states, names, n); int tdir = 0; int index = IUFindOnSwitchIndex(&TempTrackDirSP); char MFOC_cmd[32] = ": I "; char MFOC_res[32] = {0}; int nbytes_read = 0; int nbytes_written = 0; int MFOC_tdir_measd = 0; char MFOC_res_type[32] = "0"; switch (index) { case MODE_TDIR_BOTH: tdir = 0; strcat(MFOC_cmd, "0 #"); break; case MODE_TDIR_IN: tdir = 1; strcat(MFOC_cmd, "1 #"); break; case MODE_TDIR_OUT: tdir = 2; strcat(MFOC_cmd, "2 #"); break; default: TempTrackDirSP.s = IPS_ALERT; IDSetSwitch(&TempTrackDirSP, "Unknown mode index %d", index); return true; } tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); tty_write_string(PortFD, ": W #", &nbytes_written); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf (MFOC_res, "%s %d", MFOC_res_type, &MFOC_tdir_measd); LOGF_DEBUG("RES <%s>", MFOC_res); if (MFOC_tdir_measd == tdir) { TempTrackDirSP.s = IPS_OK; } else { TempTrackDirSP.s = IPS_ALERT; } IDSetSwitch(&TempTrackDirSP, nullptr); return true; } // Start at saved position if (strcmp(StartSavedPositionSP.name, name) == 0) { IUUpdateSwitch(&StartSavedPositionSP, states, names, n); int svstart = 0; int index = IUFindOnSwitchIndex(&StartSavedPositionSP); char MFOC_cmd[32] = ": F "; char MFOC_res[32] = {0}; int nbytes_read = 0; int nbytes_written = 0; int MFOC_svstart_measd = 0; char MFOC_res_type[32] = "0"; switch (index) { case MODE_SAVED_ON: svstart = 1; strcat(MFOC_cmd, "1 #"); break; case MODE_SAVED_OFF: svstart = 0; strcat(MFOC_cmd, "0 #"); break; default: StartSavedPositionSP.s = IPS_ALERT; IDSetSwitch(&StartSavedPositionSP, "Unknown mode index %d", index); return true; } tty_write_string(PortFD, MFOC_cmd, &nbytes_written); LOGF_DEBUG("CMD <%s>", MFOC_cmd); tty_write_string(PortFD, ": N #", &nbytes_written); tty_read_section(PortFD, MFOC_res, 0xD, FOCUSMFOC_TIMEOUT, &nbytes_read); sscanf (MFOC_res, "%s %d", MFOC_res_type, &MFOC_svstart_measd); LOGF_DEBUG("RES <%s>", MFOC_res); // LOGF_DEBUG("Debug MFOC cmd sent %s", MFOC_cmd); if (MFOC_svstart_measd == svstart) { StartSavedPositionSP.s = IPS_OK; } else { StartSavedPositionSP.s = IPS_ALERT; } IDSetSwitch(&StartSavedPositionSP, nullptr); return true; } } return INDI::Focuser::ISNewSwitch(dev, name, states, names, n); }
bool QFW::SelectFilter(int position) { // count from 0 to 6 for positions 1 to 7 position = position - 1; if (position < 0 || position > 6) return false; if (isSimulation()) { CurrentFilter = position + 1; SelectFilterDone(CurrentFilter); return true; } // goto char targetpos[255]={0}; char curpos[255]={0}; char dmp[255]; int err; int nbytes; // format target position G[0-6] sprintf(targetpos, "G%d\r\n ", position); // write command //int len = strlen(targetpos); err = tty_write_string(PortFD, targetpos, &nbytes); if (err) { char errmsg[255]; tty_error_msg(err, errmsg, MAXRBUF); LOGF_ERROR("Serial write error: %s", errmsg); return false; } //res = write(PortFD, targetpos, len); dump(dmp, targetpos); LOGF_DEBUG("CMD: %s", dmp); // format target marker P[0-6] sprintf(targetpos, "P%d", position); // check current position do { usleep(100 * 1000); //res = read(PortFD, curpos, 255); err = tty_read_section(PortFD, curpos, '\n', QUANTUM_TIMEOUT, &nbytes); if (err) { char errmsg[255]; tty_error_msg(err, errmsg, MAXRBUF); LOGF_ERROR("Serial read error: %s", errmsg); return false; } curpos[nbytes] = 0; dump(dmp, curpos); LOGF_DEBUG("REP: %s", dmp); } while (strncmp(targetpos, curpos, 2) != 0); // return current position to indi CurrentFilter = position + 1; SelectFilterDone(CurrentFilter); LOGF_DEBUG("CurrentFilter set to %d", CurrentFilter); return true; }