git.gag.com Git - fw/altos/blob - altosui/AltosPad.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 package altosui;
  19
  20 import java.util.*;
  21 import org.altusmetrum.altoslib_6.*;
  22 import org.altusmetrum.altosuilib_6.*;
  23
  24 public class AltosPad extends AltosUIFlightTab {
  25
  26         class Battery extends AltosUIVoltageIndicator {
  27                 public double voltage(AltosState state) { return state.battery_voltage; }
  28                 public double good() { return AltosLib.ao_battery_good; }
  29                 public Battery (AltosUIFlightTab container, int y) { super(container, y, "Battery Voltage", 2); }
  30         }
  31
  32         class Apogee extends AltosUIVoltageIndicator {
  33                 public boolean hide(double v) { return v == AltosLib.MISSING; }
  34                 public double voltage(AltosState state) { return state.apogee_voltage; }
  35                 public double good() { return AltosLib.ao_igniter_good; }
  36                 public Apogee (AltosUIFlightTab container, int y) { super(container, y, "Apogee Igniter Voltage", 2); }
  37         }
  38
  39         class Main extends AltosUIVoltageIndicator {
  40                 public boolean hide(double v) { return v == AltosLib.MISSING; }
  41                 public double voltage(AltosState state) { return state.main_voltage; }
  42                 public double good() { return AltosLib.ao_igniter_good; }
  43                 public Main (AltosUIFlightTab container, int y) { super(container, y, "Main Igniter Voltage", 2); }
  44         }
  45
  46         class LoggingReady extends AltosUIIndicator {
  47                 public void show (AltosState state, AltosListenerState listener_state) {
  48                         if (state == null || state.flight == AltosLib.MISSING) {
  49                                 hide();
  50                         } else {
  51                                 if (state.flight != 0) {
  52                                         if (state.state <= Altos.ao_flight_pad)
  53                                                 show("Ready to record");
  54                                         else if (state.state < Altos.ao_flight_landed ||
  55                                                  state.state == AltosLib.ao_flight_stateless)
  56                                                 show("Recording data");
  57                                         else
  58                                                 show("Recorded data");
  59                                 } else
  60                                         show("Storage full");
  61                                 set_lights(state.flight != 0);
  62                         }
  63                 }
  64                 public LoggingReady (AltosUIFlightTab container, int y) {
  65                         super(container, y, "On-board Data Logging", 1, true, 2);
  66                 }
  67         }
  68
  69         class GPSLocked extends AltosUIIndicator {
  70                 public void show (AltosState state, AltosListenerState listener_state) {
  71                         if (state == null || state.gps == null)
  72                                 hide();
  73                         else {
  74                                 int     sol = state.gps.nsat;
  75                                 int     sat = state.gps.cc_gps_sat == null ? 0 : state.gps.cc_gps_sat.length;
  76                                 show("%d in solution", sol, "%d in view", sat);
  77                                 set_lights(state.gps.locked && sol >= 4);
  78                         }
  79                 }
  80                 public GPSLocked (AltosUIFlightTab container, int y) {
  81                         super (container, y, "GPS Locked", 2, true, 1);
  82                 }
  83         }
  84
  85         class GPSReady extends AltosUIIndicator {
  86                 public void show (AltosState state, AltosListenerState listener_state) {
  87                         if (state == null || state.gps == null)
  88                                 hide();
  89                         else {
  90                                 if (state.gps_ready)
  91                                         show("Ready");
  92                                 else
  93                                         show("Waiting %d", state.gps_waiting);
  94                                 set_lights(state.gps_ready);
  95                         }
  96                 }
  97                 public GPSReady (AltosUIFlightTab container, int y) {
  98                         super (container, y, "GPS Ready", 1, true, 2);
  99                 }
 100         }
 101
 102         class ReceiverBattery extends AltosUIVoltageIndicator {
 103
 104                 public double voltage(AltosState state) { return AltosLib.MISSING; }
 105
 106                 public boolean hide(double v) { return v == AltosLib.MISSING; }
 107                 public double good() { return AltosLib.ao_battery_good; }
 108
 109                 public double value(AltosState state, AltosListenerState listener_state, int i) {
 110                         if (listener_state == null)
 111                                 return AltosLib.MISSING;
 112                         return listener_state.battery;
 113                 }
 114
 115                 public ReceiverBattery (AltosUIFlightTab container, int y) {
 116                         super(container, y, "Receiver Battery", 2);
 117                 }
 118         }
 119
 120         boolean report_pad(AltosState state) {
 121                 if ((state.state == AltosLib.ao_flight_stateless ||
 122                      state.state < AltosLib.ao_flight_pad) &&
 123                     state.gps != null &&
 124                     state.gps.lat != AltosLib.MISSING)
 125                 {
 126                         return false;
 127                 }
 128                 return true;
 129         }
 130
 131         class PadLat extends AltosUIIndicator {
 132
 133                 double  last_lat = AltosLib.MISSING - 1;
 134
 135                 public void show (AltosState state, AltosListenerState listener_state) {
 136                         double lat = AltosLib.MISSING;
 137                         String label = null;
 138
 139                         if (state != null) {
 140                                 if (report_pad(state)) {
 141                                         lat = state.pad_lat;
 142                                         label = "Pad Latitude";
 143                                 } else {
 144                                         lat = state.gps.lat;
 145                                         label = "Latitude";
 146                                 }
 147                         }
 148                         if (lat != last_lat) {
 149                                 if (lat != AltosLib.MISSING) {
 150                                         show(AltosConvert.latitude.show(10, lat));
 151                                         set_label(label);
 152                                 } else
 153                                         hide();
 154                                 last_lat = lat;
 155                         }
 156                 }
 157
 158                 public void reset() {
 159                         super.reset();
 160                         last_lat = AltosLib.MISSING - 1;
 161                 }
 162
 163                 public PadLat (AltosUIFlightTab container, int y) {
 164                         super (container, y, "Pad Latitude", 1, false, 2);
 165                 }
 166         }
 167
 168         class PadLon extends AltosUIIndicator {
 169
 170                 double last_lon = AltosLib.MISSING - 1;
 171
 172                 public void show (AltosState state, AltosListenerState listener_state) {
 173                         double lon = AltosLib.MISSING;
 174                         String label = null;
 175
 176                         if (state != null) {
 177                                 if (report_pad(state)) {
 178                                         lon = state.pad_lon;
 179                                         label = "Pad Longitude";
 180                                 } else {
 181                                         lon = state.gps.lon;
 182                                         label = "Longitude";
 183                                 }
 184                         }
 185                         if (lon != last_lon) {
 186                                 if (lon != AltosLib.MISSING) {
 187                                         show(AltosConvert.longitude.show(10, lon));
 188                                         set_label(label);
 189                                 } else
 190                                         hide();
 191                                 last_lon = lon;
 192                         }
 193                 }
 194
 195                 public void reset() {
 196                         super.reset();
 197                         last_lon = AltosLib.MISSING - 1;
 198                 }
 199
 200                 public PadLon (AltosUIFlightTab container, int y) {
 201                         super (container, y, "Pad Longitude", 1, false, 2);
 202                 }
 203         }
 204
 205         class PadAlt extends AltosUIIndicator {
 206
 207                 double  last_alt = AltosLib.MISSING - 1;
 208
 209                 public void show (AltosState state, AltosListenerState listener_state) {
 210                         double alt = AltosLib.MISSING;
 211                         String label = null;
 212
 213                         if (state != null) {
 214                                 if (report_pad(state)) {
 215                                         alt = state.pad_alt;
 216                                         label = "Pad Altitude";
 217                                 } else {
 218                                         alt = state.gps.alt;
 219                                         label = "Altitude";
 220                                 }
 221                         }
 222                         if (alt != last_alt) {
 223                                 if (alt != AltosLib.MISSING) {
 224                                         show(AltosConvert.height.show(5, alt));
 225                                         set_label(label);
 226                                 } else
 227                                         hide();
 228                                 last_alt = alt;
 229                         }
 230                 }
 231
 232                 public void reset() {
 233                         super.reset();
 234                         last_alt =  AltosLib.MISSING - 1;
 235                 }
 236
 237                 public PadAlt (AltosUIFlightTab container, int y) {
 238                         super (container, y, "Pad Altitude", 1, false, 2);
 239                 }
 240         }
 241         public String getName() { return "Pad"; }
 242
 243         public AltosPad() {
 244                 int y = 0;
 245                 add(new Battery(this, y++));
 246                 add(new Apogee(this, y++));
 247                 add(new Main(this, y++));
 248                 add(new LoggingReady(this, y++));
 249                 add(new GPSLocked(this, y++));
 250                 add(new GPSReady(this, y++));
 251                 add(new ReceiverBattery(this, y++));
 252                 add(new PadLat(this, y++));
 253                 add(new PadLon(this, y++));
 254                 add(new PadAlt(this, y++));
 255         }
 256 }