@mikrojs/firmware 0.0.7

package/components/mikrojs/mik_ble_c_shim.c

@@ -0,0 +1,61 @@
+/*
+ * BLE C shim.
+ *
+ * esp_bt.h transitively pulls in hal/assert.h which defines
+ *   #define __noreturn [[noreturn]]
+ * The HAL chain then applies __noreturn to a type, which fails C++
+ * -Wattributes (treated as -Werror in ESP-IDF's default build). Compiling
+ * this in C sidesteps the attribute restriction entirely, so every
+ * esp_bt.h-touching call mik_ble.cpp needs is wrapped here.
+ */
+
+#include "esp_bt.h"
+
+#include "mik_ble_c_shim.h"
+
+/* ── TX power ──────────────────────────────────────────────────────── */
+
+/* Convert dBm <-> esp_power_level_t enum.
+ * The enum spans -24 dBm (0) to +9 dBm (15) in 3 dBm steps on most ESP chips. */
+static esp_power_level_t dbm_to_level(int dbm) {
+    int level = (dbm + 24) / 3;
+    if (level < 0) level = 0;
+    if (level > 15) level = 15;
+    return (esp_power_level_t)level;
+}
+
+static int level_to_dbm(esp_power_level_t level) {
+    return (int)level * 3 - 24;
+}
+
+int mik_ble_get_tx_power_dbm(void) {
+    esp_power_level_t level = esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_ADV);
+    return level_to_dbm(level);
+}
+
+int mik_ble_set_tx_power_dbm(int dbm) {
+    esp_power_level_t level = dbm_to_level(dbm);
+    esp_err_t err = esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_ADV, level);
+    if (err != ESP_OK) return (int)err;
+    /* Also set the default power so any implicit advertising uses the new level. */
+    esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_DEFAULT, level);
+    return 0;
+}
+
+/* ── Controller teardown ───────────────────────────────────────────── */
+
+/* Disable the BT controller. Returns the esp_err_t code (0 on success).
+ * Safe to call even if the controller is already disabled. */
+int mik_ble_controller_disable(void) {
+    esp_bt_controller_status_t status = esp_bt_controller_get_status();
+    if (status != ESP_BT_CONTROLLER_STATUS_ENABLED) return 0;
+    return (int)esp_bt_controller_disable();
+}
+
+/* Deinitialize the BT controller, freeing its RAM. Returns the esp_err_t
+ * code (0 on success). Safe to call even if already deinitialized. */
+int mik_ble_controller_deinit(void) {
+    esp_bt_controller_status_t status = esp_bt_controller_get_status();
+    if (status == ESP_BT_CONTROLLER_STATUS_IDLE) return 0;
+    return (int)esp_bt_controller_deinit();
+}

package/components/mikrojs/mik_ble_c_shim.h

@@ -0,0 +1,37 @@
+#ifndef MIK_BLE_C_SHIM_H
+#define MIK_BLE_C_SHIM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ── TX power ──────────────────────────────────────────────────────── */
+
+/** Returns the current BLE advertising TX power in dBm. */
+int mik_ble_get_tx_power_dbm(void);
+
+/**
+ * Sets the BLE advertising (and default) TX power in dBm.
+ * Returns 0 on success, or a non-zero esp_err_t code on failure.
+ */
+int mik_ble_set_tx_power_dbm(int dbm);
+
+/* ── Controller teardown ───────────────────────────────────────────── */
+
+/**
+ * Disable the BT controller. Returns 0 on success or if already disabled,
+ * or a non-zero esp_err_t code on failure.
+ */
+int mik_ble_controller_disable(void);
+
+/**
+ * Deinitialize the BT controller, freeing its RAM. Returns 0 on success
+ * or if already deinitialized, or a non-zero esp_err_t code on failure.
+ */
+int mik_ble_controller_deinit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // MIK_BLE_C_SHIM_H

package/components/mikrojs/mik_config.cpp

@@ -0,0 +1,167 @@
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+
+#include <nanocbor/nanocbor.h>
+
+#include "nvs.h"
+#include "nvs_flash.h"
+#include "mikrojs/mikrojs.h"
+#include "mikrojs/private.h"
+#include "mikrojs_esp32.h"
+
+/* ── Unified protocol config handler ────────────────────────────── */
+
+/** Collected config entry for CBOR encoding */
+struct config_entry_t {
+    std::string key;
+    std::string value;
+    bool secret;
+};
+
+/** Encode a single config entry into a CBOR encoder */
+static void encode_config_entry(nanocbor_encoder_t* enc, const config_entry_t& entry) {
+    nanocbor_fmt_map(enc, 3);
+    nanocbor_put_tstr(enc, "key");
+    nanocbor_put_tstrn(enc, entry.key.c_str(), entry.key.size());
+    nanocbor_put_tstr(enc, "value");
+    nanocbor_put_tstrn(enc, entry.value.c_str(), entry.value.size());
+    nanocbor_put_tstr(enc, "secret");
+    nanocbor_fmt_bool(enc, entry.secret);
+}
+
+/** Build CBOR array of env entries for MSG_CONFIG_ENTRIES */
+static std::vector<uint8_t> build_config_entries_cbor() {
+    std::vector<config_entry_t> entries;
+
+    nvs_handle_t handle;
+    if (nvs_open(MIK__NVS_NS_ENV, NVS_READONLY, &handle) == ESP_OK) {
+        nvs_iterator_t it = NULL;
+        esp_err_t err = nvs_entry_find_in_handle(handle, NVS_TYPE_STR, &it);
+        while (err == ESP_OK && it != NULL) {
+            nvs_entry_info_t info;
+            nvs_entry_info(it, &info);
+
+            config_entry_t entry;
+            entry.key = info.key;
+            entry.secret = mik__nvs_is_secret(info.key);
+
+            if (!entry.secret) {
+                size_t val_len = 0;
+                nvs_get_str(handle, info.key, NULL, &val_len);
+                char buf[512];
+                if (val_len > 0 && val_len <= sizeof(buf)) {
+                    nvs_get_str(handle, info.key, buf, &val_len);
+                    entry.value.assign(buf, val_len > 0 ? val_len - 1 : 0);
+                }
+            }
+
+            entries.push_back(std::move(entry));
+            err = nvs_entry_next(&it);
+        }
+        nvs_release_iterator(it);
+        nvs_close(handle);
+    }
+
+    /* Two-pass CBOR encode */
+    nanocbor_encoder_t enc;
+    nanocbor_encoder_init(&enc, nullptr, 0);
+    nanocbor_fmt_array(&enc, entries.size());
+    for (const auto& e : entries) {
+        encode_config_entry(&enc, e);
+    }
+    size_t needed = nanocbor_encoded_len(&enc);
+
+    std::vector<uint8_t> buf(needed);
+    nanocbor_encoder_init(&enc, buf.data(), needed);
+    nanocbor_fmt_array(&enc, entries.size());
+    for (const auto& e : entries) {
+        encode_config_entry(&enc, e);
+    }
+    return buf;
+}
+
+bool mik__handle_config_command(MIKReplTransport* transport, uint8_t cmd_type,
+                                uint32_t payload_len) {
+    switch (cmd_type) {
+        case MIK_CMD_CONFIG_LIST: {
+            mik__proto_drain(transport, payload_len);
+            auto cbor = build_config_entries_cbor();
+            mik__proto_send(transport, MIK_MSG_CONFIG_ENTRIES, cbor.data(), cbor.size());
+            return true;
+        }
+
+        case MIK_CMD_CONFIG_SET: {
+            /* Payload: u8 flags | u16le key_len | key | u16le val_len | value */
+            uint8_t flags;
+            if (!mik__proto_read_exact(transport, &flags, 1)) return false;
+
+            uint8_t kl[2];
+            if (!mik__proto_read_exact(transport, kl, 2)) return false;
+            uint16_t key_len = kl[0] | (kl[1] << 8);
+
+            char key[64];
+            if (key_len >= sizeof(key)) {
+                mik__proto_drain(transport, payload_len - 3);
+                mik__proto_send_err(transport, "key too long");
+                return true;
+            }
+            if (!mik__proto_read_exact(transport, key, key_len)) return false;
+            key[key_len] = '\0';
+
+            uint8_t vl[2];
+            if (!mik__proto_read_exact(transport, vl, 2)) return false;
+            uint16_t val_len = vl[0] | (vl[1] << 8);
+
+            char value[512];
+            if (val_len >= sizeof(value)) {
+                mik__proto_drain(transport, val_len);
+                mik__proto_send_err(transport, "value too long");
+                return true;
+            }
+            if (!mik__proto_read_exact(transport, value, val_len)) return false;
+            value[val_len] = '\0';
+
+            if (key_len > 15) {
+                mik__proto_send_err(transport, "key exceeds NVS 15-char limit");
+                return true;
+            }
+
+            bool changed = false;
+            if (mik__nvs_env_set(key, value, flags & MIK_ENV_FLAG_SECRET, &changed)) {
+                uint8_t byte = changed ? 1 : 0;
+                mik__proto_send(transport, MIK_MSG_OK, &byte, 1);
+            } else {
+                mik__proto_send_err(transport, "nvs write failed");
+            }
+            return true;
+        }
+
+        case MIK_CMD_CONFIG_DELETE: {
+            /* Payload: u16le key_len | key */
+            uint8_t kl[2];
+            if (!mik__proto_read_exact(transport, kl, 2)) return false;
+            uint16_t key_len = kl[0] | (kl[1] << 8);
+
+            char key[64];
+            if (key_len >= sizeof(key)) {
+                mik__proto_drain(transport, key_len);
+                mik__proto_send_err(transport, "key too long");
+                return true;
+            }
+            if (!mik__proto_read_exact(transport, key, key_len)) return false;
+            key[key_len] = '\0';
+
+            uint8_t byte = mik__nvs_env_delete(key) ? 1 : 0;
+            mik__proto_send(transport, MIK_MSG_OK, &byte, 1);
+            return true;
+        }
+
+        default:
+            mik__proto_drain(transport, payload_len);
+            return false;
+    }
+}