diff --git a/src/core/experimental/debug.zig b/src/core/experimental/debug.zig index c74bdba..767f8c3 100644 --- a/src/core/experimental/debug.zig +++ b/src/core/experimental/debug.zig @@ -30,7 +30,7 @@ const DebugWriter = std.io.Writer(void, DebugErr, writer_write); pub fn write(string: []const u8) void { if (!config.has_board) return; - if (!@hasDecl(board, "debugWrite")) + if (!@hasDecl(board, "debug_write")) return; board.debug_write(string); diff --git a/src/core/experimental/i2c.zig b/src/core/experimental/i2c.zig index 7eefcbd..52fbaa3 100644 --- a/src/core/experimental/i2c.zig +++ b/src/core/experimental/i2c.zig @@ -28,7 +28,7 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { } fn read_some(self: *Self, buffer: []u8) ReadError!usize { - try self.state.readNoEof(buffer); + try self.state.read_no_eof(buffer); return buffer.len; } @@ -41,7 +41,7 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { /// Note that some platforms set the repeated START condition /// on the first read or write call. pub fn restart_transfer(self: *Self, comptime new_direction: Direction) !Transfer(new_direction) { - return Transfer(direction){ .state = try self.state.restartTransfer(new_direction) }; + return Transfer(direction){ .state = try self.state.restart_transfer(new_direction) }; } }, .write => struct { @@ -59,7 +59,7 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { } fn write_some(self: *Self, buffer: []const u8) WriteError!usize { - try self.state.writeAll(buffer); + try self.state.write_all(buffer); return buffer.len; } @@ -73,8 +73,8 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { /// on the first read or write call. pub fn restart_transfer(self: *Self, comptime new_direction: Direction) !Transfer(new_direction) { return switch (new_direction) { - .read => Transfer(new_direction){ .state = try self.state.restartRead() }, - .write => Transfer(new_direction){ .state = try self.state.restartWrite() }, + .read => Transfer(new_direction){ .state = try self.state.restart_read() }, + .write => Transfer(new_direction){ .state = try self.state.restart_write() }, }; } }, @@ -93,12 +93,12 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { /// Shorthand for 'register-based' devices pub fn write_register(self: Device, register_address: u8, byte: u8) ReadError!void { - try self.writeRegisters(register_address, &.{byte}); + try self.write_registers(register_address, &.{byte}); } /// Shorthand for 'register-based' devices - pub fn write_registers(self: Device, register_address: u8, buffer: []u8) ReadError!void { - var wt = try self.startTransfer(.write); + pub fn write_registers(self: Device, register_address: u8, buffer: []const u8) ReadError!void { + var wt = try self.start_transfer(.write); defer wt.stop() catch {}; try wt.writer().writeByte(register_address); try wt.writer().writeAll(buffer); @@ -107,17 +107,17 @@ pub fn I2CController(comptime index: usize, comptime pins: Pins) type { /// Shorthand for 'register-based' devices pub fn read_register(self: Device, register_address: u8) ReadError!u8 { var buffer: [1]u8 = undefined; - try self.readRegisters(register_address, &buffer); + try self.read_registers(register_address, &buffer); return buffer[0]; } /// Shorthand for 'register-based' devices pub fn read_registers(self: Device, register_address: u8, buffer: []u8) ReadError!void { var rt = write_and_restart: { - var wt = try self.startTransfer(.write); + var wt = try self.start_transfer(.write); errdefer wt.stop() catch {}; try wt.writer().writeByte(1 << 7 | register_address); // MSB == 'keep sending until I STOP' - break :write_and_restart try wt.restartTransfer(.read); + break :write_and_restart try wt.restart_transfer(.read); }; defer rt.stop() catch {}; try rt.reader().readNoEof(buffer); diff --git a/src/core/experimental/spi.zig b/src/core/experimental/spi.zig index 250e747..7db6ab5 100644 --- a/src/core/experimental/spi.zig +++ b/src/core/experimental/spi.zig @@ -1,16 +1,16 @@ const std = @import("std"); -const micro = @import("microzig"); -const chip = @import("chip"); +const hal = @import("hal"); +const clock = @import("clock.zig"); // Is there a different/better way? /// The SPI bus with the given environment-specific number. /// Only 'master' mode is supported currently. pub fn SpiBus(comptime index: usize) type { - const SystemSpi = chip.SpiBus(index); + const SystemSpi = hal.SpiBus(index); return struct { /// A SPI 'slave' device, selected via the given CS pin. /// (Default is CS=low to select.) - pub fn SpiDevice(comptime cs_pin: type, config: DeviceConfig) type { + pub fn SpiDevice(comptime cs_pin: type, comptime config: DeviceConfig) type { return struct { const SelfSpiDevice = @This(); @@ -24,7 +24,7 @@ pub fn SpiBus(comptime index: usize) type { device: SelfSpiDevice, fn transceive_byte(self: *SelfTransfer, write_byte: u8, read_pointer: *u8) !void { - try self.device.internal.transceiveByte(write_byte, read_pointer); + try self.device.internal.transceive_byte(write_byte, read_pointer); } pub const Writer = std.io.Writer(*SelfTransfer, WriteError, write_some); @@ -35,7 +35,7 @@ pub fn SpiBus(comptime index: usize) type { } fn write_some(self: *SelfTransfer, buffer: []const u8) WriteError!usize { - try self.device.internal.writeAll(buffer); + try self.device.internal.write_all(buffer); return buffer.len; } @@ -47,40 +47,40 @@ pub fn SpiBus(comptime index: usize) type { } fn read_some(self: *SelfTransfer, buffer: []u8) ReadError!usize { - try self.device.internal.readInto(buffer); + try self.device.internal.read_into(buffer); return buffer.len; } /// end the current transfer, releasing via the CS pin pub fn end(self: *SelfTransfer) void { - self.device.internal.endTransfer(cs_pin, config); + self.device.internal.end_transfer(cs_pin, config); } }; /// start a new transfer, selecting using the CS pin pub fn begin_transfer(self: SelfSpiDevice) !Transfer { - self.internal.switchToDevice(cs_pin, config); - self.internal.beginTransfer(cs_pin, config); + self.internal.switch_to_device(cs_pin, config); + self.internal.begin_transfer(cs_pin, config); return Transfer{ .device = self }; } pub fn transceive(self: SelfSpiDevice, write_buffer: []const u8, read_buffer: []u8) !void { std.debug.assert(write_buffer.len == read_buffer.len); - var transfer = try self.beginTransfer(); + var transfer = try self.begin_transfer(); defer transfer.end(); for (write_buffer, 0..) |_, i| { - try transfer.transceiveByte(write_buffer[i], &read_buffer[i]); + try transfer.transceive_byte(write_buffer[i], &read_buffer[i]); } } /// Shorthand for 'register-based' devices pub fn write_register(self: SelfSpiDevice, register_address: u8, byte: u8) ReadError!void { - try self.writeRegisters(register_address, &.{byte}); + try self.write_registers(register_address, &.{byte}); } /// Shorthand for 'register-based' devices - pub fn write_registers(self: SelfSpiDevice, register_address: u8, buffer: []u8) ReadError!void { - var transfer = try self.beginTransfer(); + pub fn write_registers(self: SelfSpiDevice, register_address: u8, buffer: []const u8) ReadError!void { + var transfer = try self.begin_transfer(); defer transfer.end(); // write auto-increment, starting at given register try transfer.writer().writeByte(0b01_000000 | register_address); @@ -90,13 +90,13 @@ pub fn SpiBus(comptime index: usize) type { /// Shorthand for 'register-based' devices pub fn read_register(self: SelfSpiDevice, register_address: u8) ReadError!u8 { var buffer: [1]u8 = undefined; - try self.readRegisters(register_address, &buffer); + try self.read_registers(register_address, &buffer); return buffer[0]; } /// Shorthand for 'register-based' devices pub fn read_registers(self: SelfSpiDevice, register_address: u8, buffer: []u8) ReadError!void { - var transfer = try self.beginTransfer(); + var transfer = try self.begin_transfer(); defer transfer.end(); // read auto-increment, starting at given register try transfer.writer().writeByte(0b11_000000 | register_address); @@ -111,7 +111,7 @@ pub fn SpiBus(comptime index: usize) type { /// Initialize this SPI bus and return a handle to it. pub fn init(config: BusConfig) InitError!SelfSpiBus { - micro.clock.ensure(); // TODO: Wat? + clock.ensure(); // TODO: Wat? return SelfSpiBus{ .internal = try SystemSpi.init(config), }; diff --git a/src/core/experimental/uart.zig b/src/core/experimental/uart.zig index bba29da..e64dd5e 100644 --- a/src/core/experimental/uart.zig +++ b/src/core/experimental/uart.zig @@ -20,21 +20,21 @@ pub fn Uart(comptime index: usize, comptime pins: Pins) type { /// If the UART is already initialized, try to return a handle to it, /// else initialize with the given config. pub fn get_or_init(config: Config) InitError!Self { - if (!@hasDecl(SystemUart, "getOrInit")) { + if (!@hasDecl(SystemUart, "get_or_init")) { // fallback to reinitializing the UART return init(config); } return Self{ - .internal = try SystemUart.getOrInit(config), + .internal = try SystemUart.get_or_init(config), }; } pub fn can_read(self: Self) bool { - return self.internal.canRead(); + return self.internal.can_read(); } pub fn can_write(self: Self) bool { - return self.internal.canWrite(); + return self.internal.can_write(); } pub fn reader(self: Self) Reader {