How Niagara Point Types Translate to Modbus Register Types
Boolean points map to coils, discrete inputs or register bits; Numeric points to input or holding registers; Enum points to registers holding states. Writable points need writable tables.
Every Modbus integration in Niagara comes down to choosing the right proxy point type and pointing it at the right Modbus table, address and data type. Get it right and values are correct first time; get it wrong and you see exception codes, read-only points that should be writable, or numbers that look plausible but are not. This guide maps Niagara's point types to Modbus's data tables, explains data types and bit addressing, and gives worked examples.
The two models side by side
Niagara has four basic point types, each in a read-only and a writable form:
| Niagara point | Holds | Read-only form | Writable form |
|---|---|---|---|
| Boolean | true/false | BooleanPoint | BooleanWritable |
| Numeric | number | NumericPoint | NumericWritable |
| Enum | one of a set of states | EnumPoint | EnumWritable |
| String | text | StringPoint | StringWritable |
Modbus has four data tables:
| Modbus table | Size | Access | Read function | Write function |
|---|---|---|---|---|
| Coils | 1 bit | Read/write | 01 | 05 (single), 15 (multiple) |
| Discrete inputs | 1 bit | Read only | 02 | n/a |
| Input registers | 16 bit | Read only | 04 | n/a |
| Holding registers | 16 bit | Read/write | 03 | 06 (single), 16 (multiple) |
In the Niagara Modbus driver, each proxy point's Modbus proxy extension specifies the table (register type), the address, the data type and, where relevant, the bit.
Mapping table
| What the device offers | Niagara point type | Notes |
|---|---|---|
| Coil (read/write bit) | BooleanWritable (or BooleanPoint if you only read it) | Start/stop commands, enable flags |
| Discrete input (read-only bit) | BooleanPoint | Status and alarm bits |
| A single bit inside a holding or input register | BooleanPoint, or BooleanWritable for a holding register bit | Set the bit number (0–15); common for status words |
| Input register (16-bit value) | NumericPoint | Measurements |
| Holding register (16-bit value) | NumericWritable for setpoints; NumericPoint if read-only in practice | Setpoints and configuration |
| Two registers (32-bit integer or float) | NumericPoint / NumericWritable with a 32-bit data type | Energy, power, flow |
| Four registers (64-bit) | NumericPoint with a 64-bit type if supported, otherwise combine | See reading 64-bit registers |
| Register holding a mode or state code | EnumPoint / EnumWritable with a facet range | Operating modes, fault codes |
| Consecutive registers holding ASCII text | StringPoint | Serial numbers, model names |
Data types for numeric points
Choose the data type that matches the register map:
| Data type | Registers | Notes |
|---|---|---|
| Unsigned 16-bit integer | 1 | 0 to 65,535 |
| Signed 16-bit integer | 1 | −32,768 to 32,767; check for negative temperatures |
| Unsigned 32-bit integer (long) | 2 | Counters, totals |
| Signed 32-bit integer | 2 | |
| 32-bit float | 2 | Most meter measurements |
| 64-bit types | 4 | Large totals; driver support varies |
Word and byte order
For 32-bit and 64-bit values, the device decides which register holds the most significant word, and sometimes swaps bytes too. The Niagara Modbus device has settings for word/byte order of floats and longs (the property names vary slightly between versions). If a 32-bit float reads as nonsense, change the order setting rather than the address.
Scaling and units
Many devices send scaled integers: a temperature of 21.5 °C as 215. Use the point's conversion (scale and offset) to turn the raw value into engineering units, and set facets (units and precision) so the value displays correctly everywhere.
Bits in registers: status words
Devices often pack many statuses into one register, for example bit 0 "running", bit 1 "fault", bit 2 "remote mode". To read them:
- Create a BooleanPoint for each bit you need.
- Set the register type (holding or input), the register address and the bit number (0 for the least significant bit).
- Check the register map's bit numbering convention: most count from 0 at the least significant bit, but some count from 1.
Group the points so the register is read once per poll, not once per bit.
Writing a single bit of a holding register is risky: the device may require the whole register to be written, which can overwrite other bits. If the device offers coils for commands, prefer them; otherwise read the whole register, change the bit, and write the whole register back, ideally in a Program object, and only if the device's documentation allows it.
Enum points for modes and fault codes
Use an EnumPoint when a register holds a code with a meaning, for example 0 = Off, 1 = Heat, 2 = Cool, 3 = Auto. Define a facet range that maps each number to its text. Operators then see "Cool" instead of "2", alarm extensions can trigger on specific states, and histories record meaningful values.
For fault codes, an EnumPoint with the manufacturer's fault table turns a number into a message engineers understand without opening the manual.
Writable points: what to check
- The value must be in a writable table (coils or holding registers). Writing to an input register or discrete input returns exception 01 or 02.
- Some devices accept only function 16 (write multiple registers) even for a single register. If writes fail with exception 01, check the driver's option to force multi-register writes.
- Check the range the device accepts; out-of-range writes return exception 03.
- Configure the tuning policy (min write time, write on up) to avoid excessive writes, particularly for settings stored in EEPROM.
- Use Niagara's priority array on writable points so overrides and schedules interact predictably.
Worked examples
Heat pump: run command and status
| Value | Register map | Niagara point |
|---|---|---|
| Run command | Coil 1 | BooleanWritable, coil, address 0 |
| Running | Discrete input 1 | BooleanPoint, discrete input, address 0 |
| Flow temperature | Input register 30010, signed, ×0.1 °C | NumericPoint, input register, address 9, signed 16-bit, scale 0.1 |
| Flow setpoint | Holding register 40020, ×0.1 °C | NumericWritable, holding register, address 19, scale 0.1 |
| Operating mode | Holding register 40030: 0 Off, 1 Heat, 2 Cool | EnumWritable with facet range |
| Fault word | Input register 30050, bit 3 = high pressure | BooleanPoint, input register, address 49, bit 3 |
Energy meter
| Value | Register map | Niagara point |
|---|---|---|
| Voltage L1 | 30001–30002, float | NumericPoint, input register, address 0, 32-bit float |
| Total kWh | 30073–30074, float | NumericPoint, input register, address 72, 32-bit float |
In both examples, note the conversion from the register map's 1-based register numbers to 0-based protocol addresses. Some Niagara address formats accept the "Modbus" style (40001) directly; check the address format setting on the proxy extension and be consistent.
Reading a register map: a quick method
Register maps vary widely in quality and layout. A reliable way to work through one:
- Find the addressing convention. Look for a note saying whether addresses are 0-based or 1-based, decimal or hexadecimal. If there is none, assume the listed numbers are register numbers (1-based) and test.
- Identify the function codes the device supports for each block. If the map lists "function 03", those values are holding registers; "function 04", input registers.
- Note data types and word order for every multi-register value.
- Note scaling and units, including signed values.
- Pick a test value you can see on the device's display, such as a voltage or temperature.
- Configure one point, test it, and only then configure the rest.
Keep your annotated copy of the register map with the site documentation.
Pitfalls by device type
| Device type | Common pitfall |
|---|---|
| Energy meters | 32-bit floats with unusual word order; totals in Wh vs kWh; separate registers for import and export |
| Variable speed drives | Commands in a control word with specific bit sequences; speed reference as a percentage scaled to 10,000 or 16,384 |
| Boilers and heat pumps | Values available only through an optional Modbus interface card; signed temperatures; setpoint limits enforced by the device |
| Chillers | Large register maps; read-only unless a remote mode is enabled on the chiller |
| I/O modules | Inputs and outputs in separate tables; configuration registers that should not be written routinely |
| Generators and UPS | Alarm and status bits packed into words; vendor-specific scaling |
For drives in particular, follow the manufacturer's control word sequence exactly. Many drives need a specific sequence of bits (for example ready, enable, run) before they respond, and writing the wrong value can trip them.
Building reusable device templates
Once you have mapped a device model correctly, do not repeat the work:
- Configure one device completely: points, data types, scaling, facets, tags, tuning policies, alarm and history extensions.
- Test every point against the device.
- Save the device as a template or into your own palette.
- For each further device of the same model, add the template and change only the address (unit ID or IP).
Templates make large meter or plant integrations faster and consistent, and they carry tags so hierarchies, graphics and analytics work automatically. Keep a library of templates per manufacturer and model, with the firmware version they were tested against, because register maps occasionally change between firmware versions.
Choosing read-only vs writable points
Not everything in a holding register should be writable from the BMS:
| Value | Recommended point | Reason |
|---|---|---|
| Measured values in holding registers | NumericPoint (read-only) | Prevents accidental writes to values that should not change |
| Operator setpoints | NumericWritable | Operators adjust them from graphics and schedules |
| Commissioning or configuration parameters | Read-only in normal use | Changing them can disable the device; change deliberately with the manufacturer's tool |
| Enable or run commands | BooleanWritable on a coil | Clear command semantics |
| Reset or acknowledge commands | Writable, used through an action | Often pulse-type; check the device's behaviour |
Using read-only points wherever possible reduces risk and network writes.
Troubleshooting
| Symptom | Likely cause |
|---|---|
| Exception 02 (illegal data address) | Wrong table or address offset |
| Exception 01 (illegal function) | Writing to a read-only table, or device needs function 16 |
| Value off by a register | 0-based vs 1-based addressing |
| Huge or tiny float values | Word or byte order |
| Negative temperatures read as 6,550 | Unsigned type used for a signed value |
| Value 10× or 100× too big | Missing scale |
| Booleans for the wrong status | Bit numbering convention (0 vs 1 based) |
Frequently asked questions
Which Niagara point type should I use for a Modbus coil?
A BooleanWritable if you need to command it, or a BooleanPoint if you only read it.
Can a Niagara Boolean point read a bit inside a holding register?
Yes. Set the register type and address, then the bit number in the Modbus proxy extension.
Why can't I write to my Modbus point?
The value is in a read-only table (input registers or discrete inputs), the device needs a different write function, or the value is out of range.
How do I show a Modbus mode code as text?
Use an EnumPoint or EnumWritable with a facet range mapping each code to its description.
What data type should I use for a Modbus temperature?
Follow the register map: usually a signed 16-bit integer with a scale such as 0.1, or a 32-bit float.
Can one Niagara point read a 32-bit float from two registers?
Yes. Choose a 32-bit float data type on a NumericPoint with the first register's address, and set the device's word order to match the register map.
What are facets on a Modbus point?
Facets define how a value is displayed and interpreted, such as units, precision and, for Enum points, the text for each state.
Do I need separate points for each bit in a status word?
Yes, one BooleanPoint per bit you need, all pointing at the same register with different bit numbers.
What address format should I use in Niagara Modbus points?
Use the format your team standardises on, and set the proxy extension's address format to match. Mixing 0-based addresses and 1-based register numbers within a station is the most common source of off-by-one errors.
Should I use NumericWritable for every holding register?
No. Use writable points only for values the BMS should change, such as setpoints. Read-only points protect configuration values from accidental writes.
Need help from a Niagara engineer?
If this guide has not solved the problem, contact the Tyrrell Products technical team on 01942 732819 or [email protected]. Tell us the controller or host type, its Niagara version and what you have already tried, and we will help you get the system running.