Initial commit

README.md

@@ -0,0 +1,9 @@
+`zig build` to build
+
+`openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg &>/dev/null &` starts the debug server for debugprobe (formerly picoprobe)
+
+`telnet localhost 4444` to communicate with the debugger
+
+`tio /dev/ttyACM0` to attach to the uart serial console
+
+Within the telnet session, `adapter speed 10000` provides better probe speeds. `reset` resets the target board. `program <PATH_TO_ELF> reset` uploads the binary to the chip and resets the board.

build.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+const MicroZig = @import("microzig-build");
+
+pub fn build(b: *std.Build) void {
+    const microzig = MicroZig.createBuildEnvironment(b, .{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // `addFirmware` basically works like addExecutable, but takes a
+    // `microzig.Target` for target instead of a `std.zig.CrossTarget`.
+    //
+    // The target will convey all necessary information on the chip,
+    // cpu and potentially the board as well.
+    const firmware = microzig.addFirmware(b, .{
+        .name = "oled",
+        .target = microzig.findTarget("board:raspberry_pi/pico").?,
+        .optimize = optimize,
+        .source_file = .{ .path = "oled.zig" },
+    });
+
+    // `installFirmware()` is the MicroZig pendant to `Build.installArtifact()`
+    // and allows installing the firmware as a typical firmware file.
+    //
+    // This will also install into `$prefix/firmware` instead of `$prefix/bin`.
+    microzig.installFirmware(b, firmware, .{});
+
+    // For debugging, we also always install the firmware as an ELF file
+    microzig.installFirmware(b, firmware, .{ .format = .elf });
+}

build.zig.zon

@@ -0,0 +1,18 @@
+.{
+    .name = "pi pico oled test",
+    .version = "0.1.0",
+    .dependencies = .{
+        .@"microzig-build" = .{
+            .url = "https://downloads.microzig.tech/packages/.data/microzig-build-0.11.0-42-g200340408.tar.gz",
+            .hash = "12203d2fcfa911c93c8fc6fdccaafafeeb4a9ad51a056e2ce4da64b503194a25e97a",
+        },
+        .@"microzig-core" = .{
+            .url = "https://downloads.microzig.tech/packages/.data/microzig-core-0.11.0-42-g200340408.tar.gz",
+            .hash = "12207e762b17484396b4b52cc7d76660039245f830d2e675c5d77759146f490a3738",
+        },
+        .@"raspberrypi/rp2040" = .{
+            .url = "https://downloads.microzig.tech/packages/board-support/raspberrypi/.data/rp2040-0.11.0-42-g200340408.tar.gz",
+            .hash = "1220d9cd7cd4d20f91f929bee20e90ae12a7600d07693a5bdfbaa98f4d079dec32b7",
+        },
+    },
+}

oled.zig

@@ -0,0 +1,84 @@
+const std = @import("std");
+const microzig = @import("microzig");
+
+const SEGMENT_REMAP: u8 = 0xA1; // 0xA1 = ltr, 0xA0 = rtl
+const COM_REMAP: u8 = 0xC8; // 0xC8 = top-down, 0xC0 = bottom-up
+const CONTRAST: u8 = 0x7F; // 0x7F
+const CHARGE_PERIOD: u8 = 0x22; // 0x22
+const MUX_RATIO: u8 = 0x3F; // 0x3F. range 0x0F to 0x3F
+const OSC_FREQ: u8 = 0xF0; // LH is divide ratio, UH is oscillator freq, default 0x80
+
+const SCREEN_HEIGHT: u16 = 64;
+const SCREEN_WIDTH: u16 = 128;
+const SCREEN_SIZE: u16 = SCREEN_HEIGHT * SCREEN_WIDTH / @bitSizeOf(u8);
+
+const rp2040 = microzig.hal;
+const i2c = rp2040.i2c;
+const gpio = rp2040.gpio;
+const led = gpio.num(25);
+const time = rp2040.time;
+const peripherals = microzig.chip.peripherals;
+
+pub const std_options = struct {
+    pub const log_level = .info;
+    pub const logFn = rp2040.uart.log;
+};
+
+const uart = rp2040.uart.num(0);
+const i2c0 = i2c.num(0);
+
+const Screen = struct {
+    _buffer: [SCREEN_SIZE + 1]u8 = [_]u8{0x40} ++ [_]u8{0x00} ** SCREEN_SIZE, //0x40 is the "write" command
+    fn draw(self: *Screen) void {
+        _ = i2c0.write_blocking(@enumFromInt(0x3C), &self._buffer) catch |e| switch (e) {};
+    }
+    fn fill(self: *Screen, value: u8) void {
+        for (self._buffer[1..]) |*v| {
+            v.* = value;
+        }
+    }
+    fn apply(self: *Screen, start: struct { x: u7, y: u4 }, data: []const []const u8) void {
+        var frame = self._buffer[1..];
+        for (0..data.len) |i| {
+            const start_frame: usize = SCREEN_WIDTH * (start.y + i) + start.x;
+            @memcpy(frame[start_frame .. start_frame + data[0].len], data[i]);
+        }
+    }
+};
+
+var scr = Screen{};
+
+pub fn main() !void {
+    setup();
+
+    while (true) {
+        // scr.apply(.{ .x = @intCast(i * 8), .y = @intCast(j) }, &[_][]const u8{&[_]u8{0xFF} ** 8} ** 1);
+        scr.fill(0x00);
+        scr.draw();
+        scr.fill(0x55);
+        scr.draw();
+    }
+}
+
+fn setup() void {
+    led.set_function(.sio);
+    led.set_direction(.out);
+    uart.apply(.{
+        .baud_rate = 115200,
+        .tx_pin = gpio.num(0),
+        .rx_pin = gpio.num(1),
+        .clock_config = rp2040.clock_config,
+    });
+    rp2040.uart.init_logger(uart);
+
+    _ = i2c0.apply(.{
+        .clock_config = rp2040.clock_config,
+        .scl_pin = gpio.num(21),
+        .sda_pin = gpio.num(20),
+        .baud_rate = 2_000_000,
+    });
+    led.put(1);
+
+    _ = i2c0.write_blocking(@enumFromInt(0x3C), &[_]u8{ 0xE4, 0xAE, 0xA8, MUX_RATIO, 0x20, 0x00, 0x40, 0xD3, 0x00, SEGMENT_REMAP, COM_REMAP, 0xDA, 0x12, 0x81, CONTRAST, 0xA4, 0xA6, 0xD5, OSC_FREQ, 0x8D, 0x14, 0xD9, CHARGE_PERIOD, 0x2E, 0xAF }) catch unreachable;
+    _ = i2c0.write_blocking(@enumFromInt(0x3C), &[_]u8{ 0x20, 0x02, 0x00, 0x10, 0x20, 0x00 }) catch unreachable; // reset pointer
+}

ssd1306.zig

@@ -0,0 +1,64 @@
+const micro = @import("microzig");
+
+const SCREEN_HEIGHT: u16 = 64;
+const SCREEN_WIDTH: u16 = 128;
+const SCREEN_SIZE: u16 = SCREEN_HEIGHT * SCREEN_WIDTH / @bitSizeOf(u8);
+
+const I2C_ADDR = 0x3C;
+const Command = enum(u8) {
+    SET_LOW_COLUMN = 0x00,
+    SET_HIGH_COLUMN = 0x10,
+    MEMORY_MODE = 0x20,
+    COLUMN_ADDR = 0x21,
+    PAGE_ADDR = 0x22,
+    SET_START_LINE = 0x40,
+    DEFAULT_ADDRESS = 0x78,
+    SET_CONTRAST = 0x81,
+    CHARGE_PUMP = 0x8D,
+    SEG_REMAP = 0xA0,
+    DISPLAY_RESUME = 0xA4,
+    DISPLAY_ALL_ON = 0xA5,
+    NORMAL_DISPLAY = 0xA6,
+    INVERT_DISPLAY = 0xA7,
+    SET_MUX = 0xA8,
+    DISPLAY_OFF = 0xAE,
+    DISPLAY_ON = 0xAF,
+    SET_PAGE = 0xB0,
+    COM_SCAN_DIR = 0xC0,
+    SET_DISPLAY_OFFSET = 0xD3,
+    SET_DISPLAY_CLOCK_DIV = 0xD5,
+    SET_PRECHARGE = 0xD9,
+    SET_COM_PINS = 0xDA,
+    SET_VCOM_DESELECT = 0xDB,
+
+    SWITCH_CAP_VCC = 0x02,
+    NOP = 0xE3,
+};
+pub const Config = struct {
+    contrast: u8 = 127,
+    display_start_line: u6 = 0,
+    seg_remap: bool = false,
+    mux_ratio: u6 = 63, // can't go lower than 15
+    com_scan_dir: bool = 0,
+    display_offset: u6 = 0,
+    com_pin_config: bool = 1,
+    com_left_right_remap: bool = false,
+    display_clock_div_ratio: u4 = 0x0,
+    oscillator_freq: u4 = 0xF,
+    precharge_period_1: u4 = 0x2,
+    precharge_period_2: u4 = 0x2,
+    vcomh_deselect_level: u2 = 0b10, // can't be 0b01
+};
+
+pub const SSD1306 = struct {
+    i2c: *micro.hal.i2c.I2C,
+    pub fn init(self: *SSD1306, i2c_index: usize, pins: Pins, config: Config) SSD1306 {
+
+    }
+}
+
+pub const I2CConfig = struct {
+    index: ?u1 = 0,
+    scl: ?type = null,
+    sda: ?type = null,
+};