@mikrojs/firmware 0.0.7

package/components/mikrojs/mik_sleep.cpp

@@ -0,0 +1,226 @@
+#include "driver/gpio.h"
+#include "esp_sleep.h"
+#include "soc/soc_caps.h"
+
+#include "mikrojs/private.h"
+#include "mikrojs/utils.h"
+
+static const char* mik__wakeup_cause_str(uint32_t causes) {
+    if (causes & BIT(ESP_SLEEP_WAKEUP_TIMER)) return "timer";
+    if (causes & BIT(ESP_SLEEP_WAKEUP_EXT0)) return "ext0";
+    if (causes & BIT(ESP_SLEEP_WAKEUP_EXT1)) return "ext1";
+    if (causes & BIT(ESP_SLEEP_WAKEUP_GPIO)) return "gpio";
+    if (causes & BIT(ESP_SLEEP_WAKEUP_TOUCHPAD)) return "touchpad";
+    if (causes & BIT(ESP_SLEEP_WAKEUP_ULP)) return "ulp";
+    return "undefined";
+}
+
+/* ── native:sleep JS module ─────────────────────────────────────────── */
+
+static JSValue mik__sleep_deep(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    int64_t ms;
+    if (JS_ToInt64(ctx, &ms, argv[0])) return JS_EXCEPTION;
+
+    if (ms > 0) {
+        esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(ms) * 1000);
+        if (err != ESP_OK)
+            return JS_ThrowInternalError(ctx, "timer wakeup failed: %s", esp_err_to_name(err));
+    }
+
+    /* Note: we intentionally do NOT call MIK_FreeRuntime() here.  We are inside
+     * a JS function call, so the runtime still has live GC objects on the call
+     * stack — freeing it would trigger a QuickJS assert.  Since deep sleep
+     * reboots the chip, all memory is reclaimed anyway. */
+    esp_deep_sleep_start();
+    /* Never reached */
+    __builtin_unreachable();
+}
+
+static JSValue mik__sleep_light(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    int64_t ms;
+    if (JS_ToInt64(ctx, &ms, argv[0])) return JS_EXCEPTION;
+
+    if (ms > 0) {
+        esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(ms) * 1000);
+        if (err != ESP_OK)
+            return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                         "failed to enable timer wakeup: %s",
+                                         esp_err_to_name(err));
+    }
+
+    esp_err_t err = esp_light_sleep_start();
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "LightSleepFailed",
+                                     "light sleep failed: %s", esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+}
+
+static JSValue mik__sleep_get_wakeup_cause(JSContext* ctx, JSValue this_val, int argc,
+                                            JSValue* argv) {
+    uint32_t causes = esp_sleep_get_wakeup_causes();
+    return JS_NewString(ctx, mik__wakeup_cause_str(causes));
+}
+
+static JSValue mik__sleep_enable_timer_wakeup(JSContext* ctx, JSValue this_val, int argc,
+                                               JSValue* argv) {
+    int64_t us;
+    if (JS_ToInt64(ctx, &us, argv[0])) return JS_EXCEPTION;
+
+    esp_err_t err = esp_sleep_enable_timer_wakeup(static_cast<uint64_t>(us));
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                     "failed to enable timer wakeup: %s", esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+}
+
+static JSValue mik__sleep_enable_gpio_wakeup(JSContext* ctx, JSValue this_val, int argc,
+                                              JSValue* argv) {
+    int32_t pin, level;
+    if (JS_ToInt32(ctx, &pin, argv[0])) return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &level, argv[1])) return JS_EXCEPTION;
+
+    esp_err_t err =
+        gpio_wakeup_enable(static_cast<gpio_num_t>(pin), static_cast<gpio_int_type_t>(level));
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                     "failed to enable GPIO wakeup on pin %d: %s", pin,
+                                     esp_err_to_name(err));
+
+    err = esp_sleep_enable_gpio_wakeup();
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                     "failed to enable GPIO wakeup source: %s",
+                                     esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+}
+
+/* EXT0 / EXT1 wakeup is chip-specific (not on ESP32-C3, C6, H2). We still
+ * register the JS exports unconditionally so `mikrojs/sleep`'s static
+ * re-exports resolve on every target; the function bodies return a
+ * `WakeupConfigFailed` error on chips where the capability is missing. */
+static JSValue mik__sleep_enable_ext0_wakeup(JSContext* ctx, JSValue this_val, int argc,
+                                             JSValue* argv) {
+#if SOC_PM_SUPPORT_EXT0_WAKEUP
+    int32_t pin, level;
+    if (JS_ToInt32(ctx, &pin, argv[0])) return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &level, argv[1])) return JS_EXCEPTION;
+
+    esp_err_t err = esp_sleep_enable_ext0_wakeup(static_cast<gpio_num_t>(pin), level);
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                     "failed to enable EXT0 wakeup on pin %d: %s", pin,
+                                     esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+#else
+    return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                 "EXT0 wakeup is not supported on this chip");
+#endif
+}
+
+static JSValue mik__sleep_enable_ext1_wakeup(JSContext* ctx, JSValue this_val, int argc,
+                                             JSValue* argv) {
+#if SOC_PM_SUPPORT_EXT1_WAKEUP
+    int64_t pin_mask;
+    int32_t mode;
+    if (JS_ToInt64(ctx, &pin_mask, argv[0])) return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &mode, argv[1])) return JS_EXCEPTION;
+
+    esp_err_t err = esp_sleep_enable_ext1_wakeup(static_cast<uint64_t>(pin_mask),
+                                                  static_cast<esp_sleep_ext1_wakeup_mode_t>(mode));
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                     "failed to enable EXT1 wakeup: %s", esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+#else
+    return mik__result_err_named(ctx, "WakeupConfigFailed",
+                                 "EXT1 wakeup is not supported on this chip");
+#endif
+}
+
+static JSValue mik__sleep_disable_wakeup_source(JSContext* ctx, JSValue this_val, int argc,
+                                                 JSValue* argv) {
+    esp_sleep_source_t source = ESP_SLEEP_WAKEUP_ALL;
+
+    if (argc > 0 && !JS_IsUndefined(argv[0])) {
+        const char* str = JS_ToCString(ctx, argv[0]);
+        if (!str) return JS_EXCEPTION;
+
+        bool valid = true;
+        if (strcmp(str, "timer") == 0)
+            source = ESP_SLEEP_WAKEUP_TIMER;
+        else if (strcmp(str, "ext0") == 0)
+            source = ESP_SLEEP_WAKEUP_EXT0;
+        else if (strcmp(str, "ext1") == 0)
+            source = ESP_SLEEP_WAKEUP_EXT1;
+        else if (strcmp(str, "gpio") == 0)
+            source = ESP_SLEEP_WAKEUP_GPIO;
+        else if (strcmp(str, "touchpad") == 0)
+            source = ESP_SLEEP_WAKEUP_TOUCHPAD;
+        else if (strcmp(str, "ulp") == 0)
+            source = ESP_SLEEP_WAKEUP_ULP;
+        else
+            valid = false;
+
+        if (!valid) {
+            JSValue err = JS_ThrowRangeError(ctx, "unknown wakeup source: %s", str);
+            JS_FreeCString(ctx, str);
+            return err;
+        }
+        JS_FreeCString(ctx, str);
+    }
+
+    esp_err_t err = esp_sleep_disable_wakeup_source(source);
+    if (err != ESP_OK)
+        return mik__result_err_named(ctx, "DisableWakeupFailed",
+                                     "failed to disable wakeup source: %s", esp_err_to_name(err));
+
+    return mik__result_ok_void(ctx);
+}
+
+/* ── Module init ─────────────────────────────────────────────────── */
+
+static int mik__sleep_module_init(JSContext* ctx, JSModuleDef* m) {
+    JS_SetModuleExport(ctx, m, "deepSleep",
+                       JS_NewCFunction(ctx, mik__sleep_deep, "deepSleep", 1));
+    JS_SetModuleExport(ctx, m, "lightSleep",
+                       JS_NewCFunction(ctx, mik__sleep_light, "lightSleep", 1));
+    JS_SetModuleExport(ctx, m, "getWakeupCause",
+                       JS_NewCFunction(ctx, mik__sleep_get_wakeup_cause, "getWakeupCause", 0));
+    JS_SetModuleExport(
+        ctx, m, "enableTimerWakeup",
+        JS_NewCFunction(ctx, mik__sleep_enable_timer_wakeup, "enableTimerWakeup", 1));
+    JS_SetModuleExport(
+        ctx, m, "enableGpioWakeup",
+        JS_NewCFunction(ctx, mik__sleep_enable_gpio_wakeup, "enableGpioWakeup", 2));
+    JS_SetModuleExport(
+        ctx, m, "enableExt0Wakeup",
+        JS_NewCFunction(ctx, mik__sleep_enable_ext0_wakeup, "enableExt0Wakeup", 2));
+    JS_SetModuleExport(
+        ctx, m, "enableExt1Wakeup",
+        JS_NewCFunction(ctx, mik__sleep_enable_ext1_wakeup, "enableExt1Wakeup", 2));
+    JS_SetModuleExport(
+        ctx, m, "disableWakeupSource",
+        JS_NewCFunction(ctx, mik__sleep_disable_wakeup_source, "disableWakeupSource", 1));
+    return 0;
+}
+
+static JSModuleDef* mik__sleep_init(JSContext* ctx) {
+    JSModuleDef* m = JS_NewCModule(ctx, "native:sleep", mik__sleep_module_init);
+    if (!m) return nullptr;
+    JS_AddModuleExport(ctx, m, "deepSleep");
+    JS_AddModuleExport(ctx, m, "lightSleep");
+    JS_AddModuleExport(ctx, m, "getWakeupCause");
+    JS_AddModuleExport(ctx, m, "enableTimerWakeup");
+    JS_AddModuleExport(ctx, m, "enableGpioWakeup");
+    JS_AddModuleExport(ctx, m, "enableExt0Wakeup");
+    JS_AddModuleExport(ctx, m, "enableExt1Wakeup");
+    JS_AddModuleExport(ctx, m, "disableWakeupSource");
+    return m;
+}
+
+MIK_REGISTER_MODULE(sleep, "native:sleep", mik__sleep_init, nullptr, nullptr)

package/components/mikrojs/mik_sntp.cpp

@@ -0,0 +1,275 @@
+#include <cstring>
+#include <ctime>
+#include <sys/time.h>
+
+#include "esp_log.h"
+#include "esp_netif_sntp.h"
+#include "esp_sntp.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "mikrojs/private.h"
+#include "mikrojs/utils.h"
+
+#define MIK_SNTP_TAG "native:sntp"
+#define MIK_SNTP_MAX_SERVERS 3
+
+/* ── SNTP state (attached to MIKRuntime) ───────────────────────────── */
+
+struct MIKSntpState {
+    QueueHandle_t event_queue;
+    MIKPromise sync_promise;
+    bool sync_pending;
+    bool running;
+    bool background;
+};
+
+/* Dynamic module data slot, allocated on first import */
+static int mik__sntp_slot = -1;
+
+static inline MIKSntpState*& mik__sntp_st(MIKRuntime* rt) {
+    return reinterpret_cast<MIKSntpState*&>(rt->module_data[mik__sntp_slot]);
+}
+
+/* Global queue pointer for the sync callback (runs in lwIP timer task) */
+static QueueHandle_t s_event_queue = nullptr;
+
+/* ── SNTP sync callback ────────────────────────────────────────────── */
+
+static void mik__sntp_sync_cb(struct timeval* tv) {
+    if (!s_event_queue) return;
+    struct timeval evt = *tv;
+    xQueueSend(s_event_queue, &evt, 0);
+}
+
+/* ── Test helper: inject a fake sync event ─────────────────────────── */
+
+void mik__sntp_inject_sync(int64_t epoch_sec) {
+    if (!s_event_queue) return;
+    struct timeval tv = {.tv_sec = static_cast<time_t>(epoch_sec), .tv_usec = 0};
+    xQueueSend(s_event_queue, &tv, 0);
+}
+
+/* ── JS functions ──────────────────────────────────────────────────── */
+
+static JSValue mik__sntp_sync(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(mik_rt);
+    MIKSntpState* state = mik__sntp_st(mik_rt);
+    CHECK_NOT_NULL(state);
+
+    /* arg 0: servers (array of strings) */
+    /* arg 1: timezone (string) */
+    /* arg 2: background (bool) */
+
+    if (!JS_IsArray(argv[0])) {
+        return JS_ThrowTypeError(ctx, "expected servers to be an array");
+    }
+
+    /* Extract server strings */
+    JSValue len_val = JS_GetPropertyStr(ctx, argv[0], "length");
+    int32_t server_count = 0;
+    JS_ToInt32(ctx, &server_count, len_val);
+    JS_FreeValue(ctx, len_val);
+
+    if (server_count <= 0 || server_count > MIK_SNTP_MAX_SERVERS) {
+        return JS_ThrowRangeError(ctx, "expected 1-%d servers, got %d", MIK_SNTP_MAX_SERVERS,
+                                  server_count);
+    }
+
+    const char* servers[MIK_SNTP_MAX_SERVERS] = {};
+    for (int32_t i = 0; i < server_count; i++) {
+        JSValue elem = JS_GetPropertyUint32(ctx, argv[0], i);
+        servers[i] = JS_ToCString(ctx, elem);
+        JS_FreeValue(ctx, elem);
+        if (!servers[i]) {
+            for (int32_t j = 0; j < i; j++) JS_FreeCString(ctx, servers[j]);
+            return JS_EXCEPTION;
+        }
+    }
+
+    /* Set timezone */
+    const char* tz = JS_ToCString(ctx, argv[1]);
+    if (!tz) {
+        for (int32_t i = 0; i < server_count; i++) JS_FreeCString(ctx, servers[i]);
+        return JS_EXCEPTION;
+    }
+    setenv("TZ", tz, 1);
+    tzset();
+    JS_FreeCString(ctx, tz);
+
+    bool background = JS_ToBool(ctx, argv[2]);
+
+    /* If already running, tear down first */
+    if (state->running) {
+        if (state->sync_pending) {
+            JSValue cancel_err = mik__result_err_tag(ctx, "Cancelled");
+            MIK_ResolvePromise(ctx, &state->sync_promise, 1, &cancel_err);
+            state->sync_pending = false;
+        }
+        esp_netif_sntp_deinit();
+        state->running = false;
+
+        /* Drain queue */
+        struct timeval discard;
+        while (xQueueReceive(state->event_queue, &discard, 0) == pdTRUE) {
+        }
+    }
+
+    /* Configure SNTP */
+    esp_sntp_config_t config = ESP_NETIF_SNTP_DEFAULT_CONFIG(servers[0]);
+    config.sync_cb = mik__sntp_sync_cb;
+
+    /* Add additional servers if provided */
+    if (server_count > 1) {
+        config.num_of_servers = server_count;
+        /* The first server is already set by the macro. Set additional ones after init. */
+    }
+
+    esp_err_t err = esp_netif_sntp_init(&config);
+    if (err != ESP_OK) {
+        for (int32_t i = 0; i < server_count; i++) JS_FreeCString(ctx, servers[i]);
+        return mik__result_err_named(ctx, "InitFailed",
+                                     "SNTP init failed: %s", esp_err_to_name(err));
+    }
+
+    /* Set additional servers (index 1+) */
+    for (int32_t i = 1; i < server_count; i++) {
+        esp_sntp_setservername(i, servers[i]);
+    }
+
+    for (int32_t i = 0; i < server_count; i++) JS_FreeCString(ctx, servers[i]);
+
+    state->running = true;
+    state->background = background;
+
+    /* Create and return promise wrapped in result */
+    JSValue promise = MIK_InitPromise(ctx, &state->sync_promise);
+    state->sync_pending = true;
+
+    return mik__result_ok(ctx, promise);
+}
+
+static JSValue mik__sntp_stop(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(mik_rt);
+    MIKSntpState* state = mik__sntp_st(mik_rt);
+    CHECK_NOT_NULL(state);
+
+    if (state->running) {
+        esp_netif_sntp_deinit();
+        state->running = false;
+    }
+
+    return JS_UNDEFINED;
+}
+
+static JSValue mik__sntp_set_timezone(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    const char* tz = JS_ToCString(ctx, argv[0]);
+    if (!tz) return JS_EXCEPTION;
+    setenv("TZ", tz, 1);
+    tzset();
+    JS_FreeCString(ctx, tz);
+    return JS_UNDEFINED;
+}
+
+/* ── Module init ───────────────────────────────────────────────────── */
+
+static int mik__sntp_module_init(JSContext* ctx, JSModuleDef* m) {
+    JS_SetModuleExport(ctx, m, "sync", JS_NewCFunction(ctx, mik__sntp_sync, "sync", 3));
+    JS_SetModuleExport(ctx, m, "stop", JS_NewCFunction(ctx, mik__sntp_stop, "stop", 0));
+    JS_SetModuleExport(ctx, m, "setTimezone",
+                       JS_NewCFunction(ctx, mik__sntp_set_timezone, "setTimezone", 1));
+    return 0;
+}
+
+/* ── Public API ────────────────────────────────────────────────────── */
+
+static JSModuleDef* mik__sntp_init(JSContext* ctx) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(mik_rt);
+    mik__sntp_slot = MIK_AllocModuleSlot(mik_rt);
+
+    auto* state = new MIKSntpState();
+    state->event_queue = xQueueCreate(4, sizeof(struct timeval));
+    CHECK_NOT_NULL(state->event_queue);
+    state->sync_pending = false;
+    state->running = false;
+    state->background = false;
+
+    s_event_queue = state->event_queue;
+    mik__sntp_st(mik_rt) = state;
+
+    JSModuleDef* m = JS_NewCModule(ctx, "native:sntp", mik__sntp_module_init);
+    if (!m) {
+        /* The loop consumer (mik__sntp_destroy) is only registered when init
+         * returns a non-null module (see modules.cpp). Clean up manually. */
+        s_event_queue = nullptr;
+        vQueueDelete(state->event_queue);
+        delete state;
+        mik__sntp_st(mik_rt) = nullptr;
+        return nullptr;
+    }
+    JS_AddModuleExport(ctx, m, "sync");
+    JS_AddModuleExport(ctx, m, "stop");
+    JS_AddModuleExport(ctx, m, "setTimezone");
+    return m;
+}
+
+void mik__sntp_consume(JSContext* ctx) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(mik_rt);
+    if (!mik__sntp_st(mik_rt)) return;
+
+    MIKSntpState* state = mik__sntp_st(mik_rt);
+    struct timeval tv;
+
+    while (xQueueReceive(state->event_queue, &tv, 0) == pdTRUE) {
+        if (state->sync_pending) {
+            /* Build result object: { time: <milliseconds since epoch> } */
+            double time_ms =
+                static_cast<double>(tv.tv_sec) * 1000.0 + static_cast<double>(tv.tv_usec) / 1000.0;
+            JSValue time_obj = JS_NewObject(ctx);
+            JS_SetPropertyStr(ctx, time_obj, "time", JS_NewFloat64(ctx, time_ms));
+            JSValue result = mik__result_ok(ctx, time_obj);
+
+            MIK_ResolvePromise(ctx, &state->sync_promise, 1, &result);
+            state->sync_pending = false;
+
+            /* If not background mode, stop SNTP after first sync */
+            if (!state->background) {
+                esp_netif_sntp_deinit();
+                state->running = false;
+            }
+        }
+    }
+}
+
+void mik__sntp_destroy(JSContext* ctx) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(mik_rt);
+    if (!mik__sntp_st(mik_rt)) return;
+
+    MIKSntpState* state = mik__sntp_st(mik_rt);
+
+    if (state->running) {
+        esp_netif_sntp_deinit();
+        state->running = false;
+    }
+
+    if (state->sync_pending) {
+        MIK_FreePromise(ctx, &state->sync_promise);
+        state->sync_pending = false;
+    }
+
+    /* Drain queue */
+    struct timeval discard;
+    while (xQueueReceive(state->event_queue, &discard, 0) == pdTRUE) {
+    }
+
+    s_event_queue = nullptr;
+    vQueueDelete(state->event_queue);
+    delete state;
+    mik__sntp_st(mik_rt) = nullptr;
+}
+
+MIK_REGISTER_MODULE(sntp, "native:sntp", mik__sntp_init, mik__sntp_consume, mik__sntp_destroy)