/* --------------------------------------------------
* Gets the LEDs which this element and the ones below, wants to be on
* or off. Normaly this is also the keys to react, but it doesn't have
* to be this way ...
* --------------------------------------------------*/
Leds ModeCheckBox::GetLedsStatus()
{
if(IsReadOnly() || mChecked)
{
return COMBINE(NO_LED,NO_LED);
}
return COMBINE(NO_LED,OK_LED);
}
u_long Scm_EqvHash(ScmObj obj)
{
u_long hashval;
if (SCM_NUMBERP(obj)) {
if (SCM_INTP(obj)) {
SMALL_INT_HASH(hashval, SCM_INT_VALUE(obj));
} else if (SCM_BIGNUMP(obj)) {
u_int i;
u_long u = 0;
for (i=0; i<SCM_BIGNUM_SIZE(obj); i++) {
u += SCM_BIGNUM(obj)->values[i];
}
SMALL_INT_HASH(hashval, u);
} else if (SCM_FLONUMP(obj)) {
/* TODO: I'm not sure this is a good hash. */
hashval = (u_long)(SCM_FLONUM_VALUE(obj)*2654435761UL);
} else if (SCM_RATNUMP(obj)) {
/* Ratnum must be normalized, so we can simply combine
hashvals of numerator and denominator. */
u_long h1 = Scm_EqvHash(SCM_RATNUM_NUMER(obj));
u_long h2 = Scm_EqvHash(SCM_RATNUM_DENOM(obj));
hashval = COMBINE(h1, h2);
} else {
/* TODO: I'm not sure this is a good hash. */
hashval = (u_long)((SCM_COMPNUM_REAL(obj)+SCM_COMPNUM_IMAG(obj))*2654435761UL);
}
} else {
ADDRESS_HASH(hashval, obj);
}
return hashval&HASHMASK;
}
int main(void)
{
int y1 = 5;
int x2 = 4;
//printf("y_1=%d",COMBINE(y,1));
printf("x_2=%d",COMBINE(2));
return 0;
}
/* General hash function */
u_long Scm_Hash(ScmObj obj)
{
u_long hashval;
if (!SCM_PTRP(obj)) {
SMALL_INT_HASH(hashval, (u_long)SCM_WORD(obj));
return hashval;
} else if (SCM_NUMBERP(obj)) {
return Scm_EqvHash(obj);
} else if (SCM_STRINGP(obj)) {
goto string_hash;
} else if (SCM_PAIRP(obj)) {
u_long h = 0, h2;
ScmObj cp;
SCM_FOR_EACH(cp, obj) {
h2 = Scm_Hash(SCM_CAR(cp));
h = COMBINE(h, h2);
}
h2 = Scm_Hash(cp);
h = COMBINE(h, h2);
return h;
} else if (SCM_VECTORP(obj)) {
uint8_t DIA_resizeWiz(RESWIZ_FORMAT *format, RESWIZ_AR *source, RESWIZ_AR *destination)
{
uint8_t r=0;
GtkWidget *dialog=create_dialog1();
// Initialize
#define COMBINE(x,y) gtk_combo_box_set_active(GTK_COMBO_BOX(WID(x)),(int)*y)
COMBINE(comboboxSource,source);
COMBINE(comboboxFinal,destination);
COMBINE(comboboxTarget,format);
gtk_register_dialog(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_OK)
{
r=1;
#undef COMBINE
#define COMBINE(x) gtk_combo_box_get_active(GTK_COMBO_BOX(WID(x)));
*format=(RESWIZ_FORMAT) COMBINE(comboboxTarget);
*source=(RESWIZ_AR) COMBINE(comboboxSource);
*destination=(RESWIZ_AR)COMBINE(comboboxFinal);
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return r;
}
void SEARCHER::do_move(const int& move) {
int from = m_from(move),to = m_to(move),sq;
/*remove captured piece*/
if(m_capture(move)) {
if(is_ep(move)) {
sq = to - pawn_dir[player];
} else {
sq = to;
}
pcRemove(m_capture(move),sq);
board[sq] = empty;
}
/*move piece*/
if(m_promote(move)) {
board[to] = m_promote(move);
board[from] = empty;
pcAdd(m_promote(move),to);
pcRemove(COMBINE(player,pawn),from);
} else {
board[to] = board[from];
board[from] = empty;
pcSwap(from,to);
}
/*move castle*/
if(is_castle(move)) {
int fromc,toc;
if(to > from) {
fromc = to + RR;
toc = to + LL;
} else {
fromc = to + 2*LL;
toc = to + RR;
}
board[toc] = board[fromc];
board[fromc] = empty;
pcSwap(fromc,toc);
}
/*update current state*/
epsquare = 0;
fifty++;
if(DECOMB(player,m_piece(move)) == pawn) {
fifty = 0;
if(to - from == (2 * pawn_dir[player])) {
epsquare = ((to + from) >> 1);
}
// Processes a just-completed term
// Returns true if new sentence has just passed checksum test and is validated
bool Gps::term_complete()
{
//Console.println("compl");
if (_is_checksum_term)
{
byte checksum = (byte)(16 * from_hex(_term[0]) + from_hex(_term[1]));
//Console.print(checksum);
//Console.print(",");
//Console.println(_parity);
if (checksum == _parity)
{
//if (1==1)
if (_gps_data_good)
{
#ifndef _GPS_NO_STATS
++_good_sentences;
#endif
_last_time_fix = _new_time_fix;
_last_position_fix = _new_position_fix;
switch (_sentence_type)
{
case _GPS_SENTENCE_GPRMC:
_time = _new_time;
_date = _new_date;
_latitude = _new_latitude;
_longitude = _new_longitude;
_speed = _new_speed;
_course = _new_course;
break;
case _GPS_SENTENCE_GPGGA:
_altitude = _new_altitude;
_time = _new_time;
_latitude = _new_latitude;
_longitude = _new_longitude;
_numsats = _new_numsats;
_hdop = _new_hdop;
break;
default:
break;
}
return true;
}
}
#ifndef _GPS_NO_STATS
else
{
++_failed_checksum;
}
#endif
return false;
}
// the first term determines the sentence type
if (_term_number == 0)
{
if (!gpsstrcmp(_term, _GPRMC_TERM))
{
_sentence_type = _GPS_SENTENCE_GPRMC;
}
else if (!gpsstrcmp(_term, _GPGGA_TERM))
{
_sentence_type = _GPS_SENTENCE_GPGGA;
}
else
{
_sentence_type = _GPS_SENTENCE_OTHER;
}
return false;
}
if (_sentence_type != _GPS_SENTENCE_OTHER && _term[0])
{
switch (COMBINE(_sentence_type, _term_number))
{
case COMBINE(_GPS_SENTENCE_GPRMC, 1): // Time in both sentences
case COMBINE(_GPS_SENTENCE_GPGGA, 1):
_new_time = parse_decimal();
_new_time_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 2): // GPRMC validity
_gps_data_good = _term[0] == 'A';
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 3): // Latitude
case COMBINE(_GPS_SENTENCE_GPGGA, 2):
_new_latitude = parse_degrees();
_new_position_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 4): // N/S
case COMBINE(_GPS_SENTENCE_GPGGA, 3):
if (_term[0] == 'S')
_new_latitude = -_new_latitude;
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 5): // Longitude
case COMBINE(_GPS_SENTENCE_GPGGA, 4):
_new_longitude = parse_degrees();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 6): // E/W
case COMBINE(_GPS_SENTENCE_GPGGA, 5):
if (_term[0] == 'W')
_new_longitude = -_new_longitude;
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 7): // Speed (GPRMC)
_new_speed = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 8): // Course (GPRMC)
_new_course = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 9): // Date (GPRMC)
_new_date = gpsatol(_term);
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 6): // Fix data (GPGGA) ; 0=invalid, 1=GPS fix, 2=DGPS fix, 6=estimation
_gps_data_good = _term[0] > '0';
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 7): // NN-Satellites used (GPGGA): 00-12
_new_numsats = (unsigned char)atoi(_term);
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 8): // D.D - HDOP (GPGGA) - horizontal deviation
_new_hdop = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 9): // H.H - Altitude (GPGGA)
_new_altitude = parse_decimal();
break;
default:
break;
}
}
return false;
}
const char *Console::ColourToString(char IRCColour)
{
switch (IRCColour)
{
case '0':
return COLOUR(COMBINE(LIGHT, WHITE));
case '1':
return COLOUR(COMBINE(DARK, BLACK));
case '2':
return COLOUR(COMBINE(LIGHT, RED));
case '3':
return COLOUR(BROWN);
case '4':
return COLOUR(COMBINE(LIGHT, BROWN));
case '5':
return COLOUR(COMBINE(LIGHT, GREEN));
case '6':
case '7':
return COLOUR(GREEN);
case '8':
return COLOUR(COMBINE(LIGHT, CYAN));
case '9':
return COLOUR(COMBINE(LIGHT, BLUE));
case ':':
return COLOUR(BLUE);
case ';':
return COLOUR(MAGENTA);
case '<':
case '=':
return COLOUR(COMBINE(LIGHT, MAGENTA));
case '>':
return COLOUR(WHITE);
case '?':
return COLOUR(COMBINE(DARK, WHITE));
case '@':
return COLOUR(COMBINE(DARK, RED));
case 'A':
return COLOUR(COMBINE(DARK, BROWN));
case 'B':
return COLOUR(BROWN);
case 'C':
case 'D':
case 'E':
return COLOUR(COMBINE(DARK, GREEN));
case 'F':
return COLOUR(COMBINE(DARK, CYAN));
case 'G':
case 'H':
return COLOUR(COMBINE(DARK, BLUE));
case 'I':
case 'J':
case 'K':
return COLOUR(COMBINE(DARK, MAGENTA));
}
return "\x1B[0m";
}
uint8_t Nordic::term_complete() {
uint8_t ret_val = _SENTENCE_NONE;
// the first term determines the sentence type
if (_term_number == 0) {
if (!nstrcmp(_term, _LOC_TERM))
_sentence_type = _SENTENCE_LOC;
else if (!nstrcmp(_term, _HRM_TERM))
_sentence_type = _SENTENCE_HRM;
else if (!nstrcmp(_term, _CAD_TERM))
_sentence_type = _SENTENCE_CAD;
else if (!nstrcmp(_term, _ANCS_TERM))
_sentence_type = _SENTENCE_ANCS;
else if (!nstrcmp(_term, _PC_TERM))
_sentence_type = _SENTENCE_PC;
else if (!nstrcmp(_term, _BTN_TERM))
_sentence_type = _SENTENCE_BTN;
else if (!nstrcmp(_term, _DBG_TERM))
_sentence_type = _SENTENCE_DBG;
else
_sentence_type = _SENTENCE_OTHER;
return false;
}
if (_sentence_type != _SENTENCE_OTHER && _term[0]) {
// on doit parser l'info (_term)
switch (COMBINE(_sentence_type, _term_number)) {
case COMBINE(_SENTENCE_LOC, 1):
_sec_jour = natol(_term);
break;
case COMBINE(_SENTENCE_LOC, 2):
_lat = parse_sint();
break;
case COMBINE(_SENTENCE_LOC, 3):
_lon = parse_sint();
break;
case COMBINE(_SENTENCE_LOC, 4):
_ele = parse_sint();
break;
case COMBINE(_SENTENCE_LOC, 5):
_gps_speed = parse_sint();
ret_val = _SENTENCE_LOC;
break;
case COMBINE(_SENTENCE_HRM, 1):
_bpm = natol(_term);
break;
case COMBINE(_SENTENCE_HRM, 2):
_rr = natol(_term);
ret_val = _SENTENCE_HRM;
break;
case COMBINE(_SENTENCE_CAD, 1):
_rpm = natol(_term);
break;
case COMBINE(_SENTENCE_CAD, 2):
_cad_speed = natol(_term);
ret_val = _SENTENCE_CAD;
break;
case COMBINE(_SENTENCE_ANCS, 1):
_ancs_type = natol(_term);
break;
case COMBINE(_SENTENCE_ANCS, 2):
if (_ancs_type == 0) {
_ancs_msg = _term;
ret_val = _SENTENCE_ANCS;
} else {
_ancs_title = _term;
}
break;
case COMBINE(_SENTENCE_ANCS, 3):
_ancs_msg = _term;
ret_val = _SENTENCE_ANCS;
break;
case COMBINE(_SENTENCE_DBG, 1):
_dbg_type = natol(_term);
break;
case COMBINE(_SENTENCE_DBG, 2):
_dbg_code = natol(_term);
break;
case COMBINE(_SENTENCE_DBG, 3):
_dbg_line = natol(_term);
if (_dbg_type == 0) {
ret_val = _SENTENCE_DBG;
}
break;
case COMBINE(_SENTENCE_DBG, 4):
if (_dbg_type == 1) {
_dbg_file = _term;
ret_val = _SENTENCE_DBG;
}
break;
case COMBINE(_SENTENCE_BTN, 1):
_btn = natol(_term) + 1;
ret_val = _SENTENCE_BTN;
break;
case COMBINE(_SENTENCE_PC, 1):
_pc = natol(_term);
ret_val = _SENTENCE_PC;
break;
}
}
return ret_val;
}
need_flush |= nv50_validate_tsc(nv50, 2);
if (need_flush) {
BEGIN_NV04(nv50->base.pushbuf, NV50_3D(TSC_FLUSH), 1);
PUSH_DATA (nv50->base.pushbuf, 0);
}
}
/* There can be up to 4 different MS levels (1, 2, 4, 8). To simplify the
* shader logic, allow each one to take up 8 offsets.
*/
#define COMBINE(x, y) x, y
#define DUMMY 0, 0
static const uint32_t msaa_sample_xy_offsets[] = {
/* MS1 */
COMBINE(0, 0),
DUMMY,
DUMMY,
DUMMY,
DUMMY,
DUMMY,
DUMMY,
DUMMY,
/* MS2 */
COMBINE(0, 0),
COMBINE(1, 0),
DUMMY,
DUMMY,
DUMMY,
DUMMY,
#endif
typedef union {
uint32_t w[16];
uint64_t d[8];
#ifdef __SSE2__
__m128i q[4];
#endif
} salsa20_blk_t;
static inline void salsa20_simd_shuffle(const salsa20_blk_t *Bin,
salsa20_blk_t *Bout)
{
#define COMBINE(out, in1, in2) \
Bout->d[out] = Bin->w[in1 * 2] | ((uint64_t)Bin->w[in2 * 2 + 1] << 32);
COMBINE(0, 0, 2)
COMBINE(1, 5, 7)
COMBINE(2, 2, 4)
COMBINE(3, 7, 1)
COMBINE(4, 4, 6)
COMBINE(5, 1, 3)
COMBINE(6, 6, 0)
COMBINE(7, 3, 5)
#undef COMBINE
}
static inline void salsa20_simd_unshuffle(const salsa20_blk_t *Bin,
salsa20_blk_t *Bout)
{
#define UNCOMBINE(out, in1, in2) \
Bout->w[out * 2] = Bin->d[in1]; \
// Processes a just-completed term
// Returns true if new sentence has just passed checksum test and is validated
bool TinyGPSPlus::endOfTermHandler()
{
// If it's the checksum term, and the checksum checks out, commit
if (isChecksumTerm)
{
byte checksum = 16 * fromHex(term[0]) + fromHex(term[1]);
if (checksum == parity)
{
passedChecksumCount++;
if (sentenceHasFix)
++sentencesWithFixCount;
switch(curSentenceType)
{
case GPS_SENTENCE_GPRMC:
date.commit();
time.commit();
if (sentenceHasFix)
{
location.commit();
speed.commit();
course.commit();
}
break;
case GPS_SENTENCE_GPGGA:
time.commit();
if (sentenceHasFix)
{
location.commit();
altitude.commit();
}
satellites.commit();
hdop.commit();
break;
}
// Commit all custom listeners of this sentence type
for (TinyGPSCustom *p = customCandidates; p != NULL && strcmp(p->sentenceName, customCandidates->sentenceName) == 0; p = p->next)
p->commit();
return true;
}
else
{
++failedChecksumCount;
}
return false;
}
// the first term determines the sentence type
if (curTermNumber == 0)
{
if (!strcmp(term, _GPRMCterm))
curSentenceType = GPS_SENTENCE_GPRMC;
else if (!strcmp(term, _GPGGAterm))
curSentenceType = GPS_SENTENCE_GPGGA;
else
curSentenceType = GPS_SENTENCE_OTHER;
// Any custom candidates of this sentence type?
for (customCandidates = customElts; customCandidates != NULL && strcmp(customCandidates->sentenceName, term) < 0; customCandidates = customCandidates->next);
if (customCandidates != NULL && strcmp(customCandidates->sentenceName, term) > 0)
customCandidates = NULL;
return false;
}
if (curSentenceType != GPS_SENTENCE_OTHER && term[0])
switch(COMBINE(curSentenceType, curTermNumber))
{
case COMBINE(GPS_SENTENCE_GPRMC, 1): // Time in both sentences
case COMBINE(GPS_SENTENCE_GPGGA, 1):
time.setTime(term);
break;
case COMBINE(GPS_SENTENCE_GPRMC, 2): // GPRMC validity
sentenceHasFix = term[0] == 'A';
break;
case COMBINE(GPS_SENTENCE_GPRMC, 3): // Latitude
case COMBINE(GPS_SENTENCE_GPGGA, 2):
location.setLatitude(term);
break;
case COMBINE(GPS_SENTENCE_GPRMC, 4): // N/S
case COMBINE(GPS_SENTENCE_GPGGA, 3):
location.rawNewLatData.negative = term[0] == 'S';
break;
case COMBINE(GPS_SENTENCE_GPRMC, 5): // Longitude
case COMBINE(GPS_SENTENCE_GPGGA, 4):
location.setLongitude(term);
break;
case COMBINE(GPS_SENTENCE_GPRMC, 6): // E/W
case COMBINE(GPS_SENTENCE_GPGGA, 5):
location.rawNewLngData.negative = term[0] == 'W';
break;
case COMBINE(GPS_SENTENCE_GPRMC, 7): // Speed (GPRMC)
speed.set(term);
break;
case COMBINE(GPS_SENTENCE_GPRMC, 8): // Course (GPRMC)
course.set(term);
break;
case COMBINE(GPS_SENTENCE_GPRMC, 9): // Date (GPRMC)
date.setDate(term);
break;
case COMBINE(GPS_SENTENCE_GPGGA, 6): // Fix data (GPGGA)
sentenceHasFix = term[0] > '0';
break;
case COMBINE(GPS_SENTENCE_GPGGA, 7): // Satellites used (GPGGA)
satellites.set(term);
break;
case COMBINE(GPS_SENTENCE_GPGGA, 8): // HDOP
hdop.set(term);
break;
case COMBINE(GPS_SENTENCE_GPGGA, 9): // Altitude (GPGGA)
altitude.set(term);
break;
}
// Set custom values as needed
for (TinyGPSCustom *p = customCandidates; p != NULL && strcmp(p->sentenceName, customCandidates->sentenceName) == 0 && p->termNumber <= curTermNumber; p = p->next)
if (p->termNumber == curTermNumber)
p->set(term);
return false;
}
/*****************************************************************************
* Function
* DESCRIPTION:
* Constructor
*****************************************************************************/
WriteValueToDataPointAtKeyPressAndJumpToSpecificDisplay::WriteValueToDataPointAtKeyPressAndJumpToSpecificDisplay(Component* pParent) : Component(pParent)
{
mCheckState = 0;
mLegalKeys = MPC_OK_KEY;
mLedsStatus = COMBINE(NO_LED,OK_LED);
}
static intnat caml_ba_hash(value v)
{
struct caml_ba_array * b = Caml_ba_array_val(v);
intnat num_elts, n, h;
int i;
num_elts = 1;
for (i = 0; i < b->num_dims; i++) num_elts = num_elts * b->dim[i];
if (num_elts >= 50) num_elts = 50;
h = 0;
#define COMBINE(h,v) ((h << 4) + h + (v))
switch (b->flags & CAML_BA_KIND_MASK) {
case CAML_BA_SINT8:
case CAML_BA_UINT8: {
uint8 * p = b->data;
for (n = 0; n < num_elts; n++) h = COMBINE(h, *p++);
break;
}
case CAML_BA_SINT16:
case CAML_BA_UINT16: {
uint16 * p = b->data;
for (n = 0; n < num_elts; n++) h = COMBINE(h, *p++);
break;
}
case CAML_BA_FLOAT32:
case CAML_BA_COMPLEX32:
case CAML_BA_INT32:
#ifndef ARCH_SIXTYFOUR
case CAML_BA_CAML_INT:
case CAML_BA_NATIVE_INT:
#endif
{
uint32 * p = b->data;
for (n = 0; n < num_elts; n++) h = COMBINE(h, *p++);
break;
}
case CAML_BA_FLOAT64:
case CAML_BA_COMPLEX64:
case CAML_BA_INT64:
#ifdef ARCH_SIXTYFOUR
case CAML_BA_CAML_INT:
case CAML_BA_NATIVE_INT:
#endif
#ifdef ARCH_SIXTYFOUR
{
uintnat * p = b->data;
for (n = 0; n < num_elts; n++) h = COMBINE(h, *p++);
break;
}
#else
{
uint32 * p = b->data;
for (n = 0; n < num_elts; n++) {
#ifdef ARCH_BIG_ENDIAN
h = COMBINE(h, p[1]); h = COMBINE(h, p[0]); p += 2;
#else
h = COMBINE(h, p[0]); h = COMBINE(h, p[1]); p += 2;
#endif
}
break;
}
#endif
}
#undef COMBINE
return h;
}
void CNoiseEditor::OnPaint()
{
ASSERT(m_pBackDC != NULL);
CPaintDC dc(this);
DrawBackground(m_pBackDC, m_iItems, false, 0);
DrawRange(m_pBackDC, m_iItems, 0);
// Return now if no sequence is selected
if (!m_pSequence) {
PaintBuffer(m_pBackDC, &dc);
return;
}
// Draw items
int Count = m_pSequence->GetItemCount();
if (!Count) {
PaintBuffer(m_pBackDC, &dc);
return;
}
int StepWidth = GetItemWidth();
int StepHeight = m_GraphRect.Height() / m_iItems;
// Draw items
for (int i = 0; i < Count; i++) {
// Draw noise frequency
int item = m_pSequence->GetItem(i) & 0x1F;
int x = m_GraphRect.left + i * StepWidth + 1;
int y = m_GraphRect.top + StepHeight * (m_iItems - item);
int w = StepWidth;
int h = StepHeight;//* item;
if (m_iCurrentPlayPos == i)
DrawPlayRect(m_pBackDC, x, y, w, h);
else
DrawRect(m_pBackDC, x, y, w, h);
// Draw switches
item = m_pSequence->GetItem(i);
int Offset = h * 36 - 1;
if (item & S5B_MODE_SQUARE) {
static const COLORREF BUTTON_COL = COMBINE(0, 160, 160);
int y = Offset;
int h = 9;
m_pBackDC->FillSolidRect(x, y, w, h, BUTTON_COL);
m_pBackDC->Draw3dRect(x, y, w, h, BLEND(BUTTON_COL, 0xFFFFFF, 80), BLEND(BUTTON_COL, 0x000000, 80));
}
else {
static const COLORREF BUTTON_COL = COMBINE(50, 50, 50);
int y = Offset;
int h = 9;
m_pBackDC->FillSolidRect(x, y, w, h, BUTTON_COL);
m_pBackDC->Draw3dRect(x, y, w, h, BLEND(BUTTON_COL, 0xFFFFFF, 80), BLEND(BUTTON_COL, 0x000000, 80));
}
if (item & S5B_MODE_NOISE) {
static const COLORREF BUTTON_COL = COMBINE(160, 0, 160);
int y = Offset + 11;
int h = 9;
m_pBackDC->FillSolidRect(x, y, w, h, BUTTON_COL);
m_pBackDC->Draw3dRect(x, y, w, h, BLEND(BUTTON_COL, 0xFFFFFF, 80), BLEND(BUTTON_COL, 0x000000, 80));
}
else {
static const COLORREF BUTTON_COL = COMBINE(50, 50, 50);
int y = Offset + 11;
int h = 9;
m_pBackDC->FillSolidRect(x, y, w, h, BUTTON_COL);
m_pBackDC->Draw3dRect(x, y, w, h, BLEND(BUTTON_COL, 0xFFFFFF, 80), BLEND(BUTTON_COL, 0x000000, 80));
}
}
DrawLoopPoint(m_pBackDC, StepWidth);
DrawReleasePoint(m_pBackDC, StepWidth);
DrawLine(m_pBackDC);
PaintBuffer(m_pBackDC, &dc);
}
// Processes a just-completed term
// Returns true if new sentence has just passed checksum test and is validated
bool ParserNMEA::term_complete()
{
if (_is_checksum_term)
{
byte checksum = 16 * from_hex(_term[0]) + from_hex(_term[1]);
if (checksum == _parity)
{
if (_gps_data_good)
{
#ifndef _GPS_NO_STATS
++_good_sentences;
#endif
_last_time_fix = _new_time_fix;
_last_position_fix = _new_position_fix;
switch(_sentence_type)
{
case _GPS_SENTENCE_GPRMC:
_time = _new_time;
_latitude = _new_latitude;
_longitude = _new_longitude;
_speed = _new_speed;
break;
case _GPS_SENTENCE_GPVTG:
_speed = _new_speed;
break;
case _GPS_SENTENCE_GPZDA:
_time = _new_time;
_day = _new_day;
_month = _new_month;
_year = _new_year;
break;
case _GPS_SENTENCE_GPGGA:
_time = _new_time;
_latitude = _new_latitude;
_longitude = _new_longitude;
_hdop = _new_hdop;
break;
}
return true;
}
}
#ifndef _GPS_NO_STATS
else
++_failed_checksum;
#endif
return false;
}
// the first term determines the sentence type
if (_term_number == 0)
{
if (!gpsstrcmp(_term, _GPZDA_TERM))
_sentence_type = _GPS_SENTENCE_GPZDA;
else if (!gpsstrcmp(_term, _GPGGA_TERM))
_sentence_type = _GPS_SENTENCE_GPGGA;
else if (!gpsstrcmp(_term, _GPVTG_TERM))
_sentence_type = _GPS_SENTENCE_GPVTG;
else
_sentence_type = _GPS_SENTENCE_OTHER;
return false;
}
if (_sentence_type != _GPS_SENTENCE_OTHER && _term[0])
switch(COMBINE(_sentence_type, _term_number))
{
case COMBINE(_GPS_SENTENCE_GPZDA, 1): // Time in ZDA
_new_time = parse_decimal();
_new_time_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 2): // GPRMC validity
_gps_data_good = _term[0] == 'A';
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 3): // Latitude
_new_latitude = parse_degrees();
_new_position_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 2):
_new_latitude = parse_degrees();
_new_position_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 4): // N/S
if (_term[0] == 'S')
_new_latitude = -_new_latitude;
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 3):
if (_term[0] == 'S')
_new_latitude = -_new_latitude;
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 4):
_new_longitude = parse_degrees();
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 5):
if (_term[0] == 'W')
_new_longitude = -_new_longitude;
break;
case COMBINE(_GPS_SENTENCE_GPVTG, 5): // Speed (GPVTG)
_new_speed = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 8): // Course (GPRMC)
_new_course = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPZDA, 2): // Date/day (GPZDA)
_new_day = (unsigned char)atoi(_term);
break;
case COMBINE(_GPS_SENTENCE_GPZDA, 3): // Date/month (GPZDA)
_new_month = (unsigned char)atoi(_term);
break;
case COMBINE(_GPS_SENTENCE_GPZDA, 4): // Date/year (GPZDA)
_new_year = parse_decimal() / 100;
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 6): // Fix data (GPGGA)
_gps_data_good = _term[0] > '0';
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 8): // HDOP
_new_hdop = parse_decimal();
break;
}
return false;
}
// Processes a just-completed term
// Returns true if new sentence has just passed checksum test and is validated
bool TinyGPS::term_complete()
{
if (_is_checksum_term)
{
byte checksum = 16 * from_hex(_term[0]) + from_hex(_term[1]);
if (checksum == _parity)
{
if (_gps_data_good)
{
#ifndef _GPS_NO_STATS
++_good_sentences;
#endif
_last_time_fix = _new_time_fix;
_last_position_fix = _new_position_fix;
switch(_sentence_type)
{
case _GPS_SENTENCE_GPRMC:
_time = _new_time;
_date = _new_date;
_latitude = _new_latitude;
_longitude = _new_longitude;
_speed = _new_speed;
_course = _new_course;
break;
case _GPS_SENTENCE_GPGGA:
_altitude = _new_altitude;
_time = _new_time;
_latitude = _new_latitude;
_longitude = _new_longitude;
_numsats = _new_numsats;
_hdop = _new_hdop;
break;
}
return true;
}
}
#ifndef _GPS_NO_STATS
else
++_failed_checksum;
#endif
return false;
}
// the first term determines the sentence type
if (_term_number == 0)
{
if (!gpsstrcmp(_term, _GPRMC_TERM))
_sentence_type = _GPS_SENTENCE_GPRMC;
else if (!gpsstrcmp(_term, _GPGGA_TERM))
_sentence_type = _GPS_SENTENCE_GPGGA;
else
_sentence_type = _GPS_SENTENCE_OTHER;
return false;
}
if (_sentence_type != _GPS_SENTENCE_OTHER && _term[0])
switch(COMBINE(_sentence_type, _term_number))
{
case COMBINE(_GPS_SENTENCE_GPRMC, 1): // Time in both sentences
case COMBINE(_GPS_SENTENCE_GPGGA, 1):
_new_time = parse_decimal();
_new_time_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 2): // GPRMC validity
_gps_data_good = _term[0] == 'A';
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 3): // Latitude
case COMBINE(_GPS_SENTENCE_GPGGA, 2):
_new_latitude = parse_degrees();
_new_position_fix = millis();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 4): // N/S
case COMBINE(_GPS_SENTENCE_GPGGA, 3):
if (_term[0] == 'S')
_new_latitude = -_new_latitude;
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 5): // Longitude
case COMBINE(_GPS_SENTENCE_GPGGA, 4):
_new_longitude = parse_degrees();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 6): // E/W
case COMBINE(_GPS_SENTENCE_GPGGA, 5):
if (_term[0] == 'W')
_new_longitude = -_new_longitude;
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 7): // Speed (GPRMC)
_new_speed = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 8): // Course (GPRMC)
_new_course = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPRMC, 9): // Date (GPRMC)
_new_date = gpsatol(_term);
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 6): // Fix data (GPGGA)
_gps_data_good = _term[0] > '0';
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 7): // Satellites used (GPGGA)
_new_numsats = (unsigned char)atoi(_term);
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 8): // HDOP
_new_hdop = parse_decimal();
break;
case COMBINE(_GPS_SENTENCE_GPGGA, 9): // Altitude (GPGGA)
_new_altitude = parse_decimal();
break;
}
return false;
}
void parse_gps_term(void)
{
if (gps_checksum_term)
{
unsigned char checksum = 16 * gps_from_hex(gps_term[0]) + gps_from_hex(gps_term[1]);
if (checksum == gps_parity)
{
if (gps_data_good)
{
gps_last_time_fix = gps_new_time_fix;
gps_last_position_fix = gps_new_position_fix;
switch(gps_sentence_type)
{
case GPS_SENTENCE_GPRMC:
gps_time = gps_new_time;
gps_date = gps_new_date;
gps_latitude = gps_new_latitude;
gps_longitude = gps_new_longitude;
gps_speed = gps_new_speed;
gps_course = gps_new_course;
break;
case GPS_SENTENCE_GPGGA:
gps_altitude = gps_new_altitude;
gps_time = gps_new_time;
gps_latitude = gps_new_latitude;
gps_longitude = gps_new_longitude;
gps_numsats = gps_new_numsats;
gps_hdop = gps_new_hdop;
break;
}
return;
}
}
return;
}
// the first term determines the sentence type
if (gps_term_number == 0)
{
if (!gpsstrcmp(gps_term, GPRMC_TERM))
gps_sentence_type = GPS_SENTENCE_GPRMC;
else if (!gpsstrcmp(gps_term, GPGGA_TERM))
gps_sentence_type = GPS_SENTENCE_GPGGA;
else
gps_sentence_type = GPS_SENTENCE_OTHER;
return;
}
if (gps_sentence_type != GPS_SENTENCE_OTHER && gps_term[0])
switch(COMBINE(gps_sentence_type, gps_term_number))
{
case COMBINE(GPS_SENTENCE_GPRMC, 1): // Time in both sentences
case COMBINE(GPS_SENTENCE_GPGGA, 1):
gps_new_time = gps_parse_decimal();
gps_new_time_fix = main_get_msclock_ticks();
break;
case COMBINE(GPS_SENTENCE_GPRMC, 2): // GPRMC validity
gps_data_good = gps_term[0] == 'A';
break;
case COMBINE(GPS_SENTENCE_GPRMC, 3): // Latitude
case COMBINE(GPS_SENTENCE_GPGGA, 2):
gps_new_latitude = gps_parse_degrees();
gps_new_position_fix = main_get_msclock_ticks();
break;
case COMBINE(GPS_SENTENCE_GPRMC, 4): // N/S
case COMBINE(GPS_SENTENCE_GPGGA, 3):
if (gps_term[0] == 'S')
gps_new_latitude = -gps_new_latitude;
break;
case COMBINE(GPS_SENTENCE_GPRMC, 5): // Longitude
case COMBINE(GPS_SENTENCE_GPGGA, 4):
gps_new_longitude = gps_parse_degrees();
break;
case COMBINE(GPS_SENTENCE_GPRMC, 6): // E/W
case COMBINE(GPS_SENTENCE_GPGGA, 5):
if (gps_term[0] == 'W')
gps_new_longitude = -gps_new_longitude;
break;
case COMBINE(GPS_SENTENCE_GPRMC, 7): // Speed (GPRMC)
gps_new_speed = gps_parse_decimal();
break;
case COMBINE(GPS_SENTENCE_GPRMC, 8): // Course (GPRMC)
gps_new_course = gps_parse_decimal();
break;
case COMBINE(GPS_SENTENCE_GPRMC, 9): // Date (GPRMC)
gps_new_date = gpsatol(gps_term);
break;
case COMBINE(GPS_SENTENCE_GPGGA, 6): // Fix data (GPGGA)
gps_data_good = gps_term[0] > '0';
break;
case COMBINE(GPS_SENTENCE_GPGGA, 7): // Satellites used (GPGGA)
gps_new_numsats = (unsigned char)atoi(gps_term);
break;
case COMBINE(GPS_SENTENCE_GPGGA, 8): // HDOP
gps_new_hdop = gps_parse_decimal();
break;
case COMBINE(GPS_SENTENCE_GPGGA, 9): // Altitude (GPGGA)
gps_new_altitude = gps_parse_decimal();
break;
}
}
