Merge branch 'develop'

Author: slav-at-attachix

.gitmodules

@@ -329,6 +329,10 @@
 	path = Sming/Libraries/nanopb/nanopb
 	url = https://github.com/nanopb/nanopb.git
 	ignore = dirty
+[submodule "Libraries.OneWire"]
+	path = Sming/Libraries/OneWire
+	url = https://github.com/PaulStoffregen/OneWire.git
+	ignore = dirty
 [submodule "Libraries.RapidXML"]
 	path = Sming/Libraries/RapidXML
 	url = https://github.com/mikee47/Sming-RapidXML

README.md

@@ -29,14 +29,14 @@ You can also try Sming without installing anything locally. We have an [interact
 
 The purpose of Sming is to simplify the creation of embedded applications. The documentation will help you get started in no time.
 
-- [**Documentation for version 6.1.0**](https://sming.readthedocs.io/en/stable) - current stable version.
+- [**Documentation for version 6.2.0**](https://sming.readthedocs.io/en/stable) - current stable version.
 - [Documentation for latest](https://sming.readthedocs.io/en/latest) - development version.
 
 ## Releases
 
 ### Stable
 
-- [Sming V6.1.0](https://github.com/SmingHub/Sming/releases/tag/6.1.0) - great new features, performance and stability improvements.
+- [Sming V6.2.0](https://github.com/SmingHub/Sming/releases/tag/6.2.0) - great new features, performance and stability improvements.
 
 ### Development
 

Sming/Arch/Esp32/Components/esp32/src/tasks.cpp

@@ -26,15 +26,37 @@ void sming_task_loop(void*)
 tcpip_callback_msg* callbackMessage;
 volatile bool eventQueueFlag;
 
+/**
+ * @brief Process all messages in the Sming event queue
+ * Called in the context of the tcpip message thread.
+ */
 void tcpip_message_handler(void*)
 {
 	eventQueueFlag = false;
+	// Process only waiting messages (not newly posted ones) so tcpip doesn't starve
+	auto messageCount = uxQueueMessagesWaiting(eventQueue);
 	os_event_t evt;
-	while(xQueueReceive(eventQueue, &evt, 0) == pdTRUE) {
+	while(messageCount-- && xQueueReceive(eventQueue, &evt, 0) == pdTRUE) {
 		taskCallback(&evt);
 	}
 }
 
+/**
+ * @brief Kick the tcpip message handling thread so we get a callback
+ * @retval bool Woken flag, true if a message was queued, false for no action
+ */
+bool tcpip_kick_thread()
+{
+	// If queue isn't empty and we haven't already asked for a tcpip callback, do that now
+	if(xQueueIsQueueEmptyFromISR(eventQueue) == pdFALSE && !eventQueueFlag) {
+		eventQueueFlag = true;
+		auto err = tcpip_callbackmsg_trycallback_fromisr(callbackMessage);
+		return (err == ERR_NEED_SCHED);
+	}
+
+	return false;
+}
+
 #endif
 
 } // namespace
@@ -82,6 +104,9 @@ void start_sming_task_loop()
 
 	callbackMessage = tcpip_callbackmsg_new(tcpip_callback_fn(tcpip_message_handler), nullptr);
 
+	// There may be messages already queued
+	tcpip_kick_thread();
+
 #endif
 }
 
@@ -103,14 +128,7 @@ bool IRAM_ATTR system_os_post(uint8_t prio, os_signal_t sig, os_param_t par)
 		// Message loop not yet active
 		return true;
 	}
-	// If queue isn't empty and we haven't already asked for a tcpip callback, do that now
-	if(xQueueIsQueueEmptyFromISR(eventQueue) == pdFALSE && !eventQueueFlag) {
-		eventQueueFlag = true;
-		auto err = tcpip_callbackmsg_trycallback_fromisr(callbackMessage);
-		woken = (err == ERR_NEED_SCHED);
-	} else {
-		woken = false;
-	}
+	woken = tcpip_kick_thread();
 #endif
 
 	portYIELD_FROM_ISR_ARG(woken);

Sming/Arch/Esp32/Core/Digital.cpp

@@ -13,6 +13,9 @@
 #include <esp_clk.h>
 #include <hal/gpio_ll.h>
 #include <driver/rtc_io.h>
+#include <driver/adc.h>
+#include <bitset>
+#include <debug_progmem.h>
 #if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
 #include <hal/rtc_io_ll.h>
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 2, 0)
@@ -21,12 +24,21 @@
 #endif
 #endif
 
+namespace
+{
+adc_oneshot_unit_handle_t adcUnitHandles[SOC_ADC_PERIPH_NUM];
+std::bitset<GPIO_PIN_COUNT> adcInitFlags;
+} // namespace
+
 void pinMode(uint16_t pin, uint8_t mode)
 {
 	if(pin >= GPIO_PIN_COUNT) {
 		return; // Bad pin
 	}
 
+	// Next call to `analogRead` needs to re-initialise
+	adcInitFlags[pin] = 0;
+
 	auto gpio = gpio_num_t(pin);
 
 #if SOC_RTCIO_INPUT_OUTPUT_SUPPORTED
@@ -146,3 +158,38 @@ unsigned long pulseIn(uint16_t pin, uint8_t state, unsigned long timeout)
 	WAIT_FOR_PIN_STATE(!state);
 	return clockCyclesToMicroseconds(esp_get_ccount() - pulse_start_cycle_count);
 }
+
+uint16_t analogRead(uint16_t pin)
+{
+	adc_unit_t unit_id;
+	adc_channel_t channel;
+	esp_err_t err = adc_oneshot_io_to_channel(pin, &unit_id, &channel);
+	if(err != ESP_OK) {
+		debug_e("Pin %u is not ADC pin!", pin);
+		return 0;
+	}
+
+	// Initialise unit
+	auto& adc_handle = adcUnitHandles[unit_id];
+	if(!adc_handle) {
+		adc_oneshot_unit_init_cfg_t init_config{
+			.unit_id = unit_id,
+		};
+		ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config, &adc_handle));
+	}
+
+	// Initialise channel
+	if(!adcInitFlags[pin]) {
+		adc_oneshot_chan_cfg_t channel_config{
+			.atten = ADC_ATTEN_DB_0,
+			.bitwidth = ADC_BITWIDTH_DEFAULT,
+		};
+		ESP_ERROR_CHECK(adc_oneshot_config_channel(adc_handle, channel, &channel_config));
+		adcInitFlags[pin] = 1;
+	}
+
+	int rawSampleValue{0};
+	ESP_ERROR_CHECK(adc_oneshot_read(adc_handle, channel, &rawSampleValue));
+
+	return rawSampleValue;
+}

Sming/Arch/Esp32/Core/adc.cpp

@@ -12,6 +12,8 @@
 
 #pragma once
 
+#include <soc/adc_channel.h>
+
 #define EXTERNAL_NUM_INTERRUPTS 16
 #define NUM_DIGITAL_PINS 40
 #define NUM_ANALOG_INPUTS 16
@@ -20,7 +22,7 @@
 #define digitalPinToInterrupt(p) (((p) < 40) ? (p) : -1)
 #define digitalPinHasPWM(p) (p < 34)
 
-constexpr uint8_t A0{36};
+constexpr uint8_t A0 = ADC1_CHANNEL_0_GPIO_NUM;
 
 #define GPIO_REG_TYPE uint32_t
 

Sming/Arch/Esp32/Core/pins_arduino.h

@@ -192,3 +192,11 @@ unsigned long pulseIn(uint16_t pin, uint8_t state, unsigned long timeout)
 
 	return cycleTimer.elapsedTime().as<NanoTime::Microseconds>();
 }
+
+uint16_t analogRead(uint16_t pin)
+{
+	if(pin == A0)
+		return system_adc_read();
+	else
+		return -1; // Not supported
+}

Sming/Arch/Esp8266/Core/Digital.cpp

@@ -14,11 +14,22 @@
 #include <esp_systemapi.h>
 #include <hardware/gpio.h>
 #include <Platform/Timers.h>
+#include <hardware/adc.h>
+#include <bitset>
+
+#define PIN_ADC0 26
+#define PIN_ADC1 27
+#define PIN_ADC2 28
+#define PIN_ADC3 29
+#define PIN_TEMP 30 // Not a GPIO
+#define ADC_TEMP 4
 
 namespace
 {
 constexpr uint32_t PIN_COUNT = NUM_BANK0_GPIOS;
 
+std::bitset<NUM_ADC_CHANNELS> adcInitFlags;
+
 #define CHECK_PIN(pin_number, ...)                                                                                     \
 	if(pin_number >= PIN_COUNT) {                                                                                      \
 		SYSTEM_ERROR("ERROR: Illegal pin in %s (%d)", __FUNCTION__, pin_number);                                       \
@@ -58,6 +69,12 @@ void pinMode(uint16_t pin, uint8_t mode)
 		SYSTEM_ERROR("ERROR: Illegal pinMode mode (%d)", mode);
 		return;
 	}
+
+	if(pin >= PIN_ADC0 && pin <= PIN_TEMP) {
+		// Next call to `analogRead` needs to re-initialise
+		uint8_t channel = pin - PIN_ADC0;
+		adcInitFlags[channel] = 0;
+	}
 }
 
 bool isInputPin(uint16_t pin)
@@ -130,3 +147,27 @@ unsigned long pulseIn(uint16_t pin, uint8_t state, unsigned long timeout)
 
 	return timer.elapsedTicks();
 }
+
+uint16_t analogRead(uint16_t pin)
+{
+	if(pin < PIN_ADC0 || pin > PIN_TEMP) {
+		// Not an analogue pin
+		return 0;
+	}
+
+	uint8_t channel = pin - PIN_ADC0;
+	if((adc_hw->cs & ADC_CS_EN_BITS) == 0) {
+		adc_init();
+	}
+	if(!adcInitFlags[channel]) {
+		if(channel == ADC_TEMP) {
+			adc_set_temp_sensor_enabled(true);
+		} else {
+			adc_gpio_init(pin);
+		}
+		adcInitFlags[channel] = true;
+	}
+
+	adc_select_input(channel);
+	return adc_read();
+}