From c6512013bbf9defcd28a8618beb0f20eb31c3fe5 Mon Sep 17 00:00:00 2001 From: Thomas Eckerstorfer Date: Wed, 3 Jul 2019 16:42:32 +0200 Subject: [PATCH] added tx20 wind speed sensor (#275) * added tx20 wind speed sensor * added test * fixed lint errors * fixed more lint errors * updated tx20 * updated tx20 sensor * updated to new structure and removed static variables * removed content from __init__.py * fixing lint errors * resolved issues from review Co-authored-by: Thomas Co-authored-by: Otto Winter --- esphome/components/tx20/__init__.py | 0 esphome/components/tx20/sensor.py | 38 ++++++ esphome/components/tx20/tx20.cpp | 195 ++++++++++++++++++++++++++++ esphome/components/tx20/tx20.h | 51 ++++++++ esphome/const.py | 5 + tests/test1.yaml | 8 ++ 6 files changed, 297 insertions(+) create mode 100644 esphome/components/tx20/__init__.py create mode 100644 esphome/components/tx20/sensor.py create mode 100644 esphome/components/tx20/tx20.cpp create mode 100644 esphome/components/tx20/tx20.h diff --git a/esphome/components/tx20/__init__.py b/esphome/components/tx20/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/esphome/components/tx20/sensor.py b/esphome/components/tx20/sensor.py new file mode 100644 index 0000000000..daa6677196 --- /dev/null +++ b/esphome/components/tx20/sensor.py @@ -0,0 +1,38 @@ +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome import pins +from esphome.components import sensor +from esphome.const import CONF_ID, CONF_WIND_SPEED, CONF_PIN, \ + CONF_WIND_DIRECTION_DEGREES, UNIT_KILOMETER_PER_HOUR, \ + UNIT_EMPTY, ICON_WEATHER_WINDY, ICON_SIGN_DIRECTION + +tx20_ns = cg.esphome_ns.namespace('tx20') +Tx20Component = tx20_ns.class_('Tx20Component', cg.Component) + +CONFIG_SCHEMA = cv.Schema({ + cv.GenerateID(): cv.declare_id(Tx20Component), + cv.Optional(CONF_WIND_SPEED): + sensor.sensor_schema(UNIT_KILOMETER_PER_HOUR, ICON_WEATHER_WINDY, 1), + cv.Optional(CONF_WIND_DIRECTION_DEGREES): + sensor.sensor_schema(UNIT_EMPTY, ICON_SIGN_DIRECTION, 1), + cv.Required(CONF_PIN): cv.All(pins.internal_gpio_input_pin_schema, + pins.validate_has_interrupt), +}).extend(cv.COMPONENT_SCHEMA) + + +def to_code(config): + var = cg.new_Pvariable(config[CONF_ID]) + yield cg.register_component(var, config) + + if CONF_WIND_SPEED in config: + conf = config[CONF_WIND_SPEED] + sens = yield sensor.new_sensor(conf) + cg.add(var.set_wind_speed_sensor(sens)) + + if CONF_WIND_DIRECTION_DEGREES in config: + conf = config[CONF_WIND_DIRECTION_DEGREES] + sens = yield sensor.new_sensor(conf) + cg.add(var.set_wind_direction_degrees_sensor(sens)) + + pin = yield cg.gpio_pin_expression(config[CONF_PIN]) + cg.add(var.set_pin(pin)) diff --git a/esphome/components/tx20/tx20.cpp b/esphome/components/tx20/tx20.cpp new file mode 100644 index 0000000000..f3dafda288 --- /dev/null +++ b/esphome/components/tx20/tx20.cpp @@ -0,0 +1,195 @@ +#include "tx20.h" +#include "esphome/core/log.h" +#include "esphome/core/helpers.h" + +namespace esphome { +namespace tx20 { + +static const char *TAG = "tx20"; +static const uint8_t MAX_BUFFER_SIZE = 41; +static const uint16_t TX20_MAX_TIME = MAX_BUFFER_SIZE * 1200 + 5000; +static const uint16_t TX20_BIT_TIME = 1200; +static const char *DIRECTIONS[] = {"N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE", + "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"}; + +void Tx20Component::setup() { + ESP_LOGCONFIG(TAG, "Setting up Tx20"); + this->pin_->setup(); + + this->store_.buffer = new uint16_t[MAX_BUFFER_SIZE]; + this->store_.pin = this->pin_->to_isr(); + this->store_.reset(); + + this->pin_->attach_interrupt(Tx20ComponentStore::gpio_intr, &this->store_, CHANGE); +} +void Tx20Component::dump_config() { + ESP_LOGCONFIG(TAG, "Tx20:"); + + LOG_SENSOR(" ", "Wind speed:", this->wind_speed_sensor_); + LOG_SENSOR(" ", "Wind direction degrees:", this->wind_direction_degrees_sensor_); + + LOG_PIN(" Pin: ", this->pin_); +} +void Tx20Component::loop() { + if (this->store_.tx20_available) { + this->decode_and_publish_(); + this->store_.reset(); + } +} + +float Tx20Component::get_setup_priority() const { return setup_priority::DATA; } + +std::string Tx20Component::get_wind_cardinal_direction() const { return this->wind_cardinal_direction_; } + +void Tx20Component::decode_and_publish_() { + ESP_LOGVV(TAG, "Decode Tx20..."); + + std::string string_buffer; + std::string string_buffer_2; + std::vector bit_buffer; + bool current_bit = true; + + for (int i = 1; i <= this->store_.buffer_index; i++) { + string_buffer_2 += to_string(this->store_.buffer[i]) + ", "; + uint8_t repeat = this->store_.buffer[i] / TX20_BIT_TIME; + // ignore segments at the end that were too short + string_buffer.append(repeat, current_bit ? '1' : '0'); + bit_buffer.insert(bit_buffer.end(), repeat, current_bit); + current_bit = !current_bit; + } + current_bit = !current_bit; + if (string_buffer.length() < MAX_BUFFER_SIZE) { + uint8_t remain = MAX_BUFFER_SIZE - string_buffer.length(); + string_buffer_2 += to_string(remain) + ", "; + string_buffer.append(remain, current_bit ? '1' : '0'); + bit_buffer.insert(bit_buffer.end(), remain, current_bit); + } + + uint8_t tx20_sa = 0; + uint8_t tx20_sb = 0; + uint8_t tx20_sd = 0; + uint8_t tx20_se = 0; + uint16_t tx20_sc = 0; + uint16_t tx20_sf = 0; + uint8_t tx20_wind_direction = 0; + float tx20_wind_speed_kmh = 0; + uint8_t bit_count = 0; + + for (int i = 41; i > 0; i--) { + uint8_t bit = bit_buffer.at(bit_count); + bit_count++; + if (i > 41 - 5) { + // start, inverted + tx20_sa = (tx20_sa << 1) | (bit ^ 1); + } else if (i > 41 - 5 - 4) { + // wind dir, inverted + tx20_sb = tx20_sb >> 1 | ((bit ^ 1) << 3); + } else if (i > 41 - 5 - 4 - 12) { + // windspeed, inverted + tx20_sc = tx20_sc >> 1 | ((bit ^ 1) << 11); + } else if (i > 41 - 5 - 4 - 12 - 4) { + // checksum, inverted + tx20_sd = tx20_sd >> 1 | ((bit ^ 1) << 3); + } else if (i > 41 - 5 - 4 - 12 - 4 - 4) { + // wind dir + tx20_se = tx20_se >> 1 | (bit << 3); + } else { + // windspeed + tx20_sf = tx20_sf >> 1 | (bit << 11); + } + } + + uint8_t chk = (tx20_sb + (tx20_sc & 0xf) + ((tx20_sc >> 4) & 0xf) + ((tx20_sc >> 8) & 0xf)); + chk &= 0xf; + bool value_set = false; + // checks: + // 1. Check that the start frame is 00100 (0x04) + // 2. Check received checksum matches calculated checksum + // 3. Check that Wind Direction matches Wind Direction (Inverted) + // 4. Check that Wind Speed matches Wind Speed (Inverted) + ESP_LOGVV(TAG, "BUFFER %s", string_buffer_2.c_str()); + ESP_LOGVV(TAG, "Decoded bits %s", string_buffer.c_str()); + + if (tx20_sa == 4) { + if (chk == tx20_sd) { + if (tx20_sf == tx20_sc) { + tx20_wind_speed_kmh = float(tx20_sc) * 0.36; + ESP_LOGV(TAG, "WindSpeed %f", tx20_wind_speed_kmh); + if (this->wind_speed_sensor_ != nullptr) + this->wind_speed_sensor_->publish_state(tx20_wind_speed_kmh); + value_set = true; + } + if (tx20_se == tx20_sb) { + tx20_wind_direction = tx20_se; + if (tx20_wind_direction >= 0 && tx20_wind_direction < 16) { + wind_cardinal_direction_ = DIRECTIONS[tx20_wind_direction]; + } + ESP_LOGV(TAG, "WindDirection %d", tx20_wind_direction); + if (this->wind_direction_degrees_sensor_ != nullptr) + this->wind_direction_degrees_sensor_->publish_state(float(tx20_wind_direction) * 22.5f); + value_set = true; + } + if (!value_set) { + ESP_LOGW(TAG, "No value set!"); + } + } else { + ESP_LOGW(TAG, "Checksum wrong!"); + } + } else { + ESP_LOGW(TAG, "Start wrong!"); + } +} + +void ICACHE_RAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) { + arg->pin_state = arg->pin->digital_read(); + const uint32_t now = micros(); + if (!arg->start_time) { + // only detect a start if the bit is high + if (!arg->pin_state) { + return; + } + arg->buffer[arg->buffer_index] = 1; + arg->start_time = now; + arg->buffer_index++; + return; + } + const uint32_t delay = now - arg->start_time; + const uint8_t index = arg->buffer_index; + + // first delay has to be ~2400 + if (index == 1 && (delay > 3000 || delay < 2400)) { + arg->reset(); + return; + } + // second delay has to be ~1200 + if (index == 2 && (delay > 1500 || delay < 1200)) { + arg->reset(); + return; + } + // third delay has to be ~2400 + if (index == 3 && (delay > 3000 || delay < 2400)) { + arg->reset(); + return; + } + + if (arg->tx20_available || ((arg->spent_time + delay > TX20_MAX_TIME) && arg->start_time)) { + arg->tx20_available = true; + return; + } + if (index <= MAX_BUFFER_SIZE) { + arg->buffer[index] = delay; + } + arg->spent_time += delay; + arg->start_time = now; + arg->buffer_index++; +} +void ICACHE_RAM_ATTR Tx20ComponentStore::reset() { + tx20_available = false; + buffer_index = 0; + spent_time = 0; + // rearm it! + start_time = 0; +} + +} // namespace tx20 +} // namespace esphome diff --git a/esphome/components/tx20/tx20.h b/esphome/components/tx20/tx20.h new file mode 100644 index 0000000000..8b79deffbc --- /dev/null +++ b/esphome/components/tx20/tx20.h @@ -0,0 +1,51 @@ +#pragma once + +#include "esphome/core/component.h" +#include "esphome/components/sensor/sensor.h" + +namespace esphome { +namespace tx20 { + +/// Store data in a class that doesn't use multiple-inheritance (vtables in flash) +struct Tx20ComponentStore { + volatile uint16_t *buffer; + volatile uint32_t start_time; + volatile uint8_t buffer_index; + volatile uint32_t spent_time; + volatile bool tx20_available; + volatile bool pin_state; + ISRInternalGPIOPin *pin; + + void reset(); + static void gpio_intr(Tx20ComponentStore *arg); +}; + +/// This class implements support for the Tx20 Wind sensor. +class Tx20Component : public Component { + public: + /// Get the textual representation of the wind direction ('N', 'SSE', ..). + std::string get_wind_cardinal_direction() const; + + void set_pin(GPIOPin *pin) { pin_ = pin; } + void set_wind_speed_sensor(sensor::Sensor *wind_speed_sensor) { wind_speed_sensor_ = wind_speed_sensor; } + void set_wind_direction_degrees_sensor(sensor::Sensor *wind_direction_degrees_sensor) { + wind_direction_degrees_sensor_ = wind_direction_degrees_sensor; + } + + void setup() override; + void dump_config() override; + float get_setup_priority() const override; + void loop() override; + + protected: + void decode_and_publish_(); + + std::string wind_cardinal_direction_; + GPIOPin *pin_; + sensor::Sensor *wind_speed_sensor_; + sensor::Sensor *wind_direction_degrees_sensor_; + Tx20ComponentStore store_; +}; + +} // namespace tx20 +} // namespace esphome diff --git a/esphome/const.py b/esphome/const.py index 27c4b68799..3811d5b9cf 100644 --- a/esphome/const.py +++ b/esphome/const.py @@ -454,6 +454,8 @@ CONF_WHITE = 'white' CONF_WIDTH = 'width' CONF_WIFI = 'wifi' CONF_WILL_MESSAGE = 'will_message' +CONF_WIND_SPEED = 'wind_speed' +CONF_WIND_DIRECTION_DEGREES = 'wind_direction_degrees' CONF_WINDOW_SIZE = 'window_size' CONF_ZERO = 'zero' @@ -481,12 +483,14 @@ ICON_ROTATE_RIGHT = 'mdi:rotate-right' ICON_SCALE = 'mdi:scale' ICON_SCREEN_ROTATION = 'mdi:screen-rotation' ICON_SIGNAL = 'mdi:signal' +ICON_SIGN_DIRECTION = 'mdi:sign-direction' ICON_WEATHER_SUNSET = 'mdi:weather-sunset' ICON_WEATHER_SUNSET_DOWN = 'mdi:weather-sunset-down' ICON_WEATHER_SUNSET_UP = 'mdi:weather-sunset-up' ICON_THERMOMETER = 'mdi:thermometer' ICON_TIMER = 'mdi:timer' ICON_WATER_PERCENT = 'mdi:water-percent' +ICON_WEATHER_WINDY = 'mdi:weather-windy' ICON_WIFI = 'mdi:wifi' UNIT_AMPERE = 'A' @@ -498,6 +502,7 @@ UNIT_EMPTY = '' UNIT_HZ = 'hz' UNIT_HECTOPASCAL = 'hPa' UNIT_KELVIN = 'K' +UNIT_KILOMETER_PER_HOUR = 'km/h' UNIT_LUX = 'lx' UNIT_METER = 'm' UNIT_METER_PER_SECOND_SQUARED = u'm/s²' diff --git a/tests/test1.yaml b/tests/test1.yaml index 4fa2f85cf6..8fdcdd57ea 100644 --- a/tests/test1.yaml +++ b/tests/test1.yaml @@ -564,6 +564,14 @@ sensor: name: CCS811 TVOC update_interval: 30s baseline: 0x4242 + - platform: tx20 + wind_speed: + name: "Windspeed" + wind_direction_degrees: + name: "Winddirection Degrees" + pin: + number: GPIO04 + mode: INPUT - platform: zyaura clock_pin: GPIO5 data_pin: GPIO4