How to Find Maps in an ECU File Using WinOLS

Why Map Finding Is a Core Skill

Whether you’re verifying a file from a service, learning to tune yourself, or developing calibrations professionally, the ability to find and identify maps in a raw ECU binary file is one of the most important skills in the tuning world.

An ECU binary file is just a sequence of bytes — there are no labels, no headers saying “this is the boost map,” no helpful tooltips. Everything is raw numerical data stored in flash memory. Your job is to locate the maps within this data, determine what they control, and understand their structure.

WinOLS: The Industry Standard

WinOLS (by EVC) is the most widely used ECU calibration software in the tuning industry. It provides powerful tools for viewing, identifying, and modifying maps within ECU binary files.

Key Features for Map Finding

• Hex view: Raw hex data display with configurable byte width
• 2D view: Displays data as a line graph — makes map structures visually apparent
• 3D view: Renders data as a 3D surface plot — ideal for identifying 2D maps (tables with X and Y axes)
• Map list: Stores identified maps with names, descriptions, and axis definitions
• Compare files: Overlay two files to see exactly which bytes were changed
• Damos/Mappack import: Load definition files that automatically identify all known maps

Method 1: Using Damos or Mappacks (Fastest)

The fastest way to find maps is to not find them manually at all. If a Damos file, mappack, or A2L file exists for your ECU variant, import it into WinOLS and all maps are automatically identified.

1. Open your ECU binary in WinOLS
2. Go to File → Import → Map Pack (or Damos, or A2L)
3. Select the matching definition file
4. All defined maps appear in the map list panel, labelled and ready to use

For more on definition files, see our guide on Damos, Mappacks & A2L files.

Method 2: Compare Original vs Tuned File

If you don’t have a mappack but you do have both the original and a tuned version of the same file, comparing them is extremely effective.

How to Compare

1. Open the original file in WinOLS
2. Go to File → Compare with File and select the tuned file
3. WinOLS highlights every byte that differs between the two files
4. Navigate through the differences — each changed area is a map that was modified during tuning

What to Look For

• Changed areas that form rectangular blocks: These are 2D maps (tables). The rectangular shape corresponds to rows × columns of the map.
• Changed areas that form single lines: These are 1D curves (2D graphs with one axis).
• Changed individual values: These are scalar constants (single parameters like a speed limit value).

Identifying What Each Map Does

Once you’ve found a changed area, switch to 2D or 3D view and examine the data:

• Values 0-3000: Could be RPM limits, pressure values (mbar), or temperature (°C × 10)
• Values 0-100: Could be percentages (throttle position, duty cycle, EGR position)
• Values 0-50: Could be injection quantity (mg/stroke) or ignition timing (degrees)
• Values 0-2000: Could be rail pressure (bar) or boost pressure (mbar)

The relationship between the original and tuned values gives clues:

• Values increased by 10-30%: Likely injection quantity or boost pressure (Stage 1 tune)
• Values set to zero: Likely an EGR demand map or DPF function disable
• Values set to maximum (0xFF or 0xFFFF): Likely a limiter that was raised or disabled

Method 3: Manual Map Finding (2D/3D View)

When you have neither a mappack nor a tuned file for comparison, you need to find maps manually. This is where the 2D and 3D views become essential.

Understanding Data Structure

ECU maps are stored in flash memory as sequential bytes. A 2D map (table) is stored as a flat array — the rows are laid out one after another. For example, a 16×16 map of 16-bit values occupies 512 bytes (16 × 16 × 2).

Step-by-Step Manual Finding

1. Switch to 2D view in WinOLS
2. Set the data type — most modern ECUs (TriCore) use 16-bit values. Older C167 ECUs often use 8-bit.
3. Scroll through the calibration area — not the program code area (which contains the ECU’s executable code, not calibration data)
4. Look for structured patterns:
   • Smooth curves: A smooth, gradually changing line in 2D view indicates a map. Engine parameters change smoothly — random data doesn’t.
   • Repeating patterns: Maps with similar axes (same RPM breakpoints) will show similar patterns when viewed in 2D
   • Step patterns: Some maps (like torque limiters) show distinct steps — flat sections followed by drops
   • Zero sections: Large blocks of zeros often indicate unused calibration space or padding between maps
5. Switch to 3D view — when you think you’ve found a map, switch to 3D and adjust the row width until the surface makes physical sense:
   • A boost map should look like a surface that rises with RPM and load
   • An injection quantity map should show a similar rising surface
   • A timing map typically shows a complex surface with a ridge at mid-RPM
6. Determine the correct row width — this is crucial. If you set the wrong number of columns, the 3D surface will look chaotic. Common map dimensions: 8×8, 10×10, 12×12, 16×16, 16×12, 12×8. Try different widths until the surface looks physically meaningful.

Finding Map Axes

Maps don’t just have data — they have axes (breakpoints). The X and Y axis values are stored separately from the map data, usually immediately before the map or in a dedicated axis table area.

How to find axes:

• Look for a sequence of ascending values near the map data
• RPM axes: look for sequences like 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000
• Load/pressure axes: look for sequences like 0, 200, 400, 600, 800, 1000, 1200, 1600, 2000
• Temperature axes: look for sequences covering -20 to 120 (°C) or similar ranges

Common Map Types and Recognition

Practice Exercise: EDC15 Map Finding

The Bosch EDC15 is the best ECU to practice on. Here’s a guided exercise:

1. Obtain an EDC15 original file (read from any EDC15-equipped vehicle)
2. Open in WinOLS with 16-bit data type selected
3. Navigate to approximately offset 0x10000-0x70000 (the calibration area in most EDC15 variants)
4. Switch to 2D view and scroll slowly — you’ll see smooth curves emerge from the noise
5. When you find a smooth section, switch to 3D and try column widths of 8, 10, 12, and 16
6. Look for the injection quantity map first — it’s the largest and most prominent map, typically a 16×16 table with values rising from near-zero to 40-50
7. Once you’ve found the injection map, the maps immediately before and after it are often related (injection timing, rail pressure, etc.)

Tips from Experience

• Calibration area vs. program area: Don’t waste time searching in the program code section — maps only exist in the calibration area. The calibration area is typically in the upper portion of the flash memory.
• Map packs from similar ECUs: If you can’t find a mappack for your exact software version, try one from a similar ECU variant. The map addresses may be offset, but the relative positions are often consistent.
• Use the search function: WinOLS can search for specific patterns — use it to find axis values (e.g., search for the RPM sequence 1000, 1500, 2000, 2500 in 16-bit format).
• Compare multiple originals: If you have original files from the same ECU variant but different software versions, comparing them can reveal which areas are calibration data (changes between versions) vs. program code (stays the same).
• Practice, practice, practice. Map finding is a skill that improves dramatically with experience. Start with well-documented ECUs (EDC15, ME7) and work your way up.

For more on using definition files to skip manual identification, see our guide on Damos, Mappacks & A2L files.