STM32F103 Small APIS and changes (#639)

* Add CRC and Power for STM32F103

* Add RTC and backup domain support for STM32F103

* Fix typos

* fix typo

* remove master/slave from some API

* rename clock_init to apply_clock

* Add SSD1306 display driver example for STM32F103

* remove unnecessary spaces in comments

* Add Bus reset

* Add EXTI example and HAL support for STM32F1xx

* fix typo

* Add basic DMA support for STM32F1xx and update ADC examples to use DMA controller

* Refactor get_regs() to use comptime parameters and removed implicit pointer types

* Add EVENTOUT support and GPIO remapping functionality for STM32F103

* Remove unused RCC imports from I2C, SPI, UART Echo, and UART Log examples

* fix endpoint control and status handling

Author: RecursiveError

examples/stmicro/stm32/build.zig

@@ -33,12 +33,15 @@ pub fn build(b: *std.Build) void {
         .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_i2c", .file = "src/stm32f1xx/i2c.zig" },
         .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_i2c_bus_scan", .file = "src/stm32f1xx/i2c_bus_scan.zig" },
         .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_hd44780", .file = "src/stm32f1xx/hd44780.zig" },
+        .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_ssd1306", .file = "src/stm32f1xx/ssd1306.zig" },
         .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_spi", .file = "src/stm32f1xx/spi.zig" },
         .{ .target = stm32.chips.STM32F103C8, .name = "STM32F1xx_usb_hid", .file = "src/stm32f1xx/usb_hid.zig" },
         .{ .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" },
+        .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_rtc", .file = "src/stm32f1xx/rtc.zig" },
+        .{ .target = stm32.chips.STM32F103CB, .name = "STM32F1xx_EXTI", .file = "src/stm32f1xx/EXTI.zig" },
     };
 
     for (available_examples) |example| {

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

@@ -0,0 +1,57 @@
+//External Interrupts (exti) Example for STM32F1xx
+//This example demonstrates how to configure an external interrupt on a GPIO pin
+//and toggle an LED when the interrupt is triggered.
+
+const microzig = @import("microzig");
+const hal = microzig.hal;
+const gpio = hal.gpio;
+const rcc = hal.rcc;
+const exti = hal.exti;
+
+const led = hal.gpio.Pin.from_port(.B, 2);
+const input = hal.gpio.Pin.from_port(.B, 9);
+
+//define the EXTI handler
+pub const microzig_options: microzig.Options = .{
+    .interrupts = .{
+        .EXTI9_5 = .{ .c = EXTI_handler },
+    },
+};
+
+fn EXTI_handler() callconv(.C) void {
+    // we have only one line configured, so we can just clear it
+    // if you have more than one line configured, you should check the pending lines
+    exti.clear_pending(exti.pending());
+    led.toggle();
+}
+
+pub fn main() !void {
+    // Enable clocks for GPIOB and AFIO
+    hal.rcc.enable_clock(.AFIO);
+    hal.rcc.enable_clock(.GPIOB);
+
+    // Configure the LED pin as output
+    led.set_output_mode(.general_purpose_push_pull, .max_50MHz);
+
+    // Configure the input pin as input with pull-up
+    input.set_input_mode(.pull);
+    input.set_pull(.up);
+
+    // Configure the EXTI line for PB9 with falling edge trigger
+    exti.apply_line(.{
+        .line = 9,
+        .port = .B,
+        .trigger = .falling,
+        .interrupt = true, //enable interrupt imamediately (you can also enable it later if you want)
+        .event = false, //no event for this example
+    });
+
+    //enable NVIC for EXTI9_5 and enable interrupts globally
+    microzig.interrupt.enable(.EXTI9_5);
+    microzig.interrupt.enable_interrupts();
+
+    // Main loop does nothing, waiting for interrupts
+    while (true) {
+        asm volatile ("wfi"); // Wait for interrupt
+    }
+}

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

@@ -56,7 +56,7 @@ pub fn main() !void {
     while (true) {
         const adc_buf: []const u16 = try adc.read_multiple_channels(&adc_out_buf);
         counter.sleep_ms(100);
-        std.log.info("\x1B[2J\x1B[H", .{}); // Clear screen and move cursor to 1,1
+        std.log.info("\x1B[2J\x1B[H", .{}); //Clear screen and move cursor to 1,1
         std.log.info("CPU temp: {d:.1}C", .{adc_to_temp(adc_buf[0])});
         std.log.info("Vref: {d:0>4}", .{adc_buf[1]});
         std.log.info("CH1: {d:0>4}", .{adc_buf[2]});

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

@@ -2,20 +2,19 @@
 //here it shows how to configure and use the Dual ADC mode using the advanced ADC API
 
 const std = @import("std");
-const microzig = @import("microzig");
-const DMA = microzig.chip.peripherals.DMA1;
-const DMA_t = microzig.chip.types.peripherals.bdma_v1;
 
+const microzig = @import("microzig");
 const stm32 = microzig.hal;
 const rcc = stm32.rcc;
+const gpio = stm32.gpio;
+const dma = stm32.dma;
+const AdvancedADC = stm32.adc.AdvancedADC;
 
-const timer = microzig.hal.timer.GPTimer.init(.TIM2).into_counter_mode();
-
+const dma_controller = dma.DMAController.init(.DMA1);
+const timer = stm32.timer.GPTimer.init(.TIM2).into_counter_mode();
 const uart = stm32.uart.UART.init(.USART1);
-const gpio = stm32.gpio;
-const TX = gpio.Pin.from_port(.A, 9);
 
-const AdvancedADC = microzig.hal.adc.AdvancedADC;
+const TX = gpio.Pin.from_port(.A, 9);
 const ADC_pin1 = gpio.Pin.from_port(.A, 1);
 const ADC_pin2 = gpio.Pin.from_port(.A, 2);
 
@@ -36,26 +35,6 @@ fn adc_to_temp(val: usize) f32 {
     return ((v25 - temp_mv) / avg_slope) + 25; //convert to celsius
 }
 
-fn DMA_init(arr_addr: u32, adc_addr: u32) void {
-    const CH1: *volatile DMA_t.CH = @ptrCast(&DMA.CH);
-    CH1.CR.raw = 0; //disable channel
-    CH1.NDTR.raw = 0;
-    CH1.CR.modify(.{
-        .DIR = DMA_t.DIR.FromPeripheral,
-        .CIRC = 1, //disable circular mode
-        .PL = DMA_t.PL.High, //high priority
-        .MSIZE = DMA_t.SIZE.Bits32,
-        .PSIZE = DMA_t.SIZE.Bits32,
-        .MINC = 1, //memory increment mode
-        .PINC = 0, //peripheral not incremented
-    });
-
-    CH1.NDTR.modify(.{ .NDT = 2 }); //number of data to transfer, 2 samples
-    CH1.PAR = adc_addr; //peripheral address
-    CH1.MAR = arr_addr; //memory address
-    CH1.CR.modify(.{ .EN = 1 }); //enable channel
-}
-
 pub fn main() !void {
     rcc.enable_clock(.DMA1);
     rcc.enable_clock(.TIM2);
@@ -68,10 +47,22 @@ pub fn main() !void {
     const counter = timer.counter_device(rcc.get_clock(.TIM2));
     const adc1 = AdvancedADC.init(.ADC1);
     const adc2 = AdvancedADC.init(.ADC2);
-
-    const adc_data_addr: u32 = @intFromPtr(&adc1.regs.DR);
     var adc_buf: [2]AdcData = undefined;
-    const adc_buf_addr: u32 = @intFromPtr(&adc_buf[0]);
+
+    dma_controller.apply_channel(0, .{
+        .circular_mode = true,
+        .memory_increment = true,
+
+        .direction = .FromPeripheral,
+        .priority = .High,
+        .memory_size = .Bits32,
+        .peripheral_size = .Bits32,
+
+        .transfer_count = 2,
+        .periph_address = @intFromPtr(&adc1.regs.DR),
+        .mem_address = @intFromPtr(&adc_buf),
+    });
+    dma_controller.start_channel(0);
 
     TX.set_output_mode(.alternate_function_push_pull, .max_50MHz);
     ADC_pin1.set_input_mode(.analog);
@@ -90,23 +81,22 @@ pub fn main() !void {
 
     try adc1.configure_dual_mode(.{ .Regular = .{
         .dma = true,
-        .master_seq = &.{ 16, 17 },
-        .slave_seq = &.{ 1, 2 },
+        .primary_seq = &.{ 16, 17 },
+        .secondary_seq = &.{ 1, 2 },
         .rate_seq = &.{ .@"239.5", .@"239.5" },
         .trigger = .SWSTART,
         .mode = .{ .Continuous = {} },
     } });
 
     std.log.info("start Dual ADC scan", .{});
-    DMA_init(adc_buf_addr, adc_data_addr);
     adc1.software_trigger(); //start conversion
     while (true) {
         counter.sleep_ms(250);
         const temp = adc_buf[0].adc1;
         const vref = adc_buf[1].adc1;
         const ch1 = adc_buf[0].adc2;
         const ch2 = adc_buf[1].adc2;
-        std.log.info("\x1B[2J\x1B[H", .{}); // Clear screen and move cursor to 1,1
+        std.log.info("\x1B[2J\x1B[H", .{}); //Clear screen and move cursor to 1,1
         std.log.info("CPU temp: {d:.1}C", .{adc_to_temp(temp)});
         std.log.info("Vref: {d}", .{vref});
         std.log.info("CH1: {d}", .{ch1});

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

@@ -5,36 +5,34 @@
 //before creating a program using ADC from older ST families, such as in this case STM32F1
 //be aware of possible hardware bugs and limitations
 //for example:
-// temperature sensor/VREF cannot be read in interleaved mode as it requires a sample time greater than 17
-// readings after 1ms from the previous reading may contain more noise than expected
+//temperature sensor/VREF cannot be read in interleaved mode as it requires a sample time greater than 17
+//readings after 1ms from the previous reading may contain more noise than expected
 //Voltage glitch on ADC input 0
 
 const std = @import("std");
 const microzig = @import("microzig");
-
 const interrupt = microzig.interrupt;
-const DMA = microzig.chip.peripherals.DMA1;
-const DMA_t = microzig.chip.types.peripherals.bdma_v1;
-
 const stm32 = microzig.hal;
 const rcc = stm32.rcc;
-const timer = microzig.hal.timer.GPTimer.init(.TIM2).into_counter_mode();
+const gpio = stm32.gpio;
+const dma = stm32.dma;
+const AdvancedADC = stm32.adc.AdvancedADC;
 
+const dma_controller = dma.DMAController.init(.DMA1);
+const timer = stm32.timer.GPTimer.init(.TIM2).into_counter_mode();
 const uart = stm32.uart.UART.init(.USART1);
-const gpio = stm32.gpio;
+const adc = AdvancedADC.init(.ADC1);
+
 const TX = gpio.Pin.from_port(.A, 9);
+const ADC_pin1 = gpio.Pin.from_port(.A, 1);
+const ADC_pin2 = gpio.Pin.from_port(.A, 2);
+const ADC_pin3 = gpio.Pin.from_port(.A, 3);
 
 pub const microzig_options = microzig.Options{
     .logFn = stm32.uart.log,
     .interrupts = .{ .ADC1_2 = .{ .c = watchdog_handler } },
 };
 
-const AdvancedADC = microzig.hal.adc.AdvancedADC;
-const adc = AdvancedADC.init(.ADC1);
-const ADC_pin1 = gpio.Pin.from_port(.A, 1);
-const ADC_pin2 = gpio.Pin.from_port(.A, 2);
-const ADC_pin3 = gpio.Pin.from_port(.A, 3);
-
 const v25 = 1.43;
 const avg_slope = 0.0043; //4.3mV/°C
 
@@ -49,28 +47,8 @@ fn adc_to_temp(val: usize) f32 {
     return ((v25 - temp_mv) / avg_slope) + 25; //convert to celsius
 }
 
-fn DMA_init(arr_addr: u32, adc_addr: u32) void {
-    const CH1: *volatile DMA_t.CH = @ptrCast(&DMA.CH);
-    CH1.CR.raw = 0; //disable channel
-    CH1.NDTR.raw = 0;
-    CH1.CR.modify(.{
-        .DIR = DMA_t.DIR.FromPeripheral,
-        .CIRC = 1, //disable circular mode
-        .PL = DMA_t.PL.High, //high priority
-        .MSIZE = DMA_t.SIZE.Bits16,
-        .PSIZE = DMA_t.SIZE.Bits16,
-        .MINC = 1, //memory increment mode
-        .PINC = 0, //peripheral not incremented
-    });
-
-    CH1.NDTR.modify(.{ .NDT = 4 }); //number of data to transfer, 4 samples
-    CH1.PAR = adc_addr; //peripheral address
-    CH1.MAR = arr_addr; //memory address
-    CH1.CR.modify(.{ .EN = 1 }); //enable channel
-}
-
 pub fn main() !void {
-    try rcc.clock_init(.{ .ADCprescaler = .RCC_ADCPCLK2_DIV2 });
+    try rcc.apply_clock(.{ .ADCprescaler = .RCC_ADCPCLK2_DIV2 });
 
     rcc.enable_clock(.DMA1);
     rcc.enable_clock(.TIM2);
@@ -80,11 +58,23 @@ pub fn main() !void {
     rcc.enable_clock(.ADC1);
 
     const counter = timer.counter_device(rcc.get_clock(.TIM2));
-
-    const adc_data_addr: u32 = @intFromPtr(&adc.regs.DR);
-    var adc_buf: [10]u16 = .{0} ** 10;
-    const adc_buf_addr: u32 = @intFromPtr(&adc_buf);
     const ref_ovf_flag: *volatile bool = &ovf_flag;
+    var adc_buf: [10]u16 = .{0} ** 10;
+
+    dma_controller.apply_channel(0, .{
+        .circular_mode = true,
+        .memory_increment = true,
+
+        .direction = .FromPeripheral,
+        .priority = .High,
+        .memory_size = .Bits16,
+        .peripheral_size = .Bits16,
+
+        .transfer_count = 4,
+        .periph_address = @intFromPtr(&adc.regs.DR),
+        .mem_address = @intFromPtr(&adc_buf),
+    });
+    dma_controller.start_channel(0);
 
     //configure UART log
 
@@ -142,13 +132,10 @@ pub fn main() !void {
     );
 
     std.log.info("start Advanced ADC scan", .{});
-
-    DMA_init(adc_buf_addr, adc_data_addr);
-
     while (true) {
         adc.software_trigger(); //start conversion
         counter.sleep_ms(100);
-        std.log.info("\x1B[2J\x1B[H", .{}); // Clear screen and move cursor to 1,1
+        std.log.info("\x1B[2J\x1B[H", .{}); //Clear screen and move cursor to 1,1
         std.log.info("CPU temp: {d:.1}C", .{adc_to_temp(adc_buf[0])});
         std.log.info("Vref: {d:0>4}", .{adc_buf[1]});
         std.log.info("CH1: {d:0>4}", .{adc_buf[2]});

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

@@ -72,7 +72,7 @@ pub fn main() !void {
                 continue;
             };
 
-            std.log.info("receiving data from the slave", .{});
+            std.log.info("receiving data from the device", .{});
             i2c2.read_blocking(ADDR, &to_read, counter.make_ms_timeout(1000)) catch |err| {
                 std.log.err("fail to read data | error {any}", .{err});
                 if (err == error.UnrecoverableError) {

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

@@ -1,7 +1,6 @@
 const std = @import("std");
 const microzig = @import("microzig");
 
-const RCC = microzig.chip.peripherals.RCC;
 const stm32 = microzig.hal;
 const rcc = stm32.rcc;
 const gpio = stm32.gpio;

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

@@ -24,7 +24,7 @@ const clk_config = rcc.Config{
 };
 
 pub fn main() !void {
-    try rcc.clock_init(clk_config);
+    try rcc.apply_clock(clk_config);
     rcc.enable_clock(.GPIOA);
     rcc.enable_clock(.AFIO);
     rcc.enable_clock(.USART1);