import string

var LAST_MW = 0
var INTERVAL_MS = 5000
var CUR_MW = 0
var CUR_TODAY = 0.0
var SETTLE_MS = 2000

def read_energy()
   var obj = nil
   var sns = nil
   var en = nil
   var p_mw = 0
   var t_val = 0.0

   obj = tasmota.cmd("Status 8")
   if obj != nil
       sns = obj["StatusSNS"]
       if sns == nil
           sns = obj
       end
       if sns != nil
           en = sns["ENERGY"]
           if en != nil
               if en["Power"] != nil
                   p_mw = en["Power"]
               end
               if en["Today"] != nil
                   t_val = en["Today"]
               end
           end
       end
   end

   CUR_MW = p_mw
   CUR_TODAY = t_val
end

def should_send(curr_mw)
   var diff = 0
   var base = 0
   if LAST_MW == 0
       if curr_mw > 0
           return true
       end
   end
   if LAST_MW > 0
       if curr_mw == 0
           return true
       end
   end
   base = LAST_MW
   if base < 1
       base = 1
   end
   diff = curr_mw - LAST_MW
   if diff < 0
       diff = -diff
   end
   if diff * 10 >= base
       return true
   end
   return false
end

def send_update(curr_mw)
   var onoff = "0"
   var today_str = ""
   var url = ""
   if curr_mw > 0
       onoff = "1"
   end
   today_str = string.format("%.3f", CUR_TODAY)
   url = "/cm?cmnd=" + string.format("I%%20%s%%20%d%%20%s", onoff, curr_mw, today_str)
   tasmota.cmd("WebSend [192.168.2.70:8002] " + url)
   LAST_MW = curr_mw
end

def do_settle(_)
   read_energy()
   if should_send(CUR_MW)
       send_update(CUR_MW)
   end
end

def settle_and_send()
   tasmota.set_timer(SETTLE_MS, do_settle, nil)
end

def tick(_)
   read_energy()
   if should_send(CUR_MW)
       settle_and_send()
   end
   tasmota.set_timer(INTERVAL_MS, tick, nil)
end

read_energy()
LAST_MW = CUR_MW
tasmota.set_timer(INTERVAL_MS, tick, nil)

Let's change the focus on the Tasmota device from push to pull. The following Linux command line commands will retrieve the instantaneous Watts usage, and the next will retrieve today's cumulative usage in kWh:

curl -s 'http://192.168.2.173/cm?cmnd=Status%208' | jq -r '.StatusSNS.ENERGY.Power'
curl -s 'http://192.168.2.173/cm?cmnd=Status%208' | jq -r '.StatusSNS.ENERGY.Today'

Write a python program to pull those data items every 3 seconds. Multiple devices will be polled. If Power goes below a threshold, a record in the format of "ID 0 0 #.### YYMMDDhhmmss" will be appended to /home/user0/Rx02.txt.

If Power changes by more than 30W, append a record in the format of "ID 1 # #.### YYMMDDhhmmss".

"#" (3rd data element in record) will be Power. "#.###" (4th element) will be Today (which will be to 3 decimal places (no calculation needed). "YYMMDDhhmmss" (5th element) will be a timestamp in that format.

To begin, there will be 3 devices. Their ID, on/off threshold, and IP address are as follows. No hysteresis is needed around the threshold: above it is "on", at or below it is "off".

T 0 192.168.2.170 freezer
K 0 192.168.2.173 wellpump
L 7 192.168.2.175 boiler

Any negative value is invalid.

#!/usr/bin/env python3
import json
import time
import urllib.request
from datetime import datetime
from typing import Dict, Optional, Tuple

# ====== Configuration ======
POLL_SECONDS = 3

# Change threshold: set units below to "W" (watts) or "mW" (milliwatts)
CHANGE_THRESHOLD_VALUE = 30.0     # 30 W by default
CHANGE_THRESHOLD_UNITS = "W"      # "W" or "mW"

# Optional: round power before comparisons/output to reduce jitter (None = no rounding)
# e.g., 0 = integer watts, 1 = one decimal place, etc.
ROUND_POWER_DECIMALS = None

OUTPUT_FILE = "/home/user0/Rx02.txt"

# Device list: (ID, threshold_watts, ip_address)
DEVICES = [
   ("T", 0.0, "192.168.2.170"),  # freezer
   ("K", 0.0, "192.168.2.173"),  # wellpump
   ("L", 7.0, "192.168.2.175"),  # boiler
]# ====== End configuration ======


def fetch_power_today(ip: str, timeout: float = 2.5) -> Optional[Tuple[float, float]]:
   """
   Query Tasmota: http://<ip>/cm?cmnd=Status%208
   Return (power_w, today_kwh) or None on error/invalid.
   """
   url = f"http://{ip}/cm?cmnd=Status%208"
   try:
       with urllib.request.urlopen(url, timeout=timeout) as resp:
           data = json.loads(resp.read().decode("utf-8", errors="replace"))
   except Exception:
       return None

   try:
       energy = data["StatusSNS"]["ENERGY"]
       power_w = float(energy["Power"])          # Watts
       today_kwh = float(energy["Today"])        # kWh, typically with 3 decimals
   except Exception:
       return None

   # Reject negative values as invalid
   if power_w < 0 or today_kwh < 0:
       return None

   if ROUND_POWER_DECIMALS is not None:
       power_w = round(power_w, ROUND_POWER_DECIMALS)

   return power_w, today_kwh


def ts_YYMMDDhhmmss() -> str:
   return datetime.now().strftime("%y%m%d%H%M%S")


def format_power(p: float) -> str:
   return f"{p:g}"


def format_today_kwh(t: float) -> str:
   return f"{t:.3f}"


def delta_exceeds_threshold(current_w: float, baseline_w: float) -> bool:
   delta_w = abs(current_w - baseline_w)
   if CHANGE_THRESHOLD_UNITS.lower() == "mw":
       return (delta_w * 1000.0) > CHANGE_THRESHOLD_VALUE
   # default watts
   return delta_w > CHANGE_THRESHOLD_VALUE


def main():
   # State per device
   last_sent_power_w: Dict[str, Optional[float]] = {dev_id: None for dev_id, _, _ in DEVICES}
   last_on_state: Dict[str, Optional[bool]]        = {dev_id: None for dev_id, _, _ in DEVICES}

   while True:
       cycle_started = time.time()

       # Prefetch unique IPs once per cycle
       ips = {ip for _, _, ip in DEVICES}
       ip_cache: Dict[str, Optional[Tuple[float, float]]] = {}
       for ip in ips:
           ip_cache[ip] = fetch_power_today(ip)

       lines_to_append = []

       for dev_id, threshold_w, ip in DEVICES:
           reading = ip_cache.get(ip)
           if not reading:
               continue

           power_w, today_kwh = reading

           # Current ON/OFF state: above threshold is ON, at/below is OFF
           is_on = power_w > threshold_w

           stamp = ts_YYMMDDhhmmss()

           # OFF event: crossing from ON -> OFF
           prev_on = last_on_state.get(dev_id)
           if prev_on is True and not is_on:
               lines_to_append.append(f"{dev_id} 0 0 {format_today_kwh(today_kwh)} {stamp}")

           # CHANGE event: only when currently ON and change vs last SENT baseline exceeds threshold
           if is_on:
               prev_sent = last_sent_power_w.get(dev_id)
               if prev_on is not True and is_on:
                   # entering ON state; seed baseline without emitting
                   last_sent_power_w[dev_id] = power_w
               else:
                   if prev_sent is not None and delta_exceeds_threshold(power_w, prev_sent):
                       lines_to_append.append(f"{dev_id} 1 {format_power(power_w)} {format_today_kwh(today_kwh)} {stamp}")
                       last_sent_power_w[dev_id] = power_w
                   elif prev_sent is None:
                       # No baseline yet (e.g., started already ON). Seed and do not emit.
                       last_sent_power_w[dev_id] = power_w

           # Update on/off state
           last_on_state[dev_id] = is_on

       if lines_to_append:
           try:
               with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
                   for line in lines_to_append:
                       f.write(line + "\n")
           except Exception:
               pass

       elapsed = time.time() - cycle_started
       delay = max(0.0, POLL_SECONDS - elapsed)
       time.sleep(delay)


if __name__ == "__main__":
   try:
       main()
   except KeyboardInterrupt:
       pass

awk '/^23/ && /kWh/ { sub(/kWh.*/, "kWh"); print }' x.txt > kwh23.txt

Please compose an email to be sent to the Nova Scotia Department of Energy and Department of Natural Resources and Renewables regarding an effort to have what is popularly called "balcony solar" permitted in Nova Scotia. Point out that there are over a million installations in Germany (provide links) and note that all of Germany is more northerly than Nova Scotia. Also point out that Utah recently became the first state to permit balcony solar, allowing 1200 watts to be fed directly into a standard wall outlet (with anti-islanding protections). Urge allowance of 24-hour feed-in using batteries (theoretically allowing up to 28.8kWh of daily solar production to be self-consumed with excess fed into the grid).

Subject: Permitting Balcony Solar in Nova Scotia for a More Resilient Grid

To: The Honourable Tory Rushton, Minister of Natural Resources and Renewables

To: The Nova Scotia Department of Energy and Mines

Dear Minister Rushton and Department Officials,

I am writing to urge your departments to consider establishing a clear regulatory framework to permit the use of "balcony solar" systems for all Nova Scotians, including tenants and condominium owners. This emerging technology represents a significant opportunity to empower residents, enhance our energy resilience, and accelerate the province's renewable energy goals.

Balcony solar, which involves small-scale, plug-in solar panel systems, has seen remarkable success in jurisdictions with similar or less solar potential than Nova Scotia.

The German Precedent: In Germany, a country that lies entirely north of Nova Scotia, the adoption of balcony solar has been a resounding success. The country recently surpassed one million registered balcony solar installations. This citizen-led energy movement is adding significant decentralized power to their grid, driven by simplified regulations.

Clean Energy Wire: Germany's balcony solar power boom continues

Euronews: Balcony solar is booming in Germany as red tape is cut

North American Leadership: The state of Utah recently became the first U.S. state to formally permit balcony solar. Their legislation allows for systems up to 1,200 watts to be safely connected directly to a standard wall outlet, provided they have essential anti-islanding protections. This forward-thinking policy removes barriers for renters and those in multi-unit buildings, who have largely been excluded from the solar revolution.

We propose that Nova Scotia not only adopt a similar framework but enhance it by encouraging the use of integrated battery storage. By permitting a 1,200-watt system to feed into a home circuit 24 hours a day via a battery, a household could theoretically self-consume up to 28.8 kWh of daily solar production (1,200 watts x 24 hours). This approach would maximize self-consumption, reduce evening strain on the grid, and allow any true excess to be fed back to Nova Scotia Power, benefiting all ratepayers.

Implementing a clear policy for balcony solar would be a powerful step towards energy democracy in our province. It would provide residents with a tangible way to lower their energy bills, reduce their carbon footprint, and contribute to a more stable and distributed electrical grid.

Thank you for your time and consideration of this important matter. I am hopeful that Nova Scotia can become a Canadian leader in citizen-led renewable energy.

Sincerely,

[Your Name]

[Your Address/Community]

[Your Contact Information]