Solar double-pole metering with a single CT

[ericderace]

Hi,

I have a Solar system input into my electrical panel in a double pole breaker. I currently have it set up in the YAML as on phase a, and with multiply: 2 filter. However, I notice that Phase A and Phase B are not the same voltage, therefore I don't believe the calculation is accurate. I understand that if I set it up with 2 CTs, each one would be calculated on its phase, which would result in accurate measurements. However, is there a way to set up the YAML such that I can use a single CT, but measure both Leg A and Leg B power based on respective Phase A and Phase B voltage? We know that the current in both legs would be the same.

I tried this, but it resulted in 0 W for phase B power. (same input, two phase_id's

• { phase_id: phase_a, input: "9", power: { id: solara, filters: [ ] } }
• { phase_id: phase_b, input: "9", power: { id: solarb, filters: [ *invert ] } }

[flaviut]

You likely want to use a platform: template sensor to do these calculations. Take a look at how the balance_power sensor works, and write your own with whatever C++ expression you'd like.

In this case, you'll likely want to set an id on the voltage sensors so that you can reference them from your expression.

[flaviut]

I think you deleted your comment, but

Is there a direct way to reference the current on a specific circuit?

you might have seen current sensors in some other places on this forum. Do not use these! It's unclear what data they are showing; the approach you took is the right one.

[ericderace]

Yeah, sorry - I pulled the post to explore the current data and quickly learned that it wasn't a great idea as you just mentioned. Went full circle.

Here's what I did for reference (and it works):

• Added id's to phase_a and phase_b voltages
• referenced these voltages to calculate the phase a current of the solar array

  - platform: template
    name: "Circuit 9 Current"
    lambda: return id(cir9).state / (id(phase_a_voltage).state + id(phase_b_voltage).state);
    id: cir9_current
    device_class: current
    state_class: measurement
    unit_of_measurement: "A"
  - platform: template
    name: "Solar Power"
    lambda: return id(cir9_current).state * (id(phase_a_voltage).state + id(phase_b_voltage).state) * (-1);
    id: solar_power
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
  - platform: total_daily_energy
    name: "Solar Daily Energy"
    power_id: solar_power
    accuracy_decimals: 0

Thanks for your help and for creating this integration!

[ericderace]

I'm trying another approach today:

# Phase A and Phase B power sensor for the same CT #9 (where my solar array is connected)
      - { phase_id: phase_a, input:  "9", power: { id:  cir9a, filters: [ ] } }
      - { phase_id: phase_b, input:  "9", power: { id:  cir9b, filters: [ multiply: -1  ] } } # one of these phases has to be inverted
    on_update:
      then:
        - component.update: total_power
        - component.update: balance_power
        - component.update: cir9 # update the template below

# template for cir9
- { platform: template, lambda: return id(cir9a).state + id(cir9b).state;, id: cir9, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }

# copy for reporting to HA with filters
- { platform: copy, name:  "Circuit 9 Power", source_id:  cir9, filters: *throttle_avg }

# energy counter to remain the same as per usual

I think this approach should work for any double-pole circuits

[ericderace]

Seems to be working alright. I'll try this on all my double-pole circuits tomorrow and report back. I had differences in voltages between Phase 1 and Phase 2, and I think this approach will result in more accurate values.

[ericderace]

Here is my latest complete configuration. 15 of the 16 circuits are double pole circuits. Circuit 3 in a single pole circuit, circuit 9 is where my solar array is connected. This configuration calculates the power by creating CT sensors on each phase, instead of using multiply: 2. It then adds up the two ct sensors in a template, and reports to HA using the copy sensor.

Sharing for any others that came here with a similar setup.

sensor:
  - platform: emporia_vue
    i2c_id: i2c_a
    phases:
      - id: phase_a  # Verify that this specific phase/leg is connected to correct input wire color on device listed below
        input: BLACK  # Vue device wire color
        calibration: 0.0228421516  # 0.022 is used as the default as starting point but may need adjusted to ensure accuracy
        # To calculate new calibration value use the formula <in-use calibration value> * <accurate voltage> / <reporting voltage>
        voltage:
          name: "Phase A Voltage"
          filters: [*throttle_avg, *pos]
          id: phase_a_voltage
        frequency:
          name: "Phase A Frequency"
          filters: [*throttle_avg, *pos]
      - id: phase_b  # Verify that this specific phase/leg is connected to correct input wire color on device listed below
        input: RED  # Vue device wire color
        calibration: 0.0217005262  # 0.022 is used as the default as starting point but may need adjusted to ensure accuracy
        # To calculate new calibration value use the formula <in-use calibration value> * <accurate voltage> / <reporting voltage>
        voltage:
          name: "Phase B Voltage"
          filters: [*throttle_avg, *pos]
          id: phase_b_voltage
        phase_angle:
          name: "Phase B Phase Angle"
          filters: [*throttle_avg, *pos]
    ct_clamps:
      # Do not specify a name for any of the power sensors here, only an id. This leaves the power sensors internal to ESPHome.
      # Copy sensors will filter and then send power measurements to HA
      # These non-throttled power sensors are used for accurately calculating energy
      - phase_id: phase_a
        input: "A"  # Verify the CT going to this device input also matches the phase/leg
        power:
          id: phase_a_power
          filters: [  ] 
      - phase_id: phase_b
        input: "B"  # Verify the CT going to this device input also matches the phase/leg
        power:
          id: phase_b_power
          filters: [  ] 

      # Pay close attention to set the phase_id for each breaker by matching it to the phase/leg it connects to in the panel
      - { phase_id: phase_a, input:  "1", power: { id:  cir1a, filters: [ ] } }
      - { phase_id: phase_b, input:  "1", power: { id:  cir1b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input:  "2", power: { id:  cir2a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "2", power: { id:  cir2b, filters: [ ] } }
      - { phase_id: phase_b, input:  "3", power: { id:  cir3, filters: [  ] } } # This is a single-pole circuit
      - { phase_id: phase_a, input:  "4", power: { id:  cir4a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "4", power: { id:  cir4b, filters: [ ] } }
      - { phase_id: phase_a, input:  "5", power: { id:  cir5a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "5", power: { id:  cir5b, filters: [ ] } }
      - { phase_id: phase_a, input:  "6", power: { id:  cir6a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "6", power: { id:  cir6b, filters: [ ] } }
      - { phase_id: phase_a, input:  "7", power: { id:  cir7a, filters: [ ] } }
      - { phase_id: phase_b, input:  "7", power: { id:  cir7b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input:  "8", power: { id:  cir8a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "8", power: { id:  cir8b, filters: [ ] } }
      - { phase_id: phase_a, input:  "9", power: { id:  cir9a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input:  "9", power: { id:  cir9b, filters: [ ] } }
      - { phase_id: phase_a, input: "10", power: { id:  cir10a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input: "10", power: { id:  cir10b, filters: [ ] } }
      - { phase_id: phase_a, input: "11", power: { id: cir11a, filters: [ multiply: -1 ] } }
      - { phase_id: phase_b, input: "11", power: { id: cir11b, filters: [ ] } }
      - { phase_id: phase_a, input: "12", power: { id: cir12a, filters: [ ] } }
      - { phase_id: phase_b, input: "12", power: { id: cir12b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input: "13", power: { id: cir13a, filters: [ ] } }
      - { phase_id: phase_b, input: "13", power: { id: cir13b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input: "14", power: { id: cir14a, filters: [ ] } }
      - { phase_id: phase_b, input: "14", power: { id: cir14b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input: "15", power: { id: cir15a, filters: [ ] } }
      - { phase_id: phase_b, input: "15", power: { id: cir15b, filters: [ multiply: -1 ] } }
      - { phase_id: phase_a, input: "16", power: { id: cir16a, filters: [ ] } }
      - { phase_id: phase_b, input: "16", power: { id: cir16b, filters: [ multiply: -1 ] } }

      # Required for HA Energy Panel - Separate Grid Delivery and Return sensors
      - { phase_id: phase_a, input: "A", power: { id: phase_a_in, filters: [ *pos ] } }
      - { phase_id: phase_b, input: "B", power: { id: phase_b_in, filters: [ *pos ] } }
      - { phase_id: phase_a, input: "A", power: { id: phase_a_out, filters: [ *invert ] } }
      - { phase_id: phase_b, input: "B", power: { id: phase_b_out, filters: [ *invert ] } }

      # Updates
    on_update:
      then:
        - component.update: grid_power
        - component.update: grid_delivery
        - component.update: grid_return
        - component.update: cir1
        - component.update: cir2
        - component.update: cir4
        - component.update: cir5
        - component.update: cir6
        - component.update: cir7
        - component.update: cir8
        - component.update: cir9
        - component.update: cir10
        - component.update: cir11
        - component.update: cir12
        - component.update: cir13
        - component.update: cir14
        - component.update: cir15
        - component.update: cir16
        - component.update: solar_production
        - component.update: total_power
        - component.update: balance_power

  # Templates for double-pole circuits
  - { platform: template, lambda: return id(cir1a).state + id(cir1b).state;, id: cir1, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir2a).state + id(cir2b).state;, id: cir2, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir4a).state + id(cir4b).state;, id: cir4, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir5a).state + id(cir5b).state;, id: cir5, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir6a).state + id(cir6b).state;, id: cir6, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir7a).state + id(cir7b).state;, id: cir7, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir8a).state + id(cir8b).state;, id: cir8, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir9a).state + id(cir9b).state;, id: cir9, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir10a).state + id(cir10b).state;, id: cir10, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir11a).state + id(cir11b).state;, id: cir11, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir12a).state + id(cir12b).state;, id: cir12, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir13a).state + id(cir13b).state;, id: cir13, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir14a).state + id(cir14b).state;, id: cir14, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir15a).state + id(cir15b).state;, id: cir15, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }
  - { platform: template, lambda: return id(cir16a).state + id(cir16b).state;, id: cir16, device_class: power, state_class: measurement, unit_of_measurement: "W", update_interval: never, internal: true }

    # Current Grid Power (can be pos or negative depending on current consumption & solar production)
  - platform: template
    lambda: return id(phase_a_power).state + id(phase_b_power).state;
    update_interval: never   # will be updated after all power sensors update via on_update trigger
    id: grid_power
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    name: "Grid Power"
    internal: true

    # Grid delivery sensor
  - platform: template
    lambda: |- 
      if (id(grid_power).state > 0) return id(grid_power).state;
      else return 0;
    update_interval: never
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    id: grid_delivery
    internal: true

    # Grid return sensor
  - platform: template
    lambda: |- 
      if (id(grid_power).state < 0) return -id(grid_power).state;
      else return 0;
    update_interval: never
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    id: grid_return
    internal: true

    # Solar power sensor
  - platform: template
    lambda: return -id(cir9).state;
    update_interval: never
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    id: solar_production
    internal: true

    # Total Power consumption, considering grid delivery + Solar prodction  
  - platform: template
    name: "Total Power Consumption"
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    id: total_power
    lambda: return id(grid_power).state + id(solar_production).state;
    update_interval: never   # will be updated after all power sensors update via on_update trigger
    internal: true

    # Balance Power meter
  - platform: template
    lambda: !lambda |-
      return id(grid_power).state -
        id( cir1).state -
        id( cir2).state -
        id( cir3).state -
        id( cir4).state -
        id( cir5).state -
        id( cir6).state -
        id( cir7).state -
        id( cir8).state -
        id( cir9).state -
        id(cir10).state -
        id(cir11).state -
        id(cir12).state -
        id(cir13).state -
        id(cir14).state -
        id(cir15).state -
        id(cir16).state;
    update_interval: never   # will be updated after all power sensors update via on_update trigger
    id: balance_power
    device_class: power
    state_class: measurement
    unit_of_measurement: "W"
    internal: true

  # The copy sensors filter and send the power state to HA
  - { platform: copy, name: "Phase A Power", source_id: phase_a_power, filters: *throttle_avg }
  - { platform: copy, name: "Phase B Power", source_id: phase_b_power, filters: *throttle_avg }
  - { platform: copy, name: "Total Power", source_id: total_power, filters: *throttle_avg }
  - { platform: copy, name: "Balance Power", source_id: balance_power, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 1 Power", source_id:  cir1, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 2 Power", source_id:  cir2, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 3 Power", source_id:  cir3, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 4 Power", source_id:  cir4, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 5 Power", source_id:  cir5, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 6 Power", source_id:  cir6, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 7 Power", source_id:  cir7, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 8 Power", source_id:  cir8, filters: *throttle_avg }
  - { platform: copy, name:  "Circuit 9 Power", source_id:  cir9, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 10 Power", source_id: cir10, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 11 Power", source_id: cir11, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 12 Power", source_id: cir12, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 13 Power", source_id: cir13, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 14 Power", source_id: cir14, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 15 Power", source_id: cir15, filters: *throttle_avg }
  - { platform: copy, name: "Circuit 16 Power", source_id: cir16, filters: *throttle_avg }
  - { platform: copy, name: "Solar Production", source_id: solar_production, filters: *throttle_avg }
  - { platform: copy, name: "Grid Power", source_id: grid_power, filters: *throttle_avg }
  - { platform: copy, name: "Grid Delivery", source_id: grid_delivery, filters: *throttle_avg }
  - { platform: copy, name: "Grid Return", source_id: grid_return, filters: *throttle_avg }

    # Energy counters for each circuits
  - { power_id: total_power, platform: total_daily_energy, accuracy_decimals: 0, name: "Total Daily Energy Consumption", filters: *throttle_time }
  - { power_id: balance_power, platform: total_daily_energy, accuracy_decimals: 0, name: "Balance Daily Energy Consumption", filters: *throttle_time }
  - { power_id:  cir1, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 1 Daily Energy", filters: *throttle_time }
  - { power_id:  cir2, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 2 Daily Energy", filters: *throttle_time }
  - { power_id:  cir3, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 3 Daily Energy", filters: *throttle_time }
  - { power_id:  cir4, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 4 Daily Energy", filters: *throttle_time }
  - { power_id:  cir5, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 5 Daily Energy", filters: *throttle_time }
  - { power_id:  cir6, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 6 Daily Energy", filters: *throttle_time }
  - { power_id:  cir7, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 7 Daily Energy", filters: *throttle_time }
  - { power_id:  cir8, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 8 Daily Energy", filters: *throttle_time }
  - { power_id:  cir9, platform: total_daily_energy, accuracy_decimals: 0, name:  "Circuit 9 Daily Energy", filters: *throttle_time }
  - { power_id: cir10, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 10 Daily Energy", filters: *throttle_time }
  - { power_id: cir11, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 11 Daily Energy", filters: *throttle_time }
  - { power_id: cir12, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 12 Daily Energy", filters: *throttle_time }
  - { power_id: cir13, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 13 Daily Energy", filters: *throttle_time }
  - { power_id: cir14, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 14 Daily Energy", filters: *throttle_time }
  - { power_id: cir15, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 15 Daily Energy", filters: *throttle_time }
  - { power_id: cir16, platform: total_daily_energy, accuracy_decimals: 0, name: "Circuit 16 Daily Energy", filters: *throttle_time }
  - { power_id: solar_production, platform: total_daily_energy, accuracy_decimals: 0, name: "Solar Daily Energy Production", filters: *throttle_time }
  - { power_id: grid_power, platform: total_daily_energy, accuracy_decimals: 0, name: "Net Daily Energy from Grid", filters: *throttle_time }
  - { power_id: grid_delivery, platform: total_daily_energy, accuracy_decimals: 0, name: "Total Daily Energy delivery from Grid", filters: *throttle_time }
  - { power_id: grid_return, platform: total_daily_energy, accuracy_decimals: 0, name: "Total Daily Energy return to Grid", filters: *throttle_time }