Strict usage of TockResult
diff --git a/examples/adc.rs b/examples/adc.rs
index 202270f..49d68f5 100644
--- a/examples/adc.rs
+++ b/examples/adc.rs
@@ -3,19 +3,20 @@
 use core::fmt::Write;
 use libtock::adc;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     let mut with_callback = adc::with_callback(|channel: usize, value: usize| {
         writeln!(console, "channel: {}, value: {}", channel, value).unwrap();
     });
 
-    let adc = with_callback.init().unwrap();
+    let adc = with_callback.init()?;
 
     loop {
-        adc.sample(0).unwrap();
-        timer::sleep(Duration::from_ms(2000)).await;
+        adc.sample(0)?;
+        timer::sleep(Duration::from_ms(2000)).await?;
     }
 }
diff --git a/examples/adc_buffer.rs b/examples/adc_buffer.rs
index 67917ad..4667209 100644
--- a/examples/adc_buffer.rs
+++ b/examples/adc_buffer.rs
@@ -4,25 +4,26 @@
 use libtock::adc;
 use libtock::adc::AdcBuffer;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::syscalls;
 
 /// Reads a 128 byte sample into a buffer and prints the first value to the console.
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     let mut adc_buffer = AdcBuffer::new();
     let mut temp_buffer = [0; libtock::adc::BUFFER_SIZE];
 
-    let adc_buffer = libtock::adc::Adc::init_buffer(&mut adc_buffer).unwrap();
+    let adc_buffer = libtock::adc::Adc::init_buffer(&mut adc_buffer)?;
 
     let mut with_callback = adc::with_callback(|_, _| {
         adc_buffer.read_bytes(&mut temp_buffer[..]);
         writeln!(console, "First sample in buffer: {}", temp_buffer[0]).unwrap();
     });
 
-    let adc = with_callback.init().unwrap();
+    let adc = with_callback.init()?;
 
     loop {
-        adc.sample_continuous_buffered(0, 128).unwrap();
+        adc.sample_continuous_buffered(0, 128)?;
         unsafe { syscalls::raw::yieldk() };
     }
 }
diff --git a/examples/async.rs b/examples/async.rs
index f4cc9e7..d11ec67 100644
--- a/examples/async.rs
+++ b/examples/async.rs
@@ -5,36 +5,38 @@
 use libtock::buttons::ButtonState;
 use libtock::futures as libtock_futures;
 use libtock::led;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
-    future::join(blink_periodically(), blink_on_button_press()).await;
+async fn main() -> TockResult<()> {
+    future::try_join(blink_periodically(), blink_on_button_press()).await?;
+    Ok(())
 }
 
-async fn blink_periodically() {
+async fn blink_periodically() -> TockResult<()> {
     let led = led::get(0).unwrap();
     loop {
-        timer::sleep(Duration::from_ms(250)).await;
-        led.on();
-        timer::sleep(Duration::from_ms(250)).await;
-        led.off();
+        timer::sleep(Duration::from_ms(250)).await?;
+        led.on()?;
+        timer::sleep(Duration::from_ms(250)).await?;
+        led.off()?;
     }
 }
 
-async fn blink_on_button_press() {
+async fn blink_on_button_press() -> TockResult<()> {
     let mut with_callback = buttons::with_callback(|_, _| {});
-    let mut buttons = with_callback.init().unwrap();
+    let mut buttons = with_callback.init()?;
     let mut button = buttons.iter_mut().next().unwrap();
-    let button = button.enable().unwrap();
+    let button = button.enable()?;
     let led = led::get(1).unwrap();
 
     loop {
-        libtock_futures::wait_until(|| button.read() == ButtonState::Released).await;
-        libtock_futures::wait_until(|| button.read() == ButtonState::Pressed).await;
-        led.on();
-        libtock_futures::wait_until(|| button.read() == ButtonState::Released).await;
-        libtock_futures::wait_until(|| button.read() == ButtonState::Pressed).await;
-        led.off();
+        libtock_futures::wait_until(|| button.read().ok() == Some(ButtonState::Released)).await;
+        libtock_futures::wait_until(|| button.read().ok() == Some(ButtonState::Pressed)).await;
+        led.on()?;
+        libtock_futures::wait_until(|| button.read().ok() == Some(ButtonState::Released)).await;
+        libtock_futures::wait_until(|| button.read().ok() == Some(ButtonState::Pressed)).await;
+        led.off()?;
     }
 }
diff --git a/examples/ble_scanning.rs b/examples/ble_scanning.rs
index 71ec632..216d8a1 100644
--- a/examples/ble_scanning.rs
+++ b/examples/ble_scanning.rs
@@ -3,6 +3,7 @@
 use futures::future;
 use libtock::ble_parser;
 use libtock::led;
+use libtock::result::TockResult;
 use libtock::simple_ble;
 use libtock::simple_ble::BleCallback;
 use libtock::simple_ble::BleDriver;
@@ -14,20 +15,20 @@
     pub st: bool,
 }
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut shared_buffer = BleDriver::create_scan_buffer();
     let mut my_buffer = BleDriver::create_scan_buffer();
-    let shared_memory = BleDriver::share_memory(&mut shared_buffer).unwrap();
+    let shared_memory = BleDriver::share_memory(&mut shared_buffer)?;
 
     let mut callback = BleCallback::new(|_: usize, _: usize| {
         shared_memory.read_bytes(&mut my_buffer[..]);
         ble_parser::find(&my_buffer, simple_ble::gap_data::SERVICE_DATA as u8)
             .and_then(|service_data| ble_parser::extract_for_service([91, 79], service_data))
             .and_then(|payload| corepack::from_bytes::<LedCommand>(&payload).ok())
-            .and_then(|msg| led::get(msg.nr as isize).map(|led| led.set_state(msg.st)));
+            .and_then(|msg| led::get(msg.nr as usize).map(|led| led.set_state(msg.st)));
     });
 
-    let _subscription = BleDriver::start(&mut callback).unwrap();
+    let _subscription = BleDriver::start(&mut callback)?;
 
     future::pending().await
 }
diff --git a/examples/blink.rs b/examples/blink.rs
index b731dd7..34c5d2b 100644
--- a/examples/blink.rs
+++ b/examples/blink.rs
@@ -1,11 +1,12 @@
 #![no_std]
 
 use libtock::led;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
-    let num_leds = led::count();
+async fn main() -> TockResult<()> {
+    let num_leds = led::count()?;
 
     // Blink the LEDs in a binary count pattern and scale
     // to the number of LEDs on the board.
@@ -13,14 +14,14 @@
     loop {
         for i in 0..num_leds {
             if count & (1 << i) == (1 << i) {
-                led::get(i).unwrap().on();
+                led::get(i).unwrap().on()?;
             } else {
-                led::get(i).unwrap().off();
+                led::get(i).unwrap().off()?;
             }
         }
         count = count.wrapping_add(1);
 
         // This delay uses an underlying timer in the kernel.
-        timer::sleep(Duration::from_ms(250)).await;
+        timer::sleep(Duration::from_ms(250)).await?;
     }
 }
diff --git a/examples/blink_random.rs b/examples/blink_random.rs
index 48bbf5f..e30a7cd 100644
--- a/examples/blink_random.rs
+++ b/examples/blink_random.rs
@@ -1,36 +1,38 @@
 #![no_std]
 
 use libtock::led;
+use libtock::result::TockResult;
 use libtock::rng;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
-    let num_leds = led::count();
+async fn main() -> TockResult<()> {
+    let num_leds = led::count().ok().unwrap();
     // blink_nibble assumes 4 leds.
     assert_eq!(num_leds, 4);
 
     let mut buf = [0; 64];
     loop {
-        assert!(rng::fill_buffer(&mut buf).await);
+        rng::fill_buffer(&mut buf).await?;
 
         for &x in buf.iter() {
-            blink_nibble(x);
-            timer::sleep(Duration::from_ms(100)).await;
-            blink_nibble(x >> 4);
-            timer::sleep(Duration::from_ms(100)).await;
+            blink_nibble(x)?;
+            timer::sleep(Duration::from_ms(100)).await?;
+            blink_nibble(x >> 4)?;
+            timer::sleep(Duration::from_ms(100)).await?;
         }
     }
 }
 
 // Takes the 4 least-significant bits of x, and turn the 4 leds on/off accordingly.
-fn blink_nibble(x: u8) {
+fn blink_nibble(x: u8) -> TockResult<()> {
     for i in 0..4 {
         let led = led::get(i).unwrap();
         if (x >> i) & 1 != 0 {
-            led.on();
+            led.on()?;
         } else {
-            led.off();
+            led.off()?;
         }
     }
+    Ok(())
 }
diff --git a/examples/button_leds.rs b/examples/button_leds.rs
index 42571ba..51a1b85 100644
--- a/examples/button_leds.rs
+++ b/examples/button_leds.rs
@@ -4,20 +4,20 @@
 use libtock::buttons;
 use libtock::buttons::ButtonState;
 use libtock::led;
+use libtock::result::TockResult;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut with_callback = buttons::with_callback(|button_num: usize, state| {
-        let i = button_num as isize;
         match state {
-            ButtonState::Pressed => led::get(i).unwrap().toggle(),
+            ButtonState::Pressed => led::get(button_num).unwrap().toggle().ok().unwrap(),
             ButtonState::Released => (),
         };
     });
 
-    let mut buttons = with_callback.init().unwrap();
+    let mut buttons = with_callback.init()?;
 
     for mut button in &mut buttons {
-        button.enable().unwrap();
+        button.enable()?;
     }
 
     future::pending().await
diff --git a/examples/button_read.rs b/examples/button_read.rs
index 336955d..e7ebfc8 100644
--- a/examples/button_read.rs
+++ b/examples/button_read.rs
@@ -4,22 +4,22 @@
 use libtock::buttons;
 use libtock::buttons::ButtonState;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     let mut with_callback = buttons::with_callback(|_, _| {});
-    let mut buttons = with_callback.init().unwrap();
+    let mut buttons = with_callback.init()?;
     let mut button = buttons.iter_mut().next().unwrap();
-    let button = button.enable().unwrap();
+    let button = button.enable()?;
 
     loop {
-        match button.read() {
+        match button.read()? {
             ButtonState::Pressed => writeln!(console, "pressed"),
             ButtonState::Released => writeln!(console, "released"),
-        }
-        .unwrap();
-        timer::sleep(Duration::from_ms(500)).await;
+        }?;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/button_subscribe.rs b/examples/button_subscribe.rs
index dab2422..c9acde1 100644
--- a/examples/button_subscribe.rs
+++ b/examples/button_subscribe.rs
@@ -5,9 +5,10 @@
 use libtock::buttons;
 use libtock::buttons::ButtonState;
 use libtock::console::Console;
+use libtock::result::TockResult;
 
-// FIXME: Hangs up when buttons are pressed rapidly - problem in console?
-async fn main() {
+// FIXME: Hangs up when buttons are pressed rapidly. Yielding in callback leads to stack overflow.
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
 
     let mut with_callback = buttons::with_callback(|button_num: usize, state| {
@@ -20,13 +21,14 @@
                 ButtonState::Released => "released",
             }
         )
+        .ok()
         .unwrap();
     });
 
-    let mut buttons = with_callback.init().unwrap();
+    let mut buttons = with_callback.init()?;
 
     for mut button in &mut buttons {
-        button.enable().unwrap();
+        button.enable()?;
     }
 
     future::pending().await
diff --git a/examples/gpio.rs b/examples/gpio.rs
index 4d5b9a4..1966264 100644
--- a/examples/gpio.rs
+++ b/examples/gpio.rs
@@ -1,18 +1,19 @@
 #![no_std]
 
 use libtock::gpio::GpioPinUnitialized;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
 // Example works on P0.03
-async fn main() {
+async fn main() -> TockResult<()> {
     let pin = GpioPinUnitialized::new(0);
-    let pin = pin.open_for_write().unwrap();
+    let pin = pin.open_for_write()?;
 
     loop {
-        pin.set_high();
-        timer::sleep(Duration::from_ms(500)).await;
-        pin.set_low();
-        timer::sleep(Duration::from_ms(500)).await;
+        pin.set_high()?;
+        timer::sleep(Duration::from_ms(500)).await?;
+        pin.set_low()?;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/gpio_read.rs b/examples/gpio_read.rs
index 5c18f62..01a9e8a 100644
--- a/examples/gpio_read.rs
+++ b/examples/gpio_read.rs
@@ -2,22 +2,24 @@
 
 use core::fmt::Write;
 use libtock::console::Console;
-use libtock::gpio::{GpioPinUnitialized, InputMode};
+use libtock::gpio::GpioPinUnitialized;
+use libtock::gpio::InputMode;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
 // example works on p0.03
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     let pin = GpioPinUnitialized::new(0);
-    let pin = pin.open_for_read(None, InputMode::PullDown).unwrap();
+    let pin = pin.open_for_read(None, InputMode::PullDown)?;
 
     loop {
         if pin.read() {
-            writeln!(console, "true").unwrap();
+            writeln!(console, "true")?;
         } else {
-            writeln!(console, "false").unwrap();
+            writeln!(console, "false")?;
         }
-        timer::sleep(Duration::from_ms(500)).await;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/hardware_test.rs b/examples/hardware_test.rs
index dbc7f44..d519725 100644
--- a/examples/hardware_test.rs
+++ b/examples/hardware_test.rs
@@ -1,4 +1,5 @@
 #![no_std]
+
 /// Hardware regression tests.
 /// Need P0.03 and P0.04 to be connected (on a nrf52-dk).
 extern crate alloc;
@@ -8,6 +9,7 @@
 use futures::future;
 use libtock::console::Console;
 use libtock::gpio::{GpioPinUnitialized, InputMode};
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
@@ -29,7 +31,7 @@
     }
 }
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     write!(console, "[test-results]\n").unwrap();
 
@@ -42,6 +44,8 @@
     test_trait_objects(&mut console);
 
     test_callbacks_and_wait_forever(&mut console).await;
+
+    Ok(())
 }
 
 fn test_heap(console: &mut Console) {
@@ -60,11 +64,14 @@
 /// trait_obj_value_string = string
 fn test_trait_objects(console: &mut Console) {
     let pin_in = GpioPinUnitialized::new(0);
-    let pin_in = pin_in.open_for_read(None, InputMode::PullDown).unwrap();
+    let pin_in = pin_in
+        .open_for_read(None, InputMode::PullDown)
+        .ok()
+        .unwrap();
 
     let pin_out = GpioPinUnitialized::new(1);
-    let pin_out = pin_out.open_for_write().unwrap();
-    pin_out.set_high();
+    let pin_out = pin_out.open_for_write().ok().unwrap();
+    pin_out.set_high().ok().unwrap();
 
     let string = String::from("string");
 
@@ -93,11 +100,14 @@
 /// needs P0.03 and P0.04 to be connected
 fn test_gpio(console: &mut Console) {
     let pin_in = GpioPinUnitialized::new(0);
-    let pin_in = pin_in.open_for_read(None, InputMode::PullDown).unwrap();
+    let pin_in = pin_in
+        .open_for_read(None, InputMode::PullDown)
+        .ok()
+        .unwrap();
 
     let pin_out = GpioPinUnitialized::new(1);
-    let pin_out = pin_out.open_for_write().unwrap();
-    pin_out.set_high();
+    let pin_out = pin_out.open_for_write().ok().unwrap();
+    pin_out.set_high().ok().unwrap();
 
     write!(console, "gpio_works = {}\n", pin_in.read()).unwrap();
 }
@@ -108,9 +118,9 @@
         write!(console, "all_tests_run = true").unwrap();
     });
 
-    let mut timer = with_callback.init().unwrap();
+    let mut timer = with_callback.init().ok().unwrap();
 
-    timer.set_alarm(Duration::from_ms(500)).unwrap();
+    timer.set_alarm(Duration::from_ms(500)).ok().unwrap();
 
     future::pending().await
 }
diff --git a/examples/hello.rs b/examples/hello.rs
index c95bbd8..10a1aa9 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -2,14 +2,17 @@
 
 use core::fmt::Write;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
 
     for i in 0.. {
-        writeln!(console, "Hello world! {}", i).unwrap();
-        timer::sleep(Duration::from_ms(500)).await;
+        writeln!(console, "Hello world! {}", i)?;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
+
+    Ok(())
 }
diff --git a/examples/panic.rs b/examples/panic.rs
index 8c58ac4..ad5b011 100644
--- a/examples/panic.rs
+++ b/examples/panic.rs
@@ -1,6 +1,8 @@
 #![no_std]
 
-async fn main() {
+use libtock::result::TockResult;
+
+async fn main() -> TockResult<()> {
     let _ = libtock::LibTock {};
     panic!("Bye world!");
 }
diff --git a/examples/sensors.rs b/examples/sensors.rs
index acd36e9..95f3c8d 100644
--- a/examples/sensors.rs
+++ b/examples/sensors.rs
@@ -2,21 +2,22 @@
 
 use core::fmt::Write;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::sensors::*;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
     let mut humidity = HumiditySensor;
     let mut temperature = TemperatureSensor;
     let mut light = AmbientLightSensor;
     let mut ninedof = unsafe { Ninedof::new() };
     loop {
-        writeln!(console, "Humidity:    {}\n", humidity.read()).unwrap();
-        writeln!(console, "Temperature: {}\n", temperature.read()).unwrap();
-        writeln!(console, "Light:       {}\n", light.read()).unwrap();
-        writeln!(console, "Accel:       {}\n", ninedof.read_acceleration()).unwrap();
-        timer::sleep(Duration::from_ms(500)).await;
+        writeln!(console, "Humidity:    {}\n", humidity.read()?)?;
+        writeln!(console, "Temperature: {}\n", temperature.read()?)?;
+        writeln!(console, "Light:       {}\n", light.read()?)?;
+        writeln!(console, "Accel:       {}\n", ninedof.read_acceleration()?)?;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/seven_segment.rs b/examples/seven_segment.rs
index 9e5752d..261c805 100644
--- a/examples/seven_segment.rs
+++ b/examples/seven_segment.rs
@@ -2,6 +2,7 @@
 
 use libtock::electronics::ShiftRegister;
 use libtock::gpio::GpioPinUnitialized;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
@@ -22,17 +23,17 @@
 }
 
 // Example works on a shift register on P0.03, P0.04, P0.28
-async fn main() {
+async fn main() -> TockResult<()> {
     let shift_register = ShiftRegister::new(
-        GpioPinUnitialized::new(0).open_for_write().unwrap(),
-        GpioPinUnitialized::new(1).open_for_write().unwrap(),
-        GpioPinUnitialized::new(2).open_for_write().unwrap(),
+        GpioPinUnitialized::new(0).open_for_write()?,
+        GpioPinUnitialized::new(1).open_for_write()?,
+        GpioPinUnitialized::new(2).open_for_write()?,
     );
 
     let mut i = 0;
     loop {
         i = (i + 1) % 11;
-        shift_register.write_bits(&number_to_bits(i));
-        timer::sleep(Duration::from_ms(200)).await;
+        shift_register.write_bits(&number_to_bits(i))?;
+        timer::sleep(Duration::from_ms(200)).await?;
     }
 }
diff --git a/examples/simple_ble.rs b/examples/simple_ble.rs
index 8623f9a..364648c 100644
--- a/examples/simple_ble.rs
+++ b/examples/simple_ble.rs
@@ -3,6 +3,7 @@
 use libtock::ble_composer;
 use libtock::ble_composer::BlePayload;
 use libtock::led;
+use libtock::result::TockResult;
 use libtock::simple_ble::BleAdvertisingDriver;
 use libtock::timer;
 use libtock::timer::Duration;
@@ -14,7 +15,7 @@
     pub st: bool,
 }
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let led = led::get(0).unwrap();
 
     let uuid: [u8; 2] = [0x00, 0x18];
@@ -39,12 +40,12 @@
         .unwrap();
     gap_payload.add_service_payload([91, 79], &payload).unwrap();
 
-    let _handle = BleAdvertisingDriver::initialize(100, &gap_payload, &mut buffer).unwrap();
+    let _handle = BleAdvertisingDriver::initialize(100, &gap_payload, &mut buffer);
 
     loop {
-        led.on();
-        timer::sleep(Duration::from_ms(500)).await;
-        led.off();
-        timer::sleep(Duration::from_ms(500)).await;
+        led.on()?;
+        timer::sleep(Duration::from_ms(500)).await?;
+        led.off()?;
+        timer::sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/temperature.rs b/examples/temperature.rs
index 5d7fd7f..7d4b94f 100644
--- a/examples/temperature.rs
+++ b/examples/temperature.rs
@@ -2,10 +2,11 @@
 
 use core::fmt::Write;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::temperature;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
-    let temperature = temperature::measure_temperature().await;
-    writeln!(console, "Temperature: {}", temperature).unwrap();
+    let temperature = temperature::measure_temperature().await?;
+    writeln!(console, "Temperature: {}", temperature).map_err(Into::into)
 }
diff --git a/examples/timer_subscribe.rs b/examples/timer_subscribe.rs
index 9032d13..0e18e8d 100644
--- a/examples/timer_subscribe.rs
+++ b/examples/timer_subscribe.rs
@@ -3,10 +3,11 @@
 use core::fmt::Write;
 use futures::future;
 use libtock::console::Console;
+use libtock::result::TockResult;
 use libtock::timer;
 use libtock::timer::Duration;
 
-async fn main() {
+async fn main() -> TockResult<()> {
     let mut console = Console::new();
 
     let mut with_callback = timer::with_callback(|_, _| {
@@ -17,8 +18,8 @@
         .unwrap();
     });
 
-    let mut timer = with_callback.init().unwrap();
-    timer.set_alarm(Duration::from_ms(2000)).unwrap();
+    let mut timer = with_callback.init()?;
+    timer.set_alarm(Duration::from_ms(2000))?;
 
     future::pending().await
 }
diff --git a/src/adc.rs b/src/adc.rs
index f1cbfce..e01b6ca 100644
--- a/src/adc.rs
+++ b/src/adc.rs
@@ -1,4 +1,5 @@
 use crate::callback::{CallbackSubscription, SubscribableCallback};
+use crate::result::TockResult;
 use crate::shared_memory::SharedMemory;
 use crate::syscalls;
 
@@ -60,28 +61,22 @@
 where
     Self: SubscribableCallback,
 {
-    pub fn init(&mut self) -> Result<Adc, isize> {
-        let return_value = syscalls::command(DRIVER_NUM, command::COUNT, 0, 0);
-        if return_value < 0 {
-            return Err(return_value);
-        }
-
-        syscalls::subscribe(DRIVER_NUM, subscribe::SUBSCRIBE_CALLBACK, self).map(|subscription| {
-            Adc {
-                count: return_value as usize,
-                subscription,
-            }
-        })
+    pub fn init(&mut self) -> TockResult<Adc> {
+        let adc = Adc {
+            count: syscalls::command(DRIVER_NUM, command::COUNT, 0, 0)?,
+            subscription: syscalls::subscribe(DRIVER_NUM, subscribe::SUBSCRIBE_CALLBACK, self)?,
+        };
+        Ok(adc)
     }
 }
 
 impl<'a> Adc<'a> {
-    pub fn init_buffer(buffer: &'a mut AdcBuffer) -> Result<SharedMemory, isize> {
-        syscalls::allow(DRIVER_NUM, allow::BUFFER, &mut buffer.buffer)
+    pub fn init_buffer(buffer: &'a mut AdcBuffer) -> TockResult<SharedMemory> {
+        syscalls::allow(DRIVER_NUM, allow::BUFFER, &mut buffer.buffer).map_err(Into::into)
     }
 
-    pub fn init_alt_buffer(alt_buffer: &'a mut AdcBuffer) -> Result<SharedMemory, isize> {
-        syscalls::allow(DRIVER_NUM, allow::BUFFER_ALT, &mut alt_buffer.buffer)
+    pub fn init_alt_buffer(alt_buffer: &'a mut AdcBuffer) -> TockResult<SharedMemory> {
+        syscalls::allow(DRIVER_NUM, allow::BUFFER_ALT, &mut alt_buffer.buffer).map_err(Into::into)
     }
 
     /// Return the number of available channels
@@ -90,37 +85,21 @@
     }
 
     /// Start a single sample of channel
-    pub fn sample(&self, channel: usize) -> Result<(), isize> {
-        let code = syscalls::command(DRIVER_NUM, command::START, channel, 0);
-        if code < 0 {
-            Err(code)
-        } else {
-            Ok(())
-        }
+    pub fn sample(&self, channel: usize) -> TockResult<()> {
+        syscalls::command(DRIVER_NUM, command::START, channel, 0)?;
+        Ok(())
     }
 
     /// Start continuous sampling of channel
-    pub fn sample_continuous(&self, channel: usize) -> Result<(), isize> {
-        let code = syscalls::command(DRIVER_NUM, command::START_REPEAT, channel, 0);
-        if code < 0 {
-            Err(code)
-        } else {
-            Ok(())
-        }
+    pub fn sample_continuous(&self, channel: usize) -> TockResult<()> {
+        syscalls::command(DRIVER_NUM, command::START_REPEAT, channel, 0)?;
+        Ok(())
     }
 
     /// Start continuous sampling to first buffer
-    pub fn sample_continuous_buffered(
-        &self,
-        channel: usize,
-        frequency: usize,
-    ) -> Result<(), isize> {
-        let code = syscalls::command(DRIVER_NUM, command::START_REPEAT_BUFFER, channel, frequency);
-        if code < 0 {
-            Err(code)
-        } else {
-            Ok(())
-        }
+    pub fn sample_continuous_buffered(&self, channel: usize, frequency: usize) -> TockResult<()> {
+        syscalls::command(DRIVER_NUM, command::START_REPEAT_BUFFER, channel, frequency)?;
+        Ok(())
     }
 
     /// Start continuous sampling to alternating buffer
@@ -128,33 +107,25 @@
         &self,
         channel: usize,
         frequency: usize,
-    ) -> Result<(), isize> {
-        let code = syscalls::command(
+    ) -> TockResult<()> {
+        syscalls::command(
             DRIVER_NUM,
             command::START_REPEAT_BUFFER_ALT,
             channel,
             frequency,
-        );
-        if code < 0 {
-            Err(code)
-        } else {
-            Ok(())
-        }
+        )?;
+        Ok(())
     }
 
     /// Stop any started sampling operation
-    pub fn stop(&self) -> Result<(), isize> {
-        let code = syscalls::command(DRIVER_NUM, command::STOP, 0, 0);
-        if code < 0 {
-            Err(code)
-        } else {
-            Ok(())
-        }
+    pub fn stop(&self) -> TockResult<()> {
+        syscalls::command(DRIVER_NUM, command::STOP, 0, 0)?;
+        Ok(())
     }
 }
 
 impl<'a> Drop for Adc<'a> {
     fn drop(&mut self) {
-        self.stop().unwrap();
+        let _ = self.stop();
     }
 }
diff --git a/src/buttons.rs b/src/buttons.rs
index 9857921..c360f7a 100644
--- a/src/buttons.rs
+++ b/src/buttons.rs
@@ -1,8 +1,6 @@
 use crate::callback::CallbackSubscription;
 use crate::callback::SubscribableCallback;
-use crate::result;
 use crate::result::TockResult;
-use crate::result::TockValue;
 use crate::syscalls;
 use core::marker::PhantomData;
 
@@ -37,23 +35,16 @@
 where
     Self: SubscribableCallback,
 {
-    pub fn init(&mut self) -> TockResult<Buttons, ButtonsError> {
-        let count = syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0);
-        if count < 1 {
-            return Err(TockValue::Expected(ButtonsError::NotSupported));
-        }
-
-        let subscription =
-            syscalls::subscribe(DRIVER_NUMBER, subscribe_nr::SUBSCRIBE_CALLBACK, self);
-
-        match subscription {
-            Ok(subscription) => Ok(Buttons {
-                count: count as usize,
-                subscription,
-            }),
-            Err(result::ENOMEM) => Err(TockValue::Expected(ButtonsError::SubscriptionFailed)),
-            Err(unexpected) => Err(TockValue::Unexpected(unexpected)),
-        }
+    pub fn init(&mut self) -> TockResult<Buttons> {
+        let buttons = Buttons {
+            count: syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?,
+            subscription: syscalls::subscribe(
+                DRIVER_NUMBER,
+                subscribe_nr::SUBSCRIBE_CALLBACK,
+                self,
+            )?,
+        };
+        Ok(buttons)
     }
 }
 
@@ -63,12 +54,6 @@
     subscription: CallbackSubscription<'a>,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum ButtonsError {
-    NotSupported,
-    SubscriptionFailed,
-}
-
 impl<'a> Buttons<'a> {
     pub fn iter_mut(&mut self) -> ButtonIter {
         ButtonIter {
@@ -133,34 +118,24 @@
 }
 
 impl<'a> ButtonHandle<'a> {
-    pub fn enable(&mut self) -> TockResult<Button, ButtonError> {
-        let return_code = syscalls::command(
+    pub fn enable(&mut self) -> TockResult<Button> {
+        syscalls::command(
             DRIVER_NUMBER,
             command_nr::ENABLE_INTERRUPT,
             self.button_num,
             0,
-        );
-
-        match return_code {
-            result::SUCCESS => Ok(Button { handle: self }),
-            result::ENOMEM => Err(TockValue::Expected(ButtonError::ActivationFailed)),
-            unexpected => Err(TockValue::Unexpected(unexpected)),
-        }
+        )?;
+        Ok(Button { handle: self })
     }
 
-    pub fn disable(&mut self) -> TockResult<(), ButtonError> {
-        let return_code = syscalls::command(
+    pub fn disable(&mut self) -> TockResult<()> {
+        syscalls::command(
             DRIVER_NUMBER,
             command_nr::DISABLE_INTERRUPT,
             self.button_num,
             0,
-        );
-
-        match return_code {
-            result::SUCCESS => Ok(()),
-            result::ENOMEM => Err(TockValue::Expected(ButtonError::ActivationFailed)),
-            unexpected => Err(TockValue::Unexpected(unexpected)),
-        }
+        )?;
+        Ok(())
     }
 }
 
@@ -168,18 +143,10 @@
     handle: &'a ButtonHandle<'a>,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum ButtonError {
-    ActivationFailed,
-}
-
 impl<'a> Button<'a> {
-    pub fn read(&self) -> ButtonState {
-        ButtonState::from(syscalls::command(
-            DRIVER_NUMBER,
-            command_nr::READ,
-            self.handle.button_num,
-            0,
-        ) as usize)
+    pub fn read(&self) -> TockResult<ButtonState> {
+        syscalls::command(DRIVER_NUMBER, command_nr::READ, self.handle.button_num, 0)
+            .map(ButtonState::from)
+            .map_err(Into::into)
     }
 }
diff --git a/src/console.rs b/src/console.rs
index 0011a80..3fd0361 100644
--- a/src/console.rs
+++ b/src/console.rs
@@ -1,8 +1,10 @@
 use crate::futures;
+use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
 use core::executor;
 use core::fmt;
+use core::mem;
 
 const DRIVER_NUMBER: usize = 1;
 
@@ -29,26 +31,24 @@
         }
     }
 
-    pub fn write<S: AsRef<[u8]>>(&mut self, text: S) {
+    pub fn write<S: AsRef<[u8]>>(&mut self, text: S) -> TockResult<()> {
         let mut not_written_yet = text.as_ref();
         while !not_written_yet.is_empty() {
             let num_bytes_to_print = self.allow_buffer.len().min(not_written_yet.len());
             self.allow_buffer[..num_bytes_to_print]
                 .copy_from_slice(&not_written_yet[..num_bytes_to_print]);
-            self.flush(num_bytes_to_print);
+            self.flush(num_bytes_to_print)?;
             not_written_yet = &not_written_yet[num_bytes_to_print..];
         }
+        Ok(())
     }
 
-    fn flush(&mut self, num_bytes_to_print: usize) {
-        let result = syscalls::allow(
+    fn flush(&mut self, num_bytes_to_print: usize) -> TockResult<()> {
+        let shared_memory = syscalls::allow(
             DRIVER_NUMBER,
             allow_nr::SHARE_BUFFER,
             &mut self.allow_buffer[..num_bytes_to_print],
-        );
-        if result.is_err() {
-            return;
-        }
+        )?;
 
         let is_written = Cell::new(false);
         let mut is_written_alarm = |_, _, _| is_written.set(true);
@@ -56,24 +56,21 @@
             DRIVER_NUMBER,
             subscribe_nr::SET_ALARM,
             &mut is_written_alarm,
-        );
-        if subscription.is_err() {
-            return;
-        }
+        )?;
 
-        let result_code =
-            syscalls::command(DRIVER_NUMBER, command_nr::WRITE, num_bytes_to_print, 0);
-        if result_code < 0 {
-            return;
-        }
+        syscalls::command(DRIVER_NUMBER, command_nr::WRITE, num_bytes_to_print, 0)?;
 
         unsafe { executor::block_on(futures::wait_until(|| is_written.get())) };
+
+        mem::drop(subscription);
+        mem::drop(shared_memory);
+
+        Ok(())
     }
 }
 
 impl fmt::Write for Console {
     fn write_str(&mut self, string: &str) -> Result<(), fmt::Error> {
-        self.write(string);
-        Ok(())
+        self.write(string).map_err(|_| fmt::Error)
     }
 }
diff --git a/src/debug/low_level_debug.rs b/src/debug/low_level_debug.rs
index b059fcc..ffb22e7 100644
--- a/src/debug/low_level_debug.rs
+++ b/src/debug/low_level_debug.rs
@@ -16,19 +16,19 @@
 /// code. If the capsule is not present, this is a no-op.
 #[inline(always)] // Improve reliability for relocation issues
 pub fn low_level_status_code(code: usize) {
-    syscalls::command1_insecure(DRIVER_NUMBER, command_nr::ALERT_CODE, code);
+    let _ = syscalls::command1_insecure(DRIVER_NUMBER, command_nr::ALERT_CODE, code);
 }
 
 /// Use the LowLevelDebug capsule (if present) to print a single number. If the
 /// capsule is not present, this is a no-op.
 #[inline(always)] // Improve reliability for relocation issues
 pub fn low_level_print1(value: usize) {
-    syscalls::command1_insecure(DRIVER_NUMBER, command_nr::PRINT1, value);
+    let _ = syscalls::command1_insecure(DRIVER_NUMBER, command_nr::PRINT1, value);
 }
 
 /// Use the LowLevelDebug capsule (if present) to print two numbers. If the
 /// capsule is not present, this is a no-op.
 #[inline(always)] // Improve reliability for relocation issues
 pub fn low_level_print2(value1: usize, value2: usize) {
-    syscalls::command(DRIVER_NUMBER, command_nr::PRINT2, value1, value2);
+    let _ = syscalls::command(DRIVER_NUMBER, command_nr::PRINT2, value1, value2);
 }
diff --git a/src/debug/mod.rs b/src/debug/mod.rs
index b05cf39..a64b664 100644
--- a/src/debug/mod.rs
+++ b/src/debug/mod.rs
@@ -7,13 +7,13 @@
 
 pub fn println() {
     let buffer = [b'\n'];
-    Console::new().write(&buffer);
+    let _ = Console::new().write(&buffer);
 }
 
 pub fn print_as_hex(value: usize) {
     let mut buffer = [b'\n'; 11];
     write_as_hex(&mut buffer, value);
-    Console::new().write(buffer);
+    let _ = Console::new().write(buffer);
 }
 
 #[cfg(target_arch = "arm")]
@@ -24,7 +24,7 @@
     let mut buffer = [b'\n'; 15];
     buffer[0..4].clone_from_slice(b"SP: ");
     write_as_hex(&mut buffer[4..15], stack_pointer);
-    Console::new().write(buffer);
+    let _ = Console::new().write(buffer);
 }
 
 #[cfg(target_arch = "riscv32")]
@@ -44,7 +44,7 @@
         }
     }
     buffer[27] = b'\n';
-    Console::new().write(&buffer);
+    let _ = Console::new().write(&buffer);
 }
 
 pub fn dump_memory(start_address: *const usize, count: isize) {
diff --git a/src/electronics/shift_register.rs b/src/electronics/shift_register.rs
index 9f4c664..f170225 100644
--- a/src/electronics/shift_register.rs
+++ b/src/electronics/shift_register.rs
@@ -1,4 +1,5 @@
 use crate::gpio::GpioPinWrite;
+use crate::result::TockResult;
 
 pub struct ShiftRegister {
     data_pin: GpioPinWrite,
@@ -19,25 +20,25 @@
         }
     }
 
-    pub fn write_bits(&self, values: &[bool]) {
+    pub fn write_bits(&self, values: &[bool]) -> TockResult<()> {
         for i in values {
-            self.push_bit(*i);
+            self.push_bit(*i)?;
         }
-        self.display();
+        self.display()
     }
 
-    fn push_bit(&self, value: bool) {
+    fn push_bit(&self, value: bool) -> TockResult<()> {
         if value {
-            self.data_pin.set_high();
+            self.data_pin.set_high()
         } else {
-            self.data_pin.set_low();
-        }
-        self.clock_pin.set_high();
-        self.clock_pin.set_low();
+            self.data_pin.set_low()
+        }?;
+        self.clock_pin.set_high()?;
+        self.clock_pin.set_low()
     }
 
-    fn display(&self) {
-        self.latch_pin.set_high();
-        self.latch_pin.set_low();
+    fn display(&self) -> TockResult<()> {
+        self.latch_pin.set_high()?;
+        self.latch_pin.set_low()
     }
 }
diff --git a/src/gpio.rs b/src/gpio.rs
index 7342f9b..d416632 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -1,3 +1,4 @@
+use crate::result::TockResult;
 use crate::syscalls;
 
 const DRIVER_NUMBER: usize = 0x00004;
@@ -63,20 +64,18 @@
         GpioPinUnitialized { number }
     }
 
-    pub fn open_for_write(self) -> Result<GpioPinWrite, &'static str> {
-        match syscalls::command(DRIVER_NUMBER, gpio_commands::ENABLE_OUTPUT, self.number, 0) {
-            0 => Ok(GpioPinWrite {
-                number: self.number,
-            }),
-            _ => Err("Could not open pin for writing."),
-        }
+    pub fn open_for_write(self) -> TockResult<GpioPinWrite> {
+        syscalls::command(DRIVER_NUMBER, gpio_commands::ENABLE_OUTPUT, self.number, 0)?;
+        Ok(GpioPinWrite {
+            number: self.number,
+        })
     }
 
     pub fn open_for_read(
         self,
         callback: Option<(extern "C" fn(usize, usize, usize, usize), IrqMode)>,
         input_mode: InputMode,
-    ) -> Result<GpioPinRead, &'static str> {
+    ) -> TockResult<GpioPinRead> {
         let (callback, irq_mode) = callback.unwrap_or((noop_callback, IrqMode::EitherEdge));
         self.enable_input(input_mode)
             .and_then(|pin| pin.subscribe_callback(callback))
@@ -86,84 +85,75 @@
     fn subscribe_callback(
         self,
         callback: extern "C" fn(usize, usize, usize, usize),
-    ) -> Result<GpioPinUnitialized, &'static str> {
-        if syscalls::subscribe_fn(
+    ) -> TockResult<GpioPinUnitialized> {
+        syscalls::subscribe_fn(
             DRIVER_NUMBER,
             gpio_commands::SUBSCRIBE_CALLBACK,
             callback,
-            self.number as usize,
-        ) == 0
-        {
-            Ok(self)
-        } else {
-            Err("Could not subscribe callback.")
-        }
+            self.number,
+        )?;
+        Ok(self)
     }
 
-    fn enable_input(self, mode: InputMode) -> Result<GpioPinUnitialized, &'static str> {
-        if syscalls::command(
+    fn enable_input(self, mode: InputMode) -> TockResult<GpioPinUnitialized> {
+        syscalls::command(
             DRIVER_NUMBER,
             gpio_commands::ENABLE_INPUT,
             self.number,
             mode.to_num(),
-        ) == 0
-        {
-            Ok(self)
-        } else {
-            Err("Could not enable input.")
-        }
+        )?;
+        Ok(self)
     }
 
-    fn enable_callback(self, irq_mode: IrqMode) -> Result<GpioPinRead, &'static str> {
-        if syscalls::command(
+    fn enable_callback(self, irq_mode: IrqMode) -> TockResult<GpioPinRead> {
+        syscalls::command(
             DRIVER_NUMBER,
             gpio_commands::ENABLE_INTERRUPT,
             self.number,
             irq_mode.to_num(),
-        ) == 0
-        {
-            Ok(GpioPinRead {
-                number: self.number,
-            })
-        } else {
-            Err("Could not enable callback.")
-        }
+        )?;
+        Ok(GpioPinRead {
+            number: self.number,
+        })
     }
 }
 
 impl GpioPinWrite {
-    pub fn set_low(&self) {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_LOW, self.number, 0);
+    pub fn set_low(&self) -> TockResult<()> {
+        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_LOW, self.number, 0)?;
+        Ok(())
     }
-    pub fn set_high(&self) {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_HIGH, self.number, 0);
+    pub fn set_high(&self) -> TockResult<()> {
+        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_HIGH, self.number, 0)?;
+        Ok(())
     }
-    pub fn toggle(&self) {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::TOGGLE, self.number, 0);
+    pub fn toggle(&self) -> TockResult<()> {
+        syscalls::command(DRIVER_NUMBER, gpio_commands::TOGGLE, self.number, 0)?;
+        Ok(())
     }
 }
 
 impl GpioPinRead {
     pub fn read(&self) -> bool {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::READ, self.number, 0) == 1
+        syscalls::command(DRIVER_NUMBER, gpio_commands::READ, self.number, 0).ok() == Some(1)
     }
 }
 
 impl Drop for GpioPinWrite {
     fn drop(&mut self) {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
+        let _ = syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
     }
 }
 
 impl Drop for GpioPinRead {
     fn drop(&mut self) {
-        syscalls::command(
+        let _ = syscalls::command(
             DRIVER_NUMBER,
             gpio_commands::DISABLE_INTERRUPT,
             self.number,
             0,
         );
-        syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
+        let _ = syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
     }
 }
 
diff --git a/src/lang_items.rs b/src/lang_items.rs
index 0874a32..292d1ac 100644
--- a/src/lang_items.rs
+++ b/src/lang_items.rs
@@ -19,6 +19,7 @@
 //! crate.
 
 use crate::led;
+use crate::result::TockError;
 use crate::timer;
 use crate::timer::Duration;
 use core::alloc::Layout;
@@ -41,10 +42,10 @@
 
 impl<T> Termination for T
 where
-    T: Future<Output = ()>,
+    T: Future<Output = Result<(), TockError>>,
 {
     fn report(self) -> i32 {
-        unsafe { executor::block_on(self) };
+        let _ = unsafe { executor::block_on(self) };
         0
     }
 }
@@ -58,13 +59,13 @@
     executor::block_on(async {
         loop {
             for led in led::all() {
-                led.on();
+                let _ = led.on();
             }
-            timer::sleep(Duration::from_ms(100)).await;
+            let _ = timer::sleep(Duration::from_ms(100)).await;
             for led in led::all() {
-                led.off();
+                let _ = led.off();
             }
-            timer::sleep(Duration::from_ms(100)).await;
+            let _ = timer::sleep(Duration::from_ms(100)).await;
         }
     });
     // Never type is not supported for T in Future
@@ -76,9 +77,9 @@
     executor::block_on(async {
         loop {
             for led in led::all() {
-                led.on();
-                timer::sleep(Duration::from_ms(100)).await;
-                led.off();
+                let _ = led.on();
+                let _ = timer::sleep(Duration::from_ms(100)).await;
+                let _ = led.off();
             }
         }
     });
diff --git a/src/led.rs b/src/led.rs
index 2e24bb0..bd81078 100644
--- a/src/led.rs
+++ b/src/led.rs
@@ -1,3 +1,4 @@
+use crate::result::TockResult;
 use crate::syscalls::command;
 
 const DRIVER_NUMBER: usize = 0x00002;
@@ -13,15 +14,13 @@
     led_num: usize,
 }
 
-pub fn count() -> isize {
-    command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)
+pub fn count() -> TockResult<usize> {
+    command(DRIVER_NUMBER, command_nr::COUNT, 0, 0).map_err(Into::into)
 }
 
-pub fn get(led_num: isize) -> Option<Led> {
-    if led_num >= 0 && led_num < count() {
-        Some(Led {
-            led_num: led_num as usize,
-        })
+pub fn get(led_num: usize) -> Option<Led> {
+    if led_num < count().ok().unwrap() {
+        Some(Led { led_num })
     } else {
         None
     }
@@ -30,12 +29,12 @@
 pub fn all() -> LedIter {
     LedIter {
         curr_led: 0,
-        led_count: count() as usize,
+        led_count: count().ok().unwrap(),
     }
 }
 
 impl Led {
-    pub fn set_state(&self, state: bool) {
+    pub fn set_state(&self, state: bool) -> TockResult<()> {
         if state {
             self.on()
         } else {
@@ -43,16 +42,19 @@
         }
     }
 
-    pub fn on(&self) {
-        command(DRIVER_NUMBER, command_nr::ON, self.led_num, 0);
+    pub fn on(&self) -> TockResult<()> {
+        command(DRIVER_NUMBER, command_nr::ON, self.led_num, 0)?;
+        Ok(())
     }
 
-    pub fn off(&self) {
-        command(DRIVER_NUMBER, command_nr::OFF, self.led_num, 0);
+    pub fn off(&self) -> TockResult<()> {
+        command(DRIVER_NUMBER, command_nr::OFF, self.led_num, 0)?;
+        Ok(())
     }
 
-    pub fn toggle(&self) {
-        command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0);
+    pub fn toggle(&self) -> TockResult<()> {
+        command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0)?;
+        Ok(())
     }
 }
 
diff --git a/src/result.rs b/src/result.rs
index e00f3f0..a7f40e1 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,43 +1,72 @@
+use core::fmt;
+
+pub type TockResult<T> = Result<T, TockError>;
+
 #[derive(Copy, Clone)]
-pub enum TockValue<E> {
-    Expected(E),
-    Unexpected(isize),
+pub enum TockError {
+    Subscribe(SubscribeError),
+    Command(CommandError),
+    Allow(AllowError),
+    Format,
+    Other(OtherError),
 }
 
-// Size-optimized implementation of Debug.
-impl<E: core::fmt::Debug> core::fmt::Debug for TockValue<E> {
-    fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
-        match self {
-            // Printing out the value of E would cause TockResult::unwrap() to
-            // use a &dyn core::fmt::Debug, which defeats LLVM's
-            // devirtualization and prevents LTO from removing unused Debug
-            // implementations. Unfortunately, that generates too much code
-            // bloat (several kB), so we cannot display the value contained in
-            // this TockValue.
-            TockValue::Expected(_) => f.write_str("Expected(...)"),
+#[derive(Copy, Clone)]
+pub struct SubscribeError {
+    pub driver_number: usize,
+    pub subscribe_number: usize,
+    pub return_code: isize,
+}
 
-            TockValue::Unexpected(n) => {
-                f.write_str("Unexpected(")?;
-                n.fmt(f)?;
-                f.write_str(")")
-            }
-        }
+impl From<SubscribeError> for TockError {
+    fn from(subscribe_error: SubscribeError) -> Self {
+        TockError::Subscribe(subscribe_error)
     }
 }
 
-pub type TockResult<T, E> = Result<T, TockValue<E>>;
-
-pub trait TockResultExt<T, E>: Sized {
-    fn as_expected(self) -> Result<T, E>;
+#[derive(Copy, Clone)]
+pub struct CommandError {
+    pub driver_number: usize,
+    pub command_number: usize,
+    pub arg1: usize,
+    pub arg2: usize,
+    pub return_code: isize,
 }
 
-impl<T, E> TockResultExt<T, E> for TockResult<T, E> {
-    fn as_expected(self) -> Result<T, E> {
-        match self {
-            Ok(ok) => Ok(ok),
-            Err(TockValue::Expected(err)) => Err(err),
-            Err(TockValue::Unexpected(_)) => panic!("Unexpected error"),
-        }
+impl From<CommandError> for TockError {
+    fn from(command_error: CommandError) -> Self {
+        TockError::Command(command_error)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct AllowError {
+    pub driver_number: usize,
+    pub allow_number: usize,
+    pub return_code: isize,
+}
+
+impl From<AllowError> for TockError {
+    fn from(allow_error: AllowError) -> Self {
+        TockError::Allow(allow_error)
+    }
+}
+
+impl From<fmt::Error> for TockError {
+    fn from(fmt::Error: fmt::Error) -> Self {
+        TockError::Format
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum OtherError {
+    TimerDriverDurationOutOfRange,
+    TimerDriverErroneousClockFrequency,
+}
+
+impl From<OtherError> for TockError {
+    fn from(other: OtherError) -> Self {
+        TockError::Other(other)
     }
 }
 
diff --git a/src/rng.rs b/src/rng.rs
index 4008d29..2134fb2 100644
--- a/src/rng.rs
+++ b/src/rng.rs
@@ -1,6 +1,8 @@
 use crate::futures;
+use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
+use core::mem;
 
 const DRIVER_NUMBER: usize = 0x40001;
 
@@ -16,13 +18,10 @@
     pub const SHARE_BUFFER: usize = 0;
 }
 
-pub async fn fill_buffer(buf: &mut [u8]) -> bool {
+pub async fn fill_buffer(buf: &mut [u8]) -> TockResult<()> {
     let buf_len = buf.len();
 
-    let result = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf);
-    if result.is_err() {
-        return false;
-    }
+    let shared_memory = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf)?;
 
     let is_filled = Cell::new(false);
     let mut is_filled_alarm = |_, _, _| is_filled.set(true);
@@ -30,16 +29,14 @@
         DRIVER_NUMBER,
         subscribe_nr::BUFFER_FILLED,
         &mut is_filled_alarm,
-    );
-    if subscription.is_err() {
-        return false;
-    }
+    )?;
 
-    let result_code = syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0);
-    if result_code < 0 {
-        return false;
-    }
+    syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0)?;
 
     futures::wait_until(|| is_filled.get()).await;
-    true
+
+    mem::drop(subscription);
+    mem::drop(shared_memory);
+
+    Ok(())
 }
diff --git a/src/sensors/mod.rs b/src/sensors/mod.rs
index bb2b6cd..af7e00f 100644
--- a/src/sensors/mod.rs
+++ b/src/sensors/mod.rs
@@ -1,4 +1,5 @@
 use crate::futures;
+use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
 use core::convert::From;
@@ -21,15 +22,14 @@
 pub trait Sensor<Reading: Copy + From<(usize, usize, usize)>> {
     fn driver_num(&self) -> usize;
 
-    fn read(&mut self) -> Reading {
+    fn read(&mut self) -> TockResult<Reading> {
         let res: Cell<Option<Reading>> = Cell::new(None);
         let driver_num = self.driver_num();
         syscalls::subscribe_fn(driver_num, 0, cb::<Reading>, unsafe {
             mem::transmute(&res)
-        });
-        syscalls::command(driver_num, 1, 0, 0);
-        unsafe { executor::block_on(futures::wait_until(|| res.get().is_some())) };
-        res.get().unwrap()
+        })?;
+        syscalls::command(driver_num, 1, 0, 0)?;
+        Ok(unsafe { executor::block_on(futures::wait_for_value(|| res.get())) })
     }
 }
 
diff --git a/src/sensors/ninedof.rs b/src/sensors/ninedof.rs
index f422ac1..7da0dda 100644
--- a/src/sensors/ninedof.rs
+++ b/src/sensors/ninedof.rs
@@ -1,4 +1,5 @@
 use crate::futures;
+use crate::result::TockResult;
 use crate::syscalls;
 use core::cell::Cell;
 use core::executor;
@@ -33,20 +34,20 @@
         Ninedof
     }
 
-    pub fn read_acceleration(&mut self) -> NinedofReading {
+    pub fn read_acceleration(&mut self) -> TockResult<NinedofReading> {
         let res: CbData = Default::default();
-        subscribe(Self::cb, unsafe { mem::transmute(&res) });
-        start_accel_reading();
+        subscribe(Self::cb, unsafe { mem::transmute(&res) })?;
+        start_accel_reading()?;
         unsafe { executor::block_on(futures::wait_until(|| res.ready.get())) };
-        res.res.get()
+        Ok(res.res.get())
     }
 
-    pub fn read_magnetometer(&mut self) -> NinedofReading {
+    pub fn read_magnetometer(&mut self) -> TockResult<NinedofReading> {
         let res: CbData = Default::default();
-        subscribe(Self::cb, unsafe { mem::transmute(&res) });
-        start_magnetometer_reading();
+        subscribe(Self::cb, unsafe { mem::transmute(&res) })?;
+        start_magnetometer_reading()?;
         unsafe { executor::block_on(futures::wait_until(|| res.ready.get())) };
-        res.res.get()
+        Ok(res.res.get())
     }
 
     extern "C" fn cb(x: usize, y: usize, z: usize, ptr: usize) {
@@ -60,14 +61,17 @@
     }
 }
 
-pub fn subscribe(cb: extern "C" fn(usize, usize, usize, usize), ud: usize) {
-    syscalls::subscribe_fn(DRIVER_NUM, 0, cb, ud);
+pub fn subscribe(cb: extern "C" fn(usize, usize, usize, usize), ud: usize) -> TockResult<()> {
+    syscalls::subscribe_fn(DRIVER_NUM, 0, cb, ud)?;
+    Ok(())
 }
 
-pub fn start_accel_reading() {
-    syscalls::command(DRIVER_NUM, 1, 0, 0);
+pub fn start_accel_reading() -> TockResult<()> {
+    syscalls::command(DRIVER_NUM, 1, 0, 0)?;
+    Ok(())
 }
 
-pub fn start_magnetometer_reading() {
-    syscalls::command(DRIVER_NUM, 100, 0, 0);
+pub fn start_magnetometer_reading() -> TockResult<()> {
+    syscalls::command(DRIVER_NUM, 100, 0, 0)?;
+    Ok(())
 }
diff --git a/src/simple_ble.rs b/src/simple_ble.rs
index b80ce39..113de2d 100644
--- a/src/simple_ble.rs
+++ b/src/simple_ble.rs
@@ -1,7 +1,7 @@
 use crate::ble_composer::BlePayload;
 use crate::callback::CallbackSubscription;
 use crate::callback::SubscribableCallback;
-use crate::result;
+use crate::result::TockResult;
 use crate::shared_memory::SharedMemory;
 use crate::syscalls;
 
@@ -39,7 +39,7 @@
         interval: usize,
         service_payload: &BlePayload,
         advertising_buffer: &'a mut [u8; BUFFER_SIZE_ADVERTISE],
-    ) -> Result<SharedMemory<'a>, isize> {
+    ) -> TockResult<SharedMemory<'a>> {
         let mut shared_memory = syscalls::allow(
             DRIVER_NUMBER,
             ble_commands::ALLOW_ADVERTISMENT_BUFFER,
@@ -50,14 +50,14 @@
         Ok(shared_memory)
     }
 
-    fn start_advertising(pdu_type: usize, interval: usize) -> Result<(), isize> {
-        let result = syscalls::command(
+    fn start_advertising(pdu_type: usize, interval: usize) -> TockResult<()> {
+        syscalls::command(
             DRIVER_NUMBER,
             ble_commands::START_ADVERTISING,
             pdu_type,
             interval,
-        );
-        convert_result(result)
+        )?;
+        Ok(())
     }
 }
 
@@ -84,26 +84,18 @@
         [0; BUFFER_SIZE_SCAN]
     }
 
-    pub fn share_memory(scan_buffer: &mut [u8; BUFFER_SIZE_SCAN]) -> Result<SharedMemory, isize> {
+    pub fn share_memory(scan_buffer: &mut [u8; BUFFER_SIZE_SCAN]) -> TockResult<SharedMemory> {
         syscalls::allow(DRIVER_NUMBER, ble_commands::ALLOW_SCAN_BUFFER, scan_buffer)
+            .map_err(Into::into)
     }
 
-    pub fn start<CB>(callback: &mut BleCallback<CB>) -> Result<CallbackSubscription, isize>
+    pub fn start<CB>(callback: &mut BleCallback<CB>) -> TockResult<CallbackSubscription>
     where
         BleCallback<CB>: SubscribableCallback,
     {
         let subscription =
             syscalls::subscribe(DRIVER_NUMBER, ble_commands::BLE_PASSIVE_SCAN_SUB, callback)?;
-
-        let result = syscalls::command(DRIVER_NUMBER, ble_commands::PASSIVE_SCAN, 1, 0);
-        convert_result(result)?;
+        syscalls::command(DRIVER_NUMBER, ble_commands::PASSIVE_SCAN, 1, 0)?;
         Ok(subscription)
     }
 }
-
-fn convert_result(code: isize) -> Result<(), isize> {
-    match code {
-        result::SUCCESS => Ok(()),
-        code => Err(code),
-    }
-}
diff --git a/src/syscalls/mod.rs b/src/syscalls/mod.rs
index 93b91ea..4cbef0f 100644
--- a/src/syscalls/mod.rs
+++ b/src/syscalls/mod.rs
@@ -8,6 +8,9 @@
 
 use crate::callback::CallbackSubscription;
 use crate::callback::SubscribableCallback;
+use crate::result::AllowError;
+use crate::result::CommandError;
+use crate::result::SubscribeError;
 use crate::shared_memory::SharedMemory;
 
 pub mod raw {
@@ -34,7 +37,7 @@
     driver_number: usize,
     subscribe_number: usize,
     callback: &mut CB,
-) -> Result<CallbackSubscription, isize> {
+) -> Result<CallbackSubscription, SubscribeError> {
     extern "C" fn c_callback<CB: SubscribableCallback>(
         arg1: usize,
         arg2: usize,
@@ -45,20 +48,13 @@
         callback.call_rust(arg1, arg2, arg3);
     }
 
-    let return_code = {
-        subscribe_fn(
-            driver_number,
-            subscribe_number,
-            c_callback::<CB>,
-            callback as *mut CB as usize,
-        )
-    };
-
-    if return_code == 0 {
-        Ok(CallbackSubscription::new(driver_number, subscribe_number))
-    } else {
-        Err(return_code)
-    }
+    subscribe_fn(
+        driver_number,
+        subscribe_number,
+        c_callback::<CB>,
+        callback as *mut CB as usize,
+    )
+    .map(|_| CallbackSubscription::new(driver_number, subscribe_number))
 }
 
 pub fn subscribe_fn(
@@ -66,41 +62,81 @@
     subscribe_number: usize,
     callback: extern "C" fn(usize, usize, usize, usize),
     userdata: usize,
-) -> isize {
-    unsafe {
+) -> Result<(), SubscribeError> {
+    let return_code = unsafe {
         raw::subscribe(
             driver_number,
             subscribe_number,
             callback as *const _,
             userdata,
         )
+    };
+
+    if return_code == 0 {
+        Ok(())
+    } else {
+        Err(SubscribeError {
+            driver_number,
+            subscribe_number,
+            return_code,
+        })
     }
 }
 
-pub fn command(driver_number: usize, command_number: usize, arg1: usize, arg2: usize) -> isize {
-    unsafe { raw::command(driver_number, command_number, arg1, arg2) }
+pub fn command(
+    driver_number: usize,
+    command_number: usize,
+    arg1: usize,
+    arg2: usize,
+) -> Result<usize, CommandError> {
+    let return_code = unsafe { raw::command(driver_number, command_number, arg1, arg2) };
+    if return_code >= 0 {
+        Ok(return_code as usize)
+    } else {
+        Err(CommandError {
+            driver_number,
+            command_number,
+            arg1,
+            arg2,
+            return_code,
+        })
+    }
 }
 
-// command1_insecure, is a variant of command() that only sets the first
-// argument in the system call interface. It has the benefit of generating
-// simpler assembly than command(), but it leaves the second argument's register
-// as-is which leaks it to the kernel driver being called. Prefer to use
-// command() instead of command1_insecure(), unless the benefit of generating
-// simpler assembly outweighs the drawbacks of potentially leaking arbitrary
-// information to the driver you are calling.
-//
-// At the moment, the only suitable use case for command1_insecure is the low
-// level debug interface.
-
-pub fn command1_insecure(driver_number: usize, command_number: usize, arg: usize) -> isize {
-    unsafe { raw::command1(driver_number, command_number, arg) }
+/// [command1_insecure()] is a variant of [command()] that only sets the first
+/// argument in the system call interface. It has the benefit of generating
+/// simpler assembly than [command()], but it leaves the second argument's register
+/// as-is which leaks it to the kernel driver being called. Prefer to use
+/// [command()] instead of [command1_insecure()], unless the benefit of generating
+/// simpler assembly outweighs the drawbacks of potentially leaking arbitrary
+/// information to the driver you are calling.
+///
+/// At the moment, the only suitable use case for [command1_insecure()] is the low
+/// level debug interface.
+pub fn command1_insecure(
+    driver_number: usize,
+    command_number: usize,
+    arg: usize,
+) -> Result<usize, CommandError> {
+    let return_code = unsafe { raw::command1(driver_number, command_number, arg) };
+    if return_code >= 0 {
+        Ok(return_code as usize)
+    } else {
+        Err(CommandError {
+            driver_number,
+            command_number,
+            arg1: arg,
+            arg2: 0,
+            return_code,
+        })
+    }
 }
 
 pub fn allow(
     driver_number: usize,
     allow_number: usize,
     buffer_to_share: &mut [u8],
-) -> Result<SharedMemory, isize> {
+) -> Result<SharedMemory, AllowError> {
     let len = buffer_to_share.len();
     let return_code = unsafe {
         raw::allow(
@@ -117,6 +153,10 @@
             buffer_to_share,
         ))
     } else {
-        Err(return_code)
+        Err(AllowError {
+            driver_number,
+            allow_number,
+            return_code,
+        })
     }
 }
diff --git a/src/temperature.rs b/src/temperature.rs
index 53a5dba..e50cbe2 100644
--- a/src/temperature.rs
+++ b/src/temperature.rs
@@ -1,42 +1,70 @@
-use crate::callback::CallbackSubscription;
-use crate::callback::SubscribableCallback;
 use crate::futures;
+use crate::result::TockError;
 use crate::syscalls;
 use core::cell::Cell;
+use core::fmt;
+use core::fmt::Display;
+use core::mem;
 
 const DRIVER_NUMBER: usize = 0x60000;
 const SUBSCRIBE_CALLBACK: usize = 0;
 const START_MEASUREMENT: usize = 1;
 
-fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
-    WithCallback { callback }
-}
-
-struct WithCallback<CB> {
-    callback: CB,
-}
-
-impl<CB: FnMut(isize)> SubscribableCallback for WithCallback<CB> {
-    fn call_rust(&mut self, arg0: usize, _: usize, _: usize) {
-        (self.callback)(arg0 as isize);
-    }
-}
-
-impl<CB> WithCallback<CB>
-where
-    Self: SubscribableCallback,
-{
-    fn start_measurement(&mut self) -> Result<CallbackSubscription, isize> {
-        let subscription = syscalls::subscribe(DRIVER_NUMBER, SUBSCRIBE_CALLBACK, self)?;
-        syscalls::command(DRIVER_NUMBER, START_MEASUREMENT, 0, 0);
-        Ok(subscription)
-    }
-}
-
-pub async fn measure_temperature() -> isize {
+pub async fn measure_temperature() -> Result<Temperature, TockError> {
     let temperature = Cell::<Option<isize>>::new(None);
-    let mut callback = |temp: isize| temperature.set(Some(temp));
-    let mut withcallback = with_callback(&mut callback);
-    let _subscription = withcallback.start_measurement();
-    futures::wait_for_value(|| temperature.get()).await
+    let mut callback = |arg1, _, _| temperature.set(Some(arg1 as isize));
+    let subscription = syscalls::subscribe(DRIVER_NUMBER, SUBSCRIBE_CALLBACK, &mut callback)?;
+    syscalls::command(DRIVER_NUMBER, START_MEASUREMENT, 0, 0)?;
+    let temperatur = Temperature {
+        centi_celsius: futures::wait_for_value(|| temperature.get()).await,
+    };
+    mem::drop(subscription);
+    Ok(temperatur)
+}
+
+#[derive(Copy, Clone)]
+pub struct Temperature {
+    centi_celsius: isize,
+}
+
+impl Temperature {
+    pub fn in_celsius(self) -> isize {
+        self.centi_celsius / 100
+    }
+
+    pub fn in_centi_celsius(self) -> isize {
+        self.centi_celsius
+    }
+}
+
+impl Display for Temperature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}.{:02}°C",
+            self.centi_celsius / 100,
+            self.centi_celsius.abs() % 100
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use alloc::string::String;
+    use alloc::string::ToString;
+
+    #[test]
+    fn render_temperature() {
+        assert_eq!(render_temperature_for(0), "0.00°C");
+        assert_eq!(render_temperature_for(5), "0.05°C");
+        assert_eq!(render_temperature_for(105), "1.05°C");
+        assert_eq!(render_temperature_for(125), "1.25°C");
+        assert_eq!(render_temperature_for(1025), "10.25°C");
+        assert_eq!(render_temperature_for(-1025), "-10.25°C");
+    }
+
+    fn render_temperature_for(centi_celsius: isize) -> String {
+        Temperature { centi_celsius }.to_string()
+    }
 }
diff --git a/src/timer.rs b/src/timer.rs
index e59b351..08c6fa6 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -1,9 +1,8 @@
 use crate::callback::CallbackSubscription;
 use crate::callback::SubscribableCallback;
 use crate::futures;
-use crate::result;
+use crate::result::OtherError;
 use crate::result::TockResult;
-use crate::result::TockValue;
 use crate::syscalls;
 use core::cell::Cell;
 use core::isize;
@@ -23,14 +22,15 @@
     pub const SUBSCRIBE_CALLBACK: usize = 0;
 }
 
-pub async fn sleep(duration: Duration<isize>) {
+pub async fn sleep(duration: Duration<isize>) -> TockResult<()> {
     let expired = Cell::new(false);
     let mut with_callback = with_callback(|_, _| expired.set(true));
 
-    let mut timer = with_callback.init().unwrap();
-    timer.set_alarm(duration).unwrap();
+    let mut timer = with_callback.init()?;
+    timer.set_alarm(duration)?;
 
     futures::wait_until(|| expired.get()).await;
+    Ok(())
 }
 
 pub fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
@@ -61,40 +61,29 @@
 where
     Self: SubscribableCallback,
 {
-    pub fn init(&mut self) -> TockResult<Timer, TimerError> {
+    pub fn init(&mut self) -> TockResult<Timer> {
         let num_notifications =
-            syscalls::command(DRIVER_NUMBER, command_nr::IS_DRIVER_AVAILABLE, 0, 0);
-
-        if num_notifications < 1 {
-            return Err(TockValue::Expected(TimerError::NotSupported));
-        }
+            syscalls::command(DRIVER_NUMBER, command_nr::IS_DRIVER_AVAILABLE, 0, 0)?;
 
         let clock_frequency =
-            syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0);
+            syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)?;
 
-        if clock_frequency < 1 {
-            return Err(TockValue::Expected(TimerError::ErroneousClockFrequency(
-                clock_frequency,
-            )));
+        if clock_frequency == 0 {
+            return Err(OtherError::TimerDriverErroneousClockFrequency.into());
         }
 
         let clock_frequency = ClockFrequency {
-            hz: clock_frequency as usize,
+            hz: clock_frequency,
         };
-        self.clock_frequency = clock_frequency;
 
         let subscription =
-            syscalls::subscribe(DRIVER_NUMBER, subscribe_nr::SUBSCRIBE_CALLBACK, self);
+            syscalls::subscribe(DRIVER_NUMBER, subscribe_nr::SUBSCRIBE_CALLBACK, self)?;
 
-        match subscription {
-            Ok(subscription) => Ok(Timer {
-                num_notifications: num_notifications as usize,
-                clock_frequency,
-                subscription,
-            }),
-            Err(result::ENOMEM) => Err(TockValue::Expected(TimerError::SubscriptionFailed)),
-            Err(unexpected) => Err(TockValue::Unexpected(unexpected)),
-        }
+        Ok(Timer {
+            num_notifications,
+            clock_frequency,
+            subscription,
+        })
     }
 }
 
@@ -105,13 +94,6 @@
     subscription: CallbackSubscription<'a>,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum TimerError {
-    NotSupported,
-    ErroneousClockFrequency(isize),
-    SubscriptionFailed,
-}
-
 impl<'a> Timer<'a> {
     pub fn num_notifications(&self) -> usize {
         self.num_notifications
@@ -121,28 +103,21 @@
         self.clock_frequency
     }
 
-    pub fn get_current_clock(&self) -> ClockValue {
-        let num_ticks = syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0);
-
-        ClockValue {
-            num_ticks,
+    pub fn get_current_clock(&self) -> TockResult<ClockValue> {
+        Ok(ClockValue {
+            num_ticks: syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0)?
+                as isize,
             clock_frequency: self.clock_frequency,
-        }
+        })
     }
 
-    pub fn stop_alarm(&mut self, alarm: Alarm) -> TockResult<(), StopAlarmError> {
-        let return_code =
-            syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, alarm.alarm_id, 0);
-
-        match return_code {
-            result::SUCCESS => Ok(()),
-            result::EALREADY => Err(TockValue::Expected(StopAlarmError::AlreadyDisabled)),
-            unexpected => Err(TockValue::Unexpected(unexpected)),
-        }
+    pub fn stop_alarm(&mut self, alarm: Alarm) -> TockResult<()> {
+        syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, alarm.alarm_id, 0)?;
+        Ok(())
     }
 
-    pub fn set_alarm(&mut self, duration: Duration<isize>) -> TockResult<Alarm, SetAlarmError> {
-        let now = self.get_current_clock();
+    pub fn set_alarm(&mut self, duration: Duration<isize>) -> TockResult<Alarm> {
+        let now = self.get_current_clock()?;
         let freq = self.clock_frequency.hz();
         let duration_ms = duration.ms() as usize;
         let ticks = match duration_ms.checked_mul(freq) {
@@ -153,27 +128,21 @@
                 if duration_ms > freq {
                     match (duration_ms / 1000).checked_mul(freq) {
                         Some(y) => y,
-                        None => return Err(TockValue::Expected(SetAlarmError::DurationTooLong)),
+                        None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
                     }
                 } else {
                     match (freq / 1000).checked_mul(duration_ms) {
                         Some(y) => y,
-                        None => return Err(TockValue::Expected(SetAlarmError::DurationTooLong)),
+                        None => return Err(OtherError::TimerDriverDurationOutOfRange.into()),
                     }
                 }
             }
         };
         let alarm_instant = now.num_ticks() as usize + ticks;
 
-        let alarm_id = syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, alarm_instant, 0);
+        let alarm_id = syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, alarm_instant, 0)?;
 
-        match alarm_id {
-            _ if alarm_id >= 0 => Ok(Alarm {
-                alarm_id: alarm_id as usize,
-            }),
-            result::ENOMEM => Err(TockValue::Expected(SetAlarmError::NoMemoryAvailable)),
-            unexpected => Err(TockValue::Unexpected(unexpected)),
-        }
+        Ok(Alarm { alarm_id })
     }
 }
 
@@ -183,7 +152,7 @@
 }
 
 impl ClockFrequency {
-    pub fn hz(&self) -> usize {
+    pub fn hz(self) -> usize {
         self.hz
     }
 }
@@ -195,11 +164,11 @@
 }
 
 impl ClockValue {
-    pub fn num_ticks(&self) -> isize {
+    pub fn num_ticks(self) -> isize {
         self.num_ticks
     }
 
-    pub fn ms(&self) -> isize {
+    pub fn ms(self) -> isize {
         if self.num_ticks.abs() < isize::MAX / 1000 {
             (1000 * self.num_ticks) / self.clock_frequency.hz() as isize
         } else {
@@ -207,7 +176,7 @@
         }
     }
 
-    pub fn ms_f64(&self) -> f64 {
+    pub fn ms_f64(self) -> f64 {
         1000.0 * (self.num_ticks as f64) / (self.clock_frequency.hz() as f64)
     }
 }
@@ -222,17 +191,6 @@
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-pub enum StopAlarmError {
-    AlreadyDisabled,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum SetAlarmError {
-    NoMemoryAvailable,
-    DurationTooLong,
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Duration<T> {
     ms: T,