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