Rust + STM32 Blue Pill: Panduan Lengkap Input-Output untuk Pemula

 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    flash::FlashExt,
11    gpio::GpioExt,
12    pac,
13    rcc::{Config, RccExt},
14    time::Hertz,
15};
16
17#[entry]
18fn main() -> ! {
19    defmt::println!("STM32F103C8 GPIO as Output");
20
21    // Mengakses periferal STM32F103C8
22    let dp = pac::Peripherals::take().unwrap();
23
24    // Mengakses core peripherals (cortex-M3) STM32F103C8
25    let cp = pac::CorePeripherals::take().unwrap();
26
27    // Mengakses periferal FLASH yang akan digunakan untuk menyesuaikan
28    // 'wait states' saat konfigurasi Clock.
29    let mut flash = dp.FLASH.constrain();
30
31    // Mengakses periferal Reset & Control Clock (RCC)
32    // agar dapat dikonfigurasi
33    let rcc = dp.RCC.constrain();
34
35    // membuat konfigurasi Reset & Control clock (RCC)
36    let clock_config = Config::default()
37        // menggunakan clock external 8MHZ
38        .use_hse(Hertz::MHz(8))
39        //mengatur frekuensi CPU ke 72MHZ
40        .sysclk(Hertz::MHz(72))
41        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
42        .hclk(Hertz::MHz(72));
43
44    // mengaplikasikan konfigurasi clock ke rcc dan
45    // menyesuaikan 'wait states' memori flash
46    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
47
48    // membuat instans delay dengan menggunakan Timer System.
49    let mut delay = Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
50
51    // Mengakses periferal GPIO Port C
52    let mut gpioc = dp.GPIOC.split(&mut clocks);
53
54    // Mengatur GPIOC pin 13 (PC13) sebagai output open-drain untuk
55    // menyalakan dan mematikan LED. (crl: pin 0-7; crh: pin 8-15)
56    let mut led = gpioc.pc13.into_open_drain_output(&mut gpioc.crh);
57
58    //  Tunggu 5 detik dan lihat kondisi LED on atau off?
59    defmt::println!("Default logic value of pin output:");
60    defmt::println!("\tlow: {}", led.is_set_low());
61    defmt::println!("\thigh: {}", led.is_set_high());
62    delay.delay_ms(5000);
63
64    // disini program akan dijalankan secara berulang terus menerus
65    loop {
66        // mengirim pesan ke PC/laptop
67        defmt::println!("LED off");
68        // atur pin led (PC13) ke logika HIGH
69        led.set_high();
70        // Delay selama 2 detik
71        delay.delay_ms(2000);
72
73        // mengirim pesan ke PC/laptop
74        defmt::println!("LED on");
75        // atur pin led (PC13) ke logika LOW
76        led.set_low();
77        // Delay selama 2 detik
78        delay.delay_ms(2000);
79    }
80}

1let mut led = gpioc
2        .pc13
3        // pin sebagai output open-drain dengan state HIGH
4        .into_open_drain_output_with_state(&mut gpioc.crh, PinState::High);

1let mut led = gpioc
2        .pc13
3        // pin sebagai output push-pull dengan state HIGH
4        .into_push_pull_output_with_state(&mut gpioc.crh, PinState::High);

1[[bin]]
2name = "gpio-input-pullup"
3path = "src/input_pullup.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    flash::FlashExt,
11    gpio::GpioExt,
12    pac,
13    rcc::{Config, RccExt},
14    time::Hertz,
15};
16
17#[entry]
18fn main() -> ! {
19    defmt::println!("STM32F103C8 Acess GPIO as Input Pull Up");
20
21    // Mengakses periferal STM32F103C8
22    let dp = pac::Peripherals::take().unwrap();
23
24    // Mengakses core peripherals (cortex-M3) STM32F103C8
25    let cp = pac::CorePeripherals::take().unwrap();
26
27    // Mengakses periferal FLASH yang akan digunakan untuk
28    // menyesuaikan 'wait states' saat konfigurasi Clock.
29    let mut flash = dp.FLASH.constrain();
30
31    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
32    let rcc = dp.RCC.constrain();
33
34    // membuat konfigurasi Reset & Control clock (RCC)
35    let clock_config = Config::default()
36        // menggunakan clock external 8MHZ
37        .use_hse(Hertz::MHz(8))
38        //mengatur frekuensi CPU ke 72MHZ
39        .sysclk(Hertz::MHz(72))
40        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
41        .hclk(Hertz::MHz(72));
42
43    // mengaplikasikan konfigurasi clock ke rcc dan 
44    // menyesuaikan 'wait states' memori flash
45    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
46
47    // membuat instans delay dengan menggunakan Timer System.
48    let mut delay = Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
49
50    // Mengakses periferal GPIO Port B
51    let mut gpiob = dp.GPIOB.split(&mut clocks);
52
53    // mengatur pin PB0 sebagai input pull-up
54    let button_pullup = gpiob.pb0.into_pull_up_input(&mut gpiob.crl);
55
56    // tunggu 50 ms
57    delay.delay_ms(50);
58
59    loop {
60        // Cek jika tombol ditekan maka PB0 akan low
61        if button_pullup.is_low() {
62            // kirim pesan ke PC/laptop
63            defmt::println!("button_pullup is pressed");
64            // delay 500ms
65            delay.delay_ms(500);
66        }
67    }
68}

1[[bin]]
2name = "gpio-input-pulldown"
3path = "src/input_pulldown.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    flash::FlashExt,
11    gpio::GpioExt,
12    pac,
13    rcc::{Config, RccExt},
14    time::Hertz,
15};
16
17#[entry]
18fn main() -> ! {
19    defmt::println!("STM32F103C8 Acess GPIO as Input Pull Down");
20
21    // Mengakses periferal STM32F103C8
22    let dp = pac::Peripherals::take().unwrap();
23
24    // Mengakses core peripherals (cortex-M3) STM32F103C8
25    let cp = pac::CorePeripherals::take().unwrap();
26
27    // Mengakses periferal FLASH yang akan digunakan untuk 
28    // menyesuaikan 'wait states' saat konfigurasi Clock.
29    let mut flash = dp.FLASH.constrain();
30
31    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
32    let rcc = dp.RCC.constrain();
33
34    // membuat konfigurasi Reset & Control clock (RCC)
35    let clock_config = Config::default()
36        // menggunakan clock external 8MHZ
37        .use_hse(Hertz::MHz(8))
38        //mengatur frekuensi CPU ke 72MHZ
39        .sysclk(Hertz::MHz(72))
40        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
41        .hclk(Hertz::MHz(72));
42
43    // mengaplikasikan konfigurasi clock ke rcc dan
44    // menyesuaikan 'wait states' memori flash
45    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
46
47    // membuat instans delay dengan menggunakan Timer System.
48    let mut delay = Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
49
50    // Mengakses periferal GPIO Port B
51    let mut gpiob = dp.GPIOB.split(&mut clocks);
52
53    // mengatur pin PB0 sebagai input pull-down
54    let button_pulldown = gpiob.pb0.into_pull_down_input(&mut gpiob.crl);
55
56    // tunggu 50 ms
57    delay.delay_ms(50);
58
59    loop {
60        // Cek jika tombol ditekan maka PB0 akan high
61        if button_pulldown.is_high() {
62            // kirim pesan ke PC/laptop
63            defmt::println!("button_pulldown is pressed");
64            // delay 500ms
65            delay.delay_ms(500);
66        }
67    }
68}

1[[bin]]
2name = "gpio-input-pullup-led"
3path = "src/input_pullup_led.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    flash::FlashExt,
11    gpio::{GpioExt, PinState},
12    pac,
13    rcc::{Config, RccExt},
14    time::Hertz,
15};
16
17#[entry]
18fn main() -> ! {
19    defmt::println!("STM32F103C8: Control LED with Push Button");
20
21    // Mengakses periferal STM32F103C8
22    let dp = pac::Peripherals::take().unwrap();
23
24    // Mengakses core peripherals (cortex-M3) STM32F103C8
25    let cp = pac::CorePeripherals::take().unwrap();
26
27    // Mengakses periferal FLASH yang akan digunakan untuk menyesuaikan
28    //  'wait states' saat konfigurasi Clock.
29    let mut flash = dp.FLASH.constrain();
30
31    // Mengakses periferal Reset & Control Clock agar dapat dikonfigurasi
32    let rcc = dp.RCC.constrain();
33
34    // membuat konfigurasi Reset & Control clock (RCC)
35    let clock_config = Config::default()
36        // menggunakan clock external 8MHZ
37        .use_hse(Hertz::MHz(8))
38        //mengatur frekuensi CPU ke 72MHZ
39        .sysclk(Hertz::MHz(72))
40        //mengatur frekuensi BUS (jalur akses SRAM dan FLASH) ke 72MHZ
41        .hclk(Hertz::MHz(72));
42
43    // mengaplikasikan konfigurasi clock ke rcc dan
44    // menyesuaikan 'wait states' memori flash
45    let mut clocks = rcc.freeze(clock_config, &mut flash.acr);
46
47    // membuat instans delay dengan menggunakan Timer System.
48    let mut delay = Delay::new(cp.SYST, clocks.clocks.hclk().to_Hz());
49
50    // Mengakses periferal GPIO Port C
51    let mut gpioc = dp.GPIOC.split(&mut clocks);
52
53    // Mengatur GPIOC pin 13 sebagai output open drain (dengan state awal HIGH)
54    // untuk menyalakan dan mematikan LED.
55    let mut led = gpioc
56        .pc13
57        .into_open_drain_output_with_state(&mut gpioc.crh, PinState::High);
58
59    // Mengakses periferal GPIO Port B
60    let mut gpiob = dp.GPIOB.split(&mut clocks);
61
62    // mengatur pin PB0 sebagai input pull-up
63    let button_pullup = gpiob.pb0.into_pull_up_input(&mut gpiob.crl);
64
65    // tunggu 50 ms
66    delay.delay_ms(50);
67
68    loop {
69        // Cek jika tombol ditekan maka PB0 akan low
70        if button_pullup.is_low() {
71            // mengirim pesan ke PC/laptop
72            defmt::println!("button_pullup is pressed");
73            // Menyalakan/mematikan LED
74            led.toggle();
75            // tunggu 500ms
76            delay.delay_ms(500);
77        }
78    }
79}