main.rs

#![no_std]
#![no_main]

use core::{borrow::Borrow, cell::RefCell, time::Duration};
use cortex_m::interrupt::{Mutex, free};
use panic_rtt_target as _;
use rtt_target::rprintln;
use stm32wl_hal::{
    gpio::{Level, Output, PortA, PortB},
    pac, pac::{interrupt},
    subghz::{
        AddrComp, CodingRate, CrcType, HeaderType, LoRaBandwidth, LoRaModParams,
        LoRaPacketParams, LoRaSyncWord, PaConfig, PaSel, PacketType, PreambleDetection, RfFreq, RegMode,
        SpreadingFactor, SubGhz, Timeout, CfgDioIrq, IrqLine, Irq, StandbyClk, Status, StatusMode
    },

};

pub const PREAMBLE_LEN: u16 = 10;

const PKT_PARAMS: LoRaPacketParams = LoRaPacketParams::new()
    .set_preamble_len(PREAMBLE_LEN)
    .set_header_type(HeaderType::Fixed)
    .set_payload_len(17)
    .set_crc_en(false)
    .set_invert_iq(false);

const MOD_PARAMS: LoRaModParams = LoRaModParams::new()
    .set_bw(LoRaBandwidth::Bw125)
    .set_sf(SpreadingFactor::Sf9)
    .set_cr(CodingRate::Cr45);

const IRQ_CFG: CfgDioIrq = CfgDioIrq::new()
    .irq_enable(IrqLine::Global, Irq::RxDone)
    .irq_enable(IrqLine::Global, Irq::Timeout);

// DR=3, CR=1

static SUBGHZ: Mutex<RefCell<Option<SubGhz>>> = Mutex::new(RefCell::new(None));

#[cortex_m_rt::entry]
fn main() -> ! {
    let channels = rtt_target::rtt_init! {
        up: {
            0: {
                size: 2048
                mode: NoBlockTrim
                name: "Terminal"
            }
        }
    };
    rtt_target::set_print_channel(channels.up.0);
    rprintln!("Starting up...");

    let mut dp: pac::Peripherals = pac::Peripherals::take().unwrap();

    let gpioa: PortA = PortA::split(dp.GPIOA, &mut dp.RCC);
    let gpiob: PortB = PortB::split(dp.GPIOB, &mut dp.RCC);

    let mut rcc = dp.RCC;
    let pwr = dp.PWR;

    // enable SubGHz SPI
    rcc.apb3enr.modify(|_, w| w.subghzspien().set_bit());
    rcc.apb3enr.read(); // Delay after an RCC peripheral clock enabling
    rcc.csr.modify(|_, w| w.rfrst().set_bit());
    rcc.csr.modify(|_, w| w.rfrst().clear_bit());
    pwr.subghzspicr.write(|w| w.nss().clear_bit());
    pwr.subghzspicr.write(|w| w.nss().set_bit());
    pwr.cr3.modify(|_, w| w.ewrfbusy().set_bit());
    pwr.scr.write(|w| w.cwrfbusyf().set_bit());

    rcc.ahb2enr.modify(|_, w|
        w
            .gpioaen().set_bit()
            .gpioben().set_bit()
            .gpiocen().set_bit()
    );

    // set RF switch to RX, PA4=1, PA5=0 (lora-e5 dev board)
    Output::default(gpioa.pa4).set_level_high();
    Output::default(gpioa.pa5).set_level_low();

    let mut sg = SubGhz::new(dp.SPI3, &mut rcc);

    rprintln!("{:?}", sg.status());

    sg.set_standby(StandbyClk::Rc).unwrap();
    sg.poll_not_busy();

    let status: Status = sg.status().unwrap();
    rprintln!("{:?}", sg.status());

    assert_eq!(status.mode(), Ok(StatusMode::StandbyRc));

    sg.set_regulator_mode(RegMode::Ldo).unwrap();
    sg.set_buffer_base_address(0, 0).unwrap();
    sg.set_packet_type(PacketType::LoRa).unwrap();
    sg.set_lora_packet_params(&PKT_PARAMS).unwrap();
    sg.set_lora_sync_word(LoRaSyncWord::Public).unwrap();
    sg.set_rf_frequency(&RfFreq::F868).unwrap();
    sg.set_lora_mod_params(&MOD_PARAMS).unwrap();

    //unsafe { pac::NVIC::unmask(pac::Interrupt::RADIO_IRQ_BUSY); }

    sg.set_rx(Timeout::from_duration_sat(Duration::from_millis(1000))).unwrap();
    sg.set_irq_cfg(&IRQ_CFG).unwrap();

    let (status, irq_status) = sg.irq_status().unwrap();
    rprintln!("{} {}", status, irq_status);


    // free(|cs| {
    //     let sghz = SUBGHZ.borrow(cs);
    //     sghz.replace(Some(sg));
    // });


    rprintln!("Starting loop");

    loop {
        let (status, irq_status) = sg.irq_status().unwrap();
        rprintln!("{} {}", status, irq_status);
        if irq_status & Irq::RxDone.mask() != 0 {
            let (status, len, ptr) = sg.rx_buffer_status().unwrap();
            rprintln!("{} {} {}", status, len, ptr);
            sg.clear_irq_status(Irq::RxDone.mask() | Irq::Timeout.mask());
        }
    }
}

// #[interrupt]
// fn RADIO_IRQ_BUSY() {
//     rprintln!("IRQ called");
//     free(|cs| {
//         if let Some(sg) = SUBGHZ.borrow(cs).borrow_mut().as_mut() {
//             let (n, status) = sg.irq_status().unwrap();
//             rprintln!("{:?}", status);

//             sg.clear_irq_status(Irq::RxDone.mask() | Irq::Timeout.mask()).unwrap();
//         }
//     });
// }