1 /* 2 * /src/NTP/REPOSITORY/ntp4-dev/libparse/data_mbg.c,v 4.8 2006/06/22 18:40:01 kardel RELEASE_20060622_A 3 * 4 * data_mbg.c,v 4.8 2006/06/22 18:40:01 kardel RELEASE_20060622_A 5 * 6 * $Created: Sun Jul 20 12:08:14 1997 $ 7 * 8 * Copyright (c) 1997-2005 by Frank Kardel <kardel <AT> ntp.org> 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the author nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 */ 35 36 #include <config.h> 37 #ifdef PARSESTREAM 38 #define NEED_BOPS 39 #include "ntp_string.h" 40 #else 41 #include <stdio.h> 42 #endif 43 #include "ntp_types.h" 44 #include "ntp_stdlib.h" 45 #include "ntp_fp.h" 46 #include "ntp_calendar.h" 47 #include "mbg_gps166.h" 48 #include "binio.h" 49 #include "ieee754io.h" 50 51 static void get_mbg_tzname (unsigned char **, char *); 52 static void mbg_time_status_str (char **, unsigned int, int); 53 54 #if 0 /* no actual floats on Meinberg binary interface */ 55 static offsets_t mbg_float = { 1, 0, 3, 2, 0, 0, 0, 0 }; /* byte order for meinberg floats */ 56 #endif 57 static offsets_t mbg_double = { 1, 0, 3, 2, 5, 4, 7, 6 }; /* byte order for meinberg doubles */ 58 static int32 rad2deg_i = 57; 59 static u_int32 rad2deg_f = 0x4BB834C7; /* 57.2957795131 == 180/PI */ 60 61 void 62 put_mbg_header( 63 unsigned char **bufpp, 64 GPS_MSG_HDR *headerp 65 ) 66 { 67 put_lsb_short(bufpp, headerp->cmd); 68 put_lsb_short(bufpp, headerp->len); 69 put_lsb_short(bufpp, headerp->data_csum); 70 put_lsb_short(bufpp, headerp->hdr_csum); 71 } 72 73 void 74 get_mbg_sw_rev( 75 unsigned char **bufpp, 76 SW_REV *sw_revp 77 ) 78 { 79 sw_revp->code = get_lsb_uint16(bufpp); 80 memcpy(sw_revp->name, *bufpp, sizeof(sw_revp->name)); 81 *bufpp += sizeof(sw_revp->name); 82 } 83 84 void 85 get_mbg_ascii_msg( 86 unsigned char **bufpp, 87 ASCII_MSG *ascii_msgp 88 ) 89 { 90 ascii_msgp->csum = (CSUM) get_lsb_short(bufpp); 91 ascii_msgp->valid = get_lsb_int16(bufpp); 92 memcpy(ascii_msgp->s, *bufpp, sizeof(ascii_msgp->s)); 93 *bufpp += sizeof(ascii_msgp->s); 94 } 95 96 void 97 get_mbg_svno( 98 unsigned char **bufpp, 99 SVNO *svnop 100 ) 101 { 102 *svnop = (SVNO) get_lsb_short(bufpp); 103 } 104 105 void 106 get_mbg_health( 107 unsigned char **bufpp, 108 HEALTH *healthp 109 ) 110 { 111 *healthp = (HEALTH) get_lsb_short(bufpp); 112 } 113 114 void 115 get_mbg_cfg( 116 unsigned char **bufpp, 117 CFG *cfgp 118 ) 119 { 120 *cfgp = (CFG) get_lsb_short(bufpp); 121 } 122 123 void 124 get_mbg_tgps( 125 unsigned char **bufpp, 126 T_GPS *tgpsp 127 ) 128 { 129 tgpsp->wn = get_lsb_uint16(bufpp); 130 tgpsp->sec = get_lsb_long(bufpp); 131 tgpsp->tick = get_lsb_long(bufpp); 132 } 133 134 void 135 get_mbg_tm( 136 unsigned char **buffpp, 137 TM_GPS *tmp 138 ) 139 { 140 tmp->year = get_lsb_int16(buffpp); 141 tmp->month = *(*buffpp)++; 142 tmp->mday = *(*buffpp)++; 143 tmp->yday = get_lsb_int16(buffpp); 144 tmp->wday = *(*buffpp)++; 145 tmp->hour = *(*buffpp)++; 146 tmp->min = *(*buffpp)++; 147 tmp->sec = *(*buffpp)++; 148 tmp->frac = get_lsb_long(buffpp); 149 tmp->offs_from_utc = get_lsb_long(buffpp); 150 tmp->status = get_lsb_uint16(buffpp); 151 } 152 153 void 154 get_mbg_ttm( 155 unsigned char **buffpp, 156 TTM *ttmp 157 ) 158 { 159 ttmp->channel = get_lsb_int16(buffpp); 160 get_mbg_tgps(buffpp, &ttmp->t); 161 get_mbg_tm(buffpp, &ttmp->tm); 162 } 163 164 void 165 get_mbg_synth( 166 unsigned char **buffpp, 167 SYNTH *synthp 168 ) 169 { 170 synthp->freq = get_lsb_int16(buffpp); 171 synthp->range = get_lsb_int16(buffpp); 172 synthp->phase = get_lsb_int16(buffpp); 173 } 174 175 static void 176 get_mbg_tzname( 177 unsigned char **buffpp, 178 char *tznamep 179 ) 180 { 181 strlcpy(tznamep, (char *)*buffpp, sizeof(TZ_NAME)); 182 *buffpp += sizeof(TZ_NAME); 183 } 184 185 void 186 get_mbg_tzdl( 187 unsigned char **buffpp, 188 TZDL *tzdlp 189 ) 190 { 191 tzdlp->offs = get_lsb_long(buffpp); 192 tzdlp->offs_dl = get_lsb_long(buffpp); 193 get_mbg_tm(buffpp, &tzdlp->tm_on); 194 get_mbg_tm(buffpp, &tzdlp->tm_off); 195 get_mbg_tzname(buffpp, (char *)tzdlp->name[0]); 196 get_mbg_tzname(buffpp, (char *)tzdlp->name[1]); 197 } 198 199 void 200 get_mbg_antinfo( 201 unsigned char **buffpp, 202 ANT_INFO *antinfop 203 ) 204 { 205 antinfop->status = get_lsb_int16(buffpp); 206 get_mbg_tm(buffpp, &antinfop->tm_disconn); 207 get_mbg_tm(buffpp, &antinfop->tm_reconn); 208 antinfop->delta_t = get_lsb_long(buffpp); 209 } 210 211 static void 212 mbg_time_status_str( 213 char **buffpp, 214 unsigned int status, 215 int size 216 ) 217 { 218 static struct state 219 { 220 int flag; /* bit flag */ 221 const char *string; /* bit name */ 222 } states[] = 223 { 224 { TM_UTC, "UTC CORR" }, 225 { TM_LOCAL, "LOCAL TIME" }, 226 { TM_DL_ANN, "DST WARN" }, 227 { TM_DL_ENB, "DST" }, 228 { TM_LS_ANN, "LEAP WARN" }, 229 { TM_LS_ENB, "LEAP SEC" }, 230 { 0, "" } 231 }; 232 233 if (status) 234 { 235 char *start, *p; 236 struct state *s; 237 238 start = p = *buffpp; 239 240 for (s = states; s->flag; s++) 241 { 242 if (s->flag & status) 243 { 244 if (p != *buffpp) 245 { 246 strlcpy(p, ", ", size - (p - start)); 247 p += 2; 248 } 249 strlcpy(p, s->string, size - (p - start)); 250 p += strlen(p); 251 } 252 } 253 *buffpp = p; 254 } 255 } 256 257 void 258 mbg_tm_str( 259 char **buffpp, 260 TM_GPS *tmp, 261 int size, 262 int print_status 263 ) 264 { 265 char *s = *buffpp; 266 267 snprintf(*buffpp, size, "%04d-%02d-%02d %02d:%02d:%02d.%07ld (%c%02d%02d) ", 268 tmp->year, tmp->month, tmp->mday, 269 tmp->hour, tmp->min, tmp->sec, (long) tmp->frac, 270 (tmp->offs_from_utc < 0) ? '-' : '+', 271 abs((int)tmp->offs_from_utc) / 3600, 272 (abs((int)tmp->offs_from_utc) / 60) % 60); 273 *buffpp += strlen(*buffpp); 274 275 if (print_status) 276 mbg_time_status_str(buffpp, tmp->status, size - (*buffpp - s)); 277 } 278 279 void 280 mbg_tgps_str( 281 char **buffpp, 282 T_GPS *tgpsp, 283 int size 284 ) 285 { 286 snprintf(*buffpp, size, "week %d + %ld days + %ld.%07ld sec", 287 tgpsp->wn, (long) tgpsp->sec / SECSPERDAY, 288 (long) tgpsp->sec % SECSPERDAY, (long) tgpsp->tick); 289 *buffpp += strlen(*buffpp); 290 } 291 292 void 293 get_mbg_cfgh( 294 unsigned char **buffpp, 295 CFGH *cfghp 296 ) 297 { 298 int i; 299 300 cfghp->csum = (CSUM) get_lsb_short(buffpp); 301 cfghp->valid = get_lsb_int16(buffpp); 302 get_mbg_tgps(buffpp, &cfghp->tot_51); 303 get_mbg_tgps(buffpp, &cfghp->tot_63); 304 get_mbg_tgps(buffpp, &cfghp->t0a); 305 306 for (i = 0; i < N_SVNO_GPS; i++) 307 { 308 get_mbg_cfg(buffpp, &cfghp->cfg[i]); 309 } 310 311 for (i = 0; i < N_SVNO_GPS; i++) 312 { 313 get_mbg_health(buffpp, &cfghp->health[i]); 314 } 315 } 316 317 void 318 get_mbg_utc( 319 unsigned char **buffpp, 320 UTC *utcp 321 ) 322 { 323 utcp->csum = (CSUM) get_lsb_short(buffpp); 324 utcp->valid = get_lsb_int16(buffpp); 325 326 get_mbg_tgps(buffpp, &utcp->t0t); 327 328 if (fetch_ieee754(buffpp, IEEE_DOUBLE, &utcp->A0, mbg_double) != IEEE_OK) 329 { 330 L_CLR(&utcp->A0); 331 } 332 333 if (fetch_ieee754(buffpp, IEEE_DOUBLE, &utcp->A1, mbg_double) != IEEE_OK) 334 { 335 L_CLR(&utcp->A1); 336 } 337 338 utcp->WNlsf = get_lsb_uint16(buffpp); 339 utcp->DNt = get_lsb_int16(buffpp); 340 utcp->delta_tls = *(*buffpp)++; 341 utcp->delta_tlsf = *(*buffpp)++; 342 } 343 344 void 345 get_mbg_lla( 346 unsigned char **buffpp, 347 LLA lla 348 ) 349 { 350 int i; 351 352 for (i = LAT; i <= ALT; i++) 353 { 354 if (fetch_ieee754(buffpp, IEEE_DOUBLE, &lla[i], mbg_double) != IEEE_OK) 355 { 356 L_CLR(&lla[i]); 357 } 358 else 359 if (i != ALT) 360 { /* convert to degrees (* 180/PI) */ 361 mfp_mul(&lla[i].l_i, &lla[i].l_uf, lla[i].l_i, lla[i].l_uf, rad2deg_i, rad2deg_f); 362 } 363 } 364 } 365 366 void 367 get_mbg_xyz( 368 unsigned char **buffpp, 369 XYZ xyz 370 ) 371 { 372 int i; 373 374 for (i = XP; i <= ZP; i++) 375 { 376 if (fetch_ieee754(buffpp, IEEE_DOUBLE, &xyz[i], mbg_double) != IEEE_OK) 377 { 378 L_CLR(&xyz[i]); 379 } 380 } 381 } 382 383 static void 384 get_mbg_comparam( 385 unsigned char **buffpp, 386 COM_PARM *comparamp 387 ) 388 { 389 size_t i; 390 391 comparamp->baud_rate = get_lsb_long(buffpp); 392 for (i = 0; i < sizeof(comparamp->framing); i++) 393 { 394 comparamp->framing[i] = *(*buffpp)++; 395 } 396 comparamp->handshake = get_lsb_int16(buffpp); 397 } 398 399 void 400 get_mbg_portparam( 401 unsigned char **buffpp, 402 PORT_PARM *portparamp 403 ) 404 { 405 int i; 406 407 for (i = 0; i < DEFAULT_N_COM; i++) 408 { 409 get_mbg_comparam(buffpp, &portparamp->com[i]); 410 } 411 for (i = 0; i < DEFAULT_N_COM; i++) 412 { 413 portparamp->mode[i] = *(*buffpp)++; 414 } 415 } 416 417 #define FETCH_DOUBLE(src, addr) \ 418 if (fetch_ieee754(src, IEEE_DOUBLE, addr, mbg_double) != IEEE_OK) \ 419 { \ 420 L_CLR(addr); \ 421 } 422 423 void 424 get_mbg_eph( 425 unsigned char ** buffpp, 426 EPH *ephp 427 ) 428 { 429 ephp->csum = (CSUM) get_lsb_short(buffpp); 430 ephp->valid = get_lsb_int16(buffpp); 431 432 ephp->health = (HEALTH) get_lsb_short(buffpp); 433 ephp->IODC = (IOD) get_lsb_short(buffpp); 434 ephp->IODE2 = (IOD) get_lsb_short(buffpp); 435 ephp->IODE3 = (IOD) get_lsb_short(buffpp); 436 437 get_mbg_tgps(buffpp, &ephp->tt); 438 get_mbg_tgps(buffpp, &ephp->t0c); 439 get_mbg_tgps(buffpp, &ephp->t0e); 440 441 FETCH_DOUBLE(buffpp, &ephp->sqrt_A); 442 FETCH_DOUBLE(buffpp, &ephp->e); 443 FETCH_DOUBLE(buffpp, &ephp->M0); 444 FETCH_DOUBLE(buffpp, &ephp->omega); 445 FETCH_DOUBLE(buffpp, &ephp->OMEGA0); 446 FETCH_DOUBLE(buffpp, &ephp->OMEGADOT); 447 FETCH_DOUBLE(buffpp, &ephp->deltan); 448 FETCH_DOUBLE(buffpp, &ephp->i0); 449 FETCH_DOUBLE(buffpp, &ephp->idot); 450 FETCH_DOUBLE(buffpp, &ephp->crc); 451 FETCH_DOUBLE(buffpp, &ephp->crs); 452 FETCH_DOUBLE(buffpp, &ephp->cuc); 453 FETCH_DOUBLE(buffpp, &ephp->cus); 454 FETCH_DOUBLE(buffpp, &ephp->cic); 455 FETCH_DOUBLE(buffpp, &ephp->cis); 456 457 FETCH_DOUBLE(buffpp, &ephp->af0); 458 FETCH_DOUBLE(buffpp, &ephp->af1); 459 FETCH_DOUBLE(buffpp, &ephp->af2); 460 FETCH_DOUBLE(buffpp, &ephp->tgd); 461 462 ephp->URA = get_lsb_uint16(buffpp); 463 464 ephp->L2code = *(*buffpp)++; 465 ephp->L2flag = *(*buffpp)++; 466 } 467 468 void 469 get_mbg_alm( 470 unsigned char **buffpp, 471 ALM *almp 472 ) 473 { 474 almp->csum = (CSUM) get_lsb_short(buffpp); 475 almp->valid = get_lsb_int16(buffpp); 476 477 almp->health = (HEALTH) get_lsb_short(buffpp); 478 get_mbg_tgps(buffpp, &almp->t0a); 479 480 481 FETCH_DOUBLE(buffpp, &almp->sqrt_A); 482 FETCH_DOUBLE(buffpp, &almp->e); 483 484 FETCH_DOUBLE(buffpp, &almp->M0); 485 FETCH_DOUBLE(buffpp, &almp->omega); 486 FETCH_DOUBLE(buffpp, &almp->OMEGA0); 487 FETCH_DOUBLE(buffpp, &almp->OMEGADOT); 488 FETCH_DOUBLE(buffpp, &almp->deltai); 489 FETCH_DOUBLE(buffpp, &almp->af0); 490 FETCH_DOUBLE(buffpp, &almp->af1); 491 } 492 493 void 494 get_mbg_iono( 495 unsigned char **buffpp, 496 IONO *ionop 497 ) 498 { 499 ionop->csum = (CSUM) get_lsb_short(buffpp); 500 ionop->valid = get_lsb_int16(buffpp); 501 502 FETCH_DOUBLE(buffpp, &ionop->alpha_0); 503 FETCH_DOUBLE(buffpp, &ionop->alpha_1); 504 FETCH_DOUBLE(buffpp, &ionop->alpha_2); 505 FETCH_DOUBLE(buffpp, &ionop->alpha_3); 506 507 FETCH_DOUBLE(buffpp, &ionop->beta_0); 508 FETCH_DOUBLE(buffpp, &ionop->beta_1); 509 FETCH_DOUBLE(buffpp, &ionop->beta_2); 510 FETCH_DOUBLE(buffpp, &ionop->beta_3); 511 } 512 513 /* 514 * data_mbg.c,v 515 * Revision 4.8 2006/06/22 18:40:01 kardel 516 * clean up signedness (gcc 4) 517 * 518 * Revision 4.7 2005/10/07 22:11:10 kardel 519 * bounded buffer implementation 520 * 521 * Revision 4.6.2.1 2005/09/25 10:23:06 kardel 522 * support bounded buffers 523 * 524 * Revision 4.6 2005/04/16 17:32:10 kardel 525 * update copyright 526 * 527 * Revision 4.5 2004/11/14 15:29:41 kardel 528 * support PPSAPI, upgrade Copyright to Berkeley style 529 * 530 * Revision 4.3 1999/02/21 12:17:42 kardel 531 * 4.91f reconcilation 532 * 533 * Revision 4.2 1998/06/14 21:09:39 kardel 534 * Sun acc cleanup 535 * 536 * Revision 4.1 1998/05/24 08:02:06 kardel 537 * trimmed version log 538 * 539 * Revision 4.0 1998/04/10 19:45:33 kardel 540 * Start 4.0 release version numbering 541 */ 542 543