Merge branch 'pi_spi' into 'master'

pi spi working

See merge request !2

.cargo/config

+[target.arm-unknown-linux-gnueabi]
+linker = "arm-linux-gnueabi-gcc"
\ No newline at end of file

Cargo.toml

@@ -23,9 +23,12 @@ bitvec = "1.0.1"
 crc = "3.0.1"
 image = "0.24.6"
 kiss-tnc = "0.2.2"
+rppal = { version = "0.14.1", features = ["hal"] }
 serde = { version = "1.0.160", features = ["derive"] }
 serial = "0.4.0"
 sha3 = "0.10.7"
 subprocess = "0.2.9"
 tokio = { version = "1.27.0", features = ["full"] }
 toml = "0.7.3"
+rf4463 = { path = "../rf4463" }
+thread-priority = "0.13.1"

src/control.rs

@@ -5,13 +5,14 @@ use std::{
 };
 
 use anyhow::Context;
+use thread_priority::ThreadPriority;
 
 use crate::{
     aprs::CommandHandler,
     config::Config,
     img::ImgManager,
     packet::{FecPacket, Packet},
-    radio::UartRadio,
+    radio::{SpiRadio, UartRadio},
     ssdv::ssdv_encode,
 };
 
@@ -80,7 +81,10 @@ impl Controller {
 
     // manages our transceiver
     fn tx_thread(image_rx: Receiver<FecPacket>, telem_rx: Receiver<Packet>) {
-        let mut radio = UartRadio::new("/dev/ttyAMA0").expect("Could not initialize radio");
+        ThreadPriority::Max.set_for_current().unwrap();
+
+        //let mut radio = UartRadio::new("/dev/ttyAMA0").expect("Could not initialize radio");
+        let mut radio = SpiRadio::new().expect("Could not initialize radio");
 
         let mut text_msg_id = 0;
         loop {
@@ -93,11 +97,9 @@ impl Controller {
             }
 
             if let Ok(img) = image_rx.try_recv() {
-                println!("start send packet");
                 if let Err(e) = radio.send_packet(&img) {
                     eprintln!("Could not send packet: {}", e);
                 }
-                println!("end send packet");
             } else {
                 thread::sleep(Duration::from_millis(5));
             }

src/radio.rs

+use rf4463::{
+    config::{RADIO_CONFIG_500_2, RADIO_CONFIG_5_4},
+    Rf4463, TransferError,
+};
+use rppal::{
+    gpio::{Gpio, OutputPin},
+    hal::Delay,
+    spi::{self, Bus, Mode, SlaveSelect, Spi},
+};
 use serial::{unix::TTYPort, BaudRate::BaudOther, SerialPort};
 use std::{
     io::{Read, Write},
@@ -42,3 +51,61 @@ impl UartRadio {
         Ok(())
     }
 }
+
+pub struct SpiRadio {
+    radio: Rf4463<Spi, OutputPin, OutputPin, Delay>,
+    failures: u32,
+    total: u32,
+}
+
+impl SpiRadio {
+    pub fn new() -> anyhow::Result<Self> {
+        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 10_000_000, Mode::Mode0)?;
+        let gpio = Gpio::new()?;
+        let sdn = gpio.get(22)?.into_output();
+        let cs = gpio.get(24)?.into_output();
+
+        let delay = Delay::new();
+
+        // todo fix this unwrap
+        let radio = Rf4463::new(spi, sdn, cs, delay, &mut RADIO_CONFIG_500_2.clone()).unwrap();
+
+        Ok(Self {
+            radio,
+            failures: 0,
+            total: 0,
+        })
+    }
+
+    pub fn send_packet(&mut self, packet: &FecPacket) -> anyhow::Result<()> {
+        self.total += 1;
+
+        // todo fix this unwrap
+        if self.actually_send(packet, 3).is_err() {
+            self.failures += 1;
+
+            println!(
+                "{} % fail rate",
+                (self.failures as f64) / (self.total as f64)
+            );
+        }
+
+        Ok(())
+    }
+
+    fn actually_send(
+        &mut self,
+        packet: &FecPacket,
+        tries: u32,
+    ) -> Result<(), TransferError<spi::Error>> {
+        if tries == 0 {
+            return Err(TransferError::FifoOverflow);
+        }
+
+        match self.radio.tx(&mut packet.0.clone()) {
+            Ok(()) => Ok(()),
+            Err(TransferError::FifoOverflow) => self.actually_send(packet, tries - 1),
+            Err(e) => Err(e),
+        }
+    }
+}