Modbus controller (#1779)

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

esphome/components/modbus_controller/binary_sensor/__init__.py

@@ -0,0 +1,81 @@
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OFFSET
+from .. import (
+    SensorItem,
+    modbus_controller_ns,
+    ModbusController,
+    MODBUS_REGISTER_TYPE,
+)
+from ..const import (
+    CONF_BITMASK,
+    CONF_BYTE_OFFSET,
+    CONF_FORCE_NEW_RANGE,
+    CONF_MODBUS_CONTROLLER_ID,
+    CONF_REGISTER_TYPE,
+    CONF_SKIP_UPDATES,
+)
+
+DEPENDENCIES = ["modbus_controller"]
+CODEOWNERS = ["@martgras"]
+
+
+ModbusBinarySensor = modbus_controller_ns.class_(
+    "ModbusBinarySensor", cg.Component, binary_sensor.BinarySensor, SensorItem
+)
+
+CONFIG_SCHEMA = cv.All(
+    binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(ModbusBinarySensor),
+            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
+            cv.Required(CONF_ADDRESS): cv.positive_int,
+            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
+            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_SKIP_UPDATES, default=0): cv.positive_int,
+            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_SKIP_UPDATES],
+        config[CONF_FORCE_NEW_RANGE],
+    )
+    await cg.register_component(var, config)
+    await binary_sensor.register_binary_sensor(var, config)
+
+    paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
+    cg.add(paren.add_sensor_item(var))
+    if CONF_LAMBDA in config:
+        template_ = await cg.process_lambda(
+            config[CONF_LAMBDA],
+            [
+                (ModbusBinarySensor.operator("ptr"), "item"),
+                (cg.float_, "x"),
+                (
+                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
+                    "data",
+                ),
+            ],
+            return_type=cg.optional.template(bool),
+        )
+        cg.add(var.set_template(template_))

esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.cpp

@@ -0,0 +1,40 @@
+#include "modbus_binarysensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace modbus_controller {
+
+static const char *const TAG = "modbus_controller.binary_sensor";
+
+void ModbusBinarySensor::dump_config() { LOG_BINARY_SENSOR("", "Modbus Controller Binary Sensor", this); }
+
+void ModbusBinarySensor::parse_and_publish(const std::vector<uint8_t> &data) {
+  bool value;
+
+  switch (this->register_type) {
+    case ModbusRegisterType::DISCRETE_INPUT:
+      value = coil_from_vector(this->offset, data);
+      break;
+    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->transform_func_.has_value()) {
+    // the lambda can parse the response itself
+    auto val = (*this->transform_func_)(this, value, data);
+    if (val.has_value()) {
+      ESP_LOGV(TAG, "Value overwritten by lambda");
+      value = val.value();
+    }
+  }
+  this->publish_state(value);
+}
+
+}  // namespace modbus_controller
+}  // namespace esphome

esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/components/modbus_controller/modbus_controller.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace modbus_controller {
+
+class ModbusBinarySensor : public Component, public binary_sensor::BinarySensor, public SensorItem {
+ public:
+  ModbusBinarySensor(ModbusRegisterType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask,
+                     uint8_t skip_updates, bool force_new_range)
+      : Component(), binary_sensor::BinarySensor() {
+    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 = skip_updates;
+    this->force_new_range = force_new_range;
+
+    if (register_type == ModbusRegisterType::COIL || register_type == ModbusRegisterType::DISCRETE_INPUT)
+      this->register_count = offset + 1;
+    else
+      this->register_count = 1;
+  }
+
+  void parse_and_publish(const std::vector<uint8_t> &data) override;
+  void set_state(bool state) { this->state = state; }
+
+  void dump_config() override;
+
+  using transform_func_t =
+      optional<std::function<optional<bool>(ModbusBinarySensor *, bool, const std::vector<uint8_t> &)>>;
+  void set_template(transform_func_t &&f) { this->transform_func_ = f; }
+
+ protected:
+  transform_func_t transform_func_{nullopt};
+};
+
+}  // namespace modbus_controller
+}  // namespace esphome