嵌入式系统

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#include <stdint.h>#include "stm32g4xx.h"/* Conversion-complete interrupt. It runs on every sample, so it does the least * work that is correct and gets out: stash the reading, return. Filtering, * scaling and telemetry all happen in the main loop, where a slow path costs * latency instead of a missed sample. * * The buffer length is a power of two so the wrap is a mask rather than a * modulo — integer division is ~20 cycles on this part and the ISR budget is * about 60. */#define ADC_BUF_LEN  64u#define ADC_BUF_MASK (ADC_BUF_LEN - 1u)static volatile uint16_t adc_buf[ADC_BUF_LEN];static volatile uint8_t  adc_head = 0u;static volatile uint8_t  adc_tail = 0u;static volatile uint32_t adc_overruns = 0u;void ADC1_2_IRQHandler(void) {  if ((ADC1->ISR & ADC_ISR_EOC) == 0u) {    return;                       /* not ours — shared vector */  }  uint8_t next = (uint8_t)((adc_head + 1u) & ADC_BUF_MASK);  if (next == adc_tail) {    adc_overruns++;               /* main loop is behind; count it, never block */    (void)ADC1->DR;               /* read anyway, or EOC never clears */  } else {    adc_buf[adc_head] = (uint16_t)ADC1->DR;    adc_head = next;  }}

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//! The same ring buffer in Rust. The interesting difference is not syntax: the//! C version relies on review to guarantee that the ISR and the main loop never//! touch head and tail at the same time. Here the queue is split into a producer//! and a consumer, and the compiler refuses to build anything else.use core::sync::atomic::{AtomicU32, Ordering};use heapless::spsc::{Consumer, Producer};static OVERRUNS: AtomicU32 = AtomicU32::new(0);#[interrupt]fn ADC1_2(producer: &mut Producer<'static, u16, 64>) {    let sample = adc::read_dr();    // A full queue means the main loop is behind. Drop the sample and record it:    // an ISR that waits for space is an ISR that misses its deadline.    if producer.enqueue(sample).is_err() {        OVERRUNS.fetch_add(1, Ordering::Relaxed);    }}fn main_loop(consumer: &mut Consumer<'static, u16, 64>) -> ! {    let mut filter = Iir::new(0.15);    loop {        while let Some(raw) = consumer.dequeue() {            let volts = filter.push(f32::from(raw) * (3.3 / 4095.0));            telemetry::publish(volts);        }        cortex_m::asm::wfi();     // sleep until the next interrupt    }}