STM32F1xxx Low-level timer APIs (#625)

Author: RecursiveError

examples/stmicro/stm32/build.zig

@@ -38,6 +38,7 @@ pub fn build(b: *std.Build) void {
         .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_usb_cdc", .file = "src/stm32f1xx/usb_cdc.zig" },
         .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_rcc", .file = "src/stm32f1xx/rcc.zig" },
         .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_timer", .file = "src/stm32f1xx/timer.zig" },
+        .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_timer_capture", .file = "src/stm32f1xx/timer_capture.zig" },
     };
 
     for (available_examples) |example| {

examples/stmicro/stm32/src/stm32f1xx/timer.zig

@@ -1,3 +1,5 @@
+//basic example of using timers on STM32F1xx showing how to use high-level APIs for PWM and Counter.
+
 const std = @import("std");
 const microzig = @import("microzig");
 
@@ -39,10 +41,10 @@ pub fn main() !void {
     }
 
     //first we need to configure the PWM peripheral
-    pwm.configure_PWM(.{
+    pwm.configure(.{
         .prescaler = 7, //prescaler value, 7 means pckl / 8
         .auto_reload = 1000, //1khz
-        .counter_direction = .Up,
+        .counter_mode = .{ .up = {} },
     });
 
     //then we configure the channels

examples/stmicro/stm32/src/stm32f1xx/timer_capture.zig

@@ -0,0 +1,132 @@
+//NOTE: this is an advanced example and is recommended for those who already have experience with the STM32F1
+//Example to demonstrate the use of input capture on STM32F1xx
+//in this example an operation called PWM input is performed
+//where two channels read the same input but are triggered on different edges
+//thus measuring the frequency and duty cycle of a PWM signal
+
+const std = @import("std");
+const microzig = @import("microzig");
+
+//example usage
+const stm32 = microzig.hal;
+const gpio = stm32.gpio;
+const GPTimer = stm32.timer.GPTimer;
+
+//gpios
+const ch1 = gpio.Pin.from_port(.A, 0);
+
+const uart = stm32.uart.UART.init(.USART1);
+const TX = gpio.Pin.from_port(.A, 9);
+
+pub const microzig_options = microzig.Options{
+    .logFn = stm32.uart.log,
+    .interrupts = .{ .TIM2 = .{ .c = isr_tim2 } },
+};
+
+const comp = GPTimer.init(.TIM2);
+const counter = GPTimer.init(.TIM3).into_counter_mode();
+
+var global_uptime: i32 = 0;
+var global_downtime: i32 = 0;
+var global_dif: u32 = 0;
+
+var freq: i32 = 0;
+var duty_cycle: f32 = 0;
+
+//function that handles timer interrupts
+//since the timer is reset at each rising edge,
+//the value of ch2 marks the moment when the signal went from high to low, indicating the duty cycle.
+//the value of ch1 marks the point when the signal goes back to high before the timer resets, indicating the period.
+fn isr_tim2() callconv(.C) void {
+    const flags = comp.get_interrupt_flags();
+    if (flags.channel2) {
+        const rev_ch1 = comp.read_ccr(0);
+        const rev_fch1: f32 = @floatFromInt(rev_ch1);
+        const rev_ch2 = comp.read_ccr(1);
+        const rev_fch2: f32 = @floatFromInt(rev_ch2);
+
+        global_uptime = rev_ch1;
+        global_downtime = rev_ch2;
+
+        global_dif = @intCast(@abs(global_uptime - global_downtime));
+        freq = @divFloor(1_000_000, global_uptime);
+
+        duty_cycle = (rev_fch2 / rev_fch1) * 100;
+    }
+
+    comp.clear_interrupts();
+}
+
+//timers
+pub fn main() !void {
+
+    //first we need to enable the clocks for the GPIO and TIM peripherals
+
+    //use HSE as system clock source, more stable than HSI
+    try stm32.rcc.clock_init(.{ .SysClkSource = .RCC_SYSCLKSOURCE_HSE });
+
+    //enable GPIOA and TIM2, TIM3, AFIO clocks
+    //AFIO is needed for alternate function remapping, not used in this example but eneble for easy remapping
+    //if needed
+    stm32.rcc.enable_clock(.GPIOA);
+    stm32.rcc.enable_clock(.TIM2);
+    stm32.rcc.enable_clock(.TIM3);
+    stm32.rcc.enable_clock(.AFIO);
+    stm32.rcc.enable_clock(.USART1);
+
+    TX.set_output_mode(.alternate_function_push_pull, .max_50MHz);
+
+    uart.apply(.{
+        .baud_rate = 115200,
+        .clock_speed = 8_000_000,
+    });
+
+    stm32.uart.init_logger(&uart);
+
+    //counter device to genereate delays
+    const cd = counter.counter_device(8_000_000); //8MHz clock
+
+    //set PA0 (TI1) to input
+    ch1.set_input_mode(.floating);
+
+    //configure the timer for a frequency of 1MHz counting upwards
+    //enable slave mode to reset the counter on the rising edge of TI1 (after filtering)
+    //filter only can be configured by channel 1 (index 0)
+    comp.timer_general_config(.{
+        .prescaler = 7,
+        .counter_mode = .{ .up = {} },
+        .slave_config = .{
+            .trigger_source = .TI1FP1,
+            .mode = .ResetMode,
+        },
+    });
+    comp.start();
+
+    //configure channel 1 and 2 for the same input (TI1) with inverted edges between them
+    comp.configure_ccr(0, .{
+        .ch_mode = .{ .capture = .{} },
+    });
+
+    comp.configure_ccr(1, .{
+        .ch_mode = .{ .capture = .{ .mode = .input_alternate } },
+        .polarity = .low,
+        .channel_interrupt_enable = true,
+    });
+
+    //enable timer channels and interrupts
+    comp.set_channel(0, true);
+    comp.set_channel(1, true);
+    comp.set_interrupt(true);
+    microzig.interrupt.enable_interrupts();
+    microzig.interrupt.enable(.TIM2);
+
+    while (true) {
+        //values are received in the timer interrupt
+        std.log.info("uptime: {d}", .{global_uptime});
+        std.log.info("downtime: {d}", .{global_downtime});
+        std.log.info("freq: {d}HZ", .{freq});
+        std.log.info("duty: {d:.2}%", .{duty_cycle});
+
+        cd.sleep_ms(1350);
+    }
+}