arduino-tnc

main.rs (5551B)

---

 #![no_std]
 #![no_main]
 #![feature(abi_avr_interrupt)]
 
 mod kiss;
 mod rx;
 mod tx;
 
 use core::cell::RefCell;
 use core::hint::spin_loop;
 
 use arduino_hal::clock::MHz16;
 use arduino_hal::hal::usart::{Event, Usart0};
 use arduino_hal::{pac, Adc};
 use avr_device::generic::Periph;
 use avr_device::interrupt::{self, Mutex};
 use kiss::{KissAction, KissTncState};
 use panic_halt as _;
 use rx::Receiver;
 use tx::Transmitter;
 
 type TC0 = Periph<pac::tc0::RegisterBlock, 53>;
 type TC1 = Periph<pac::tc1::RegisterBlock, 54>;
 
 struct Tnc {
     state: TncState,
     serial: Option<Usart0<MHz16>>,
     receiver: Receiver,
     transmitter: Transmitter,
     kiss_state: KissTncState,
     sample_timer: Option<TC0>,
     symbol_timer: Option<TC1>,
 }
 
 impl Tnc {
     // 52 * 8 = 416 cycles; at 16 MHz this gives a period of 26 µs (about 38460 Hz)
     const SAMPLE_TIMER_COMPARE: u8 = 52;
     // this should theoretically be 13_333 cycles, but in practice we have to go a little faster to
     // account for overhead; this value seems to work well
     const SYMBOL_TIMER_COMPARE: u16 = 13_300;
 
     const fn default() -> Tnc {
         Tnc {
             state: TncState::Receiving,
             serial: None,
             receiver: Receiver::default(),
             transmitter: Transmitter::default(),
             kiss_state: KissTncState::Idle,
             sample_timer: None,
             symbol_timer: None,
         }
     }
     pub(crate) fn handle_usart_byte(&mut self, byte: u8) {
         if let Some(action) = self.kiss_state.update(byte) {
             match action {
                 KissAction::PushTx(b) => {
                     let _ = self.transmitter.push_message_byte(b);
                 }
                 KissAction::ClearTx => self.transmitter.clear_message(),
                 KissAction::SendTx => {
                     if self.transmitter.has_pending_bytes() {
                         self.state = TncState::Transmitting;
                         self.transmitter.start();
                     }
                 }
                 KissAction::_SetTxDelay { .. } => todo!(),
                 KissAction::_SetPersistence { .. } => todo!(),
                 KissAction::_SetSlotTime { .. } => todo!(),
                 KissAction::_SetTxTail { .. } => todo!(),
                 KissAction::_SetFullDuplex { .. } => todo!(),
                 KissAction::_SetHardware { .. } => todo!(),
                 KissAction::_Return => todo!(),
             }
         };
     }
 }
 
 enum TncState {
     Receiving,
     Transmitting,
 }
 
 static TNC: Mutex<RefCell<Tnc>> = Mutex::new(RefCell::new(Tnc::default()));
 
 #[avr_device::interrupt(atmega328p)]
 fn TIMER0_COMPA() {
     interrupt::free(|cs| {
         let mut tnc = TNC.borrow(cs).borrow_mut();
         match tnc.state {
             TncState::Receiving => {
                 if tnc.receiver.sample_update() {
                     if let Some(ref mut symbol_timer) = tnc.symbol_timer {
                         symbol_timer
                             .tcnt1()
                             .write(|w| w.set(Tnc::SYMBOL_TIMER_COMPARE / 2));
                     }
                 }
                 if let Some(byte) = tnc.receiver.get_output() {
                     if let Some(ref mut serial) = tnc.serial {
                         let _ = ufmt::uwriteln!(serial, "0x{:02x}", byte);
                     }
                 }
             }
             TncState::Transmitting => {
                 tnc.transmitter.sample_update();
                 if tnc.transmitter.is_done() {
                     tnc.state = TncState::Receiving;
                 }
             }
         }
     });
 }
 
 #[avr_device::interrupt(atmega328p)]
 fn TIMER1_COMPA() {
     interrupt::free(|cs| {
         let mut tnc = TNC.borrow(cs).borrow_mut();
         if let TncState::Transmitting = tnc.state {
             tnc.transmitter.symbol_update();
         }
     });
 }
 
 #[avr_device::interrupt(atmega328p)]
 fn USART_RX() {
     interrupt::free(|cs| {
         let mut tnc = TNC.borrow(cs).borrow_mut();
         if let Some(ref mut serial) = tnc.serial {
             let byte = serial.read_byte();
             tnc.handle_usart_byte(byte);
         }
     });
 }
 
 #[arduino_hal::entry]
 fn main() -> ! {
     let dp = arduino_hal::Peripherals::take().unwrap();
     let pins = arduino_hal::pins!(dp);
 
     let mut serial = arduino_hal::default_serial!(dp, pins, 115200);
     serial.listen(Event::RxComplete);
 
     let sample_timer = dp.TC0;
     sample_timer.tccr0a().write(|w| w.wgm0().ctc());
     sample_timer.tccr0b().write(|w| w.cs0().prescale_8());
     sample_timer
         .ocr0a()
         .write(|w| w.set(Tnc::SAMPLE_TIMER_COMPARE));
     sample_timer.timsk0().write(|w| w.ocie0a().set_bit());
 
     let symbol_timer = dp.TC1;
     symbol_timer
         .tccr1b()
         .write(|w| w.wgm1().set(0b01).cs1().direct());
     symbol_timer
         .ocr1a()
         .write(|w| w.set(Tnc::SYMBOL_TIMER_COMPARE));
     symbol_timer.timsk1().write(|w| w.ocie1a().set_bit());
 
     interrupt::free(|cs| {
         let mut tnc = TNC.borrow(cs).borrow_mut();
         tnc.serial = Some(serial);
         tnc.sample_timer = Some(sample_timer);
         tnc.symbol_timer = Some(symbol_timer);
         tnc.receiver
             .initialize(Adc::new(dp.ADC, Default::default()), pins.a0);
         tnc.transmitter.initialize(
             pins.d2.into_output(),
             pins.d3.into_output(),
             pins.d4.into_output(),
             pins.d5.into_output(),
             pins.d6.into_output(),
         );
     });
 
     unsafe { avr_device::interrupt::enable() };
 
     loop {
         spin_loop();
     }
 }