Use code from KinDR007#139

Author: miceno

components/victron/__init__.py

@@ -10,6 +10,7 @@
 CODEOWNERS = ["@KinDR007"]
 
 MULTI_CONF = True
+CONF_ASYNC_UART = "async_uart"
 
 victron_ns = cg.esphome_ns.namespace("victron")
 VictronComponent = victron_ns.class_("VictronComponent", uart.UARTDevice, cg.Component)
@@ -20,6 +21,7 @@
     {
         cv.GenerateID(): cv.declare_id(VictronComponent),
         cv.Optional(CONF_THROTTLE, default="1s"): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_ASYNC_UART, default=False): cv.boolean,
     }
 )
 
@@ -30,3 +32,4 @@ def to_code(config):
     yield uart.register_uart_device(var, config)
 
     cg.add(var.set_throttle(config[CONF_THROTTLE]))
+    cg.add(var.set_async_uart(config[CONF_ASYNC_UART]))

components/victron/victron.cpp

@@ -87,6 +87,14 @@ void VictronComponent::dump_config() {  // NOLINT(google-readability-function-si
 }
 
 void VictronComponent::loop() {
+  if (async_uart_) {
+    async_loop();
+  } else {
+    blocking_loop();
+  }
+}
+
+void VictronComponent::blocking_loop() {
   const uint32_t now = millis();
   const uint8_t elapsed_time = now - last_transmission_;
   if ((state_ > 0) && (elapsed_time >= 200)) {
@@ -143,7 +151,7 @@ void VictronComponent::loop() {
 				ESP_LOGD(TAG, "v:%s", value_.c_str());
         if (this->publishing_) {
 					ESP_LOGD(TAG, "pub:%s", label_.c_str());
-          handle_value_();
+          handle_value_(label_, value_);
         }
         state_ = 0;
       } else {
@@ -163,6 +171,115 @@ void VictronComponent::loop() {
 	}
 }
 
+
+void VictronComponent::async_loop() {
+  // publish one value at a time to yield to esphome between
+  // each value and avoid blocking too long
+  if (publishing_ && recv_buffer_.size() > 0) {
+    std::pair<std::string, std::string> p = recv_buffer_.back();
+    handle_value_(p.first, p.second);
+    recv_buffer_.pop_back();
+    if (recv_buffer_.size() == 0) {
+      publishing_ = false;
+    }
+    return;
+  }
+  // reset publishing in case buffer is empty while publishing
+  publishing_ = false;
+  const uint32_t now = millis();
+  if ((state_ > 0) && (now - last_transmission_ >= 200)) {
+    // last transmission too long ago. Reset RX index.
+    ESP_LOGW(TAG, "Last transmission too long ago");
+    state_ = 0;
+  }
+  if (!available())
+    return;
+
+  last_transmission_ = now;
+  uint8_t c;
+  read_byte(&c);
+  // checksum is calculated as the sum of all bytes in a frame
+  // the final checksum should be a multiple of 256 (0 in 8 bit value)
+  checksum_ += c;
+  if (state_ == 0) {
+    if (c == '\r' || c == '\n') {
+      return;
+    }
+    // reset label/value
+    label_.clear();
+    value_.clear();
+    state_ = 1;
+    if (begin_frame_ == 0) {
+      begin_frame_ = now;
+    }
+  }
+  // read label
+  if (state_ == 1) {
+    // Start of a ve.direct hex frame
+    if (c == ':') {
+      state_ = 3;
+      return;
+    }
+    if (c == '\t') {
+      // end of label received, start reading value
+      state_ = 2;
+    } else {
+      // update label
+      label_.push_back(c);
+    }
+    return;
+  }
+  // read value
+  if (state_ == 2) {
+    // The checksum is used as end of frame indicator
+    if (label_ == "Checksum") {
+      state_ = 0;
+      if (begin_frame_ - this->last_publish_ >= this->throttle_) {
+        // check that checksum value is accurate
+        if (checksum_ != 0) {
+          // invalid checksum, drop frame
+          ESP_LOGW(TAG, "Received invalid checksum, dropping frame: recv %d, calc %d", c, checksum_);
+          checksum_ = 0;
+          for (std::pair<std::string, std::string> element : recv_buffer_) {
+            ESP_LOGD(TAG, ">> %s: %s", element.first.c_str(), element.second.c_str());
+          }
+          // clear buffer with invalid data
+          recv_buffer_.clear();
+          return;
+        }
+        this->last_publish_ = begin_frame_;
+        // full buffer received, with valid checksum
+        // set state to publishing to publish the values in the buffer
+        publishing_ = true;
+      } else {
+        // frame is throttled, clear buffer and skip publishing
+        ESP_LOGD(TAG, "recv throttled, drop frame");
+        recv_buffer_.clear();
+      }
+      // reset checksum and frame
+      checksum_ = 0;
+      begin_frame_ = now;
+      return;
+    }
+    if (c == '\r' || c == '\n') {
+      // end of value received, add label/value to buffer
+      recv_buffer_.insert(recv_buffer_.begin(), std::make_pair(label_, value_));
+      state_ = 0;
+    } else {
+      // update value
+      value_.push_back(c);
+    }
+  }
+  // Discard ve.direct hex frame
+  if (state_ == 3) {
+    if (c == '\r' || c == '\n') {
+      state_ = 0;
+      checksum_ = 0;
+      recv_buffer_.clear();
+    }
+  }
+}
+
 static std::string charging_mode_text(int value) {
   switch (value) {
     case 0:
@@ -663,7 +780,7 @@ static std::string off_reason_text(uint32_t mask) {
   return value_list;
 }
 
-void VictronComponent::handle_value_() {
+void VictronComponent::handle_value_(std::string label_, std::string value_) {
   int value;
 
   if (label_ == "V") {

components/victron/victron.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <vector>
+#include <utility>
 #include "esphome/core/component.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/components/sensor/sensor.h"
@@ -15,6 +17,7 @@ class VictronComponent : public uart::UARTDevice, public Component {
   void set_load_state_binary_sensor(binary_sensor::BinarySensor *load_state_binary_sensor) {
     load_state_binary_sensor_ = load_state_binary_sensor;
   }
+  void set_async_uart(bool async_uart) { this->async_uart_ = async_uart; }
   void set_relay_state_binary_sensor(binary_sensor::BinarySensor *relay_state_binary_sensor) {
     relay_state_binary_sensor_ = relay_state_binary_sensor;
   }
@@ -205,11 +208,13 @@ class VictronComponent : public uart::UARTDevice, public Component {
 
   void dump_config() override;
   void loop() override;
+  void async_loop();
+  void blocking_loop();
 
   float get_setup_priority() const override { return setup_priority::DATA; }
 
  protected:
-  void handle_value_();
+  void handle_value_(std::string label_, std::string value_);
   void publish_state_(binary_sensor::BinarySensor *binary_sensor, const bool &state);
   void publish_state_(sensor::Sensor *sensor, float value);
   void publish_state_(text_sensor::TextSensor *text_sensor, const std::string &state);
@@ -287,13 +292,17 @@ class VictronComponent : public uart::UARTDevice, public Component {
   text_sensor::TextSensor *alarm_reason_text_sensor_{nullptr};
   text_sensor::TextSensor *model_description_text_sensor_{nullptr};
 
-  bool publishing_{true};
   int state_{0};
+  bool async_uart_{false};
+  bool publishing_{false};
   std::string label_;
   std::string value_;
+  uint32_t begin_frame_{0};
   uint32_t last_transmission_{0};
   uint32_t last_publish_{0};
   uint32_t throttle_{0};
+  uint8_t checksum_{0};
+  std::vector<std::pair<std::string, std::string>> recv_buffer_{};
 };
 
 }  // namespace victron