Siemens LOGO! 8 kWh Pulse Metering: Programming Guide

Overview

Implementing energy metering on a Siemens LOGO! 8 requires a deterministic mapping between the meter's pulse output specification and the PLC's available function blocks. The pulse-output kWh meter used as the reference in this guide is a three-phase utility-grade instrument with the following primary output:

• Primary output pulse constant: 1000 imp/MWh
• Primary output pulse weight: 1 kWh per impulse
• Maximum output pulse frequency: 0.4 Hz
• Output pulse length: 80 ms

Typical site demand seen at the meter: 197 kW to 534 kW, with monthly consumption between 32,000 kWh and 79,577 kWh. The meter pulses must be wired to a digital input on the LOGO! base module (or an expansion DM8/DM16 digital module) that is configured for high-speed counting, and processed in LOGO! Soft Comfort (LSC).

This guide covers three implementation methods:

1. Threshold trigger for instantaneous power
2. Stopwatch for instantaneous power (preferred for low pulse rates)
3. Counter chain for kWh and MWh accumulation

It also covers the 1 / 5 / 15 / 30 / 60 minute averaging windows required for the LOGO! Web View, and threshold alarms for demand monitoring.

Prerequisites

Pulse Output Specification Decoded

The meter's two specifications describe the same physical signal from different angles and must be reconciled before any block parameter is set:

Both "1000 imp/MWh" and "1 kWh/imp" are arithmetically identical (1000 × 1 kWh = 1 MWh), so the counter implementation is identical: one rising edge = one kWh unit increment. This is the simplest pulse ratio to work with in LOGO! because no prescale counter is required. If the meter were specified as 500 imp/kWh, a divide-by-500 counter with auto-reset would be needed before the kWh register; the approach is described in Counter Chain for Higher-Resolution Meters below.

Power Range and Pulse Interval Analysis

For a 1 kWh/imp meter, the relationship between inter-pulse time and instantaneous power is:

P (kW) = 3600 / dt (seconds)
dt (seconds) = 3600 / P (kW)

Applied to the observed site demand envelope:

The long pulse intervals at low load are exactly why the threshold trigger must be tuned: a 1 s gate time would miss the 0.054 Hz rate entirely, because the meter may produce only one pulse every 18.65 s. A 30 s gate time can capture at most one pulse per gate at minimum load, which is the binding design constraint that drives the stopwatch method preferred for low pulse rates.

Method 1: Threshold Trigger for Power

The LOGO! Threshold Trigger (Block ID Threshold Trigger) counts edges over a programmable gate time and outputs the count, which is then scaled to engineering units by an arithmetic block. The relationship is:

Power (kW) = (Pulses in gate) x (kWh per pulse) / (gate time in hours)
           = (Pulses in gate) x 1 kWh / (gate time in hours)
           = (Pulses in gate) x 3600 / (gate time in seconds)

Configuration for 1 s gate time (default):

• Threshold Trigger B003
  • On = I1 (meter pulse input)
  • Gate time (GT) = 1.00 s (P2)
  • On delay / off delay: leave at 0
• Arithmetic Trigger B012
  • Input 1: Par (Q of B003 / 10 ms pulses) — e.g. 0-1000 Hz if P2=0.01 s
  • Operator: x
  • Input 2: 3600 (if P2=1 s) or 360 (if P2=10 s) or 36 (if P2=100 s)
  • Result: instantaneous power in kW

Gate time selection matrix:

Method 2: Stopwatch for Instantaneous Power

For low pulse rates the threshold trigger produces stale, steppy output because it requires multiple pulses per gate to converge. The Stopwatch block (rising-edge triggered) measures the time between two consecutive pulses, which gives true instantaneous power from a single pulse pair. The block outputs the elapsed time in 10 ms increments on output ET.

Wiring in LSC:

1. Place a Stopwatch block; set trigger source to I1 (meter pulse).
2. Place an AND block to re-arm the stopwatch: inputs are Q (latch of last measurement) and I1 inverted. OR connect the stopwatch's R (reset) input directly to I1; in this topology the block starts a new measurement on every rising edge and exposes the previous result on ET for the duration of the next pulse interval.
3. Place an Arithmetic block: Operator = ÷, Input 1 = constant 360000, Input 2 = ET (10 ms units). The output is kW because:
   360000 / (ET x 0.01 s) = 3,600,000 / ET = 3600/dt = kW

Power_kW = 360000 / ET    (where ET is the Stopwatch elapsed-time register in 10 ms units)

Verification points:

• At 197 kW: ET should converge to 360000 / 197 = 1827 (i.e. 18.27 s measured by the block).
• At 534 kW: ET should converge to 360000 / 534 = 674 (6.74 s).
• At 1440 kW: ET = 250 (2.5 s) — the absolute floor of the meter's output range.

kWh Accumulation with Counter Chain

The total kWh register is a simple Up counter driven directly by the meter pulse. The base counter range on LOGO! 8 is 0 to 999,999. With a 79,577 kWh/month peak and full site history, the counter will roll over in under a year. Two options exist:

Option A: 32-bit counter (LOGO! 8.2+)

LOGO! 8.2 firmware (FW 1.82.01 and later) exposes counters with a 32-bit value range, configurable in the counter block's Range parameter. This is the cleanest solution if the firmware is current.

Option B: kWh / MWh cascade (all firmware)

1. Counter Cnt1 (kWh register): counts every pulse of I1; range 0 - 999999.
2. Counter Cnt2 (MWh register): triggered by the carry-out of Cnt1, i.e. on a transition from 999999 → 0. This is achieved with a comparator block watching Cnt1's Q for the value 999999 and the previous scan value 999998; on the next pulse the carry increments Cnt2.

Counter chain for higher-resolution meters (e.g. 500 imp/kWh)

Counter Cnt0 (impulses): 0-500, auto-reset on reaching 500
Counter Cnt1 (kWh):      increments by 1 on every Cnt0 reset edge
Counter Cnt2 (MWh):      increments by 1 on every Cnt1 reset edge (every 1000 kWh)

For 1 kWh/imp meters, Cnt0 is unnecessary and the kWh register is wired directly to I1.

Time-Window Averaging (1 / 5 / 15 / 30 / 60 min)

LOGO! does not expose a native sliding-window average block, but the same effect is built from:

• A clock-pulse generator (e.g. Hour counter with 1-min, 5-min, 15-min, 30-min, 60-min periods) generating a WindowTick flag.
• A snapshot of the kWh counter captured at each tick (transfer the current Cnt1.Q to a holding word kWh_latch).
• A second snapshot kWh_prev taken at the previous tick.
• Arithmetic: Window_kWh = kWh_latch - kWh_prev.
• Average power: Window_kW = Window_kWh / Window_hours where Window_hours = 1/60, 5/60, 0.25, 0.5, or 1.

Block diagram for one window

Hour counter (GT = 1 min)  ---tick--->  AND (with NOT reset)  ---> Move: kWh_curr → kWh_prev
                                                                  AND
                                                                  Move: Cnt1.Q → kWh_curr
                                                                  Subtract: kWh_curr - kWh_prev → kWh_window
                                                                  Divide: kWh_window / 0.01667 → kW_1min

Repeat the structure five times, parameterizing GT and the divisor as shown below. The latch moves must execute in a fixed order: first capture kWh_curr into kWh_prev, then capture Cnt1.Q into kWh_curr. The reverse order introduces a 1-tick error.

Alarm Implementation

Two complementary alarm strategies are recommended:

1. Sustained high demand alarm: Comparators (Analog Threshold Trigger or Comparator block) on the time-window kW tags. A 15 min demand > 450 kW is a typical threshold for this site. Wire the comparator output to a digital output or to a text-message block; on LOGO! 8.3, alarms can also trigger an e-mail through the integrated SMTP client.
2. Zero-demand watchdog: A separate timer (On-delay or Watchdog) reset by every meter pulse. If no pulse arrives within a configurable dead-time (e.g. 60 s — i.e. less than 60 kW of demand for 1 kWh/imp meters), raise a "consumption has dropped to < 60 kW" or "meter failure" alarm. The dead-time must be set longer than the worst-case pulse interval for the alarm threshold.

On-delay:        I1 (pulse) ---|TRG|--Q--> R (reset of on-delay)  (re-armed on every pulse)
                  preset 60 s (alarm if 60 s elapsed without a pulse)

LOGO! Web View Configuration

1. In LSC, open Tools → Web Editor and create a status page for energy.
2. Drag a numeric field onto the page; bind it to the variable Cnt1.Q for live kWh, Cnt2.Q for MWh, and the five VW200-VW208 tags for the windowed kW values.
3. Set update rate to 1 s (LOGO! 8 limit for Web View polling) and enable read-only access for the operator role.
4. Add a bar graph bound to VW204 (15 min demand) with a high alarm color at 450 kW; this gives the operator a real-time demand indicator.
5. Configure the LOGO! base module IP address under Network Settings; reserve an address in the plant DHCP range and enable Web server access.

Block Parameter Reference

Verification and Commissioning Steps

1. Pulse simulation in LSC: Use a Pulse Generator block (B001) configured for 1 Hz with 50% duty and connect it to I1. Power values should converge to 3600 kW. Disconnect after testing.
2. Field cross-check: Compare the LOGO! Web View kWh value against the meter's mechanical or LCD register over a 1-hour window. Tolerance: ± 1 kWh (one pulse).
3. Stopwatch sanity check: Read ET in LSC online mode; verify it falls in the band [250, 1827] for the expected power range [197, 534] kW.
4. Window average verification: Inject a known 100 kW load (e.g. a 100 kW heater) and confirm the 1 min, 5 min, 15 min values all converge to 100 kW within one full window period after the load is applied.
5. Alarm test: Force the comparator input to 500 kW in LSC simulation; the alarm output must change state and be visible in Web View.
6. Counter roll test: In LSC simulation, pre-load Cnt1 with 999,998 and inject two pulses; verify Cnt2 increments by 1 and Cnt1 wraps to 1.
7. Web View refresh: Open Web View in two browsers and confirm independent polling of all five kW tags at the expected 1 Hz refresh rate.

Troubleshooting Matrix

Field-Proven Notes

• Pulse weight vs pulse constant: The first meter used in prototyping was 1 imp/kWh (i.e. 1000 imp/MWh with 1 kWh/imp specification — same as this site, only a 1:1 mapping). Meters with 500 imp/kWh, 1000 imp/kWh, or 10,000 imp/kWh are common in retrofit installs. The 1000 imp/kWh class requires a divide-by-1000 counter before the kWh register; the 10,000 imp/kWh class also requires a divide-by-10 then divide-by-1000, or a single divide-by-10,000 counter. Always reconcile both numbers on the meter nameplate before sizing the counter chain.
• Stopwatch vs counter on a single pulse: The stopwatch output ET cannot be wired directly to a counter's Cnt input as a pulse source — ET is a value, not an edge. To convert ET to a kWh pulse train, use a comparator: when ET crosses a preset (e.g. when a new measurement has been latched), generate a one-cycle flag and feed that to the kWh counter. This pattern is the standard way to integrate the stopwatch's continuous measurement into a discrete energy register.
• Gate-time drift in threshold trigger: When the threshold trigger is used as a frequency-to-power converter, the displayed power always lags real demand by exactly one gate time. On a 20 s gate this is a 20 s lag — unacceptable for some peak-shaving applications. The stopwatch method has a single-pulse lag of dt seconds (6-19 s at this site), which can be shorter than the threshold trigger's gate-time lag at low load.
• LOGO! program memory: The 1/5/15/30/60 min window structure, plus the stopwatch arithmetic, threshold trigger, and counter chain, consumes roughly 60-80 function blocks. LOGO! 8 base modules support 200/400 blocks depending on variant; expansion is rarely required for this scope. The five window structures dominate the block count.

FAQ