Added the zig_main project to software for zig based implementation of code for robot

software/zig_main/main/app.zig

@@ -0,0 +1,121 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const idf = @import("esp_idf");
+const ver = idf.ver.Version;
+const mem = std.mem;
+
+comptime {
+    @export(&main, .{ .name = "app_main" });
+}
+
+fn main() callconv(.c) void {
+    // This allocator is safe to use as the backing allocator w/ arena allocator
+
+    // custom allocators (based on old raw_c_allocator)
+    // idf.heap.HeapCapsAllocator
+    // idf.heap.MultiHeapAllocator
+    // idf.heap.VPortAllocator
+
+    var heap = idf.heap.HeapCapsAllocator.init(.{ .@"8bit" = true });
+    var arena = std.heap.ArenaAllocator.init(heap.allocator());
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    log.info("Hello, world from Zig!", .{});
+
+    log.info(
+        \\[Zig Info]
+        \\* Version: {s}
+        \\* Compiler Backend: {s}
+    , .{
+        @as([]const u8, builtin.zig_version_string),
+        @tagName(builtin.zig_backend),
+    });
+
+    log.info(
+        \\[ESP-IDF Info]
+        \\* Version: {s}
+    , .{ver.get().toString(allocator)});
+
+    log.info(
+        \\[Memory Info]
+        \\* Total: {d}
+        \\* Free: {d}
+        \\* Minimum: {d}
+    , .{
+        heap.totalSize(),
+        heap.freeSize(),
+        heap.minimumFreeSize(),
+    });
+
+    log.info("Let's have a look at your shiny {s} - {s} system! :)", .{
+        @tagName(builtin.cpu.arch),
+        builtin.cpu.model.name,
+    });
+
+    arraylist(allocator) catch |err| {
+        log.err("Error: {s}", .{@errorName(err)});
+    };
+
+    if (builtin.mode == .Debug)
+        heap.dump();
+
+    // FreeRTOS Tasks — Task.create returns !Handle; on failure panic with a clear message.
+    _ = idf.rtos.Task.create(fooTask, "foo", 1024 * 3, null, 1) catch @panic("Task foo not created");
+    _ = idf.rtos.Task.create(barTask, "bar", 1024 * 3, null, 2) catch @panic("Task bar not created");
+    _ = idf.rtos.Task.create(blinkTask, "blink", 1024 * 2, null, 5) catch @panic("Task blink not created");
+}
+
+fn blinkLED(delay_ms: u32) !void {
+    try idf.gpio.Direction.set(.@"18", .output);
+    while (true) {
+        log.info("LED: ON", .{});
+        try idf.gpio.Level.set(.@"18", 1);
+        idf.rtos.Task.delayMs(delay_ms);
+
+        log.info("LED: OFF", .{});
+        try idf.gpio.Level.set(.@"18", 0);
+        idf.rtos.Task.delayMs(delay_ms);
+    }
+}
+
+fn arraylist(allocator: mem.Allocator) !void {
+    var arr: std.ArrayList(u32) = .empty;
+    defer arr.deinit(allocator);
+
+    try arr.append(allocator, 10);
+    try arr.append(allocator, 20);
+    try arr.append(allocator, 30);
+
+    for (arr.items) |value| {
+        idf.log.ESP_LOG(allocator, idf.log.default_level, "EXAMPLE", "Arr value: {}\n", .{value});
+    }
+}
+
+export fn blinkTask(_: ?*anyopaque) callconv(.c) void {
+    blinkLED(1000) catch |err| @panic(@errorName(err));
+}
+
+export fn fooTask(_: ?*anyopaque) callconv(.c) void {
+    while (true) {
+        log.info("Demo_Task foo printing..", .{});
+        idf.rtos.Task.delayMs(2000);
+    }
+}
+
+export fn barTask(_: ?*anyopaque) callconv(.c) void {
+    while (true) {
+        log.info("Demo_Task bar printing..", .{});
+        idf.rtos.Task.delayMs(1000);
+    }
+}
+
+pub const panic = idf.esp_panic.panic;
+const log = std.log.scoped(idf.log.default_log_scope);
+pub const std_options: std.Options = .{
+    .log_level = switch (builtin.mode) {
+        .Debug => .debug,
+        else => .info,
+    },
+    .logFn = idf.log.espLogFn,
+};