Command Reference - gmenounos/kw1281test GitHub Wiki
A detailed reference for every command understood by kw1281test, a command-line tool that talks the KW1281 (and, for a few commands, KW2000) KWP "OnBoard Diagnostics" protocol to modules in Volkswagen Group vehicles (VW, Audi, Ε koda, SEAT). It is used over a "dumb" serialβKKL or USBβKKL cable plugged into the vehicle's OBD-II port.
This reference is derived directly from the current source code (Program.cs,
Tester.cs, KW1281Dialog.cs, KwpCommon.cs, the Cluster\ and EDC15\
implementations), which is the authoritative source. Where the older README.md
or the project Wiki disagree, the code wins β a few commands are implemented but
not advertised in the on-screen Usage: help, and this document covers those too
(marked hidden below).
- How to run the tool
- Ports and cables
- Baud rate
- Controller address
- How argument numbers are parsed
- Command index
- Commands
- Safety notes
- Where the output goes
KW1281Test PORT BAUD ADDRESS COMMAND [args]
-
Windows:
KW1281Test.exe PORT BAUD ADDRESS COMMAND [args] -
macOS / Linux:
./kw1281test PORT BAUD ADDRESS COMMAND [args]
If you run it with fewer than 4 arguments, it prints the Usage: help and exits.
Command names and all START/LENGTH/ADDRESS/VALUE style arguments are
case-insensitive, and address/size/value numbers accept decimal, 0xβ¦, or
$β¦ (see How argument numbers are parsed).
# Identify a cluster (address 0x17) over COM4 at 10400 baud
KW1281Test.exe COM4 10400 17 ReadIdent
# Get the immobilizer SKC of a cluster
./kw1281test A12JCDR4 10400 17 GetSKC
The PORT argument selects which serial interface the tool opens. The tool
decides which driver backend to use based on the string you pass:
Form of PORT
|
Backend used | Notes |
|---|---|---|
COM1, COM4, β¦ |
Generic / Windows serial | Any Windows serial port. |
/dev/ttyUSB0, /dev/ttyS0, β¦ |
Linux serial | Must start with /dev/ on Linux. |
8 uppercase alphanumerics, e.g. A12JCDR4
|
FTDI (D2xx) | An FTDI USBβserial device serial number. |
Why the FTDI serial-number form exists: the KW1281 wakeup is a bit-banged
5 baud (β 200 ms per bit) line that the tool generates by toggling the serial
port's break line at precise timing (KwpCommon.BitBang5Baud). The FTDI D2xx
driver gives the tool the low-level control (break line, exact baud changes) it
needs for that. On macOS and Linux you therefore must use an FTDI cable and
the D2xx drivers, and pass the cable's 8-character serial number as PORT.
The cable itself must be a passive "dumb" KKL cable (no protocol chip).
- Windows: cheap CH340-based cables generally work (install the CH340 driver); a legacy Ross-Tech cable can be used with its Virtual-COM-Port driver.
- macOS / Linux: FTDI-based cable with the D2xx drivers.
BAUD is the post-wakeup data rate, in decimal. Typical values:
| Baud | Where you'll usually find it |
|---|---|
10400 |
Most clusters. Try this first. |
9600 |
ECUs, Radios, CCM / central modules, airbag. |
4800 |
Occasionally, on older modules. |
The wakeup message itself is always sent at 5 baud regardless of BAUD; BAUD
is the speed the controller and cable switch to after the handshake. If the log
shows "unexpected sync byte" style errors, the baud rate (or the cable/address)
is usually wrong β try 10400, 9600, then 4800.
ADDRESS is the controller's K-line address. Important: this argument is
parsed as a hexadecimal number (int.Parse(args[2], NumberStyles.HexNumber)),
so you type the address in hex without any 0x/$ prefix:
KW1281Test.exe COM4 10400 17 ReadIdent # 17 (hex) = 0x17 = cluster
KW1281Test.exe COM4 9600 1 ReadIdent # 1 (hex) = 0x01 = engine ECU
Known controller addresses used in the code:
| Hex | Module | Typical BAUD
|
|---|---|---|
01 |
Engine (ECU) | 9600 |
09 |
Central Electric | ? |
15 |
Airbag | 9600 |
17 |
Instruments (cluster) |
10400 (often) / 9600
|
19 |
CAN Gateway | ? |
25 |
Immobilizer (immo box) | ? |
35 |
Central Locking | ? |
37 |
Navigation | ? |
46 |
Comfort/Convenience Module (CCM) | 9600 |
56 |
Radio (head unit) | 9600 |
7C |
Radio (manufacturing/delco test) | 9600 |
Commands check this address internally and many are only meaningful for one or a few of these (noted per command below).
Any numeric argument that the tool parses with Utils.ParseUint (all START,
LENGTH, ADDRESS, VALUE, CODING, WORKSHOP, LOGIN values, and the
WriteEdc15Eeprom address/value pairs) accepts three forms:
-
decimal:
2048 -
0xhex:0x800 -
$hex:$800
The lone exception is the ADDRESS positional argument (controller address),
which is always plain hex, as described above.
All commands the tool will actually execute (from the dispatcher in
Program.Run). Commands marked hidden are implemented but not listed in the
on-screen Usage: help.
| Command | Short description | Section |
|---|---|---|
AutoScan |
Scan every K-line address for a live module | 1 |
ReadIdent |
Read the module's identification text (part no., etc.) | 1 |
GetClusterId |
hidden β read a cluster's anti-theft ID byte pair | 1 |
GetSKC |
Read the immobilizer Super Key Code (SKC) | 1 |
ReadSoftwareVersion |
hidden β read cluster (VDO) software version | 1 |
ReadFaultCodes |
Read stored fault/DTC codes | 2 |
ClearFaultCodes |
Clear stored fault/DTC codes | 2 |
ActuatorTest |
Run the module's actuator output tests (interactive) | 3 |
GroupRead |
Read a measuring-values / diagnostic group (interactive) | 3 |
BasicSetting |
Read a "basic setting" group (interactive) | 3 |
AdaptationRead |
Read an adaptation (learning) channel | 4 |
AdaptationTest |
Set an adaptation channel value without storing it | 4 |
AdaptationSave |
Set and store an adaptation channel value | 4 |
FindLogins |
hidden β brute-force which login codes are accepted | 4 |
SetSoftwareCoding |
Write the module's software coding + workshop code | 5 |
ClarionVWPremium4SafeCode |
Read a Clarion VW Premium 4 radio's safe code | 6 |
DelcoVWPremium5SafeCode |
Read a Delco VW Premium 5 radio's safe code | 6 |
ReadEeprom |
Read one byte from EEPROM | 7 |
ReadROM |
Read one byte from ROM | 7 |
ReadRAM |
Read one byte from RAM | 7 |
DumpEeprom |
Dump an EEPROM range to a file | 7 |
DumpRom |
Dump a ROM range to a file | 7 |
DumpRam |
Dump a RAM range to a file | 7 |
DumpMarelliMem |
Dump a Magneti Marelli cluster EEPROM to a file | 7 |
DumpRBxMem |
Dump a Bosch RB4/RB8 cluster memory (KW2000) | 7 |
DumpRBxMemOdd |
hidden β like DumpRBxMem, odd-parity wakeup |
7 |
DumpCcmRom |
hidden β dump a CCM/central-locking ROM (64 KB) | 7 |
DumpClusterNecRom |
hidden β dump a VDO cluster NEC-ROM (64 KB) | 7 |
DumpMem |
Dump a VDO cluster's raw memory (custom command) | 7 |
MapEeprom |
hidden β probe every EEPROM byte into a map file | 7 |
WriteEeprom |
Write one byte to EEPROM | 8 |
WriteRAM |
Write one byte to cluster RAM | 8 |
LoadEeprom |
Load a binary file into EEPROM starting at START
|
8 |
DumpEdc15Eeprom |
Dump + display an EDC15 ECU EEPROM | 9 |
WriteEdc15Eeprom |
Dump, then patch specific EDC15 EEPROM bytes | 9 |
Reset |
hidden β reset a VDO cluster (custom command) | 10 |
ToggleRB4Mode |
Toggle a Bosch RB4 cluster between New/Adapted mode | 10 |
KW1281Test PORT BAUD ADDRESS AutoScan
The ADDRESS argument is ignored. For each of the 128 possible K-line
addresses, and for both odd and even parity, the tool sends a KW1281 wakeup and
records which modules answer. KWP1281 responders are listed under KWP1281: and
modules that reply with a different (KW2000) keyword under KWP2000:.
Use this to discover what's on the bus when you don't know the module addresses.
BAUD still matters for the post-wakeup handshake, so 10400 is a reasonable
default. It is interactive only in that it takes a while (it pokes all 256
address/parity combinations).
KW1281Test PORT BAUD ADDRESS ReadIdent
Wakes the module up and reads its identification string β typically the part number plus a short description, e.g.:
ECU: 1J5920926CX KOMBI+WEGFAHRSP VDO V01
This is the first command to run on any unknown module: it tells you the part number (so you can look the cluster up in the Supported Clusters wiki page) and the manufacturer (VDO, Marelli, Bosch, Motometer, β¦), which decides which of the other commands will work.
GetClusterId (hidden)
KW1281Test PORT BAUD ADDRESS GetClusterId
Sends a Security Access mode 1 challenge to the cluster and decodes the
cluster's 2-byte unique ID (the value the radio uses to detect the cluster has
been swapped into a different vehicle). The response bytes are de-obfuscated
(subtract constants, XOR, bit-count, rotate). Prints Cluster Id: $XX $XX.
KW1281Test PORT BAUD 17 GetSKC # cluster
KW1281Test PORT BAUD 25 GetSKC # immobilizer box
KW1281Test PORT BAUD 1 GetSKC # engine ECU
Reads and prints the Secret Key Code (SKC) β the 5-digit immobilizer code
needed to adapt new keys. Only supported for clusters (0x17), immobilizer
boxes (0x25) and engine ECUs (0x01); any other address is rejected with a
message.
How it works depends on the module, detected from the ReadIdent text:
- Marelli (M73): dumps the EEPROM and computes the SKC from it.
-
Audi C5 (part prefixes
4B0,4Z7,8D0,8Z0): unlocks and dumps the EEPROM, reads the SKC at0x7E2/0x7E4/0x7E6and warns if the redundant copies disagree. -
VDO: parses the part number, then reads the SKC from the correct EEPROM
location (BCD-encoded) for either non-CAN (
919) or CAN (920) part variants. -
Bosch RB4 / RB8: switches the cluster to New Mode, dumps two bytes at
the SKC offset (RB4
0x10046, RB80x1040E) and prints the SKC. (RB4 must be in New Mode β seeToggleRB4Mode.) - Motometer BOO: dumps 16 bytes and reads the BCD SKC.
-
VWZ3Z0 immo boxes (
1H0,6H0,7M0): reads ROM at0x190; for the IMMO BOX 2 family it sends an unlock ROM + secure immo access command first. -
EDC15 ECU (
0x01): performs an EDC15 EEPROM dump and prints the SKC, odometer, VIN and immo number (see the EDC15 section).
If the cluster type isn't recognized it prints Unsupported cluster: <ident>.
ReadSoftwareVersion (hidden)
KW1281Test PORT BAUD 17 ReadSoftwareVersion
Only supported for a VDO cluster. Sends a cluster custom command
($84 with variations 0x00β0x03) to read and print the cluster software
version strings.
KW1281Test PORT BAUD ADDRESS ReadFaultCodes
Wakes the module and reads all stored fault/DTC codes, printing one per line
under a Fault codes: header. If the module replies with something other than a
fault-code block, nothing is printed for that module.
KW1281Test PORT BAUD ADDRESS ClearFaultCodes
Sends the fault codes delete command. On success it prints Fault codes cleared. if there were no codes left, or lists any that remain. If the module
NAKs, it prints Failed to clear fault codes.
All three of these are interactive: they keep the session alive and read
your keystrokes. The command name is a positional argument; GROUP is the only
extra argument.
KW1281Test PORT BAUD ADDRESS ActuatorTest
Runs the module's actuator test routine, which drives its outputs (blinkers, horns, relay clicks, gauge sweeps, β¦) so you can confirm hardware works. It sends the first actuator test and prints the actuator name; you then:
- press N to advance to the next actuator, or
- press Q to stop.
The test ends on its own when the module reports the End actuator.
KW1281Test PORT BAUD ADDRESS GroupRead GROUP
GROUP = group number (0-255)
(group 0 = raw controller data)
Reads a measuring values / diagnostic group and keeps refreshing it. While running you can:
- press the Up arrow to increment the group number,
- press the Down arrow to decrement it,
- press Q to quit.
Group 0 uses the raw-data-read path and prints raw byte values (with a text
label when the module supplies one). For other groups the module may return
either a decoded text label or a numeric value; both are shown.
KW1281Test PORT BAUD ADDRESS BasicSetting GROUP
GROUP = group number (0-255)
(group 0 = raw controller data)
Same interactive behavior as GroupRead, but it uses the basic setting
read path (BasicSettingRead / BasicSettingRawDataRead) instead of the
measuring-values path. This corresponds to the "Basic Settings" function in
VAG diagnostic software, used to check a module's basic self-test / operating
status. Group 0 again selects raw data.
Adaptation channels (a.k.a. "learnings" or "coding bytes") are per-module
calibration values. The three commands share the same argument shape; LOGIN
is optional and, when present, the tool performs a login (seed/key) before the
adaptation command β required by many modules to allow the write.
-
CHANNELβ the adaptation channel number,0β99. -
VALUEβ the value to set,0β65535. -
LOGINβ an optional login code,0β65535. If omitted, no login is sent (works only on modules/channels that don't require one). The workshop code used for the login is taken automatically from the module's identification.
KW1281Test PORT BAUD ADDRESS AdaptationRead CHANNEL [LOGIN]
Reads the current value of the given channel and prints Adaptation value: N.
KW1281Test PORT BAUD ADDRESS AdaptationTest CHANNEL VALUE [LOGIN]
Sends a test adaptation value. This applies the value without committing it to non-volatile storage β useful for trying a setting live (e.g. adjusting a calibration to see its effect) before you decide to save it.
KW1281Test PORT BAUD ADDRESS AdaptationSave CHANNEL VALUE [LOGIN]
Sends a save adaptation value: applies and permanently stores the value in the module. This is the command used, for example, to adapt the number of keys for the immobilizer (e.g. channel 21 on a cluster). The workshop code is included in the save block.
Common example β adapting an Immo3 cluster to 2 keys (SKC
01111):KW1281Test.exe COM4 10400 17 AdaptationSave 21 2 01111
FindLogins (hidden)
KW1281Test PORT BAUD ADDRESS FindLogins LOGIN
LOGIN = a known-good login code (0-65535)
Brute-forces the login space: with a known-good login as the baseline, it
iterates every candidate code from 0 to 65535, attempting a second login
after each, and prints every code that succeeds. This is a research/forensics
helper for discovering which login codes a module accepts. It can take a very
long time and re-wakes the module whenever the session times out.
KW1281Test PORT BAUD ADDRESS SetSoftwareCoding CODING WORKSHOP
CODING = software coding, 0-32767
WORKSHOP = workshop code, 0-99999
Writes the module's software coding and workshop code (the "coding" /
"long coding" you see in VAG tools). Validation: CODING must be β€ 32767 and
WORKSHOP must be β€ 99999.
The coding is packed into the KW1281 software coding block; a workshop code
above 65535 overflows into the low bit of the coding (this is by design to match
how the protocol stores the combined value). After sending, the tool reads the
module's coding back and reports Software coding set. only if both the coding
and workshop code match what you sent, otherwise Failed to set software coding.
Always read the current coding first (it's part of the module identification shown on wakeup, and in the
CodingWscBlock). If you need to change only the workshop code, keep the original coding value.
These read the anti-theft "safe code" from a head unit so it can be paired with the cluster. Each is only valid for one radio address.
KW1281Test PORT BAUD 56 ClarionVWPremium4SafeCode
Only supported for radio address 0x56. Sends the ReadSafeCode command
(block title $F0, read) and prints the 16-bit safe code as 4 hex digits
(Safe code: XXXX).
KW1281Test PORT BAUD 7C DelcoVWPremium5SafeCode
Only supported for the radio manufacturing address 0x7C. Performs a login
using the "DELCO" secret, then reads two bytes of ROM/EEPROM at 0x0014 and
prints them as the safe code.
The KW1281 protocol distinguishes several memory spaces:
- EEPROM β non-volatile memory holding codings, the SKC, odometer, etc.
- ROM β (mask/flash) program/read-only memory.
- RAM β volatile working memory.
Most read commands unlock the module first (login/seed-key) because memory
access is permission-gated. For a VDO cluster that means the cluster-specific
seed/key dance; for CCM / central-locking / central-electric it sends a fixed
login (the codes VDS-PRO uses). If a read is NAK'd, the tool prints a
β¦ read failed message.
Single-byte reads print Address N ($NNNN): Value V ($XX).
KW1281Test PORT BAUD ADDRESS ReadEeprom ADDRESS
Reads a single byte from EEPROM at ADDRESS (16-bit address space).
KW1281Test PORT BAUD ADDRESS ReadROM ADDRESS
Reads a single byte from ROM at ADDRESS.
KW1281Test PORT BAUD ADDRESS ReadRAM ADDRESS
Reads a single byte from RAM at ADDRESS.
KW1281Test PORT BAUD ADDRESS DumpEeprom START LENGTH [FILENAME]
Dumps LENGTH bytes of EEPROM starting at START to FILENAME (default name
derived from the module identification + start address, e.g.
β¦_0x0000_eeprom.bin). Only supported for cluster, airbag, CCM, central
locking and central electric addresses; other addresses print a "not
supported" message. A cluster dump uses the VDO seed/key path and reads in 16-byte
blocks; CCM-family dumps read in 8-byte blocks. If any block can't be read it is
zero-filled and a warning is printed.
VW51/VW61/1C0909601 airbag controllers only: Logicalβphysical mapping: logical 0 maps to physical 0x0800 (VW51/1C0909601) or 0x0D00 (VW61). Default filename is Airbag_{addr}eeprom{start}_{length}.bin
KW1281Test PORT BAUD ADDRESS DumpEeprom [FILENAME]
Only supported for VW51, VW61 and 1C0909601 airbag controllers. Dumps the whole EEPROM from address 0, size auto-detected (VW51 = 512 Bytes, VW61 = 768 Bytes, 1C0909601 = 784 Bytes, the last unconfirmed).
KW1281Test PORT BAUD ADDRESS DumpRom START LENGTH [FILENAME]
Dumps LENGTH bytes of ROM from START to FILENAME (default
rom_0xSTART.bin). Reads in 8-byte blocks after unlocking the module. Used, for
example, to pull the full program from a module.
KW1281Test PORT BAUD ADDRESS DumpRam START LENGTH [FILENAME]
Dumps LENGTH bytes of RAM from START to FILENAME (default
ram_0xSTART.bin). Reads in 8-byte blocks after unlocking.
KW1281Test PORT BAUD 17 DumpMarelliMem START LENGTH [FILENAME]
Dumps a Magneti Marelli cluster's EEPROM (cluster address 0x17 only).
Marelli clusters read memory by uploading a small program to the cluster and
running it, so this uses the Marelli cluster handler. Because different Marelli
variants have different EEPROM sizes/starts, if you're unsure which region is
valid the wiki suggests probing, e.g.:
kw1281test.exe COM1 9600 17 DumpMarelliMem 3072 1024
kw1281test.exe COM1 9600 17 DumpMarelliMem 14336 2048
KW1281Test PORT BAUD 17 DumpRBxMem START LENGTH [FILENAME]
Dumps memory of a Bosch RB4 / RB8 cluster (cluster 0x17). These clusters
communicate memory access over KW2000 (not KW1281), so the tool wakes the
module in KW2000 mode (even parity), unlocks it, and dumps LENGTH bytes from
START. Default file name RBx_0xSTART_mem.bin.
DumpRBxMemOdd (hidden)
KW1281Test PORT BAUD 17 DumpRBxMemOdd START LENGTH [FILENAME]
Exactly like DumpRBxMem, but the KW2000 wakeup uses odd parity
(evenParityWakeup: false) instead of even. For clusters that only answer the
KW2000 keyword with odd parity.
DumpCcmRom (hidden)
KW1281Test PORT BAUD 46 DumpCcmRom
Dumps the full 64 KB CCM ROM (CCM 0x46 or central-locking 0x35 only).
It reads the CCM ROM in a segment / msb / lsb layout (16 Γ 16 Γ 32, in 8-byte
blocks) and writes it to a fixed file ccm_rom_dump.bin (the FILENAME
argument is not parsed for this command). Unreadable bytes are zero-filled and a
warning is printed.
DumpClusterNecRom (hidden)
KW1281Test PORT BAUD 17 DumpClusterNecRom
Dumps the low 64 KB of a VDO cluster's NEC controller ROM (cluster 0x17
only) via a custom cluster command, in 16-byte blocks, to a fixed file
cluster_nec_rom_dump.bin. (For MFA clusters this is the whole ROM; FIS
clusters have a 128 KB ROM and only the low 64 KB is retrieved.)
KW1281Test PORT BAUD 17 DumpMem START LENGTH [FILENAME]
Dumps a VDO cluster's raw memory via its custom "read memory" command (3-byte
addresses, so it can reach beyond 16 bits). Cluster 0x17 only; performs the
VDO seed/key unlock first. Default file cluster_mem_0xSTART.bin.
MapEeprom (hidden)
KW1281Test PORT BAUD ADDRESS MapEeprom
Probes every EEPROM address 0x0000β0xFFFF once and writes a 64 KB map file
where each byte is 0xFF if that address reads (is live) or 0x00 if it
NAK'd/is absent. Useful for discovering the real size/boundaries of a module's
EEPROM. Cluster uses the VDO map path; CCM-family uses the byte-probe path.
Output file is fixed (eeprom_map.bin or ccm_eeprom_map.bin; the FILENAME
argument is not parsed for this command).
β οΈ These modify the module. A wrong value can disable a feature, break the immobilizer pairing, or make a module inoperable. Dump the affected range first (DumpEeprom) so you have a known-good backup, and change only what you mean to.
KW1281Test PORT BAUD ADDRESS WriteEeprom ADDRESS VALUE
ADDRESS = EEPROM address
VALUE = 0-255
Writes a single byte to EEPROM after unlocking the module. The tool verifies the module's write-acknowledge block echoes the address/value; a mismatch or NAK is reported as a failed write.
Example β VW T5 comfort module (CCM
0x46), disable three window-roll-up values (from10to2):kw1281test /dev/ttyUSB0 9600 46 WriteEeprom 4361 2 kw1281test /dev/ttyUSB0 9600 46 WriteEeprom 4362 2 kw1281test /dev/ttyUSB0 9600 46 WriteEeprom 4363 2
KW1281Test PORT BAUD 17 WriteRAM ADDRESS VALUE
VALUE = 0-255
Writes a single byte to cluster RAM (cluster 0x17 only), performing the VDO
seed/key unlock first. RAM is volatile β this only affects the module until its
next power cycle.
KW1281Test PORT BAUD ADDRESS LoadEeprom START FILENAME
START = EEPROM start address
FILENAME = file containing the binary data to write
Loads a binary file into EEPROM starting at START. Only supported for cluster,
airbag, CCM, central locking and central electric. It unlocks the module, reads
FILENAME from disk, and writes it in 16-byte blocks (cluster) or 8-byte blocks
(CCM-family), verifying each block. If FILENAME does not exist it aborts. This
is how you restore a previously dumped EEPROM.
These two commands work on Bosch EDC15 engine ECUs (engine address 0x01).
They are the only commands that fully use the KW2000 diagnostic protocol.
Both first end the KW1281 session and re-wake the ECU in KW2000 mode, then run a
built-in loader program (uploaded to ECU RAM at 0x40E000 and executed)
that drives the ECU's serial EEPROM. Authentication is level 0x41 (a real seed
is only computed when the ECU is already awake in KW2000 mode).
Because they replace code running in the ECU, a failed write can brick the ECU β the wiki recommends disconnecting the battery for a minute to recover. A backup of the whole EEPROM is written before any bytes are changed. This is the EEPROM, not the flash β you cannot upload a tune this way.
KW1281Test PORT BAUD 1 DumpEdc15Eeprom [FILENAME]
Dumps the full 512-byte EDC15 EEPROM to FILENAME (default
EDC15_EEPROM.bin) and then prints decoded information:
- SKC (5-digit immobilizer code)
- Odometer (km)
- VIN
- Immo number / ID
-
Immo status β
Offif EEPROM bytes0x1B0and0x1DEare both0x60, otherwiseOn.
KW1281Test PORT BAUD 1 WriteEdc15Eeprom ADDRESS1 VALUE1 [ADDRESS2 VALUE2 ...]
ADDRESS = 0-511
VALUE = 0-255
Dumps the EEPROM to a timestamped backup file
(EDC15_EEPROM_<timestamp>.bin), then writes each ADDRESS VALUE pair and
reboots the ECU. Addresses and values must be even-count pairs; addresses are
limited to 0β511 and values to 0β255. Addresses above 0xFF are written via
the EEPROM "page 1" path, the rest via "page 0".
The well-known use case is EDC15 immobilizer-off (set both immo bytes to
0x60):
kw1281test.exe com1 9600 1 WriteEdc15Eeprom 0x1B0 0x60 0x1DE 0x60
Reset (hidden)
KW1281Test PORT BAUD 17 Reset
Sends a VDO cluster custom reset command ($82). Cluster 0x17 only. Used,
for instance, after a mode change to make the cluster re-initialize.
KW1281Test PORT BAUD 17 ToggleRB4Mode
Wakes a Bosch RB4 cluster in KW2000 mode (even parity), unlocks it, and
toggles between its two operating modes β New Mode (4) and Adapted Mode
(6) β then resets the cluster. The cluster must be in New Mode to read the
SKC (via GetSKC) but must be in Adapted Mode for normal use, so the
typical flow is: GetSKC β if it reports "not in New mode", ToggleRB4Mode β
GetSKC β ToggleRB4Mode (back to Adapted).
- Wiring / power: ignition on (or the module's power supply active) and a working KKL cable are prerequisites for every command.
- Wakeup retries: if the module doesn't wake, the tool retries 3 times and, on failure, reminds you to check the cable, drivers, ignition, address and baud rate.
-
Writes are destructive:
WriteEeprom,WriteRAM,LoadEeprom,SetSoftwareCoding,AdaptationSaveandWriteEdc15Eepromchange module state. Always back up first (dump the range, or note the current coding). - EDC15 is highest-risk: it runs a loader in the running ECU; an interruption can brick it. Disconnect the battery for a minute to recover.
- SKC/adaptation: writing an SKC or key-count adaptation with the wrong value can lock you out of the immobilizer.
Everything the tool logs goes to both the console and a KW1281Test.log
file created in the current working directory (appended on each run). This log
contains the raw wakeup handshake, block titles, seed/key exchange, and every
byte sent/received, which is exactly what the project maintainers ask for when
you open a support issue. Interactive prompts (actuator-test keys, group-read
arrows) are printed to the console only.
| Command | Addresses it accepts |
|---|---|
ReadIdent, ReadFaultCodes, ClearFaultCodes, SetSoftwareCoding, ActuatorTest, GroupRead, BasicSetting, AdaptationRead/Test/Save, FindLogins, MapEeprom
|
most modules (some features depend on the module) |
DumpEeprom, LoadEeprom, DumpMem, WriteRAM, DumpMarelliMem, DumpRBxMem/Odd, DumpClusterNecRom, ReadSoftwareVersion, Reset, ToggleRB4Mode, GetClusterId
|
cluster 0x17
|
DumpEeprom, LoadEeprom (also CCM-family) |
cluster 0x17, CCM 0x46, central locking 0x35, central electric 0x09
|
DumpCcmRom |
CCM 0x46, central locking 0x35
|
GetSKC |
cluster 0x17, immo 0x25, ECU 0x01
|
ReadEeprom, ReadROM, ReadRAM, DumpRom, DumpRam, WriteEeprom
|
cluster / CCM / central modules (unlock-dependent) |
ClarionVWPremium4SafeCode |
radio 0x56
|
DelcoVWPremium5SafeCode |
radio manufacturing 0x7C
|
DumpEdc15Eeprom, WriteEdc15Eeprom
|
engine ECU 0x01
|