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

software/zig_main/imports/nvs.zig

@@ -0,0 +1,292 @@
+const sys = @import("sys");
+const errors = @import("error");
+
+// ---------------------------------------------------------------------------
+// Type aliases
+// ---------------------------------------------------------------------------
+
+pub const Handle = sys.nvs_handle_t;
+pub const Iterator = sys.nvs_iterator_t;
+pub const EntryInfo = sys.nvs_entry_info_t;
+pub const Stats = sys.nvs_stats_t;
+
+pub const OpenMode = enum(sys.nvs_open_mode_t) {
+    read_only = sys.NVS_READONLY,
+    read_write = sys.NVS_READWRITE,
+};
+
+pub const Type = enum(sys.nvs_type_t) {
+    u8 = sys.NVS_TYPE_U8,
+    i8 = sys.NVS_TYPE_I8,
+    u16 = sys.NVS_TYPE_U16,
+    i16 = sys.NVS_TYPE_I16,
+    u32 = sys.NVS_TYPE_U32,
+    i32 = sys.NVS_TYPE_I32,
+    u64 = sys.NVS_TYPE_U64,
+    i64 = sys.NVS_TYPE_I64,
+    str = sys.NVS_TYPE_STR,
+    blob = sys.NVS_TYPE_BLOB,
+    any = sys.NVS_TYPE_ANY,
+};
+
+// ---------------------------------------------------------------------------
+// Flash initialisation
+// ---------------------------------------------------------------------------
+
+/// Initialise NVS flash with the default "nvs" partition.
+/// Call once at boot before opening any handles.
+pub fn flashInit() !void {
+    try errors.espCheckError(sys.nvs_flash_init());
+}
+
+/// Initialise NVS flash on an explicitly named partition.
+pub fn flashInitPartition(partition_label: [*:0]const u8) !void {
+    try errors.espCheckError(sys.nvs_flash_init_partition(partition_label));
+}
+
+/// Initialise NVS flash, erasing the default partition if it has no free pages
+/// or if an incompatible version was found. This is the pattern recommended by
+/// Espressif for robust boot-time NVS initialisation.
+pub fn flashInitOrErase() !void {
+    const rc = sys.nvs_flash_init();
+    if (rc == sys.ESP_ERR_NVS_NO_FREE_PAGES or rc == sys.ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        try errors.espCheckError(sys.nvs_flash_erase());
+        try errors.espCheckError(sys.nvs_flash_init());
+    } else {
+        try errors.espCheckError(rc);
+    }
+}
+
+/// De-initialise the default NVS partition.
+pub fn flashDeinit() !void {
+    try errors.espCheckError(sys.nvs_flash_deinit());
+}
+
+/// De-initialise a named NVS partition.
+pub fn flashDeinitPartition(partition_label: [*:0]const u8) !void {
+    try errors.espCheckError(sys.nvs_flash_deinit_partition(partition_label));
+}
+
+/// Erase all data in the default NVS partition (loses all stored values).
+pub fn flashErase() !void {
+    try errors.espCheckError(sys.nvs_flash_erase());
+}
+
+/// Erase all data in a named NVS partition.
+pub fn flashErasePartition(part_name: [*:0]const u8) !void {
+    try errors.espCheckError(sys.nvs_flash_erase_partition(part_name));
+}
+
+// ---------------------------------------------------------------------------
+// Handle open / close
+// ---------------------------------------------------------------------------
+
+/// Open an NVS namespace in the default "nvs" partition.
+pub fn open(namespace: [*:0]const u8, mode: OpenMode) !Handle {
+    var handle: Handle = 0;
+    try errors.espCheckError(sys.nvs_open(namespace, @intFromEnum(mode), &handle));
+    return handle;
+}
+
+/// Open an NVS namespace on a specific partition.
+pub fn openFromPartition(part_name: [*:0]const u8, namespace: [*:0]const u8, mode: OpenMode) !Handle {
+    var handle: Handle = 0;
+    try errors.espCheckError(sys.nvs_open_from_partition(part_name, namespace, @intFromEnum(mode), &handle));
+    return handle;
+}
+
+/// Close an NVS handle. Must be called to release resources.
+pub fn close(handle: Handle) void {
+    sys.nvs_close(handle);
+}
+
+/// Commit pending writes. Must be called after set operations to persist data.
+pub fn commit(handle: Handle) !void {
+    try errors.espCheckError(sys.nvs_commit(handle));
+}
+
+// ---------------------------------------------------------------------------
+// Write (set) operations
+// ---------------------------------------------------------------------------
+
+pub fn setI8(handle: Handle, key: [*:0]const u8, value: i8) !void {
+    try errors.espCheckError(sys.nvs_set_i8(handle, key, value));
+}
+
+pub fn setU8(handle: Handle, key: [*:0]const u8, value: u8) !void {
+    try errors.espCheckError(sys.nvs_set_u8(handle, key, value));
+}
+
+pub fn setI16(handle: Handle, key: [*:0]const u8, value: i16) !void {
+    try errors.espCheckError(sys.nvs_set_i16(handle, key, value));
+}
+
+pub fn setU16(handle: Handle, key: [*:0]const u8, value: u16) !void {
+    try errors.espCheckError(sys.nvs_set_u16(handle, key, value));
+}
+
+pub fn setI32(handle: Handle, key: [*:0]const u8, value: i32) !void {
+    try errors.espCheckError(sys.nvs_set_i32(handle, key, value));
+}
+
+pub fn setU32(handle: Handle, key: [*:0]const u8, value: u32) !void {
+    try errors.espCheckError(sys.nvs_set_u32(handle, key, value));
+}
+
+pub fn setI64(handle: Handle, key: [*:0]const u8, value: i64) !void {
+    try errors.espCheckError(sys.nvs_set_i64(handle, key, value));
+}
+
+pub fn setU64(handle: Handle, key: [*:0]const u8, value: u64) !void {
+    try errors.espCheckError(sys.nvs_set_u64(handle, key, value));
+}
+
+/// Store a null-terminated string. The key limit is 15 characters.
+pub fn setStr(handle: Handle, key: [*:0]const u8, value: [*:0]const u8) !void {
+    try errors.espCheckError(sys.nvs_set_str(handle, key, value));
+}
+
+/// Store a binary blob of arbitrary length.
+pub fn setBlob(handle: Handle, key: [*:0]const u8, value: []const u8) !void {
+    try errors.espCheckError(sys.nvs_set_blob(handle, key, value.ptr, value.len));
+}
+
+// ---------------------------------------------------------------------------
+// Read (get) operations
+// ---------------------------------------------------------------------------
+
+pub fn getI8(handle: Handle, key: [*:0]const u8) !i8 {
+    var v: i8 = 0;
+    try errors.espCheckError(sys.nvs_get_i8(handle, key, &v));
+    return v;
+}
+
+pub fn getU8(handle: Handle, key: [*:0]const u8) !u8 {
+    var v: u8 = 0;
+    try errors.espCheckError(sys.nvs_get_u8(handle, key, &v));
+    return v;
+}
+
+pub fn getI16(handle: Handle, key: [*:0]const u8) !i16 {
+    var v: i16 = 0;
+    try errors.espCheckError(sys.nvs_get_i16(handle, key, &v));
+    return v;
+}
+
+pub fn getU16(handle: Handle, key: [*:0]const u8) !u16 {
+    var v: u16 = 0;
+    try errors.espCheckError(sys.nvs_get_u16(handle, key, &v));
+    return v;
+}
+
+pub fn getI32(handle: Handle, key: [*:0]const u8) !i32 {
+    var v: i32 = 0;
+    try errors.espCheckError(sys.nvs_get_i32(handle, key, &v));
+    return v;
+}
+
+pub fn getU32(handle: Handle, key: [*:0]const u8) !u32 {
+    var v: u32 = 0;
+    try errors.espCheckError(sys.nvs_get_u32(handle, key, &v));
+    return v;
+}
+
+pub fn getI64(handle: Handle, key: [*:0]const u8) !i64 {
+    var v: i64 = 0;
+    try errors.espCheckError(sys.nvs_get_i64(handle, key, &v));
+    return v;
+}
+
+pub fn getU64(handle: Handle, key: [*:0]const u8) !u64 {
+    var v: u64 = 0;
+    try errors.espCheckError(sys.nvs_get_u64(handle, key, &v));
+    return v;
+}
+
+/// Read a string value.
+/// Pass `buf = null` with `buf_len` pointing to 0 first to query the required size.
+/// Then allocate `buf_len` bytes and call again.
+pub fn getStr(handle: Handle, key: [*:0]const u8, buf: ?[*]u8, buf_len: *usize) !void {
+    try errors.espCheckError(sys.nvs_get_str(handle, key, buf, buf_len));
+}
+
+/// Read a blob value.
+/// Pass `buf = null` with `buf_len` pointing to 0 first to query the required size.
+pub fn getBlob(handle: Handle, key: [*:0]const u8, buf: ?*anyopaque, buf_len: *usize) !void {
+    try errors.espCheckError(sys.nvs_get_blob(handle, key, buf, buf_len));
+}
+
+// ---------------------------------------------------------------------------
+// Key management
+// ---------------------------------------------------------------------------
+
+/// Returns the type stored for `key`, or an error if the key does not exist.
+pub fn findKey(handle: Handle, key: [*:0]const u8) !Type {
+    var t: sys.nvs_type_t = 0;
+    try errors.espCheckError(sys.nvs_find_key(handle, key, &t));
+    return @enumFromInt(t);
+}
+
+/// Erase a single key from the namespace.
+pub fn eraseKey(handle: Handle, key: [*:0]const u8) !void {
+    try errors.espCheckError(sys.nvs_erase_key(handle, key));
+}
+
+/// Erase all keys in the namespace.
+pub fn eraseAll(handle: Handle) !void {
+    try errors.espCheckError(sys.nvs_erase_all(handle));
+}
+
+// ---------------------------------------------------------------------------
+// Statistics
+// ---------------------------------------------------------------------------
+
+/// Get storage statistics for a partition (pass `null` for the default "nvs" partition).
+pub fn getStats(part_name: ?[*:0]const u8, stats: *Stats) !void {
+    try errors.espCheckError(sys.nvs_get_stats(part_name, stats));
+}
+
+/// Get the number of used entries for an open handle's namespace.
+pub fn getUsedEntryCount(handle: Handle) !usize {
+    var count: usize = 0;
+    try errors.espCheckError(sys.nvs_get_used_entry_count(handle, &count));
+    return count;
+}
+
+// ---------------------------------------------------------------------------
+// Iteration
+// ---------------------------------------------------------------------------
+
+/// Find an iterator over entries matching the given partition, namespace, and type.
+/// Release with `releaseIterator` when done.
+pub fn entryFind(
+    part_name: ?[*:0]const u8,
+    namespace: ?[*:0]const u8,
+    nvs_type: Type,
+) !Iterator {
+    var it: Iterator = null;
+    try errors.espCheckError(sys.nvs_entry_find(part_name, namespace, @intFromEnum(nvs_type), &it));
+    return it;
+}
+
+/// Find an iterator over entries in an open handle matching the given type.
+pub fn entryFindInHandle(handle: Handle, nvs_type: Type) !Iterator {
+    var it: Iterator = null;
+    try errors.espCheckError(sys.nvs_entry_find_in_handle(handle, @intFromEnum(nvs_type), &it));
+    return it;
+}
+
+/// Advance the iterator to the next entry. Returns error when no more entries.
+pub fn entryNext(it: *Iterator) !void {
+    try errors.espCheckError(sys.nvs_entry_next(it));
+}
+
+/// Fill `info` with details about the current iterator position.
+pub fn entryInfo(it: Iterator, info: *EntryInfo) !void {
+    try errors.espCheckError(sys.nvs_entry_info(it, info));
+}
+
+/// Release an iterator obtained with `entryFind`.
+pub fn releaseIterator(it: Iterator) void {
+    sys.nvs_release_iterator(it);
+}