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