analogWrite: implement DAC pins

Co-Authored-by: Martino Facchin <m.facchin@arduino.cc>
Co-Authored-by: Luca Burelli <l.burelli@arduino.cc>
Signed-off-by: TOKITA Hiroshi <tokita.hiroshi@gmail.com>

Author: 2 people

cores/arduino/Arduino.h

@@ -12,6 +12,7 @@
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/pwm.h>
 #include <zephyr/drivers/adc.h>
+#include <zephyr/drivers/dac.h>
 #include <zephyr/drivers/i2c.h>
 
 #if DT_PROP_LEN(DT_PATH(zephyr_user), digital_pin_gpios) > 0
@@ -105,11 +106,37 @@ enum analogPins {
 
 #endif
 
+#ifdef CONFIG_DAC
+
+#undef DAC0
+#undef DAC1
+#undef DAC2
+#undef DAC3
+#define DAC_ENUMS(n, p, i) DAC##i = i,
+
+enum dacPins {
+#if DT_PROP_LEN_OR(DT_PATH(zephyr_user), dac_channels, 0) > 0
+	DT_FOREACH_PROP_ELEM(DT_PATH(zephyr_user), dac_channels, DAC_ENUMS)
+#endif
+	NUM_OF_DACS
+};
+
+#endif
+
 void interrupts(void);
 void noInterrupts(void);
 
 int digitalPinToInterrupt(pin_size_t pin);
 
+#define digitalPinToPort(x)    (x)
+#define digitalPinToBitMask(x) (x)
+#define portOutputRegister(x)  (x)
+#define portInputRegister(x)   (x)
+
+#if defined(CONFIG_PWM) || defined(CONFIG_DAC)
+void analogWriteResolution(int bits);
+#endif
+
 #include <variant.h>
 
 #if !defined(LED_BUILTIN) && defined(ZARD_LED_BUILTIN)
@@ -120,4 +147,12 @@ int digitalPinToInterrupt(pin_size_t pin);
 
 #ifdef __cplusplus
 #include <zephyrSerial.h>
+#include <strings.h>
+#include <api/itoa.h>
+#include <time_macros.h>
+#include <overloads.h>
+
+// Allow namespace-less operations if Arduino.h is included
+using namespace arduino;
+
 #endif // __cplusplus

cores/arduino/overloads.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) Arduino s.r.l. and/or its affiliated companies
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef CONFIG_DAC
+
+void analogWrite(enum dacPins pinNumber, int value);
+
+#endif
+
+// In c++ mode, we also provide analogReadResolution and analogWriteResolution getters
+int analogReadResolution();
+int analogWriteResolution();

cores/arduino/zephyrCommon.cpp

@@ -175,6 +175,32 @@ size_t analog_pin_index(pin_size_t pinNumber) {
 
 #endif // CONFIG_ADC
 
+#ifdef CONFIG_DAC
+
+#if (DT_NODE_HAS_PROP(DT_PATH(zephyr_user), dac))
+
+#define DAC_NODE       DT_PHANDLE(DT_PATH(zephyr_user), dac)
+#define DAC_RESOLUTION DT_PROP(DT_PATH(zephyr_user), dac_resolution)
+static const struct device *const dac_dev = DEVICE_DT_GET(DAC_NODE);
+
+#define DAC_CHANNEL_DEFINE(n, p, i)                                                                \
+	{                                                                                              \
+		.channel_id = DT_PROP_BY_IDX(n, p, i),                                                     \
+		.resolution = DAC_RESOLUTION,                                                              \
+		.buffered = true,                                                                          \
+	},
+
+#if DT_PROP_LEN_OR(DT_PATH(zephyr_user), dac_channels, 0) > 0
+static const struct dac_channel_cfg dac_ch_cfg[] = {
+	DT_FOREACH_PROP_ELEM(DT_PATH(zephyr_user), dac_channels, DAC_CHANNEL_DEFINE)};
+
+static bool dac_channel_initialized[NUM_OF_DACS];
+#endif
+
+#endif
+
+#endif // CONFIG_DAC
+
 static unsigned int irq_key;
 static bool interrupts_disabled = false;
 } // namespace
@@ -350,6 +376,18 @@ unsigned long millis(void) {
 	return k_uptime_get_32();
 }
 
+#if defined(CONFIG_DAC) || defined(CONFIG_PWM)
+static int _analog_write_resolution = 8;
+
+void analogWriteResolution(int bits) {
+	_analog_write_resolution = bits;
+}
+
+int analogWriteResolution() {
+	return _analog_write_resolution;
+}
+#endif
+
 #ifdef CONFIG_PWM
 
 static uint32_t map64(uint32_t x, uint32_t in_min, uint32_t in_max, uint32_t out_min,
@@ -382,6 +420,41 @@ void analogWrite(pin_size_t pinNumber, int value) {
 
 #endif
 
+#ifdef CONFIG_DAC
+void analogWrite(enum dacPins dacName, int value) {
+#if DT_PROP_LEN_OR(DT_PATH(zephyr_user), dac_channels, 0) > 0
+	const int maxInput = BIT(_analog_write_resolution) - 1U;
+	int ret = 0;
+
+	if (dacName >= NUM_OF_DACS) {
+		return;
+	}
+
+	if (!dac_channel_initialized[dacName]) {
+		if (!device_is_ready(dac_dev)) {
+			return;
+		}
+
+		ret = dac_channel_setup(dac_dev, &dac_ch_cfg[dacName]);
+		if (ret != 0) {
+			return;
+		}
+		dac_channel_initialized[dacName] = true;
+	}
+
+	value = CLAMP(value, 0, maxInput);
+
+	const int max_dac_value = BIT(dac_ch_cfg[dacName].resolution) - 1;
+	const uint32_t output = map(value, 0, maxInput, 0, max_dac_value);
+
+	(void)dac_write_value(dac_dev, dac_ch_cfg[dacName].channel_id, output);
+#else
+	ARG_UNUSED(dacName);
+	ARG_UNUSED(value);
+#endif
+}
+#endif
+
 #ifdef CONFIG_ADC
 
 void analogReference(uint8_t mode) {