X-Git-Url: https://git.gag.com/?p=fw%2Faltos;a=blobdiff_plain;f=src%2Fao_log.c;h=099c5f6ff9683aebf4a7048f2ed212e71578f60e;hp=00bb46d32369781b9b9bd15c0996a3e71ab6d745;hb=da42f406e88ccc821cd45d5a94d5afec65ec50e9;hpb=e991f52276248fa08d96fbecc458bc478e98d299 diff --git a/src/ao_log.c b/src/ao_log.c index 00bb46d3..099c5f6f 100644 --- a/src/ao_log.c +++ b/src/ao_log.c @@ -42,8 +42,8 @@ ao_log_data(__xdata struct ao_log_record *log) __reentrant log->csum = 0; log->csum = ao_log_csum((__xdata uint8_t *) log); ao_mutex_get(&ao_log_mutex); { - if (ao_log_current_pos >= ao_log_end_pos) - ao_log_running = 0; + if (ao_log_current_pos >= ao_log_end_pos && ao_log_running) + ao_log_stop(); if (ao_log_running) { wrote = 1; ao_storage_write(ao_log_current_pos, @@ -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) @@ -103,10 +99,10 @@ ao_log(void) /* Write the whole contents of the ring to the log * when starting up. */ - ao_log_adc_pos = ao_adc_ring_next(ao_adc_head); + ao_log_adc_pos = ao_adc_ring_next(ao_flight_adc); for (;;) { /* Write samples to EEPROM */ - while (ao_log_adc_pos != ao_adc_head) { + while (ao_log_adc_pos != ao_flight_adc) { log.type = AO_LOG_SENSOR; log.tick = ao_adc_ring[ao_log_adc_pos].tick; log.u.sensor.accel = ao_adc_ring[ao_log_adc_pos].accel; @@ -174,6 +170,7 @@ ao_log_write_erase(uint8_t pos) erase.unused = 0x00; erase.flight = ao_flight_number; ao_storage_write(ao_log_erase_pos(pos), &erase, sizeof (erase)); + ao_storage_flush(); } static void @@ -200,66 +197,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 +277,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,58 +309,81 @@ ao_log_stop(void) ao_log_flush(); } +uint8_t +ao_log_present(void) +{ + return ao_log_max_flight() != 0; +} + +uint8_t +ao_log_full(void) +{ + return ao_log_current_pos == ao_log_end_pos; +} + 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 %x end %x\n", + flight, + (uint16_t) (ao_log_pos(slot) >> 8), + (uint16_t) (ao_log_pos(slot+1) >> 8)); } + printf ("done\n"); } 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 */ - { - if (ao_log_flight(slot) == ao_cmd_lex_i) { - ao_log_current_pos = 0; - ao_log_end_pos = ao_storage_config; - while (ao_log_current_pos < ao_log_end_pos) { - /* - * Check to see if we've reached the end of - * the used memory to avoid re-erasing the same - * memory over and over again - */ - if (ao_storage_read(ao_log_current_pos, - &log, - sizeof (struct ao_log_record))) { - for (slot = 0; slot < sizeof (struct ao_log_record); slot++) - if (((uint8_t *) &log)[slot] != 0xff) + if (ao_cmd_lex_i) { + for (slot = 0; slot < slots; slot++) { + if (ao_log_flight(slot) == ao_cmd_lex_i) { + ao_log_erase_mark(); + 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 + * the used memory to avoid re-erasing the same + * memory over and over again + */ + if (ao_storage_read(ao_log_current_pos, + &log, + sizeof (struct ao_log_record))) { + for (slot = 0; slot < sizeof (struct ao_log_record); slot++) + if (((uint8_t *) &log)[slot] != 0xff) + break; + if (slot == sizeof (struct ao_log_record)) break; - if (slot == sizeof (struct ao_log_record)) - break; + } + ao_storage_erase(ao_log_current_pos); + ao_log_current_pos += ao_storage_block; } - ao_storage_erase(ao_log_current_pos); - ao_log_current_pos += ao_storage_block; + puts("Erased"); + return; } - puts("Erased"); - return; } } - ao_log_erase_mark(); printf("No such flight: %d\n", ao_cmd_lex_i); }