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(¬_written_yet[..num_bytes_to_print]); - self.flush(num_bytes_to_print); + self.flush(num_bytes_to_print)?; not_written_yet = ¬_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,