Blue Pill (STM3F103C8): ADC Continuous Conversion dengan Rust

 1use cortex_m_rt::entry;
 2
 3use defmt_rtt as _;
 4use panic_probe as _;
 5use stm32f1xx_hal::{
 6    adc::{self, ChannelTimeSequence},
 7    flash::FlashExt,
 8    gpio::{GpioExt, PinExt},
 9    hal::delay::DelayNs,
10    pac,
11    rcc::{Config, RccExt},
12    time::Hertz,
13    timer::SysTimerExt,
14};

Kode tersebut berfungsi untuk mendefinisikan libray-libray yang kita gunakan. Library/crate cortex-m-rt untuk menentukan fungsi entry program akan mulai berjalan dan menangani proses startup program. defmt_rtt berfungsi untuk membantu mengirim data ke PC/laptop untuk logging dengan efisien menggunakan protokol real time transfer . panic_probe digunakan untuk menangani jika terjadi runtime error, dan akan otomati memberikan log error apa yang terjadi ke host PC/laptop. Library stm32f1xx_hal berfungsi agar kita dapat mengakses periferal mikrokontoler STM32F103C8 secara aman.

1#[entry]
2fn main() -> ! {
3    // Kode logik kita
4    // ...
5}

Fungsi main tersebut kita beri macro entry yang berfungsi untuk menentukan bahwa dari fungsi ini program akan mulai dijalankan. Di dalam fungsi main ini kita kan mengakses periferal STM32F103C8 dan membuat kode logik.

1defmt::println!("Input Analog Mode Continuous Poll");

Berfungsi untuk mengirim pesan ke PC/Laptop, sekaligus menandai program mode Continuous Conversion Poll.

1let dp = pac::Peripherals::take().unwrap();
2let cp = pac::CorePeripherals::take().unwrap()

Berfungsi untuk mengakses periferal STM32F103C8 dan periferal CPU Cortex-M3 dan menyimpannya masing-masing di variabel dp dan cp .

1let mut flash = dp.FLASH.constrain();
2let rcc = dp.RCC.constrain();

Mengakses periferal flash dan periferal reset & control clock (RCC). Periferal Flash diperlukan untuk menyesuaikan wait state ketika konfigurasi clock. Periferal RCC digunakan untuk mengonfigurasi clock mikrokontoler STM32F103C8.

1let clock_cfgr = Config::default()
2        .use_hse(Hertz::MHz(8))
3        .sysclk(Hertz::MHz(72))
4        .hclk(Hertz::MHz(72))
5        .adcclk(Hertz::MHz(9));
6
7let mut clocks = rcc.freeze(clock_cfgr, &mut flash.acr);

Membuat konfigurasi clock yang menggunakan clock eksternal ( use_hse ) dengan frekuensi 8 MHz, mengatur System clock ( sysclk ) ke 72 MHz, mengatur Bus clock ( hclk ) ke 72 MHz, dan mengatur ADC clock ( adcclk ) ke 9 MHz. Kemudian menerapkan konfigurasi clock tersebut ke RCC dan sekaligus menyesuaikan wait state memori flash.

1let mut delay = cp.SYST.delay(&clocks.clocks);

Membuat instance delay dengan menggunakan System Timer. Delay akan kita gunakan untuk memberikan waktu tunggu saat program berjalan.

1let mut gpioa = dp.GPIOA.split(&mut clocks);
2let potentio = gpioa.pa0.into_analog(&mut gpioa.crl);

Mengakses periperal GPIO Port A dan mengonfigurasi pin PA0 sebagai input analog yang akan digunakan untuk membaca tegangan input dari potensionmeter.

1let mut adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
2adc1.set_continuous_mode(true);

Mengakses periferal ADC1 dan mengaturnya ke mode continuous conversion.

1let adc_reg = unsafe { &*pac::ADC1::ptr() };

Mengakses pointer register ADC1 secara langsung agar kita bisa mengubah bit registernya untuk menyesuaikan ke mode continuous conversion dengan metode poll.

1adc_reg.cr2().modify(|_, w| w.adon().clear_bit());

Mengatur register CR2 bit ADON ke 0 untuk mematikan ADC agar aman saat mengonfigurasi bit register yang lain.

1adc_reg.cr1().modify(|_, w| w.scan().clear_bit());

Menonaktifkan Mode Scan Conversion, karena kita hanya akan menggunakan 1 channel. Register CR1 bit SCAN akan bernilai 0.

1adc_reg.cr1().modify(|_, w| w.discen().clear_bit());

Menonaktifkan mode Discontinuous Conversion agar mode continuous conversion dapat berjalan. Mode Discontinuous Conversion otomatis diaktifkan ketika kita memanggil fungsi Adc::new . Register CR1 bit DISCEN akan bernilai 0.

1adc_reg.sqr1().modify(|_, w| unsafe { w.l().bits(0b0000) });

Menentukan jumlah channel yang digunakan, karena kita menggunakan 1 channel maka diisi dengan 0 (jumlah channel-1).

1adc_reg.cr2().modify(|_, w| w.adon().set_bit());

Menyalakan kembali ADC1. Register CR2 bit ADON akan bernilai 1.

1adc_reg
2    .sqr3()
3    .modify(|_, w| unsafe { w.sq1().bits(potentio.pin_id()) });

Mengatur channel ADC yang akan dibaca. Perintah potentio.pin_id() akan mengembalikan nilai pin ID dari pin PA0 yaitu 0.

1// adc_reg.cr2().modify(|_, w| w.adon().set_bit());
2adc_reg.cr2().modify(|_, w| w.swstart().set_bit());

Memulai konversi dengan mengatur register CR2 bit SWSTART ke 1. Kita juga bisa memulai konversi dengan mengatur register CR2 bit ADON ke 1 sekali lagi. Silakan pilih salah satu sesuai dengan keinginan anda.

1loop {
2    // Kode utama
3    // yang dijalankan berulang-ulang
4    // ...
5}

Merupakan blok perulangan. Di dalam blok tersebut kita akan menaruh program utama kita, sehingga akan terus dijalankan secara berulang-ulang.

1if adc_reg.sr().read().eoc().bit_is_set() {
2    // Baca nilai ADC
3}

Kode ini kita taruh dalam blok loop agar dijalankan secara berulang-ulang. Kode tersebut berfungsi untuk memmbaca nilai register SR bit EOC , jika nilainya 1 (selesai melakukan konversi) maka jalankan perintah kode di dalam blok if.

1let val = adc_reg.dr().read().bits();
2let voltage = (val as f32 / 4095.0) * 3.3;
3defmt::println!("Raw Avg: {} | Volt: {}V", val, voltage);
4delay.delay_ms(500);

Di dalam blok if kita isi dengan kode ini, yang berfungsi untuk membaca nilai ADC dari DATA register DR yang disimpan dalam variabel val . Kemudian menghitung besar tegangan input yang disimpan dalam variabel voltage . Selanjutnya nilai variabel val dan voltage dikirimkan ke terminal PC/laptop, dan kita beri jeda selama 500 ms.

 1#![no_std]
 2#![no_main]
 3
 4use cortex_m_rt::entry;
 5
 6use defmt_rtt as _;
 7use panic_probe as _;
 8use stm32f1xx_hal::{
 9    adc::{self},
10    dma::{CircReadDma, DmaExt},
11    flash::FlashExt,
12    gpio::GpioExt,
13    pac,
14    prelude::*,
15    rcc::{Config, RccExt},
16    time::Hertz,
17    timer::SysTimerExt,
18};

Pastikan anda menggunakan menggunakan modul stm32f1xx_hal::dma::{CircReadDma, DmaExt} karena kita akan menggunakan periferal Direct Memory Access (DMA).

1defmt::println!("Input Analog Mode Continuous DMA");
2
3let dp = pac::Peripherals::take().unwrap();
4let cp = pac::CorePeripherals::take().unwrap();

Untuk mengirim pesan ke terminal PC/laptop, kemudian mengakses periferal STM32F103C8 dan periferal CPU Cortex-M3.

 1let mut flash = dp.FLASH.constrain();
 2let rcc = dp.RCC.constrain();
 3
 4let clock_cfgr = Config::default()
 5        .use_hse(Hertz::MHz(8))
 6        .sysclk(Hertz::MHz(72))
 7        .hclk(Hertz::MHz(72))
 8        .adcclk(Hertz::MHz(9));
 9
10let mut clocks = rcc.freeze(clock_cfgr, &mut flash.acr);

Mengakses periferal flash dan periferal reset & control clock (RCC). Kemudian mengonfigurasi clock ke clock eksternal sebesar 8 MHz, mengatur System clock ke 72 MHz, mengatur Bus clock ke 72 MHz, dan mengatur ADC clock ke 9 MHz.

1let mut gpioa = dp.GPIOA.split(&mut clocks);
2let potentio = gpioa.pa0.into_analog(&mut gpioa.crl);

Mengakses periferal GPIO A dan mengonfigurasi pin PA0 sebagai input analog yang dihubungkan ke potensiometer. Sesuai dengan gambar skematik sebelumnya.

1let mut adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
2
3adc1.set_sample_time(adc::SampleTime::T_239);

Mengakses periferal ADC1. Kemudian mengatur sample time ADC1 ke 239 cycles.

1let dma1_channels = dp.DMA1.split(&mut clocks);

Mengakses periferal DMA1.

1let adc_dma = adc1.with_dma(potentio, dma1_channels.1);

Mengonfiguras ADC1 untuk menggunakan DMA1 channel 1 dan secara otomatis akan mengubah ADC1 ke mode continuous conversion.

1let buffer = cortex_m::singleton!(: [[u16; 300];2] = [[0; 300];2]).unwrap();

Menyiapkan buffer yang akan diisi nilai ADC oleh DMA. Kita menggunakan Array unsigned integer 16 bit dengan panjang buffer 300 item sebanyak 2 buah untuk setengah buffer bagian pertama dan setengah buffer bagian kedua.

1let mut circ_buffer = adc_dma.circ_read(buffer);

Memerintahkan ADC1 untuk memulai konversi. Kita hanya perlu memerintahkan konversi sekali saja karena sudah dalam mode continuous conversion, sehingga selanjutnya ADC1 akan otomatis akan melakukan konversi lagi secara terus menerus tanpa menunggu perintah dari CPU lagi. ADC1 dibantu DMA akan otomatis mengisi setengah buffer (pertama atau kedua) setiap selesai melakukan konversi.

1let mut counter = cp.SYST.counter_us(&clocks.clocks);
2let _ = counter.start(230_000.micros()).unwrap();
3let mut last_update_time = counter.now();
4let interval = 200_000u32.micros::<1, 1_000_000>();

Membuat counter yang akan kita gunakan sebagai waktu jeda (delay), karena ketika menggunakan circular read kita tidak bisa menggunakan delay blocking. Kami menggunakan System Timer untuk membuat counter yang bertambah tiap mikrodetik dengan nilai maksimal 230000 mikrodetik (230 ms). Kita juga butuh variable last_update_time untuk menyimpan nilai counter terakhir dan variabel interval untuk menentukan lama waktu jeda disini kami menggunakan 200000 mikrodetik (200 ms).

1loop {
2    if let Ok(half) = circ_buffer.readable_half() {
3        // program membaca nilai ADC
4    }
5}

Di dalam loop kita akan mengecek circular buffer , jika sudah bisa dibaca setengah buffernya maka kita akan mengambil nilainya.

1let avg = circ_buffer.peek(|data, h| {
2    if h == half {
3        let sum: u32 = data.iter().map(|&v| v as u32).sum();
4        (sum / data.len() as u32) as u16
5    } else {
6        0
7    }
8});

Kita menggunakan method peek untuk membaca setengah buffer yang sudah terisi dari circular_buffer . Jika nilai dari variabel h sama dengan variabel half pada readable_half() maka hitung rata-ratanya dan simpan di variabel avg . Atau jika tidak sama maka simpan nilai 0 di variabel avg .

 1let now = counter.now();
 2
 3if last_update_time.ticks().wrapping_sub(now.ticks()) >= interval.ticks() {
 4    if let Ok(avg) = avg {
 5        let voltage = (avg as f32 / 4095.0) * 3.3;
 6        defmt::println!("ADC: {} | Volt: {}V", avg, voltage);
 7    }
 8
 9    last_update_time = now;
10}

Pertama kita simpan nilai counter saat ini ke variabel now . Kemudian kurangkan variabel last_update_time dengan now , jika lebih besar dari interval maka hitung nilai voltage dari nilai ADC dan kirim ke terminal PC/laptop. Dengan begitu program akan mengirim data setiap 200000 mikrodetik (200 ms) ke terminal PC/laptop. Terkahir perbarui nilai variabel last_update_time dengan nilai now .

 1#![no_std]
 2#![no_main]
 3
 4use core::sync::atomic::{AtomicI16, Ordering};
 5
 6use cortex_m_rt::entry;
 7
 8use defmt_rtt as _;
 9use panic_probe as _;
10use stm32f1xx_hal::{
11    adc::{self, ChannelTimeSequence},
12    flash::FlashExt,
13    gpio::{GpioExt, PinExt},
14    hal::delay::DelayNs,
15    pac::{self, interrupt},
16    rcc::{Config, RccExt},
17    time::Hertz,
18    timer::SysTimerExt,
19};

Disana kita menggunakan library atomic untuk menyimpan data pada variabel yang dibagikan antar thread secara aman, dalam hal ini agar dapat diakses dari fungsi Interupsi dan fungsi utama.

1static ADC_VALUE: AtomicI16 = AtomicI16::new(0);

Membuat variabel global dengan tipe Atomic16 untuk menyimpan nilai ADC agar dapat diakses dengan aman baik dari fungsi Interupsi dan fungsi utama.

1defmt::println!("Input Analog Mode Continuous Interrupt");
2
3let dp = pac::Peripherals::take().unwrap();
4let cp = pac::CorePeripherals::take().unwrap();

Berfungsi untuk mengirim pesan ke PC/laptop, kemudian mengakses periferal STM32F103C8 dan periferal CPU Cortex-M3.

 1let mut flash = dp.FLASH.constrain();
 2let rcc = dp.RCC.constrain();
 3
 4let clock_cfgr = Config::default()
 5        .use_hse(Hertz::MHz(8))
 6        .sysclk(Hertz::MHz(72))
 7        .hclk(Hertz::MHz(72))
 8        .adcclk(Hertz::MHz(9));
 9
10let mut clocks = rcc.freeze(clock_cfgr, &mut flash.acr);

Mengakses periferal flash dan periferal reset & control clock (RCC). Kemudian mengonfigurasi clock ke clock eksternal sebesar 8 MHz, mengatur System clock ke 72 MHz, mengatur Bus clock ke 72 MHz, dan mengatur ADC clock ke 9 MHz.

1let mut delay = cp.SYST.delay(&clocks.clocks);

Membuat instance delay untuk memberikan waktu jeda.

1let mut gpioa = dp.GPIOA.split(&mut clocks);
2let potentio = gpioa.pa0.into_analog(&mut gpioa.crl);

Mengakses periferal GPIO pin PA0 sebagai input analog yang dihubungkan ke potensiometer.

1let mut adc1 = adc::Adc::new(dp.ADC1, &mut clocks);
2
3adc1.set_sample_time(adc::SampleTime::T_239);
4adc1.set_continuous_mode(true);
5adc1.enable_eoc_interrupt();

Mengakses periferal ADC1. Kemudian mengonfigurasi sample time ADC1 ke 239 cycle dengan mode continuous conversion. Kita juga mengaktifkan EOC interrupt pada ADC1.

1unsafe {
2    pac::NVIC::unmask(interrupt::ADC1_2);
3}

Mengaktifkan interrupt ADC1_2 agar CPU ARM Cortex-M3 dapat menerima interrupt dari ADC1.

1let adc_reg = unsafe { &*pac::ADC1::ptr() };

Mengakses pointer register ADC1 secara langsung agar kita bisa mengubah bit registernya untuk menyesuaikan ke mode continuous conversion dengan metode poll.

1adc_reg.cr2().modify(|_, w| w.adon().clear_bit());

Mengatur register CR2 bit ADON ke 0 untuk mematikan ADC agar aman saat mengonfigurasi bit register yang lain.

1adc_reg.cr1().modify(|_, w| w.scan().clear_bit());

Menonaktifkan Mode Scan Conversion, karena kita hanya akan menggunakan 1 channel. Register CR1 bit SCAN akan bernilai 0.

1adc_reg.cr1().modify(|_, w| w.discen().clear_bit());

Menonaktifkan mode Discontinuous Conversion agar mode continuous conversion dapat berjalan. Mode Discontinuous Conversion otomatis diaktifkan ketika kita memanggil fungsi Adc::new . Register CR1 bit DISCEN akan bernilai 0.

1adc_reg.sqr1().modify(|_, w| unsafe { w.l().bits(0b0000) });

Menentukan jumlah channel yang digunakan, karena kita menggunakan 1 channel maka diisi dengan 0 (jumlah channel-1).

1adc_reg.cr2().modify(|_, w| w.adon().set_bit());

Menyalakan kembali ADC1. Register CR2 bit ADON akan bernilai 1.

1adc_reg
2    .sqr3()
3    .modify(|_, w| unsafe { w.sq1().bits(potentio.pin_id()) });

Mengatur channel ADC yang akan dibaca. Perintah potentio.pin_id() akan mengembalikan nilai pin ID dari pin PA0 yaitu 0.

1// adc_reg.cr2().modify(|_, w| w.adon().set_bit());
2adc_reg.cr2().modify(|_, w| w.swstart().set_bit());

Memulai konversi dengan mengatur register CR2 bit SWSTART ke 1. Kita juga bisa memulai konversi dengan mengatur register CR2 bit ADON ke 1 sekali lagi. Silakan pilih salah satu sesuai dengan keinginan anda.

 1defmt::println!("Main program");
 2
 3// Load value from global variable ADC_VALUE and calculate voltage
 4let val = ADC_VALUE.load(Ordering::Relaxed);
 5let voltage = (val as f32 / 4095.0) * 3.3;
 6
 7// Send results to PC/laptop
 8defmt::println!("Raw Avg: {} | Volt: {}V", val, voltage);
 9
10// Wait for 200ms
11delay.delay_ms(200);

Pertama kita mengirimkan pesan ke terminal PC/laptop untuk menandai ini sebagai program utama. Kemudian membaca nilai ADC dari variabel global ADC_VALUE yang selanjutnya dihitung untuk mendapatkan tegangan input dari potensiometer. Selanjutnya nilai ADC dan tegangan dikirimkan ke terminal PC/laptop, dan kita beri jeda selama 200 ms.

 1#[interrupt]
 2fn ADC1_2() {
 3    // Send message to PC/laptop
 4    defmt::println!("Interrupt ADC");
 5
 6    // Access the ADC1 register pointer directly
 7    let adc_reg = unsafe { &*pac::ADC1::ptr() };
 8
 9    // Check if ADC1 triggered the interrupt due to EOC (End of Conversion) or other factors.
10    if adc_reg.sr().read().eoc().bit_is_set() {
11        // Read value from ADC1 Data Register (DR)
12        let val = adc_reg.dr().read().bits();
13        // Store the ADC value into global variable ADC_VALUE
14        ADC_VALUE.store(val as i16, Ordering::Relaxed);
15
16        defmt::println!("ADC Value: {}", val);
17    }
18}

Fungsi ini akan dieksekusi oleh CPU ketika ADC1 mengirimkan interupsi ke CPU. Pertama kita mengirimkan pesan ke terminal PC/laptop untuk menandai bahwa ini program interupsi. Kemudian mengakses pointer register ADC1. Selanjutnya mengecek nilai bit EOC (End of Conversion) pada register SR, Jika nilainya 1 maka baca nilai ADC dari DATA di register DR yang selanjutnya disimpan di global variabel ADC_VALUE . Selain itu kita juga mengirimkan nilai ADC ke terminal PC/laptop.