Blink an LED using an interrupt (no example)

[cjdell]

I have a ch32v003f4p6 and I just wanted to get interrupt functions working. The closest I have to an example is the implementation of Embassy:

https://github.com/ch32-rs/ch32-hal/blob/main/src/embassy/time_driver_tim.rs

It is however complex and so I'm really shooting in the dark. The following code compiles but the TIM1 function is never invoked.

#![no_std]
#![no_main]

use ch32_hal::gpio::{Level, Output};
use ch32_hal::pac::timer::vals::FilterValue;
use ch32_hal::peripherals::SPI1;
use ch32_hal::println;
use ch32_hal::time::Hertz;
use ch32_hal::timer::low_level::{InputTISelection, Timer};
use ch32_hal::timer::Channel;
use core::ptr::{self, null_mut};
use panic_halt as _;
use qingke::riscv;
use qingke_rt::interrupt;

struct UnsafeSync<T>(T);
unsafe impl<T> Sync for UnsafeSync<T> {}

static mut LED: UnsafeSync<*mut Output<'_>> = UnsafeSync(ptr::null_mut());

#[qingke_rt::interrupt]
fn TIM1() {
    unsafe {
        if !LED.0.is_null() {
            // Never called?
            (*LED.0).toggle();
        }
    }
}

#[qingke_rt::entry]
fn main() -> ! {
    riscv::asm::delay(20_000_000);

    let mut config = ch32_hal::Config::default();
    config.rcc = ch32_hal::rcc::Config::SYSCLK_FREQ_48MHZ_HSI;
    let p = ch32_hal::init(config);

    let mut led = Output::new(p.PD2, Level::Low, Default::default());
    unsafe { LED.0 = &mut led };

    let ch = Channel::Ch1;

    let timer = Timer::new(p.TIM1);
    timer.set_frequency(Hertz(1));
    timer.set_input_ti_selection(ch, InputTISelection::TRC);
    timer.set_input_capture_prescaler(ch, 0);
    timer.set_input_capture_filter(ch, FilterValue::FCK_INT_N2);
    timer.enable_channel(ch, true);
    timer.enable_input_interrupt(ch, true);
    timer.start();

    loop {
        // Just to test the GPIO works...
        // led.toggle();
    }
}

I'll be especially grateful if someone can show me how to get this example to work.

[ktims]

It might just be that there is no interrupt called TIM1 on ch32v003. It has several, you probably want TIM1_CC, see https://github.com/ch32-rs/ch32-data/blob/main/data/interrupts/CH32V0.yaml .

[cjdell]

Thanks @ktims . So it was never going to work then. Tried at few different names and also the TIM2 peripheral but unfortunately still not working.

Searched all of GitHub for examples. Is there perhaps another resource out there that might help me?

At this point I might try getting it to work in C and then inspecting the disassembly...

[cjdell]

After much chatting with Claude I have a solution, using SysTick instead of a timer. I might make a PR with an example as this took a lot of time to figure out:

#![no_std]
#![no_main]

use ch32_hal::gpio::{Level, Output};
use panic_halt as _;
use qingke::riscv;
use qingke_rt::interrupt;

// Simple global variables - no atomics needed with single core
static mut SYSTICK_MILLIS: u32 = 0;
static mut LED: Option<Output<'static>> = None;

#[qingke_rt::interrupt(core)]
fn SysTick() {
    let r = &ch32_hal::pac::SYSTICK;

    // Clear interrupt flag
    r.sr().write(|w| w.set_cntif(false));

    // Increment milliseconds counter
    unsafe {
        SYSTICK_MILLIS = SYSTICK_MILLIS.wrapping_add(1);

        // Toggle LED every 1000ms (1 second)
        if SYSTICK_MILLIS % 1000 == 0 {
            if let Some(ref mut led) = LED {
                led.toggle();
            }
        }
    }
}

fn systick_init() {
    let r = &ch32_hal::pac::SYSTICK;

    // Calculate counts per millisecond using HCLK/8 as clock source
    // HCLK/8 = 48MHz/8 = 6MHz
    // For 1ms interrupt: 6MHz / 1000 = 6000 counts
    let cnt_per_ms = 48_000_000 / 8 / 1000;

    // Reset SysTick
    r.ctlr().write(|w| {
        // Start with everything disabled
    });

    // Set compare register and reset counter
    r.cmp().write_value(cnt_per_ms - 1);
    r.cnt().write_value(0);

    // Clear interrupt flag
    r.sr().write(|w| w.set_cntif(false));

    // Configure and start SysTick
    r.ctlr().write(|w| {
        w.set_ste(true); // Enable counter
        w.set_stie(true); // Enable interrupt
        w.set_stre(true); // Auto reload enable
        w.set_stclk(ch32_hal::pac::systick::vals::Stclk::HCLK_DIV8); // HCLK/8 clock source
    });
}

// Simple utility function to get milliseconds
fn millis() -> u32 {
    unsafe { SYSTICK_MILLIS }
}

#[qingke_rt::entry]
fn main() -> ! {
    riscv::asm::delay(20_000_000);

    let mut config = ch32_hal::Config::default();
    config.rcc = ch32_hal::rcc::Config::SYSCLK_FREQ_48MHZ_HSI;
    let p = ch32_hal::init(config);

    let led = Output::new(p.PD2, Level::Low, Default::default());

    // Store LED in global variable
    unsafe {
        LED = Some(led);
    }

    // Initialize SysTick for 1ms interrupts
    systick_init();

    // Enable SysTick interrupt
    unsafe {
        use qingke::interrupt::Priority;
        use qingke_rt::CoreInterrupt;

        qingke::pfic::set_priority(CoreInterrupt::SysTick as u8, Priority::P15 as u8);
        qingke::pfic::enable_interrupt(CoreInterrupt::SysTick as u8);
    }

    loop {
        // You can use millis() here for timing other things
        // let current_time = millis();

        // Sleep to save power
        riscv::asm::wfi();
    }
}