Mengukur Lebar Pulsa dengan STM32 Timer Input Capture menggunakan Rust

Apa itu Input Capture?

Input capture merupakan salah satu fungsi dari Timer STM32F103C8 untuk menyimpan nilai counter Timer saat terjadi perubahan tegangan pada pin input (channel Timer). Ketika terjadi perubahan tegangan pada channel Timer, maka secara otomatis akan menyalin nilai pada register counter (TIMx_CNT) ke register TIMx_CCR (Capture/Compare Register). Berikut merupakan perubahan tegangan channel Timer yang dapat dideteksi oleh fitur input capture:

1. Rising edge: Input capture hanya menyalin nilai register TIMx_CNT ke register TIMx_CCR ketika terjadi perubahan tegangan dari 0V ke 3.3V (LOW ke HIGH).
2. Falling edge: Input capture hanya menyalin nilai register TIMx_CNT ke register TIMx_CCR ketika terjadi perubahan tegangan dari 3.3V ke 0V (HIGH ke LOW).
3. Both edges (Rising/Falling edge): Input capture menyalin nilai register TIMx_CNT ke register TIMx_CCR ketika terjadi perubahan tegangan dari 0V ke 3.3V (LOW ke HIGH) atau 3.3V ke 0V (HIGH ke LOW).

Dengan menggunakan selisih nilai register TIMx_CCR ketika terjadi perubahan tegangan maka kita bisa mengetahui durasi dari perubahan tegangan pertama sampai perubahan tegangan kedua (lebar pulsa). Berikut merupakan persamaan untuk mencari durasi (lebar pulsa) 2 peristiwa pada channel Timer:

Keterangan:

• $T$ : Periode antar 2 peristiwa pada channel Timer (lebar pulsa).
• $\Delta_{tick}$ : Selisih nilai register TIMx_CCR ketika terjadi perubahan tegangan.
• $f_{timer}$ : Frekuensi Timer yang digunakan.
• $CCR$ : Nilai register Capture/Compare (TIMx_CCR).

Persiapan Hardware

Komponen yang digunakan pada tutorial kali ini antara lain: Mikrokontroler STM32F103C8 (Blue Pill), ST-Link USB Downloader Debuger, Breadboard, push button, dan beberapa kabel jumper (female to female dan male to male).

1. Mikrokontroler STM32F103C8 (Blue Pill):

   Merupakan komponen utama yang dibutuhkan. Kita akan mengakses periferal Timer dari mikrokontroler STM32F103C8.

   

2. ST-LINK USB Downloader Debuger:

   ST-LINK USB Downloader Debuger digunakan untuk memprogram dan melakukan debugging pada mikrokontroler STM32F103C8. Komponen ini yang akan menghubungkan PC/laptop ke mikrokontroler STM32F103C8.

   

3. Breadboard

   Breadboard digunakan untuk membuat prototipe rangkaian elektronik. Dengan menggunakan breadboard kita tidak perlu menyolder komponen, cukup dengan menggunakan kabel jumper male to male.

   

4. Push Button

   Push button digunakan sebagai input ke channel Timer mikrokontroler STM32F103C8. Ketika push button ditekan maka kedua kakinya akan terhubung.

   

5. Kabel Jumper

   Kabel jumper digunakan untuk menghubungkan komponen-komponen di breadboard, selain itu juga digunakan untuk menghubungkan Blue Pill dengan ST-Link USB Downloader Debuger.

Penjelasan lebih detail mengenai fungsi komponen-komponen yang digunakan dapat dilihat pada halaman Setup STM32F103C8 dengan Rust dan halaman Menggunakan GPIO STM32F103C8 dengan Rust.

Timer STM32F103C8 sebagai Input Capture dengan Rust

Pada artikel ini, kita akan menggunakan timer sebagai input capture untuk hal sederhana yaitu mengukur berapa lama push button ditekan. Meksipun sederhana, ini merupakan konsep dasar yang nanti akan digunakan ketika kita ingin membaca sensor seperti tachometer, sensor jarak ultrasonic (HC-SR04), dan lain-lain.

Kita akan menggunakan Timer 2 dengan channel 1 (pin PA0) sebagai input capture. Push button digunakan untuk memberikan pulsa input ke channel 1 Timer 2. Ketika push button ditekan maka terjadi perubahan tegangan pada pin PA0, perubahan tegangan inilah yang akan dideteksi oleh input capture.

Pada tutorial ini kita akan menggunakan channel 1 Timer 2 dengan mode rising edge dan falling edge secara bergantian, karena Timer 2 tidak mendukung mode both edges.

Rangkaian skematik STM32F103C8 untuk Input Capture

Salah satu kaki push button dihubungakan ke channel 1 Timer 2 (pin PA0) mikrokontroler STM32F103C8, kaki satunya lagi kita hubungkan ke tegangan 3.3V. Pin PA0 (channel 1 Timer 2) juga akan kita konfigurasi sebagai input pull-down. Berikut merupakan skematik rangkaian yang digunakan, silakan buat rangkaiannya di bredboard:

Ketika push button ditekan maka pin PA0 (channel 1 Timer 2) akan terhubung ke tegangan 3.3V, sehingga input capture mendeteksi perubahan tegangan (Rising edge). Karena pin PA0 dikonfigurasi sebagai input pull-down maka setelah push button dilepas, pin PA0 akan terhubung ke GND, sehingga input capture mendeteksi perubahan tegangan (Falling edge). Dengan menggunakan selisih nilai register TIMx_CCR saat Rising edge dan Falling edge maka kita akan dapat mengetahui berapa lama push button ditekan.

Memprogram Timer STM32F103C8 sebagai Input Capture dengan Rust

Pertama mari buat project Rust baru sesuai dengan halaman ini. Buka file Cargo.toml lalu tambahkan kode berikut untuk mendefinisikan binary executable baru dengan nama timer-input-capture :

1[[bin]]
2name = "timer-input-capture"
3path = "src/main.rs"
4test = false
5bench = false

Selanjutnya buka file src/main.rs, tambahkan kode berikut untuk memberitahu compiler bahwa program ini tidak menggunakan standard library:

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

1defmt::println!("STM32F103C8 Timer as Input Capture");

 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);

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

1let timer2 = Timer::new(dp.TIM2, &mut clocks);
2
3let mut counter = timer2.counter_hz();

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

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

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

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

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

Catatan: Ketika bit CCxP bernilai 0 maka channel tersebut akan mendeteksi Rising Edge, sedangkan ketika bernilai 1 maka akan mendeteksi Falling Edge.

1// frekuensi 10KHz dan Arr maks
2counter.start_raw(7199, 65535);

Dengan menggunakan prescaler 7199 maka frekuensi timer akan menjadi 10 kHz (10000 Hz), artinya timer dapat mendeteksi dengan ketelitian $\frac {1} {10000}=0.1\ ms$ . Berikut merupakan perhitungan frekuensi timer tersebut:

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

1loop {
2    if timer_register.sr().read().cc1if().bit_is_set() {
3           
4    }
5}

 1let captured_tick = timer_register.ccr1().read().ccr().bits();
 2
 3let pin_is_high = channel_1.is_high();
 4
 5if pin_is_high && !is_pressed {
 6    // Push button mulai ditekan
 7    start_press_tick = captured_tick;
 8    timer_register.ccer().modify(|_, w| w.cc1p().set_bit());
 9
10    is_pressed = true;
11    defmt::println!("--- Button Pressed ---");
12    defmt::println!("start: {}", start_press_tick);
13} else if !pin_is_high && is_pressed {
14    // Push button dilepas
15    let delta = captured_tick.wrapping_sub(start_press_tick);
16    timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());
17
18    defmt::println!("end: {} | delta: {}", captured_tick, delta);
19    defmt::println!("press long: {} ms", delta as f32 / 10f32);
20    defmt::println!("----------------------");
21    is_pressed = false;
22}
23
24timer_register.sr().modify(|_, w| w.cc1if().clear_bit());

Perhitungan durasi tombol ditekan:

 1#![no_std]
 2#![no_main]
 3
 4use defmt_rtt as _;
 5use panic_probe as _;
 6
 7use cortex_m_rt::entry;
 8use stm32f1xx_hal::{
 9    flash::FlashExt,
10    pac,
11    prelude::*,
12    rcc::{Config, RccExt},
13    time::Hertz,
14    timer::Timer,
15};
16
17#[entry]
18fn main() -> ! {
19    defmt::println!("STM32F103C8 Timer as Input Capture");
20
21    let dp = pac::Peripherals::take().unwrap();
22
23    let mut flash = dp.FLASH.constrain();
24
25    let rcc = dp.RCC.constrain();
26
27    let clock_config = Config::default()
28        .use_hse(Hertz::MHz(8))
29        .sysclk(Hertz::MHz(72))
30        .hclk(Hertz::MHz(72))
31        .pclk1(Hertz::MHz(36));
32
33    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
34
35    let mut gpioa = dp.GPIOA.split(&mut clocks);
36
37    let channel_1 = gpioa.pa0.into_pull_down_input(&mut gpioa.crl);
38
39    let timer2 = Timer::new(dp.TIM2, &mut clocks);
40
41    let mut counter = timer2.counter_hz();
42
43    let timer_register = unsafe { &*pac::TIM2::ptr() };
44
45    // 00 output
46    // 01 input
47    // 10 Input, (Cross-mapping channel 2).
48    timer_register.ccmr1_input().modify(|_, w| w.cc1s().ti1());
49
50    timer_register
51        .ccmr1_input()
52        .modify(|_, w| w.ic1f().fck_int_n8());
53
54    timer_register.ccer().modify(|_, w| w.cc1e().set_bit());
55
56    timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());
57
58    counter.start_raw(7199, 65535);
59
60    let mut start_press_tick = 0u16;
61
62    let mut is_pressed = false;
63
64    loop {
65        if timer_register.sr().read().cc1if().bit_is_set() {
66            let captured_tick = timer_register.ccr1().read().ccr().bits();
67
68            let pin_is_high = channel_1.is_high();
69
70            if pin_is_high && !is_pressed {
71                start_press_tick = captured_tick;
72                timer_register.ccer().modify(|_, w| w.cc1p().set_bit());
73
74                is_pressed = true;
75                defmt::println!("--- Button Pressed ---");
76                defmt::println!("start: {}", start_press_tick);
77            } else if !pin_is_high && is_pressed {
78                let delta = captured_tick.wrapping_sub(start_press_tick);
79                timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());
80
81                defmt::println!("end: {} | delta: {}", captured_tick, delta);
82                defmt::println!("press long: {} ms", delta as f32 / 10f32);
83                defmt::println!("----------------------");
84                is_pressed = false;
85            }
86
87            timer_register.sr().modify(|_, w| w.cc1if().clear_bit());
88        }
89    }
90}

Dengan menggunakan ST-Link USB Downloader Debuger hubungkan mikrokontroler STM32F103C8 ke PC/laptop. Kemudian jalankan program dengan perintah ‘cargo run --bin timer-input-capture’ pada terminal. Berikut merupakan hasil dari program ketika dijalankan:

Ketika push button mulai ditekan di terminal akan muncul nilai tick saat mulai ditekan, kemudian saat dilepas nilai tick, selisih dan durasi push button ditekan akan muncul di terminal.

Peringatan: Karena timer di set ke frekuensi 10 KHz (mampu mengukur dengan ketelitian 0.1 ms) dan ARR disetting ke maksimal (65535), maka lama maksimal durasi pengukuran makimal adalah $0.1\times65535=6553.5\ ms$ . Jika tombol ditekan malebihi waktu tersebut maka akan direset kembali ke 0 dan menyebabkan pengukuran tidak akurat. Hal ini karena nilai CNT direset ke 0 kembali ketika mencapai nilai $ARR+1$ dan menghitung kembali sampai nilai ARR.

Permasalahan dan Source Code

Masalah dalam menggunakan Input Capture:

• Dalam membuat tutorial ini awalnya kami ingin menggunakan mode both edge. Tetapi karena Timer 2 STM32F103C8 tidak mendukung mode both edges, maka kami mengakalinya dengan mengubah mode dari rising edge ke falling edge ketika tombol mulai ditekan dan mengubah kembali ke rising edge ketika tombol selesai ditekan.
• Durasi maksimal pengukuran adalah $0.1\times65535=6553.5\ ms$ . Untuk mengatasi hal ini, solusinya akan kami bahas pada artikel selanjutnya.

Source code yang digunakan pada tutorial ini dapat diakses pada repositori Github.

Jika anda mengalami kendala ketika mengikuti tutorial ini, ingin bertanya, atau menyampaikan kritik dan saran, silakan hubungi kami melalui halaman kontak.