Timer STM32 + Rust: Membaca 1 Pin GPIO Menggunakan 2 channel

 1#![no_std]
 2#![no_main]
 3
 4use core::sync::atomic::{AtomicU32, Ordering};
 5
 6use defmt_rtt as _;
 7use panic_probe as _;
 8
 9use cortex_m_rt::entry;
10use stm32f1xx_hal::{
11    flash::FlashExt,
12    pac::{self, interrupt},
13    prelude::*,
14    rcc::{Config, RccExt},
15    time::Hertz,
16    timer::{Event, Timer},
17};

Memberitahu kompiler Rust untuk tidak menggunakan standard library dan tidak menjalankan program diatas sistem operasi.

Kemudian mendefinisikan library yang akan digunakan dalam project:

• library atomic digunakan untuk mendefinisikan variabel global agar dapat diakses dari blok loop utama dan dapat diakses dari fungsi interrupt.
• Library/crate cortex_m_rt untuk menentukan fungsi entry program akan mulai berjalan dan menangani proses startup program.
• defmt_rtt berfungsi untuk mengirimkan data ke PC/laptop untuk logging menggunakan protokol real time transfer.
• Library stm32f1xx_hal berfungsi agar kita dapat mengakses periferal mikrokontroler STM32F103C8 secara aman.
• panic_probe digunakan untuk menangani jika terjadi runtime error, dan akan otomatis mengirimkan log eror yang terjadi ke host PC/laptop.

1static NUMB_OVERFLOW: AtomicU32 = AtomicU32::new(0);

Membuat variabel global dengan nama NUMB_OVERFLOW untuk menyimpan jumlah timer mengalami overflow. Disini kami menggunakan tipe variabel AtomicU32 agar variabel dapat diakses baik dari blok loop utama maupun dari blok fungsi interrupt (Interrupt Service Routine/ISR) secara aman.

1defmt::println!("STM32F103C8 Timer Channel Cross Mapping");    

Mengirim pesan ke PC/laptop untuk menandai sebagai program timer dengan channel cross-mapping.

 1let dp = pac::Peripherals::take().unwrap();
 2
 3let mut flash = dp.FLASH.constrain();
 4
 5let rcc = dp.RCC.constrain();
 6
 7let clock_config = Config::default()
 8    .use_hse(Hertz::MHz(8))
 9    .sysclk(Hertz::MHz(72))
10    .hclk(Hertz::MHz(72))
11    .pclk1(Hertz::MHz(36));
12
13let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
14    

Mengonfigurasi clock untuk menggunakan clock external sebesar 8 MHz, kemudian menggunakan clock System* sebesar 72 MHz, clock Advanced-High Bus Periferal sebesar 72 MHz, dan clock Advanced-Periferal Bus 1 sebesar 36 MHz. Sehingga frekuensi clock Timer 2 akan menjadi 72 MHz.

1let mut gpioa = dp.GPIOA.split(&mut clocks);
2
3let channel_1 = gpioa.pa0.into_pull_down_input(&mut gpioa.crl);    

Mengakses periferal GPIO Port A (GPIOA) dan mengonfigurasi pin PA0 sebagai input pull-down. Pada tahap selanjutnya pin PA0 akan kita hubungkan ke channel 1 dan ke channel 2 pada Timer 2.

1let timer2 = Timer::new(dp.TIM2, &mut clocks);
2
3unsafe {
4    pac::NVIC::unmask(interrupt::TIM2);
5}

Mengakses periferal Timer 2 dan mengaktifkan interrupt untuk Timer 2 pada NVIC (Nested Vectored Interrupt Controller).

1let mut counter = timer2.counter_hz();

Melakukan setup Timer 2 sebagai counter

1counter.listen(Event::Update);

Mengaktifkan interrupt untuk event update pada Timer 2 STM32F103C8.

1let timer_register = unsafe { &*pac::TIM2::ptr() };
2    

Mengakses pointer register Timer 2 STM32F103C8 secara langsung.

1timer_register.ccmr1_input().modify(|_, w| w.cc1s().ti1());
2timer_register.ccmr1_input().modify(|_, w| w.cc2s().ti1());

Mengonfigurasi channel 1 dan channel 2 sebagai input capture. Kemudian channel 1 dan channel 2 akan dihubungkan ke pin yang sama yaitu pin PA0 (TI1).

1timer_register
2    .ccmr1_input()
3    .modify(|_, w| w.ic1f().fck_int_n8());
4timer_register
5    .ccmr1_input()
6    .modify(|_, w| w.ic2f().fck_int_n8());

Mengaktifkan filter digital untuk channel 1 dan channel 2 pada Timer 2 untuk mengurangi debounce.

1timer_register.ccer().modify(|_, w| w.cc1e().set_bit());
2timer_register.ccer().modify(|_, w| w.cc2e().set_bit());

Mengaktifkan input capture channel 1 dan channel 2 pada Timer 2.

1timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());
2timer_register.ccer().modify(|_, w| w.cc2p().set_bit());

Mengonfigurasi agar channel 1 pada Timer 2 mendeteksi Rising edge. Sedangkan channel 2 pada Timer 2 dikonfigurasi untuk mendeteksi Falling edge.

1counter.start_raw(7199, 65535);

Menjalankan Timer 2 dengan prescaler 7199 dan nilai register Auto-Reload sebesar 65535. Sehingga frekuensi timer menjadi 10 KHz

1let mut start_press_tick = 0u16;
2
3let mut is_pressed = false;

Membuat variabel untuk menyimpan nilai tick saat push button mulai ditekan dan menyimpan status kondisi push button.

1loop {
2        
3}

Membuat blok loop untuk menjalankan program utama secara terus-menerus.

 1if counter.get_interrupt().contains(Event::C1) {
 2    let captured_tick = timer_register.ccr1().read().ccr().bits() as u16;
 3
 4    let pin_is_high = channel_1.is_high();
 5
 6    if pin_is_high && !is_pressed {
 7        start_press_tick = captured_tick;
 8        NUMB_OVERFLOW.store(0, Ordering::SeqCst);
 9
10        is_pressed = true;
11        defmt::println!("--- Button Pressed ---");
12            defmt::println!("start: {}", start_press_tick);
13    }
14    counter.clear_interrupt(Event::C1);
15}

Di dalam blok loop kita mengecek event capture/compare pada channel 1. Jika ada event capture/compare artinya terjadi rising edge pada pin PA0, maka ambil nilai pada register Capture/Compare channel 1 Timer 2. Selanjutnya lihat status dari pin PA0. Jika pin PA0 bernilai HIGH dan nilai variabel is_pressed false, maka update nilai variable start_press_tick dengan nilai tick yang sudah diambil, kemudian reset nilai variabel global NUMB_OVERFLOW ke 0, dan mengubah nilai variabe is_pressed ke true. Jangan lupa untuk membersihkan capture/compare interrupt flag channel 1 meskipun biasanya secara otomatis dibersihkan.

 1if counter.get_interrupt().contains(Event::C2) {
 2    let captured_tick = timer_register.ccr2().read().ccr().bits() as u16;
 3
 4    let pin_is_high = channel_1.is_high();
 5    if !pin_is_high && is_pressed {
 6        let total_overflow = NUMB_OVERFLOW.load(Ordering::SeqCst);
 7
 8        let total_tick =
 9        (total_overflow * 65536) + captured_tick as u32 - start_press_tick as u32;
10
11        defmt::println!(
12            "end: {} | total_overflow: {}",
13            captured_tick,
14            total_overflow
15        );
16        defmt::println!("press long: {} ms", total_tick as f32 / 10f32);
17        defmt::println!("----------------------");
18        is_pressed = false;
19    }
20
21counter.clear_interrupt(Event::C2);
22}

mengecek event capture/compare pada channel 2. Jika ada event capture/compare artinya terjadi falling edge pada pin PA0, maka ambil nilai pada register Capture/Compare channel 2 Timer 2. Selanjutnya lihat status dari pin PA0. Jika pin PA0 bernilai LOW dan nilai variabel is_pressed true, maka hitung total tick selama push buttong ditekan. Selanjutnya menggunakan total tick untuk menghitung durasi push button ditekan, dan mengubah nilai is_pressed ke false. Jangan lupa untuk membersihkan capture/compare interrupt flag channel 2 meskipun biasanya secara otomatis dibersihkan.

 1#[interrupt]
 2fn TIM2() {
 3    let timer_register = unsafe { &*pac::TIM2::ptr() };
 4
 5    // check update interrupt flag
 6    if timer_register.sr().read().uif().bit_is_set() {
 7        // Increment overflow count
 8        NUMB_OVERFLOW.fetch_add(1, Ordering::SeqCst);
 9        // Clear update interrupt flag
10        timer_register.sr().modify(|_, w| w.uif().clear_bit());
11    }
12}

Membuat fungsi interrupt (ISR) untuk Timer 2. Di dalam fungsi tersebut kita mengecek update interrupt flag. Jika interrupt disebabkan oleh event update maka nilai global variabel NUMB_OVERFLOW akan kita tambah 1, dan selanjutnya membersihkan bit update interrupt flag.