[hdsc] HC32L110 i2c write

vesim987 · vesim987 · commit 9733eae2e3d3 · 2025-04-26T23:42:30.000+02:00
diff --git a/examples/hdsc/hc32l110/src/i2c_ssd1306.zig b/examples/hdsc/hc32l110/src/i2c_ssd1306.zig
@@ -0,0 +1,65 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const time = microzig.drivers.time;
+
+const hal = microzig.hal;
+const i2c = hal.i2c;
+const gpio = hal.gpio;
+const clocks = hal.clocks;
+const peripherals = microzig.chip.peripherals;
+
+const drivers = microzig.drivers.base;
+const Datagram_Device = drivers.Datagram_Device;
+
+const I2C_Device_Hal = hal.drivers.I2C_Device;
+
+const i2c0 = i2c.instance.num(0);
+const i2c_device = I2C_Device_Hal.init(i2c0, @enumFromInt(0x78));
+
+const SSD1306 = microzig.drivers.display.ssd1306.SSD1306_Generic(.{
+    .mode = .i2c,
+    .Datagram_Device = I2C_Device_Hal,
+});
+
+const sda_pin = gpio.num(0, 1);
+const scl_pin = gpio.num(0, 2);
+
+const data: [128 * 8]u8 = blk: {
+    var tmp: [128 * 8]u8 = undefined;
+    @memset(&tmp, 0xFF);
+    break :blk tmp;
+};
+
+const data2: [128 * 8]u8 = blk: {
+    var tmp: [128 * 8]u8 = undefined;
+    @memset(&tmp, 0x00);
+    break :blk tmp;
+};
+
+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 = 2 });
+    i2c0.enable();
+
+    var display = try SSD1306.init(i2c_device);
+
+    while (true) {
+        try display.write_full_display(&data);
+        hal.time.sleep_ms(100);
+        try display.write_full_display(&data2);
+        hal.time.sleep_ms(100);
+    }
+}
diff --git a/port/hdsc/hc32l110/src/hal.zig b/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
diff --git a/port/hdsc/hc32l110/src/hal/drivers.zig b/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,
+        };
+    }
+};
diff --git a/port/hdsc/hc32l110/src/hal/i2c.zig b/port/hdsc/hc32l110/src/hal/i2c.zig
@@ -0,0 +1,208 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const mdf = microzig.drivers;
+const peripherals = microzig.chip.peripherals;
+
+const I2C0 = peripherals.I2C;
+const RESET = microzig.chip.peripherals.RESET;
+
+pub const Config = struct {
+    baud: u8,
+};
+
+///
+/// 7-bit I²C address, without the read/write bit.
+///
+pub const Address = enum(u7) {
+    /// The general call addresses all devices on the bus using the I²C address 0.
+    pub const general_call: Address = @enumFromInt(0x00);
+
+    _,
+
+    pub fn new(addr: u7) Address {
+        const a = @as(Address, @enumFromInt(addr));
+        // std.debug.assert(!a.is_reserved());
+        return a;
+    }
+
+    ///
+    /// Returns `true` if the Address is a reserved I²C address.
+    ///
+    /// Reserved addresses are ones that match `0b0000XXX` or `0b1111XXX`.
+    ///
+    /// See more here: https://www.i2c-bus.org/addressing/
+    pub fn is_reserved(addr: Address) bool {
+        const value: u7 = @intFromEnum(addr);
+        return ((value & 0x78) == 0) or ((value & 0x78) == 0x78);
+    }
+
+    pub fn format(addr: Address, fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try writer.print("I2C(0x{X:0>2})", .{@intFromEnum(addr)});
+    }
+};
+
+const i2c = @This();
+
+pub const instance = struct {
+    pub const I2C: i2c.I2C = @enumFromInt(0);
+    pub fn num(instance_number: u1) i2c.I2C {
+        std.debug.assert(instance_number == 0);
+        return @enumFromInt(instance_number);
+    }
+};
+
+pub const TransactionError = error{
+    Timeout,
+    TargetAddressReserved,
+    NoData,
+};
+
+pub const ConfigError = error{
+    UnsupportedBaudRate,
+};
+
+pub const I2C = enum(u1) {
+    _,
+
+    pub fn apply(self: I2C, comptime config: Config) ConfigError!void {
+        self.reset();
+        I2C0.TM.write(.{ .TM = config.baud });
+        I2C0.ADDR.write(.{
+            .I2CADR = 0,
+            .GC = 0,
+        });
+    }
+
+    pub inline fn reset(_: I2C) void {
+        RESET.PREI_RESET.modify(.{
+            .I2C = 0,
+        });
+        RESET.PREI_RESET.modify(.{
+            .I2C = 1,
+        });
+    }
+
+    pub inline fn enable(_: I2C) void {
+        I2C0.TMRUN.write(.{
+            // enable baudrate generation
+            .TME = 1,
+        });
+
+        I2C0.CR.modify(.{
+            // enable i2c module
+            .ENS = 1,
+            // enable high speed mode
+            .H1M = 1,
+        });
+    }
+
+    pub inline fn disable(_: I2C) void {
+        I2C0.CR.modify(.{
+            .TMRUN = 0,
+            .ENS = 0,
+            .H1M = 0,
+        });
+    }
+
+    pub fn writev_blocking(self: I2C, addr: Address, buffers: []const []const u8, timeout: ?mdf.time.Duration) TransactionError!void {
+        // TODO: timeouts
+        _ = timeout;
+
+        const write_vec = microzig.utilities.Slice_Vector([]const u8).init(buffers);
+        if (write_vec.size() == 0)
+            return TransactionError.NoData;
+
+        self.set_start();
+        self.wait_for_irq();
+
+        // send address
+        self.wait_for_any_state(&.{ 0x08, 0x10 });
+        self.clear_start();
+        self.write_data(@intFromEnum(addr));
+        self.clear_irq();
+
+        self.wait_for_irq();
+        // @breakpoint();
+        self.wait_for_any_state(&.{ 0x18, 0x28 });
+
+        var iter = write_vec.iterator();
+        while (iter.next_element()) |element| {
+            self.write_data(element.value);
+            self.clear_irq();
+
+            self.wait_for_irq();
+            self.wait_for_any_state(&.{ 0x18, 0x28 });
+        }
+
+        self.set_stop();
+        self.clear_irq();
+    }
+
+    pub fn write_blocking(self: I2C, addr: Address, data: []const u8, timeout: ?mdf.time.Duration) TransactionError!void {
+        return self.writev_blocking(addr, &.{data}, timeout);
+    }
+
+    pub fn readv_blocking(self: I2C, addr: Address, buffers: []const []u8, timeout: ?mdf.time.Duration) TransactionError!void {
+        // TODO: timeouts
+        _ = timeout;
+        _ = addr;
+        _ = buffers;
+        _ = self;
+    }
+
+    pub fn read_blocking(self: I2C, addr: Address, dst: []u8, timeout: ?mdf.time.Duration) TransactionError!void {
+        return try self.readv_blocking(addr, &.{dst}, timeout);
+    }
+
+    inline fn set_start(_: I2C) void {
+        I2C0.CR.modify(.{ .STA = 1 });
+    }
+
+    inline fn clear_start(_: I2C) void {
+        I2C0.CR.modify(.{ .STA = 0 });
+    }
+
+    inline fn set_stop(_: I2C) void {
+        I2C0.CR.modify(.{ .STO = 1 });
+    }
+
+    inline fn clear_stop(_: I2C) void {
+        I2C0.CR.modify(.{ .STO = 0 });
+    }
+
+    inline fn set_ack(_: I2C) void {
+        I2C0.CR.modify(.{ .AA = 1 });
+    }
+
+    inline fn clear_ack(_: I2C) void {
+        I2C0.CR.modify(.{ .AA = 0 });
+    }
+
+    inline fn write_data(_: I2C, data: u8) void {
+        I2C0.DATA.write(.{ .I2CDAT = data });
+    }
+
+    fn wait_for_any_state(_: I2C, comptime states: []const u8) void {
+        while (true) {
+            const state = I2C0.STAT.read().I2CSTA;
+            inline for (states) |s| {
+                if (s == state)
+                    return;
+            }
+        }
+    }
+
+    fn wait_for_irq(self: I2C) void {
+        while (!self.is_irq_set()) {}
+    }
+
+    inline fn is_irq_set(_: I2C) bool {
+        return I2C0.CR.read().SI == 1;
+    }
+
+    inline fn clear_irq(_: I2C) void {
+        I2C0.CR.modify(.{ .SI = 0 });
+    }
+};
