X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=src%2Fcommon%2Flogger.rs;h=ea84bc23d4e23ad71d73f6ec6859977e1f913a6b;hb=70fb2fadd8688fdc11ba1d398661ac99aaa1b02a;hp=2ca2e22980f48b7867abddae91b2e09e1506c7d2;hpb=241e581359f381c5aaa18cefa3dbcb7d46241267;p=gps-watch.git

diff --git a/src/common/logger.rs b/src/common/logger.rs
index 2ca2e22..ea84bc2 100644
--- a/src/common/logger.rs
+++ b/src/common/logger.rs
@@ -38,6 +38,7 @@ const NUM_SECTORS: usize = MEMORY_SIZE / SECTOR_SIZE;
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Error {
     NoSuchRecording,
+    StorageError,
 }
 
 enum SectorFlag {
@@ -115,6 +116,9 @@ pub struct Logger<'a> {
 
     recording_started: u32,
 
+    // The total distance logged of the currently running recording.
+    pub total_distance_cm: u32,
+
     // The number of slots filled in num_flight.
     num_in_flight: usize,
 
@@ -289,6 +293,7 @@ impl<'a> Logger<'a> {
             recording_id: 0,
             first_sector: 0,
             recording_started: 0,
+            total_distance_cm: 0,
             num_in_flight: 0,
 
             in_flight: [InFlight::new(); 7],
@@ -356,16 +361,19 @@ impl<'a> Logger<'a> {
 
         self.sectors_written = 0;
         self.recording_started = tap.unix_time;
+        self.total_distance_cm = 0;
         self.num_in_flight = 0;
 
         self.prepare_write_buffer(true);
 
-        self.write_packet(0, tap.latitude, tap.longitude);
+        self.write_packet(0, tap.latitude_deg, tap.longitude_deg);
 
         self.recording_id
     }
 
     pub fn log(&mut self, prev_tap: &TimeAndPos, tap: &TimeAndPos) {
+        self.total_distance_cm += tap.distance_cm(&prev_tap) as u32;
+
         let d_time_ms = elapsed_ms(tap.system_time, prev_tap.system_time);
 
         // We know that our hardware cannot deliver updates more often
@@ -376,8 +384,8 @@ impl<'a> Logger<'a> {
         // the intervals to full seconds.
         let d_time_s = (d_time_ms + 500) / 1000;
 
-        let d_lat = tap.latitude - prev_tap.latitude;
-        let d_lon = tap.longitude - prev_tap.longitude;
+        let d_lat = tap.latitude_deg - prev_tap.latitude_deg;
+        let d_lon = tap.longitude_deg - prev_tap.longitude_deg;
 
         if self.write_packet(d_time_s, d_lat, d_lon) {
             self.flush_in_flight(false);
@@ -554,6 +562,17 @@ impl<'a> Logger<'a> {
                 continue;
             }
 
+            let mut num_data_sectors = 0;
+
+            for d in 1..NUM_SECTORS {
+                let wrapped_index = ((index + d) & (NUM_SECTORS - 1)) as usize;
+                let other_sector_header = &self.sector_header[wrapped_index];
+
+                if other_sector_header.belongs_to(sector_header.recording_id) {
+                    num_data_sectors += 1;
+                }
+            }
+
             let mut date_time_s = [b' '; 19];
 
             if let Some(tm) = Time::from_unix_time(sector_header.start_time) {
@@ -561,6 +580,13 @@ impl<'a> Logger<'a> {
                 tm.fmt_time(&mut date_time_s[11..]);
             }
 
+            let recording_size = (num_data_sectors + 1) * (SECTOR_SIZE >> 10);
+
+            let mut recording_size_s = [b'0'; 9];
+            let recording_size_s_len = fmt_u32_pad(&mut recording_size_s,
+                                                   recording_size as u32,
+                                                   8, b' ');
+
             let mut recording_id_s = [b'0'; 9];
             let recording_id_s_len =
                 fmt_u32_pad(&mut recording_id_s,
@@ -568,7 +594,8 @@ impl<'a> Logger<'a> {
                             8, b' ');
 
             tx_buf.write(&date_time_s);
-            tx_buf.write(b"       ");
+            tx_buf.write(&recording_size_s[0..recording_size_s_len]);
+            tx_buf.write(b"K");
             tx_buf.write(&recording_id_s[0..recording_id_s_len]);
             tx_buf.write(b"\n");
 
@@ -647,4 +674,40 @@ impl<'a> Logger<'a> {
             Err(Error::NoSuchRecording)
         }
     }
+
+    ///
+    /// Remove recording @p recording_id.
+    pub fn remove_recording(&mut self, recording_id: u16) -> Result<(), Error> {
+        if let Some(found_index) = (0..NUM_SECTORS).find(|&index| {
+            let sector_header = &self.sector_header[index as usize];
+
+            sector_header.recording_id == recording_id &&
+            sector_header.starts_recording()
+        }) {
+            let mut next_sector = found_index as usize;
+
+            for _ in 0..NUM_SECTORS {
+                let address = next_sector * SECTOR_SIZE;
+
+                if let Err(_) = self.storage.erase(address) {
+                    return Err(Error::StorageError);
+                }
+
+                // Mark this sector as eligible for the next recording
+                // and ensure it won't be picked up by list_recordings().
+                self.read_sector_header(next_sector);
+
+                next_sector += 1;
+                next_sector &= NUM_SECTORS - 1;
+
+                if !self.sector_header[next_sector].belongs_to(recording_id) {
+                    break;
+                }
+            }
+
+            Ok(())
+        } else {
+            Err(Error::NoSuchRecording)
+        }
+    }
 }