Modbus 32-Bit Integer Data Types: Registers, Byte Order, and Scaling Explained

Modbus registers are 16 bits. But energy meters report kilowatt-hours as 32-bit values, drives report encoder positions as 32-bit values, and flow totals overflow a single register quickly. Every one of them uses two consecutive Modbus registers for one value — and the way those two registers are ordered and interpreted is where engineers lose hours.

This guide covers 32-bit integers in Modbus: the register-pair layout, word order (high word first vs low word first), signed vs unsigned interpretation, scaling and offset conventions, and the classic bugs that produce values like 4,294,967,295 instead of −1.

Why 32-Bit Values Need Two Registers

A Modbus holding register is a 16-bit unsigned integer: 0 to 65,535. That's plenty for a voltage reading, but it caps at 65,535 for anything else. A 32-bit value spans 0 to 4,294,967,295 (unsigned) — which needs two registers.

Register capacity
───────────────
1 register  = 16 bits = 0 .. 65,535
2 registers = 32 bits = 0 .. 4,294,967,295 (unsigned)
                        −2,147,483,648 .. 2,147,483,647 (signed)

The two registers are always consecutive — for example, address 40001 and 40002. The device manual will say something like "Energy Total (U32): Registers 40001–40002."

Word Order: High Word First vs Low Word First

Once you know the value spans two registers, the next question is which register holds which half. There are two conventions:

Convention	First register	Second register	Common in
High word first (big-endian words)	Most significant 16 bits	Least significant 16 bits	Most European meters, Schneider, many drives
Low word first (little-endian words)	Least significant 16 bits	Most significant 16 bits	Some PLC brands and PC-based tools

Here's a worked example. A meter reports 1,500,000 Wh. In hex that's 0x0016E360, split across the word boundary:

Value: 1,500,000 decimal
Hex:   0x0016E360

High word (most significant): 0x0016  = 22
Low word  (least significant): 0xE360  = 58,208

High word first (ABCD):
  Register 40001 = 0x0016
  Register 40002 = 0xE360
  → 0x0016E360 = 1,500,000 ✓

Low word first (CDAB):
  Register 40001 = 0xE360
  Register 40002 = 0x0016
  → 0xE3600016 = 3,813,736,470 ✗ (huge wrong value)

The same two registers, read in the wrong order, turn a sensible 1.5 MWh reading into 3.8 billion. That's the signature of a word-order mismatch: values that are either absurdly large or absurdly small.

Signed vs Unsigned: The −1 vs 4,294,967,295 Trap

The same 32 bits can be read as unsigned (0 to 4.29 billion) or signed (−2.1 billion to +2.1 billion). The meter doesn't tell you which — the manual does.

Bits: 1111 1111 1111 1111 1111 1111 1111 1111

As unsigned 32-bit: 4,294,967,295
As signed 32-bit:   −1

Bits: 1000 0000 0000 0000 0000 0000 0000 0000

As unsigned: 2,147,483,648
As signed:   −2,147,483,648

Common failure modes:

• A temperature that should be −5 °C reads 4,294,967,291. That's a signed value being decoded as unsigned.
• A totalizer that reads 4,294,967,295 and never increments. Either it's −1 (signed) or it genuinely overflowed — check which.
• Power factor readings jumping between −1 and +1 with huge values in between. Likely a signed/unsigned mismatch on a value stored as a signed scaled integer.

Scaling and Offset: The "Why Is It ×100?" Question

Most Modbus devices don't transmit raw engineering units. They transmit a scaled integer. The manual specifies a scale factor and sometimes an offset:

Raw value × scale + offset = engineering value

Voltage meter:
  Raw register pair = 23,000
  Scale = 0.01
  → 23,000 × 0.01 = 230.0 V

Energy meter:
  Raw = 1,500,000
  Scale = 0.001
  → 1,500 kWh

Temperature sensor (offset example):
  Raw = 250, scale = 0.1, offset = −40
  → 250 × 0.1 − 40 = −15 °C

Scale factors to watch for:

Typical scale	What it means	Example raw → real
0.001	Milli-units (kWh, kW)	1,500,000 → 1,500.0
0.01	Centi-units (volts, amps)	23,000 → 230.0
0.1	Deci-units (temps, power factor ×10)	250 → 25.0
1 (no scale)	Whole units (counts, totals)	42 → 42

When a value "looks right but off by a factor of 10/100/1000," that's a scale factor problem, not a byte order problem. Byte order errors produce wildly wrong values; scale errors produce recognizable-but-wrong ones.

Register Pairs and How to Read Them

Reading a 32-bit value as a master is just an FC03 read of two consecutive registers:

FC03 request:  Slave 01, start 40000 (0x0000), quantity 2
Request frame: 01 03 00 00 00 02 C4 0B

FC03 response:  Slave 01, 4 data bytes
Response frame: 01 03 04 00 16 E3 60 CRC

Decoded as high-word-first unsigned:
  Register 0 = 0x0016, Register 1 = 0xE360
  Value = 1,500,000

Two gotchas:

• Alignment. The pair must start at an even offset in most devices (register 0–1, 2–3, 4–5…). Reading 32-bit values at odd boundaries is undefined and device-specific.
• Quantity. FC03 quantity is in registers, so a 32-bit read requests 2 registers, a 64-bit read requests 4. The response data length tells you how many bytes came back.

A good Modbus poll tool handles pair alignment, word order, and signed/unsigned decoding for you — you just tell it the type (U32/S32) and the order, and it formats registers 40001–40002 as one value.

64-Bit Values and the Same Principles

Energy totalizers and gas meters sometimes use 64-bit integers (four registers). The same rules extend: four consecutive registers, ordered by word, with signed/unsigned and scale. The failure modes are identical, just with more bits to scramble — a wrong word order on a 64-bit value produces astronomically wrong numbers that are easy to spot.

Support for 64-bit types varies by device; when a manual says "INT64" or "U64," read four registers and apply the same reasoning.

How to Debug a 32-Bit Reading That Looks Wrong

Step-by-step, in the order that finds the bug fastest:

1. Read the raw registers. Get the two hex values before any interpretation — most tools show this.
2. Check signed vs unsigned first. If you see 4,294,967,295 or 2,147,483,648, flip the interpretation.
3. Check word order. Assemble both high-word-first and low-word-first; one should be a plausible value.
4. Apply the scale from the manual. If the raw value is plausible but ten times too big/small, it's scaling.
5. Verify against a known state. Put the device into a known condition (0, full-scale, a calibration value) and confirm the reading tracks.
6. Document the working combo — type, word order, byte order, scale — in your project notes so the next engineer doesn't redo the archaeology.

The Bottom Line

Modbus 32-bit integers span two consecutive registers, and every device picks its own word order, signedness, and scale. High-word-first unsigned is the most common default, but "common" is not "guaranteed" — the manual is the source of truth.

The three classic failure signatures: absurdly large values (word order), exactly 4,294,967,295 or 2,147,483,648 (signed/unsigned), and recognizable-but-wrong magnitudes (scale). Each has a distinct fix, and none of them require touching the hardware.

With a poll tool that decodes register pairs as typed values, most of this becomes a dropdown instead of a hex-decoding session.

Keep reading

Comparison Modbus Poll vs Modscan vs Modbus Slave: Which Master Tool to Use August 11, 2026 Comparison Modbus TCP vs PROFINET: Choosing the Right Industrial Ethernet August 11, 2026 How-To How to Read Modbus Holding Registers (FC03): A Practical Walkthrough August 11, 2026