02a71118c331e72c0af2fb4d6d76d6b043defe49
[fw/altos] / ao-tools / altosui / AltosEepromDownload.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.awt.*;
21 import java.awt.event.*;
22 import javax.swing.*;
23 import javax.swing.filechooser.FileNameExtensionFilter;
24 import javax.swing.table.*;
25 import java.io.*;
26 import java.util.*;
27 import java.text.*;
28 import java.util.prefs.*;
29 import java.util.concurrent.LinkedBlockingQueue;
30
31 import altosui.Altos;
32 import altosui.AltosSerial;
33 import altosui.AltosSerialMonitor;
34 import altosui.AltosRecord;
35 import altosui.AltosTelemetry;
36 import altosui.AltosState;
37 import altosui.AltosDeviceDialog;
38 import altosui.AltosPreferences;
39 import altosui.AltosLog;
40 import altosui.AltosVoice;
41 import altosui.AltosEepromMonitor;
42
43 import libaltosJNI.*;
44
45 public class AltosEepromDownload implements Runnable {
46
47         static final String[] state_names = {
48                 "startup",
49                 "idle",
50                 "pad",
51                 "boost",
52                 "fast",
53                 "coast",
54                 "drogue",
55                 "main",
56                 "landed",
57                 "invalid",
58         };
59
60         int[] ParseHex(String line) {
61                 String[] tokens = line.split("\\s+");
62                 int[] array = new int[tokens.length];
63
64                 for (int i = 0; i < tokens.length; i++)
65                         try {
66                                 array[i] = Integer.parseInt(tokens[i], 16);
67                         } catch (NumberFormatException ne) {
68                                 return null;
69                         }
70                 return array;
71         }
72
73         int checksum(int[] line) {
74                 int     csum = 0x5a;
75                 for (int i = 1; i < line.length; i++)
76                         csum += line[i];
77                 return csum & 0xff;
78         }
79
80         void FlushPending(FileWriter file, LinkedList<String> pending) throws IOException {
81                 while (!pending.isEmpty()) {
82                         file.write(pending.remove());
83                 }
84         }
85
86         JFrame                  frame;
87         AltosDevice             device;
88         AltosSerial             serial_line;
89         boolean                 remote;
90         Thread                  eeprom_thread;
91         AltosEepromMonitor      monitor;
92
93         void CaptureLog() throws IOException, InterruptedException {
94                 int                     serial = 0;
95                 int                     block, state_block = 0;
96                 int                     addr;
97                 int                     flight = 0;
98                 int                     year = 0, month = 0, day = 0;
99                 int                     state = 0;
100                 boolean                 done = false;
101                 boolean                 want_file = false;
102                 boolean                 any_valid;
103                 FileWriter              eeprom_file = null;
104                 AltosFile               eeprom_name;
105                 LinkedList<String>      eeprom_pending = new LinkedList<String>();
106
107                 serial_line.printf("\nc s\nv\n");
108
109                 /* Pull the serial number out of the version information */
110
111                 for (;;) {
112                         String  line = serial_line.get_reply();
113
114                         if (line.startsWith("serial-number")) {
115                                 try {
116                                         serial = Integer.parseInt(line.substring(13).trim());
117                                 } catch (NumberFormatException ne) {
118                                         serial = 0;
119                                 }
120                         }
121
122                         eeprom_pending.add(String.format("%s\n", line));
123
124                         /* signals the end of the version info */
125                         if (line.startsWith("software-version"))
126                                 break;
127                 }
128                 if (serial == 0)
129                         throw new IOException("no serial number found");
130
131                 monitor.set_serial(serial);
132                 /* Now scan the eeprom, reading blocks of data and converting to .eeprom file form */
133
134                 state = 0; state_block = 0;
135                 for (block = 0; !done && block < 511; block++) {
136                         serial_line.printf("e %x\n", block);
137                         any_valid = false;
138                         monitor.set_value(state_names[state], state, block - state_block);
139                         for (addr = 0; addr < 0x100;) {
140                                 String  line = serial_line.get_reply();
141                                 int[] values = ParseHex(line);
142
143                                 if (values == null) {
144                                         System.out.printf("invalid line: %s\n", line);
145                                 } else if (values[0] != addr) {
146                                         System.out.printf("data address out of sync at 0x%x\n",
147                                                           block * 256 + values[0]);
148                                 } else if (checksum(values) != 0) {
149                                         System.out.printf("invalid checksum at 0x%x\n",
150                                                           block * 256 + values[0]);
151                                 } else {
152                                         any_valid = true;
153                                         int     cmd = values[1];
154                                         int     tick = values[3] + (values[4] << 8);
155                                         int     a = values[5] + (values[6] << 8);
156                                         int     b = values[7] + (values[8] << 8);
157
158                                         if (cmd == Altos.AO_LOG_FLIGHT) {
159                                                 flight = b;
160                                                 monitor.set_flight(flight);
161                                         }
162
163                                         /* Monitor state transitions to update display */
164                                         if (cmd == Altos.AO_LOG_STATE && a <= Altos.ao_flight_landed) {
165                                                 if (a > Altos.ao_flight_pad)
166                                                         want_file = true;
167                                                 if (a > state)
168                                                         state_block = block;
169                                                 state = a;
170                                         }
171
172                                         if (cmd == Altos.AO_LOG_GPS_DATE) {
173                                                 year = 2000 + (a & 0xff);
174                                                 month = (a >> 8) & 0xff;
175                                                 day = (b & 0xff);
176                                                 want_file = true;
177                                         }
178
179                                         if (eeprom_file == null) {
180                                                 if (serial != 0 && flight != 0 && want_file) {
181                                                         if (year != 0 && month != 0 && day != 0)
182                                                                 eeprom_name = new AltosFile(year, month, day, serial, flight, "eeprom");
183                                                         else
184                                                                 eeprom_name = new AltosFile(serial, flight, "eeprom");
185
186                                                         monitor.set_file(eeprom_name.getName());
187                                                         eeprom_file = new FileWriter(eeprom_name);
188                                                         if (eeprom_file != null) {
189                                                                 FlushPending(eeprom_file, eeprom_pending);
190                                                                 eeprom_pending = null;
191                                                         }
192                                                 }
193                                         }
194
195                                         String log_line = String.format("%c %4x %4x %4x\n",
196                                                                         cmd, tick, a, b);
197                                         if (eeprom_file != null)
198                                                 eeprom_file.write(log_line);
199                                         else
200                                                 eeprom_pending.add(log_line);
201
202                                         if (cmd == Altos.AO_LOG_STATE && a == Altos.ao_flight_landed) {
203                                                 done = true;
204                                         }
205                                 }
206                                 addr += 8;
207                         }
208                         if (!any_valid)
209                                 done = true;
210                 }
211                 if (eeprom_file == null) {
212                         eeprom_name = new AltosFile(serial,flight,"eeprom");
213                         eeprom_file = new FileWriter(eeprom_name);
214                         if (eeprom_file != null) {
215                                 FlushPending(eeprom_file, eeprom_pending);
216                         }
217                 }
218                 if (eeprom_file != null) {
219                         eeprom_file.flush();
220                         eeprom_file.close();
221                 }
222         }
223
224         public void run () {
225                 if (remote) {
226                         serial_line.printf("m 0\n");
227                         serial_line.set_channel(AltosPreferences.channel());
228                         serial_line.set_callsign(AltosPreferences.callsign());
229                         serial_line.printf("p\n");
230                 }
231
232                 monitor = new AltosEepromMonitor(frame, Altos.ao_flight_boost, Altos.ao_flight_landed);
233                 monitor.addActionListener(new ActionListener() {
234                                 public void actionPerformed(ActionEvent e) {
235                                         eeprom_thread.interrupt();
236                                 }
237                         });
238                 try {
239                         CaptureLog();
240                 } catch (IOException ee) {
241                         JOptionPane.showMessageDialog(frame,
242                                                       device.getPath(),
243                                                       ee.getLocalizedMessage(),
244                                                       JOptionPane.ERROR_MESSAGE);
245                 } catch (InterruptedException ie) {
246                 }
247                 if (remote)
248                         serial_line.printf("~");
249                 monitor.done();
250                 serial_line.close();
251         }
252
253         public AltosEepromDownload(JFrame given_frame) {
254                 frame = given_frame;
255                 device = AltosDeviceDialog.show(frame, AltosDevice.Any);
256
257                 serial_line = new AltosSerial();
258                 remote = false;
259
260                 if (device != null) {
261                         try {
262                                 serial_line.open(device);
263                                 if (!device.matchProduct(AltosDevice.TeleMetrum))
264                                         remote = true;
265                                 eeprom_thread = new Thread(this);
266                                 eeprom_thread.start();
267                         } catch (FileNotFoundException ee) {
268                                 JOptionPane.showMessageDialog(frame,
269                                                               String.format("Cannot open device \"%s\"",
270                                                                             device.getPath()),
271                                                               "Cannot open target device",
272                                                               JOptionPane.ERROR_MESSAGE);
273                         } catch (IOException ee) {
274                                 JOptionPane.showMessageDialog(frame,
275                                                               device.getPath(),
276                                                               ee.getLocalizedMessage(),
277                                                               JOptionPane.ERROR_MESSAGE);
278                         }
279                 }
280         }
281 }