waterfurnace_aurora 0.7.7 → 1.1.0

data/exe/aurora_mqtt_bridge

@@ -90,29 +90,33 @@ class MQTTBridge
     loop do
       begin
         @mutex.synchronize do
-          @abc.refresh
-
-          components = { @homie_abc => @abc,
-                         @compressor => @abc.compressor,
-                         @blower => @abc.blower,
-                         @pump => @abc.pump,
-                         @dhw => @abc.dhw,
-                         @humidistat => @abc.humidistat }.compact
-          @abc.zones.each_with_index do |z, idx|
-            homie_zone = @homie["zone#{idx + 1}"]
-            components[homie_zone] = z
-          end
+          @homie.mqtt.batch_publish do
+            @abc.refresh
+
+            components = { @homie_abc => @abc,
+                           @aux_heat => @abc.aux_heat,
+                           @compressor => @abc.compressor,
+                           @blower => @abc.blower,
+                           @pump => @abc.pump,
+                           @dhw => @abc.dhw,
+                           @humidistat => @abc.humidistat }.compact
+            @abc.zones.each_with_index do |z, idx|
+              homie_zone = @homie["zone#{idx + 1}"]
+              components[homie_zone] = z
+            end
 
-          components.each do |(node, object)|
-            node.each do |property|
-              property.value = object.public_send(property.id.tr("-", "_"))
+            components.each do |(node, object)|
+              node.each do |property|
+                property.value = object.public_send(property.id.tr("-", "_"))
+              end
             end
-          end
 
-          @abc.faults.each_with_index do |fault_count, i|
-            next if fault_count == 0xffff
+            @faults["current"].value = @abc.current_fault
+            @abc.faults.each_with_index do |fault_count, i|
+              next if fault_count == 0xffff
 
-            @faults["e#{i + 1}"].value = fault_count
+              @faults["e#{i + 1}"].value = fault_count
+            end
           end
         end
       rescue => e
@@ -131,7 +135,7 @@ class MQTTBridge
     }
 
     @homie_abc = @homie.node("abc", "Heat Pump", "ABC") do |node|
-      allowed_modes = %w[lockout standby blower heating cooling eh1 eh2 emergency waiting]
+      allowed_modes = %w[lockout standby blower heating heating_with_aux emergency_heat cooling waiting]
       allowed_modes << "dehumidify" if @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
       node.property("current-mode",
                     "Current Heating/Cooling Mode",
@@ -139,6 +143,31 @@ class MQTTBridge
                     @abc.current_mode,
                     format: allowed_modes,
                     hass: { sensor: { state_class: :measurement } })
+      node.property("emergency-shutdown",
+                    "Emergency Shutdown Requested",
+                    :boolean,
+                    @abc.emergency_shutdown?,
+                    hass: :binary_sensor)
+      node.property("load-shed",
+                    "Load Shed Requested",
+                    :boolean,
+                    @abc.load_shed?,
+                    hass: :binary_sensor)
+      node.property("locked-out",
+                    "Is the heat pump currently locked out?",
+                    :boolean,
+                    @abc.locked_out?,
+                    hass: :binary_sensor)
+      node.property("derated",
+                    "Is the compressor currently running at a derated level?",
+                    :boolean,
+                    @abc.derated?,
+                    hass: :binary_sensor)
+      node.property("safe-mode",
+                    "Is the heat pump currently in safe mode?",
+                    :boolean,
+                    @abc.safe_mode?,
+                    hass: :binary_sensor)
       node.property("entering-air-temperature",
                     "Entering Air Temperature",
                     :float,
@@ -155,14 +184,27 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
-      node.property("leaving-air-temperature",
-                    "Leaving Air Temperature",
-                    :float,
-                    @abc.leaving_air_temperature,
-                    unit: "°F",
-                    hass: { sensor: { device_class: :temperature,
-                                      state_class: :measurement,
-                                      entity_category: :diagnostic } })
+      node.property("low-pressure-switch",
+                    "Low Pressure Switch Status",
+                    :enum,
+                    @abc.low_pressure_switch,
+                    format: %w[open closed])
+      node.property("high-pressure-switch",
+                    "High Pressure Switch Status",
+                    :enum,
+                    @abc.high_pressure_switch,
+                    format: %w[open closed])
+
+      if @abc.awl_communicating?
+        node.property("leaving-air-temperature",
+                      "Leaving Air Temperature",
+                      :float,
+                      @abc.leaving_air_temperature,
+                      unit: "°F",
+                      hass: { sensor: { device_class: :temperature,
+                                        state_class: :measurement,
+                                        entity_category: :diagnostic } })
+      end
       node.property("leaving-water-temperature",
                     "Leaving Water Temperature",
                     :float,
@@ -171,7 +213,8 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
-      unless @abc.outdoor_temperature.zero? # TODO: figure out the config if this actually exists
+      # TODO: figure out the config if this actually exists
+      if @abc.awl_communicating? && !@abc.outdoor_temperature.zero?
         node.property("outdoor-temperature",
                       "Outdoor Temperature",
                       :float,
@@ -186,8 +229,8 @@ class MQTTBridge
                     :integer,
                     @abc.line_voltage,
                     format: 90..635,
-                    unit: "V") do |value, property|
-                      @mutex.synchronize { property.value = @abc.line_voltage = value }
+                    unit: "V") do |value|
+                      @mutex.synchronize { @abc.line_voltage = value }
                     end
       node.property("fp1",
                     "FP1 Sensor",
@@ -205,12 +248,11 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
-      %i[aux_heat total].each do |component|
-        component = "#{component}_watts"
-        node.property(component.tr("_", "-"),
-                      component.sub("_watts", " Power Usage").tr("_", " ").titleize,
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Total Power Usage",
                       :integer,
-                      @abc.public_send(component),
+                      @abc.watts,
                       unit: "W",
                       hass: { sensor: { device_class: :power,
                                         state_class: :measurement } })
@@ -224,6 +266,14 @@ class MQTTBridge
                     @abc.compressor.speed,
                     format: @abc.compressor.speed_range,
                     hass: { sensor: { state_class: :measurement } })
+      node.property("saturated-condensor-discharge-temperature",
+                    "Saturated Condensor Discharge Temperature",
+                    :float,
+                    @abc.compressor.saturated_condensor_discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
       if @abc.energy_monitoring?
         node.property("watts",
                       "Power Usage",
@@ -244,6 +294,86 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
+      node.property("drive-temperature",
+                    "Drive Temperature",
+                    :float,
+                    @abc.compressor.drive_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("inverter-temperature",
+                    "Inverter Temperature",
+                    :float,
+                    @abc.compressor.inverter_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("fan-speed",
+                    "Fan Speed",
+                    :integer,
+                    @abc.compressor.fan_speed,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("discharge-temperature",
+                    "Discharge Temperature",
+                    :float,
+                    @abc.compressor.discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("discharge-pressure",
+                    "Discharge Pressure",
+                    :float,
+                    @abc.compressor.discharge_pressure,
+                    unit: "psi",
+                    hass: { sensor: { device_class: :pressure,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("suction-temperature",
+                    "Suction Temperature",
+                    :float,
+                    @abc.compressor.suction_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("suction-pressure",
+                    "Suction Pressure",
+                    :float,
+                    @abc.compressor.suction_pressure,
+                    unit: "psi",
+                    hass: { sensor: { device_class: :pressure,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("saturated-evaporator-discharge-temperature",
+                    "Saturated Evaporator Discharge Temperature",
+                    :float,
+                    @abc.compressor.saturated_evaporator_discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("superheat-temperature",
+                    "SuperHeat Temperature",
+                    :float,
+                    @abc.compressor.superheat_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("superheat-percentage",
+                    "SuperHeat Percentage",
+                    :integer,
+                    @abc.compressor.superheat_percentage,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
 
       next unless @abc.iz2?
 
@@ -256,6 +386,25 @@ class MQTTBridge
                                       entity_category: :diagnostic } })
     end
 
+    @aux_heat = @homie.node("aux-heat", "Aux Heater", "Aux Heater") do |node|
+      node.property("stage",
+                    "Current Stage",
+                    :integer,
+                    @abc.aux_heat.stage,
+                    format: 0..2,
+                    hass: { sensor: { state_class: :measurement } })
+
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Power Usage",
+                      :integer,
+                      @abc.aux_heat.watts,
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
+      end
+    end
+
     @blower = @homie.node("blower", "Blower", @abc.blower.type) do |node|
       node.property("running",
                     "Running",
@@ -291,8 +440,8 @@ class MQTTBridge
                       :integer,
                       @abc.blower.public_send(field),
                       format: 1..12,
-                      hass: { number: { entity_category: :config } }) do |value, property|
-          @mutex.synchronize { property.value = @abc.blower.public_send("#{field}=", value) }
+                      hass: { number: { entity_category: :config } }) do |value|
+          @mutex.synchronize { @abc.blower.public_send("#{field}=", value) }
         end
       end
 
@@ -333,21 +482,12 @@ class MQTTBridge
                     :boolean,
                     @abc.pump.running,
                     hass: { binary_sensor: { device_class: :running } })
-      node.property("speed",
-                    "Speed",
-                    :integer,
-                    @abc.pump.speed,
-                    format: 0..100,
-                    unit: "%",
-                    hass: { number: { entity_category: :diagnostic } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.speed = value }
-      end
       node.property("manual-control",
                     "Manual Control",
                     :boolean,
                     @abc.pump.manual_control?,
-                    hass: { switch: { entity_category: :diagnostic } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.manual_control = value }
+                    hass: { switch: { entity_category: :diagnostic } }) do |value|
+        @mutex.synchronize { @abc.pump.manual_control = value }
       end
       node.property("minimum-speed",
                     "Actual Minimum Speed",
@@ -355,8 +495,8 @@ class MQTTBridge
                     @abc.pump.minimum_speed,
                     format: 0..100,
                     unit: "%",
-                    hass: { number: { entity_category: :config } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.minimum_speed = value }
+                    hass: { number: { entity_category: :config } }) do |value|
+        @mutex.synchronize { @abc.pump.minimum_speed = value }
       end
       node.property("maximum-speed",
                     "Actual Maximum Speed",
@@ -364,8 +504,19 @@ class MQTTBridge
                     @abc.pump.minimum_speed,
                     format: 0..100,
                     unit: "%",
-                    hass: { number: { entity_category: :config } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.maximum_speed = value }
+                    hass: { number: { entity_category: :config } }) do |value|
+        @mutex.synchronize { @abc.pump.maximum_speed = value }
+      end
+      next unless @abc.awl_axb?
+
+      node.property("speed",
+                    "Speed",
+                    :integer,
+                    @abc.pump.speed,
+                    format: 0..100,
+                    unit: "%",
+                    hass: { number: { entity_category: :diagnostic } }) do |value|
+        @mutex.synchronize { @abc.pump.speed = value }
       end
     end
 
@@ -375,8 +526,8 @@ class MQTTBridge
                       "Enabled",
                       :boolean,
                       @abc.dhw.enabled,
-                      hass: { switch: { icon: "mdi:water-boiler" } }) do |value, property|
-          @mutex.synchronize { property.value = @abc.dhw.enabled = value }
+                      hass: { switch: { icon: "mdi:water-boiler" } }) do |value|
+          @mutex.synchronize { @abc.dhw.enabled = value }
         end
         node.property("running",
                       "Pump Running",
@@ -396,47 +547,41 @@ class MQTTBridge
                       @abc.dhw.set_point,
                       format: 100..140,
                       unit: "°F",
-                      hass: :number) do |value, property|
-          @mutex.synchronize { property.value = @abc.dhw.set_point = value }
+                      hass: { number: { step: 5 } }) do |value|
+          @mutex.synchronize { @abc.dhw.set_point = value }
         end
       end
     end
 
     @humidistat = @homie.node("humidistat", "Humidistat", "Humidistat") do |node|
-      node.property("relative-humidity",
-                    "Relative Humidity",
-                    :integer,
-                    @abc.humidistat.relative_humidity,
-                    unit: "%",
-                    format: 0..100,
-                    hass: { sensor: { device_class: :humidity,
-                                      state_class: :measurement } })
       if @abc.humidistat.humidifier?
         node.property("humidifier-running",
                       "Humidifier Running",
                       :boolean,
                       @abc.humidistat.humidifier_running?)
-        node.property("humidifier-mode",
-                      "Humidifier Mode",
-                      :enum,
-                      @abc.humidistat.humidifier_mode,
-                      format: %i[auto manual]) do |value, property|
-          @mutex.synchronize { property.value = @abc.humidistat.humidifier_mode = value.to_sym }
-        end
-        node.property("humidification-target",
-                      "Humidification Target Relative Humidity",
-                      :integer,
-                      @abc.humidistat.humidification_target,
-                      unit: "%",
-                      format: 15..50) do |value, property|
-          @mutex.synchronize { property.value = @abc.humidistat.humidification_target = value }
+        if @abc.awl_communicating?
+          node.property("humidifier-mode",
+                        "Humidifier Mode",
+                        :enum,
+                        @abc.humidistat.humidifier_mode,
+                        format: %i[auto manual]) do |value|
+            @mutex.synchronize { @abc.humidistat.humidifier_mode = value.to_sym }
+          end
+          node.property("humidification-target",
+                        "Humidification Target Relative Humidity",
+                        :integer,
+                        @abc.humidistat.humidification_target,
+                        unit: "%",
+                        format: 15..50) do |value|
+            @mutex.synchronize { @abc.humidistat.humidification_target = value }
+          end
+          node.hass_humidifier("humidifier-running",
+                               target_property: "humidification-target",
+                               mode_property: "humidifier-mode",
+                               id: "humidifier",
+                               name: "Humidifier",
+                               device_class: :humidifier)
         end
-        node.hass_humidifier("humidifier-running",
-                             target_property: "humidification-target",
-                             mode_property: "humidifier-mode",
-                             id: "humidifier",
-                             name: "Humidifier",
-                             device_class: :humidifier)
       end
 
       # VSDrive can perform active dehumidification, even without a dedicated dehumidifier
@@ -446,31 +591,49 @@ class MQTTBridge
                       "Dehumidifier Running",
                       :boolean,
                       @abc.humidistat.dehumidifier_running?)
-        node.property("dehumidifier-mode",
-                      "Dehumidifier Mode",
-                      :enum,
-                      @abc.humidistat.dehumidifier_mode,
-                      format: %i[auto manual]) do |value, property|
-          @mutex.synchronize { property.value = @abc.humidistat.dehumidifier_mode = value.to_sym }
-        end
-        node.property("dehumidification-target",
-                      "Dehumidification Target Relative Humidity",
-                      :integer,
-                      @abc.humidistat.dehumidification_target,
-                      unit: "%",
-                      format: 35..65) do |value, property|
-          @mutex.synchronize { property.value = @abc.humidistat.dehumidification_target = value }
+        if @abc.awl_communicating?
+          node.property("dehumidifier-mode",
+                        "Dehumidifier Mode",
+                        :enum,
+                        @abc.humidistat.dehumidifier_mode,
+                        format: %i[auto manual]) do |value|
+            @mutex.synchronize { @abc.humidistat.dehumidifier_mode = value.to_sym }
+          end
+          node.property("dehumidification-target",
+                        "Dehumidification Target Relative Humidity",
+                        :integer,
+                        @abc.humidistat.dehumidification_target,
+                        unit: "%",
+                        format: 35..65) do |value|
+            @mutex.synchronize { @abc.humidistat.dehumidification_target = value }
+          end
+          node.hass_humidifier("dehumidifier-running",
+                               target_property: "dehumidification-target",
+                               mode_property: "dehumidifier-mode",
+                               id: "dehumidifier",
+                               name: "Dehumidifier",
+                               device_class: :dehumidifier)
         end
-        node.hass_humidifier("dehumidifier-running",
-                             target_property: "dehumidification-target",
-                             mode_property: "dehumidifier-mode",
-                             id: "dehumidifier",
-                             name: "Dehumidifier",
-                             device_class: :dehumidifier)
       end
+      next unless @abc.awl_communicating?
+
+      node.property("relative-humidity",
+                    "Relative Humidity",
+                    :integer,
+                    @abc.humidistat.relative_humidity,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { device_class: :humidity,
+                                      state_class: :measurement } })
     end
 
     @faults = @homie.node("faults", "Fault History", "ABC") do |node|
+      node.property("current",
+                    "Current fault",
+                    :integer,
+                    @abc.current_fault,
+                    format: 0..99,
+                    hass: :sensor)
       node.property("clear-history",
                     "Reset Fault Counts",
                     :enum,
@@ -495,26 +658,29 @@ class MQTTBridge
     @abc.zones.each_with_index do |zone, i|
       type = zone.is_a?(Aurora::IZ2Zone) ? "IntelliZone 2 Zone" : "Thermostat"
       @homie.node("zone#{i + 1}", "Zone #{i + 1}", type) do |node|
+        node.property("current-mode",
+                      "Current Heating/Cooling Mode Requested",
+                      :enum,
+                      zone.current_mode,
+                      format: %w[standby h1 h2 h3 c1 c2])
+
+        next unless @abc.awl_communicating?
+
         allowed_modes = %w[off auto cool heat]
         allowed_modes << "eheat" if i.zero?
         node.property("target-mode",
                       "Target Heating/Cooling Mode",
                       :enum,
                       zone.target_mode,
-                      format: allowed_modes) do |value, property|
-          @mutex.synchronize { property.value = zone.target_mode = value.to_sym }
+                      format: allowed_modes) do |value|
+          @mutex.synchronize { zone.target_mode = value.to_sym }
         end
-        node.property("current-mode",
-                      "Current Heating/Cooling Mode Requested",
-                      :enum,
-                      zone.current_mode,
-                      format: %w[standby h1 h2 h3 c1 c2])
         node.property("target-fan-mode",
                       "Target Fan Mode",
                       :enum,
                       zone.target_fan_mode,
-                      format: %w[auto continuous intermittent]) do |value, property|
-          @mutex.synchronize { property.value = zone.target_fan_mode = value.to_sym }
+                      format: %w[auto continuous intermittent]) do |value|
+          @mutex.synchronize { zone.target_fan_mode = value.to_sym }
         end
         node.property("fan-intermittent-on",
                       "Fan Intermittent Mode On Duration",
@@ -522,8 +688,8 @@ class MQTTBridge
                       zone.fan_intermittent_on,
                       unit: "M",
                       format: %w[0 5 10 15 20],
-                      hass: { select: { entity_category: :config } }) do |value, property|
-          @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
+                      hass: { select: { entity_category: :config } }) do |value|
+          @mutex.synchronize { zone.fan_intermittent_on = value.to_i }
         end
         node.property("fan-intermittent-off",
                       "Fan Intermittent Mode Off Duration",
@@ -531,8 +697,8 @@ class MQTTBridge
                       zone.fan_intermittent_on,
                       unit: "M",
                       format: %w[0 5 10 15 20 25 30 35 40],
-                      hass: { select: { entity_category: :config } }) do |value, property|
-          @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
+                      hass: { select: { entity_category: :config } }) do |value|
+          @mutex.synchronize { zone.fan_intermittent_on = value.to_i }
         end
         node.property("current-fan-mode",
                       "Current Fan Status",
@@ -573,15 +739,15 @@ class MQTTBridge
                       :integer,
                       zone.heating_target_temperature,
                       unit: "°F",
-                      format: 40..90) do |value, property|
-          @mutex.synchronize { property.value = zone.heating_target_temperature = value }
+                      format: 40..90) do |value|
+          @mutex.synchronize { zone.heating_target_temperature = value }
         end
         node.property("cooling-target-temperature",
                       "Cooling Target Temperature", :integer,
                       zone.cooling_target_temperature,
                       unit: "°F",
-                      format: 54..99) do |value, property|
-          @mutex.synchronize { property.value = zone.cooling_target_temperature = value }
+                      format: 54..99) do |value|
+          @mutex.synchronize { zone.cooling_target_temperature = value }
         end
         node.hass_climate(action_property: "current-mode",
                           current_temperature_property: "ambient-temperature",
@@ -612,12 +778,12 @@ class MQTTBridge
 end
 
 log_level = ARGV.include?("--debug") ? :debug : :warn
-logger = Logger.new($stdout)
-logger.level = log_level
-abc.modbus_slave.logger = logger
+Aurora.logger = Logger.new($stdout)
+Aurora.logger.level = log_level
+abc.modbus_slave.logger = Aurora.logger
 
 device = "aurora-#{abc.serial_number}"
 homie = MQTT::Homie::Device.new(device, "WaterFurnace", mqtt: mqtt_uri)
-homie.logger = logger
+homie.logger = Aurora.logger
 
 MQTTBridge.new(abc, homie)

data/exe/web_aid_tool

@@ -7,13 +7,17 @@ require "logger"
 require "optparse"
 require "yaml"
 
-debug_modbus = monitor = false
+debug_modbus = monitor = ignore_missing_registers = false
 
 options = OptionParser.new do |opts|
   opts.banner = "Usage: web_aid_tool /path/to/serial/port [options]"
 
   opts.on("--debug-modbus", "Print actual protocol bytes") { debug_modbus = true }
   opts.on("--monitor", "Print interpreted registers as they are requested, like aurora_monitor") { monitor = true }
+  opts.on("--ignore-missing-registers",
+          "For YAML input only, just log a warning when a register doesn't exist, instead of failing") do
+    ignore_missing_registers = true
+  end
   opts.on("-v", "--version", "Print version") do
     puts Aurora::VERSION
     exit
@@ -31,7 +35,7 @@ unless ARGV.length == 1
   exit 1
 end
 
-slave = Aurora::ABCClient.open_modbus_slave(ARGV[0])
+slave = Aurora::ABCClient.open_modbus_slave(ARGV[0], ignore_missing_registers: ignore_missing_registers)
 slave.logger = Logger.new($stdout)
 slave.logger.level = debug_modbus ? :debug : :warn