telegps-v1.0: Provide one log and append to it
[fw/altos] / src / kernel / ao_log_mini.c
1 /*
2  * Copyright © 2012 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 #include <ao_log.h>
20 #include <ao_data.h>
21 #include <ao_flight.h>
22
23 static __xdata struct ao_log_mini log;
24
25 __code uint8_t ao_log_format = AO_LOG_FORMAT;
26
27 static uint8_t
28 ao_log_csum(__xdata uint8_t *b) __reentrant
29 {
30         uint8_t sum = 0x5a;
31         uint8_t i;
32
33         for (i = 0; i < sizeof (struct ao_log_mini); i++)
34                 sum += *b++;
35         return -sum;
36 }
37
38 uint8_t
39 ao_log_mini(__xdata struct ao_log_mini *log) __reentrant
40 {
41         uint8_t wrote = 0;
42         /* set checksum */
43         log->csum = 0;
44         log->csum = ao_log_csum((__xdata uint8_t *) log);
45         ao_mutex_get(&ao_log_mutex); {
46                 if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
47                         ao_log_stop();
48                 if (ao_log_running) {
49                         wrote = 1;
50                         ao_storage_write(ao_log_current_pos,
51                                          log,
52                                          sizeof (struct ao_log_mini));
53                         ao_log_current_pos += sizeof (struct ao_log_mini);
54                 }
55         } ao_mutex_put(&ao_log_mutex);
56         return wrote;
57 }
58
59 static uint8_t
60 ao_log_dump_check_data(void)
61 {
62         if (ao_log_csum((uint8_t *) &log) != 0)
63                 return 0;
64         return 1;
65 }
66
67 static __data uint8_t   ao_log_data_pos;
68
69 /* a hack to make sure that ao_log_minis fill the eeprom block in even units */
70 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mini))] ;
71
72 #ifndef AO_SENSOR_INTERVAL_ASCENT
73 #define AO_SENSOR_INTERVAL_ASCENT       1
74 #define AO_SENSOR_INTERVAL_DESCENT      10
75 #endif
76
77 void
78 ao_log(void)
79 {
80         __pdata uint16_t        next_sensor;
81
82         ao_storage_setup();
83
84         ao_log_scan();
85
86         while (!ao_log_running)
87                 ao_sleep(&ao_log_running);
88
89 #if HAS_FLIGHT
90         log.type = AO_LOG_FLIGHT;
91         log.tick = ao_sample_tick;
92         log.u.flight.flight = ao_flight_number;
93         log.u.flight.ground_pres = ao_ground_pres;
94         ao_log_mini(&log);
95 #endif
96
97         /* Write the whole contents of the ring to the log
98          * when starting up.
99          */
100         ao_log_data_pos = ao_data_ring_next(ao_data_head);
101         next_sensor = ao_data_ring[ao_log_data_pos].tick;
102         ao_log_state = ao_flight_startup;
103         for (;;) {
104                 /* Write samples to EEPROM */
105                 while (ao_log_data_pos != ao_data_head) {
106                         log.tick = ao_data_ring[ao_log_data_pos].tick;
107                         if ((int16_t) (log.tick - next_sensor) >= 0) {
108                                 log.type = AO_LOG_SENSOR;
109                                 ao_log_pack24(log.u.sensor.pres,
110                                               ao_data_ring[ao_log_data_pos].ms5607_raw.pres);
111                                 ao_log_pack24(log.u.sensor.temp,
112                                               ao_data_ring[ao_log_data_pos].ms5607_raw.temp);
113                                 log.u.sensor.sense_a = ao_data_ring[ao_log_data_pos].adc.sense_a;
114                                 log.u.sensor.sense_m = ao_data_ring[ao_log_data_pos].adc.sense_m;
115                                 log.u.sensor.v_batt = ao_data_ring[ao_log_data_pos].adc.v_batt;
116                                 ao_log_mini(&log);
117                                 if (ao_log_state <= ao_flight_coast)
118                                         next_sensor = log.tick + AO_SENSOR_INTERVAL_ASCENT;
119                                 else
120                                         next_sensor = log.tick + AO_SENSOR_INTERVAL_DESCENT;
121                         }
122                         ao_log_data_pos = ao_data_ring_next(ao_log_data_pos);
123                 }
124 #if HAS_FLIGHT
125                 /* Write state change to EEPROM */
126                 if (ao_flight_state != ao_log_state) {
127                         ao_log_state = ao_flight_state;
128                         log.type = AO_LOG_STATE;
129                         log.tick = ao_time();
130                         log.u.state.state = ao_log_state;
131                         log.u.state.reason = 0;
132                         ao_log_mini(&log);
133
134                         if (ao_log_state == ao_flight_landed)
135                                 ao_log_stop();
136                 }
137 #endif
138
139                 ao_log_flush();
140
141                 /* Wait for a while */
142                 ao_delay(AO_MS_TO_TICKS(100));
143
144                 /* Stop logging when told to */
145                 while (!ao_log_running)
146                         ao_sleep(&ao_log_running);
147         }
148 }
149
150 uint16_t
151 ao_log_flight(uint8_t slot)
152 {
153         if (!ao_storage_read(ao_log_pos(slot),
154                              &log,
155                              sizeof (struct ao_log_mini)))
156                 return 0;
157
158         if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
159                 return log.u.flight.flight;
160         return 0;
161 }