# Module 8: Scaling & Engineering Meaning

> Raw register → engineering value with units, scale, and a sanity check at every step.

**Phase:** Addressing & Data Meaning  
**Estimated time:** 9 min  
**Release status:** Published  
**Content version:** 1.0.0  
**Source:** https://learnmodbus.studioseventeen.io/lesson/scaling-engineering-meaning

## What you'll be able to do
- Convert a raw register to engineering units with the correct sign, scale, and unit.
- Decode bitfields and enums from a status word.
- Use sentinel values to mark a reading invalid instead of displaying nonsense.

## Three things people get wrong
1. **Scaling before checking signedness.** Apply the type rule (S16/S32) first, then divide by 10. Otherwise -1 becomes 6553.5.
2. **Showing sentinels as values.** 0x7FFF / 0x8000 / 0xFFFF are often 'invalid' markers — gate them before they reach a dashboard.
3. **Forgetting the unit.** A number without a unit is a guess. Carry the unit through every transformation.

## From the field
**The dashboard that scaled twice**

A team multiplied by 0.1 in the gateway and another 0.1 in the historian. Voltages displayed as 2.4 V instead of 240 V. The bug only showed up when an operator tried to plot trends against the utility bill.

## References
- [Modbus Application Protocol V1.1b3](https://www.modbus.org/file/secure/modbusprotocolspecification.pdf) — Modbus does not standardize scaling — entirely vendor convention.

## Lesson

# Module 8 Lesson: Scaling And Engineering Meaning
## Learner Outcome

By the end of this module, learners can convert raw Modbus values into engineering telemetry with explicit type, scale, offset, unit, sign convention, sentinel handling, quality, and state context. They can also decode simple status words and enum values without treating map-specific meanings as official Modbus behavior.

## Key Concepts

- Modbus transports raw bits and register data. The register map supplies engineering meaning.
- Scaling can be written as `/10`, `/100`, `*0.1`, a decimal-position register, an offset formula, or a profile-specific convention.
- Units and sign conventions are part of the integration contract. `W`, `kW`, `Hz`, `centi-Hz`, `deg C`, import/export direction, and charge/discharge direction can vary by device.
- Sentinel values are raw values that mean invalid, unavailable, overflow, not installed, stale, or sensor fault.
- Status words, alarm words, command words, and enums must be decoded from the source map and verified against known safe states.
- A professional integration preserves raw value, decoded value, unit, quality, source evidence, and unresolved assumptions during commissioning.

## Key Terms

- Scale: the source-map rule that converts raw value into engineering value.
- Engineering unit: the unit that gives a decoded value meaning, such as volts, hertz, or degrees C.
- Sentinel: a special raw value that means invalid, unavailable, overrange, or another non-measurement state.
- Enum: a numeric code mapped to named states.
- Bitfield: a register where individual bits carry separate meanings.
- Quality: evidence that a value is valid, stale, invalid, estimated, or context-dependent.
- Freshness: whether the value is current enough to use.

## Source-Grounded Explanation

A Modbus response can return valid bytes while the displayed telemetry is still wrong. The response does not carry a unit label, scale factor, sign convention, sentinel table, or quality flag. Those meanings come from vendor documentation, a device profile, a synthetic course map, or verified behavior.

The basic teaching model is:

```text
engineering value = decoded raw value * scale + offset
```

That formula is useful, but maps may express it in different ways. A row may say `/10`, `0.1`, `scale = -1`, `decimal position = 2`, or `value = raw / 100`. If the map does not say whether an offset is applied before or after scaling, mark the row `Needs verification` and test against a known display or simulator.

### Scaling Examples

| Source Row | Raw Bytes | Raw Value | Meaning |
|---|---:|---:|---|
| `line_voltage_l1_l2`, `U16`, `/10 V` | `09 C4` | `2500` | `250.0 V` |
| `ac_frequency`, `U16`, `/100 Hz` | `17 70` | `6000` | `60.00 Hz` |
| `battery_power`, `S32`, `/10 kW` | `FF FF F6 3C` | `-2500` | `-250.0 kW` in the synthetic sign convention |

Synthetic sign convention for this lesson: negative `battery_power` means charging/import into the battery; positive means discharging/export from the battery. This is scoped to the synthetic course map. It is not a universal Modbus rule or a universal battery-vendor convention.

### Sentinels And Quality

A sentinel is a raw value that should not be displayed as a real measurement.

Example:

| Field | Value |
|---|---|
| Parameter | Lab temperature reading |
| Type | signed 16-bit |
| Scale/unit | `/10 deg C` |
| Sentinel | `0x7FFF` means invalid/unavailable |
| Response | `03 02 7F FF` |

Wrong display:

```text
32767 / 10 = 3276.7 deg C
```

Correct telemetry:

```text
temperature.raw = 0x7FFF
temperature.value = null
temperature.unit = deg C
temperature.quality = invalid
temperature.reason = synthetic sentinel: unavailable
```

### Status Words And Enums

Bit-level meaning also comes from the map. A 16-bit status word might define:

| Bit | Meaning |
|---:|---|
| 0 | Enabled |
| 1 | Fault active |
| 2 | Remote mode |
| 3 | Power value valid |

If the raw value is `0x000D`, the binary value is:

```text
0000 0000 0000 1101
```

Bits `0`, `2`, and `3` are set. The device is enabled, remote mode is true, and the power value is valid. Fault active is false.

Field note: many maps use bit `0` as the least-significant bit, but bit numbering is still a map convention. Some manuals number bits `1-16` or display bit diagrams left-to-right. Verify the convention before building alarms or command logic.

Enum values are similar. A register value of `2` means nothing by itself. In the synthetic fixture, operating mode enum `2` means `Remote`. In another device, the same value could mean a different state.

## Practical Example: Normalized Telemetry

Synthetic read set:

| Tag | Function | Documented Address | PDU Address | Quantity | Type | Raw Response |
|---|---:|---|---:|---:|---|---|
| `battery_power` | `03` | `40091` | `90` | `2` | signed 32-bit high word first, `/10 kW` | `03 04 FF FF F6 3C` |
| `telemetry_status_word` | `03` | `40081` | `80` | `1` | U16 bitfield | `03 02 00 0D` |
| `operating_mode` | `03` | `40093` | `92` | `1` | U16 enum | `03 02 00 02` |
| `lab_temperature_reading` | `03` | `40094` | `93` | `1` | S16 `/10 deg C`, sentinel `0x7FFF` | `03 02 7F FF` |

Decoded telemetry:

| Tag | Raw | Decoded Value | Unit | Quality | State Context |
|---|---:|---:|---|---|---|
| `battery_power` | `-2500` | `-250.0` | `kW` | valid | valid because status bit `3` is true; negative means charging in this synthetic map |
| `telemetry_status_word.enabled` | bit `0` | `true` | flag | valid | source label: synthetic vendor note |
| `telemetry_status_word.fault_active` | bit `1` | `false` | flag | valid | no active fault in this response |
| `telemetry_status_word.remote_mode` | bit `2` | `true` | flag | valid | operating mode should agree with enum |
| `operating_mode` | `2` | `Remote` | enum | valid | synthetic enum table |
| `lab_temperature_reading` | `0x7FFF` | null | `deg C` | invalid | sentinel means unavailable |

The important point is not just arithmetic. Learners should preserve the evidence chain:

```text
response bytes -> raw value -> typed value -> scale/unit -> quality/state-aware telemetry
```

## Common Pitfalls

- Displaying a scaled value without its unit.
- Applying scale before signedness and width are correct.
- Treating a sentinel as a real maximum, minimum, or alarming process value.
- Showing stale or invalid values as live telemetry because the valid bit was ignored.
- Assuming negative power always means import, export, charge, or discharge.
- Treating bit numbering as obvious from the tool display rather than from the source map.
- Treating latching, historical, or read-to-clear alarm behavior as generic Modbus behavior instead of future vendor-specific coverage that needs a named source.
- Treating a write echo as proof that the physical process changed state.

## Instructor Flow

1. Start with one known raw register and apply scale/unit.
2. Add signedness and sign convention.
3. Add one status word and decode bit truth values.
4. Add one sentinel and force learners to output null/invalid rather than a fake engineering value.
5. Add one enum and cross-check it against a related status bit.
6. End with a normalized telemetry table that keeps raw, decoded, quality, and source evidence together.

## Check-Your-Understanding

1. A register returns raw `1234`, type signed 16-bit, scale `/10`, unit `deg C`. What should be displayed?
2. A status register returns `0x0006`. If bit `1` means fault active and bit `2` means remote mode, what is true?
3. A temperature register returns `0x7FFF`, and the map says that value means unavailable. What should the telemetry show?
4. Why should a dashboard keep both raw value and decoded engineering value during commissioning?

## Source Notes

- Official rule: Modbus Application Protocol Specification V1.1b3 defines normal and exception response shapes, register read/write functions, byte counts for normal read responses, and exception behavior. It does not define universal engineering units, scale factors, alarm meanings, quality bits, sentinels, enum values, or battery sign conventions.
- Official citation targets: [official-citation-map.md](https://learnmodbus.studioseventeen.io/resource/official-citation-map) rows for normal response vs exception response, exception codes and exception response PDU shape, read holding/input register quantity limits, write single register shape and echo boundary, and multi-byte numeric encoding in protocol fields.
- Future vendor-specific coverage: latching alarms, historical alarms, and read-to-clear registers need a named device manual or profile before becoming runnable course examples.
- Synthetic source: `release/synthetic-course-device-map.md` provides the current no-hardware Module 8 fixtures.
- Vendor/profile source: real scale, sentinel, bitfield, enum, and sign-convention rules must come from the named device manual, profile, or verified behavior.
- Tool source: display names, bit labels, and alarm handling must be tied to a selected tool/version before release.

## Completion Checkpoint

Before moving on, learners should turn one raw register value into an engineering value and also decide whether sentinel, quality, state, or freshness rules prevent that value from being used as trustworthy telemetry.

## Reusable Assets

- [Synthetic course device map](https://learnmodbus.studioseventeen.io/resource/synthetic-course-device-map)
- [Raw-to-telemetry worksheet](https://learnmodbus.studioseventeen.io/resource/raw-to-telemetry-worksheet)
- [Raw-to-telemetry lab](https://learnmodbus.studioseventeen.io/lesson/scaling-engineering-meaning?page=lab-1)
- [Module 8 quiz](https://learnmodbus.studioseventeen.io/lesson/scaling-engineering-meaning?page=quiz)
- [Data type and byte-order worksheet](https://learnmodbus.studioseventeen.io/resource/data-type-byte-order-worksheet)

## Diagram source

```mermaid
flowchart LR
  Raw["Raw register: 224"]
  Map["Map: INT16, /10, °C"]
  Raw --> Apply["Apply scale"]
  Map --> Apply
  Apply --> Eng["22.4 °C"]
  Eng --> Check["Plausible range check"]
```

## Labs

### Lab 1

# Lab 8: Raw Registers To Normalized Telemetry
## Learner Outcome

Learners can convert raw Modbus response bytes into normalized telemetry that includes raw value, decoded value, unit, quality, state context, source label, and unresolved assumptions.

## Prerequisites

- Module 5: documented address versus PDU address.
- Module 6: normalized register-map rows.
- Module 7: signedness, width, and word order.
- Module 8 lesson through sentinels and bitfields.

## Safety And Scope

This lab uses [Synthetic Course Device Map](https://learnmodbus.studioseventeen.io/resource/synthetic-course-device-map) and [Raw-To-Telemetry Worksheet](https://learnmodbus.studioseventeen.io/resource/raw-to-telemetry-worksheet). It is a paper or spreadsheet exercise until the simulator fixture is implemented.

Do not use these synthetic sign conventions, sentinel values, enum values, or bit meanings on production devices. Real equipment requires its own manual, read-only verification, and commissioning evidence.

## Scenario

You have a valid set of Modbus read responses from a course energy system simulator. The raw values are not ready for a dashboard. Your job is to turn them into normalized telemetry that another integrator can review without guessing.

## Protocol Targets

| Tag | Function | Documented Address | PDU Address | Quantity | Type | Source Meaning | Response PDU |
|---|---:|---|---:|---:|---|---|---|
| `line_voltage_l1_l2` | `03` | `40010` | `9` | `1` | U16 | `/10 V`; validity depends on grid-present evidence not included in this fixture | `03 02 09 C4` |
| `ac_frequency` | `04` | `30021` | `20` | `1` | U16 | `/100 Hz`, input-register table | `04 02 17 70` |
| `battery_power` | `03` | `40091` | `90` | `2` | S32 high word first | `/10 kW`; negative means charging in this synthetic map | `03 04 FF FF F6 3C` |
| `telemetry_status_word` | `03` | `40081` | `80` | `1` | U16 bitfield | bit 0 enabled, bit 1 fault, bit 2 remote, bit 3 power valid | `03 02 00 0D` |
| `operating_mode` | `03` | `40093` | `92` | `1` | U16 enum | `0` Off, `1` Local, `2` Remote, `3` Faulted | `03 02 00 02` |
| `lab_temperature_reading` | `03` | `40094` | `93` | `1` | S16 | `/10 deg C`; `0x7FFF` means unavailable | `03 02 7F FF` |

## Procedure

1. For each row, confirm the request fields: function code, documented address, PDU address, and quantity.
2. Confirm the response shape: function code, byte count, and data bytes.
3. Decode the raw value using the stated type, signedness, and word order.
4. Apply scale and unit only after the raw type is correct.
5. Decode `telemetry_status_word` into individual boolean fields.
6. Decode `operating_mode` using the synthetic enum table.
7. Apply the temperature sentinel rule before scaling it as a real temperature.
8. Fill the normalized telemetry table and source labels.
9. Write one sentence explaining which claims came from official protocol behavior and which came from synthetic map meaning.

## Auto-Graded Checks

```lab
type: scale
prompt: line_voltage_l1_l2 reads raw 0x09C4 (= 2500). Apply the synthetic map scale (÷10 V).
raw: 2500
op: div
factor: 10
unit: V
explain: 2500 ÷ 10 = 250.0 V (quality conditional on grid-present evidence).
```

```lab
type: scale
prompt: ac_frequency reads raw 0x1770 (= 6000). Apply the input-register scale (÷100 Hz).
raw: 6000
op: div
factor: 100
unit: Hz
explain: 6000 ÷ 100 = 60.00 Hz.
```

```lab
type: decode
prompt: Decode battery_power as S32 high word first. Raw bytes shown below.
bytes: FF FF F6 3C
as: s32
order: ABCD
hint: A leading 0xFFFF strongly suggests a negative two's-complement value.
explain: 0xFFFFF63C → -2500. After ÷10 kW that's -250.0 kW (charging in this synthetic map).
toolLink: /tools?tab=decoder&hex=FFFFF63C
```

```lab
type: text
prompt: lab_temperature_reading returns raw 0x7FFF. According to the synthetic source map, what value should you display? (one word)
answer: invalid
hint: 0x7FFF is the sentinel for unavailable on this map — quality should win over plausibility.
explain: Display invalid / unavailable, NOT 3276.7 °C.
```

## Worksheet

| Tag | Raw Bytes | Raw Value | Decode Rule | Engineering Value | Unit | Quality | State Context | Source Label | Unresolved Assumptions |
|---|---|---:|---|---:|---|---|---|---|---|
| `line_voltage_l1_l2` |  |  |  |  |  |  |  |  |  |
| `ac_frequency` |  |  |  |  |  |  |  |  |  |
| `battery_power` |  |  |  |  |  |  |  |  |  |
| `telemetry_status_word.enabled` |  |  |  |  | flag |  |  |  |  |
| `telemetry_status_word.fault_active` |  |  |  |  | flag |  |  |  |  |
| `telemetry_status_word.remote_mode` |  |  |  |  | flag |  |  |  |  |
| `telemetry_status_word.power_valid` |  |  |  |  | flag |  |  |  |  |
| `operating_mode` |  |  |  |  | enum |  |  |  |  |
| `lab_temperature_reading` |  |  |  |  | deg C |  |  |  |  |

## Expected Results

| Tag | Expected Result | Why |
|---|---|---|
| `line_voltage_l1_l2` | `250.0 V`, quality conditional | `0x09C4 = 2500`; `/10 V` is synthetic map meaning; grid-present evidence is not included in this fixture. |
| `ac_frequency` | `60.00 Hz` | `0x1770 = 6000`; `/100 Hz`; function `04` confirms input-register response. |
| `battery_power` | `-250.0 kW`, valid | `0xFFFFF63C` as S32 is `-2500`; `/10 kW`; status bit `3` is true. |
| `telemetry_status_word.enabled` | `true` | `0x000D` has bit `0` set. |
| `telemetry_status_word.fault_active` | `false` | `0x000D` does not have bit `1` set. |
| `telemetry_status_word.remote_mode` | `true` | `0x000D` has bit `2` set. |
| `telemetry_status_word.power_valid` | `true` | `0x000D` has bit `3` set. |
| `operating_mode` | `Remote` | Synthetic enum table maps raw `2` to `Remote`. |
| `lab_temperature_reading` | null/invalid, not `3276.7 deg C` | `0x7FFF` is a synthetic sentinel for unavailable. |

## Expected Observations

- Scaling without unit and quality is not enough for paid-course-grade telemetry.
- A raw sentinel should become invalid/unavailable, not a large process value.
- Bitfield and enum meanings are source-map claims, not official Modbus claims.
- Status bit `remote_mode` and enum `Remote` agree in this fixture; a mismatch would be a troubleshooting clue.

## Troubleshooting Notes

- If a value looks wrong, separate communication evidence from interpretation evidence.
- If a scaled value is plausible but the valid bit is false, quality should win over plausibility.
- If a tool numbers bits differently than the source map, record both labels and prove the convention with a known safe state.
- Treat read-to-clear alarm behavior as vendor-specific future coverage until a named manual or profile is reviewed.

## Check Questions

1. Which values in this lab are official protocol evidence?
2. Which values are synthetic map meaning?
3. Why is `0x7FFF` not displayed as `3276.7 deg C`?
4. What would you record if `operating_mode` said `Remote` but the status word's remote bit was false?

## Instructor Notes

- Insist that learners fill source labels, not just numbers.
- Ask learners to show the raw response bytes next to every decoded value.
- Use the temperature sentinel row to reinforce that quality gates come before dashboards.
- Keep write behavior out of this lab; Module 15 owns write safety.

## Source Notes

- Official source: Modbus Application Protocol Specification V1.1b3 for normal read response structure, exception response structure, and register data fields.
- Synthetic source: `release/synthetic-course-device-map.md` for scale, unit, bit, enum, sentinel, and sign-convention meanings.
- Course-owned helper evidence: `python3 tools/modbus_fixture_helper.py decode-fixtures` verifies the Lab 8 raw decode values before synthetic scale, unit, enum, bitfield, sentinel, and quality rules are applied.
- Local source: Module 7 data-type assets for signedness and word-order prerequisites.
- Tool source: selected learner tools still need version-specific terminology and display verification before release.

## Knowledge check

# Module 8 Quiz: Scaling And Engineering Meaning
## Questions

### Multiple Choice

1. A register returns raw `09 C4`, and the map says `U16`, `/10 V`. What should be displayed?
   - A. `2500 V`.
   - B. `250.0 V`.
   - C. `25.00 V`.
   - D. `09 C4 V`.

2. A temperature row says `S16`, `/10 deg C`, sentinel `0x7FFF = unavailable`, and the response data is `7F FF`. What should a dashboard show?
   - A. `3276.7 deg C`.
   - B. `32767 deg C`.
   - C. Invalid or unavailable, with raw value preserved.
   - D. Exception response.

3. A status word returns `0x000D`. If bits `0`, `2`, and `3` are set, which statement is true?
   - A. Bits `1`, `2`, and `4` are set because bit numbering starts at one.
   - B. The map's bit numbering must be applied; in the synthetic fixture, enabled, remote, and power-valid are true.
   - C. Modbus defines bit `3` as power valid.
   - D. The register must be a coil table.

4. A synthetic battery-power row says signed 32-bit, high word first, `/10 kW`, and negative means charging. Raw `FF FF F6 3C` decodes to `-2500`. What is the engineering value?
   - A. `-250.0 kW`, charging in this synthetic map.
   - B. `-2500 kW`, discharging by universal Modbus convention.
   - C. `250.0 W`, charging.
   - D. Invalid because negative values are not allowed in holding registers.

5. Which claim is official Modbus behavior for a normal FC03/FC04 read response?
   - A. `0x7FFF` means unavailable.
   - B. Enum value `2` means `Remote`.
   - C. The normal response includes a function code, byte count, and data bytes.
   - D. Negative battery power means charging.

6. A temperature row is `S16`, `/10 deg C`, with sentinel `0x7FFF = unavailable`. The response returns data bytes `7F FF`. What raw value and telemetry should be published?
   - A. Raw `32767`, value `3276.7 deg C`, quality valid.
   - B. Raw `0x7FFF`, value null/invalid, quality unavailable, raw preserved.
   - C. Raw `-1`, value `-0.1 deg C`, quality valid.
   - D. Raw `0x7FFF`, value `327.67 deg C`, quality valid.

7. In a decode pipeline, when should sentinel and quality handling happen relative to scaling and alarming?
   - A. After scaling, so the sentinel is scaled into engineering units first.
   - B. Before scaling and alarming, so an unavailable value is never displayed or alarmed as a real measurement.
   - C. Only after an alarm has already been raised on the scaled value.
   - D. Never, because Modbus flags sentinels in the response frame.

### Short Answer

1. Why should normalized telemetry preserve both raw value and engineering value?
2. What evidence would you need before using a vendor sign convention in a real dashboard?
3. Why should quality or sentinel handling happen before alarming on a scaled value?
4. Name three fields that belong in a telemetry row after decoding.

### Applied Scenario

A synthetic course fixture returns:

| Tag | Response | Source Meaning |
|---|---|---|
| `telemetry_status_word` | `03 02 00 0D` | bit 0 enabled, bit 1 fault, bit 2 remote, bit 3 power valid |
| `operating_mode` | `03 02 00 02` | enum `0` Off, `1` Local, `2` Remote, `3` Faulted |
| `lab_temperature_reading` | `03 02 7F FF` | S16 `/10 deg C`; `0x7FFF` means unavailable |

Tasks:

1. Decode the status bits.
2. Decode the operating mode.
3. State the temperature telemetry value and quality.
4. Label which facts are official protocol behavior and which are synthetic map meaning.

## Answer Key

1. Multiple choice: B. `0x09C4` is `2500`, and the synthetic map's `/10 V` scale gives `250.0 V`. A misses the scale, C applies the wrong scale, and D displays the raw hex as if it were engineering data.
2. Multiple choice: C. The sentinel rule wins before scaling. A and B incorrectly display an unavailable value as real temperature, and D is wrong because the bytes shown are a normal data response.
3. Multiple choice: B. The bit meanings come from the source map. A assumes a different numbering convention without evidence, C invents an official Modbus meaning, and D confuses packed register bits with the coil table.
4. Multiple choice: A. The signed raw value `-2500` scaled by `/10 kW` is `-250.0 kW`, and the charging direction is scoped to the synthetic map. B invents a universal sign convention, C changes the unit, and D is false because holding registers can carry signed interpretations.
5. Multiple choice: C. Function code, byte count, and data bytes are part of a normal FC03/FC04 read response shape. Exception responses use a different exception-response shape, and the other claims are synthetic or vendor/profile meanings.
6. Multiple choice: B. `0x7FFF` matches the sentinel, so publish null/invalid with quality unavailable and preserve the raw value; do not scale it into `3276.7 deg C`.
7. Multiple choice: B. Sentinel and quality handling must run before scaling and alarming so an unavailable value is never displayed or alarmed as a real measurement.

## Distractor Review Notes

| Question | Correct | Why The Distractors Are Wrong |
|---:|---|---|
| 1 | B | A misses the `/10` scale, C applies the wrong scale, and D displays raw hex as if it were the engineering value. |
| 2 | C | A/B scale or display a sentinel as real data, and D confuses normal data bytes with an exception response. |
| 3 | B | A assumes a numbering convention without evidence, C invents an official bit meaning, and D confuses packed register bits with the coil table. |
| 4 | A | B invents a universal sign convention, C changes the unit and magnitude, and D invents a ban on signed interpretations in holding registers. |
| 5 | C | A/B/D are synthetic map or vendor/profile meanings, not fields defined by the normal FC03/FC04 response shape. |
| 6 | B | A scales the sentinel as if valid, C invents a wrong sign and value, and D applies the wrong scale to a value that should not be scaled at all. |
| 7 | B | A scales the sentinel before checking it, C alarms on a value before validating quality, and D falsely claims Modbus flags sentinels in the frame. |

Short answer:

1. Raw values make commissioning and troubleshooting repeatable; engineering values make the data usable. Keeping both preserves evidence when scale, signedness, quality, or source assumptions are challenged.
2. A named manual/profile row plus known operating state, device display comparison, or captured real-device evidence showing the convention. Simulator evidence only counts for real equipment if it is versioned and explicitly implements the named device/profile.
3. A sentinel may look like a large valid number after scaling. Quality handling prevents false alarms, fake dashboards, and bad control decisions.
4. Good answers include raw bytes, raw value, type, scale, unit, decoded value, quality, validity context, source label, timestamp/freshness, and unresolved assumptions.

Applied scenario:

1. `0x000D` has bits `0`, `2`, and `3` set: enabled true, fault false, remote true, power valid true.
2. Raw enum `2` means `Remote` in the synthetic enum table.
3. Temperature is null/invalid or unavailable; preserve raw `0x7FFF` and do not display `3276.7 deg C`.
4. Official protocol behavior: response function code, byte count, and data bytes. Synthetic map meaning: bit labels, enum labels, sentinel rule, and temperature unit/scale.

## Source Notes

- Official citation targets: [official-citation-map.md](https://learnmodbus.studioseventeen.io/resource/official-citation-map) rows for four primary logical data tables, normal response vs exception response, exception codes and exception response PDU shape, read holding/input register quantity limits, write single register shape and echo boundary, and multi-byte numeric encoding in protocol fields.
- Scale, unit, sentinel, enum, status-bit, freshness, and quality rules remain synthetic-map or vendor/profile behavior.

---
_Learn Modbus · learnmodbus.studioseventeen.io · Module 8/16 · v1.0.0 · Exported for offline / agent use._