a02yyu: add support for DYP-A02YYU ultrasonic sensor

code/espurna/config/sensors.h

@@ -90,6 +90,19 @@
 // =============================================================================
 
 //------------------------------------------------------------------------------
+// A02YYUx (DYP) Ultrasonic Sensor
+// Enable support by passing A02YYU_SUPPORT=1 build flag
+//------------------------------------------------------------------------------
+
+#ifndef A02YYU_SUPPORT
+#define A02YYU_SUPPORT                  0
+#endif
+
+#ifndef A02YYU_PORT
+#define A02YYU_PORT                     1   // By default, use the first port
+                                            // (needs `UART[1-3]_BAUDRATE 9600`)
+#endif
+
 // AM2320 Humidity & Temperature sensor over I2C
 // Enable support by passing AM2320_SUPPORT=1 build flag
 //------------------------------------------------------------------------------
@@ -1519,6 +1532,7 @@
 // Provide generic way to detect sensor presence
 #ifndef SENSOR_SUPPORT
 #define SENSOR_SUPPORT ( \
+    A02YYU_SUPPORT || \
     ADE7953_SUPPORT || \
     AM2320_SUPPORT || \
     ANALOG_SUPPORT || \

code/espurna/config/types.h

@@ -332,6 +332,7 @@
 #define SENSOR_SM300D2_ID           43
 #define SENSOR_PM1006_ID            44
 #define SENSOR_INA219_ID            45
+#define SENSOR_A02YYU_ID            46
 
 //--------------------------------------------------------------------------------
 // Magnitudes

code/espurna/sensor.cpp

@@ -42,6 +42,9 @@ Copyright (C) 2020-2022 by Maxim Prokhorov <prokhorov dot max at outlook dot com
     #include "sensors/DummySensor.h"
 #endif
 
+#if A02YYU_SUPPORT
+    #include "sensors/A02YYUSensor.h"
+#endif
 #if AM2320_SUPPORT
     #include "sensors/AM2320Sensor.h"
 #endif
@@ -2034,6 +2037,20 @@ size_t count() {
 // - update config/custom.h or config/sensor.h, adding `#define DHT2_PIN ...` and `#define DHT2_TYPE ...`
 
 void load() {
+#if A02YYU_SUPPORT
+    {
+        const auto port = uartPort(A02YYU_PORT - 1);
+
+        if (!port) {
+            return;
+        }
+
+        auto* sensor = new A02YYUSensor();
+        sensor->setPort(port->stream);        
+
+        add(sensor);
+    }
+#endif
 #if AM2320_SUPPORT
     {
         auto* sensor = new AM2320Sensor();

code/espurna/sensors/A02YYUSensor.h

@@ -0,0 +1,148 @@
+// -----------------------------------------------------------------------------
+// DYP A02YYUx Ultrasonic Distance Sensor
+// Copyright (C) 2024 by tsouthiv @ gmail dot com
+// -----------------------------------------------------------------------------
+
+// This should be also compatible with other similar sensors like JSN-SR04T
+// or AJ-SR04M in auto UART mode.
+
+#if SENSOR_SUPPORT && A02YYU_SUPPORT
+
+#pragma once
+
+#include "Arduino.h"
+#include "BaseSensor.h"
+
+#define _RX_LEN     16
+#define _RX_MASK    (_RX_LEN - 1)
+
+class A02YYUSensor : public BaseSensor {
+
+    public:
+
+        void setPort(Stream* port) {
+            _serial = port;
+            _dirty = true;
+        }
+
+        // ---------------------------------------------------------------------
+        // Sensor API
+        // ---------------------------------------------------------------------
+
+        unsigned char id() const override {
+            return SENSOR_A02YYU_ID;
+        }
+
+        unsigned char count() const override {
+            return 1;
+        }
+
+        // Initialization method, must be idempotent
+        void begin() {
+            if (!_dirty) return;
+            _ready = true;
+            _dirty = false;
+        }
+
+        // Descriptive name of the sensor
+        String description() const override {
+            return F("A02YYU");
+        }
+
+        // Address of the sensor (it could be the GPIO or I2C address)
+        String address(unsigned char index) const override {
+            return String(A02YYU_PORT, 10);
+        }
+
+        // Type for slot # index
+        unsigned char type(unsigned char index) const override {
+            if (index == 0) return MAGNITUDE_DISTANCE;
+            return MAGNITUDE_NONE;
+        }
+
+        // Current value for slot # index
+        double value(unsigned char index) override {
+            if (index == 0) return _distance;
+            return 0;
+        }
+
+        // Loop-like method, call it in your main loop
+        void tick() override {
+            _read();
+        }
+
+    protected:
+
+        // ---------------------------------------------------------------------
+        // Protected
+        // ---------------------------------------------------------------------
+
+        int _parse(uint8_t startIndex)
+        {
+            uint8_t i = startIndex;
+
+            if (_rx[i] != 0xff)
+                return -1;
+
+            int vh = _rx[(i + 1) & _RX_MASK];
+            int vl = _rx[(i + 2) & _RX_MASK];
+            int cs = _rx[(i + 3) & _RX_MASK];
+
+            if (cs != ((0xff + vh + vl) & 0xff))
+                return -2;
+
+            return (vh << 8) + vl;
+        }
+
+        void _read() {
+
+            int n;
+
+            _error = SENSOR_ERROR_OK;
+
+            // read all available bytes into rx circular buffer
+            while ((n = _serial->available()))
+            {    
+                for (; n > 0; n--) 
+                {
+                    char c = _serial->read();
+
+                    if (_rxCount < _RX_LEN) {
+                        _rx[_rxIndex] = c;
+                        _rxIndex = (_rxIndex + 1) & _RX_MASK;
+                        _rxCount++;
+                    } else {
+                        // overflow
+                        _error = SENSOR_ERROR_OTHER;
+                    }
+                }
+                yield();
+            }
+
+            while (_rxCount >= 4)
+            {
+                int d = _parse(_rdIndex);
+
+                if (d > 0) {
+                    _rdIndex = (_rdIndex + 4) & _RX_MASK;
+                    _rxCount -= 4;
+                    _distance = d / 1000.0;
+                } else {
+                    _rdIndex = (_rdIndex + 1) & _RX_MASK;
+                    _rxCount--;
+                }
+            }
+        }
+
+        // ---------------------------------------------------------------------
+
+        char _rx[_RX_LEN];
+        Stream* _serial { nullptr };
+        double _distance = 0;
+        uint8_t _rxIndex = 0;
+        uint8_t _rxCount = 0;
+        uint8_t _rdIndex = 0;
+        uint8_t _rdCount = 0;
+};
+
+#endif // SENSOR_SUPPORT && A02YYU_SUPPORT