Cara Membaca Input Analog (ADC) pada STM32 Blue Pill dengan Rust

1[[bin]]
2name = "single-conversion-poll"
3path = "src/main.rs"
4test = false
5bench = false

 1#![no_std]
 2#![no_main]
 3
 4use defmt_rtt as _;
 5use panic_probe as _;
 6
 7use cortex_m::delay::Delay;
 8use cortex_m_rt::entry;
 9use stm32f1xx_hal::{
10    adc,
11    flash::FlashExt,
12    gpio::GpioExt,
13    pac,
14    prelude::*,
15    rcc::{Config, RccExt},
16    time::Hertz,
17};
18
19#[entry]
20fn main() -> ! {
21    defmt::println!("STM32F103C8 Acess GPIO as Input Analog Single Conversion Poll");
22
23    // Mengakses periferal STM32F103C8
24    let dp = pac::Peripherals::take().unwrap();
25
26    // Mengakses core peripherals (cortex-M3) STM32F103C8
27    let cp = pac::CorePeripherals::take().unwrap();
28
29    // Mengakses periferal FLASH yang akan digunakan untuk menyesuaikan
30    // 'wait states' saat konfigurasi Clock.
31    let mut flash = dp.FLASH.constrain();
32
33    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
34    let rcc = dp.RCC.constrain();
35
36    // membuat konfigurasi Reset & Control clock (RCC)
37    let clock_config = Config::default()
38        // menggunakan clock external 8MHZ
39        .use_hse(Hertz::MHz(8))
40        // mengatur frekuensi CPU ke 72MHZ
41        .sysclk(Hertz::MHz(72))
42        // mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
43        .hclk(Hertz::MHz(72))
44        // mengatur frekuensi ADC ke 9MHZ
45        .adcclk(Hertz::MHz(9));
46
47    // mengaplikasikan konfigurasi clock ke rcc dan
48    // menyesuaikan 'wait states' memori flash
49    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
50
51    // membuat instans delay dengan menggunakan Timer System Coretex-M3.
52    let mut delay = Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
53
54    // Mengakses periferal ADC1
55    let mut adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
56
57    // Mengakses periferal GPIO Port A
58    let mut gpioa = dp.GPIOA.split(&mut clocks);
59    // Mengonfigurasi PA0 sebagai input analog
60    let mut potentio = gpioa.pa0.into_analog(&mut gpioa.crl);
61
62    // disini program akan dijalankan secara berulang terus menerus
63    loop {
64        // CPU memerintahkan ADC1 untuk membaca dan
65        // mengonversi tegangan input ke nilai digital
66        let data: u16 = adc1.read(&mut potentio).unwrap();
67        // menghitung tegangan input dari nilai digital yang dibaca
68        let voltage_input = 3.3f32 * data as f32 / 4095.0f32;
69        // mengirim pesan ke PC/laptop
70        defmt::println!(
71            "Digital value: {} || voltage input: {}V",
72            data,
73            voltage_input
74        );
75        // tunggu 200 ms
76        delay.delay_ms(200);
77    }
78}

1[[bin]]
2name = "single-conversion-dma"
3path = "src/single_conversion_dma.rs"
4test = false
5bench = false

 1#![no_std]
 2#![no_main]
 3
 4use cortex_m::delay;
 5use defmt_rtt as _;
 6use panic_probe as _;
 7
 8use cortex_m_rt::entry;
 9use stm32f1xx_hal::{adc, pac, prelude::*, rcc::Config, time::Hertz};
10
11#[entry]
12fn main() -> ! {
13    defmt::println!("STM32F103C8 Acess GPIO as Input Analog Single Conversion DMA");
14
15    // Mengakses periferal STM32F103C8
16    let dp = pac::Peripherals::take().unwrap();
17
18    // Mengakses core peripherals (cortex-M3) STM32F103C8
19    let cp = pac::CorePeripherals::take().unwrap();
20
21    // Mengakses periferal FLASH yang akan digunakan untuk menyesuaikan
22    // 'wait states' saat konfigurasi Clock.
23    let mut flash = dp.FLASH.constrain();
24
25    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
26    let rcc = dp.RCC.constrain();
27
28    // membuat konfigurasi Reset & Control clock (RCC)
29    let clock_config = Config::default()
30        // menggunakan clock external 8MHZ
31        .use_hse(Hertz::MHz(8))
32        //mengatur frekuensi CPU ke 72MHZ
33        .sysclk(Hertz::MHz(72))
34        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
35        .hclk(Hertz::MHz(72))
36        //mengatur frekuensi ADC ke 9MHZ
37        .adcclk(Hertz::MHz(9));
38
39    // mengaplikasikan konfigurasi clock ke rcc dan
40    // menyesuaikan 'wait states' memori flash
41    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
42
43    // membuat instans delay dengan menggunakan Timer System Coretex-M3.
44    let mut delay = delay::Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
45
46    // inisialisasi periferal ADC1
47    let adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
48
49    // konfigurasi GPIO PA0 sebagai Input Analog
50    let mut gpioa = dp.GPIOA.split(&mut clocks);
51    let potentio = gpioa.pa0.into_analog(&mut gpioa.crl);
52
53    // inisialisasi DMA1
54    let dma1_channels = dp.DMA1.split(&mut clocks);
55
56    // menghubungkan ADC dengan DMA Channel 1
57    let mut adc_dma = adc1.with_dma(potentio, dma1_channels.1);
58
59    // siapkan Buffer yang akan diisi oleh DMA
60    // (Misal kita ambil 10 sampel untuk dirata-rata)
61    let mut buffer = cortex_m::singleton!(: [u16; 10] = [0; 10]).unwrap();
62
63    loop {
64        // CPU memerintahkan ADC untuk mengonversi dan
65        // menggunakan DMA untuk menyimpan data di buffer
66        let transfer = adc_dma.read(buffer);
67
68        // membaca hasil konversi di buffer DMA
69        let (recovered_buffer, recovered_adc_dma) = transfer.wait();
70
71        // mengolah data (rata-rata 10 sampel) dan menghitung tegangan
72        // dari nilai digital yang dibaca
73        let sum: u32 = recovered_buffer.iter().map(|&v| v as u32).sum();
74        let avg = (sum / recovered_buffer.len() as u32) as u16;
75        let voltage = (avg as f32 / 4095.0) * 3.3;
76        // mengirim pesan ke PC/laptop
77        defmt::println!("Raw Avg: {} | Volt: {}V", avg, voltage);
78
79        // mengembalikan variable buffer dan adc untuk digunakan di loop berikutnya
80        adc_dma = recovered_adc_dma;
81        buffer = recovered_buffer;
82
83        // tunggu 200ms
84        delay.delay_ms(200);
85    }
86}

1[[bin]]
2name = "single-conversion-interrupt"
3path = "src/single_conversion_interrupt.rs"
4test = false
5bench = false

  1#![no_std]
  2#![no_main]
  3
  4use core::sync::atomic::AtomicI16;
  5use core::sync::atomic::Ordering;
  6
  7use cortex_m::delay;
  8use defmt_rtt as _;
  9use panic_probe as _;
 10
 11use cortex_m_rt::entry;
 12use stm32f1xx_hal::adc::SampleTime;
 13use stm32f1xx_hal::gpio::PinExt;
 14use stm32f1xx_hal::pac::Interrupt;
 15use stm32f1xx_hal::pac::interrupt;
 16use stm32f1xx_hal::{adc, pac, prelude::*, rcc::Config, time::Hertz};
 17
 18// Global variable untuk menyimpan nilai ADC. Menggunakan tipe atomic 
 19// untuk menghindari race condition ketika data diubah di fungsi interup
 20// dan dibaca di loop utama.
 21static ADC_VALUE: AtomicI16 = AtomicI16::new(0);
 22
 23#[entry]
 24fn main() -> ! {
 25    defmt::println!("STM32F103C8 Acess GPIO as Input Analog Single Conversion Interrupt");
 26
 27    // Mengakses periferal STM32F103C8
 28    let dp = pac::Peripherals::take().unwrap();
 29
 30    // Mengakses core peripherals (cortex-M3) STM32F103C8
 31    let cp = pac::CorePeripherals::take().unwrap();
 32
 33    // Mengakses periferal FLASH yang akan digunakan untuk menyesuaikan
 34    // 'wait states' saat konfigurasi Clock.
 35    let mut flash = dp.FLASH.constrain();
 36
 37    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
 38    let rcc = dp.RCC.constrain();
 39
 40    // membuat konfigurasi Reset & Control clock (RCC)
 41    let clock_config = Config::default()
 42        // menggunakan clock external 8MHZ
 43        .use_hse(Hertz::MHz(8))
 44        //mengatur frekuensi CPU ke 72MHZ
 45        .sysclk(Hertz::MHz(72))
 46        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
 47        .hclk(Hertz::MHz(72))
 48        //mengatur frekuensi ADC ke 9MHZ
 49        .adcclk(Hertz::MHz(9));
 50
 51    // mengaplikasikan konfigurasi clock ke rcc dan
 52    // menyesuaikan 'wait states' memori flash
 53    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
 54
 55    // membuat instans delay dengan menggunakan Timer System Coretex-M3.
 56    let mut delay = delay::Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
 57
 58    // inisialisasi periferal ADC1
 59    let mut adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
 60
 61    // mengaktifkan interrupt eoc (End of Conversion) pada ADC1
 62    adc1.enable_eoc_interrupt();
 63
 64    // konfigurasi GPIO PA0 sebagai Input Analog
 65    let mut gpioa = dp.GPIOA.split(&mut clocks);
 66    let potentio = gpioa.pa0.into_analog(&mut gpioa.crl);
 67
 68    // mengatur sample time ADC untuk channel PA0 ke default
 69    adc1.set_channel_sample_time(potentio.pin_id(), SampleTime::default());
 70
 71    // Mengaktifkan interupsi ADC1_2.
 72    unsafe {
 73        pac::NVIC::unmask(Interrupt::ADC1_2);
 74    }
 75
 76    // Mengakses lebih dalam ke pointer register ADC1
 77    let adc_reg = unsafe { &*pac::ADC1::ptr() };
 78
 79    // mengatur channel ADC yang akan dikonversi.
 80    // Disini menggunakan PA0 yang berarti channel 0.
 81    adc_reg
 82        .sqr3()
 83        .modify(|_, w| unsafe { w.sq1().bits(potentio.pin_id()) });
 84
 85    loop {
 86        // mengirim pesan ke PC/laptop
 87        defmt::println!("Main program");
 88
 89        // CPU memerintahkan ADC1 untuk memulai konversi. Dengan cara
 90        // mengubah bit swstart ke 1 pada register CR2.
 91        adc_reg.cr2().modify(|_, w| w.swstart().set_bit());
 92
 93        // mengambil nilai dari global variabel ADC_VALUE dan menghitung tegangan
 94        let val = ADC_VALUE.load(Ordering::Relaxed);
 95        let voltage = (val as f32 / 4095.0) * 3.3;
 96        // mengirim pesan ke PC/laptop
 97        defmt::println!("Raw Avg: {} | Volt: {}V", val, voltage);
 98
 99        // tunggu 200ms
100        delay.delay_ms(200);
101    }
102}
103
104// Fungsi Interup: fungsi yang dijalankan CPU ketika ADC mengirim sinyal
105// interup ke CPU. Nama fungsi harus sesuai dengan nama interup yang
106// digunakan: Disini kita menggunakan interup ADC1_2, maka nama fungsinya
107// juga ADC1_2.
108#[interrupt]
109fn ADC1_2() {
110    // mengirim pesan ke PC/laptop
111    defmt::println!("Interrupt ADC");
112
113    // Mengakses lebih dalam ke pointer register ADC1
114    let adc_reg = unsafe { &*pac::ADC1::ptr() };
115
116    // mengecek apakah ADC1 melakukan interup karena eoc atau hal lain.
117    // jika bit eoc pada register SR bernilai 1 artinya ADC selesai melakukan konversi
118    if adc_reg.sr().read().eoc().bit_is_set() {
119        // membaca nilai pada register data (DR) dari ADC1
120        let val = adc_reg.dr().read().bits();
121        // menyimpan nilai ADC ke global variabel ADC_VALUE
122        ADC_VALUE.store(val as i16, Ordering::Relaxed);
123    }
124}