Modbus controller (#1779)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>

esphome/components/modbus_controller/switch/__init__.py

@@ -0,0 +1,81 @@
+from esphome.components import switch
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+
+from esphome.const import CONF_ID, CONF_ADDRESS, CONF_LAMBDA, CONF_OFFSET
+from .. import (
+    MODBUS_REGISTER_TYPE,
+    SensorItem,
+    modbus_controller_ns,
+    ModbusController,
+)
+from ..const import (
+    CONF_BITMASK,
+    CONF_BYTE_OFFSET,
+    CONF_FORCE_NEW_RANGE,
+    CONF_MODBUS_CONTROLLER_ID,
+    CONF_REGISTER_TYPE,
+)
+
+DEPENDENCIES = ["modbus_controller"]
+CODEOWNERS = ["@martgras"]
+
+
+ModbusSwitch = modbus_controller_ns.class_(
+    "ModbusSwitch", cg.Component, switch.Switch, SensorItem
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    switch.SWITCH_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(ModbusSwitch),
+            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
+            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
+            cv.Required(CONF_ADDRESS): cv.positive_int,
+            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
+            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
+            cv.Optional(CONF_BITMASK, default=0x1): cv.hex_uint32_t,
+            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
+            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+)
+
+
+async def to_code(config):
+    byte_offset = 0
+    if CONF_OFFSET in config:
+        byte_offset = config[CONF_OFFSET]
+    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
+    if CONF_BYTE_OFFSET in config:
+        byte_offset = config[CONF_BYTE_OFFSET]
+    var = cg.new_Pvariable(
+        config[CONF_ID],
+        config[CONF_REGISTER_TYPE],
+        config[CONF_ADDRESS],
+        byte_offset,
+        config[CONF_BITMASK],
+        config[CONF_FORCE_NEW_RANGE],
+    )
+    await cg.register_component(var, config)
+    await switch.register_switch(var, config)
+
+    paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
+    cg.add(paren.add_sensor_item(var))
+    cg.add(var.set_parent(paren))
+    if CONF_LAMBDA in config:
+        publish_template_ = await cg.process_lambda(
+            config[CONF_LAMBDA],
+            [
+                (ModbusSwitch.operator("ptr"), "item"),
+                (bool, "x"),
+                (
+                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
+                    "data",
+                ),
+            ],
+            return_type=cg.optional.template(bool),
+        )
+        cg.add(var.set_template(publish_template_))

esphome/components/modbus_controller/switch/modbus_switch.cpp

@@ -0,0 +1,70 @@
+
+#include "modbus_switch.h"
+#include "esphome/core/log.h"
+namespace esphome {
+namespace modbus_controller {
+
+static const char *const TAG = "modbus_controller.switch";
+
+void ModbusSwitch::setup() {
+  // value isn't required
+  // without it we crash on save
+  this->get_initial_state();
+}
+void ModbusSwitch::dump_config() { LOG_SWITCH(TAG, "Modbus Controller Switch", this); }
+
+void ModbusSwitch::parse_and_publish(const std::vector<uint8_t> &data) {
+  bool value = false;
+  switch (this->register_type) {
+    case ModbusRegisterType::DISCRETE_INPUT:
+    case ModbusRegisterType::COIL:
+      // offset for coil is the actual number of the coil not the byte offset
+      value = coil_from_vector(this->offset, data);
+      break;
+    default:
+      value = get_data<uint16_t>(data, this->offset) & this->bitmask;
+      break;
+  }
+
+  // Is there a lambda registered
+  // call it with the pre converted value and the raw data array
+  if (this->publish_transform_func_) {
+    // the lambda can parse the response itself
+    auto val = (*this->publish_transform_func_)(this, value, data);
+    if (val.has_value()) {
+      ESP_LOGV(TAG, "Value overwritten by lambda");
+      value = val.value();
+    }
+  }
+
+  ESP_LOGV(TAG, "Publish '%s': new value = %s type = %d address = %X offset = %x", this->get_name().c_str(),
+           ONOFF(value), (int) this->register_type, this->start_address, this->offset);
+  this->publish_state(value);
+}
+
+void ModbusSwitch::write_state(bool state) {
+  // This will be called every time the user requests a state change.
+  ModbusCommandItem cmd;
+  ESP_LOGV(TAG, "write_state '%s': new value = %s type = %d address = %X offset = %x", this->get_name().c_str(),
+           ONOFF(state), (int) this->register_type, this->start_address, this->offset);
+  switch (this->register_type) {
+    case ModbusRegisterType::COIL:
+      // offset for coil and discrete inputs is the coil/register number not bytes
+      cmd = ModbusCommandItem::create_write_single_coil(parent_, this->start_address + this->offset, state);
+      break;
+    case ModbusRegisterType::DISCRETE_INPUT:
+      cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset, state);
+      break;
+
+    default:
+      // since offset is in bytes and a register is 16 bits we get the start by adding offset/2
+      cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset / 2,
+                                                           state ? 0xFFFF & this->bitmask : 0);
+      break;
+  }
+  this->parent_->queue_command(cmd);
+  publish_state(state);
+}
+// ModbusSwitch end
+}  // namespace modbus_controller
+}  // namespace esphome

esphome/components/modbus_controller/switch/modbus_switch.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "esphome/components/modbus_controller/modbus_controller.h"
+#include "esphome/components/switch/switch.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace modbus_controller {
+
+class ModbusSwitch : public Component, public switch_::Switch, public SensorItem {
+ public:
+  ModbusSwitch(ModbusRegisterType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask,
+               bool force_new_range)
+      : Component(), switch_::Switch() {
+    this->register_type = register_type;
+    this->start_address = start_address;
+    this->offset = offset;
+    this->bitmask = bitmask;
+    this->sensor_value_type = SensorValueType::BIT;
+    this->skip_updates = 0;
+    this->register_count = 1;
+    if (register_type == ModbusRegisterType::HOLDING || register_type == ModbusRegisterType::COIL) {
+      this->start_address += offset;
+      this->offset = 0;
+    }
+    this->force_new_range = force_new_range;
+  };
+  void setup() override;
+  void write_state(bool state) override;
+  void dump_config() override;
+  void set_state(bool state) { this->state = state; }
+  void parse_and_publish(const std::vector<uint8_t> &data) override;
+  void set_parent(ModbusController *parent) { this->parent_ = parent; }
+
+  using transform_func_t = std::function<optional<bool>(ModbusSwitch *, bool, const std::vector<uint8_t> &)>;
+  void set_template(transform_func_t &&f) { this->publish_transform_func_ = f; }
+
+ protected:
+  ModbusController *parent_;
+  optional<transform_func_t> publish_transform_func_{nullopt};
+};
+
+}  // namespace modbus_controller
+}  // namespace esphome