#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Error {
NoSuchRecording,
+ StorageError,
}
enum SectorFlag {
recording_started: u32,
+ // The total distance logged of the currently running recording.
+ pub total_distance_cm: u32,
+
+ split_distance_cm: u32,
+ split_duration_ms: u32,
+ pub pace_s: u32,
+
// The number of slots filled in num_flight.
num_in_flight: usize,
recording_id: 0,
first_sector: 0,
recording_started: 0,
+ total_distance_cm: 0,
+ split_distance_cm: 0,
+ split_duration_ms: 0,
+ pace_s: 0,
num_in_flight: 0,
in_flight: [InFlight::new(); 7],
self.sectors_written = 0;
self.recording_started = tap.unix_time;
+ self.total_distance_cm = 0;
+ self.split_distance_cm = 0;
+ self.split_duration_ms = 0;
+ self.pace_s = 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
}
// 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);
}
+
+ let distance_cm = tap.distance_cm(&prev_tap) as u32;
+
+ self.total_distance_cm += distance_cm;
+ self.split_distance_cm += distance_cm;
+
+ self.split_duration_ms += d_time_ms;
+
+ if self.split_distance_cm >= 100_000 {
+ self.split_distance_cm -= 100_000;
+
+ self.pace_s = self.split_duration_ms / 1000;
+ self.split_duration_ms = 0;
+ }
}
pub fn stop_recording(&mut self, tap: &TimeAndPos) -> u16 {
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) {
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,
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");
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)
+ }
+ }
}