Help with UART RX

[itsLydt]

Trying to get uart working on my atsam board with this crate. I am using the Atmel SAM D21 Xplained kit (ATSAMD21J18A) on sercom0. I am able to transmit from the board, but having a difficult time receiving.

If I call

let mut rx_buffer = [0x00; 50];
uart_rx.read(rx_buffer )

The call to read blocks forever. However, if I make an unsafe block and use let bytes = uart_rx.read_data() , I can see that the bytes are being received by the board.

I may have missed something very silly, if that is the case I apologize!

[rnd-ash]

is it possible to see your full UART code? - which trait did you use for the 'read' function? - The one in embedded::io::Read will block until at least 1 byte is available

[itsLydt]

Here is the code I am using, but it is somewhat complicated due to templates and rather long. I can provide a simpler version later once I am back at my desk. I am using atsamd_hal::embedded_io::Read, which gives read and read_exact if I remember correctly. My understanding is read_exact will attempt to fill the buffer, whereas read will read one or more bytes. Is there a different trait I should be using or should I use a smaller buffer for rx? In my testing I am sending about 5-10 bytes at a time.

Imports:

#![cfg(ATSAMD21XPRO)]

use core::option::Option;
use core::option::Option::{None, Some };
use core::result::Result;
use core::result::Result::{Err, Ok};
use core::fmt::Write;

use atsamd_hal as hal;
use hal::clock::{ Sercom0CoreClock, Sercom1CoreClock, Sercom2CoreClock, Sercom3CoreClock, Sercom4CoreClock, Sercom5CoreClock };
use hal::embedded_io::{Read, ErrorType};
use hal::nb::block;

use hal::gpio;
use hal::gpio::{Pin};

use hal::sercom::{uart, Pad, Sercom, GetPad, IsPad};
use hal::sercom::uart::{TxDuplex, RxDuplex, BaudMode, Oversampling, Config, Pads, Uart};
use hal::ehal_nb::serial::Write as SerialWrite;

use hal::time::{Hertz, MegaHertz};

type UartConfig<S, I1, I2> = Config<Pads<S, Pin<I1, <I1 as GetPad<S>>::PinMode>, Pin<I2, <I2 as GetPad<S>>::PinMode>>>;

My struct definition for a UART:

pub struct MyUart<S, I1, I2>
where S: Sercom,
      I1: GetPad<S>,
      I2: GetPad<S>,
      Pin<I1, <I1 as GetPad<S>>::PinMode>: IsPad,
      Pin<I2, <I2 as GetPad<S>>::PinMode>: IsPad,
      (<Pin<I1, <I1 as GetPad<S>>::PinMode> as IsPad>::PadNum,
       <Pin<I2, <I2 as GetPad<S>>::PinMode> as IsPad>::PadNum,
       hal::typelevel::NoneT, hal::typelevel::NoneT): uart::RxpoTxpo {
    uart_tx: Uart<UartConfig<S, I1, I2>, TxDuplex>,
    uart_rx: Uart<UartConfig<S, I1, I2>, RxDuplex>
}

MyUart constructor:

impl<S, I1, I2> MyUart<S, I1, I2>
where S: Sercom,
    I1: GetPad<S>,
    I2: GetPad<S>,
    Pin<I1, <I1 as GetPad<S>>::PinMode>: IsPad,
    Pin<I2, <I2 as GetPad<S>>::PinMode>: IsPad,
    (<Pin<I1, <I1 as GetPad<S>>::PinMode> as IsPad>::PadNum,
     <Pin<I2, <I2 as GetPad<S>>::PinMode> as IsPad>::PadNum,
     hal::typelevel::NoneT, hal::typelevel::NoneT): uart::RxpoTxpo
{

    pub fn new<M1, M2>(rx_pin :  Pin<I1, M1>, tx_pin :  Pin<I2, M2>, clk: &uart::Clock, sercom : S)
                                     -> MyUart<S, I1, I2>
    where S: Sercom,
          I1: GetPad<S>,
          I2: GetPad<S>,
          M1: gpio::PinMode,
          M2: gpio::PinMode,
          Pin<I1, <I1 as GetPad<S>>::PinMode>: IsPad,
          Pin<I2, <I2 as GetPad<S>>::PinMode>: IsPad,
          (<Pin<I1, <I1 as GetPad<S>>::PinMode> as IsPad>::PadNum,
           <Pin<I2, <I2 as GetPad<S>>::PinMode> as IsPad>::PadNum,
           hal::typelevel::NoneT, hal::typelevel::NoneT): uart::RxpoTxpo
    {
        let pads : Pads<S, Pad<S, I1>, Pad<S, I2>> = Pads::<S>::default().rx(rx_pin).tx(tx_pin);
        let freq : MegaHertz = MegaHertz::MHz(8);
        let config = uart::Config::new(clk, sercom, pads, freq.convert());
        let uart = config.baud(Hertz::Hz(115200), BaudMode::Arithmetic(Oversampling::Bits16)).enable();
        let (uart_rx, uart_tx) = uart.split();

        MyUart::<S, I1, I2>{ uart_tx, uart_rx }
    }

The code for reading:

impl<S, I1, I2> ErrorType for MyUart<S, I1, I2>
where S: Sercom,
      I1: GetPad<S>,
      I2: GetPad<S>,
      Pin<I1, <I1 as GetPad<S>>::PinMode>: IsPad,
      Pin<I2, <I2 as GetPad<S>>::PinMode>: IsPad,
      (<Pin<I1, <I1 as GetPad<S>>::PinMode> as IsPad>::PadNum,
       <Pin<I2, <I2 as GetPad<S>>::PinMode> as IsPad>::PadNum,
       hal::typelevel::NoneT, hal::typelevel::NoneT): uart::RxpoTxpo
{ type Error = uart::Error; }

impl<S, I1, I2> Read for MyUart<S, I1, I2>
where S: Sercom,
    I1: GetPad<S>,
    I2: GetPad<S>,
    Pin<I1, <I1 as GetPad<S>>::PinMode>: IsPad,
    Pin<I2, <I2 as GetPad<S>>::PinMode>: IsPad,
  (<Pin<I1, <I1 as GetPad<S>>::PinMode> as IsPad>::PadNum,
   <Pin<I2, <I2 as GetPad<S>>::PinMode> as IsPad>::PadNum,
   hal::typelevel::NoneT, hal::typelevel::NoneT): uart::RxpoTxpo {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
        self.uart_rx.read(buf)
    }
}

FInally, the clock / peripheral setup and usage of the uart:

let mut peripherals = Peripherals::take().unwrap();
let gpio_pins = hal::gpio::Pins::new(peripherals.port);
let gpio::Pins { pb30, pa08, pa09 , ..} = gpio_pins;

let mut led = led_setup(pb30);

let core = CorePeripherals::take().unwrap();
let mut clocks = hal::clock::GenericClockController::with_external_32kosc(
    peripherals.gclk,
    &mut peripherals.pm,
    &mut peripherals.sysctrl,
    &mut peripherals.nvmctrl,
);

let gclk2 = clocks.configure_gclk_divider_and_source(Gclk2, 6, Dfll48m, true).unwrap();
let serial_clock = clocks.sercom0_core(&gclk2);

let uart = MyUart::new(pa09, pa08, &peripherals.pm, peripherals.sercom0);

  // Make buffers to store data to send/receive
  let mut rx_buffer = [0x00; 50];
  let tx_buffer = "Hello, world!\r\n";

loop {
    led.toggle().unwrap();
    uart.write_str(tx_buffer).unwrap();
    delay.delay_ms(200u8);

    let bytes_read = uart.read(&mut rx_buffer); // this never returns
    if let Ok(bytes) = bytes_read {
        write!(uart, "Received {} bytes\r\n", bytes).unwrap();
    }
}

There is code for write that I did not include as this is already rather long and writing appears to be working just fine.

[sajattack]

It will probably be easier to help you via live chat.
https://matrix.to/#/#atsamd-rs:matrix.org