esp: Add GPIO device to hal (#483)

* esp32c3: Add gpio driver and stepper example
* Add stepper example

Author: Grazfather

examples/espressif/esp/build.zig

@@ -19,8 +19,9 @@ pub fn build(b: *std.Build) void {
 
     const available_examples = [_]Example{
         .{ .name = "blinky", .file = "src/blinky.zig" },
-        .{ .name = "interrupts", .file = "src/interrupts.zig" },
         .{ .name = "custom_clock_config", .file = "src/custom_clock_config.zig" },
+        .{ .name = "interrupts", .file = "src/interrupts.zig" },
+        .{ .name = "stepper_driver", .file = "src/stepper_driver.zig" },
     };
 
     for (available_examples) |example| {

examples/espressif/esp/src/blinky.zig

@@ -4,10 +4,9 @@ const peripherals = microzig.chip.peripherals;
 const hal = microzig.hal;
 const gpio = hal.gpio;
 const usb_serial_jtag = hal.usb_serial_jtag;
-const time = microzig.hal.time;
+const time = hal.time;
 
 pub const microzig_options: microzig.Options = .{
-    .log_level = .debug,
     .logFn = usb_serial_jtag.logger.logFn,
 };
 
@@ -17,9 +16,9 @@ pub fn main() !void {
         .drive_strength = gpio.DriveStrength.@"40mA",
     };
 
-    const led_r_pin = gpio.instance.GPIO3;
-    const led_g_pin = gpio.instance.GPIO4;
-    const led_b_pin = gpio.instance.GPIO5;
+    const led_r_pin = gpio.instance.num(3);
+    const led_g_pin = gpio.instance.num(4);
+    const led_b_pin = gpio.instance.num(5);
 
     led_r_pin.apply(pin_config);
     led_g_pin.apply(pin_config);

examples/espressif/esp/src/stepper_driver.zig

@@ -0,0 +1,66 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const hal = microzig.hal;
+const gpio = hal.gpio;
+const time = hal.time;
+
+const GPIO_Device = hal.drivers.GPIO_Device;
+const ClockDevice = hal.drivers.ClockDevice;
+const A4988 = microzig.drivers.stepper.A4988;
+
+const usb_serial_jtag = hal.usb_serial_jtag;
+
+pub const microzig_options = microzig.Options{
+    .logFn = usb_serial_jtag.logger.logFn,
+};
+
+pub fn main() !void {
+    var cd = ClockDevice{};
+
+    // Setup all pins for the stepper driver
+    var pins: struct {
+        ms1: GPIO_Device,
+        ms2: GPIO_Device,
+        ms3: GPIO_Device,
+        dir: GPIO_Device,
+        step: GPIO_Device,
+    } = undefined;
+    inline for (std.meta.fields(@TypeOf(pins)), .{ 0, 1, 2, 20, 10 }) |field, num| {
+        const pin = gpio.instance.num(num);
+        // Give the pin a sane default config
+        pin.apply(.{});
+        @field(pins, field.name) = GPIO_Device.init(pin);
+    }
+
+    var stepper = A4988.init(.{
+        .ms1_pin = pins.ms1.digital_io(),
+        .ms2_pin = pins.ms2.digital_io(),
+        .ms3_pin = pins.ms3.digital_io(),
+        .dir_pin = pins.dir.digital_io(),
+        .step_pin = pins.step.digital_io(),
+        .clock_device = cd.clock_device(),
+    });
+
+    try stepper.begin(100, 1);
+
+    while (true) {
+        const linear_profile = A4988.Speed_Profile{ .linear_speed = .{ .accel = 200, .decel = 200 } };
+        const constant_profile = A4988.Speed_Profile.constant_speed;
+        // Try both constant and linear acceleration profiles
+        inline for (.{ constant_profile, linear_profile }) |profile| {
+            stepper.set_speed_profile(
+                profile,
+            );
+            std.log.info("profile: {s} ", .{@tagName(profile)});
+            // Try different microsteps
+            inline for (.{ 1, 2, 4, 8, 16 }) |ms| {
+                _ = try stepper.set_microstep(ms);
+                std.log.info("microsteps: {}", .{ms});
+                try stepper.rotate(360);
+                time.sleep_ms(250);
+                try stepper.rotate(-360);
+                time.sleep_ms(250);
+            }
+        }
+    }
+}

examples/raspberrypi/rp2xxx/src/stepper_driver.zig

@@ -48,11 +48,11 @@ pub fn main() !void {
     }
 
     var stepper = A4988.init(.{
-        .dir_pin = pins.dir.digital_io(),
-        .step_pin = pins.step.digital_io(),
         .ms1_pin = pins.ms1.digital_io(),
         .ms2_pin = pins.ms2.digital_io(),
         .ms3_pin = pins.ms3.digital_io(),
+        .dir_pin = pins.dir.digital_io(),
+        .step_pin = pins.step.digital_io(),
         .clock_device = cd.clock_device(),
     });
 

port/espressif/esp/src/hal/drivers.zig

@@ -9,8 +9,83 @@ const hal = @import("../hal.zig");
 const drivers = microzig.drivers.base;
 const time = microzig.drivers.time;
 
+const Digital_IO = drivers.Digital_IO;
 const Clock_Device = drivers.Clock_Device;
 
+///
+/// Implementation of a digital i/o device.
+///
+pub const GPIO_Device = struct {
+    pub const SetDirError = Digital_IO.SetDirError;
+    pub const SetBiasError = Digital_IO.SetBiasError;
+    pub const WriteError = Digital_IO.WriteError;
+    pub const ReadError = Digital_IO.ReadError;
+
+    pub const State = Digital_IO.State;
+    pub const Direction = Digital_IO.Direction;
+
+    pin: hal.gpio.Pin,
+
+    pub fn init(pin: hal.gpio.Pin) GPIO_Device {
+        return .{ .pin = pin };
+    }
+
+    pub fn digital_io(dio: *GPIO_Device) Digital_IO {
+        return Digital_IO{
+            .ptr = dio,
+            .vtable = &vtable,
+        };
+    }
+
+    pub fn set_direction(dio: GPIO_Device, dir: Direction) SetDirError!void {
+        dio.pin.set_output_enable(dir == .output);
+    }
+
+    pub fn set_bias(dio: GPIO_Device, maybe_bias: ?State) SetBiasError!void {
+        dio.pin.set_pullup(if (maybe_bias) |bias| switch (bias) {
+            .low => false,
+            .high => true,
+        } else false);
+    }
+
+    pub fn write(dio: GPIO_Device, state: State) WriteError!void {
+        dio.pin.write(@enumFromInt(state.value()));
+    }
+
+    pub fn read(dio: GPIO_Device) ReadError!State {
+        return @enumFromInt(@intFromEnum(dio.pin.read()));
+    }
+
+    const vtable = Digital_IO.VTable{
+        .set_direction_fn = set_direction_fn,
+        .set_bias_fn = set_bias_fn,
+        .write_fn = write_fn,
+        .read_fn = read_fn,
+    };
+
+    fn set_direction_fn(io: *anyopaque, dir: Direction) SetDirError!void {
+        const gpio: *GPIO_Device = @ptrCast(@alignCast(io));
+        try gpio.set_direction(dir);
+    }
+
+    fn set_bias_fn(io: *anyopaque, bias: ?State) SetBiasError!void {
+        const gpio: *GPIO_Device = @ptrCast(@alignCast(io));
+
+        try gpio.set_bias(bias);
+    }
+
+    fn write_fn(io: *anyopaque, state: State) WriteError!void {
+        const gpio: *GPIO_Device = @ptrCast(@alignCast(io));
+
+        try gpio.write(state);
+    }
+
+    fn read_fn(io: *anyopaque) ReadError!State {
+        const gpio: *GPIO_Device = @ptrCast(@alignCast(io));
+        return try gpio.read();
+    }
+};
+
 ///
 /// Implementation of a time device
 ///

port/espressif/esp/src/hal/gpio.zig

@@ -67,14 +67,14 @@ pub const Pin = struct {
                 usb_conf0.DM_PULLDOWN == 0);
         }
 
-        GPIO.ENABLE_W1TS.write(.{ .ENABLE_W1TS = @as(u17, 1) << self.number, .padding = 0 });
+        GPIO.ENABLE_W1TS.write(.{ .ENABLE_W1TS = @as(u26, 1) << self.number, .padding = 0 });
     }
 
     pub fn reset(self: Pin) void {
         IO_MUX.GPIO[self.number].write_raw(0x00);
         GPIO.FUNC_OUT_SEL_CFG[self.number].write_raw(0x00);
         GPIO.PIN[self.number].write_raw(0x00);
-        GPIO.ENABLE_W1TC.write(.{ .ENABLE_W1TC = @as(u17, 1) << self.number, .padding = 0 });
+        GPIO.ENABLE_W1TC.write(.{ .ENABLE_W1TC = @as(u26, 1) << self.number, .padding = 0 });
     }
 
     pub fn set_output_enable(self: Pin, enable: bool) void {
@@ -120,11 +120,12 @@ pub const Pin = struct {
     }
 
     pub fn write(self: Pin, level: Level) void {
+        // Assert that the pin is set to output enabled
         std.debug.assert(GPIO.FUNC_OUT_SEL_CFG[self.number].read().OEN_SEL == 1);
 
         switch (level) {
-            Level.low => GPIO.OUT_W1TC.write(.{ .OUT_W1TC = @as(u17, 1) << self.number, .padding = 0 }),
-            Level.high => GPIO.OUT_W1TS.write(.{ .OUT_W1TS = @as(u17, 1) << self.number, .padding = 0 }),
+            Level.low => GPIO.OUT_W1TC.write(.{ .OUT_W1TC = @as(u26, 1) << self.number }),
+            Level.high => GPIO.OUT_W1TS.write(.{ .OUT_W1TS = @as(u26, 1) << self.number }),
         }
     }
 
@@ -135,7 +136,7 @@ pub const Pin = struct {
     }
 
     pub fn read(self: Pin) Level {
-        std.debug.assert(IO_MUX.GPIO[self.number].FUN_IE == 1);
+        std.debug.assert(IO_MUX.GPIO[self.number].read().FUN_IE == 1);
 
         return @enumFromInt(GPIO.IN.raw >> self.number & 0x01);
     }
@@ -175,9 +176,10 @@ pub const instance = struct {
     pub const GPIO18: Pin = .{ .number = 18 };
     pub const GPIO19: Pin = .{ .number = 19 };
     pub const GPIO20: Pin = .{ .number = 20 };
+    pub const GPIO21: Pin = .{ .number = 21 };
 
     pub fn num(instance_number: u5) Pin {
-        std.debug.assert(instance_number < 21);
+        std.debug.assert(instance_number < 22);
         return .{ .number = instance_number };
     }
 };