A02YYUW Waterproof Ultrasonic Distance Sensor

#include <stdio.h>
#include "driver/uart.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define RXD_PIN 16
#define TXD_PIN 17
#define UART_NUM UART_NUM_1
#define UART_BUFFER_SIZE (1024 * 2)
#define UART_TIMEOUT_MS 20

static const char *TAG = "UART_SENSOR";

void init_uart(void) {
    // Configure UART parameters
    const uart_config_t uart_config = {
        .baud_rate = 9600,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
    };

    // Apply UART configuration
    ESP_ERROR_CHECK(uart_param_config(UART_NUM, &uart_config));
    ESP_ERROR_CHECK(uart_set_pin(UART_NUM, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));

    // Install UART driver with RX buffer and a small TX buffer
    ESP_ERROR_CHECK(uart_driver_install(UART_NUM, UART_BUFFER_SIZE, 512, 0, NULL, 0));

    // Set UART mode explicitly
    ESP_ERROR_CHECK(uart_set_mode(UART_NUM, UART_MODE_UART));
}

void uart_task(void *pvParameters) {
    uint8_t data[4];

    while (1) {
        // Read 4 bytes from UART
        int len = uart_read_bytes(UART_NUM, data, 4, pdMS_TO_TICKS(UART_TIMEOUT_MS));

        if (len == 4 && data[0] == 0xFF) {
            // Calculate checksum
            int sum = (data[0] + data[1] + data[2]) & 0xFF;
            if (sum == data[3]) {
                // Convert distance to centimeters
                int distance = (data[1] << 8) | data[2];

                if (distance > 30) {
                    ESP_LOGI(TAG, "Distance: %.2f cm", distance / 10.0);
                } else {
                    ESP_LOGW(TAG, "Below the lower limit");
                }
            } else {
                ESP_LOGE(TAG, "Checksum error (Received: 0x%02X, Expected: 0x%02X)", data[3], sum);
            }
        } else if (len > 0) {
            ESP_LOGW(TAG, "Invalid data received");
        }

        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void app_main(void) {
    init_uart();
    xTaskCreate(uart_task, "UART Task", 4096, NULL, 5, NULL);
}

uart:
  rx_pin: GPIO16  # sensor TX -> GPIO16 (RX2)
  tx_pin: GPIO17  # sensor RX -> GPIO17 (TX2)
  baud_rate: 9600

sensor:
  - platform: a02yyuw
    name: "A02YYUW Distance"

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

#include <Arduino.h>

// Define ESP32 hardware serial port for the A02YYUW sensor
#define A02YYUW_TX 18  // ESP32 TX connected to Sensor RX
#define A02YYUW_RX 5   // ESP32 RX connected to Sensor TX

// Initialize hardware serial for A02YYUW
HardwareSerial mySerial(2);

void setup() {
    Serial.begin(115200);  // Initialize Serial Monitor
    mySerial.begin(9600, SERIAL_8N1, A02YYUW_RX, A02YYUW_TX);  // Initialize UART2
    Serial.println("A02YYUW Distance Sensor Example");
}

void loop() {
    if (mySerial.available() >= 4) {
        uint8_t data[4];
        for (int i = 0; i < 4; i++) {
            data[i] = mySerial.read();
        }

        if (data[0] == 0xFF) {  // Check packet start byte
            int sum = (data[0] + data[1] + data[2]) & 0xFF;
            if (sum == data[3]) {  // Validate checksum
                int distance = (data[1] << 8) + data[2];  // Calculate distance
                if (distance > 30) {  // Ensure valid reading
                    Serial.print("Distance: ");
                    Serial.print(distance / 10.0);
                    Serial.println(" cm");
                } else {
                    Serial.println("Below the lower limit");
                }
            } else {
                Serial.println("Checksum error");
            }
        }
    }
    delay(100);
}

from machine import UART
from time import sleep

# Configure UART
uart = UART(2, baudrate=9600, tx=5, rx=18)

def read_distance():
    if uart.any() >= 4:
        data = uart.read(4)
        if data[0] == 0xFF:
            checksum = (data[0] + data[1] + data[2]) & 0xFF
            if checksum == data[3]:
                distance = (data[1] << 8) | data[2]
                if distance > 30:
                    return distance / 10.0
                else:
                    return "Below the lower limit"
            else:
                return "Checksum error"
    return None

print("A02YYUW Distance Sensor Example")

while True:
    result = read_distance()
    if result:
        print(f"Distance: {result} cm")
    sleep(0.1)