import microzig as microzig

core/src/core/experimental/gpio.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const micro = @import("microzig");
 const hal = @import("hal");
 
 pub const Mode = enum {

core/test/programs/blinky.zig

@@ -1,27 +1,27 @@
-const micro = @import("microzig");
+const microzig = @import("microzig");
 
 // Configures the led_pin to a hardware pin
-const led_pin = if (micro.config.has_board)
-    switch (micro.config.board_name) {
-        .@"Arduino Nano" => micro.Pin("D13"),
-        .@"Arduino Uno" => micro.Pin("D13"),
-        .@"mbed LPC1768" => micro.Pin("LED-1"),
-        .STM32F3DISCOVERY => micro.Pin("LD3"),
-        .STM32F4DISCOVERY => micro.Pin("LD5"),
-        .STM32F429IDISCOVERY => micro.Pin("LD4"),
-        .@"Longan Nano" => micro.Pin("PA2"),
+const led_pin = if (microzig.config.has_board)
+    switch (microzig.config.board_name) {
+        .@"Arduino Nano" => microzig.Pin("D13"),
+        .@"Arduino Uno" => microzig.Pin("D13"),
+        .@"mbed LPC1768" => microzig.Pin("LED-1"),
+        .STM32F3DISCOVERY => microzig.Pin("LD3"),
+        .STM32F4DISCOVERY => microzig.Pin("LD5"),
+        .STM32F429IDISCOVERY => microzig.Pin("LD4"),
+        .@"Longan Nano" => microzig.Pin("PA2"),
         else => @compileError("unknown board"),
     }
-else switch (micro.config.chip_name) {
-    .ATmega328p => micro.Pin("PB5"),
-    .@"NXP LPC1768" => micro.Pin("P1.18"),
-    .STM32F103x8 => micro.Pin("PC13"),
-    .GD32VF103x8 => micro.Pin("PA2"),
+else switch (microzig.config.chip_name) {
+    .ATmega328p => microzig.Pin("PB5"),
+    .@"NXP LPC1768" => microzig.Pin("P1.18"),
+    .STM32F103x8 => microzig.Pin("PC13"),
+    .GD32VF103x8 => microzig.Pin("PA2"),
     else => @compileError("unknown chip"),
 };
 
 pub fn main() void {
-    const led = micro.Gpio(led_pin, .{
+    const led = microzig.Gpio(led_pin, .{
         .mode = .output,
         .initial_state = .low,
     });

core/test/programs/interrupt.zig

@@ -1,4 +1,3 @@
-const micro = @import("microzig");
 const builtin = @import("builtin");
 
 pub const interrupts = switch (builtin.cpu.arch) {

core/test/programs/uart-sync.zig

@@ -1,57 +1,57 @@
-const micro = @import("microzig");
+const microzig = @import("microzig");
 
 // Configures the led_pin and uart index
-const cfg = if (micro.config.has_board)
-    switch (micro.config.board_name) {
+const cfg = if (microzig.config.has_board)
+    switch (microzig.config.board_name) {
         .@"mbed LPC1768" => .{
-            .led_pin = micro.Pin("LED-1"),
+            .led_pin = microzig.Pin("LED-1"),
             .uart_idx = 1,
             .pins = .{},
         },
         .STM32F3DISCOVERY => .{
-            .led_pin = micro.Pin("LD3"),
+            .led_pin = microzig.Pin("LD3"),
             .uart_idx = 1,
             .pins = .{},
         },
         .STM32F4DISCOVERY => .{
-            .led_pin = micro.Pin("LD5"),
+            .led_pin = microzig.Pin("LD5"),
             .uart_idx = 2,
-            .pins = .{ .tx = micro.Pin("PA2"), .rx = micro.Pin("PA3") },
+            .pins = .{ .tx = microzig.Pin("PA2"), .rx = microzig.Pin("PA3") },
         },
         .@"Longan Nano" => .{
-            .led_pin = micro.Pin("PA2"),
+            .led_pin = microzig.Pin("PA2"),
             .uart_idx = 1,
             .pins = .{ .tx = null, .rx = null },
         },
         .@"Arduino Uno" => .{
-            .led_pin = micro.Pin("D13"),
+            .led_pin = microzig.Pin("D13"),
             .uart_idx = 0,
             .pins = .{},
         },
         else => @compileError("unknown board"),
     }
-else switch (micro.config.chip_name) {
-    .@"NXP LPC1768" => .{ .led_pin = micro.Pin("P1.18"), .uart_idx = 1, .pins = .{} },
-    .GD32VF103x8 => .{ .led_pin = micro.Pin("PA2"), .uart_idx = 1, .pins = .{} },
+else switch (microzig.config.chip_name) {
+    .@"NXP LPC1768" => .{ .led_pin = microzig.Pin("P1.18"), .uart_idx = 1, .pins = .{} },
+    .GD32VF103x8 => .{ .led_pin = microzig.Pin("PA2"), .uart_idx = 1, .pins = .{} },
     else => @compileError("unknown chip"),
 };
 
 pub fn main() !void {
-    const led = micro.Gpio(cfg.led_pin, .{
+    const led = microzig.Gpio(cfg.led_pin, .{
         .mode = .output,
         .initial_state = .low,
     });
     led.init();
 
-    var uart = micro.Uart(cfg.uart_idx, cfg.pins).init(.{
+    var uart = microzig.Uart(cfg.uart_idx, cfg.pins).init(.{
         .baud_rate = 9600,
         .stop_bits = .one,
         .parity = null,
         .data_bits = .eight,
     }) catch |err| {
         blinkError(led, err);
 
-        micro.hang();
+        microzig.hang();
     };
 
     var out = uart.writer();
@@ -60,11 +60,11 @@ pub fn main() !void {
         led.setToHigh();
         try out.writeAll("Hello microzig!\r\n");
         led.setToLow();
-        micro.debug.busySleep(100_000);
+        microzig.debug.busySleep(100_000);
     }
 }
 
-fn blinkError(led: anytype, err: micro.uart.InitError) void {
+fn blinkError(led: anytype, err: microzig.uart.InitError) void {
     var blinks: u3 =
         switch (err) {
         error.UnsupportedBaudRate => 1,
@@ -75,8 +75,8 @@ fn blinkError(led: anytype, err: micro.uart.InitError) void {
 
     while (blinks > 0) : (blinks -= 1) {
         led.setToHigh();
-        micro.debug.busySleep(1_000_000);
+        microzig.debug.busySleep(1_000_000);
         led.setToLow();
-        micro.debug.busySleep(1_000_000);
+        microzig.debug.busySleep(1_000_000);
     }
 }

core/thoughts.md

@@ -20,11 +20,11 @@ root
 Declaring `panic` in the root file will cause `builtin` to reference the proper package which will then instantiate microzig which will reference `mcu` package which will instantiate `reset` (or similar) which will invoke `microzig.main()` which will invoke `root.main()`. Oh boy :laughing:
 
 ```zig
-const micro = @import("micro");
+const microzig = @import("microzig");
 
-pub const panic = micro.panic; // this will instantiate microzig
+pub const panic = microzig.panic; // this will instantiate microzig
 
-comptime { _ = micro };  // this should not be necessary
+comptime { _ = microzig };  // this should not be necessary
 
 pub fn main() void {
 
@@ -59,18 +59,18 @@ A symbol can be a function `fn() void`, or a anonymous enum literal `.hang` or `
 
 ```zig
 pub fn main() void {
-  micro.interrupts.enable(.WDT);  // enables the WDT interrupt
-  micro.interrupts.disable(.WDT); // enables the WDT interrupt
-  micro.interrupts.enable(.WTF); // yields compile error "WTF is not a valid interrupt"
-  micro.interrupts.enable(.PCINT0); // yields compile error "PCINT0 has no defined interrupt handler"
-  micro.interrupts.enable(.NMI); // yields compile error "NMI cannot be masked"
-  micro.interrupts.enableAll();
-  micro.interrupts.batchEnable(.{ .NMI, .WDT  });
+  microzig.interrupts.enable(.WDT);  // enables the WDT interrupt
+  microzig.interrupts.disable(.WDT); // enables the WDT interrupt
+  microzig.interrupts.enable(.WTF); // yields compile error "WTF is not a valid interrupt"
+  microzig.interrupts.enable(.PCINT0); // yields compile error "PCINT0 has no defined interrupt handler"
+  microzig.interrupts.enable(.NMI); // yields compile error "NMI cannot be masked"
+  microzig.interrupts.enableAll();
+  microzig.interrupts.batchEnable(.{ .NMI, .WDT  });
 
-  micro.interrupts.cli(); // set interrupt enabled (global enable)
+  microzig.interrupts.cli(); // set interrupt enabled (global enable)
 
   { // critical section
-    var crit = micro.interrupts.enterCriticalSection();
+    var crit = microzig.interrupts.enterCriticalSection();
     defer crit.leave();
   }
 }
@@ -100,7 +100,7 @@ pub const interrupt_handlers = struct {
 microzig should allow having a general purpose timer mechanism
 
 ```zig
-pub var cpu_frequency = 16.0 * micro.clock.mega_hertz;
+pub var cpu_frequency = 16.0 * microzig.clock.mega_hertz;
 
 pub const sleep_mode = .timer; // timer, busyloop, whatever
 
@@ -109,7 +109,7 @@ pub fn main() !void {
 
   while(true) {
     led.toggle();
-    micro.sleep(100_000); // sleep 100ms
+    microzig.sleep(100_000); // sleep 100ms
   }
 }
 ```
@@ -121,18 +121,18 @@ pub fn main() !void {
 
 ```zig
 
-// micro.Pin returns a type containing all relevant pin information
-const status_led_pin = micro.Pin("PA3");
+// microzig.Pin returns a type containing all relevant pin information
+const status_led_pin = microzig.Pin("PA3");
 
 // generate a runtime possible pin that cannot be used in all APIs
-var generic_pic: micro.RuntimePin.init(status_led_pin);
+var generic_pic: microzig.RuntimePin.init(status_led_pin);
 
 // 4 Bit IEEE-488 bit banging register
-const serial_out = micro.GpioOutputRegister(.{
-  micro.Pin("PA0"),
-  micro.Pin("PA1"),
-  micro.Pin("PA3"), // whoopsies, i miswired, let the software fix that
-  micro.Pin("PA2"),
+const serial_out = microzig.GpioOutputRegister(.{
+  microzig.Pin("PA0"),
+  microzig.Pin("PA1"),
+  microzig.Pin("PA3"), // whoopsies, i miswired, let the software fix that
+  microzig.Pin("PA2"),
 });
 
 pub fn bitBang(nibble: u4) void {
@@ -150,9 +150,9 @@ pub fn main() !void {
 	// route that pin to UART.RXD
   status_led_pin.route(.uart0_rxd); 
 
-  //var uart_read_dma_channel = micro.Dma.init(.{.channel = 1});
+  //var uart_read_dma_channel = microzig.Dma.init(.{.channel = 1});
 
-  const status_led = micro.Gpio(status_led_pin, .{
+  const status_led = microzig.Gpio(status_led_pin, .{
     .mode          = .output,       // { input, output, input_output, open_drain, generic }
     .initial_state = .unspecificed, // { unspecified, low, high, floating, driven }
   });
@@ -206,17 +206,17 @@ pub fn main() !void {
 
 ```zig
 const std = @import("std");
-const micro = @import("µzig");
+const microzig = @import("µzig");
 
 // if const it can be comptime-optimized
-pub var cpu_frequency = 100.0 * micro.clock.mega_hertz;
+pub var cpu_frequency = 100.0 * microzig.clock.mega_hertz;
 
 // if this is enabled, a event loop will run
 // in microzig.main() that allows using `async`/`await` "just like that" *grin*
 pub const io_mode = .evented;
 
 pub fn main() !void {
-  var debug_port = micro.Uart.init(0, .{
+  var debug_port = microzig.Uart.init(0, .{
     .baud_rate = 9600,
     .stop_bits = .@"2",
     .parity = .none, // { none, even, odd, mark, space }
@@ -239,7 +239,7 @@ pub fn main() !void {
 
 ## Initialization
 
-somewhere inside micro.zig
+somewhere inside microzig.zig
 ```zig
 extern fn reset() noreturn {
   if(@hasDecl(mcu, "mcu_reset")) {

port/gigadevice/gd32/src/boards/longan_nano.zig

@@ -1,5 +1,4 @@
 pub const chip = @import("chip");
-pub const micro = @import("microzig");
 
 pub const cpu_frequency = 8_000_000; // 8 MHz
 

port/gigadevice/gd32/src/hals/GD32VF103.zig

@@ -1,5 +1,5 @@
-const micro = @import("microzig");
-const peripherals = micro.chip.peripherals;
+const microzig = @import("microzig");
+const peripherals = microzig.chip.peripherals;
 const UART3 = peripherals.UART3;
 const UART4 = peripherals.UART4;
 
@@ -40,13 +40,13 @@ pub const gpio = struct {
         // TODO: check if pin is already configured as input
     }
 
-    pub fn read(comptime pin: type) micro.gpio.State {
+    pub fn read(comptime pin: type) microzig.gpio.State {
         _ = pin;
         // TODO: check if pin is configured as input
         return .low;
     }
 
-    pub fn write(comptime pin: type, state: micro.gpio.State) void {
+    pub fn write(comptime pin: type, state: microzig.gpio.State) void {
         _ = pin;
         _ = state;
         // TODO: check if pin is configured as output
@@ -74,7 +74,7 @@ pub const uart = struct {
     };
 };
 
-pub fn Uart(comptime index: usize, comptime pins: micro.uart.Pins) type {
+pub fn Uart(comptime index: usize, comptime pins: microzig.uart.Pins) type {
     if (pins.tx != null or pins.rx != null)
         @compileError("TODO: custom pins are not currently supported");
 
@@ -86,7 +86,7 @@ pub fn Uart(comptime index: usize, comptime pins: micro.uart.Pins) type {
         };
         const Self = @This();
 
-        pub fn init(config: micro.uart.Config) !Self {
+        pub fn init(config: microzig.uart.Config) !Self {
             _ = config;
             return Self{};
         }

port/gigadevice/gd32/src/hals/GD32VF103/uart.zig

@@ -1,5 +1,5 @@
-const micro = @import("microzig");
-const peripherals = micro.chip.peripherals;
+const microzig = @import("microzig");
+const peripherals = microzig.chip.peripherals;
 const UART3 = peripherals.UART3;
 const UART4 = peripherals.UART4;
 
@@ -24,7 +24,7 @@ pub const uart = struct {
     };
 };
 
-pub fn Uart(comptime index: usize, comptime pins: micro.uart.Pins) type {
+pub fn Uart(comptime index: usize, comptime pins: microzig.uart.Pins) type {
     if (pins.tx != null or pins.rx != null)
         @compileError("TODO: custom pins are not currently supported");
 
@@ -36,7 +36,7 @@ pub fn Uart(comptime index: usize, comptime pins: micro.uart.Pins) type {
         };
         const Self = @This();
 
-        pub fn init(config: micro.uart.Config) !Self {
+        pub fn init(config: microzig.uart.Config) !Self {
             _ = config;
             return Self{};
         }

port/gigadevice/gd32/test/programs/minimal.zig

@@ -1,4 +1,4 @@
-const micro = @import("microzig");
+const microzig = @import("microzig");
 
 pub fn main() void {
     // This function will contain the application logic.

port/microchip/avr/src/boards.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const micro = @import("microzig");
 const chips = @import("chips.zig");
 
 fn root_dir() []const u8 {

port/microchip/avr/src/chips.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
-const micro = @import("microzig");
-const Chip = micro.Chip;
-const MemoryRegion = micro.MemoryRegion;
+const microzig = @import("microzig");
+const Chip = microzig.Chip;
+const MemoryRegion = microzig.MemoryRegion;
 
 fn root_dir() []const u8 {
     return std.fs.path.dirname(@src().file) orelse ".";