Opamp

.github/workflows/ci_opamp.yml

@@ -0,0 +1,84 @@
+on:
+  push:
+    branches: [opamp]
+  pull_request:
+
+name: Continuous integration
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix: # All permutations of {rust, mcu}
+        rust:
+          - stable
+        mcu:
+          - stm32l412
+          - stm32l422
+          - stm32l431
+          - stm32l432
+          - stm32l433
+          - stm32l442
+          - stm32l443
+          - stm32l451
+          - stm32l452
+          - stm32l462
+          - stm32l471
+          - stm32l475
+          - stm32l476
+          - stm32l486
+          - stm32l496
+          - stm32l4a6
+          #- stm32l4r9
+          #- stm32l4s9
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: thumbv7em-none-eabihf
+          override: true
+      - name: build
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --verbose --release --examples --target thumbv7em-none-eabihf --features rt,unproven,${{ matrix.mcu }}
+      - name: test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --lib --target x86_64-unknown-linux-gnu --features rt,unproven,${{ matrix.mcu }}
+
+  ci-r9:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust:
+          - stable
+        mcu:
+          - stm32l4r9
+          - stm32l4s9
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: thumbv7em-none-eabihf
+          override: true
+      - name: build
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --verbose --release --target thumbv7em-none-eabihf --features rt,unproven,${{ matrix.mcu }}
+      # note that examples were not built
+      - name: test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --lib --target x86_64-unknown-linux-gnu --features rt,unproven,${{ matrix.mcu }}

.github/workflows/clippy_opamp.yml

@@ -0,0 +1,22 @@
+on:
+  push:
+    branches: [ opamp ]
+  pull_request:
+
+name: Clippy check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          target: thumbv7em-none-eabihf
+          override: true
+          components: clippy
+      - uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --examples --target thumbv7em-none-eabihf --features=stm32l432,rt,unproven

.github/workflows/rustfmt_opamp.yml

@@ -0,0 +1,23 @@
+on:
+  push:
+    branches: [ opamp ]
+  pull_request:
+
+name: Code formatting check
+
+jobs:
+  fmt:
+    name: Rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check

Cargo.toml

@@ -197,3 +197,4 @@ required-features = ["rt"]
 [[example]]
 name = "adc_dma"
 required-features = ["rt"]
+

examples/adc_dma_seq.rs

@@ -0,0 +1,109 @@
+#![no_main]
+#![no_std]
+
+use panic_rtt_target as _;
+use rtt_target::{rprintln, rtt_init_print};
+use stm32l4xx_hal::{
+    adc::{DmaMode, SampleTime, Sequence, ADC},
+    delay::DelayCM,
+    dma::{dma1, RxDma, Transfer, W},
+    prelude::*,
+    time::Hertz,
+};
+
+use rtic::app;
+
+const SEQUENCE_LEN: usize = 4;
+
+#[app(device = stm32l4xx_hal::stm32, peripherals = true, monotonic = rtic::cyccnt::CYCCNT)]
+const APP: () = {
+    // RTIC app is written in here!
+
+    struct Resources {
+        transfer: Option<Transfer<W, &'static mut [u16; SEQUENCE_LEN], RxDma<ADC, dma1::C1>>>,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> init::LateResources {
+        let MEMORY = {
+            static mut MEMORY: [u16; SEQUENCE_LEN] = [0u16; SEQUENCE_LEN];
+            unsafe { &mut MEMORY }
+        };
+
+        rtt_init_print!();
+
+        rprintln!("Hello from init!");
+
+        let cp = cx.core;
+        let mut dcb = cp.DCB;
+        let mut dwt = cp.DWT;
+
+        dcb.enable_trace();
+        dwt.enable_cycle_counter();
+
+        let pac = cx.device;
+
+        let mut rcc = pac.RCC.constrain();
+        let mut flash = pac.FLASH.constrain();
+        let mut pwr = pac.PWR.constrain(&mut rcc.apb1r1);
+        let dma_channels = pac.DMA1.split(&mut rcc.ahb1);
+
+        //
+        // Initialize the clocks
+        //
+        let clocks = rcc
+            .cfgr
+            .sysclk(Hertz(80_000_000))
+            .freeze(&mut flash.acr, &mut pwr);
+
+        let mut delay = DelayCM::new(clocks);
+
+        let mut adc = ADC::new(
+            pac.ADC1,
+            pac.ADC_COMMON,
+            &mut rcc.ahb2,
+            &mut rcc.ccipr,
+            &mut delay,
+        );
+
+        let mut temp_pin = adc.enable_temperature(&mut delay);
+
+        let dma1_channel = dma_channels.1;
+        let mut gpioc = pac.GPIOC.split(&mut rcc.ahb2);
+        let mut pc0 = gpioc.pc0.into_analog(&mut gpioc.moder, &mut gpioc.pupdr);
+
+        adc.configure_sequence(&mut temp_pin, Sequence::One, SampleTime::Cycles12_5);
+        adc.configure_sequence(&mut temp_pin, Sequence::Two, SampleTime::Cycles247_5);
+        adc.configure_sequence(&mut temp_pin, Sequence::Three, SampleTime::Cycles640_5);
+        adc.configure_sequence(&mut pc0, Sequence::Four, SampleTime::Cycles640_5);
+
+        // Heapless boxes also work very well as buffers for DMA transfers
+        let transfer = Transfer::from_adc(adc, dma1_channel, MEMORY, DmaMode::Oneshot, true);
+
+        init::LateResources {
+            transfer: Some(transfer),
+        }
+    }
+
+    #[idle]
+    fn idle(_cx: idle::Context) -> ! {
+        loop {
+            cortex_m::asm::nop();
+        }
+    }
+
+    #[task(binds = DMA1_CH1, resources = [transfer])]
+    fn dma1_interrupt(cx: dma1_interrupt::Context) {
+        let transfer = cx.resources.transfer;
+        if let Some(transfer_val) = transfer.take() {
+            let (buffer, rx_dma) = transfer_val.wait();
+            rprintln!("DMA measurements: {:?}", buffer);
+            *transfer = Some(Transfer::from_adc_dma(
+                rx_dma,
+                buffer,
+                DmaMode::Oneshot,
+                true,
+            ));
+        }
+    }
+};

examples/adc_opamp1.rs

@@ -0,0 +1,66 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+
+use panic_rtt_target as _;
+
+use cortex_m_rt::entry;
+use rtt_target::{rprint, rprintln};
+use stm32l4xx_hal::{adc::ADC, delay::Delay, opamp::*, pac, prelude::*};
+
+use stm32l4xx_hal::traits::opamp::*;
+
+#[entry]
+fn main() -> ! {
+    rtt_target::rtt_init_print!();
+    rprint!("Initializing...");
+
+    let cp = pac::CorePeripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    let mut rcc = dp.RCC.constrain();
+    let mut flash = dp.FLASH.constrain();
+    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
+
+    let clocks = rcc.cfgr.freeze(&mut flash.acr, &mut pwr);
+
+    // set IOs to analgo mode, which are used by the Opamp
+    let mut gpioa = dp.GPIOA.split(&mut rcc.ahb2);
+    // OPAMP1_VINP
+    let mut pa0 = gpioa.pa0.into_analog(&mut gpioa.moder, &mut gpioa.pupdr);
+
+    let mut delay = Delay::new(cp.SYST, clocks);
+    let mut adc = ADC::new(
+        dp.ADC1,
+        dp.ADC_COMMON,
+        &mut rcc.ahb2,
+        &mut rcc.ccipr,
+        &mut delay,
+    );
+
+    let mut opamp1_out = adc.enable_opamp1_out();
+
+    let ops = dp.OPAMP;
+    let op1: OP1 = OP1::new(
+        &ops.opamp1_csr,
+        &ops.opamp1_otr,
+        &ops.opamp1_lpotr,
+        &ops.opamp1_csr,
+        &rcc.apb1r1,
+    );
+
+    op1.set_opamp_oper_mode(OperationMode::Pga).unwrap();
+    // set pga gain
+    op1.set_pga_gain(2).unwrap();
+    op1.enable(true);
+
+    rprintln!(" done.");
+
+    loop {
+        // let value = adc.read(&mut opamp2_out).unwrap();
+        let value_opamp1 = adc.read(&mut opamp1_out).unwrap();
+        let value_a0 = adc.read(&mut pa0).unwrap();
+        rprintln!("Value: pa0 {} opam1 {}", value_a0, value_opamp1);
+    }
+}