zephyr: pwm led functionality

Author: mkellner

build/devices/zephyr/targets/nrf52840dk/manifest.json

@@ -9,10 +9,11 @@
 	},
 	"preload": "setup/target",
 	"zephyrConfig": {
-		"CONFIG_USERSPACE": "n"
+		"CONFIG_PWM": "y"
 	},
 	"zephyrOverlay": [
-		"./analog.overlay"
+		"./analog.overlay",
+		"./pwm.overlay"
 	],
 	"config": {
 	},

build/devices/zephyr/targets/nrf52840dk/pwm.overlay

@@ -0,0 +1,29 @@
+
+&pinctrl {
+	pwm0_custom: pwm0_custom {
+		group1 {
+			psels = <NRF_PSEL(PWM_OUT0, 0, 13)>,
+					<NRF_PSEL(PWM_OUT1, 0, 14)>,
+					<NRF_PSEL(PWM_OUT2, 0, 15)>,
+					<NRF_PSEL(PWM_OUT3, 0, 16)>;
+			nordic,invert;
+		};
+	};
+	pwm0_csleep: pwm0_csleep {
+		group1 {
+			psels = <NRF_PSEL(PWM_OUT0, 0, 13)>,
+					<NRF_PSEL(PWM_OUT1, 0, 14)>,
+					<NRF_PSEL(PWM_OUT2, 0, 15)>,
+					<NRF_PSEL(PWM_OUT3, 0, 16)>;
+			low-power-enable;
+		};
+	};
+};
+
+&pwm0 {
+	status = "okay";
+	pinctrl-0 = <&pwm0_custom>;
+	pinctrl-1 = <&pwm0_csleep>;
+	pinctrl-names = "default", "sleep";
+};
+

modules/io/manifests/zephyr/manifest.json

@@ -41,6 +41,7 @@
 		}
 	},
 	"zephyrConfig": {
-		"CONFIG_ADC": "y"
+		"CONFIG_ADC": "y",
+		"CONFIG_PWM": "y"
 	}
 }

modules/io/pwm/zephyr/_pwm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2022  Moddable Tech, Inc.
+ * Copyright (c) 2019-2025  Moddable Tech, Inc.
  *
  *   This file is part of the Moddable SDK Runtime.
  *
@@ -28,65 +28,42 @@
 
 #include "builtinCommon.h"
 
-#if 0	// kModZephyrPWMBusCount
+#if kModZephyrPWMBusCount
 
-#include "hardware/pwm.h"
-#include "hardware/clocks.h"
-
-#define RES_BITS_MAX	16
+#include <zephyr/device.h>
+#include <zephyr/drivers/pwm.h>
 
 struct PWMRecord {
-	uint8_t		pin;
 	int			hz;
 	int			resolution;
-	int			duty;
-	uint8_t		slice;
-	uint8_t		channel;			
+	uint8_t		channel;
+	const struct device *port;
 	xsSlot		obj;
 };
 typedef struct PWMRecord PWMRecord;
 typedef struct PWMRecord *PWM;
 
-uint32_t pwm_set_freq_duty(PWM pwm, uint32_t f, int d)
-{
-	uint32_t clock = clock_get_hz(clk_sys);
-	uint32_t clock_div = clock / f / 4096 + (clock % (f * 4096) != 0);
-	if (0 == clock_div / 16)
-		clock_div = 16;
-	uint32_t wrap = clock * 16 / clock_div / f - 1;
-	pwm_set_clkdiv_int_frac(pwm->slice, clock_div/16, clock_div & 0xF);
-	pwm_set_wrap(pwm->slice, wrap);
-	pwm_set_chan_level(pwm->slice, pwm->channel, (wrap * d) / (1 << pwm->resolution));
-	return wrap;
-}
+#define RES_BITS_MAX	16
 
 void xs_pwm_constructor_(xsMachine *the)
 {
+	xsSlot tmp;
 	PWM pwm = NULL;
-	int pin;
-	int hz = 1024 * 10;
+	int hz = 1024 * 3;
 	int resolution = 10;
-	int duty = 0;
+	int channel = 0;
 
 	xsmcVars(2);
 
-    if (xsmcHas(xsArg(0), xsID_from)) {
-		xsmcGet(xsVar(1), xsArg(0), xsID_from);
-		pwm = xsmcGetHostDataValidate(xsVar(1), xs_pwm_destructor_);
-		pin = pwm->pin;
-		duty = pwm->duty;
-		hz = pwm->hz;
-		resolution = pwm->resolution;
-    }
-    else {
-		int i = 0;
-
-		xsmcGet(xsVar(0), xsArg(0), xsID_pin);
-		pin = builtinGetPin(the, &xsVar(0));
+	if (!xsmcHas(xsArg(0), xsID_port))
+		xsRangeError("port required");
+	xsmcGet(tmp, xsArg(0), xsID_port);
+	const struct modZephyrPWM *port = modZephyrGetPWM(xsmcToString(tmp));
+	if (NULL == port)
+		xsRangeError("bad pwm port");
 
-		if (!builtinIsPinFree(pin))
-			xsUnknownError("in use");
-	}
+	if (!device_is_ready(port->device))
+		xsRangeError("pwm port not ready");
 
     if (xsmcHas(xsArg(0), xsID_hz)) {
         xsmcGet(xsVar(0), xsArg(0), xsID_hz);
@@ -95,6 +72,13 @@ void xs_pwm_constructor_(xsMachine *the)
 			xsRangeError("invalid hz");
     }
 
+    if (xsmcHas(xsArg(0), xsID_channel)) {
+        xsmcGet(xsVar(0), xsArg(0), xsID_channel);
+        channel = xsmcToInteger(xsVar(0));
+        if (channel < 0)
+			xsRangeError("invalid channel");
+    }
+
     if (xsmcHas(xsArg(0), xsID_resolution)) {
         xsmcGet(xsVar(0), xsArg(0), xsID_resolution);
         resolution = xsmcToInteger(xsVar(0));
@@ -106,7 +90,7 @@ void xs_pwm_constructor_(xsMachine *the)
 		xsRangeError("invalid format");
 
 	if (NULL == pwm) {
-		pwm = c_malloc(sizeof(PWMRecord));
+		pwm = c_calloc(1, sizeof(PWMRecord));
 		if (!pwm)
 			xsRangeError("no memory");
 	}
@@ -118,34 +102,21 @@ void xs_pwm_constructor_(xsMachine *the)
 
 	builtinInitializeTarget(the);
 
-	pwm->pin = pin;
-	pwm->duty = duty;
 	pwm->hz = hz;
 	pwm->resolution = resolution;
+	pwm->channel = channel;
+	pwm->port = port->device;
 	pwm->obj = xsThis;
 
-	pwm->slice = pwm_gpio_to_slice_num(pin);
-	pwm->channel = pwm_gpio_to_channel(pin);
-
 	xsRemember(pwm->obj);
     xsmcSetHostData(xsThis, pwm);
-
-	builtinUsePin(pin);
-
-	gpio_set_function(pin, GPIO_FUNC_PWM);
-	pwm_set_freq_duty(pwm, hz, duty);
-	pwm_set_enabled(pwm->slice, true);
 }
 
 void xs_pwm_destructor_(void *data)
 {
 	PWM pwm = data;
 	if (!pwm) return;
 
-	pwm_set_enabled(pwm->slice, false);
-	gpio_deinit(pwm->pin);
-    builtinFreePin(pwm->pin);
-
     c_free(pwm);
 }
 
@@ -163,23 +134,27 @@ void xs_pwm_close_(xsMachine *the)
 void xs_pwm_write_(xsMachine *the)
 {
 	PWM pwm = xsmcGetHostDataValidate(xsThis, xs_pwm_destructor_);
-	int max = (1 << pwm->resolution) - 1;
+	int err;
+
+	int period = PWM_SEC(1) / pwm->hz;
 	int value = xsmcToInteger(xsArg(0));
 
-	if ((value < 0) || (value > max))
+	if ((value < 0) || (value > period))
 		xsRangeError("invalid value");
-	if (value == max)
-		value += 1;
-	pwm->duty = value;
 
-	pwm_set_freq_duty(pwm, pwm->hz, pwm->duty);
+	double cycle = period / (1 << pwm->resolution);
+	int pulse = (double)value * cycle;
+
+	err = pwm_set(pwm->port, pwm->channel, period, pulse, 0);
 }
 
 void xs_pwm_get_hz_(xsMachine *the)
 {
 	PWM pwm = xsmcGetHostDataValidate(xsThis, xs_pwm_destructor_);
+	uint64_t cycles;
 
-	xsmcSetInteger(xsResult, pwm->hz);
+	pwm_get_cycles_per_sec(pwm->port, pwm->channel, &cycles);
+	xsmcSetInteger(xsResult, cycles);
 }
 
 void xs_pwm_get_resolution_(xsMachine *the)