zephyrCommon: Make configurable the max number of tones

Allows you to change the maximum number of notes that can be
played with `tone()`.

Signed-off-by: TOKITA Hiroshi <tokita.hiroshi@gmail.com>

Author: soburi

Kconfig

@@ -30,6 +30,14 @@ config ARDUINO_ENTRY
 	bool "Provide arduino setup and loop entry points"
 	default y
 
+config ARDUINO_MAX_TONES
+	int "Maximum number of tones that can be played simultaneously with tone()"
+	default -1
+	help
+	  Specify the maximum number of tones that can be played simultaneously with tone().
+	  If set to a negative value, the maximum number will be determined from the
+	  system's digital pin configuration.
+
 endif
 
 if USB_DEVICE_STACK_NEXT

cores/arduino/zephyrCommon.cpp

@@ -7,6 +7,9 @@
 #include <Arduino.h>
 #include "zephyrInternal.h"
 
+#include <zephyr/kernel.h>
+#include <zephyr/spinlock.h>
+
 static const struct gpio_dt_spec arduino_pins[] = {
 	DT_FOREACH_PROP_ELEM_SEP(
 	DT_PATH(zephyr_user), digital_pin_gpios, GPIO_DT_SPEC_GET_BY_IDX, (, ))};
@@ -230,53 +233,120 @@ PinStatus digitalRead(pin_size_t pinNumber) {
 	return (gpio_pin_get_dt(&arduino_pins[pinNumber]) == 1) ? HIGH : LOW;
 }
 
-#ifndef MAX_TONE_PINS
+#if CONFIG_ARDUINO_MAX_TONES < 0
 #define MAX_TONE_PINS DT_PROP_LEN(DT_PATH(zephyr_user), digital_pin_gpios)
+#else
+#define MAX_TONE_PINS CONFIG_ARDUINO_MAX_TONES
 #endif
 
 #define TOGGLES_PER_CYCLE 2ULL
 
 static struct pin_timer {
 	struct k_timer timer;
-	uint32_t count;
-	pin_size_t pin;
-	bool infinity;
+	uint32_t count{0};
+	pin_size_t pin{pin_size_t(-1)};
+	bool infinity{false};
+	bool timer_initialized{false};
+	struct k_spinlock lock;
 } arduino_pin_timers[MAX_TONE_PINS];
 
+K_MUTEX_DEFINE(timer_cfg_lock);
+
+void tone_expiry_cb(struct k_timer *timer);
+
+static struct pin_timer *find_pin_timer(pin_size_t pinNumber, bool active_only) {
+	for (size_t i = 0; i < ARRAY_SIZE(arduino_pin_timers); i++) {
+		k_spinlock_key_t key = k_spin_lock(&arduino_pin_timers[i].lock);
+
+		if (arduino_pin_timers[i].pin == pinNumber) {
+			k_spin_unlock(&arduino_pin_timers[i].lock, key);
+			return &arduino_pin_timers[i];
+		}
+
+		k_spin_unlock(&arduino_pin_timers[i].lock, key);
+	}
+
+	if (active_only) {
+		return nullptr;
+	}
+
+	for (size_t i = 0; i < ARRAY_SIZE(arduino_pin_timers); i++) {
+		k_spinlock_key_t key = k_spin_lock(&arduino_pin_timers[i].lock);
+
+		if (arduino_pin_timers[i].pin == pin_size_t(-1)) {
+			arduino_pin_timers[i].pin = pinNumber;
+
+			if (!arduino_pin_timers[i].timer_initialized) {
+				k_timer_init(&arduino_pin_timers[i].timer, tone_expiry_cb, NULL);
+				arduino_pin_timers[i].timer_initialized = true;
+			}
+
+			k_spin_unlock(&arduino_pin_timers[i].lock, key);
+			return &arduino_pin_timers[i];
+		}
+
+		k_spin_unlock(&arduino_pin_timers[i].lock, key);
+	}
+
+	return nullptr;
+}
+
 void tone_expiry_cb(struct k_timer *timer) {
 	struct pin_timer *pt = CONTAINER_OF(timer, struct pin_timer, timer);
-	const struct gpio_dt_spec *spec = &arduino_pins[pt->pin];
+	k_spinlock_key_t key = k_spin_lock(&pt->lock);
+	pin_size_t pin = pt->pin;
 
 	if (pt->count == 0 && !pt->infinity) {
+		if (pin != pin_size_t(-1)) {
+			gpio_pin_set_dt(&arduino_pins[pin], 0);
+		}
+
 		k_timer_stop(timer);
-		gpio_pin_set_dt(spec, 0);
+		pt->count = 0;
+		pt->infinity = false;
+		pt->pin = pin_size_t(-1);
 	} else {
-		gpio_pin_toggle_dt(spec);
+		if (pin != pin_size_t(-1)) {
+			gpio_pin_toggle_dt(&arduino_pins[pin]);
+		}
+
 		pt->count--;
 	}
-}
 
-void tone_timeout_cb(struct k_timer *timer) {
-	pin_size_t pinNumber = (pin_size_t)(uintptr_t)k_timer_user_data_get(timer);
-	noTone(pinNumber);
+	k_spin_unlock(&pt->lock, key);
 }
 
 void tone(pin_size_t pinNumber, unsigned int frequency, unsigned long duration) {
-	const struct gpio_dt_spec *spec = &arduino_pins[pinNumber];
-	struct k_timer *timer;
+	k_spinlock_key_t key;
+	struct pin_timer *pt;
 	k_timeout_t timeout;
 
-	if (pinNumber >= MAX_TONE_PINS) {
+	if (k_is_in_isr()) {
 		return;
 	}
 
-	timer = &arduino_pin_timers[pinNumber].timer;
+	k_mutex_lock(&timer_cfg_lock, K_FOREVER);
+
+	pt = find_pin_timer(pinNumber, false);
+
+	if (pt == nullptr) {
+		k_mutex_unlock(&timer_cfg_lock);
+		return;
+	}
 
 	pinMode(pinNumber, OUTPUT);
-	k_timer_stop(&arduino_pin_timers[pinNumber].timer);
+	k_timer_stop(&pt->timer);
 
 	if (frequency == 0) {
-		gpio_pin_set_dt(spec, 0);
+		key = k_spin_lock(&pt->lock);
+		pt->count = 0;
+		pt->infinity = false;
+		pt->pin = pin_size_t(-1);
+		k_spin_unlock(&pt->lock, key);
+
+		gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
+
+		k_mutex_unlock(&timer_cfg_lock);
 		return;
 	}
 
@@ -285,21 +355,45 @@ void tone(pin_size_t pinNumber, unsigned int frequency, unsigned long duration)
 		timeout.ticks = 1;
 	}
 
-	arduino_pin_timers[pinNumber].infinity = (duration == 0);
-	arduino_pin_timers[pinNumber].count = (uint64_t)duration * frequency *
-					(MSEC_PER_SEC / TOGGLES_PER_CYCLE);
-	arduino_pin_timers[pinNumber].pin = pinNumber;
-	k_timer_init(timer, tone_expiry_cb, NULL);
+	key = k_spin_lock(&pt->lock);
+	pt->infinity = (duration == 0);
+	pt->count = min((uint64_t)duration * frequency * TOGGLES_PER_CYCLE / MSEC_PER_SEC, UINT32_MAX);
+	pt->pin = pinNumber;
+	k_spin_unlock(&pt->lock, key);
+
+	gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
+	k_timer_start(&pt->timer, timeout, timeout);
 
-	gpio_pin_set_dt(spec, 0);
-	k_timer_start(timer, timeout, timeout);
+	k_mutex_unlock(&timer_cfg_lock);
 }
 
 void noTone(pin_size_t pinNumber) {
-	const struct gpio_dt_spec *spec = &arduino_pins[pinNumber];
+	struct pin_timer *pt;
+	k_spinlock_key_t key;
+
+	if (k_is_in_isr()) {
+		return;
+	}
+
+	k_mutex_lock(&timer_cfg_lock, K_FOREVER);
+
+	pt = find_pin_timer(pinNumber, true);
+
+	if (pt == nullptr) {
+		k_mutex_unlock(&timer_cfg_lock);
+		return;
+	}
+
+	key = k_spin_lock(&pt->lock);
+	k_timer_stop(&pt->timer);
+	pt->count = 0;
+	pt->infinity = false;
+	pt->pin = pin_size_t(-1);
+	k_spin_unlock(&pt->lock, key);
+
+	gpio_pin_set_dt(&arduino_pins[pinNumber], 0);
 
-	k_timer_stop(&arduino_pin_timers[pinNumber].timer);
-	gpio_pin_set_dt(spec, 0);
+	k_mutex_unlock(&timer_cfg_lock);
 }
 
 __attribute__((always_inline)) void delay(unsigned long ms) {