IOCAN

# Map Output

## Overview

A **Map Output** passes a value through a **1D lookup table** and sends the result

to another **target output**. Use it to reshape or **linearise** a command on its

way to an output — for example to compensate for a non-linear actuator without

changing the strategy that drives it.

It does not control a pin itself; it **remaps** a value and forwards it to the

target output you choose.

## Prerequisites & hardware

- The **target output** must already exist — create it first and note its alias.

- A source value (a map, driver or input) to feed into the lookup.

- No wiring of its own: the target output handles the physical pin.

## Add it in the app

1. Add a new output and choose **Map Output** as the type.

2. Give it a clear **alias** (e.g. `Actuator Linearise`).

3. Select the **target output** (by alias) that this should drive.

4. Enter the **lookup points** (X breakpoints and their Y values) and a

   **default value**, then drive the Map Output from your source.

## Settings reference

> Schema: `config/MapOutputConfigData.proto`.

| Setting | Meaning | Unit | Range / values | Notes |

|---|---|---|---|---|

| **Target output** | The output this drives | — | an existing output | Chosen by alias; receives the remapped value. |

| **Default value** | Value used before a source value is available | target unit | sint32 | Sent to the target until a source value arrives. |

| **Input values (X)** | Breakpoints on the input axis | source unit | repeated sint32 | Must be **strictly increasing**. |

| **Output values (Y)** | Value at each breakpoint | target unit | repeated sint32 | One per input breakpoint; the controller interpolates between points. |

The lookup is a **1D map**: the source value is found on the X axis and the

corresponding Y value is produced, interpolating between breakpoints. See

[Scaling & Maps](Scaling_and_Maps).

## Common settings

Map Output also uses the shared settings — alias and pin. See [Common IO Settings](Common_IO_Settings).

## Example — linearise a proportional valve

1. Create the valve's [PWM Output](PWM_Output) first (alias `Valve Drive`).

2. Add a **Map Output**, alias `Valve Linearise`, **target output** `Valve Drive`.

3. **Input values (X)** = requested flow `0, 25, 50, 75, 100`.

4. **Output values (Y)** = the duty needed for that flow, e.g. `0, 15, 40, 70, 100`.

5. **Default value** `0`, then drive the Map Output from the flow request.

## Troubleshooting

- **Target doesn't move / wrong value:** check the **target output** alias and that

  the source is driving the Map Output, not the target directly.

- **Output jumps or is non-monotonic:** make sure **Input values (X)** are strictly

  increasing and that X and Y have the same number of points.

- **Unexpected value at start-up:** set a sensible **default value**.

## Related

- [Map Input](Map_Input) — the same 1D lookup applied to an input.

- [Splitter Output](Splitter_Output) — send one value to several outputs at once.

- [Scaling & Maps](Scaling_and_Maps)