initial commit

Author: piotrfila

examples/raspberrypi/rp2xxx/build.zig

@@ -49,6 +49,7 @@ pub fn build(b: *std.Build) void {
 
     const chip_agnostic_examples: []const ChipAgnosticExample = &.{
         .{ .name = "adc", .file = "src/adc.zig" },
+        .{ .name = "async-blinky", .file = "src/async_blinky.zig" },
         .{ .name = "i2c-accel", .file = "src/i2c_accel.zig" },
         .{ .name = "i2c-bus-scan", .file = "src/i2c_bus_scan.zig" },
         .{ .name = "i2c-hall-effect", .file = "src/i2c_hall_effect.zig" },
@@ -79,20 +80,20 @@ pub fn build(b: *std.Build) void {
     available_examples.appendSlice(specific_examples) catch @panic("out of memory");
     for (chip_agnostic_examples) |example| {
         available_examples.append(.{
-            .target = mb.ports.rp2xxx.boards.raspberrypi.pico,
+            .target = raspberrypi.pico,
             .name = b.fmt("pico_{s}", .{example.name}),
             .file = example.file,
         }) catch @panic("out of memory");
 
         available_examples.append(.{
-            .target = mb.ports.rp2xxx.boards.raspberrypi.pico2_arm,
+            .target = raspberrypi.pico2_arm,
             .name = b.fmt("pico2_arm_{s}", .{example.name}),
             .file = example.file,
         }) catch @panic("out of memory");
 
         if (example.works_with_riscv) {
             available_examples.append(.{
-                .target = mb.ports.rp2xxx.boards.raspberrypi.pico2_riscv,
+                .target = raspberrypi.pico2_riscv,
                 .name = b.fmt("pico2_riscv_{s}", .{example.name}),
                 .file = example.file,
             }) catch @panic("out of memory");

examples/raspberrypi/rp2xxx/src/async_blinky.zig

@@ -0,0 +1,62 @@
+const std = @import("std");
+const microzig = @import("microzig");
+const time = microzig.drivers.time;
+
+const rp2xxx = microzig.hal;
+const get_time_since_boot = rp2xxx.time.get_time_since_boot;
+const Io = rp2xxx.Io;
+
+pub const microzig_options = microzig.Options{
+    .log_level = .info,
+    .logFn = rp2xxx.uart.log,
+};
+
+const pin_config: rp2xxx.pins.GlobalConfiguration = .{
+    .GPIO0 = .{ .function = .UART0_TX },
+    .GPIO25 = .{
+        .name = "led",
+        .direction = .out,
+    },
+};
+
+const pins = pin_config.pins();
+const uart = rp2xxx.uart.instance.num(0);
+
+// Blink the led with given half-period.
+fn task_blink(io: *Io.RoundRobin, delay: u32) callconv(.c) noreturn {
+    var deadline: time.Absolute = get_time_since_boot();
+    while (true) {
+        pins.led.toggle();
+        deadline = deadline.add_duration(.from_us(delay));
+        io.pause(&.{ .sleep_until = deadline });
+    }
+}
+
+pub fn main() !void {
+    pin_config.apply();
+    uart.apply(.{ .baud_rate = 1_000_000, .clock_config = rp2xxx.clock_config });
+    rp2xxx.uart.init_logger(uart);
+
+    // Set up stacks. A helper function that automates this would be nice.
+    const max_tasks = 2;
+    var task_stacks_data: [max_tasks][1024]usize = undefined;
+    var task_stacks: [max_tasks]*Io.PauseReason = undefined;
+    for (&task_stacks, &task_stacks_data) |*dst, *src|
+        dst.* = Io.prepare_empty_stack(src);
+
+    var io: Io.RoundRobin = .{ .next_swap = 0, .tasks = &task_stacks };
+
+    // Mixing (xoring) two squarewaves of almost the same frequency produces a beat frequency.
+    io.async(task_blink, .{ &io, 24_000 });
+    io.async(task_blink, .{ &io, 25_000 });
+
+    // We might want both a monotonic clock and an epoch-synchronized one.
+    var deadline: time.Absolute = get_time_since_boot();
+    var cnt: u32 = 0;
+    while (true) {
+        try uart.writer().print("Hello! {}\r\n", .{cnt});
+        cnt += 1;
+        deadline = deadline.add_duration(.from_ms(1000));
+        io.pause(&.{ .sleep_until = deadline });
+    }
+}

port/raspberrypi/rp2xxx/src/hal.zig

@@ -19,6 +19,7 @@ pub const dma = @import("hal/dma.zig");
 pub const drivers = @import("hal/drivers.zig");
 pub const flash = @import("hal/flash.zig");
 pub const gpio = @import("hal/gpio.zig");
+pub const Io = @import("hal/Io.zig");
 pub const multicore = @import("hal/multicore.zig");
 pub const mutex = @import("hal/mutex.zig");
 pub const pins = @import("hal/pins.zig");