base-station: Power-cycle module until it responds.

base-station/software/src/radio.rs

 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
+use embedded_hal::blocking::spi::Transfer;
+use embedded_hal::digital::v2::OutputPin;
 use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, NRF24L01};
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
 use linux_embedded_hal::sysfs_gpio::Direction;
         // - MOSI: PC0
         // - MISO: PC1
         // - SCK: PC2
-
-        // Configure SPI.
-        let mut spi = Spidev::open("/dev/spidev0.0").unwrap();
-        let options = SpidevOptions::new()
-            .bits_per_word(8)
-            .max_speed_hz(500_000)
-            .mode(SpiModeFlags::SPI_MODE_0)
-            .build();
-        spi.configure(&options).unwrap();
-        let spi = EmbeddedHalSpidev::from(spi);
+        // - Power (active low): PG11
 
         // Configure the GPIOs.
+        let pwr_nr = get_pin_number('G', 11);
+        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 ce = Pin::new(ce_nr);
+        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 cs = Pin::new(cs_nr);
+        let mut cs = Pin::new(cs_nr);
         cs.export().unwrap();
         cs.set_direction(Direction::Out).unwrap();
+        cs.set_high().unwrap();
         let irq_nr = get_pin_number('G', 9);
         let irq = Pin::new(irq_nr);
         irq.export().unwrap();
         irq.set_direction(Direction::In).unwrap();
 
+        // Configure SPI.
+        let mut spi = Spidev::open("/dev/spidev0.0").unwrap();
+        let options = SpidevOptions::new()
+            .bits_per_word(8)
+            .max_speed_hz(500_000)
+            .mode(SpiModeFlags::SPI_MODE_0)
+            .build();
+        spi.configure(&options).unwrap();
+        let mut spi = EmbeddedHalSpidev::from(spi);
+
+        // 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();
+            let mut read_aw = [0x03, 0x00];
+            if spi.transfer(&mut read_aw).is_ok() {
+                // Correct address field width?
+                if read_aw[1] >= 0x1 && read_aw[1] <= 0x3 {
+                    break;
+                }
+            }
+        }
+
         // Initialize the radio module.
         let mut nrf24 = NRF24L01::new(ce, cs, spi)?;
         nrf24.set_frequency(0x32)?;
             .map_err(|(_, e)| Error::Radio(e))?;
         let mut encoded = [0u8; 32];
         let key = get_key(device_id);
+        // TODO: Check whether the packet arrived.
         if packet.encode_and_encrypt(key.unwrap(), salt, &mut encoded) {
             tx.set_tx_addr(&[0xB3, 0xB3, 0xB3, 0xB3, device_id])
                 .unwrap();
             tx.set_rx_addr(0, &[0xB3, 0xB3, 0xB3, 0xB3, device_id])
                 .unwrap();
             tx.send(&encoded).unwrap();
-        // TODO: Check whether the packet arrived.
         } else {
             info!("could not encode packet {:?}", packet);
         }
                 .rx()
                 .map_err(|(_, e)| Error::Radio(e))?,
         );
+        info!("packet sent: {:?}", packet);
         Ok(())
     }
 }