Make the ao_log_record structures 8 bytes again.
[fw/altos] / src / ao_log.c
1 /*
2  * Copyright © 2009 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 #include "ao.h"
19
20 static __pdata uint32_t ao_log_current_pos;
21 static __pdata uint32_t ao_log_start_pos;
22 static __xdata uint8_t  ao_log_running;
23 static __xdata uint8_t  ao_log_mutex;
24
25 static uint8_t
26 ao_log_csum(uint8_t *b)
27 {
28         uint8_t sum = 0x5a;
29         uint8_t i;
30
31         for (i = 0; i < sizeof (struct ao_log_record); i++)
32                 sum += *b++;
33         return -sum;
34 }
35
36 void
37 ao_log_data(struct ao_log_record *log)
38 {
39         /* set checksum */
40         log->csum = 0;
41         log->csum = ao_log_csum((uint8_t *) log);
42         ao_mutex_get(&ao_log_mutex); {
43                 if (ao_log_running) {
44                         ao_ee_write(ao_log_current_pos,
45                                     (uint8_t *) log,
46                                     sizeof (struct ao_log_record));
47                         ao_log_current_pos += sizeof (struct ao_log_record);
48                         if (ao_log_current_pos >= AO_EE_DATA_SIZE)
49                                 ao_log_current_pos = 0;
50                         if (ao_log_current_pos == ao_log_start_pos)
51                                 ao_log_running = 0;
52                 }
53         } ao_mutex_put(&ao_log_mutex);
54 }
55
56 void
57 ao_log_flush(void)
58 {
59         ao_ee_flush();
60 }
61
62 __xdata struct ao_log_record ao_log_dump;
63 static __xdata uint16_t ao_log_dump_flight;
64 static __xdata uint32_t ao_log_dump_pos;
65
66 static uint8_t
67 ao_log_dump_check_data(void)
68 {
69         if (ao_log_csum((uint8_t *) &ao_log_dump) != 0)
70                 return 0;
71         return 1;
72 }
73
74 static uint8_t
75 ao_log_dump_scan(void)
76 {
77         if (!ao_ee_read(0, (uint8_t *) &ao_log_dump, sizeof (struct ao_log_record)))
78                 ao_panic(AO_PANIC_LOG);
79         if (ao_log_dump_check_data() && ao_log_dump.type == AO_LOG_FLIGHT) {
80                 ao_log_dump_flight = ao_log_dump.u.flight.flight;
81                 return 1;
82         } else {
83                 ao_log_dump_flight = 0;
84                 return 0;
85         }
86 }
87
88 uint8_t
89 ao_log_dump_first(void)
90 {
91         ao_log_dump_pos = 0;
92         if (!ao_log_dump_scan())
93                 return 0;
94         return 1;
95 }
96
97 uint8_t
98 ao_log_dump_next(void)
99 {
100         ao_log_dump_pos += sizeof (struct ao_log_record);
101         if (ao_log_dump_pos >= AO_EE_DEVICE_SIZE)
102                 return 0;
103         if (!ao_ee_read(ao_log_dump_pos, (uint8_t *) &ao_log_dump,
104                         sizeof (struct ao_log_record)))
105                 return 0;
106         return ao_log_dump_check_data();
107 }
108
109 __xdata uint8_t ao_log_adc_pos;
110 __xdata enum flight_state ao_log_state;
111
112 void
113 ao_log(void)
114 {
115         static __xdata struct ao_log_record     log;
116
117         ao_log_dump_scan();
118
119         while (!ao_log_running)
120                 ao_sleep(&ao_log_running);
121
122         log.type = AO_LOG_FLIGHT;
123         log.tick = ao_flight_tick;
124         log.u.flight.ground_accel = ao_ground_accel;
125         log.u.flight.flight = ao_log_dump_flight + 1;
126         ao_log_data(&log);
127
128         /* Write the whole contents of the ring to the log
129          * when starting up.
130          */
131         ao_log_adc_pos = ao_adc_ring_next(ao_adc_head);
132         for (;;) {
133                 /* Write samples to EEPROM */
134                 while (ao_log_adc_pos != ao_adc_head) {
135                         log.type = AO_LOG_SENSOR;
136                         log.tick = ao_adc_ring[ao_log_adc_pos].tick;
137                         log.u.sensor.accel = ao_adc_ring[ao_log_adc_pos].accel;
138                         log.u.sensor.pres = ao_adc_ring[ao_log_adc_pos].pres;
139                         ao_log_data(&log);
140                         if ((ao_log_adc_pos & 0x1f) == 0) {
141                                 log.type = AO_LOG_TEMP_VOLT;
142                                 log.tick = ao_adc_ring[ao_log_adc_pos].tick;
143                                 log.u.temp_volt.temp = ao_adc_ring[ao_log_adc_pos].temp;
144                                 log.u.temp_volt.v_batt = ao_adc_ring[ao_log_adc_pos].v_batt;
145                                 ao_log_data(&log);
146                                 log.type = AO_LOG_DEPLOY;
147                                 log.tick = ao_adc_ring[ao_log_adc_pos].tick;
148                                 log.u.deploy.drogue = ao_adc_ring[ao_log_adc_pos].sense_d;
149                                 log.u.deploy.main = ao_adc_ring[ao_log_adc_pos].sense_m;
150                                 ao_log_data(&log);
151                         }
152                         ao_log_adc_pos = ao_adc_ring_next(ao_log_adc_pos);
153                 }
154                 /* Write state change to EEPROM */
155                 if (ao_flight_state != ao_log_state) {
156                         ao_log_state = ao_flight_state;
157                         log.type = AO_LOG_STATE;
158                         log.tick = ao_flight_tick;
159                         log.u.state.state = ao_log_state;
160                         log.u.state.reason = 0;
161                         ao_log_data(&log);
162
163                         if (ao_log_state == ao_flight_landed)
164                                 ao_log_stop();
165                 }
166
167                 /* Wait for a while */
168                 ao_delay(AO_MS_TO_TICKS(100));
169
170                 /* Stop logging when told to */
171                 while (!ao_log_running)
172                         ao_sleep(&ao_log_running);
173         }
174 }
175
176 void
177 ao_log_start(void)
178 {
179         /* start logging */
180         ao_log_running = 1;
181         ao_wakeup(&ao_log_running);
182 }
183
184 void
185 ao_log_stop(void)
186 {
187         ao_log_running = 0;
188         ao_log_flush();
189 }
190
191 static void
192 dump_log(void)
193 {
194         uint8_t more;
195
196         for (more = ao_log_dump_first(); more; more = ao_log_dump_next()) {
197                 printf("%c %4x %4x %4x\n",
198                        ao_log_dump.type,
199                        ao_log_dump.tick,
200                        ao_log_dump.u.anon.d0,
201                        ao_log_dump.u.anon.d1);
202                 if (ao_log_dump.type == AO_LOG_STATE &&
203                     ao_log_dump.u.state.state == ao_flight_landed)
204                         break;
205         }
206         printf("end\n");
207 }
208
209 __code struct ao_cmds ao_log_cmds[] = {
210         { 'l',  dump_log,               "l                                  Dump last flight log" },
211         { 0, dump_log, NULL },
212 };
213
214 static __xdata struct ao_task ao_log_task;
215
216 void
217 ao_log_init(void)
218 {
219         ao_log_running = 0;
220
221         /* For now, just log the flight starting at the begining of eeprom */
222         ao_log_start_pos = 0;
223         ao_log_current_pos = ao_log_start_pos;
224         ao_log_state = ao_flight_invalid;
225
226         /* Create a task to log events to eeprom */
227         ao_add_task(&ao_log_task, ao_log, "log");
228         ao_cmd_register(&ao_log_cmds[0]);
229 }