git.gag.com Git - fw/altos/blob - altoslib/AltosState.java

   1 /*
   2  * Copyright © 2010 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 /*
  19  * Track flight state from telemetry or eeprom data stream
  20  */
  21
  22 package org.altusmetrum.altoslib_1;
  23
  24 public class AltosState implements Cloneable {
  25         public AltosRecord record;
  26
  27         public static final int set_position = 1;
  28         public static final int set_gps = 2;
  29         public static final int set_data = 4;
  30
  31         public int set;
  32
  33         static final double ascent_filter_len = 0.1;
  34         static final double descent_filter_len = 2.0;
  35
  36         /* derived data */
  37
  38         public long     received_time;
  39
  40         public double   time;
  41         public double   prev_time;
  42         public double   time_change;
  43         public int      tick;
  44         private int     prev_tick;
  45         public int      boost_tick;
  46
  47         class AltosValue {
  48                 private double  value;
  49                 private double  prev_value;
  50                 private double  max_value;
  51                 private double  set_time;
  52                 private double  prev_set_time;
  53                 private double  max_rate = 1000.0;
  54
  55                 void set(double new_value, double time) {
  56                         if (new_value != AltosRecord.MISSING) {
  57                                 value = new_value;
  58                                 if (max_value == AltosRecord.MISSING || value > max_value) {
  59                                         max_value = value;
  60                                 }
  61                                 set_time = time;
  62                         }
  63                 }
  64
  65                 void set_filtered(double new_value, double time) {
  66                         if (prev_value != AltosRecord.MISSING)
  67                                 new_value = (prev_value * 15.0 + new_value) / 16.0;
  68                         set(new_value, time);
  69                 }
  70
  71                 double value() {
  72                         return value;
  73                 }
  74
  75                 double max() {
  76                         return max_value;
  77                 }
  78
  79                 double prev() {
  80                         return prev_value;
  81                 }
  82
  83                 double change() {
  84                         if (value != AltosRecord.MISSING && prev_value != AltosRecord.MISSING)
  85                                 return value - prev_value;
  86                         return AltosRecord.MISSING;
  87                 }
  88
  89                 double rate() {
  90                         double c = change();
  91                         double t = set_time - prev_set_time;
  92
  93                         if (c != AltosRecord.MISSING && t != 0)
  94                                 return c / t;
  95                         return AltosRecord.MISSING;
  96                 }
  97
  98                 double integrate() {
  99                         if (value == AltosRecord.MISSING)
 100                                 return AltosRecord.MISSING;
 101                         if (prev_value == AltosRecord.MISSING)
 102                                 return AltosRecord.MISSING;
 103
 104                         return (value + prev_value) / 2 * (set_time - prev_set_time);
 105                 }
 106
 107                 double time() {
 108                         return set_time;
 109                 }
 110
 111                 void set_derivative(AltosValue in) {
 112                         double  n = in.rate();
 113
 114                         if (n == AltosRecord.MISSING)
 115                                 return;
 116
 117                         double  p = prev_value;
 118                         double  pt = prev_set_time;
 119
 120                         if (p == AltosRecord.MISSING) {
 121                                 p = 0;
 122                                 pt = in.time() - 0.01;
 123                         }
 124
 125                         /* Clip changes to reduce noise */
 126                         double  ddt = in.time() - pt;
 127                         double  ddv = (n - p) / ddt;
 128
 129                         /* 100gs */
 130                         if (Math.abs(ddv) > 1000) {
 131                                 if (n > p)
 132                                         n = p + ddt * 1000;
 133                                 else
 134                                         n = p - ddt * 1000;
 135                         }
 136
 137                         double filter_len;
 138
 139                         if (ascent)
 140                                 filter_len = ascent_filter_len;
 141                         else
 142                                 filter_len = descent_filter_len;
 143
 144                         double f = 1/Math.exp(ddt/ filter_len);
 145                         n = p * f + n * (1-f);
 146
 147                         set(n, in.time());
 148                 }
 149
 150                 void set_integral(AltosValue in) {
 151                         double  change = in.integrate();
 152
 153                         if (change != AltosRecord.MISSING)
 154                                 set(prev_value + change, in.time());
 155                 }
 156
 157                 void copy(AltosValue old) {
 158                         value = old.value;
 159                         set_time = old.set_time;
 160                         prev_value = old.value;
 161                         prev_set_time = old.set_time;
 162                         max_value = old.max_value;
 163                 }
 164
 165                 AltosValue() {
 166                         value = AltosRecord.MISSING;
 167                         prev_value = AltosRecord.MISSING;
 168                         max_value = AltosRecord.MISSING;
 169                 }
 170         }
 171
 172         class AltosCValue {
 173                 AltosValue      measured;
 174                 AltosValue      computed;
 175
 176                 double value() {
 177                         double v = measured.value();
 178                         if (v != AltosRecord.MISSING)
 179                                 return v;
 180                         return computed.value();
 181                 }
 182
 183                 boolean is_measured() {
 184                         return measured.value() != AltosRecord.MISSING;
 185                 }
 186
 187                 double max() {
 188                         double m = measured.max();
 189
 190                         if (m != AltosRecord.MISSING)
 191                                 return m;
 192                         return computed.max();
 193                 }
 194
 195                 double prev_value() {
 196                         if (measured.value != AltosRecord.MISSING && measured.prev_value != AltosRecord.MISSING)
 197                                 return measured.prev_value;
 198                         return computed.prev_value;
 199                 }
 200
 201                 AltosValue altos_value() {
 202                         if (measured.value() != AltosRecord.MISSING)
 203                                 return measured;
 204                         return computed;
 205                 }
 206
 207                 double change() {
 208                         double c = measured.change();
 209                         if (c == AltosRecord.MISSING)
 210                                 c = computed.change();
 211                         return c;
 212                 }
 213
 214                 double rate() {
 215                         double r = measured.rate();
 216                         if (r == AltosRecord.MISSING)
 217                                 r = computed.rate();
 218                         return r;
 219                 }
 220
 221                 void set_measured(double new_value, double time) {
 222                         measured.set(new_value, time);
 223                 }
 224
 225                 void set_computed(double new_value, double time) {
 226                         computed.set(new_value, time);
 227                 }
 228
 229                 void set_derivative(AltosValue in) {
 230                         computed.set_derivative(in);
 231                 }
 232
 233                 void set_derivative(AltosCValue in) {
 234                         set_derivative(in.altos_value());
 235                 }
 236
 237                 void set_integral(AltosValue in) {
 238                         computed.set_integral(in);
 239                 }
 240
 241                 void set_integral(AltosCValue in) {
 242                         set_integral(in.altos_value());
 243                 }
 244
 245                 void copy(AltosCValue old) {
 246                         measured.copy(old.measured);
 247                         computed.copy(old.computed);
 248                 }
 249
 250                 AltosCValue() {
 251                         measured = new AltosValue();
 252                         computed = new AltosValue();
 253                 }
 254         }
 255
 256         public int      state;
 257         public int      flight;
 258         public int      serial;
 259         public boolean  landed;
 260         public boolean  ascent; /* going up? */
 261         public boolean  boost;  /* under power */
 262         public int      rssi;
 263         public int      status;
 264         public int      device_type;
 265         public int      config_major;
 266         public int      config_minor;
 267         public int      apogee_delay;
 268         public int      main_deploy;
 269         public int      flight_log_max;
 270
 271         private double pressure_to_altitude(double p) {
 272                 if (p == AltosRecord.MISSING)
 273                         return AltosRecord.MISSING;
 274                 return AltosConvert.pressure_to_altitude(p);
 275         }
 276
 277         private AltosCValue ground_altitude;
 278
 279         public double ground_altitude() {
 280                 return ground_altitude.value();
 281         }
 282
 283         public void set_ground_altitude(double a) {
 284                 ground_altitude.set_measured(a, time);
 285         }
 286
 287         class AltosGroundPressure extends AltosCValue {
 288                 void set_filtered(double p, double time) {
 289                         computed.set_filtered(p, time);
 290                         ground_altitude.set_computed(pressure_to_altitude(computed.value()), time);
 291                 }
 292
 293                 void set_measured(double p, double time) {
 294                         super.set_measured(p, time);
 295                         ground_altitude.set_computed(pressure_to_altitude(p), time);
 296                 }
 297         }
 298
 299         private AltosGroundPressure ground_pressure;
 300
 301         public double ground_pressure() {
 302                 return ground_pressure.value();
 303         }
 304
 305         public void set_ground_pressure (double pressure) {
 306                 ground_pressure.set_measured(pressure, time);
 307         }
 308
 309         class AltosAltitude extends AltosCValue {
 310
 311                 private void set_speed(AltosValue v) {
 312                         if (!acceleration.is_measured() || !ascent)
 313                                 speed.set_derivative(this);
 314                 }
 315
 316                 void set_computed(double a, double time) {
 317                         super.set_computed(a,time);
 318                         set_speed(computed);
 319                         set |= set_position;
 320                 }
 321
 322                 void set_measured(double a, double time) {
 323                         super.set_measured(a,time);
 324                         set_speed(measured);
 325                         set |= set_position;
 326                 }
 327         }
 328
 329         private AltosAltitude   altitude;
 330
 331         public double altitude() {
 332                 double a = altitude.value();
 333                 if (a != AltosRecord.MISSING)
 334                         return a;
 335                 if (gps != null)
 336                         return gps.alt;
 337                 return AltosRecord.MISSING;
 338         }
 339
 340         public double max_altitude() {
 341                 double a = altitude.max();
 342                 if (a != AltosRecord.MISSING)
 343                         return a;
 344                 return AltosRecord.MISSING;
 345         }
 346
 347         public void set_altitude(double new_altitude) {
 348                 altitude.set_measured(new_altitude, time);
 349         }
 350
 351         class AltosPressure extends AltosValue {
 352                 void set(double p, double time) {
 353                         super.set(p, time);
 354                         if (state == AltosLib.ao_flight_pad)
 355                                 ground_pressure.set_filtered(p, time);
 356                         double a = pressure_to_altitude(p);
 357                         altitude.set_computed(a, time);
 358                 }
 359         }
 360
 361         private AltosPressure   pressure;
 362
 363         public double pressure() {
 364                 return pressure.value();
 365         }
 366
 367         public void set_pressure(double p) {
 368                 pressure.set(p, time);
 369         }
 370
 371         public double height() {
 372                 double k = kalman_height.value();
 373                 if (k != AltosRecord.MISSING)
 374                         return k;
 375
 376                 double a = altitude();
 377                 double g = ground_altitude();
 378                 if (a != AltosRecord.MISSING && g != AltosRecord.MISSING)
 379                         return a - g;
 380                 return AltosRecord.MISSING;
 381         }
 382
 383         public double max_height() {
 384                 double  k = kalman_height.max();
 385                 if (k != AltosRecord.MISSING)
 386                         return k;
 387
 388                 double a = altitude.max();
 389                 double g = ground_altitude();
 390                 if (a != AltosRecord.MISSING && g != AltosRecord.MISSING)
 391                         return a - g;
 392                 return AltosRecord.MISSING;
 393         }
 394
 395         class AltosSpeed extends AltosCValue {
 396
 397                 void set_accel() {
 398                         acceleration.set_derivative(this);
 399                 }
 400
 401                 void set_derivative(AltosCValue in) {
 402                         super.set_derivative(in);
 403                         set_accel();
 404                 }
 405
 406                 void set_computed(double new_value, double time) {
 407                         super.set_computed(new_value, time);
 408                         set_accel();
 409                 }
 410
 411                 void set_measured(double new_value, double time) {
 412                         super.set_measured(new_value, time);
 413                         set_accel();
 414                 }
 415         }
 416
 417         private AltosSpeed speed;
 418
 419         public double speed() {
 420                 return speed.value();
 421         }
 422
 423         public double max_speed() {
 424                 return speed.max();
 425         }
 426
 427         class AltosAccel extends AltosCValue {
 428                 void set_measured(double a, double time) {
 429                         super.set_measured(a, time);
 430                         if (ascent)
 431                                 speed.set_integral(this.measured);
 432                 }
 433         }
 434
 435         AltosAccel acceleration;
 436
 437         public double acceleration() {
 438                 return acceleration.value();
 439         }
 440
 441         public double max_acceleration() {
 442                 return acceleration.max();
 443         }
 444
 445         public AltosValue       kalman_height, kalman_speed, kalman_acceleration;
 446
 447         public void set_kalman(double height, double speed, double acceleration) {
 448                 kalman_height.set(height, time);
 449                 kalman_speed.set(speed, time);
 450                 kalman_acceleration.set(acceleration, time);
 451         }
 452
 453         public double   battery_voltage;
 454         public double   pyro_voltage;
 455         public double   temperature;
 456         public double   apogee_voltage;
 457         public double   main_voltage;
 458
 459         public double   ignitor_voltage[];
 460
 461         public AltosGPS gps;
 462         public AltosGPS temp_gps;
 463         public boolean  temp_gps_clear_sats_pending;
 464         public boolean  gps_pending;
 465         public int gps_sequence;
 466
 467         public AltosIMU imu;
 468         public AltosMag mag;
 469
 470         public static final int MIN_PAD_SAMPLES = 10;
 471
 472         public int      npad;
 473         public int      gps_waiting;
 474         public boolean  gps_ready;
 475
 476         public int      ngps;
 477
 478         public AltosGreatCircle from_pad;
 479         public double   elevation;      /* from pad */
 480         public double   range;          /* total distance */
 481
 482         public double   gps_height;
 483
 484         public double pad_lat, pad_lon, pad_alt;
 485
 486         public int      speak_tick;
 487         public double   speak_altitude;
 488
 489         public String   callsign;
 490         public String   firmware_version;
 491
 492         public double   accel_plus_g;
 493         public double   accel_minus_g;
 494         public double   accel;
 495         public double   ground_accel;
 496         public double   ground_accel_avg;
 497
 498         public int      log_format;
 499
 500         public AltosMs5607      baro;
 501
 502         public AltosRecordCompanion     companion;
 503
 504         public void set_npad(int npad) {
 505                 this.npad = npad;
 506                 gps_waiting = MIN_PAD_SAMPLES - npad;
 507                 if (this.gps_waiting < 0)
 508                         gps_waiting = 0;
 509                 gps_ready = gps_waiting == 0;
 510         }
 511
 512         public void init() {
 513                 record = null;
 514
 515                 set = 0;
 516
 517                 received_time = System.currentTimeMillis();
 518                 time = AltosRecord.MISSING;
 519                 time_change = AltosRecord.MISSING;
 520                 prev_time = AltosRecord.MISSING;
 521                 tick = AltosRecord.MISSING;
 522                 prev_tick = AltosRecord.MISSING;
 523                 boost_tick = AltosRecord.MISSING;
 524                 state = AltosLib.ao_flight_invalid;
 525                 flight = AltosRecord.MISSING;
 526                 landed = false;
 527                 boost = false;
 528                 rssi = AltosRecord.MISSING;
 529                 status = 0;
 530                 device_type = AltosRecord.MISSING;
 531                 config_major = AltosRecord.MISSING;
 532                 config_minor = AltosRecord.MISSING;
 533                 apogee_delay = AltosRecord.MISSING;
 534                 main_deploy = AltosRecord.MISSING;
 535                 flight_log_max = AltosRecord.MISSING;
 536
 537                 ground_altitude = new AltosCValue();
 538                 ground_pressure = new AltosGroundPressure();
 539                 altitude = new AltosAltitude();
 540                 pressure = new AltosPressure();
 541                 speed = new AltosSpeed();
 542                 acceleration = new AltosAccel();
 543
 544                 temperature = AltosRecord.MISSING;
 545                 battery_voltage = AltosRecord.MISSING;
 546                 pyro_voltage = AltosRecord.MISSING;
 547                 apogee_voltage = AltosRecord.MISSING;
 548                 main_voltage = AltosRecord.MISSING;
 549                 ignitor_voltage = null;
 550
 551                 kalman_height = new AltosValue();
 552                 kalman_speed = new AltosValue();
 553                 kalman_acceleration = new AltosValue();
 554
 555                 gps = null;
 556                 temp_gps = null;
 557                 temp_gps_clear_sats_pending = false;
 558                 gps_sequence = 0;
 559                 gps_pending = false;
 560
 561                 imu = null;
 562                 mag = null;
 563
 564                 set_npad(0);
 565                 ngps = 0;
 566
 567                 from_pad = null;
 568                 elevation = AltosRecord.MISSING;
 569                 range = AltosRecord.MISSING;
 570                 gps_height = AltosRecord.MISSING;
 571
 572                 pad_lat = AltosRecord.MISSING;
 573                 pad_lon = AltosRecord.MISSING;
 574                 pad_alt = AltosRecord.MISSING;
 575
 576                 speak_tick = AltosRecord.MISSING;
 577                 speak_altitude = AltosRecord.MISSING;
 578
 579                 callsign = null;
 580
 581                 accel_plus_g = AltosRecord.MISSING;
 582                 accel_minus_g = AltosRecord.MISSING;
 583                 accel = AltosRecord.MISSING;
 584
 585                 ground_accel = AltosRecord.MISSING;
 586                 ground_accel_avg = AltosRecord.MISSING;
 587
 588                 log_format = AltosRecord.MISSING;
 589                 serial = AltosRecord.MISSING;
 590
 591                 baro = null;
 592                 companion = null;
 593         }
 594
 595         void copy(AltosState old) {
 596
 597                 record = null;
 598
 599                 if (old == null) {
 600                         init();
 601                         return;
 602                 }
 603
 604                 received_time = old.received_time;
 605                 time = old.time;
 606                 time_change = 0;
 607                 tick = old.tick;
 608                 prev_tick = old.tick;
 609                 boost_tick = old.boost_tick;
 610
 611                 state = old.state;
 612                 flight = old.flight;
 613                 landed = old.landed;
 614                 ascent = old.ascent;
 615                 boost = old.boost;
 616                 rssi = old.rssi;
 617                 status = old.status;
 618                 device_type = old.device_type;
 619                 config_major = old.config_major;
 620                 config_minor = old.config_minor;
 621                 apogee_delay = old.apogee_delay;
 622                 main_deploy = old.main_deploy;
 623                 flight_log_max = old.flight_log_max;
 624
 625                 set = 0;
 626
 627                 ground_altitude.copy(old.ground_altitude);
 628                 altitude.copy(old.altitude);
 629                 pressure.copy(old.pressure);
 630                 speed.copy(old.speed);
 631                 acceleration.copy(old.acceleration);
 632
 633                 battery_voltage = old.battery_voltage;
 634                 pyro_voltage = old.pyro_voltage;
 635                 temperature = old.temperature;
 636                 apogee_voltage = old.apogee_voltage;
 637                 main_voltage = old.main_voltage;
 638                 ignitor_voltage = old.ignitor_voltage;
 639
 640                 kalman_height.copy(old.kalman_height);
 641                 kalman_speed.copy(old.kalman_speed);
 642                 kalman_acceleration.copy(old.kalman_acceleration);
 643
 644                 if (old.gps != null)
 645                         gps = old.gps.clone();
 646                 else
 647                         gps = null;
 648                 if (old.temp_gps != null)
 649                         temp_gps = old.temp_gps.clone();
 650                 else
 651                         temp_gps = null;
 652                 temp_gps_clear_sats_pending = old.temp_gps_clear_sats_pending;
 653                 gps_sequence = old.gps_sequence;
 654                 gps_pending = old.gps_pending;
 655
 656                 if (old.imu != null)
 657                         imu = old.imu.clone();
 658                 else
 659                         imu = null;
 660
 661                 if (old.mag != null)
 662                         mag = old.mag.clone();
 663                 else
 664                         mag = null;
 665
 666                 npad = old.npad;
 667                 gps_waiting = old.gps_waiting;
 668                 gps_ready = old.gps_ready;
 669                 ngps = old.ngps;
 670
 671                 if (old.from_pad != null)
 672                         from_pad = old.from_pad.clone();
 673                 else
 674                         from_pad = null;
 675
 676                 elevation = old.elevation;
 677                 range = old.range;
 678
 679                 gps_height = old.gps_height;
 680                 pad_lat = old.pad_lat;
 681                 pad_lon = old.pad_lon;
 682                 pad_alt = old.pad_alt;
 683
 684                 speak_tick = old.speak_tick;
 685                 speak_altitude = old.speak_altitude;
 686
 687                 callsign = old.callsign;
 688
 689                 accel_plus_g = old.accel_plus_g;
 690                 accel_minus_g = old.accel_minus_g;
 691                 accel = old.accel;
 692                 ground_accel = old.ground_accel;
 693                 ground_accel_avg = old.ground_accel_avg;
 694
 695                 log_format = old.log_format;
 696                 serial = old.serial;
 697
 698                 baro = old.baro;
 699                 companion = old.companion;
 700         }
 701
 702         void update_time() {
 703         }
 704
 705         void update_gps() {
 706                 elevation = 0;
 707                 range = -1;
 708                 gps_height = 0;
 709
 710                 if (gps == null)
 711                         return;
 712
 713                 if (gps.locked && gps.nsat >= 4) {
 714                         /* Track consecutive 'good' gps reports, waiting for 10 of them */
 715                         if (state == AltosLib.ao_flight_pad) {
 716                                 set_npad(npad+1);
 717                                 if (pad_lat != AltosRecord.MISSING) {
 718                                         pad_lat = (pad_lat * 31 + gps.lat) / 32;
 719                                         pad_lon = (pad_lon * 31 + gps.lon) / 32;
 720                                         pad_alt = (pad_alt * 31 + gps.alt) / 32;
 721                                 }
 722                         }
 723                         if (pad_lat == AltosRecord.MISSING) {
 724                                 pad_lat = gps.lat;
 725                                 pad_lon = gps.lon;
 726                                 pad_alt = gps.alt;
 727                         }
 728                 }
 729                 if (gps.lat != 0 && gps.lon != 0 &&
 730                     pad_lat != AltosRecord.MISSING &&
 731                     pad_lon != AltosRecord.MISSING)
 732                 {
 733                         double h = height();
 734
 735                         if (h == AltosRecord.MISSING)
 736                                 h = 0;
 737                         from_pad = new AltosGreatCircle(pad_lat, pad_lon, 0, gps.lat, gps.lon, h);
 738                         elevation = from_pad.elevation;
 739                         range = from_pad.range;
 740                         gps_height = gps.alt - pad_alt;
 741                 }
 742         }
 743
 744         public void set_tick(int new_tick) {
 745                 if (new_tick != AltosRecord.MISSING) {
 746                         if (prev_tick != AltosRecord.MISSING) {
 747                                 while (new_tick < prev_tick - 32767) {
 748                                         new_tick += 65536;
 749                                 }
 750                         }
 751                         tick = new_tick;
 752                         time = tick / 100.0;
 753                 }
 754         }
 755
 756         public void set_boost_tick(int boost_tick) {
 757                 if (boost_tick != AltosRecord.MISSING)
 758                         this.boost_tick = boost_tick;
 759         }
 760
 761         public String state_name() {
 762                 return AltosLib.state_name(state);
 763         }
 764
 765         public void set_state(int state) {
 766                 if (state != AltosLib.ao_flight_invalid) {
 767                         this.state = state;
 768                         ascent = (AltosLib.ao_flight_boost <= state &&
 769                                   state <= AltosLib.ao_flight_coast);
 770                         boost = (AltosLib.ao_flight_boost == state);
 771                 }
 772
 773         }
 774
 775         public void set_device_type(int device_type) {
 776                 this.device_type = device_type;
 777         }
 778
 779         public void set_config(int major, int minor, int apogee_delay, int main_deploy, int flight_log_max) {
 780                 config_major = major;
 781                 config_minor = minor;
 782                 this.apogee_delay = apogee_delay;
 783                 this.main_deploy = main_deploy;
 784                 this.flight_log_max = flight_log_max;
 785         }
 786
 787         public void set_callsign(String callsign) {
 788                 this.callsign = callsign;
 789         }
 790
 791         public void set_firmware_version(String version) {
 792                 firmware_version = version;
 793         }
 794
 795         public void set_flight(int flight) {
 796
 797                 /* When the flight changes, reset the state */
 798                 if (flight != AltosRecord.MISSING) {
 799                         if (this.flight != AltosRecord.MISSING &&
 800                             this.flight != flight) {
 801                                 init();
 802                         }
 803                         this.flight = flight;
 804                 }
 805         }
 806
 807         public void set_serial(int serial) {
 808                 /* When the serial changes, reset the state */
 809                 if (serial != AltosRecord.MISSING) {
 810                         if (this.serial != AltosRecord.MISSING &&
 811                             this.serial != serial) {
 812                                 init();
 813                         }
 814                         this.serial = serial;
 815                 }
 816         }
 817
 818         public int rssi() {
 819                 if (rssi == AltosRecord.MISSING)
 820                         return 0;
 821                 return rssi;
 822         }
 823
 824         public void set_rssi(int rssi, int status) {
 825                 if (rssi != AltosRecord.MISSING) {
 826                         this.rssi = rssi;
 827                         this.status = status;
 828                 }
 829         }
 830
 831         public void set_received_time(long ms) {
 832                 received_time = ms;
 833         }
 834
 835         public void set_gps(AltosGPS gps, int sequence) {
 836                 if (gps != null) {
 837                         this.gps = gps.clone();
 838                         gps_sequence = sequence;
 839                         update_gps();
 840                         set |= set_gps;
 841                 }
 842         }
 843
 844         public void make_baro() {
 845                 if (baro == null)
 846                         baro = new AltosMs5607();
 847         }
 848
 849         public void set_ms5607(int pres, int temp) {
 850                 if (baro != null) {
 851                         baro.set(pres, temp);
 852
 853                         set_pressure(baro.pa);
 854                         set_temperature(baro.cc / 100.0);
 855                 }
 856         }
 857
 858         public void make_companion (int nchannels) {
 859                 if (companion == null)
 860                         companion = new AltosRecordCompanion(nchannels);
 861         }
 862
 863         public void set_companion(AltosRecordCompanion companion) {
 864                 this.companion = companion;
 865         }
 866
 867         void update_accel() {
 868                 double  ground = ground_accel;
 869
 870                 if (ground == AltosRecord.MISSING)
 871                         ground = ground_accel_avg;
 872                 if (accel == AltosRecord.MISSING)
 873                         return;
 874                 if (ground == AltosRecord.MISSING)
 875                         return;
 876                 if (accel_plus_g == AltosRecord.MISSING)
 877                         return;
 878                 if (accel_minus_g == AltosRecord.MISSING)
 879                         return;
 880
 881                 double counts_per_g = (accel_minus_g - accel_plus_g) / 2.0;
 882                 double counts_per_mss = counts_per_g / 9.80665;
 883                 acceleration.set_computed((ground - accel) / counts_per_mss, time);
 884         }
 885
 886         public void set_accel_g(double accel_plus_g, double accel_minus_g) {
 887                 if (accel_plus_g != AltosRecord.MISSING) {
 888                         this.accel_plus_g = accel_plus_g;
 889                         this.accel_minus_g = accel_minus_g;
 890                         update_accel();
 891                 }
 892         }
 893
 894         public void set_ground_accel(double ground_accel) {
 895                 if (ground_accel != AltosRecord.MISSING) {
 896                         this.ground_accel = ground_accel;
 897                         update_accel();
 898                 }
 899         }
 900
 901         public void set_accel(double accel) {
 902                 if (accel != AltosRecord.MISSING) {
 903                         this.accel = accel;
 904                         if (state == AltosLib.ao_flight_pad) {
 905                                 if (ground_accel_avg == AltosRecord.MISSING)
 906                                         ground_accel_avg = accel;
 907                                 else
 908                                         ground_accel_avg = (ground_accel_avg * 7 + accel) / 8;
 909                         }
 910                 }
 911                 update_accel();
 912         }
 913
 914         public void set_temperature(double temperature) {
 915                 if (temperature != AltosRecord.MISSING) {
 916                         this.temperature = temperature;
 917                         set |= set_data;
 918                 }
 919         }
 920
 921         public void set_battery_voltage(double battery_voltage) {
 922                 if (battery_voltage != AltosRecord.MISSING) {
 923                         this.battery_voltage = battery_voltage;
 924                         set |= set_data;
 925                 }
 926         }
 927
 928         public void set_pyro_voltage(double pyro_voltage) {
 929                 if (pyro_voltage != AltosRecord.MISSING) {
 930                         this.pyro_voltage = pyro_voltage;
 931                         set |= set_data;
 932                 }
 933         }
 934
 935         public void set_apogee_voltage(double apogee_voltage) {
 936                 if (apogee_voltage != AltosRecord.MISSING) {
 937                         this.apogee_voltage = apogee_voltage;
 938                         set |= set_data;
 939                 }
 940         }
 941
 942         public void set_main_voltage(double main_voltage) {
 943                 if (main_voltage != AltosRecord.MISSING) {
 944                         this.main_voltage = main_voltage;
 945                         set |= set_data;
 946                 }
 947         }
 948
 949         public void set_ignitor_voltage(double[] voltage) {
 950                 this.ignitor_voltage = voltage;
 951         }
 952
 953         public double time_since_boost() {
 954                 if (tick == AltosRecord.MISSING)
 955                         return 0.0;
 956
 957                 if (boost_tick != AltosRecord.MISSING) {
 958                         return (tick - boost_tick) / 100.0;
 959                 }
 960                 return tick / 100.0;
 961         }
 962
 963         public boolean valid() {
 964                 return tick != AltosRecord.MISSING && serial != AltosRecord.MISSING;
 965         }
 966
 967         public AltosGPS make_temp_gps(boolean sats) {
 968                 if (temp_gps == null) {
 969                         temp_gps = new AltosGPS(gps);
 970                 }
 971                 gps_pending = true;
 972                 if (!sats)
 973                         temp_gps_clear_sats_pending = true;
 974                 else if (temp_gps_clear_sats_pending) {
 975                         temp_gps.cc_gps_sat = null;
 976                         temp_gps_clear_sats_pending = false;
 977                 }
 978                 return temp_gps;
 979         }
 980
 981         public void set_temp_gps() {
 982                 set_gps(temp_gps, gps_sequence + 1);
 983                 gps_pending = false;
 984                 temp_gps = null;
 985         }
 986
 987         public AltosState clone() {
 988                 AltosState s = new AltosState();
 989                 s.copy(this);
 990                 return s;
 991         }
 992
 993
 994         public void init (AltosRecord cur, AltosState prev_state) {
 995
 996                 System.out.printf ("init\n");
 997                 if (cur == null)
 998                         cur = new AltosRecord();
 999
1000                 record = cur;
1001
1002                 /* Discard previous state if it was for a different board */
1003                 if (prev_state != null && prev_state.serial != cur.serial)
1004                         prev_state = null;
1005
1006                 copy(prev_state);
1007
1008                 set_ground_altitude(cur.ground_altitude());
1009                 set_altitude(cur.altitude());
1010
1011                 set_kalman(cur.kalman_height, cur.kalman_speed, cur.kalman_acceleration);
1012
1013                 received_time = System.currentTimeMillis();
1014
1015                 set_temperature(cur.temperature());
1016                 set_apogee_voltage(cur.drogue_voltage());
1017                 set_main_voltage(cur.main_voltage());
1018                 set_battery_voltage(cur.battery_voltage());
1019
1020                 set_pressure(cur.pressure());
1021
1022                 set_tick(cur.tick);
1023                 set_state(cur.state);
1024
1025                 set_accel_g (cur.accel_minus_g, cur.accel_plus_g);
1026                 set_ground_accel(cur.ground_accel);
1027                 set_accel (cur.accel);
1028
1029                 if (cur.gps_sequence != gps_sequence)
1030                         set_gps(cur.gps, cur.gps_sequence);
1031
1032         }
1033
1034         public AltosState(AltosRecord cur) {
1035                 init(cur, null);
1036         }
1037
1038         public AltosState (AltosRecord cur, AltosState prev) {
1039                 init(cur, prev);
1040         }
1041
1042
1043         public AltosState () {
1044                 init();
1045         }
1046 }