from decimal import Decimal
import struct

def decode_dlms_register(raw_val_int, scaler_byte, unit_enum):
    # 1. Decode Scaler as Signed 8-bit Integer
    scaler = struct.unpack('b', bytes([scaler_byte]))[0]
    
    # 2. Use Decimal Arithmetic to prevent Float32 precision loss
    raw_dec = Decimal(str(raw_val_int))
    scale_factor = Decimal(10) ** Decimal(scaler)
    physical_value = raw_dec * scale_factor
    
    print(f"[+] Scaler: {scaler}, Scale Factor: 10^{scaler}")
    print(f"[+] Exact Physical Value: {physical_value} (Unit Enum: {unit_enum})")
    return physical_value

# Test Case 1: L1 Current (5230 mA, Scaler 0xFD = -3)
assert decode_dlms_register(5230, 0xFD, 33) == Decimal("5.230")

# Test Case 2: Cumulative Energy (20,000,000 Wh, Scaler 0x00 = 0)
assert decode_dlms_register(20000000, 0x00, 30) == Decimal("20000000")

Summary Checklist for Register Parsing:

1. Signed Scaler: Always unpack Tag 0x0F as signed 8-bit integer (struct.unpack('b')).
2. Decimal Arithmetic: Use Decimal or float64 to prevent mantissa truncation on high cumulative energy registers (Blue Book Section 4.3.3).
3. Unit Mapping: Map unit enums to standard SI physical dimensions.

00 01 00 01 00 01 00 12 C4 01 C1 00 02 02 06 01 31 2D 00 02 02 0F 00 16 1E

• 06 01 31 2D 00: Double-Long-Unsigned 20,000,000 Wh (20,000 kWh)
• 0F 00: Scaler 0 ($10^0$)
• 16 1E: Unit 30 [Wh]

# Compliant Signed Int8 Unpacking:
import struct

def parse_scaler(scaler_byte):
    # struct.unpack('b') reads signed 8-bit integer (-128 to +127)
    return struct.unpack('b', bytes([scaler_byte]))[0]

# Testing with 0xFD:
scaler = parse_scaler(0xFD)
print(f"Parsed Scaler: {scaler}") # Outputs: -3

Notice that Voltage and Current scalers are almost ALWAYS negative!

The Correct Datatype Standard:

In all billing and data ingestion pipelines:

1. Never use float (32-bit) for energy quantities;
2. Use Double (float64: 53-bit mantissa $\implies 9 \times 10^{15}$ exact integers) or Fixed-Point Decimal (Python decimal.Decimal, Java BigDecimal);
3. Perform all aggregation using raw integer arithmetic before applying the scaler.

Smart meters measure cumulative energy in Watt-hours (Wh) or milli-Watt-hours as a 64-bit integer (Double-Long-Unsigned 0x06 or Long64-Unsigned 0x15).

When a meter accumulates $20{,}000{,}000\text{ Wh}$ ($20{,}000\text{ kWh}$):

• In IEEE 754 Single Precision (float32), the significand/mantissa is only 24 bits (approx 7.22 decimal digits of precision).
• Maximum exact integer in float32: $2^{24} = 16{,}777{,}216$.

Beyond 16,777,216 Wh, float32 cannot represent individual 1 Wh increments! Adding $1\text{ Wh}$ to $20{,}000{,}000\text{ Wh}$ in float32 results in exact zero change:
$$20{,}000{,}000.0f + 1.0f = 20{,}000{,}000.0f$$
Over time, thousands of kilowatt-hours are lost to rounding!

Per DLMS Blue Book Ed. 17 Section 4.3.3 (Register Interface Class 3) and IEC 62056-62 Table 12:
Attribute 3 scaler_unit is defined as:

ScalerUnit ::= Structure {
  scaler: Integer8 (Tag 0x0F), // SIGNED 8-bit integer!
  unit:   Enum     (Tag 0x16)
}

In two's complement 8-bit signed arithmetic:
0xFD is $-3$ ($253 - 256 = -3$).
$$\text{Physical Value} = \text{Raw Value} \times 10^{\text{scaler}} = 5230 \times 10^{-3} = 5.230\text{ A}$$

If a parser incorrectly reads Tag 0x0F as an Unsigned Byte (uint8), it treats 0xFD as $+253$, calculating:
$$\text{Corrupted Value} = 5230 \times 10^{+253} = 5.23 \times 10^{256}\text{ A}!$$