ElicMagus
/
microzig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change the HAL API to snake_case() from camelCase() (#151)

Browse Source
wch-ch32v003
Marnix Klooster 11 months ago committed by GitHub
parent f286bc8e25
commit 2873e9e0b1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File

2
src/core/experimental/debug.zig
Unescape Escape View File

@ -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);

22
src/core/experimental/i2c.zig
Unescape Escape View File

@ -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);

36
src/core/experimental/spi.zig
Unescape Escape View File

@ -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),
};

8
src/core/experimental/uart.zig
Unescape Escape View File

@ -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 {

Write Preview
Loading…
Cancel
Save