void DDSWidget::receiveValue(double pValue) {
double m_nVoltRangeArray[5]={0.6,1.5,3.5,7.0,13.0};
qDebug() << m_nLineEditIndex << "pValue:" << pValue;
if (m_nLineEditIndex == 4) {
m_nOutputFrequency = validateFrequency(pValue);
qDebug() << "validated frequency:" << m_nOutputFrequency
<< m_strFreqUnit;
m_objLE_OPFreq->setText(QString::number(m_nOutputFrequency, 'f', 3));
ui->FoUnit->setText(m_strFreqUnit);
m_nOutputFrequency = pValue;
ui->leOutputTime->setText(QString::number((validateTime((1 / pValue))),
'f', 3));
ui->opUnit->setText(m_strTimeUnit);
//update on value change---------------------------------------
double l_nFTWOutputFrequency, l_nOutputTime;
l_nFTWOutputFrequency = (m_nOutputFrequency / 50000000);
l_nFTWOutputFrequency = l_nFTWOutputFrequency * pow(2, 32);
l_nOutputTime = 1 / l_nFTWOutputFrequency;
qDebug() << "FTW Output Frequency:" << l_nFTWOutputFrequency;
qDebug() << "FTW Output Time:" << l_nOutputTime;
m_nFTW_LSW = ((unsigned int) l_nFTWOutputFrequency << 16) >> 16;
m_nFTW_MSW = (unsigned int) l_nFTWOutputFrequency >> 16;
qDebug() << "FTW_LSW" << hex << m_nFTW_LSW;
qDebug() << "FTW_MSW" << hex << m_nFTW_MSW;
IAppCard->setDDSFTW_LSW(m_nFTW_LSW);
IAppCard->setDDSFTW_MSW(m_nFTW_MSW);
//---------------------------------------------------------------
} else if (m_nLineEditIndex == 9) {
bool parse(int argc, char **argv, Args &args)
{
for (int i = 0; i < argc; ++i)
{
const char *opt = argv[i];
if (strcmp("-T", opt) == 0 && i+1 < argc)
{
args.timestamp = (Timestamp) QByteArray(argv[++i]).toUInt(&args.hasTimestamp);
if (!args.hasTimestamp || !validateTime(args.timestamp))
return DEBUGRET(false, "invalid timestamp: " << argv[i]);
}
else if (strcmp("-K", opt) == 0 && i+1 < argc)
{
const char *token = argv[++i];
args.token = token;
if (!validateToken(token))
return DEBUGRET(false, "invalid token: " << token);
}
else if ((strcmp("-E", opt) == 0 || strcmp("-G", opt) == 0) && i+1 < argc)
{
const char *name = argv[++i];
if (!validateName(name))
return DEBUGRET(false, "invalid name: " << name);
args.person.isGuest = (strcmp("-G", opt) == 0);
args.person.name = name;
args.person.id = PersonID(0);
}
else if (strcmp("-A", opt) == 0)
{
args.mode = ArriveLeaveMode::Arrive;
}
else if (strcmp("-L", opt) == 0)
{
args.mode = ArriveLeaveMode::Leave;
}
else if (strcmp("-R", opt) == 0 && i+1 < argc)
{
args.room = (RoomID) QByteArray(argv[++i]).toUInt(&args.hasRoom);
if (!args.hasRoom || !validateRoom(args.room))
return false;
}
else if (*opt == '-') // unknown option
{
return DEBUGRET(false, "unknown option: " << opt);
}
else // log file
{
if (!args.path.isEmpty())
return DEBUGRET(false, "path already specified");
args.path = opt;
}
}
// check mandatory values
return (args.hasTimestamp && !args.token.isEmpty() && !args.person.name.isEmpty() &&
args.mode != ArriveLeaveMode::None && !args.path.isEmpty());
}
/*
Parse the a date/time string and return the result in *time. Missing date items may be provided
via the defaults argument. This is a tolerant parser. It is not validating and will do its best
to parse any possible date string.
*/
PUBLIC int websParseDateTime(WebsTime *time, char *dateString, struct tm *defaults)
{
TimeToken *tt;
struct tm tm;
char *str, *next, *token, *cp, *sep;
int64 value;
int kind, hour, min, negate, value1, value2, value3, alpha, alpha2, alpha3;
int dateSep, offset, zoneOffset, explicitZone, fullYear;
if (!dateString) {
dateString = "";
}
offset = 0;
zoneOffset = 0;
explicitZone = 0;
sep = ", \t";
cp = 0;
next = 0;
fullYear = 0;
/*
Set these mandatory values to -1 so we can tell if they are set to valid values
WARNING: all the calculations use tm_year with origin 0, not 1900. It is fixed up below.
*/
tm.tm_year = -MAXINT;
tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_sec = tm.tm_min = tm.tm_wday = -1;
tm.tm_min = tm.tm_sec = tm.tm_yday = -1;
#if ME_UNIX_LIKE && !CYGWIN
tm.tm_gmtoff = 0;
tm.tm_zone = 0;
#endif
/*
Set to -1 to try to determine if DST is in effect
*/
tm.tm_isdst = -1;
str = slower(dateString);
/*
Handle ISO dates: "2009-05-21t16:06:05.000z
*/
if (strchr(str, ' ') == 0 && strchr(str, '-') && str[slen(str) - 1] == 'z') {
for (cp = str; *cp; cp++) {
if (*cp == '-') {
*cp = '/';
} else if (*cp == 't' && cp > str && isdigit((uchar) cp[-1]) && isdigit((uchar) cp[1]) ) {
*cp = ' ';
}
}
}
token = stok(str, sep, &next);
while (token && *token) {
if (snumber(token)) {
/*
Parse either day of month or year. Priority to day of month. Format: <29> Jan <15> <2014>
*/
value = atoi(token);
if (value > 3000) {
*time = value;
return 0;
} else if (value > 32 || (tm.tm_mday >= 0 && tm.tm_year == -MAXINT)) {
if (value >= 1000) {
fullYear = 1;
}
tm.tm_year = (int) value - 1900;
} else if (tm.tm_mday < 0) {
tm.tm_mday = (int) value;
}
} else if ((*token == '+') || (*token == '-') ||
((strncmp(token, "gmt", 3) == 0 || strncmp(token, "utc", 3) == 0) &&
((cp = strchr(&token[3], '+')) != 0 || (cp = strchr(&token[3], '-')) != 0))) {
/*
Timezone. Format: [GMT|UTC][+-]NN[:]NN
*/
if (!isalpha((uchar) *token)) {
cp = token;
}
negate = *cp == '-' ? -1 : 1;
cp++;
hour = getNum(&cp, timeSep);
if (hour >= 100) {
hour /= 100;
}
min = getNum(&cp, timeSep);
zoneOffset = negate * (hour * 60 + min);
explicitZone = 1;
} else if (isalpha((uchar) *token)) {
if ((tt = (TimeToken*) hashLookupSymbol(timeTokens, token)) != 0) {
kind = tt->value & TOKEN_MASK;
value = tt->value & ~TOKEN_MASK;
switch (kind) {
case TOKEN_DAY:
tm.tm_wday = (int) value;
break;
case TOKEN_MONTH:
tm.tm_mon = (int) value;
break;
case TOKEN_OFFSET:
/* Named timezones or symbolic names like: tomorrow, yesterday, next week ... */
/* Units are seconds */
offset += (int) value;
break;
case TOKEN_ZONE:
zoneOffset = (int) value;
explicitZone = 1;
break;
default:
/* Just ignore unknown values */
break;
}
}
} else if ((cp = strchr(token, timeSep)) != 0 && isdigit((uchar) token[0])) {
/*
Time: 10:52[:23]
Must not parse GMT-07:30
*/
tm.tm_hour = getNum(&token, timeSep);
tm.tm_min = getNum(&token, timeSep);
tm.tm_sec = getNum(&token, timeSep);
} else {
dateSep = '/';
if (strchr(token, dateSep) == 0) {
dateSep = '-';
if (strchr(token, dateSep) == 0) {
dateSep = '.';
if (strchr(token, dateSep) == 0) {
dateSep = 0;
}
}
}
if (dateSep) {
/*
Date: 07/28/2014, 07/28/08, Jan/28/2014, Jaunuary-28-2014, 28-jan-2014
Support order: dd/mm/yy, mm/dd/yy and yyyy/mm/dd
Support separators "/", ".", "-"
*/
value1 = getNumOrSym(&token, dateSep, TOKEN_MONTH, &alpha);
value2 = getNumOrSym(&token, dateSep, TOKEN_MONTH, &alpha2);
value3 = getNumOrSym(&token, dateSep, TOKEN_MONTH, &alpha3);
if (value1 > 31) {
/* yy/mm/dd */
tm.tm_year = value1;
tm.tm_mon = value2;
tm.tm_mday = value3;
} else if (value1 > 12 || alpha2) {
/*
dd/mm/yy
Cannot detect 01/02/03 This will be evaluated as Jan 2 2003 below.
*/
tm.tm_mday = value1;
tm.tm_mon = value2;
tm.tm_year = value3;
} else {
/*
The default to parse is mm/dd/yy unless the mm value is out of range
*/
tm.tm_mon = value1;
tm.tm_mday = value2;
tm.tm_year = value3;
}
}
}
token = stok(NULL, sep, &next);
}
/*
Y2K fix and rebias
*/
if (0 <= tm.tm_year && tm.tm_year < 100 && !fullYear) {
if (tm.tm_year < 50) {
tm.tm_year += 2000;
} else {
tm.tm_year += 1900;
}
}
if (tm.tm_year >= 1900) {
tm.tm_year -= 1900;
}
/*
Convert back to origin 0 for months
*/
if (tm.tm_mon > 0) {
tm.tm_mon--;
}
/*
Validate and fill in missing items with defaults
*/
validateTime(&tm, defaults);
*time = makeTime(&tm);
*time += -(zoneOffset * SEC_PER_MIN);
*time += offset;
return 0;
}
/**
* Parse a GPRMC sentence from a string
*
* @param s the string
* @param len the length of the string
* @param pack a pointer to the result structure
* @return 1 (true) - if parsed successfully or 0 (false) otherwise.
*/
int nmea_parse_GPRMC(const char *s, const int len, nmeaGPRMC *pack) {
int token_count;
char time_buff[NMEA_TIMEPARSE_BUF];
int date;
size_t time_buff_len = 0;
assert(s);
assert(pack);
nmea_trace_buff(s, len);
/*
* Clear before parsing, to be able to detect absent fields
*/
time_buff[0] = '\0';
date = -1;
pack->present = 0;
pack->utc.year = -1;
pack->utc.mon = -1;
pack->utc.day = -1;
pack->utc.hour = -1;
pack->utc.min = -1;
pack->utc.sec = -1;
pack->utc.hsec = -1;
pack->status = 0;
pack->lat = NAN;
pack->ns = 0;
pack->lon = NAN;
pack->ew = 0;
pack->speed = NAN;
pack->track = NAN;
pack->magvar = NAN;
pack->magvar_ew = 0;
pack->mode = 0;
/* parse */
token_count = nmea_scanf(s, len, "$GPRMC,%s,%c,%f,%c,%f,%c,%f,%f,%d,%f,%c,%c*", &time_buff[0], &pack->status,
&pack->lat, &pack->ns, &pack->lon, &pack->ew, &pack->speed, &pack->track, &date,
&pack->magvar, &pack->magvar_ew, &pack->mode);
/* see that we have enough tokens */
if ((token_count != 11) && (token_count != 12)) {
nmea_error("GPRMC parse error: need 11 or 12 tokens, got %d in %s", token_count, s);
return 0;
}
/* determine which fields are present and validate them */
time_buff_len = strlen(&time_buff[0]);
if (time_buff_len) {
if (!_nmea_parse_time(&time_buff[0], time_buff_len, &pack->utc)) {
return 0;
}
if (!validateTime(&pack->utc)) {
return 0;
}
nmea_INFO_set_present(&pack->present, UTCTIME);
}
if (!pack->status) {
pack->status = 'V';
} else {
pack->status = toupper(pack->status);
if (!((pack->status == 'A') || (pack->status == 'V'))) {
nmea_error("GPRMC parse error: invalid status (%c)", pack->status);
return 0;
}
}
if (!isnan(pack->lat) && (pack->ns)) {
if (!validateNSEW(&pack->ns, true)) {
return 0;
}
nmea_INFO_set_present(&pack->present, LAT);
}
if (!isnan(pack->lon) && (pack->ew)) {
if (!validateNSEW(&pack->ew, false)) {
return 0;
}
nmea_INFO_set_present(&pack->present, LON);
}
if (!isnan(pack->speed)) {
nmea_INFO_set_present(&pack->present, SPEED);
}
if (!isnan(pack->track)) {
nmea_INFO_set_present(&pack->present, TRACK);
}
if (date != -1) {
if (!_nmea_parse_date(date, &pack->utc)) {
return 0;
}
if (!validateDate(&pack->utc)) {
return 0;
}
nmea_INFO_set_present(&pack->present, UTCDATE);
}
if (!isnan(pack->magvar) && (pack->magvar_ew)) {
if (!validateNSEW(&pack->magvar_ew, false)) {
return 0;
}
nmea_INFO_set_present(&pack->present, MAGVAR);
}
if (token_count == 11) {
pack->mode = 'A';
} else {
if (!pack->mode) {
pack->mode = 'N';
} else {
if (!validateMode(&pack->mode)) {
return 0;
}
}
}
return 1;
}
/**
* Parse a GPGGA sentence from a string
*
* @param s the string
* @param len the length of the string
* @param pack a pointer to the result structure
* @return 1 (true) - if parsed successfully or 0 (false) otherwise.
*/
int nmea_parse_GPGGA(const char *s, const int len, nmeaGPGGA *pack) {
int token_count;
char time_buff[NMEA_TIMEPARSE_BUF];
size_t time_buff_len = 0;
assert(s);
assert(pack);
nmea_trace_buff(s, len);
/*
* Clear before parsing, to be able to detect absent fields
*/
time_buff[0] = '\0';
pack->present = 0;
pack->utc.hour = -1;
pack->utc.min = -1;
pack->utc.sec = -1;
pack->utc.hsec = -1;
pack->lat = NAN;
pack->ns = 0;
pack->lon = NAN;
pack->ew = 0;
pack->sig = -1;
pack->satinuse = -1;
pack->HDOP = NAN;
pack->elv = NAN;
pack->elv_units = 0;
pack->diff = 0; /* ignored */
pack->diff_units = 0; /* ignored */
pack->dgps_age = 0; /* ignored */
pack->dgps_sid = 0; /* ignored */
/* parse */
token_count = nmea_scanf(s, len, "$GPGGA,%s,%f,%c,%f,%c,%d,%d,%f,%f,%c,%f,%c,%f,%d*", &time_buff[0], &pack->lat,
&pack->ns, &pack->lon, &pack->ew, &pack->sig, &pack->satinuse, &pack->HDOP, &pack->elv, &pack->elv_units,
&pack->diff, &pack->diff_units, &pack->dgps_age, &pack->dgps_sid);
/* see that we have enough tokens */
if (token_count != 14) {
nmea_error("GPGGA parse error: need 14 tokens, got %d in %s", token_count, s);
return 0;
}
/* determine which fields are present and validate them */
time_buff_len = strlen(&time_buff[0]);
if (time_buff_len > (NMEA_TIMEPARSE_BUF - 1))
time_buff_len = NMEA_TIMEPARSE_BUF - 1;
if (time_buff_len) {
if (!_nmea_parse_time(&time_buff[0], time_buff_len, &pack->utc)) {
return 0;
}
if (!validateTime(&pack->utc)) {
return 0;
}
nmea_INFO_set_present(&pack->present, UTCTIME);
}
if (!isnan(pack->lat) && (pack->ns)) {
if (!validateNSEW(&pack->ns, true)) {
return 0;
}
nmea_INFO_set_present(&pack->present, LAT);
}
if (!isnan(pack->lon) && (pack->ew)) {
if (!validateNSEW(&pack->ew, false)) {
return 0;
}
nmea_INFO_set_present(&pack->present, LON);
}
if (pack->sig != -1) {
if (!((pack->sig >= NMEA_SIG_FIRST) && (pack->sig <= NMEA_SIG_LAST))) {
nmea_error("GPGGA parse error: invalid signal %d, expected [%d, %d]", pack->sig, NMEA_SIG_FIRST, NMEA_SIG_LAST);
return 0;
}
nmea_INFO_set_present(&pack->present, SIG);
}
if (pack->satinuse != -1) {
nmea_INFO_set_present(&pack->present, SATINUSECOUNT);
}
if (!isnan(pack->HDOP)) {
nmea_INFO_set_present(&pack->present, HDOP);
}
if (!isnan(pack->elv) && (pack->elv_units)) {
if (pack->elv_units != 'M') {
nmea_error("GPGGA parse error: invalid elevation unit (%c)", pack->elv_units);
return 0;
}
nmea_INFO_set_present(&pack->present, ELV);
}
/* ignore diff and diff_units */
/* ignore dgps_age and dgps_sid */
return 1;
}
