Create dart-70 firmware

1 files changed, 511 insertions, 0 deletions

diff --git a/sw/dart-70/src/main.rs b/sw/dart-70/src/main.rs
new file mode 100644
index 0000000..425f1c6
--- /dev/null
+++ b/sw/dart-70/src/main.rs
@@ -0,0 +1,511 @@
+/*
+    The MIT License (MIT)
+
+    Copyright (c) 2023 Matthias P. Braendli
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+
+#![no_main]
+#![no_std]
+
+use core::mem::MaybeUninit;
+use cortex_m_rt::ExceptionFrame;
+use cortex_m_semihosting::hprintln;
+use panic_semihosting as _;
+
+use stm32f1xx_hal::{
+    prelude::*,
+    adc,
+    pac,
+    pac::interrupt,
+    i2c,
+    gpio,
+    gpio::PinState,
+    timer::{CounterHz, Timer, Event},
+    qei::QeiOptions,
+};
+
+use hd44780_driver::{Cursor, CursorBlink, Display, DisplayMode, HD44780};
+
+pub mod ui;
+pub mod cw;
+pub mod state;
+pub mod si_clock;
+pub mod log10f;
+
+use state::*;
+
+const TICKS_PER_SECOND: u32 = 100;
+
+struct SharedWithISR {
+    state: State,
+    last_sequence_state_change: u32,
+    cw_ptt_timestamp: u32,
+    cw_key_n: gpio::gpioa::PA15<gpio::Output<gpio::OpenDrain>>,
+    ui: ui::UI,
+    cw_pwm: cw::CWPWM,
+    cw_keyer: cw::Keyer,
+    cw_paddle_tip: gpio::gpiob::PB8<gpio::Input<gpio::PullUp>>,
+    cw_paddle_ring: gpio::gpiob::PB9<gpio::Input<gpio::PullUp>>,
+    en_rx: gpio::gpiob::PB3<gpio::Output<gpio::PushPull>>,
+    en_tx: gpio::gpiob::PB5<gpio::Output<gpio::PushPull>>,
+    mute_spkr: gpio::gpioa::PA2<gpio::Output<gpio::PushPull>>,
+    mute_micn: gpio::gpioa::PA1<gpio::Output<gpio::PushPull>>,
+    led: gpio::gpiob::PB14<gpio::Output<gpio::OpenDrain>>,
+}
+
+static mut SHARED: MaybeUninit<SharedWithISR> = MaybeUninit::uninit();
+static mut CLOCK_TIMER: MaybeUninit<CounterHz<pac::TIM2>> = MaybeUninit::uninit();
+static mut TICK_COUNTER: MaybeUninit<u32> = MaybeUninit::uninit();
+
+fn ticks_now() -> u32 {
+    cortex_m::interrupt::free(|_cs| unsafe { *TICK_COUNTER.as_ptr() })
+}
+
+fn get_state_copy() -> State {
+    cortex_m::interrupt::free(|_cs| unsafe {
+        (*SHARED.as_ptr()).state.clone()
+    })
+}
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    let mut flash = dp.FLASH.constrain();
+    let rcc = dp.RCC.constrain();
+    let mut afio = dp.AFIO.constrain();
+    let clocks = rcc.cfgr
+        .use_hse(16.MHz())
+        .sysclk(32.MHz())
+        .pclk1(24.MHz())
+        .adcclk(2.MHz())
+        .freeze(&mut flash.acr);
+    let mut delay = cp.SYST.delay(&clocks);
+
+    delay.delay_ms(200u16);
+
+    let mut gpioa = dp.GPIOA.split();
+    let mut gpiob = dp.GPIOB.split();
+    let mut gpioc = dp.GPIOC.split();
+
+    // Buttons as analog inputs (multi-level)
+    let mic_ptt = gpioa.pa3.into_floating_input(&mut gpioa.crl);
+    let vox_ptt_n = gpioa.pa0.into_pull_up_input(&mut gpioa.crl);
+    let btn0 = gpiob.pb1.into_floating_input(&mut gpiob.crl); // BTN0 Button A
+    let btn1 = gpiob.pb0.into_floating_input(&mut gpiob.crl); // BTN1 Button B
+    let btn2 = gpiob.pb12.into_floating_input(&mut gpiob.crh); // BTN2 Button C
+    let btn3 = gpiob.pb13.into_floating_input(&mut gpiob.crh); // BTN3 Button D
+    let pc15 = gpioc.pc15.into_floating_input(&mut gpioc.crh); // ENC BTN
+    let ui = ui::UI::new(mic_ptt, vox_ptt_n, btn0, btn1, btn2, btn3, pc15);
+
+    let cw_pwm = {
+        let pa8 = gpioa.pa8.into_alternate_push_pull(&mut gpioa.crh); // CW PWM output using TIM1 Ch1
+        let pwm = dp.TIM1.pwm_hz(pa8, &mut afio.mapr, cw::SIDETONE_FREQ.Hz(), &clocks);
+        let channel = pwm.split();
+        cw::CWPWM::new(channel)
+    };
+
+    let cw_paddle_tip = gpiob.pb8.into_pull_up_input(&mut gpiob.crh); // CW paddle tip
+    let cw_paddle_ring = gpiob.pb9.into_pull_up_input(&mut gpiob.crh); // CW paddle ring
+
+    let mut s_meter = gpioa.pa5.into_analog(&mut gpioa.crl);
+    let mut adc2 = adc::Adc::adc2(dp.ADC2, clocks);
+    let mut last_s_meter_update_time = 0;
+
+    // Configure PB14 as output. (LED)
+    let mut led = gpiob.pb14.into_open_drain_output(&mut gpiob.crh);
+    led.set_low();
+
+    let (pa15, pb3, _pb4) = afio.mapr.disable_jtag(gpioa.pa15, gpiob.pb3, gpiob.pb4);
+    let cw_key_n = pa15.into_open_drain_output_with_state(&mut gpioa.crh, PinState::High);
+
+    let en_rx = pb3.into_push_pull_output_with_state(&mut gpiob.crl, PinState::Low);
+    let en_tx = gpiob.pb5.into_push_pull_output_with_state(&mut gpiob.crl, PinState::Low);
+
+    let mute_spkr = gpioa.pa2.into_push_pull_output_with_state(&mut gpioa.crl, PinState::Low);
+    let mute_micn = gpioa.pa1.into_push_pull_output_with_state(&mut gpioa.crl, PinState::Low);
+
+    let c1 = gpioa.pa6;
+    let c2 = gpioa.pa7;
+
+    let qei = Timer::new(dp.TIM3, &clocks)
+        .qei((c1, c2), &mut afio.mapr, QeiOptions::default());
+
+    // Configure I2C2 for display
+    let scl2 = gpiob.pb10.into_alternate_open_drain(&mut gpiob.crh);
+    let sda2 = gpiob.pb11.into_alternate_open_drain(&mut gpiob.crh);
+
+    let i2c2 = i2c::BlockingI2c::i2c2(
+        dp.I2C2,
+        (scl2, sda2),
+        i2c::Mode::Fast {
+            frequency: 400_000.Hz(),
+            duty_cycle: i2c::DutyCycle::Ratio2to1,
+        },
+        clocks,
+        /* start_timeout_us */ 1000,
+        /* start_retries */ 10,
+        /* addr_timeout_us */ 1000,
+        /* data_timeout_us */ 1000,
+    );
+
+    let i2c2_busmanager = shared_bus::BusManagerSimple::new(i2c2);
+
+    const I2C_ADDRESS: u8 = 0b010_0000; // MCP23008, depending on solder bridges
+    let mut lcd = match HD44780::new_i2c_mcp23008(i2c2_busmanager.acquire_i2c(), I2C_ADDRESS, &mut delay) {
+        Ok(lcd) => lcd,
+        Err(_) => panic!("HD44780 init fail"),
+    };
+
+    lcd.reset(&mut delay).unwrap();
+    lcd.clear(&mut delay).unwrap();
+    lcd.set_display_mode(
+        DisplayMode {
+            display: Display::On,
+            cursor_visibility: Cursor::Invisible,
+            cursor_blink: CursorBlink::Off,
+        },
+        &mut delay).unwrap();
+    lcd.set_cursor_pos(0, &mut delay).unwrap();
+    lcd.write_str("     HB9EGM     ", &mut delay).unwrap();
+    lcd.set_cursor_pos(40, &mut delay).unwrap();
+    lcd.write_str("  DART-70 2023  ", &mut delay).unwrap();
+    delay.delay_ms(1_500u16);
+
+    // Configure I2C1 to be used for Si5351
+    let scl = gpiob.pb6.into_alternate_open_drain(&mut gpiob.crl);
+    let sda = gpiob.pb7.into_alternate_open_drain(&mut gpiob.crl);
+
+    let i2c = i2c::BlockingI2c::i2c1(
+        dp.I2C1,
+        (scl, sda),
+        &mut afio.mapr,
+        i2c::Mode::Standard {
+            frequency: 100_000.Hz(),
+        },
+        clocks,
+        /* start_timeout_us */ 1000,
+        /* start_retries */ 10,
+        /* addr_timeout_us */ 1000,
+        /* data_timeout_us */ 1000,
+    );
+    let i2c_busmanager = shared_bus::BusManagerSimple::new(i2c);
+
+
+    let mut siclock = {
+        let shared = unsafe { &mut *SHARED.as_mut_ptr() };
+        *shared = SharedWithISR {
+            state : State::new(),
+            last_sequence_state_change : 0,
+            cw_ptt_timestamp : 0,
+            cw_key_n,
+            ui,
+            cw_pwm,
+            cw_keyer : cw::Keyer::new(12, TICKS_PER_SECOND),
+            cw_paddle_tip, cw_paddle_ring, en_rx, en_tx, mute_spkr, mute_micn, led
+        };
+
+        si_clock::SiClock::new(i2c_busmanager.acquire_i2c(), shared.state.bfo(), shared.state.vfo())
+    };
+
+    let mut last_s_meter_value = 0;
+    ui::update_disp(&mut lcd, &get_state_copy(), &mut delay, last_s_meter_value, false);
+
+    let mut last_encoder_count = qei.count();
+
+    {
+        let ticks = unsafe { &mut *TICK_COUNTER.as_mut_ptr() };
+        *ticks = 0;
+    }
+
+    {
+        let timer = unsafe { &mut *CLOCK_TIMER.as_mut_ptr() };
+        *timer = Timer::new(dp.TIM2, &clocks).counter_hz();
+        timer.start(TICKS_PER_SECOND.Hz()).unwrap();
+        timer.listen(Event::Update);
+    }
+
+    unsafe { pac::NVIC::unmask(pac::Interrupt::TIM2); }
+
+    let mut last_disp_update_counter = 1;
+    let mut previous_vfo = 0;
+    let mut previous_bfo = 0;
+
+    loop {
+        let mut update_disp_required = false;
+        let mut bfo_tune_fail = false;
+
+        let state = get_state_copy();
+
+        let encoder_count : u16 = qei.count();
+        if encoder_count != last_encoder_count {
+            let delta = encoder_count.wrapping_sub(last_encoder_count);
+            let delta = if delta > 0x7FFF { delta as i32 - 0x10000 } else { delta as i32 };
+
+            let require_bfo_update = cortex_m::interrupt::free(|_cs| {
+                let shared = unsafe { &mut *SHARED.as_mut_ptr() };
+                let r = shared.ui.update_encoder(&mut shared.state, delta);
+                if let Mode::CW(CWMode::Iambic) = shared.state.mode {
+                    shared.cw_keyer.set_speed(shared.state.cw_wpm, TICKS_PER_SECOND)
+                }
+                r
+            });
+
+            if require_bfo_update {
+                bfo_tune_fail = !siclock.set_bfo(state.bfo()).is_ok();
+            }
+            siclock.set_vfo(state.vfo());
+            update_disp_required = true;
+        }
+
+        let bfo = state.bfo();
+        if previous_bfo != bfo {
+            bfo_tune_fail = !siclock.set_bfo(bfo).is_ok();
+        }
+        previous_bfo = bfo;
+
+        let vfo = state.vfo();
+        if previous_vfo != vfo {
+            siclock.set_vfo(vfo);
+        }
+        previous_vfo = vfo;
+
+        let s_meter_adc_value: u16 = adc2.read(&mut s_meter).unwrap();
+        let s_meter_value = s_meter_from_adc(s_meter_adc_value);
+        let t_now = ticks_now();
+        if last_s_meter_update_time + 10 < t_now {
+            update_disp_required |= s_meter_value != last_s_meter_value;
+            last_s_meter_value = s_meter_value;
+            last_s_meter_update_time = t_now;
+        }
+
+        if last_disp_update_counter != state.update_disp_counter {
+            update_disp_required = true;
+            last_disp_update_counter = state.update_disp_counter;
+        }
+
+        if update_disp_required {
+            let state = get_state_copy();
+            ui::update_disp(&mut lcd, &state, &mut delay, s_meter_value, bfo_tune_fail);
+        }
+
+        last_encoder_count = encoder_count;
+
+        cortex_m::asm::wfi();
+    }
+}
+
+fn s_meter_from_adc(adc : u16) -> u8 {
+    // Avoid 0 because of log10
+    let adc = f32::from(if adc == 0 { 1 } else { adc });
+    // ADC is 12-bit, convert to dB full-scale
+    let adc_db = 10f32 * log10f::log10f(adc / 4092f32);
+
+    /* Hand-calibrated lookup table */
+    if adc_db <= -35f32 {
+        1
+    }
+    else if adc_db <= -20f32 {
+        4
+    }
+    else if adc_db <= -12f32 {
+        5
+    }
+    else if adc_db <= -8f32 {
+        6
+    }
+    else if adc_db <= -7f32 {
+        7
+    }
+    else {
+        9
+    }
+}
+
+#[interrupt]
+fn TIM2() {
+    let timer = unsafe { &mut *CLOCK_TIMER.as_mut_ptr() };
+    timer.clear_interrupt(Event::Update);
+
+    let ticks = unsafe { &mut *TICK_COUNTER.as_mut_ptr() };
+    *ticks += 1;
+
+    let mut shared = unsafe { &mut *SHARED.as_mut_ptr() };
+    let button_result = shared.ui.handle_buttons(&mut shared.state);
+
+    if button_result.display_update {
+        shared.state.update_disp_counter += 1;
+    }
+
+    let cw_paddle_tip_low = shared.cw_paddle_tip.is_low();
+    let cw_paddle_ring_low = shared.cw_paddle_ring.is_low();
+
+    if cw_paddle_tip_low || cw_paddle_ring_low {
+        shared.state.send_tone = false;
+    }
+
+    let cw_ptt_delay : u32 = TICKS_PER_SECOND * 800 / 1000;
+    let cw_ptt = shared.state.send_tone ||
+        match shared.state.mode {
+            Mode::CW(_) => {
+                if cw_paddle_tip_low || cw_paddle_ring_low {
+                    shared.cw_ptt_timestamp = *ticks;
+                    true
+                }
+                else {
+                    shared.cw_ptt_timestamp + cw_ptt_delay > *ticks
+                }
+            },
+            _ => false,
+        };
+
+    let cw_beep = shared.state.send_tone ||
+        match shared.state.mode {
+            Mode::CW(CWMode::StraightKey) => cw_paddle_tip_low,
+            Mode::CW(CWMode::Iambic) => shared.cw_keyer.tick(*ticks, cw_paddle_tip_low, cw_paddle_ring_low),
+            _ => false,
+        };
+
+    let next_state = match shared.state.sequence_state {
+        SequenceState::Rx => {
+            shared.mute_spkr.set_low();
+            shared.mute_micn.set_low();
+            shared.en_rx.set_high();
+            shared.en_tx.set_low();
+            if button_result.ptt || cw_ptt {
+                SequenceState::MutingSpkr
+            }
+            else {
+                SequenceState::Rx
+            }
+        },
+        SequenceState::MutingSpkr => {
+            shared.mute_spkr.set_high();
+            shared.mute_micn.set_low();
+            shared.en_rx.set_high();
+            shared.en_tx.set_low();
+            if button_result.ptt {
+                SequenceState::SwitchingSSB
+            }
+            else if cw_ptt {
+                SequenceState::SwitchingCW
+            }
+            else {
+                SequenceState::Rx
+            }
+        },
+        SequenceState::SwitchingSSB => {
+            shared.mute_spkr.set_high();
+            shared.en_rx.set_low();
+            shared.en_tx.set_low();
+            shared.mute_micn.set_high();
+
+            if button_result.ptt {
+                SequenceState::TxSSB
+            }
+            else {
+                SequenceState::Rx
+            }
+        },
+        SequenceState::SwitchingCW => {
+            shared.mute_spkr.set_high();
+            shared.en_rx.set_low();
+            shared.en_tx.set_low();
+            shared.mute_micn.set_low();
+            if cw_ptt {
+                SequenceState::TxCW
+            }
+            else {
+                SequenceState::Rx
+            }
+        },
+        SequenceState::TxSSB => {
+            shared.en_rx.set_low();
+            shared.en_tx.set_high();
+
+            if button_result.ptt {
+                SequenceState::TxSSB
+            }
+            else {
+                SequenceState::SwitchingSSB
+            }
+        },
+        SequenceState::TxCW => {
+            shared.en_rx.set_low();
+            shared.en_tx.set_high();
+
+            if cw_ptt {
+                SequenceState::TxCW
+            }
+            else {
+                SequenceState::SwitchingCW
+            }
+        },
+    };
+
+    match shared.state.sequence_state {
+        SequenceState::TxCW => {
+            if cw_beep {
+                shared.led.set_low();
+                shared.cw_pwm.on();
+                shared.cw_key_n.set_low();
+            }
+            else {
+                shared.led.set_high();
+                shared.cw_pwm.off();
+                shared.cw_key_n.set_high();
+            }
+        },
+        _ => {
+            shared.led.set_high();
+            shared.cw_pwm.off();
+            shared.cw_key_n.set_high();
+        },
+    }
+
+    const SWITCHING_DELAY : u32 = TICKS_PER_SECOND * 80 / 1000;
+    if shared.state.sequence_state != next_state &&
+        shared.last_sequence_state_change + SWITCHING_DELAY <= *ticks {
+            shared.state.sequence_state = next_state;
+            shared.last_sequence_state_change = *ticks;
+    }
+}
+
+#[allow(non_snake_case)]
+#[cortex_m_rt::exception]
+unsafe fn HardFault(ef: &ExceptionFrame) -> ! {
+    let periph = unsafe { cortex_m::Peripherals::steal() };
+    let hfsr = periph.SCB.hfsr.read();
+    let cfsr = periph.SCB.cfsr.read();
+
+    hprintln!("Hardfault {:x} {:x} at {:x}\n", hfsr, cfsr, ef.pc());
+    cortex_m::asm::bkpt();
+    loop { }
+}
+
+#[allow(non_snake_case)]
+#[cortex_m_rt::exception]
+unsafe fn DefaultHandler(irqn: i16) {
+    hprintln!("Unhandled exception (IRQn = {})", irqn);
+    cortex_m::asm::bkpt();
+    loop { }
+}