urm37 1.2.0

Platform-agnostic no_std driver for the DFRobot URM37 V4.0 ultrasonic distance sensor (UART, PWM, Analog)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! # URM37 Async UART Example for STM32F767ZI
//!
//! Demonstrates async UART communication with distance and temperature reading.
//!
//! ## Hardware Setup
//! - **UART5**: RX=PD2, TX=PC12
//! - **STM32F767ZI (Nucleo)**
//! - DMA: CH0 (TX), CH7 (RX)
//!
//! ## Output Format
//! ```text
//! [DISTANCE] X cm
//! [TEMPERATURE] X.X °C
//! [ERROR]
//! ```
//!
//! ## Build & Run
//! ```bash
//! cargo run --example stm32_uart_async --features async --release
//! ```

#![no_std]
#![no_main]

use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::usart::Uart;
use embassy_stm32::{bind_interrupts, dma, peripherals, usart};
use embassy_time::Timer;
use urm37::uart_async::Urm37UartAsync;
use embedded_io_async::{Read, Write};
use core::fmt;
use {defmt_rtt as _, panic_probe as _};

bind_interrupts!(struct Irqs {
    UART5 => usart::InterruptHandler<peripherals::UART5>;
    DMA1_STREAM0 => dma::InterruptHandler<peripherals::DMA1_CH0>;
    DMA1_STREAM7 => dma::InterruptHandler<peripherals::DMA1_CH7>;
});

#[derive(Debug, Clone, Copy)]
pub enum TransportError {
    Uart(embassy_stm32::usart::Error),
    Timeout,
}

impl From<embassy_stm32::usart::Error> for TransportError {
    fn from(e: embassy_stm32::usart::Error) -> Self {
        TransportError::Uart(e)
    }
}

impl fmt::Display for TransportError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TransportError::Uart(_) => f.write_str("UART error"),
            TransportError::Timeout => f.write_str("Timeout"),
        }
    }
}

impl core::error::Error for TransportError {}

impl embedded_io::Error for TransportError {
    fn kind(&self) -> embedded_io::ErrorKind {
        match self {
            TransportError::Timeout => embedded_io::ErrorKind::TimedOut,
            TransportError::Uart(_) => embedded_io::ErrorKind::Other,
        }
    }
}

impl defmt::Format for TransportError {
    fn format(&self, fmt: defmt::Formatter) {
        match self {
            TransportError::Uart(_) => defmt::write!(fmt, "Uart"),
            TransportError::Timeout => defmt::write!(fmt, "Timeout"),
        }
    }
}

struct UartWrapper<'d> {
    uart: Uart<'d, embassy_stm32::mode::Async>,
}

impl<'d> embedded_io_async::ErrorType for UartWrapper<'d> {
    type Error = TransportError;
}

impl<'d> Read for UartWrapper<'d> {
    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
        if buf.is_empty() {
            return Ok(0);
        }
        match embassy_time::with_timeout(embassy_time::Duration::from_millis(100), self.uart.read(&mut buf[..1])).await {
            Ok(Ok(())) => Ok(1),
            Ok(Err(e)) => Err(TransportError::Uart(e)),
            Err(_) => Err(TransportError::Timeout),
        }
    }
}

impl<'d> Write for UartWrapper<'d> {
    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
        self.uart.write_all(buf).await?;
        Ok(buf.len())
    }

    async fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());

    // Configure UART5 (PC12=TX, PD2=RX) with DMA
    let mut uart_config = embassy_stm32::usart::Config::default();
    uart_config.baudrate = 9600;

    let uart = Uart::new(
        p.UART5,
        p.PD2,  // RX
        p.PC12, // TX
        p.DMA1_CH7,  // RX DMA
        p.DMA1_CH0,  // TX DMA
        Irqs,
        uart_config,
    )
    .unwrap();

    let wrapper = UartWrapper { uart };
    let mut sensor = Urm37UartAsync::new(wrapper);

    loop {
        match sensor.read_distance().await {
            Ok(distance) => {
                info!("[DISTANCE] {} cm", distance);
            }
            Err(_) => {
                info!("[ERROR]");
            }
        }

        Timer::after_millis(500).await;

        match sensor.read_temperature().await {
            Ok(temp) => {
                let temp_int = temp as i32;
                let temp_frac = ((temp * 10.0) as i32) % 10;
                info!("[TEMPERATURE] {}.{} °C", temp_int, temp_frac);
            }
            Err(_) => {
                info!("[ERROR]");
            }
        }

        Timer::after_millis(500).await;
    }
}