altosui: Correctly show/hide receiver battery value
[fw/altos] / 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_7.*;
22 import org.altusmetrum.altosuilib_7.*;
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 double good() { return AltosLib.ao_battery_good; }
107
108                 public boolean hide(AltosState state, AltosListenerState listener_state, int i) {
109                         return value(state, listener_state, i) == AltosLib.MISSING;
110                 }
111
112                 public double value(AltosState state, AltosListenerState listener_state, int i) {
113                         if (listener_state == null)
114                                 return AltosLib.MISSING;
115                         return listener_state.battery;
116                 }
117
118                 public ReceiverBattery (AltosUIFlightTab container, int y) {
119                         super(container, y, "Receiver Battery", 2);
120                 }
121         }
122
123         boolean report_pad(AltosState state) {
124                 if ((state.state == AltosLib.ao_flight_stateless ||
125                      state.state < AltosLib.ao_flight_pad) &&
126                     state.gps != null &&
127                     state.gps.lat != AltosLib.MISSING)
128                 {
129                         return false;
130                 }
131                 return true;
132         }
133
134         class PadLat extends AltosUIIndicator {
135
136                 double  last_lat = AltosLib.MISSING - 1;
137
138                 public void show (AltosState state, AltosListenerState listener_state) {
139                         double lat = AltosLib.MISSING;
140                         String label = null;
141
142                         if (state != null) {
143                                 if (report_pad(state)) {
144                                         lat = state.pad_lat;
145                                         label = "Pad Latitude";
146                                 } else {
147                                         lat = state.gps.lat;
148                                         label = "Latitude";
149                                 }
150                         }
151                         if (lat != last_lat) {
152                                 if (lat != AltosLib.MISSING) {
153                                         show(AltosConvert.latitude.show(10, lat));
154                                         set_label(label);
155                                 } else
156                                         hide();
157                                 last_lat = lat;
158                         }
159                 }
160
161                 public void reset() {
162                         super.reset();
163                         last_lat = AltosLib.MISSING - 1;
164                 }
165
166                 public PadLat (AltosUIFlightTab container, int y) {
167                         super (container, y, "Pad Latitude", 1, false, 2);
168                 }
169         }
170
171         class PadLon extends AltosUIIndicator {
172
173                 double last_lon = AltosLib.MISSING - 1;
174
175                 public void show (AltosState state, AltosListenerState listener_state) {
176                         double lon = AltosLib.MISSING;
177                         String label = null;
178
179                         if (state != null) {
180                                 if (report_pad(state)) {
181                                         lon = state.pad_lon;
182                                         label = "Pad Longitude";
183                                 } else {
184                                         lon = state.gps.lon;
185                                         label = "Longitude";
186                                 }
187                         }
188                         if (lon != last_lon) {
189                                 if (lon != AltosLib.MISSING) {
190                                         show(AltosConvert.longitude.show(10, lon));
191                                         set_label(label);
192                                 } else
193                                         hide();
194                                 last_lon = lon;
195                         }
196                 }
197
198                 public void reset() {
199                         super.reset();
200                         last_lon = AltosLib.MISSING - 1;
201                 }
202
203                 public PadLon (AltosUIFlightTab container, int y) {
204                         super (container, y, "Pad Longitude", 1, false, 2);
205                 }
206         }
207
208         class PadAlt extends AltosUIIndicator {
209
210                 double  last_alt = AltosLib.MISSING - 1;
211
212                 public void show (AltosState state, AltosListenerState listener_state) {
213                         double alt = AltosLib.MISSING;
214                         String label = null;
215
216                         if (state != null) {
217                                 if (report_pad(state)) {
218                                         alt = state.pad_alt;
219                                         label = "Pad Altitude";
220                                 } else {
221                                         alt = state.gps.alt;
222                                         label = "Altitude";
223                                 }
224                         }
225                         if (alt != last_alt) {
226                                 if (alt != AltosLib.MISSING) {
227                                         show(AltosConvert.height.show(5, alt));
228                                         set_label(label);
229                                 } else
230                                         hide();
231                                 last_alt = alt;
232                         }
233                 }
234
235                 public void reset() {
236                         super.reset();
237                         last_alt =  AltosLib.MISSING - 1;
238                 }
239
240                 public PadAlt (AltosUIFlightTab container, int y) {
241                         super (container, y, "Pad Altitude", 1, false, 2);
242                 }
243         }
244         public String getName() { return "Pad"; }
245
246         public AltosPad() {
247                 int y = 0;
248                 add(new Battery(this, y++));
249                 add(new ReceiverBattery(this, y++));
250                 add(new Apogee(this, y++));
251                 add(new Main(this, y++));
252                 add(new LoggingReady(this, y++));
253                 add(new GPSLocked(this, y++));
254                 add(new GPSReady(this, y++));
255                 add(new PadLat(this, y++));
256                 add(new PadLon(this, y++));
257                 add(new PadAlt(this, y++));
258         }
259 }