altos: support storage of multiple flights.

This adds the logging support for dealing with multiple flights

Signed-off-by: Keith Packard <keithp@keithp.com>

diff --git a/src/ao.h b/src/ao.h
index a5890d4726736538d03baa9c6414842799a975aa..ad02a8296f22de94c1eca7bdb029805607b1ee11 100644 (file)
--- a/src/ao.h
+++ b/src/ao.h
@@ -624,6 +624,10 @@ ao_log_init(void);
 void
 ao_log_write_erase(uint8_t pos);
 
+/* Returns true if there are any logs stored in eeprom */
+uint8_t
+ao_log_present(void);
+
 /*
  * ao_flight.c
  */

diff --git a/src/ao_config.c b/src/ao_config.c
index ebfb0386c4fa851505a6efe0978b728592082df3..a3e0a64f3451e2d76bd01c1ef58767b2f2c8b29b 100644 (file)
--- a/src/ao_config.c
+++ b/src/ao_config.c
@@ -27,7 +27,7 @@ __xdata uint8_t ao_config_mutex;
 #define AO_CONFIG_DEFAULT_CALLSIGN     "N0CALL"
 #define AO_CONFIG_DEFAULT_ACCEL_ZERO_G 16000
 #define AO_CONFIG_DEFAULT_APOGEE_DELAY 0
-#define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX       ((uint32_t) 256 * (uint32_t) 1024)
+#define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX       ((uint32_t) 192 * (uint32_t) 1024)
 
 #if HAS_EEPROM
 static void
@@ -308,14 +308,18 @@ ao_config_log_set(void) __reentrant
        ao_cmd_decimal();
        if (ao_cmd_status != ao_cmd_success)
                return;
-       ao_mutex_get(&ao_config_mutex);
-       _ao_config_get();
-       if (ao_storage_block > 1024 && (ao_cmd_lex_u32 & ((ao_storage_block >> 10) - 1)))
+       if (ao_log_present())
+               printf("Storage must be empty before changing log size\n");
+       else if (ao_storage_block > 1024 && (ao_cmd_lex_u32 & ((ao_storage_block >> 10) - 1)))
                printf("Flight log size must be multiple of %ld\n", ao_storage_block >> 10);
-       ao_config.flight_log_max = ao_cmd_lex_u32 << 10;
-       ao_config_dirty = 1;
-       ao_mutex_put(&ao_config_mutex);
-       ao_config_log_show();
+       else {
+               ao_mutex_get(&ao_config_mutex);
+               _ao_config_get();
+               ao_config.flight_log_max = ao_cmd_lex_u32 << 10;
+               ao_config_dirty = 1;
+               ao_mutex_put(&ao_config_mutex);
+               ao_config_log_show();
+       }
 }
 #endif /* HAS_EEPROM */
 

diff --git a/src/ao_log.c b/src/ao_log.c
index 21d0bc34419fa96f883a9d7eefac0946e5addad1..47f24f0195151b95289e3729af64f589d13e40d0 100644 (file)
--- a/src/ao_log.c
+++ b/src/ao_log.c
@@ -85,10 +85,6 @@ ao_log(void)
 {
        ao_storage_setup();
 
-       /* For now, use all of the available space */
-       ao_log_current_pos = 0;
-       ao_log_end_pos = ao_storage_config;
-
        ao_log_scan();
 
        while (!ao_log_running)
@@ -200,66 +196,64 @@ ao_log_erase_mark(void)
        ao_config_put();
 }
 
-static void
-ao_log_erase(uint8_t pos)
+static uint8_t
+ao_log_slots()
 {
-       ao_config_get();
-       (void) pos;
-//     ao_log_current_pos = pos * ao_config.flight_log_max;
-//     ao_log_end_pos = ao_log_current_pos + ao_config.flight_log_max;
-//     if (ao_log_end_pos > ao_storage_config)
-//             return;
-
-       ao_log_current_pos = 0;
-       ao_log_end_pos = ao_storage_config;
-
-       while (ao_log_current_pos < ao_log_end_pos) {
-               ao_storage_erase(ao_log_current_pos);
-               ao_log_current_pos += ao_storage_block;
-       }
+       return (uint8_t) (ao_storage_config / ao_config.flight_log_max);
+}
+
+static uint32_t
+ao_log_pos(uint8_t slot)
+{
+       return ((slot) * ao_config.flight_log_max);
 }
 
 static uint16_t
 ao_log_flight(uint8_t slot)
 {
-       (void) slot;
-       if (!ao_storage_read(0,
+       if (!ao_storage_read(ao_log_pos(slot),
                             &log,
                             sizeof (struct ao_log_record)))
-               ao_panic(AO_PANIC_LOG);
+               return 0;
 
        if (ao_log_dump_check_data() && log.type == AO_LOG_FLIGHT)
                return log.u.flight.flight;
        return 0;
 }
 
-static void
-ao_log_scan(void) __reentrant
+static uint16_t
+ao_log_max_flight(void)
 {
        uint8_t         log_slot;
        uint8_t         log_slots;
-       uint8_t         log_avail = 0;
        uint16_t        log_flight;
-
-       ao_config_get();
-
-       ao_flight_number = 0;
+       uint16_t        max_flight = 0;
 
        /* Scan the log space looking for the biggest flight number */
-       log_slot = 0;
-       {
+       log_slots = ao_log_slots();
+       for (log_slot = 0; log_slot < log_slots; log_slot++) {
                log_flight = ao_log_flight(log_slot);
-               if (log_flight) {
-                       if (++log_flight == 0)
-                               log_flight = 1;
-                       if (ao_flight_number == 0 ||
-                           (int16_t) (log_flight - ao_flight_number) > 0) {
-                               ao_flight_number = log_flight;
-                       }
-               } else
-                       log_avail = 1;
+               if (!log_flight)
+                       continue;
+               if (max_flight == 0 || (int16_t) (log_flight - max_flight) > 0)
+                       max_flight = log_flight;
        }
-       log_slots = log_slot + 1;
+       return max_flight;
+}
+
+static void
+ao_log_scan(void) __reentrant
+{
+       uint8_t         log_slot;
+       uint8_t         log_slots;
+       uint8_t         log_want;
+
+       ao_config_get();
+
+       ao_flight_number = ao_log_max_flight();
+       if (ao_flight_number)
+               if (++ao_flight_number == 0)
+                       ao_flight_number = 1;
 
        /* Now look through the log of flight numbers from erase operations and
         * see if the last one is bigger than what we found above
@@ -282,11 +276,19 @@ ao_log_scan(void) __reentrant
         */
 
        /* Find a log slot for the next flight, if available */
-       if (log_avail) {
-               ao_log_current_pos = 0;
-               ao_log_end_pos = ao_storage_config;
-       } else
-               ao_log_current_pos = ao_log_end_pos = 0;
+       ao_log_current_pos = ao_log_end_pos = 0;
+       log_slots = ao_log_slots();
+       log_want = (ao_flight_number - 1) % log_slots;
+       log_slot = log_want;
+       do {
+               if (ao_log_flight(log_slot) == 0) {
+                       ao_log_current_pos = ao_log_pos(log_slot);
+                       ao_log_end_pos = ao_log_current_pos + ao_config.flight_log_max;
+                       break;
+               }
+               if (++log_slot >= log_slots)
+                       log_slot = 0;
+       } while (log_slot != log_want);
 
        ao_wakeup(&ao_flight_number);
 }
@@ -306,19 +308,28 @@ ao_log_stop(void)
        ao_log_flush();
 }
 
+uint8_t
+ao_log_present(void)
+{
+       return ao_log_max_flight() != 0;
+}
+
 static __xdata struct ao_task ao_log_task;
 
 void
 ao_log_list(void) __reentrant
 {
        uint8_t slot;
+       uint8_t slots;
        uint16_t flight;
 
-       slot = 0;
+       slots = ao_log_slots();
+       for (slot = 0; slot < slots; slot++)
        {
                flight = ao_log_flight(slot);
                if (flight)
-                       printf ("Flight %d\n", flight);
+                       printf ("flight %d start %ld end %ld\n",
+                               flight, ao_log_pos(slot), ao_log_pos(slot+1));
        }
        printf ("done\n");
 }
@@ -327,15 +338,18 @@ void
 ao_log_delete(void) __reentrant
 {
        uint8_t slot;
+       uint8_t slots;
+
        ao_cmd_decimal();
        if (ao_cmd_status != ao_cmd_success)
                return;
-       slot = 0;
+
+       slots = ao_log_slots();
        /* Look for the flight log matching the requested flight */
-       {
+       for (slot = 0; slot < slots; slot++) {
                if (ao_log_flight(slot) == ao_cmd_lex_i) {
-                       ao_log_current_pos = 0;
-                       ao_log_end_pos = ao_storage_config;
+                       ao_log_current_pos = ao_log_pos(slot);
+                       ao_log_end_pos = ao_log_current_pos + ao_config.flight_log_max;
                        while (ao_log_current_pos < ao_log_end_pos) {
                                /*
                                 * Check to see if we've reached the end of

diff --git a/src/ao_storage.c b/src/ao_storage.c
index 25a7c8b9016a651558c98233abc83a1d5a22edee..c4beedd21c93f44b7b6272b32fe8677cb7584b28 100644 (file)
--- a/src/ao_storage.c
+++ b/src/ao_storage.c
@@ -103,6 +103,10 @@ ao_storage_dump(void) __reentrant
        }
 }
 
+#if 0
+
+/* not enough space for this today
+ */
 static void
 ao_storage_store(void) __reentrant
 {
@@ -130,6 +134,7 @@ ao_storage_store(void) __reentrant
                addr++;
        }
 }
+#endif
 
 void
 ao_storage_zap(void) __reentrant
@@ -140,6 +145,18 @@ ao_storage_zap(void) __reentrant
        ao_storage_erase((uint32_t) ao_cmd_lex_i << 8);
 }
 
+void
+ao_storage_zapall(void) __reentrant
+{
+       uint32_t        pos;
+
+       ao_cmd_white();
+       if (!ao_match_word("DoIt"))
+               return;
+       for (pos = 0; pos < ao_storage_config; pos += ao_storage_block)
+               ao_storage_erase(pos);
+}
+
 void
 ao_storage_info(void) __reentrant
 {
@@ -151,8 +168,11 @@ ao_storage_info(void) __reentrant
 __code struct ao_cmds ao_storage_cmds[] = {
        { 'f', ao_storage_info, "f                                  Show storage info" },
        { 'e', ao_storage_dump, "e <block>                          Dump a block of flash data" },
-       { 'w', ao_storage_store,"w <block> <start> <len> <data> ... Write data to flash" },
-       { 'z', ao_storage_zap,  "z <block>                          Erase flash containing <block>" },
+#if 0
+       { 'w', ao_storage_store, "w <block> <start> <len> <data> ... Write data to flash" },
+       #endif
+       { 'z', ao_storage_zap,   "z <block>                          Erase flash containing <block>" },
+       { 'Z', ao_storage_zapall,"Z <key>                            Erase all logs. <key> is doit with D&I" },
        { 0,   ao_storage_zap, NULL },
 };