common: Implement the "rm" shell command.

Removes a recording.

common: Implement Logger::remove_recording().

common: Implement Storage::erase() in Mx25l.

common: Rename TimeAndPos::latitude to latitude_deg.

Same for longitude.

application: Show distance travelled while recording.

common: Implement TimeAndPos::distance_cm().

Calculates the distance between two points in cm.

common: Store GPS coordinates in radians, too.

Use the Q15.49 fixed point format to store those values.

common: Add the fixed15_49 module.

Implements Q15.49 fixed point math.

test: Order arguments to assert_eq!() consistently.

The expected value comes first.

common: Include the recordings' size in the listing.

The size is only approximate (i.e. multiples of sectors used).

common: Avoid duplicated recordings shown in Logger::list_recordings().

This is achieved by simplifying the way we sort our sector indices,
which unfortunately also comes with a performance hit.

common: Use slice.swap() to clean up SectorHeaderIter::sort().

common: Factor out the SectorHeaderIter::sort() method.

test: Verify Logger::list_recordings()'s behavior with empty storage.

We expect no output in that case.

test: Make Logger test's pipe non-blocking.

There are cases where we need to verify that the pipe is empty.

test: Add a first test for Logger::list_recordings().

tools: Import the gpxify program.

gpxify takes as input an recording retrieved from the GPS watch
and converts it to GPX format.

tools: Add license header to update-firmware.

common: Implement the "ls" shell command.

Shows a listing of the stored recordings.

common: Implement Logger::list_recordings().

common: Make Logger::read_sector_header() read the start_time field.

This is necessary so that we can show the date and time when a
recording was done.

test: Use a pipe to back the write buffer for the Logger test.

common: Silence compiler warnings about ignored Result return values.

Note that we still don't handle potential errors from Storage::write().

common: Implement the "get" shell command.

Retrieves a recording in yenc format.

application: Start and stop recordings by pressing the play button.

common: Implement Logger::has_recording().

contrib: Add udev rules file.

common: Add missing Write Enable command to Mx25L::program_page().

Without a write enable, the flash memory doesn't take our data.

application: Set up a Logger instance.

This also passes a mutable Logger reference to Shell::update()
since we no longer can pass another mutable Storage reference to it:
doing so would break the requirement of only having one
mutable reference to any instance at any time, and Logger requires
a mutable storage reference, too.

common: Make Logger::storage public.

This is required to avoid some multiple mutable borrow issues
in the upcoming changesets.

common: Implement Logger::get_recording().

common: Synchronize sector headers after a recording is finished.

This is necessary to be able to retrieve the recording without
restarting the device.

common: Factor out Logger::read_sector_header().

test: Add tests for the logger module.

common: Add the logger module.

test: Add tests for the gps module.

common: Make Gps::update() access UART0's receive buffer via a closure.

This will allow us to write tests for Gps without providing a fake
implementation of the UART reader function in the test.

build: Add infrastructure for building automated tests.

build: Split SConscript.libcommon in two.

Split it in SConscript.libcommon.c, dealing with the C code
that's used to build libcommon.a, and SConscript.libcommon.rs,
used to build libcommon.rlib.

This will be useful for native builds used for testing in the future.

common: Implement the "dump_storage" shell command.

Lists the mx25l flash's contents in the yencode format.

common: Implement Storage::size() in Mx25l.

common: Implement the "clear_storage" shell command.

Erases all of the mx25l flash's contents.

application: Integrate flash storage via Mx25l.

common: Implement Storage::clear() in Mx25l.

application: Integrate the shell.

common: Implement Mx25l::erase_all().

common: Implement Storage::write() in Mx25l.

common: Implement Mx25l::program_page().

common: Implement Mx25l::erase_sector().

common: Add the varint module.

common: Add the yencode module.

common: Implement Time::fmt_date().

common: Add the shell module.

It implements no useful functionality yet.

bootloader: Stay in bootloader when the middle left push button is held.

application: Make system reset less likely do be run by accident.

System reset is now triggered by holding the upper left and the
lower right push button at the same time.

application: Configure the remaining push buttons.

application: Factor out the configure_push_buttons() function.

application: Factor out the reset_requested() function.

No change in behavior.

application: Set up pins for the MX25L flash memory.

This configures SPI0 as well as the GPIO used as the flash's
chip select line.

common: Implement Storage::read() in Mx25l.

common: Add the storage module.

application: Perform system reset from panic handler if requested.

This is untested; I'm not sure if it would work at all.

common: Add the mx25l module.

Provides access to the status register and device ID only for now.

common: Accept DGPS fix information.

We used to reject differential GPS (DGPS) fixes as invalid, but they
are actually more accurate than standard GPS fixes.

common: Increase size of the UART receive ringbuffer.

The GPS module sends about ~380 bytes per second, which led to
overflows of our 256 byte sized ringbuffer.

common: Add the spi module.

common: Restart NMEA message parsing when a '$' character is seen.

The GPS module sometimes sends incomplete NMEA messages such as this:
  $GP$GGA...*
This changeset makes it so we'd only parse the second, complete message
in that example.

tools: Pad final chunks with 0xff if necessary.

The bootloader only accepts chunks whose size is a multiple of four.

common: Move panic handler out of libcommon.

This allows us to do a native build of libcommon which is useful for
unit testing.

application: Show current time on the display if we have a GPS fix.

common: Implement Time::fmt_time().

Formats time as HH:MM:SS.

common: Add the time module.

This currently only contains the equivalent of gmtime(), which was
adapted from Rich Felker's musl.

common: Add the fmt module.

common: Implement screen::clear() and screen::draw_text().

This also imports (a subset of) Frederic Cambus' spleen font,
used by screen::draw_text().

common: Tweak bit order of screen data.

The left-most pixel is now defined by the most significant bit.
This is a more intuitive representation than what we had before.

application: Visualize GPS fix state using the satellite icons.

As long as we are waiting for a GPS fix, we animate the satellite
icons.

application: Manage whether or not we have valid GPS fix information.

Expire such information after about 1.5s.

application: Blink heart icon to indicate liveness.

common: Implement display::show_icon() and display::hide_icon().

This only supports the alarm, heart and satellite icons for now,
but not the battery meter icon.

application: Extract time and position from GPS NMEA messages.

common: Add the gps module.

application: Set up pins for the GPS.

This configures UART0 as well as the GPS' reset line.

application: Define UART0_IRQHandler().

Writes received data to the global uart0_rx_buf ringbuffer.

common: Add Rust glue for the ringbuf module.

For now this only allows us to access a ringbuffer from Rust
after it has been defined in C code.

common: Add the uart module.

application: Enable OSC0.

Needed for UART0.

common: Implement clock::enable_osc0().

build: Use rustc to link the binaries instead of gcc.

This simplifies the build system by removing the need for
libapplication.a, libbootloader.a and the two start.c copies.

bootloader: Mark jump_to_application() as noreturn.

build: Link libgcc from the command line instead of the linker script.

Pulling it in via the linker script will only work if we use our
C toolchain's linker and would fail if we used the Rust linker.

build: Don't link libraries we don't need.

application: Initialize and clear the display on startup.

application: Set up pins for the display.

This configures I2C0 as well as the GPIO used to control the display's
reset line.

common: Add the display module.

It currently can initialize, clear and draw the main area
of the display. Drawing or clearing the icon area is not yet
supported.

application: Perform a system reset if PTA12 is pressed.

application: Configure PTA12 for push button use.

common: Implement nvic::system_reset().

Performs a system reset.

bootloader: Never auto-start the application in the intermediate bootloader.

Instead, we now always enter bootloader operation. I think this has
less potential of bricking a device in case you don't press PTE24
fast enough after installing the intermediate bootloader.

common: Add the i2c module.

bootloader: Call clock::reset() before jumping to the application.

By switching back to FBE clock mode there, we can unconditionally
do the switches to FBE, PBE and PEE in any of our programs.