nRF5x: Add i2c hal + datagram device (#561)

Author: Grazfather

examples/nordic/nrf5x/build.zig

@@ -22,6 +22,10 @@ pub fn build(b: *std.Build) void {
         .{ .target = nrf52840_mdk, .name = "blinky", .file = "src/blinky.zig" },
         .{ .target = pca10040, .name = "uart", .file = "src/uart.zig" },
         .{ .target = nrf52840_mdk, .name = "uart", .file = "src/uart.zig" },
+        .{ .target = pca10040, .name = "i2c_bus_scan", .file = "src/i2c_bus_scan.zig" },
+        .{ .target = nrf52840_mdk, .name = "i2c_bus_scan", .file = "src/i2c_bus_scan.zig" },
+        .{ .target = pca10040, .name = "i2c_temp", .file = "src/i2c_temp.zig" },
+        .{ .target = nrf52840_mdk, .name = "i2c_temp", .file = "src/i2c_temp.zig" },
     };
 
     for (available_examples) |example| {

examples/nordic/nrf5x/src/i2c_bus_scan.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const time = microzig.drivers.time;
+const board = microzig.board;
+const nrf = microzig.hal;
+
+const gpio = nrf.gpio;
+const i2c = nrf.i2c;
+const i2cdma = nrf.i2cdma;
+
+const uart = nrf.uart.num(0);
+const i2c0 = i2c.num(0);
+const i2c0dma = i2cdma.num(0);
+
+const sleep_ms = nrf.time.sleep_ms;
+
+pub const microzig_options = microzig.Options{
+    .log_level = .debug,
+    .logFn = nrf.uart.logFn,
+};
+
+pub fn main() !void {
+    board.init();
+
+    uart.apply(.{
+        .tx_pin = board.uart_tx,
+        .rx_pin = board.uart_rx,
+        .baud_rate = .@"115200",
+    });
+
+    nrf.uart.init_logger(uart);
+
+    defer i2c0.reset();
+    defer i2c0dma.reset();
+
+    // ------------------------ BUS SCAN ------------------------
+    std.log.info("I2C bus scan", .{});
+
+    try i2c0.apply(.{
+        .scl_pin = gpio.num(0, 9),
+        .sda_pin = gpio.num(0, 10),
+    });
+    for (0..std.math.maxInt(u7)) |addr| {
+        const a: i2c.Address = @enumFromInt(addr);
+
+        var rx_data: [1]u8 = undefined;
+        _ = i2c0.read_blocking(a, &rx_data, null) catch |e| {
+            if (e != i2c.TransactionError.DeviceNotPresent and
+                e != i2c.TransactionError.TargetAddressReserved)
+                std.log.info("Error {any}", .{e});
+            continue;
+        };
+
+        std.log.info("I2C device found at address {X}.", .{addr});
+    }
+    i2c0.reset();
+
+    // ------------------------ BUS SCAN (DMA) ------------------------
+    std.log.info("I2C bus scan (DMA)", .{});
+
+    try i2c0dma.apply(.{
+        .scl_pin = gpio.num(0, 9),
+        .sda_pin = gpio.num(0, 10),
+    });
+    for (0..std.math.maxInt(u7)) |addr| {
+        const a: i2cdma.Address = @enumFromInt(addr);
+
+        var rx_data: [1]u8 = undefined;
+        _ = i2c0dma.read_blocking(a, &rx_data, null) catch |e| {
+            if (e != i2c.TransactionError.DeviceNotPresent and
+                e != i2c.TransactionError.TargetAddressReserved)
+                std.log.info("Error {any}", .{e});
+            continue;
+        };
+
+        std.log.info("I2C device found at address {X}.", .{addr});
+    }
+    i2c0dma.reset();
+
+    std.log.info("Done!", .{});
+}

examples/nordic/nrf5x/src/i2c_temp.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const time = microzig.drivers.time;
+const board = microzig.board;
+
+const nrf = microzig.hal;
+const TMP117 = microzig.drivers.sensor.TMP117;
+
+const i2c = nrf.i2c;
+const i2cdma = nrf.i2cdma;
+const gpio = nrf.gpio;
+const peripherals = microzig.chip.peripherals;
+const I2C_Device = nrf.drivers.I2C_Device;
+
+const uart = nrf.uart.num(0);
+const i2c0 = i2c.num(0);
+const i2c0dma = i2cdma.num(0);
+
+const sleep_ms = nrf.time.sleep_ms;
+
+pub const microzig_options = microzig.Options{
+    .log_level = .debug,
+    .logFn = nrf.uart.logFn,
+};
+
+pub fn main() !void {
+    board.init();
+
+    uart.apply(.{
+        .tx_pin = board.uart_tx,
+        .rx_pin = board.uart_rx,
+        .baud_rate = .@"115200",
+    });
+
+    nrf.uart.init_logger(uart);
+    defer i2c0.reset();
+    defer i2c0dma.reset();
+
+    // ------------------------ TMP117 w/driver ------------------------
+    std.log.info("I2C temp sensor (using driver)", .{});
+    try i2c0.apply(.{
+        .scl_pin = gpio.num(0, 9),
+        .sda_pin = gpio.num(0, 10),
+    });
+
+    // Create i2c datagram device
+    var i2c_device = I2C_Device.init(i2c0, @enumFromInt(0x48));
+    // Pass i2c device to driver to create sensor instance
+    const temp_sensor = try TMP117.init(i2c_device.datagram_device());
+
+    const temp_sensor_address = 0x48;
+    var temp_buf: [2]u8 = undefined;
+    const cbuf = [3]u8{ 1, 0, 0 };
+
+    std.log.info("Writing config", .{});
+    try temp_sensor.write_configuration(.{});
+
+    std.log.info("Reading device ID config", .{});
+    const id = try temp_sensor.read_device_id();
+    std.log.info("ID: {any}", .{id});
+
+    for (0..5) |_| {
+        const temp = try temp_sensor.read_temperature();
+        std.log.info("Temp: {d:0.2}°C", .{temp});
+        sleep_ms(500);
+    }
+    i2c0.reset();
+
+    // ------------------------ TMP117 raw ------------------------
+    std.log.info("I2C temp sensor (raw writes)", .{});
+
+    try i2c0.apply(.{
+        .scl_pin = gpio.num(0, 9),
+        .sda_pin = gpio.num(0, 10),
+    });
+
+    std.log.info("Writing config", .{});
+    try i2c0.writev_blocking(@enumFromInt(temp_sensor_address), &.{&cbuf}, null);
+
+    std.log.info("Reading temp", .{});
+    for (0..5) |_| {
+        const write_buf = [_]u8{0}; // Read temperature register
+        try i2c0.writev_then_readv_blocking(@enumFromInt(temp_sensor_address), &.{&write_buf}, &.{&temp_buf}, null);
+        const temp_u = std.mem.readInt(u16, &temp_buf, .big);
+        const temp = @as(f32, @floatFromInt(temp_u)) * 7.8125E-3;
+        std.log.info("Temp: {d:0.2}°C", .{temp});
+        sleep_ms(500);
+    }
+    i2c0.reset();
+
+    // ------------------------ TMP117 raw (DMA) ------------------------
+    std.log.info("I2C temp sensor (raw writes w/DMA)", .{});
+
+    try i2c0dma.apply(.{
+        .scl_pin = gpio.num(0, 9),
+        .sda_pin = gpio.num(0, 10),
+    });
+
+    std.log.info("Writing config", .{});
+    try i2c0dma.write_blocking(@enumFromInt(temp_sensor_address), &cbuf, null);
+
+    std.log.info("Reading temp", .{});
+    for (0..5) |_| {
+        const write_buf = [_]u8{0}; // Read temperature register
+        try i2c0dma.write_then_read_blocking(@enumFromInt(temp_sensor_address), &write_buf, &temp_buf, null);
+        const temp_u = std.mem.readInt(u16, &temp_buf, .big);
+        const temp = @as(f32, @floatFromInt(temp_u)) * 7.8125E-3;
+        std.log.info("Temp: {d:0.2}°C", .{temp});
+        sleep_ms(500);
+    }
+    i2c0dma.reset();
+}

port/nordic/nrf5x/src/hal.zig

@@ -2,8 +2,11 @@ const microzig = @import("microzig");
 
 pub const compatibility = @import("hal/compatibility.zig");
 pub const gpio = @import("hal/gpio.zig");
+pub const i2c = @import("hal/i2c.zig");
+pub const i2cdma = @import("hal/i2cdma.zig");
 pub const time = @import("hal/time.zig");
 pub const uart = @import("hal/uart.zig");
+pub const drivers = @import("hal/drivers.zig");
 // TODO: adc, timers, pwm, rng, rtc, spi, interrupts, i2c, wdt, wifi, nfc, bt, zigbee
 
 pub fn init() void {
@@ -12,6 +15,10 @@ pub fn init() void {
 
 test "hal tests" {
     _ = gpio;
+    _ = i2c;
+    _ = i2cdma;
     _ = time;
     _ = uart;
+
+    _ = drivers;
 }

port/nordic/nrf5x/src/hal/drivers.zig

@@ -0,0 +1,111 @@
+//!
+//! This file implements driver abstractions based on HAL devices.
+//!
+
+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;
+const Stream_Device = drivers.Stream_Device;
+const Digital_IO = drivers.Digital_IO;
+const Clock_Device = drivers.Clock_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.Overrun,
+            => 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.Overrun,
+            => return error.IoError,
+
+            error.Timeout => return error.Timeout,
+            error.NoData => return 0,
+        };
+    }
+};