base-station: Reimplement radio code.

base-station/software/Cargo.lock

  "embedded-hal",
  "embedded-nrf24l01",
  "env_logger",
+ "futures",
+ "futures-util",
  "linux-embedded-hal",
  "log",
  "mqtt-protocol",
  "protocol",
  "rand",
+ "sysfs_gpio",
  "thiserror",
  "tokio",
 ]
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 
+[[package]]
+name = "futures"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e05b85ec287aac0dc34db7d4a569323df697f9c55b99b15d6b4ef8cde49f613"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f366ad74c28cca6ba456d95e6422883cfb4b252a83bed929c83abfdbbf2967d5"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
 [[package]]
 name = "futures-core"
 version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59f5fff90fd5d971f936ad674802482ba441b6f09ba5e15fd8b39145582ca399"
 
+[[package]]
+name = "futures-executor"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d6bb888be1153d3abeb9006b11b02cf5e9b209fda28693c31ae1e4e012e314"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0b5a30a4328ab5473878237c447333c093297bded83a4983d10f4deea240d39"
+dependencies = [
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f2032893cb734c7a05d85ce0cc8b8c4075278e93b24b66f9de99d6eb0fa8acc"
+
+[[package]]
+name = "futures-task"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdb66b5f09e22019b1ab0830f7785bcea8e7a42148683f99214f73f8ec21a626"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "futures-util"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8764574ff08b701a084482c3c7031349104b07ac897393010494beaa18ce32c6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project",
+ "pin-utils",
+ "proc-macro-hack",
+ "proc-macro-nested",
+ "slab",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.14"
  "libc",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c601810575c99596d4afc46f78a678c80105117c379eb3650cf99b8a21ce5b"
+
+[[package]]
+name = "pin-project"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbe07cee13ca15295ce93a5b1094d63e0420603e91ffda4f86d4478988916f2"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b789ec51a10e5a985a9863ef8791412523334d6240fab2cf40dd9fd47496dc6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7505eeebd78492e0f6108f7171c4948dbb120ee8119d9d77d0afa5469bef67f"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b"
 
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d659fe7c6d27f25e9d80a1a094c223f5246f6a6596453e09d7229bf42750b63"
+
+[[package]]
+name = "proc-macro-nested"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e946095f9d3ed29ec38de908c22f95d9ac008e424c7bcae54c75a79c527c694"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.10"
 [[package]]
 name = "sysfs_gpio"
 version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24961a55846623d8e4f6cec38718945116fed8d6970336a7110710a07aa9b5d1"
+source = "git+https://github.com/mgottschlag/rust-sysfs-gpio?branch=new-futures#c412bdc6d18910db8d66cea3db2dbad96af780b2"
 dependencies = [
+ "futures",
+ "mio",
  "nix",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]

base-station/software/Cargo.toml

 thiserror = "1.0"
 protocol = { path = "../../common/rust-protocol" }
 rand = "0.7.3"
-tokio = { version="0.2", features=[ "full" ] }
+tokio = { version = "0.2", features = [ "full" ] }
+sysfs_gpio = { version = "0.5.4", features = [ "use_tokio" ] }
+futures = "0.3.5"
+futures-util = "0.3.5"
+
+[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.
 
 use std::env;
-use std::io;
 use std::sync::Arc;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use log::{error, info};
 use protocol::{GetValues, Packet, Report, Value, Values};
 use rand::{rngs::ThreadRng, Rng};
 use tokio::sync::Mutex;
+use tokio::time::delay_for;
 
 use current::CurrentValues;
 use publish::Publish;
     }
 
     async fn handle_get_salt(&mut self, device_id: u8) {
+        delay_for(Duration::from_millis(1)).await;
         let salt = (self.rng.gen::<u64>() & !0xff & !(1 << 63)) | device_id as u64;
         // TODO: Store the salt as the expected salt in Radio.
         self.radio
         }
     }
 }*/
-
-/*pub(crate) struct SensorUpdate {
-    location: u32,
-    data: Vec<SensorData>,
-}
-
-pub(crate) enum SensorData {
-    Temperature(f32),
-    Humidity(f32),
-    Pressure(f32),
-}*/
-
-#[derive(thiserror::Error, Debug)]
-pub(crate) enum Error {
-    #[error("I/O error")]
-    Io(#[from] io::Error),
-    #[error("radio error: {0:?}")]
-    Radio(embedded_nrf24l01::Error<std::io::Error>),
-}
-
-impl From<embedded_nrf24l01::Error<std::io::Error>> for Error {
-    fn from(e: embedded_nrf24l01::Error<std::io::Error>) -> Self {
-        Error::Radio(e)
-    }
-}

base-station/software/src/radio.rs

 //! Wrapper around the NRF24 driver which provides tokio-compatible asynchronous interfaces.
 
-/*use std::convert::TryInto;
-use std::sync::mpsc;
-use std::thread;
-use std::thread::sleep;
-use std::time::{Duration, Instant};*/
+use std::convert::TryInto;
+use std::io;
+use std::time::Duration;
 
-/*use embedded_hal::blocking::spi::Transfer;
+use embedded_hal::blocking::spi::Transfer;
 use embedded_hal::digital::v2::OutputPin;
 use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, NRF24L01};
+use futures_util::stream::StreamExt;
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
-use linux_embedded_hal::sysfs_gpio::Direction;
-use linux_embedded_hal::sysfs_gpio::Error as GpioError;
+use linux_embedded_hal::sysfs_gpio::{Direction, Edge, Error as GpioError};
 use linux_embedded_hal::Pin;
 use log::{error, info};
-use rand::rngs::ThreadRng;
-use rand::Rng;*/
 use protocol::{Location, Packet};
-use tokio::sync::mpsc::UnboundedReceiver;
+use rand::Rng;
+use tokio::select;
+use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
+use tokio::time::delay_for;
 
-/*use super::spi::EmbeddedHalSpidev;
-use super::Error;
-use super::{SensorData, SensorUpdate};*/
+use super::spi::EmbeddedHalSpidev;
 
 const DISPLAY_ID: u8 = 0x20;
-//const DISPLAY_KEY: [u8; 16] = include!("../../../common/display_key.txt");
+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_0_KEY: [u8; 16] = include!("../../../common/weather_station_0_key.txt");
 
 /// Hardware configuration.
 pub struct RadioConfig {
 
 /// Wrapper around the NRF24 radio driver.
 pub struct Radio {
-    // TODO
+    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,
+        config: RadioConfig,
     ) -> Result<(Radio, UnboundedReceiver<(u8, Packet)>), RadioError> {
-        // TODO
-        panic!("Not yet implemented.");
+        info!("Initializing radio...");
+        let (tx_send, tx_recv) = mpsc::unbounded_channel();
+        let (rx_send, rx_recv) = mpsc::unbounded_channel();
+        let mut task = 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.
     ///
     /// * `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
-        panic!("Not yet implemented.");
+    pub fn send_packet_async(&mut self, device_id: u8, packet: Packet) {
+        self.tx.send((device_id, packet)).unwrap();
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-pub enum RadioError {
-    // TODO
-}
-
-/*pub(crate) fn start(updates: mpsc::Sender<SensorUpdate>) {
-    // TODO: Channels for sensor readings.
-    thread::spawn(move || {
-        // Whenever a error occurs, reinitialize the radio module shortly later.
-        loop {
-            match radio_thread(&updates) {
-                Ok(()) => {}
-                Err(e) => {
-                    error!("Radio error: {:?}", e);
-                }
-            }
-            thread::sleep(Duration::from_secs(3));
-        }
-    });
-}
-
-fn radio_thread(updates: &mpsc::Sender<SensorUpdate>) -> Result<(), Error> {
-    let mut radio = RadioImpl::init(updates)?;
-    radio.run_loop()?;
-    Ok(())
-}
-
-struct RadioImpl<'a> {
-    rx: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
-    updates: &'a mpsc::Sender<SensorUpdate>,
-    rng: ThreadRng,
+struct RadioTask {
+    config: RadioConfig,
+    nrf24: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
+    irq: Option<Pin>,
+    tx: UnboundedReceiver<(u8, Packet)>,
+    rx: UnboundedSender<(u8, Packet)>,
 }
 
-impl<'a> RadioImpl<'a> {
-    fn init(updates: &'a mpsc::Sender<SensorUpdate>) -> Result<RadioImpl<'a>, Error> {
-        info!("Initializing radio...");
-
+impl RadioTask {
+    async fn init(&mut self) -> Result<(), RadioError> {
         // The NRF module is connected as follows:
         // - CE: PA1
         // - CS: PG8
         let irq = Pin::new(irq_nr);
         irq.export().unwrap();
         irq.set_direction(Direction::In).unwrap();
+        irq.set_edge(Edge::FallingEdge)?;
 
         // Configure SPI.
         let mut spi = Spidev::open("/dev/spidev0.0").unwrap();
 
         // HACK: Cycle power until transfers to the module seem to work.
         loop {
-            pwr.set_high().unwrap();
-            sleep(Duration::from_millis(10));
-            pwr.set_low().unwrap();
-            sleep(Duration::from_millis(10));
-            cs.set_low().unwrap();
+            pwr.set_high()?;
+            delay_for(Duration::from_millis(10)).await;
+            pwr.set_low()?;
+            delay_for(Duration::from_millis(10)).await;
+            cs.set_low()?;
             let mut read_aw = [0x03, 0x00];
             if spi.transfer(&mut read_aw).is_ok() {
                 // Correct address field width?
                     break;
                 }
             }
+            println!("radio not yet responding correctly ({:x})...", read_aw[1]);
+            delay_for(Duration::from_millis(1000)).await;
         }
 
         // Initialize the radio module.
         nrf24.set_rf(DataRate::R2Mbps, 3)?;
         nrf24.set_crc(Some(CrcMode::OneByte))?;
         nrf24.set_auto_retransmit(250, 3)?;
-        nrf24.set_pipes_rx_enable(&[true, true, false, false, false, false])?; // TODO enable pipe 0 once the base station receives messages
-        nrf24
-            .set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
-            .unwrap();
-        nrf24
-            .set_rx_addr(1, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])
-            .unwrap();
-        nrf24.flush_rx().unwrap();
-        nrf24.flush_tx().unwrap();
-        nrf24.set_auto_ack(&[true; 6]).unwrap();
-        info!("auto ack: {:?}", nrf24.get_auto_ack().unwrap());
-        nrf24.set_pipes_rx_lengths(&[Some(32); 6]).unwrap();
-
-        info!("width: {}", nrf24.get_address_width().unwrap());
-
-        let rx = nrf24.rx().unwrap();
-
-        Ok(RadioImpl {
-            rx: Some(rx),
-            updates,
-            rng: rand::thread_rng(),
-        })
-    }
+        nrf24.set_pipes_rx_enable(&[true, true, false, false, false, false])?;
+        nrf24.set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])?;
+        nrf24.set_rx_addr(1, &[0xB3, 0xB3, 0xB3, 0xB3, 0x00])?;
+        nrf24.flush_rx()?;
+        nrf24.flush_tx()?;
+        nrf24.set_auto_ack(&[true; 6])?;
+        info!("auto ack: {:?}", nrf24.get_auto_ack()?);
+        nrf24.set_pipes_rx_lengths(&[Some(32); 6])?;
+
+        self.nrf24 = Some(nrf24.rx().unwrap());
+        self.irq = Some(irq);
 
-    fn run_loop(&mut self) -> Result<(), Error> {
-        let mut start = Instant::now();
+        Ok(())
+    }
 
-        // Receive data.
-        info!("Starting to receive:");
+    async fn run(&mut self) {
         loop {
-            sleep(Duration::from_millis(1));
-            let rx = self.rx.as_mut().unwrap();
-            if let Some(pipe) = rx.can_read().unwrap() {
-                let payload = rx.read().unwrap();
-                info!(
-                    "packet received on pipe {}: {:x?}, {}",
-                    pipe,
-                    payload.as_ref(),
-                    payload.len()
-                );
-                if payload.len() != 32 {
-                    continue;
+            let e = self.run_with_initialized_radio().await;
+            error!("Error in radio task: {:?}", e);
+            self.nrf24 = 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;
+            }
+        }
+    }
 
-                let mut payload: [u8; 32] = payload.as_ref().try_into().unwrap();
-                self.handle_packet(&mut payload)?;
-
-                let end = Instant::now();
-                let elapsed = end.duration_since(start);
-                info!("Debug: {:?}", elapsed);
-                start = end;
+    async fn run_with_initialized_radio(&mut self) -> Result<(), RadioError> {
+        // Wait for an RX interrupt of until we have to send a packet.
+        let mut irq_states = self.irq.as_mut().unwrap().get_value_stream().unwrap();
+        loop {
+            select! {
+                _pin_value = irq_states.next() => {
+                    // Try to receive until there are no packets left in the RX fifo and until the
+                    // interrupt pin is high again.
+                    self.receive_packets().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?;
+                },
             }
         }
     }
 
-    fn handle_packet(&mut self, payload: &mut [u8]) -> Result<(), Error> {
+    async fn receive_packets(&mut self) -> Result<(), RadioError> {
+        let rx = self.nrf24.as_mut().unwrap();
+        let pipe = match rx.can_read()? {
+            Some(p) => p,
+            None => return Ok(()),
+        };
+        let payload = rx.read()?;
+        info!(
+            "packet received on pipe {}: {:x?}, {}",
+            pipe,
+            payload.as_ref(),
+            payload.len()
+        );
+        if payload.len() != 32 {
+            return Ok(());
+        }
+
+        let mut payload: [u8; 32] = payload.as_ref().try_into().unwrap();
+        self.handle_packet(&mut payload).await;
+
+        Ok(())
+    }
+
+    async fn handle_packet(&mut self, packet: &mut [u8]) {
         // Get the key of the device.
-        let device_id = payload[0];
+        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 Ok(());
+                return;
             }
         };
 
         // Decode the packet.
-        let packet = match Packet::decrypt_and_decode(key, payload) {
+        let packet = match Packet::decrypt_and_decode(key, packet) {
             Err(e) => {
                 info!(
                     "invalid packet from device {:02x}, error {:?}",
                     device_id, e
                 );
-                return Ok(());
+                return;
             }
             Ok(p) => p,
         };
 
         info!("packet from {}: {:?}", device_id, packet);
 
-        match packet {
-            Packet::GetSalt => {
-                self.send_salt(device_id)?;
-            }
-            Packet::Salt(_) => {
-                error!("received Salt packet from device.");
-            }
-            Packet::Report(payload) => {
-                let location = get_location(device_id);
-                let count = payload.count;
-                for i in 0..count {
-                    match payload.values[i as usize] {
-                        Value::Invalid => {}
-                        Value::Time(_) => {
-                            error!("device tried to report a time");
-                        }
-                        Value::Temperature(temperature) => {
-                            let temperature = temperature as f32 / 10.0;
-                            info!("{:?} temperature: {} °C", location, temperature);
-                        }
-                        Value::Pressure(pressure) => {
-                            let pressure = pressure as f32 / 100.0;
-                            info!("{:?} pressure: {} HPa", location, pressure);
-                        }
-                        Value::Humidity(humidity) => {
-                            let humidity = humidity as f32 / 100.0;
-                            info!("{:?} humidity: {}%", location, humidity);
-                        }
-                    }
-                }
-                // TODO: Send values via MQTT
-                /*
-                updates
-                    .send(SensorUpdate {
-                        location: 0,
-                        data: vec![
-                            SensorData::Temperature(temperature),
-                            SensorData::Pressure(pressure),
-                            SensorData::Humidity(humidity),
-                        ],
-                    })
-                    .unwrap();
-                */
-            }
-            Packet::GetValues(_payload) => {
-                error!("GetValues not yet implemented.");
-                // TODO
-            }
-            Packet::Values(_payload) => {
-                error!("received Values packet from device.");
-            }
-        }
-        Ok(())
+        self.rx.send((device_id, packet)).unwrap();
     }
 
-    fn send_salt(&mut self, device_id: u8) -> Result<(), Error> {
-        let salt = (self.rng.gen::<u64>() & !0xff & !(1 << 63)) | device_id as u64;
-        let packet = Packet::Salt(salt);
-        self.send_packet(device_id, packet)
-    }
-
-    fn send_packet(&mut self, device_id: u8, packet: Packet) -> Result<(), Error> {
-        let salt = self.rng.gen::<u64>();
+    async fn send_packet(&mut self, device_id: u8, packet: Packet) -> Result<(), RadioError> {
+        let salt = rand::thread_rng().gen::<u64>();
         let mut tx = self
-            .rx
+            .nrf24
             .take()
             .unwrap()
             .standby()
             .tx()
-            .map_err(|(_, e)| Error::Radio(e))?;
+            .map_err(|(_, e)| RadioError::Radio(e))?;
         let mut encoded = [0u8; 32];
         let key = get_key(device_id);
         // TODO: Check whether the packet arrived.
         } else {
             info!("could not encode packet {:?}", packet);
         }
-        self.rx = Some(
+        self.nrf24 = Some(
             tx.standby()
-                .map_err(Error::Radio)?
+                .map_err(RadioError::Radio)?
                 .rx()
-                .map_err(|(_, e)| Error::Radio(e))?,
+                .map_err(|(_, e)| RadioError::Radio(e))?,
         );
         info!("packet sent: {:?}", packet);
         Ok(())
     }
-}*/
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum RadioError {
+    #[error("I/O error")]
+    Io(#[from] io::Error),
+    #[error("GPIO error")]
+    Gpio(#[from] GpioError),
+    #[error("radio error: {0:?}")]
+    Radio(embedded_nrf24l01::Error<std::io::Error>),
+}
+
+impl From<embedded_nrf24l01::Error<std::io::Error>> for RadioError {
+    fn from(e: embedded_nrf24l01::Error<std::io::Error>) -> Self {
+        RadioError::Radio(e)
+    }
+}
 
 pub fn get_device_location(device_id: u8) -> Location {
     match device_id {
     }
 }
 
-/*fn get_key(device_id: u8) -> Option<&'static [u8]> {
+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),
 
 fn get_pin_number(c: char, n: u64) -> u64 {
     (c as u64 - 'A' as u64) * 32 + n
-}*/
+}