base-station: Add support for the nrf24l01-stick USB adapter and the RPi 4.

base-station/software/Cargo.lock

 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+[[package]]
+name = "CoreFoundation-sys"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0e9889e6db118d49d88d84728d0e964d973a5680befb5f85f55141beea5c20b"
+dependencies = [
+ "libc",
+ "mach 0.1.2",
+]
+
+[[package]]
+name = "IOKit-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99696c398cbaf669d2368076bdb3d627fb0ce51a26899d7c61228c5c0af3bf4a"
+dependencies = [
+ "CoreFoundation-sys",
+ "libc",
+ "mach 0.1.2",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b585a98a234c46fc563103e9278c9391fde1f4e6850334da895d27edb9580f62"
 
+[[package]]
+name = "as-slice"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4d1c23475b74e3672afa8c2be22040b8b7783ad9b461021144ed10a46bb0e6"
+dependencies = [
+ "generic-array 0.12.3",
+ "generic-array 0.13.2",
+ "generic-array 0.14.4",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "atty"
 version = "0.2.14"
  "log",
  "mqtt-protocol",
  "nb",
+ "nrf24l01-stick-driver",
  "protocol",
  "rand",
  "sysfs_gpio",
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ed1e761351b56f54eb9dcd0cfaca9fd0daecf93918e1cfc01c8a3d26ee7adcd"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.14"
  "futures",
  "libc",
  "mio",
- "nix",
+ "nix 0.14.1",
  "tokio",
 ]
 
+[[package]]
+name = "hash32"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4041af86e63ac4298ce40e5cca669066e75b6f1aa3390fe2561ffa5e1d9f4cc"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "heapless"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74911a68a1658cfcfb61bc0ccfbd536e3b6e906f8c2f7883ee50157e3e2184f1"
+dependencies = [
+ "as-slice",
+ "generic-array 0.13.2",
+ "hash32",
+ "serde",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.11"
  "bitflags",
  "byteorder",
  "libc",
- "nix",
+ "nix 0.14.1",
 ]
 
 [[package]]
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3baa92041a6fec78c687fa0cc2b3fae8884f743d672cf551bed1d6dac6988d0f"
 
+[[package]]
+name = "libudev"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea626d3bdf40a1c5aee3bcd4f40826970cae8d80a8fec934c82a63840094dcfe"
+dependencies = [
+ "libc",
+ "libudev-sys",
+]
+
+[[package]]
+name = "libudev-sys"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "linux-embedded-hal"
 version = "0.3.0"
  "cfg-if",
 ]
 
+[[package]]
+name = "mach"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fd13ee2dd61cc82833ba05ade5a30bb3d63f7ced605ef827063c63078302de9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "mach"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86dd2487cdfea56def77b88438a2c915fb45113c5319bfe7e14306ca4cd0b0e1"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "memchr"
 version = "2.3.3"
  "winapi 0.3.8",
 ]
 
+[[package]]
+name = "mio-serial"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0f0c240805cd4c65aa97da44ad99df8bad922cb999d0e451b51fdec13a661fd"
+dependencies = [
+ "mio",
+ "mio-named-pipes",
+ "nix 0.17.0",
+ "serialport",
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "mio-uds"
 version = "0.6.7"
  "void",
 ]
 
+[[package]]
+name = "nix"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e4785f2c3b7589a0d0c1dd60285e1188adac4006e8abd6dd578e1567027363"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if",
+ "libc",
+ "void",
+]
+
+[[package]]
+name = "nrf24l01-stick-driver"
+version = "0.1.0"
+source = "git+https://github.com/mgottschlag/nrf24l01-stick#fe8085d89823ed30fa54715f4d891609b0b239d7"
+dependencies = [
+ "bytes",
+ "futures",
+ "nrf24l01-stick-protocol",
+ "thiserror",
+ "tokio",
+ "tokio-serial",
+ "tokio-util",
+]
+
+[[package]]
+name = "nrf24l01-stick-protocol"
+version = "0.1.0"
+source = "git+https://github.com/mgottschlag/nrf24l01-stick#fe8085d89823ed30fa54715f4d891609b0b239d7"
+dependencies = [
+ "postcard",
+ "serde",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "pkg-config"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
+
+[[package]]
+name = "postcard"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3e3f5c2e9a91383c6594ec68aa2dfdfe19a3c86f34b088ba7203f2483d2682f"
+dependencies = [
+ "heapless",
+ "postcard-cobs",
+ "serde",
+]
+
+[[package]]
+name = "postcard-cobs"
+version = "0.1.5-pre"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c68cb38ed13fd7bc9dd5db8f165b7c8d9c1a315104083a2b10f11354c2af97f"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
+[[package]]
+name = "serde"
+version = "1.0.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6135c78461981c79497158ef777264c51d9d0f4f3fc3a4d22b915900e42dac6a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93c5eaa17d0954cb481cdcfffe9d84fcfa7a1a9f2349271e678677be4c26ae31"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "serial-core"
 version = "0.4.0"
  "termios",
 ]
 
+[[package]]
+name = "serialport"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8d3ecaf58010bedccae17be55d4ed6f2ecde5646fc48ce8c66ea2d35a1419c"
+dependencies = [
+ "CoreFoundation-sys",
+ "IOKit-sys",
+ "bitflags",
+ "cfg-if",
+ "libudev",
+ "mach 0.2.3",
+ "nix 0.14.1",
+ "regex",
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.2.0"
 dependencies = [
  "bitflags",
  "libc",
- "nix",
+ "nix 0.14.1",
 ]
 
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "syn"
 version = "1.0.17"
 dependencies = [
  "futures",
  "mio",
- "nix",
+ "nix 0.14.1",
  "pin-project-lite",
  "tokio",
 ]
  "syn",
 ]
 
+[[package]]
+name = "tokio-serial"
+version = "4.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad6436458f961b1345f55f2a771325f8dbdd9b5908285059d34a31e86779e38"
+dependencies = [
+ "mio-serial",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "log",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "typenum"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
 
+[[package]]
+name = "version_check"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
+
 [[package]]
 name = "void"
 version = "1.0.2"

base-station/software/Cargo.toml

 authors = ["Mathias Gottschlag <mgottschlag@gmail.com>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = []
+rpi4 = [ "sysfs_gpio", "gpio-cdev" ]
+nanopineo = [ "sysfs_gpio", "gpio-cdev" ]
+nrf24l01-stick = [ "nrf24l01-stick-driver" ]
 
 [dependencies]
 linux-embedded-hal = "0.3"
 protocol = { path = "../../common/rust-protocol" }
 rand = "0.7.3"
 tokio = { version = "0.2", features = [ "full" ] }
-sysfs_gpio = { version = "0.5.4", features = [ "use_tokio" ] }
+sysfs_gpio = { version = "0.5.4", features = [ "use_tokio" ], optional = true }
 futures = "0.3.5"
 futures-util = "0.3.5"
 nb = "0.1.2"
-gpio-cdev = { git = "https://github.com/mgottschlag/gpio-cdev", branch = "tokio", features = [ "async-tokio" ] }
+gpio-cdev = { git = "https://github.com/mgottschlag/gpio-cdev", branch = "tokio", features = [ "async-tokio" ], optional = true }
 chrono = "0.4.11"
+nrf24l01-stick-driver = { git = "https://github.com/mgottschlag/nrf24l01-stick", optional = true }
 
 [patch.crates-io]
 sysfs_gpio = { git = "https://github.com/mgottschlag/rust-sysfs-gpio", branch = "new-futures" }

base-station/software/src/main.rs

 //!
 //! TODO: Document configuration and hardware setup.
 
+#[cfg(not(any(feature = "rpi4", feature = "nanopineo", feature = "nrf24l01-stick")))]
+compile_error!("Select an SPI implementation via the corresponding cargo feature!");
+
 use std::env;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 mod current;
 mod publish;
 mod radio;
+#[cfg(any(feature = "nanopineo", feature = "rpi4"))]
 mod spi;
 mod tsdb;
 

base-station/software/src/radio.rs → base-station/software/src/radio/gpio.rs

-//! Wrapper around the NRF24 driver which provides tokio-compatible asynchronous interfaces.
-
 use std::convert::TryInto;
 use std::io;
 use std::time::Duration;
 use linux_embedded_hal::sysfs_gpio::{Direction, Error as GpioError};
 use linux_embedded_hal::Pin;
 use log::{error, info};
-use protocol::{Location, Packet};
+use protocol::Packet;
 use rand::Rng;
 use tokio::select;
-use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 use tokio::time::delay_for;
 
-use super::spi::EmbeddedHalSpidev;
-
-const DISPLAY_ID: u8 = 0x20;
-const DISPLAY_KEY: [u8; 16] = include!("../../../common/display_key.txt");
-const WEATHER_STATION_0_ID: u8 = 0x30;
-const WEATHER_STATION_0_KEY: [u8; 16] = include!("../../../common/weather_station_0_key.txt");
-const WEATHER_STATION_1_ID: u8 = 0x31;
-const WEATHER_STATION_1_KEY: [u8; 16] = include!("../../../common/weather_station_1_key.txt");
+use super::super::spi::EmbeddedHalSpidev;
+use super::{get_key, RadioConfig};
 
-/// Hardware configuration.
-pub struct RadioConfig {
-    // TODO
-}
-
-/// Wrapper around the NRF24 radio driver.
-pub struct Radio {
-    tx: UnboundedSender<(u8, Packet)>,
+pub struct RadioTask {
+    config: super::RadioConfig,
+    nrf24: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
+    irq: Option<AsyncLineEventHandle>,
+    tx: UnboundedReceiver<(u8, Packet)>,
+    rx: UnboundedSender<(u8, Packet)>,
 }
 
-impl Radio {
-    /// Initializes the radio and returns both radio and the stream of incoming packets.
-    pub async fn init(
+impl RadioTask {
+    pub fn new(
         config: RadioConfig,
-    ) -> Result<(Radio, UnboundedReceiver<(u8, Packet)>), RadioError> {
-        info!("Initializing radio...");
-        let (tx_send, tx_recv) = mpsc::unbounded_channel();
-        let (rx_send, rx_recv) = mpsc::unbounded_channel();
-        let mut task = RadioTask {
+        tx: UnboundedReceiver<(u8, Packet)>,
+        rx: UnboundedSender<(u8, Packet)>,
+    ) -> RadioTask {
+        RadioTask {
             config,
             nrf24: None,
             irq: None,
-            tx: tx_recv,
-            rx: rx_send,
-        };
-        task.init().await?;
-        info!("radio initialized.");
-
-        // Start a task for packet handling.
-        tokio::spawn(async move {
-            task.run().await;
-        });
-
-        Ok((Radio { tx: tx_send }, rx_recv))
-    }
-
-    /// Sends a packet to the specified device.
-    ///
-    /// The function returns immediately, and the packet might or might not be sent successfully.
-    ///
-    /// # Arguments
-    ///
-    /// * `device_id` - the ID of the targeted device
-    /// * `packet` - the packet to send
-    pub fn send_packet_async(&mut self, device_id: u8, packet: Packet) {
-        self.tx.send((device_id, packet)).unwrap();
+            tx,
+            rx,
+        }
     }
-}
 
-struct RadioTask {
-    config: RadioConfig,
-    nrf24: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
-    irq: Option<AsyncLineEventHandle>,
-    tx: UnboundedReceiver<(u8, Packet)>,
-    rx: UnboundedSender<(u8, Packet)>,
-}
-
-impl RadioTask {
-    async fn init(&mut self) -> Result<(), RadioError> {
-        // The NRF module is connected as follows:
+    pub async fn init(&mut self) -> Result<(), RadioError> {
+        // On the NanoPi Neo, the NRF module is connected as follows:
         // - CE: PA1
         // - CS: PG8
         // - IRQ: PG9
         // - SCK: PC2
         // - Power (active low): PG11
 
+        // TODO: Other pins.
+
         // Configure the GPIOs.
-        let pwr_nr = get_pin_number('G', 11);
+        let (pwr_nr, ce_nr, cs_nr, irq_nr) = if cfg!(feature = "nanopineo") {
+            (
+                get_pin_number('G', 11),
+                get_pin_number('A', 1),
+                get_pin_number('G', 8),
+                get_pin_number('G', 9),
+            )
+        } else if cfg!(feature = "rpi4") {
+            (20, 25, 7, 12)
+        } else {
+            panic!("no system selected");
+        };
+
         let mut pwr = Pin::new(pwr_nr);
         pwr.export().unwrap();
         pwr.set_direction(Direction::Out).unwrap();
 
-        let ce_nr = get_pin_number('A', 1);
         let mut ce = Pin::new(ce_nr);
         ce.export().unwrap();
         ce.set_direction(Direction::Out).unwrap();
         ce.set_high().unwrap();
-        let cs_nr = get_pin_number('G', 8);
         let mut cs = Pin::new(cs_nr);
         cs.export().unwrap();
         cs.set_direction(Direction::Out).unwrap();
         cs.set_high().unwrap();
         let mut chip = Chip::new("/dev/gpiochip0")?;
-        let irq_nr = get_pin_number('G', 9);
         let line = chip.get_line(irq_nr as u32)?;
         let irq = AsyncLineEventHandle::new(line.events(
             LineRequestFlags::INPUT,
         Ok(())
     }
 
-    async fn run(&mut self) {
+    pub async fn run(&mut self) {
         loop {
             let e = self.run_with_initialized_radio().await;
             error!("Error in radio task: {:?}", e);
     }
 }
 
-pub fn get_device_location(device_id: u8) -> Location {
-    match device_id {
-        DISPLAY_ID => Location::Bedroom,
-        WEATHER_STATION_0_ID => Location::Livingroom,
-        WEATHER_STATION_1_ID => Location::Bathroom,
-        _ => Location::Livingroom,
-    }
-}
-
-fn get_key(device_id: u8) -> Option<&'static [u8]> {
-    match device_id {
-        DISPLAY_ID => Some(&DISPLAY_KEY),
-        WEATHER_STATION_0_ID => Some(&WEATHER_STATION_0_KEY),
-        WEATHER_STATION_1_ID => Some(&WEATHER_STATION_1_KEY),
-        _ => None,
-    }
-}
-
 fn get_pin_number(c: char, n: u64) -> u64 {
     (c as u64 - 'A' as u64) * 32 + n
 }

base-station/software/src/radio/mod.rs

+//! Wrapper around the NRF24 driver which provides tokio-compatible asynchronous interfaces.
+
+use log::info;
+use protocol::{Location, Packet};
+use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
+
+#[cfg(feature = "nrf24l01-stick")]
+mod nrfstick;
+#[cfg(feature = "nrf24l01-stick")]
+pub use nrfstick::RadioError;
+#[cfg(feature = "nrf24l01-stick")]
+pub use nrfstick::RadioTask;
+
+#[cfg(any(feature = "nanopineo", feature = "rpi4"))]
+mod gpio;
+#[cfg(any(feature = "nanopineo", feature = "rpi4"))]
+pub use gpio::RadioError;
+#[cfg(any(feature = "nanopineo", feature = "rpi4"))]
+pub use gpio::RadioTask;
+
+const DISPLAY_ID: u8 = 0x20;
+const DISPLAY_KEY: [u8; 16] = include!("../../../../common/display_key.txt");
+const WEATHER_STATION_0_ID: u8 = 0x30;
+const WEATHER_STATION_0_KEY: [u8; 16] = include!("../../../../common/weather_station_0_key.txt");
+const WEATHER_STATION_1_ID: u8 = 0x31;
+const WEATHER_STATION_1_KEY: [u8; 16] = include!("../../../../common/weather_station_1_key.txt");
+
+/// Hardware configuration.
+pub struct RadioConfig {
+    // TODO
+}
+
+/// Wrapper around the NRF24 radio driver.
+pub struct Radio {
+    tx: UnboundedSender<(u8, Packet)>,
+}
+
+impl Radio {
+    /// Initializes the radio and returns both radio and the stream of incoming packets.
+    pub async fn init(
+        config: RadioConfig,
+    ) -> Result<(Radio, UnboundedReceiver<(u8, Packet)>), RadioError> {
+        info!("Initializing radio...");
+        let (tx_send, tx_recv) = mpsc::unbounded_channel();
+        let (rx_send, rx_recv) = mpsc::unbounded_channel();
+        let mut task = RadioTask::new(config, tx_recv, rx_send);
+        task.init().await?;
+        info!("radio initialized.");
+
+        // Start a task for packet handling.
+        tokio::spawn(async move {
+            task.run().await;
+        });
+
+        Ok((Radio { tx: tx_send }, rx_recv))
+    }
+
+    /// Sends a packet to the specified device.
+    ///
+    /// The function returns immediately, and the packet might or might not be sent successfully.
+    ///
+    /// # Arguments
+    ///
+    /// * `device_id` - the ID of the targeted device
+    /// * `packet` - the packet to send
+    pub fn send_packet_async(&mut self, device_id: u8, packet: Packet) {
+        // TODO: Can we encrypt the packet here (and deduplicate the code)?
+        self.tx.send((device_id, packet)).unwrap();
+    }
+}
+
+pub fn get_device_location(device_id: u8) -> Location {
+    match device_id {
+        DISPLAY_ID => Location::Bedroom,
+        WEATHER_STATION_0_ID => Location::Livingroom,
+        WEATHER_STATION_1_ID => Location::Bathroom,
+        _ => Location::Livingroom,
+    }
+}
+
+fn get_key(device_id: u8) -> Option<&'static [u8]> {
+    match device_id {
+        DISPLAY_ID => Some(&DISPLAY_KEY),
+        WEATHER_STATION_0_ID => Some(&WEATHER_STATION_0_KEY),
+        WEATHER_STATION_1_ID => Some(&WEATHER_STATION_1_KEY),
+        _ => None,
+    }
+}

base-station/software/src/radio/nrfstick.rs

+use std::convert::TryInto;
+use std::io;
+use std::time::Duration;
+
+use futures_util::stream::StreamExt;
+use log::{error, info};
+use nrf24l01_stick_driver::{
+    Configuration, CrcMode, DataRate, Receiver, MAX_PAYLOAD_LEN, NRF24L01,
+};
+use protocol::Packet;
+use rand::Rng;
+use tokio::select;
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+use tokio::time::delay_for;
+
+use super::{get_key, RadioConfig};
+
+pub struct RadioTask {
+    config: super::RadioConfig,
+    nrf: Option<Receiver>,
+
+    tx: UnboundedReceiver<(u8, Packet)>,
+    rx: UnboundedSender<(u8, Packet)>,
+}
+
+impl RadioTask {
+    pub fn new(
+        config: RadioConfig,
+        tx: UnboundedReceiver<(u8, Packet)>,
+        rx: UnboundedSender<(u8, Packet)>,
+    ) -> RadioTask {
+        RadioTask {
+            config,
+            nrf: None,
+            tx,
+            rx,
+        }
+    }
+
+    pub async fn init(&mut self) -> Result<(), RadioError> {
+        let mut config = Configuration::default();
+        config.channel = 0x32;
+        config.rate = DataRate::R2Mbps;
+        config.power = 3;
+        config.crc = Some(CrcMode::OneByte);
+        config.auto_retransmit_delay_count = Some((250, 3));
+        // TODO: Auto ACK
+
+        let mut nrf24l01 = NRF24L01::open_default(config)
+            .await
+            .expect("could not open device");
+        nrf24l01
+            .set_receive_addr(
+                Some((&[0xb3u8, 0xb3u8, 0xb3u8, 0xb3u8, 0x00u8] as &[u8]).into()),
+                None,
+                None,
+                None,
+                None,
+            )
+            .await
+            .expect("could not set receive address");
+        self.nrf = Some(nrf24l01.receive().await.expect("could not start receiving"));
+
+        Ok(())
+    }
+
+    pub async fn run(&mut self) {
+        loop {
+            let e = self.run_with_initialized_radio().await;
+            error!("Error in radio task: {:?}", e);
+            self.nrf = None;
+            // Try to reinitialize the radio.
+            loop {
+                info!("Trying to reinitialize radio: {:?}", e);
+                match self.init().await {
+                    Ok(_) => break,
+                    Err(e) => error!("Radio reinitialization failed: {:?}", e),
+                }
+                delay_for(Duration::from_secs(3)).await;
+            }
+        }
+    }
+
+    async fn run_with_initialized_radio(&mut self) -> Result<(), RadioError> {
+        // Wait for an RX interrupt of until we have to send a packet.
+        loop {
+            select! {
+                packet = self.nrf.as_mut().unwrap().receive() => {
+                    let packet = packet?;
+                    info!(
+                        "packet received on pipe {}: {:x?}, {}",
+                        packet.pipe,
+                        packet.payload,
+                        packet.payload.len()
+                    );
+                    if packet.payload.len() != 32 {
+                        continue;
+                    }
+
+                    let mut payload: [u8; 32] = packet.payload[0..32].try_into().unwrap();
+                    self.handle_packet(&mut payload).await;
+                },
+                packet = self.tx.next() => {
+                    let (device_id, packet) = packet.unwrap();
+                    // Switch to TX mode and send the packet.
+                    self.send_packet(device_id, packet).await?;
+                },
+            }
+        }
+    }
+
+    async fn handle_packet(&mut self, packet: &mut [u8]) {
+        // Get the key of the device.
+        let device_id = packet[0];
+        let key = match get_key(device_id) {
+            Some(k) => k,
+            None => {
+                info!("packet from unknown device {:02x}", device_id);
+                return;
+            }
+        };
+
+        // Decode the packet.
+        let packet = match Packet::decrypt_and_decode(key, packet) {
+            Err(e) => {
+                info!(
+                    "invalid packet from device {:02x}, error {:?}",
+                    device_id, e
+                );
+                return;
+            }
+            Ok(p) => p,
+        };
+        // TODO: For all packets except for salt requests, check whether the
+        // salt was incremented to prevent replay attacks.
+        // TODO: Also check whether the device bit in the salt is 0.
+
+        info!("packet from {}: {:?}", device_id, packet);
+
+        self.rx.send((device_id, packet)).unwrap();
+    }
+
+    async fn send_packet(&mut self, device_id: u8, packet: Packet) -> Result<(), RadioError> {
+        let salt = rand::thread_rng().gen::<u64>();
+        // TODO: Fix salt (device bit, device id).
+        let mut encoded = [0u8; 32];
+        let key = get_key(device_id);
+
+        info!("sending packet: {:?}", packet);
+        if packet.encode_and_encrypt(key.unwrap(), salt, &mut encoded) {
+            match self
+                .nrf
+                .as_mut()
+                .unwrap()
+                .send(
+                    (&[0xb3u8, 0xb3u8, 0xb3u8, 0xb3u8, device_id][..]).into(),
+                    &encoded,
+                )
+                .await
+            {
+                Ok(()) => {}
+                Err(e) => println!("could not send: {:?}", e), // TODO: Distinguish between packet loss and other errors!
+            }
+        } else {
+            info!("could not encode packet {:?}", packet);
+        }
+        Ok(())
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum RadioError {
+    #[error("I/O error")]
+    Io(#[from] io::Error),
+    #[error("radio error: {0:?}")]
+    Radio(#[from] nrf24l01_stick_driver::Error),
+}