More user-friendly method of how to use the Drivers struct

examples/adc.rs

diff --git a/examples/adc.rs b/examples/adc.rs
index 8aaf194..711176e 100644
--- a/examples/adc.rs
+++ b/examples/adc.rs
@@ -3,21 +3,15 @@
 use core::fmt::Write;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut adc_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let adc_driver = adc_driver_factory.init_driver()?;
-    let mut driver = timer_context.create_timer_driver();
-    let timer_driver = driver.activate()?;
-    let mut console = console_driver.create_console();
+    let adc_driver = drivers.adc.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
+    let timer_driver = timer_driver.activate()?;
+    let mut console = drivers.console.create_console();
 
     let mut callback = |channel, value| {
         writeln!(console, "channel: {}, value: {}", channel, value).unwrap();

examples/adc_buffer.rs

diff --git a/examples/adc_buffer.rs b/examples/adc_buffer.rs
index d06f356..86f94b2 100644
--- a/examples/adc_buffer.rs
+++ b/examples/adc_buffer.rs
@@ -4,19 +4,14 @@
 use libtock::adc::AdcBuffer;
 use libtock::result::TockResult;
 use libtock::syscalls;
-use libtock::Drivers;
 
 #[libtock::main]
 /// Reads a 128 byte sample into a buffer and prints the first value to the console.
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut adc_driver_factory,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let adc_driver = adc_driver_factory.init_driver()?;
-    let mut console = console_driver.create_console();
+    let adc_driver = drivers.adc.init_driver()?;
+    let mut console = drivers.console.create_console();
 
     let mut adc_buffer = AdcBuffer::default();
     let mut temp_buffer = [0; libtock::adc::BUFFER_SIZE];

examples/ble_scanning.rs

diff --git a/examples/ble_scanning.rs b/examples/ble_scanning.rs
index 10e269b..8396399 100644
--- a/examples/ble_scanning.rs
+++ b/examples/ble_scanning.rs
@@ -6,7 +6,6 @@
 use libtock::simple_ble;
 use libtock::simple_ble::BleCallback;
 use libtock::simple_ble::BleScanningDriver;
-use libtock::Drivers;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -17,17 +16,13 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut ble_scanning_driver,
-        mut leds_driver_factory,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let leds_driver = leds_driver_factory.init_driver()?;
+    let leds_driver = drivers.leds.init_driver()?;
 
     let mut shared_buffer = BleScanningDriver::create_scan_buffer();
     let mut my_buffer = BleScanningDriver::create_scan_buffer();
-    let shared_memory = ble_scanning_driver.share_memory(&mut shared_buffer)?;
+    let shared_memory = drivers.ble_scanning.share_memory(&mut shared_buffer)?;
 
     let mut callback = BleCallback::new(|_: usize, _: usize| {
         shared_memory.read_bytes(&mut my_buffer[..]);
@@ -37,7 +32,7 @@
             .and_then(|msg| leds_driver.get(msg.nr as usize).map(|led| led.set(msg.st)));
     });
 
-    let _subscription = ble_scanning_driver.start(&mut callback)?;
+    let _subscription = drivers.ble_scanning.start(&mut callback)?;
 
     future::pending().await
 }

examples/blink.rs

diff --git a/examples/blink.rs b/examples/blink.rs
index 8d6f6da..fd3b1e5 100644
--- a/examples/blink.rs
+++ b/examples/blink.rs
@@ -2,18 +2,13 @@
 
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut leds_driver_factory,
-        mut timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let leds_driver = leds_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let leds_driver = drivers.leds.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
 
     // Blink the LEDs in a binary count pattern and scale

examples/blink_random.rs

diff --git a/examples/blink_random.rs b/examples/blink_random.rs
index 985746d..60bac18 100644
--- a/examples/blink_random.rs
+++ b/examples/blink_random.rs
@@ -3,19 +3,13 @@
 use libtock::leds::LedsDriver;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut leds_driver_factory,
-        mut rng_driver,
-        mut timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let leds_driver = leds_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let leds_driver = drivers.leds.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
 
     // blink_nibble assumes 4 leds.
@@ -23,7 +17,7 @@
 
     let mut buf = [0; 64];
     loop {
-        rng_driver.fill_buffer(&mut buf).await?;
+        drivers.rng.fill_buffer(&mut buf).await?;
 
         for &x in buf.iter() {
             blink_nibble(&leds_driver, x)?;

examples/button_leds.rs

diff --git a/examples/button_leds.rs b/examples/button_leds.rs
index 94fdd85..794251d 100644
--- a/examples/button_leds.rs
+++ b/examples/button_leds.rs
@@ -3,18 +3,13 @@
 use futures::future;
 use libtock::buttons::ButtonState;
 use libtock::result::TockResult;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut buttons_driver_factory,
-        mut leds_driver_factory,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let buttons_driver = buttons_driver_factory.init_driver()?;
-    let leds_driver = leds_driver_factory.init_driver()?;
+    let buttons_driver = drivers.buttons.init_driver()?;
+    let leds_driver = drivers.leds.init_driver()?;
 
     let mut callback = |button_num, state| {
         if let (ButtonState::Pressed, Some(led)) = (state, leds_driver.get(button_num)) {

examples/button_read.rs

diff --git a/examples/button_read.rs b/examples/button_read.rs
index 252493b..c3f9aa6 100644
--- a/examples/button_read.rs
+++ b/examples/button_read.rs
@@ -3,21 +3,15 @@
 use core::fmt::Write;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut buttons_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let buttons_driver = buttons_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let buttons_driver = drivers.buttons.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     loop {
         for button in buttons_driver.buttons() {

examples/button_subscribe.rs

diff --git a/examples/button_subscribe.rs b/examples/button_subscribe.rs
index 9fd64f4..d06a0e9 100644
--- a/examples/button_subscribe.rs
+++ b/examples/button_subscribe.rs
@@ -5,21 +5,15 @@
 use libtock::buttons::ButtonState;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut buttons_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let buttons_driver = buttons_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let buttons_driver = drivers.buttons.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     let pressed_count = Cell::new(0usize);
     let released_count = Cell::new(0usize);

examples/gpio.rs

diff --git a/examples/gpio.rs b/examples/gpio.rs
index 2f2c94f..9241e74 100644
--- a/examples/gpio.rs
+++ b/examples/gpio.rs
@@ -2,19 +2,14 @@
 
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 // Example works on P0.03
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut gpio_driver_factory,
-        mut timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut gpio_driver = gpio_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let mut gpio_driver = drivers.gpio.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
 
     let mut gpio = gpio_driver.gpios().next().unwrap();

examples/gpio_read.rs

diff --git a/examples/gpio_read.rs b/examples/gpio_read.rs
index 88e723d..a29662e 100644
--- a/examples/gpio_read.rs
+++ b/examples/gpio_read.rs
@@ -4,22 +4,16 @@
 use libtock::gpio::ResistorMode;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 // example works on p0.03
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut gpio_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut gpio_driver = gpio_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let mut gpio_driver = drivers.gpio.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     let mut gpio = gpio_driver.gpios().next().unwrap();
     let gpio_in = gpio.enable_input(ResistorMode::PullDown)?;

examples/hardware_test.rs

diff --git a/examples/hardware_test.rs b/examples/hardware_test.rs
index 73b4204..2f7028c 100644
--- a/examples/hardware_test.rs
+++ b/examples/hardware_test.rs
@@ -15,7 +15,6 @@
 use libtock::result::TockResult;
 use libtock::timer::DriverContext;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 static mut STATIC: usize = 0;
 
@@ -37,15 +36,10 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut gpio_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut gpio_driver = gpio_driver_factory.init_driver()?;
-    let mut console = console_driver.create_console();
+    let mut gpio_driver = drivers.gpio.init_driver()?;
+    let mut console = drivers.console.create_console();
 
     let mut gpios = gpio_driver.gpios();
     let mut pin_in = gpios.next().unwrap();
@@ -63,7 +57,7 @@
 
     test_trait_objects(&mut console, &pin_in, &mut pin_out)?;
 
-    test_callbacks_and_wait_forever(&mut console, &mut timer_context).await
+    test_callbacks_and_wait_forever(&mut console, &mut drivers.timer).await
 }
 
 fn test_heap(console: &mut Console) {

examples/sensors.rs

diff --git a/examples/sensors.rs b/examples/sensors.rs
index afe365c..7ea87c7 100644
--- a/examples/sensors.rs
+++ b/examples/sensors.rs
@@ -2,34 +2,37 @@
 
 use core::fmt::Write;
 use libtock::result::TockResult;
-use libtock::sensors::*;
+use libtock::sensors::Sensor;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut temperature_sensor,
-        mut humidity_sensor,
-        mut ambient_light_sensor,
-        mut ninedof_driver,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut timer_driver = timer_context.create_timer_driver();
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     loop {
-        writeln!(console, "Humidity:    {}\n", humidity_sensor.read()?)?;
-        writeln!(console, "Temperature: {}\n", temperature_sensor.read()?)?;
-        writeln!(console, "Light:       {}\n", ambient_light_sensor.read()?)?;
+        writeln!(
+            console,
+            "Humidity:    {}\n",
+            drivers.humidity_sensor.read()?
+        )?;
+        writeln!(
+            console,
+            "Temperature: {}\n",
+            drivers.temperature_sensor.read()?
+        )?;
+        writeln!(
+            console,
+            "Light:       {}\n",
+            drivers.ambient_light_sensor.read()?
+        )?;
         writeln!(
             console,
             "Accel:       {}\n",
-            ninedof_driver.read_acceleration()?
+            drivers.ninedof.read_acceleration()?
         )?;
         timer_driver.sleep(Duration::from_ms(500)).await?;
     }

examples/seven_segment.rs

diff --git a/examples/seven_segment.rs b/examples/seven_segment.rs
index 5637497..88b0700 100644
--- a/examples/seven_segment.rs
+++ b/examples/seven_segment.rs
@@ -3,7 +3,6 @@
 use libtock::electronics::ShiftRegister;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 fn number_to_bits(n: u8) -> [bool; 8] {
     match n {
@@ -24,13 +23,9 @@
 // Example works on a shift register on P0.03, P0.04, P0.28
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut gpio_driver_factory,
-        mut timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut gpio_driver = gpio_driver_factory.init_driver()?;
+    let mut gpio_driver = drivers.gpio.init_driver()?;
     let mut gpios = gpio_driver.gpios();
     let mut gpio0 = gpios.next().unwrap();
     let gpio0 = gpio0.enable_output()?;
@@ -40,7 +35,7 @@
     let gpio2 = gpio2.enable_output()?;
     let mut shift_register = ShiftRegister::new(&gpio0, &gpio1, &gpio2);
 
-    let mut driver = timer_context.create_timer_driver();
+    let mut driver = drivers.timer.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     let mut i = 0;

examples/simple_ble.rs

diff --git a/examples/simple_ble.rs b/examples/simple_ble.rs
index a6e5289..23543ed 100644
--- a/examples/simple_ble.rs
+++ b/examples/simple_ble.rs
@@ -5,7 +5,6 @@
 use libtock::result::TockResult;
 use libtock::simple_ble::BleAdvertisingDriver;
 use libtock::timer::Duration;
-use libtock::Drivers;
 use serde::Serialize;
 
 #[derive(Serialize)]
@@ -16,16 +15,11 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut leds_driver_factory,
-        mut ble_advertising_driver,
-        mut timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let leds_driver = leds_driver_factory.init_driver()?;
-    let mut driver = timer_context.create_timer_driver();
-    let timer_driver = driver.activate()?;
+    let leds_driver = drivers.leds.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
+    let timer_driver = timer_driver.activate()?;
 
     let led = leds_driver.leds().next().unwrap();
 
@@ -50,7 +44,9 @@
 
     gap_payload.add_service_payload([91, 79], &payload).unwrap();
 
-    let _handle = ble_advertising_driver.initialize(100, &gap_payload, &mut buffer);
+    let _handle = drivers
+        .ble_advertising
+        .initialize(100, &gap_payload, &mut buffer);
 
     loop {
         led.on()?;

examples/temperature.rs

diff --git a/examples/temperature.rs b/examples/temperature.rs
index aa868ff..7428187 100644
--- a/examples/temperature.rs
+++ b/examples/temperature.rs
@@ -3,21 +3,15 @@
 use core::fmt::Write;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut temperature_driver_factory,
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut temperature_driver = temperature_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let mut temperature_driver = drivers.temperature.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     loop {
         let temperature = temperature_driver.measure_temperature().await?;

examples/timer.rs

diff --git a/examples/timer.rs b/examples/timer.rs
index bb6d862..493f0b9 100644
--- a/examples/timer.rs
+++ b/examples/timer.rs
@@ -8,26 +8,21 @@
 use libtock::result::TockResult;
 use libtock::timer::DriverContext;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 const DELAY_MS: usize = 500;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
     let mut previous_ticks = None;
 
     for i in 0.. {
-        print_now(&mut console, &mut timer_context, &mut previous_ticks, i)?;
-        let mut driver = timer_context.create_timer_driver();
-        let timer_driver = driver.activate()?;
+        print_now(&mut console, &mut drivers.timer, &mut previous_ticks, i)?;
+        let mut timer_driver = drivers.timer.create_timer_driver();
+        let timer_driver = timer_driver.activate()?;
 
         timer_driver.sleep(Duration::from_ms(DELAY_MS)).await?;
     }

examples/timer_parallel.rs

diff --git a/examples/timer_parallel.rs b/examples/timer_parallel.rs
index d2ce3ae..66ddac2 100644
--- a/examples/timer_parallel.rs
+++ b/examples/timer_parallel.rs
@@ -5,7 +5,6 @@
 use libtock::result::TockResult;
 use libtock::timer::Duration;
 use libtock::timer::ParallelSleepDriver;
-use libtock::Drivers;
 
 async fn blink(
     timer_driver: &ParallelSleepDriver<'_>,
@@ -21,14 +20,10 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut leds_driver_factory,
-        timer_context,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let leds_driver = leds_driver_factory.init_driver()?;
-    let mut timer_driver = timer_context.create_timer_driver();
+    let leds_driver = drivers.leds.init_driver()?;
+    let mut timer_driver = drivers.timer.create_timer_driver();
     let timer_driver = timer_driver.activate()?;
 
     let mut leds = leds_driver.leds();

examples/timer_subscribe.rs

diff --git a/examples/timer_subscribe.rs b/examples/timer_subscribe.rs
index 6f7ec1b..5c69be1 100644
--- a/examples/timer_subscribe.rs
+++ b/examples/timer_subscribe.rs
@@ -4,19 +4,14 @@
 use futures::future;
 use libtock::result::TockResult;
 use libtock::timer::Duration;
-use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let Drivers {
-        mut timer_context,
-        console_driver,
-        ..
-    } = libtock::retrieve_drivers()?;
+    let mut drivers = libtock::retrieve_drivers()?;
 
-    let mut console = console_driver.create_console();
+    let mut console = drivers.console.create_console();
 
-    let mut with_callback = timer_context.with_callback(|_, _| {
+    let mut with_callback = drivers.timer.with_callback(|_, _| {
         writeln!(
             console,
             "This line is printed 2 seconds after the start of the program.",

src/debug/mod.rs

diff --git a/src/debug/mod.rs b/src/debug/mod.rs
index 1e55bb3..4596aaa 100644
--- a/src/debug/mod.rs
+++ b/src/debug/mod.rs
@@ -1,23 +1,23 @@
 //! Heapless debugging functions for Tock troubleshooting
 
 mod low_level_debug;
-use crate::drivers::Drivers;
-pub use low_level_debug::*;
 
-use crate::retrieve_drivers_unsafe;
+use crate::drivers;
+
+pub use low_level_debug::*;
 
 pub fn println() {
     let buffer = [b'\n'];
-    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
-    let mut console = console_driver.create_console();
+    let drivers = unsafe { drivers::retrieve_drivers_unsafe() };
+    let mut console = drivers.console.create_console();
     let _ = console.write(&buffer);
 }
 
 pub fn print_as_hex(value: usize) {
     let mut buffer = [b'\n'; 11];
     write_as_hex(&mut buffer, value);
-    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
-    let mut console = console_driver.create_console();
+    let drivers = unsafe { drivers::retrieve_drivers_unsafe() };
+    let mut console = drivers.console.create_console();
     let _ = console.write(buffer);
 }
 
@@ -29,8 +29,8 @@
     let mut buffer = [b'\n'; 15];
     buffer[0..4].clone_from_slice(b"SP: ");
     write_as_hex(&mut buffer[4..15], stack_pointer);
-    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
-    let mut console = console_driver.create_console();
+    let drivers = unsafe { drivers::retrieve_drivers_unsafe() };
+    let mut console = drivers.console.create_console();
     let _ = console.write(buffer);
 }
 
@@ -54,8 +54,8 @@
         }
     }
     buffer[27] = b'\n';
-    let Drivers { console_driver, .. } = retrieve_drivers_unsafe();
-    let mut console = console_driver.create_console();
+    let drivers = drivers::retrieve_drivers_unsafe();
+    let mut console = drivers.console.create_console();
     let _ = console.write(&buffer);
 }
 

src/drivers.rs

diff --git a/src/drivers.rs b/src/drivers.rs
index b7c9845..a8e1e98 100644
--- a/src/drivers.rs
+++ b/src/drivers.rs
@@ -20,20 +20,20 @@
 /// Struct containing all drivers constructible through [retrieve_drivers()]
 #[non_exhaustive]
 pub struct Drivers {
-    pub console_driver: ConsoleDriver,
-    pub leds_driver_factory: LedsDriverFactory,
-    pub timer_context: DriverContext,
-    pub gpio_driver_factory: GpioDriverFactory,
-    pub temperature_driver_factory: TemperatureDriverFactory,
-    pub buttons_driver_factory: ButtonsDriverFactory,
-    pub adc_driver_factory: AdcDriverFactory,
-    pub rng_driver: RngDriver,
-    pub ble_advertising_driver: BleAdvertisingDriver,
-    pub ble_scanning_driver: BleScanningDriver,
+    pub console: ConsoleDriver,
+    pub leds: LedsDriverFactory,
+    pub timer: DriverContext,
+    pub gpio: GpioDriverFactory,
+    pub temperature: TemperatureDriverFactory,
+    pub buttons: ButtonsDriverFactory,
+    pub adc: AdcDriverFactory,
+    pub rng: RngDriver,
+    pub ble_advertising: BleAdvertisingDriver,
+    pub ble_scanning: BleScanningDriver,
     pub ambient_light_sensor: AmbientLightSensor,
     pub temperature_sensor: TemperatureSensor,
     pub humidity_sensor: HumiditySensor,
-    pub ninedof_driver: NinedofDriver,
+    pub ninedof: NinedofDriver,
 }
 
 /// Retrieve [Drivers] struct. Returns struct only once.
@@ -56,31 +56,30 @@
 
 #[allow(clippy::declare_interior_mutable_const)]
 const DRIVERS: Drivers = Drivers {
-    adc_driver_factory: AdcDriverFactory,
-    ble_advertising_driver: BleAdvertisingDriver,
-    ble_scanning_driver: BleScanningDriver,
-    buttons_driver_factory: ButtonsDriverFactory,
-    console_driver: ConsoleDriver,
-    leds_driver_factory: LedsDriverFactory,
-    timer_context: DriverContext {
+    adc: AdcDriverFactory,
+    ble_advertising: BleAdvertisingDriver,
+    ble_scanning: BleScanningDriver,
+    buttons: ButtonsDriverFactory,
+    console: ConsoleDriver,
+    leds: LedsDriverFactory,
+    timer: DriverContext {
         active_timer: Cell::new(None),
     },
-    gpio_driver_factory: GpioDriverFactory,
-    temperature_driver_factory: TemperatureDriverFactory,
-    rng_driver: RngDriver,
+    gpio: GpioDriverFactory,
+    temperature: TemperatureDriverFactory,
+    rng: RngDriver,
     ambient_light_sensor: AmbientLightSensor,
     temperature_sensor: TemperatureSensor,
     humidity_sensor: HumiditySensor,
-    ninedof_driver: NinedofDriver,
+    ninedof: NinedofDriver,
 };
 
 static mut DRIVERS_SINGLETON: Option<Drivers> = Some(DRIVERS);
 
 #[cfg(test)]
 mod test {
-    use super::DRIVERS;
-    use super::DRIVERS_SINGLETON;
-    use crate::retrieve_drivers;
+    use super::*;
+
     #[test]
     pub fn can_be_retrieved_once() {
         reset_drivers_singleton();

src/lang_items.rs

diff --git a/src/lang_items.rs b/src/lang_items.rs
index 4f8d947..69ddf85 100644
--- a/src/lang_items.rs
+++ b/src/lang_items.rs
@@ -18,12 +18,12 @@
 //! `rustc_main`. That's covered by the `_start` function in the root of this
 //! crate.
 
+use crate::drivers;
 use crate::entry_point::TockAllocator;
 use crate::leds::LedsDriver;
 use crate::result::TockResult;
 use crate::timer::Duration;
 use crate::timer::ParallelSleepDriver;
-use crate::Drivers;
 use core::alloc::Layout;
 use core::executor;
 use core::panic::PanicInfo;
@@ -50,14 +50,10 @@
 
     // Flash all LEDs (if available).
     executor::block_on(async {
-        let Drivers {
-            mut leds_driver_factory,
-            timer_context,
-            ..
-        } = crate::retrieve_drivers_unsafe();
+        let mut drivers = drivers::retrieve_drivers_unsafe();
 
-        let leds_driver = leds_driver_factory.init_driver();
-        let mut timer_driver = timer_context.create_timer_driver();
+        let leds_driver = drivers.leds.init_driver();
+        let mut timer_driver = drivers.timer.create_timer_driver();
         let timer_driver = timer_driver.activate();
 
         if let (Ok(leds_driver), Ok(timer_driver)) = (leds_driver, timer_driver) {
@@ -89,14 +85,10 @@
 #[alloc_error_handler]
 unsafe fn alloc_error_handler(_: Layout) -> ! {
     executor::block_on(async {
-        let Drivers {
-            mut leds_driver_factory,
-            timer_context,
-            ..
-        } = crate::retrieve_drivers_unsafe();
+        let mut drivers = drivers::retrieve_drivers_unsafe();
 
-        let leds_driver = leds_driver_factory.init_driver();
-        let mut timer_driver = timer_context.create_timer_driver();
+        let leds_driver = drivers.leds.init_driver();
+        let mut timer_driver = drivers.timer.create_timer_driver();
         let timer_driver = timer_driver.activate();
 
         if let (Ok(leds_driver), Ok(timer_driver)) = (leds_driver, timer_driver) {

src/lib.rs

diff --git a/src/lib.rs b/src/lib.rs
index 6752ea8..e7d9d63 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,6 @@
 #![feature(asm, alloc_error_handler, lang_items, naked_functions)]
 #![cfg_attr(any(target_arch = "arm", target_arch = "riscv32"), no_std)]
 
-mod drivers;
 mod entry_point;
 #[cfg(any(target_arch = "arm", target_arch = "riscv32"))]
 mod lang_items;
@@ -13,6 +12,7 @@
 pub mod callback;
 pub mod console;
 pub mod debug;
+pub mod drivers;
 pub mod electronics;
 pub mod futures;
 pub mod gpio;
@@ -28,5 +28,5 @@
 pub mod timer;
 pub mod unwind_symbols;
 
-pub use drivers::*;
+pub use drivers::retrieve_drivers;
 pub use libtock_codegen::main;

src/timer.rs

diff --git a/src/timer.rs b/src/timer.rs
index d93198e..7319109 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -283,12 +283,10 @@
 /// Context for the time driver.
 /// You can create a context as follows:
 /// ```no_run
-/// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
-/// # use libtock::Drivers;
-/// # #[libtock::main]
-/// # async fn main() -> TockResult<()> {
-///  let Drivers {  timer_context, .. } = libtock::retrieve_drivers()?;
+/// # async fn doc() -> TockResult<()> {
+/// let mut drivers = libtock::retrieve_drivers()?;
+/// let mut timer_context = drivers.timer;
 /// # Ok(())
 /// # }
 /// ```
@@ -317,14 +315,12 @@
 
 /// Timer driver instance. You can create a TimerDriver from a DriverContext as follows:
 /// ```no_run
-/// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
-/// # use libtock::Drivers;
-/// # #[libtock::main]
-/// # async fn main() -> TockResult<()> {
-/// # let Drivers {  timer_context,.. } = libtock::retrieve_drivers()?;
-/// # let mut driver = timer_context.create_timer_driver();
-/// let timer_driver = driver.activate()?;
+/// # async fn doc() -> TockResult<()> {
+/// # let mut drivers = libtock::retrieve_drivers()?;
+/// # let mut timer_context = drivers.timer;
+/// let mut timer_driver = timer_context.create_timer_driver();
+/// let timer_driver = timer_driver.activate()?;
 /// # Ok(())
 /// # }
 /// ```
@@ -343,15 +339,12 @@
 /// active alarms.
 /// Example usage (sleep for 1 second):
 /// ```no_run
-/// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
 /// # use libtock::timer::Duration;
-/// # use libtock::Drivers;
-/// # #[libtock::main]
-/// # async fn main() -> TockResult<()> {
-/// # let Drivers {  timer_context,.. } = libtock::retrieve_drivers()?;
-/// # let mut driver = timer_context.create_timer_driver();
-/// let timer_driver = driver.activate()?;
+/// # async fn doc() -> TockResult<()> {
+/// # let mut drivers = libtock::retrieve_drivers()?;
+/// # let mut timer_driver = drivers.timer.create_timer_driver();
+/// let timer_driver = timer_driver.activate()?;
 /// timer_driver.sleep(Duration::from_ms(1000)).await?;
 /// # Ok(())
 /// # }