[hdsc] HC32L110 i2c master read and write

Author: vesim987

examples/hdsc/hc32l110/build.zig

@@ -12,9 +12,12 @@ pub fn build(b: *std.Build) void {
     const mz_dep = b.dependency("microzig", .{});
     const mb = MicroBuild.init(b, mz_dep) orelse return;
 
+    const rtt = b.dependency("rtt", .{});
+
     const examples: []const Example = &.{
         .{ .name = "blinky", .file = "src/blinky.zig" },
         .{ .name = "crc16", .file = "src/crc16.zig" },
+        .{ .name = "i2c_ssd1306", .file = "src/i2c_ssd1306.zig" },
     };
 
     for (examples) |example| {
@@ -24,10 +27,11 @@ pub fn build(b: *std.Build) void {
 
         const firmware = mb.add_firmware(.{
             .name = example.name,
-            .target = mb.ports.hc32l110.chips.hc32l110x4,
+            .target = mb.ports.hc32l110.chips.hc32l110x6,
             .optimize = optimize,
             .root_source_file = b.path(example.file),
         });
+        firmware.add_app_import("rtt", rtt.module("rtt"), .{});
 
         mb.install_firmware(firmware, .{});
         mb.install_firmware(firmware, .{ .format = .elf });

examples/hdsc/hc32l110/build.zig.zon

@@ -4,6 +4,10 @@
     .version = "0.0.0",
     .dependencies = .{
         .microzig = .{ .path = "../../.." },
+        .rtt = .{
+            .url = "git+https://github.com/haydenridd/zig-rtt#b21fa1b54176e9aa5d17aefe4a7c4e0d9a89a09e",
+            .hash = "rtt-0.0.0-s7auv1V5AAAtPzKYj-8Kbj7dD1JPkDJBsVxrKGfnIwqj",
+        },
     },
     .paths = .{
         "README.md",

examples/hdsc/hc32l110/src/i2c_ssd1306.zig

@@ -0,0 +1,56 @@
+const std = @import("std");
+const microzig = @import("microzig");
+
+const hal = microzig.hal;
+const time = microzig.time;
+const i2c = hal.i2c;
+const gpio = hal.gpio;
+const clocks = hal.clocks;
+const peripherals = microzig.chip.peripherals;
+
+const drivers = microzig.drivers;
+const display = drivers.display;
+const ssd1306 = display.ssd1306;
+
+const i2c0 = i2c.instance.num(0);
+
+const sda_pin = gpio.num(0, 1);
+const scl_pin = gpio.num(0, 2);
+
+var framebuffer: drivers.display.ssd1306.Framebuffer = .init(.black);
+
+pub fn main() !void {
+    clocks.gate.enable(.Gpio);
+    clocks.gate.enable(.I2c);
+
+    inline for (&.{ scl_pin, sda_pin }) |pin| {
+        pin.set_direction(.out);
+        pin.set_pull(.disabled);
+        pin.set_open_drain(.enabled);
+        pin.set_drive_strength(.normal);
+        pin.set_analog(.disabled);
+    }
+    // TODO:
+    sda_pin.set_function(2);
+    scl_pin.set_function(2);
+
+    try i2c0.apply(.{ .baud = 32 });
+    i2c0.enable();
+
+    const i2c_device = i2c0.device(.new(0x3c));
+    const disp = ssd1306.init(.i2c, i2c_device, null) catch |err|
+        switch (err) {
+            error.Timeout => while (true) {},
+            else => return err,
+        };
+
+    var color: display.colors.BlackWhite = .white;
+
+    while (true) {
+        framebuffer.clear(color);
+        color = if (color == .black) .white else .black;
+
+        try disp.write_full_display(framebuffer.bit_stream());
+        hal.time.sleep_ms(100);
+    }
+}

port/hdsc/hc32l110/README.md

@@ -9,8 +9,8 @@ HAL and register definitions for the HC32L110 family of microcontrollers
 - [x] crc
 - [ ] flash
 - [x] gpio
-- [ ] i2c
-  - [ ] master
+- [-] i2c
+  - [x] master
   - [ ] slave
 - [ ] irq
 - [ ] lpm - Low Power Management

port/hdsc/hc32l110/src/hal.zig

@@ -5,7 +5,7 @@ const chip = microzig.chip;
 
 pub const time = @import("hal/time.zig");
 pub const gpio = @import("hal/gpio.zig");
-pub const clock = @import("hal/clocks.zig");
+pub const clocks = @import("hal/clocks.zig");
 pub const crc16 = @import("hal/crc16.zig");
 pub const spi = @import("hal/spi.zig");
 pub const uart = @import("hal/uart.zig");
@@ -14,8 +14,8 @@ pub const drivers = @import("hal/drivers.zig");
 
 pub inline fn init() void {
     const CLOCK = chip.peripherals.CLOCK;
-    clock.set_rch_frequency(.@"4MHz");
-    clock.enable(.InternalHighSpeed, true);
+    clocks.set_rch_frequency(.@"24MHz");
+    clocks.enable(.InternalHighSpeed, true);
     // TODO: hide pins on 20-pin mcu
 
     // TODO: move this to seprate function

port/hdsc/hc32l110/src/hal/drivers.zig

@@ -0,0 +1,104 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const hal = @import("../hal.zig");
+
+const drivers = microzig.drivers.base;
+const time = microzig.drivers.time;
+
+const Datagram_Device = drivers.Datagram_Device;
+
+///
+/// A datagram device attached to an I²C bus.
+///
+pub const I2C_Device = struct {
+    pub const ConnectError = Datagram_Device.ConnectError;
+    pub const WriteError = Datagram_Device.WriteError;
+    pub const ReadError = Datagram_Device.ReadError;
+
+    /// Selects I²C bus should be used.
+    bus: hal.i2c.I2C,
+
+    /// The address of our I²C device.
+    address: hal.i2c.Address,
+
+    pub fn init(bus: hal.i2c.I2C, address: hal.i2c.Address) I2C_Device {
+        return .{
+            .bus = bus,
+            .address = address,
+        };
+    }
+
+    pub fn datagram_device(dev: *I2C_Device) Datagram_Device {
+        return .{
+            .ptr = dev,
+            .vtable = &vtable,
+        };
+    }
+
+    pub fn connect(dev: I2C_Device) ConnectError!void {
+        _ = dev;
+    }
+
+    pub fn disconnect(dev: I2C_Device) void {
+        _ = dev;
+    }
+
+    pub fn write(dev: I2C_Device, datagram: []const u8) !void {
+        try dev.bus.write_blocking(dev.address, datagram, null);
+    }
+
+    pub fn writev(dev: I2C_Device, datagrams: []const []const u8) !void {
+        try dev.bus.writev_blocking(dev.address, datagrams, null);
+    }
+
+    pub fn read(dev: I2C_Device, datagram: []u8) !usize {
+        try dev.bus.read_blocking(dev.address, datagram, null);
+        return datagram.len;
+    }
+
+    pub fn readv(dev: I2C_Device, datagrams: []const []u8) !usize {
+        try dev.bus.readv_blocking(dev.address, datagrams, null);
+        return microzig.utilities.Slice_Vector([]u8).init(datagrams).size();
+    }
+
+    const vtable = Datagram_Device.VTable{
+        .connect_fn = null,
+        .disconnect_fn = null,
+        .writev_fn = writev_fn,
+        .readv_fn = readv_fn,
+    };
+
+    fn writev_fn(dd: *anyopaque, chunks: []const []const u8) WriteError!void {
+        const dev: *I2C_Device = @ptrCast(@alignCast(dd));
+        return dev.writev(chunks) catch |err| switch (err) {
+            error.DeviceNotPresent,
+            error.NoAcknowledge,
+            error.TargetAddressReserved,
+            => return error.Unsupported,
+
+            error.UnknownAbort,
+            error.TxFifoFlushed,
+            => return error.IoError,
+
+            error.Timeout => return error.Timeout,
+            error.NoData => {},
+        };
+    }
+
+    fn readv_fn(dd: *anyopaque, chunks: []const []u8) ReadError!usize {
+        const dev: *I2C_Device = @ptrCast(@alignCast(dd));
+        return dev.readv(chunks) catch |err| switch (err) {
+            error.DeviceNotPresent,
+            error.NoAcknowledge,
+            error.TargetAddressReserved,
+            => return error.Unsupported,
+
+            error.UnknownAbort,
+            error.TxFifoFlushed,
+            => return error.IoError,
+
+            error.Timeout => return error.Timeout,
+            error.NoData => return 0,
+        };
+    }
+};