Skip to content

Releases

Beta v0.4.3

Choose a tag to compare

@PabloSoage PabloSoage released this 27 Oct 22:31

opendash 0.4.3 — the adapter's address from its own network

Context: one change on top of 0.4.2. A new release of the manufacturer's software asks
SM3 owners to update the adapter's Wi-Fi module, and the module firmware that update
installs does not contain the address the app has always used, 192.168.81.1.

Deliverable: android-arm64-v8a-release.apk and android-x86_64-release.apk,
versionCode 7, versionName 0.4.3, minSdk 26, three languages (en/es/de). Signed with the
same key as 0.4.0–0.4.2, so it installs over them and keeps presets, scans and recordings.


1. The change

Until now the adapter's address was a fixed setting, 192.168.81.1 unless changed by hand.

The Link screen, under Adapter, now has Address from the adapter's DHCP, on by
default. When Connect is pressed, the app takes the address from the adapter's network:

  • The DHCP server of that network, which is the adapter itself (Android 11 and newer).
  • Otherwise, its default gateway.
  • Otherwise, the address typed in, now labelled Fallback address.

The address found is shown on the screen and in the section summary.

This is how the manufacturer's own app finds the adapter. It keeps working if a Wi-Fi
module firmware moves the access point to another subnet.

2. Which network is asked

  • The network the app joined itself, if there is one.
  • Otherwise, a Wi-Fi network the system has not validated as having internet.

The adapter's access point never has internet, and a home router always does. So a phone on
its home Wi-Fi never takes the router for the adapter, and falls back to the typed address.

Turn it off to always use the typed address: for an emulator, or a bridge reached over
an ordinary network.

3. What the Wi-Fi module update changes, and what it does not

Checked against the manufacturer's software 2.21.35, 2.22.3 and 2.22.4, and against the
module firmware itself:

  • The frames are the same in all three versions: port 777, the 16-byte header, the h4
    CRC and the h8 sum.
  • The module does not look inside them. It is a TCP-to-UART bridge for one client at a
    time, so the update changes nothing the app sends.
  • What was left unproven was the address, and this release stops depending on it.

Host tests unchanged and passing. Release APKs built from the tagged commit and checked
against 0.4.2's signing certificate. Not yet run against an adapter with the updated Wi-Fi
module.

Beta v0.4.2

Choose a tag to compare

@PabloSoage PabloSoage released this 16 Oct 16:34

opendash 0.4.2 — updates that reach a phone with installs locked down

Context: one fix on top of 0.4.1, found the same day: 0.4.1 was offered as an update
on a phone where "install unknown apps" is locked by a security setting, and the update
could not be installed.

Deliverable: android-arm64-v8a-release.apk, versionCode 6, versionName 0.4.2,
minSdk 26, three languages (en/es/de). Signed with the same key as 0.4.1 and 0.4.0.
Everything in 0.4.1 — the ELM327 bridge that ScanMyOpel CAN can use — is in here too.


1. The fix

The update dialog asked for "install unknown apps" before listing the installers on the
phone. That permission is what the system installer needs from this app. A Shizuku-based
installer such as Install With Options installs on its own authority and does not. On a
phone where the permission is locked, the settings screen refused, and the installer that
would have worked was never offered.

The installers now come first, as in Rustify:

  • Two or more installers: the list, whatever the permission says.
  • One installer and no permission: the list too, so a Shizuku-based one can be picked.
  • Permission granted and a single installer: straight to it.
  • Nothing to choose from and no permission: the permission screen, as before.

2. Upgrading

  • From 0.4.0 or 0.4.1 on a phone with installs locked, install this one by hand once:
    download the APK from this page and open it with Install With Options (or another
    Shizuku-based installer). The update dialog in those versions still asks for the
    permission first. From 0.4.2 on, updates offer the installer list.
  • Anywhere else it is offered by the app as usual, and installs over 0.4.x keeping
    presets, scans and recordings.
  • The notes for 0.4.1 cover the bridge changes and the three new Astra J profiles in the
    opel-vauxhall plugin.

Host tests unchanged and passing. Release APK built from the tagged commit and checked
against 0.4.1's signing certificate.

Beta v0.4.1

Choose a tag to compare

@PabloSoage PabloSoage released this 16 Oct 16:28

opendash 0.4.1 — the ELM327 bridge that a real scan tool can use

Context: one commit in opendash on top of 0.4.0, and three new profiles in
opendash-plugins. Found and fixed on 16 October 2026 against an emulated engine module
of an Opel Astra J 1.7 CDTI (A17DTJ, Denso ECU), with ScanMyOpel CAN on a phone talking
to a desk copy of the bridge that logged every byte.

Theme: the bridge passed its own self-test and every command a generic OBD app sends
first, and still ScanMyOpel CAN could not connect. It speaks a part of ELM327 the bridge
did not.

Deliverable: android-arm64-v8a-release.apk, versionCode 5, versionName 0.4.1,
minSdk 26, three languages (en/es/de). Signed with the same key as 0.4.0, so it installs
over it and keeps its data, and 0.4.0 offers it as an update.


1. The headline

ScanMyOpel CAN against the bridge 0.4.0 0.4.1
Connecting hangs up on ATBI, 46 times in a row connects
Engine module not found identified, identification read
Stored codes — listed

2. What the scan tool was asking for

With every byte logged, the session reads like this:

  • ATBI, bypass the protocol search. The bridge answered ?, which a real ELM327
    only says to a command it does not have. ScanMyOpel CAN took that as the wrong adapter,
    hung up and started again, every time. There is no search to bypass — the bus is
    known — so it is now OK.
  • ATCAF0, then whole frames. The tool turns automatic formatting off and does its
    own ISO-TP: 02 1A 9A, 03 A9 81 12, the first byte being the frame's own length.
    The bridge acknowledged ATCAF0 and ignored it, so that length byte went to the module
    as the service: 03 A9 81 12 arrived as service 03 and came back "not supported".
  • Receive filters. Before each module it sets ATCM and ATCF (or ATCRA). For
    the engine, mask 5FF over 5E8 lets both 0x7E8 and 0x5E8 through, because GM
    modules answer A9 with one stored code per frame on 0x5E8, not in a reply on
    0x7E8. A request-and-answer exchange can never show them.

3. What the bridge does now

  • ATCAF0 carries whole frames. The client's frame goes on the bus as it is, and
    every frame that passes the client's filter comes back as it arrived, until ATST
    passes with nothing more. No filter set means the addresses an answer can come back
    on, not the whole bus — on this car that is 1300 frames a second.
  • Flow control as an ELM327 does it. When a first frame arrives, the "go ahead"
    goes out by itself, to the address and with the bytes the client set with
    ATFCSH/ATFCSD/ATFCSM, or not at all after ATCFC0.
  • Headers off now answers like an ELM327. It used to print CAN frames in every
    mode. A real adapter prints the message: 41 00 98 3B 20 13 for a single frame, and
    for a longer answer its length and then numbered lines (014, 0: 49 02 …). A client
    checking that the answer to 0100 begins with 41 00 decided there was no car.
    Headers on still prints the frames, protocol byte and padding included.
  • ATBI is accepted.

4. Still reading only

The bridge goes through the same list of services as the rest of the app, in both modes,
so another app on the phone can read what this one reads and no more:

  • Two services join the list, both from what ScanMyOpel CAN sends to find and read
    modules: 0xA9, stored codes by status, a read; and 0x20, return to normal mode,
    which ends diagnostic mode and writes nothing. The most it can do is stop this app's
    own live stream if both run at once.
  • A device command from another app (AE) still needs actuation unlocked here.
    Paid actuator tests in a third-party app do not get past the bridge on their own.
  • A raw frame is checked by the service inside it. Only single frames and flow
    control are carried; a client segmenting its own request would get its service past
    the check one frame at a time, so that is refused rather than reassembled.
  • A refused request answers NO DATA and the session goes on. It used to close the
    connection.

5. The rest

  • Host tests for the bridge session, nine of them, built from the recorded ScanMyOpel
    CAN session: ATBI, both answer formats, the long-answer format, the raw exchange with
    its filter and flow control, ATCRA wildcards, a refused write in both modes, and
    ATZ putting formatting back. 44 host tests in total, all passing.
  • The Kotlin bridge is now ahead of core/src/elm327.rs. Raw mode, the filters, flow
    control and the headers-off format exist only in Kotlin. The README says so; the core
    has to catch up before it replaces it.
  • No dependency changes.

6. Upgrading

  • 0.4.0 offers this update by itself. It installs over it and keeps presets, scans
    and recordings.
  • Update the opel-vauxhall plugin for three new profiles for the Astra J A17DTJ,
    all in one round at 100 Hz: EGR (the valve in volts and percent with the
    temperatures), fuel rail (rail pressure, its target and both regulator readings in
    the same packet, with the EGR beside it), and air conditioning (high-side pressure
    next to the compressor flags, and the cooling fan).
  • To use the bridge: start it on the Link screen and point the other app at
    127.0.0.1:35000 as a Wi-Fi adapter.

Found with ScanMyOpel CAN on a phone against a logging copy of the bridge on a laptop,
over an emulated A17DTJ engine module, on 16 October 2026. Not yet run with this APK on
the phone against the car. Release APK built from the tagged commit and checked against
0.4.0's signing certificate.

Beta v0.4.0

Choose a tag to compare

@PabloSoage PabloSoage released this 25 Sep 10:57

opendash 0.4.0 — a recording that is not cut, and the first output worth commanding

Context: four days, 21 to 25 September 2026, on top of 0.3.0. Four commits in
opendash, three in opendash-plugins, four in scanmatik-bench. One session at the
vehicle — an Opel Astra J 1.7 CDTI (A17DTJ, Denso ECU) — to declare the new round and
sweep the EGR valve against the oxygen sensor, followed by the drive that tested
everything: 160 km, two hours and eight minutes, 20.3 million readings, one file,
with the engine switched off for a refuel in the middle.

Theme: 0.3.0 said of its recording fixes that "the next long drive is the test".
That drive happened. This release is what it took for the drive to pass, and for the
app to open the file afterwards.

Deliverable: android-arm64-v8a-release.apk, versionCode 4, versionName 0.4.0,
minSdk 26, three languages (en/es/de). Signed with the same key as 0.3.0, so it installs
over it and keeps its data. From this version on, the app finds and installs its own
updates.


1. The headline

0.3.0 0.4.0
Engine switched off mid-recording the run gave up after three revivals resumes on its own, same file
Opening a two-hour recording the app closed opens, 78 MB of memory
Actuators a list with a padlock their own screen, gated by risk
Updates download by hand from GitHub offered by the app

2. A recording that is not cut

0.3.0 closed with two recordings that had died, at 65 and at 32 minutes, and two fixes that
were certain to help without being a cause that is understood. Instead of looking for
the one cause, this release removes every way a recording could end that is not the user
pressing stop:

  • Frames a request reads past are kept for the stream reader. Every polled
    parameter, heartbeat and declaration used to throw away the packets that arrived while
    it waited for its own answer.
  • The run ends only after twenty minutes without a single frame, never after a count
    of attempts. Three revivals per run was not enough for a long drive, and an engine
    switched off to refuel is exactly a module that goes quiet for minutes and comes back.
    The link is retried on the same clock.
  • Heartbeat every second from the reading thread, and silence detected after two
    seconds instead of three.
  • One bad slice no longer ends a run. It is reported and skipped.
  • The file is written on its own thread. A content provider that blocks could hold
    up the thread that sends the heartbeat, and the module drops the session about five
    seconds after the last one. A failed write now carries on in a new file instead of
    ending the recording.
  • The recording belongs to the process, not the screen. A rebuilt or reclaimed
    activity — a rotation, the system reclaiming memory with the screen off — used to stop
    it.
  • A high-performance Wi-Fi lock beside the low-latency one, which does nothing with
    the screen off.

The test: Coruña to Cangas on 24 September, 2 h 8 min, 20.3 million readings in a
single file. Halfway, the engine was off for 221 seconds at a petrol station; when it came
back the app declared the packets again and kept writing to the same file. Nobody touched
the phone.


3. And a recording that opens

That file then closed the app when it was tapped. Twenty million readings across 33
channels, twelve bytes each and twice that while an array grows, is past what Android
gives an app.

Each channel now keeps at most 50 000 points, thinned as the file is read. A chart on
a phone is a few hundred pixels wide, so that is still more than a hundred points per
pixel. It keeps the extreme of each stretch, not whichever reading happens to fall on
a stride. A boost peak, a rail dip or the limiter is usually why the file is being opened,
and striding throws exactly those away.

The file is also streamed from storage instead of loaded whole first. Measured on the
drive above with the memory capped at 256 MB: 1.27 million points kept, 78 MB used.
The summary still counts the file's readings, not the ones kept. If memory runs out
anyway, the screen says so instead of closing.


4. Actuators, behind a gate that grows with the risk

Actuators have their own screen, reached from the Live header. The list comes from the
catalogue (actuators.tsv), so a newly captured command is a row in a plugin, not a
release. Each row carries what it does, when to use it, how, and what can go wrong.

Tier What it takes
Harmless — horn, wipers, door locks, lamps, gauge sweep fingerprint
Low — EGR valve, window, cooling fan, glow plugs the warning read, fingerprint
Engine + a checklist, 0 km/h read from the car before every command, the screen lock instead of a fingerprint
Learn / reset + the actuator's name typed, ten seconds' wait
Do not touch + a sentence typed, thirty seconds, and the screen lock again before every command

A held output is released when the panel closes, and AE 00 (give everything back to
the module) is never behind any gate. Requests are serialized across threads, so a
command works while the live view keeps streaming. The panel charts what the live view is
reading, so you can see the effect of a command: EGR against air flow, rpm and fuel.

One row is commandable today: the EGR valve (CPID 0x1C, 0–100 %), verified at the
car. The Opel catalogue lists 44 outputs across the five tiers. The rest are shown with
their warnings but can't be commanded yet: their command numbers are in the
manufacturer's own data package, and each one gets a button once it has been tried at the
car.


5. What is being recorded, from outside the app

  • The notification says it: rows written, rate, and the last problem, if there was
    one.
  • A Mark button, on the notification and on the Live header, writes a marker row into
    the recording, to find later the moment something happened without stopping the car to
    write it down.

6. Updates from inside the app

Ported from Rustify. On start, and from Settings → About, the app asks GitHub for this
project's releases, including betas. It compares versions numerically and downloads the
APK for the phone's architecture. If more than one installer is on the phone, it lets you
choose which one opens it. The check can be turned off.

This is the first version that has it, so 0.3.0 cannot find 0.4.0 by itself. Install
this one by hand; the next one will be offered.


7. The rest

  • Live header in two rows. On a phone held upright, the module name got whatever the
    header had left over, which was nothing. It now has its own row and opens the setup
    when tapped.
  • A catalogue whose profiles changed replaces its presets on update. Before, the new
    profile arrived and the old copy stayed in the list.
  • Host tests for the new parts: the recorder writing on its own thread and recovering
    from a failed write, version comparison and APK choice for updates, the actuator table,
    and a spike that must survive thinning four times over the cap. 35 in total.
  • No dependency changes.

8. Upgrading

  • Install this APK by hand once. It goes over 0.3.0 and keeps presets, scans and
    recordings.
  • Update the opel-vauxhall plugin. It brings a new single-round profile — 33
    magnitudes, 49 of 49 bytes, nothing rotating — and the actuator table. Its presets
    replace themselves; apply the profile again if it was the one in use.

Measured against an Opel Astra J 1.7 CDTI (A17DTJ): the new round and the EGR sweep with
the car parked on 24 September 2026, and the 160 km drive that evening, recorded through
the app in one file of 20.3 million readings. Release APK built from the tagged commit and
checked against 0.3.0's signing certificate.

Beta v0.3.0

Choose a tag to compare

@PabloSoage PabloSoage released this 20 Sep 23:18

opendash 0.3.0 — twelve samples a second to three thousand, and a ceiling that was never the car's

Context: four days, 17 to 21 September 2026, on top of 0.2.0. Twenty commits in
opendash, five in opendash-plugins, sixteen in scanmatik-bench. Five sessions at
the vehicle — an Opel Astra J 1.7 CDTI (A17DTJ, Denso ECU) — plus one with the
manufacturer's own software captured in a virtual machine while the car idled outside.
Two hours and twenty-one minutes of driving recorded through the app, 14.5 million
readings.

Theme: 0.2.0 was about everything that was wrong once the app could talk to the
car. This one is about everything that was wrong once it could measure — because two
of the numbers this project had been building on turned out to be measurements that
stopped at the first refusal instead of looking for the boundary.

Deliverable: android-arm64-v8a-release.apk, versionCode 3, versionName 0.3.0,
minSdk 26, three languages (en/es/de). Host tests, which this project did not have.


1. The headline

0.2.0 0.3.0
Live data, catalogue parameters 1 044 samples/s 3 163 samples/s
Live data, standard OBD 12 samples/s 80 samples/s
Opening a 20 MB recording 12.8 s 3.9 s
Parameters live at once 30 40
Preparing a recording needs the car needs nothing

None of it came from optimising anything.


2. Two ceilings that were ours, not the module's

2.1 The module does not charge a price per packet

The belief: five packets emit at about 96 Hz each and seven fall to 51, so declaring two
more packets lowers the total. Everything about rotation was built on it — five packets
to a round, the dwell, the round switch, and the seven-second gaps.

Measured again at the car with our own client, declaring and reading for real:

 packets  ids each  total  Hz each  frames/s  samples/s
       1         6      6     99.6       100        598
       3         6     18    100.0       300      1 801
       5         6     30     99.9       500      2 998
       7         5     35     99.6       697      3 485

Seven packets emit as fast as one. The 51 Hz was this side not reading fast enough. A
capture of GDS2 the same day agrees from the outside: seven packets at 97.6 Hz each,
683 frames a second.

2.2 And the limit is not bytes

The replacement belief, arrived at the same way: 7 × 5 = 35 declared bytes is accepted and
6 × 6 = 36 is refused, therefore the ceiling is 35 bytes. It was the first refusal in a
short list, not a boundary.

Changing one variable at a time:

seven packets of 3 ids of 2 bytes    42 bytes, 21 ids    accepted
seven packets of 4 ids of 7 bytes    49 bytes, 28 ids    accepted
seven identifiers in ONE packet                          refused
forty identifiers                                        accepted
forty-one identifiers                        refused, 7F 2C 31

What the module counts is identifiers: forty. Bytes have their own ceiling and it is
structural rather than measured — a packet is one CAN frame, so its payload is seven
bytes and seven packets is 49. A two-byte magnitude therefore costs exactly the same as a
one-byte one.

A measurement that stops at the first failure is not a limit. This release learned
that twice, and the second time cost a rewrite of the first fix.

2.3 Six PIDs to a request

Mode 01 takes up to six PIDs in one request. The app asked for one at a time, and a round
trip on this car is about eighty milliseconds, so twenty-five parameters were two seconds
a lap — the twelve readings a second the screen was showing.

This was implemented in 0.3.0 deduced from a rate and then confirmed at the car:
six per request, ×2.7, 88 of 88 read either way.

An earlier measurement of the same thing gave ×14 and was false. The stopwatch included
a PID this car does not have, and each attempt spent 1 500 ms in a timeout. That does not
compare two ways of asking; it compares one way of asking against a wait.

Batching then exposed a bug that had never cost anything: flow control was sent to the
functional broadcast 0x7DF
. A broadcast "carry on" is addressed to nobody, so the
module holding the rest of a long answer never hears it. Invisible while every answer
fitted in one frame — which is exactly what a multi-PID reply stops doing.


3. The app stopped needing the car to be useful

Everything a scan finds is keyed by VIN, and the VIN only ever comes from the car. So a
phone on a table knew nothing about a vehicle it had spent ten minutes scanning in the
cold: no list, no groups, nothing to think about until you were back at the kerb with the
engine running.

The VIN is remembered now, and the standard PIDs the car advertises are kept beside the
scan. Reading values needs the link; deciding what to read does not — and deciding
what to read is the slow part.

A catalogue can also publish known vehicles (vehicles.txt): what one car of that
kind answered, with the width of every answer. Adopting one keys it exactly where a VIN
would go, so every screen that already worked from a scan works from this one without
knowing the difference. No VIN in the file, and the day it was scanned travels with
it — a profile from elsewhere is exactly where "how old is this" matters.


4. Where a recording gets designed

The order of a selection is not cosmetic, and there was nowhere to see it. Two identifiers
next to each other share a packet, a packet arrives in one CAN frame, and one frame is
one instant. Two values you mean to compare must sit together; split across rounds they
were never measured at the same time, and every conclusion drawn from comparing them is an
artefact of the layout.

The new sheet shows every round, every packet, and how many of its seven bytes are
used
— a packet with room left is one that could carry another magnitude at no cost at
all, and that number is invisible anywhere else. With more than one round it also says, in
seconds, how long each parameter is dark between its turns.

And rows that cannot afford a gap ride in every round. Road speed above all: over the
119 km run of 18–19 September, seven separate speed drops fell entirely inside a
rotation gap
— one of them 89 km/h down to 28 with nothing at all in between, so all
that can be said of that braking is that it was at least 1.84 m/s², where the one event
that did land inside an emission turned out to be 0.93 g.


5. Three bugs that cost real data

5.1 Forty asked for, thirty-three recorded

One line filtered pid > 0xff, and with it went every catalogue row whose identifier
collides with a standard OBD PID
. It cost the seven that mattered most: mass air flow,
the real rail pressure, the EGR target and its error.

It did not fail loudly. The row simply was not in the list, and a profile naming it
selected nothing.

5.2 Opening a long recording closed the app

Two and a half hours is 5.7 million rows: 312 MB of text decompressed, 624 MB again as a
String because Kotlin's is UTF-16, and then boxed lists. It was over before a single row
was parsed.

It now scans the bytes in a sliding window and allocates nothing per row. Measured on the
real files, with the sample count identical to the unit: 20 MB and 5.67 million readings
from 12.8 s to 3.9 s, the 6 MB ones from 3.9 to 1.7.

5.3 The recording that said it was recording

Two have died the same way, at 65 and at 32 minutes, with the rate flat up to the last
sample
— 2 443 samples a second in the first minute of the second one and 2 542 in the
thirty-first. That is what rules out memory: memory decays, these fell off a cliff.

What the loop could not tell is that a read finding nothing is not a failure. It
returns a batch of zero frames, which is exactly what an idle moment looks like, and with
a single round there is no dwell to expire — so it span, for ever, while the screen said
"recording, 0 samples/s" for the remaining hour and a half of the drive.

Three seconds of silence now ends the round and declares the packets again. The heartbeat
also moved onto the thread that owns the socket: a module drops the session about five
seconds after the last TesterPresent, and the thread whose job that was has to take the
client lock — which the reading loop holds while it drains seven hundred frames a second.

Both fixes are certain to help and neither is a cause that is understood. The next
long drive is the test.


6. The rest

  • The live screen, rebuilt: one mode at a time. A header of at most two lines carrying
    the one button that matters, and everything else in sheets that slide over the top.
  • The link screen, rebuilt as a chain of three steps.
  • A group keeps its order. It was stored as a set, and the order is what decides which
    identifiers share a packet.
  • One refused round no longer ends a two-hour recording.
  • The vehicle panel opens itself when there is something in it.
  • Actuators, listed with the padlock on. The service is GMLAN $AE DeviceControl and
    it takes a CPID, a different namespace that appears in no catalogue. One is known
    and it works: the EGR valve, 0x1C, commanded at the car with the air flow falling from
    9.33 to 4.45 g/s at a constant 750 rpm — and rising when the valve is closed below what
    the ECU was doing by itself.
  • A .sm2 that holds a screen is shown as a screen. The Windows software saves files
    from screens with no series in them at all, under the same signature; read as recordings
    they produced a screenful of numbers that meant nothing. A recording marks its parameter
    names with 1, a saved screen marks its cells...
Read more

Beta v0.2.0

Choose a tag to compare

@PabloSoage PabloSoage released this 17 Sep 20:47

opendash 0.2.0 — a session that survives the drive, and a list that tells the truth about the car

Context: three days, 15 to 17 September 2026, on top of v0.1.0-beta. Ten commits
in opendash, two in opendash-plugins, four in scanmatik-bench. One session at the
vehicle — an Opel Astra J 1.7 CDTI (A17DTJ, Denso ECU) — driven from a Windows bench
over the adapter's Wi-Fi while the owner worked the pedals.

Theme: 0.1.0 established that the app could talk to the car. This release is about
everything that was still wrong once it could: a recording that came home empty, a
viewer that could not open its own files, a pedal reading 798 %, injectors reported as
broken that were not, and a forty-seven-parameter selection in which thirty-seven
parameters never received a single sample.

Deliverable: android-arm64-v8a-release.apk, versionCode 2, versionName 0.2.0,
minSdk 26, three languages (en/es/de). 50 Kotlin files, 11 Rust files, 242 strings.


1. Change catalogue

ID Area Item Type
L1 Link Channel narrowed to four PASS filter ranges instead of the whole bus fix
S5 Streaming All seven packets used, not five: fourteen identifiers, not ten fix
S6 Streaming What does not fit in the packets is polled rather than dropped fix
S7 Streaming Frames per second reported alongside samples per second feature
S8 Streaming Extras polled every 300 ms instead of once per loop fix
D1 Data Row width taken from the car's answer, not from the catalogue fix
D2 Data Signed rows read as signed where the declared minimum is below zero fix
D3 Data Unitless single-bit rows read as On/Off rather than 1.00 fix
R2 Recording Foreground service, Wi-Fi lock and wake lock, so a locked screen keeps recording fix
R3 Recording Recording on by default, and next to Start rather than folded away fix
R4 Recording Reader takes its columns from the header, so it can open what the writer writes fix
R5 Recording Flush every 250 ms rather than every row fix
R6 Recording No file created until the first row, so an empty run leaves nothing fix
U1 UI Live screen is one scrolling surface; the setup panel is the list's first item fix
U2 UI Selected (n) filter, and named groups per module feature
U3 UI The fast switch says why it is refusing fix
U4 UI System back closes the screen you are on, not the app fix
C3 Catalogue A catalogue can publish profiles.txt: named selections, ready-made feature
C4 Catalogue A catalogue carries a content revision, so refresh can report an update feature
C5 Catalogue Profiles are listed and importable from the catalogues screen, without the car fix
A10 Actuation Rows naming an output are listed with a padlock; the Settings lock now gates something feature
A11 Actuation $AE DeviceControl permitted only while unlocked; AE 00 release implemented feature
B1 Bench 63-perfil-del-coche.mjs builds a car's profile from a probe feature
B2 Bench 82-grafo-del-vatbin.mjs reads GDS2's option tree with its own loader's format feature
B3 Bench 83-actuadores.mjs inventories what the ECM drives feature
B4 Bench 60-app-en-windows.mjs --hacer maniobras: a time series, driven from the bench feature

2. Measured at the vehicle, 17 September

Engine running, idle to 3 000 rpm, the bench driving the adapter over Wi-Fi from a
Windows machine while the owner worked the throttle.

Measurement Value
Unfiltered bus, this car ~1 340 CAN frames/s
Of those, frames with the exact shape of a complete ISO-TP single frame ~173/s
Five packets declared, two identifiers each ~96 Hz per packet — 960 samples/s over 10 parameters
Seven packets declared, two identifiers each ~45 Hz per packet — 630 samples/s over 14 parameters
Parameters this engine's variant lists 1 179
Of those, answering 0x22 with a width matching a catalogue row 331
Rows dropped because the car's width disagreed with the catalogue's 91
Rows that qualified as signed; rows that came back into declared range 33; 13
Rows naming an output (suffix "Command") 29

The packet figure is the one worth carrying forward. Five packets are faster per
parameter and faster in total than seven
, and nothing in the design predicted that:
2 × 5 = 10 parameters at 96 Hz beats 2 × 7 = 14 at 45 Hz on aggregate throughput as well
as on resolution. The manufacturer's own tool never ran more than four packets in the
captured session, which now reads less like caution and more like somebody having
measured this before.

This has not been turned into a cap in the app, and that is a deliberate reversal of
an earlier intention. Hard-capping at five packets would reinstate the ten-parameter
ceiling that S5 exists to remove. The measurement is reported; the count still follows
the selection. Choosing between resolution and breadth is the user's, and the screen now
gives them the numbers to choose with — which is what S7 is for.


3. Two readings that were impossible

Both had the same root: a catalogue identifier carries several rows and the app was
choosing among them without asking the car.

3.1 The accelerator at 798 %

0x131F carries three rows — one byte scaled by 100/255, and two of two bytes, one of
them scaled as though it were still a byte. This car answers one byte. Picking a
two-byte row applies a scale built for a width the module does not send.

The probe already had the answer and threw it away: it read the reply and kept only the
fact that something came back. It now keeps the width, CarProfile stores it as
id:bytes pairs, and rows whose width disagrees with the car are not offered. Ninety-one
of this module's 331 answering rows fail that test.

3.2 Injector balancing rates at +0.46 ms

They run −0.256 to +0.254 ms: a signed byte times 0.002. Read unsigned, cylinders 3
and 4 reported +0.460 and +0.450 where the car is trimming −0.052 and −0.062 — a healthy
engine reported as a broken one, on the screen somebody uses to judge injectors.

The rule is narrow on purpose: a declared minimum below zero and no offset in the
formula, so a coolant temperature at (X(0)*1)-40 is untouched. Across this car's
answering identifiers, 33 rows qualify, 13 come back into their declared range, and none
leaves it.


4. The drive that came home empty

A twenty-minute drive recorded nothing, because the phone locked. Three things had to be
true and none were:

  1. a foreground service — the ELM327 bridge had one; the part that writes the file had
    nothing;
  2. a Wi-Fi lock — Android powers the radio down with the screen, and the adapter's
    access point is an ordinary network as far as the phone is concerned
    (WIFI_MODE_FULL_LOW_LATENCY on Q+, WIFI_MODE_FULL_HIGH_PERF below);
  3. a partial wake lock, so the reading thread keeps running.

LiveService holds all three for exactly as long as a run lasts, including when a run
ends by itself.

Three further costs the same session exposed:

  • A viewer that could not open its own files. The recorder grew an identifier
    column; the reader still counted to four. On a five-column file the fourth field is the
    unit, "%".toDoubleOrNull() is null, every line was skipped, and a complete
    185 000-row recording opened as "no readings in this file". Columns now come from the
    header.
  • Many files, most of them ten bytes. A sink was created per run whether or not
    anything was ever written to it. Creation is lazy now: no first row, no file.
  • A gzip sync-flush per row. Correct when a row was a polled reading four times a
    second; ruinous at seven hundred a second, on the one thread that has to be back
    reading the socket before the module sends the next packet. Every 250 ms now — at most
    a quarter second lost to a cut session, which is the trade the code already claimed to
    be making.

5. The ten-parameter ceiling was ours

Forty-seven parameters selected; the first ten reading, the other thirty-seven never
receiving a sample.

Five packets × two identifiers. Those are limits on a message — five packet numbers is
what one AA 04 frame carries — and they had been read as limits on a plan. The
protocol numbers seven packets (0xF8–0xFE), and a start now goes out as as many AA 04
commands as it takes. Past fourteen identifiers a packet only holds seven bytes, so seven
of them hold forty-nine bytes however they are declared; the remainder is polled one per
turn round the stream loop instead of being dropped. Everything selected gets data — the
packets fast, the rest a few times a second — and the screen says which.

A related fault, found the same evening: streaming stopped after two or three seconds.
The module stops emitting about five seconds after the last 3E, and the stream loop sent
none. The bench had known this for weeks; the app had never been told. The loop now runs
inside a whileStreaming block that keeps the heartbeat going.


6. Four filter ranges instead of the whole bus

The adapter's own light was the clue: it blinks hard the moment this app connects and asks
for nothing, where the manufacturer's software sits quiet.

It was doing what it was told. The opening this app replays is the manufacturer's driver
byte for byte, and its channel message carries one filter: PASS mask=0 pattern=0 — send
everything. On this car that is about 1 340 f...

Read more

Beta v0.1.0

Choose a tag to compare

@PabloSoage PabloSoage released this 14 Sep 20:52

opendash 0.1.0 — a Scanmatik SM3 over Wi-Fi, a GM parameter catalogue, and an ELM327 bridge

Context: first release. A proprietary Wi-Fi diagnostic adapter with no public
protocol, an Android app that speaks it, and the parameter catalogues of the
manufacturer's own tool. Fifteen days, 31 August to 14 September 2026, across three
repositories: opendash (the app, GPL-3.0, public), opendash-plugins (the
catalogues, private) and scanmatik-bench (the reverse-engineering bench, private).

Method: empirical throughout. The protocol was taken from packet captures of the
factory tool and then confirmed against a physical vehicle — an Opel Astra J 1.7 CDTI
(A17DTJ, Denso ECU) — over three sessions at the car. Nothing in section 3
is inferred from a capture alone unless it says so. Where a thing is believed rather
than measured, section 7 says which.

Deliverable: android-arm64-v8a-release.apk, minSdk 26, three languages
(en/es/de). 47 Kotlin files, 7 Rust files, 17 core tests.


1. What it is

A diagnostic application for Android that talks to a Scanmatik SM3 over the
adapter's own Wi-Fi access point, and turns it into three things:

  1. a live data screen driven by the manufacturer's own parameter catalogue, able
    to read a module's own identifiers rather than the twenty-odd standard OBD PIDs;
  2. an ELM327 bridge — a TCP server the phone runs, so any existing OBD app can use
    an adapter that speaks nothing it has ever heard of;
  3. a recorder, writing gzipped CSV as the session happens.

The adapter is not an ELM327 and does not pretend to be. It is a J2534 pass-through
with a proprietary TCP protocol; the whole of section 3 is what had to be established
before any of the above could exist.


2. Change catalogue

ID Area Item Type
P1 Protocol 16-byte frame header, wire stride align(16+len, 4) feature
P2 Protocol h4 identified as a CRC, reflected polynomial 0x9960034C feature
P3 Protocol h8 = sum of the padded data as little-endian words feature
P4 Protocol Both signatures closed for any length, so messages can be constructed feature
P5 Protocol Opcode map: greeting, open, session, config, channel, status, control, voltages, bus, pushed frames feature
P6 Protocol Channel block with real filters, built and signed by us, accepted by the adapter feature
G1 GMLAN This bus is GMLAN, not UDS: TesterPresent is a bare 3E, no sub-function fix
G2 GMLAN A module answering on 0x64X emits on 0x54X; the engine answers 0x7E8 and emits 0x5E8 fix
G3 GMLAN The eight bytes of a bus write are the CAN frame itself, not a length and seven fix
G4 GMLAN Identification block: 1A 90 VIN, 92 supplier, 97 engine type, 98 subscriber, 99 date, B4 traceability feature
S1 Streaming 2C <dpid> <id16>… declares a packet, max 2 identifiers; 6C acknowledges feature
S2 Streaming AA 04 <dpid>… starts up to 5 packets at once, AA 00 stops feature
S3 Streaming ~101 frames per second per packet, measured feature
S4 Streaming The module stops emitting after ~5 s without a 3E; the stream needs a heartbeat fix
A1 App Link screen: joins the adapter's Wi-Fi, opens the channel, shows battery feature
A2 App Identification: module sweep and the 1A block, per module feature
A3 App Live data: catalogue by module and variant, search, selection, charts feature
A4 App "Ask this car": probes the catalogue with 0x22 and remembers what answered, per VIN feature
A5 App Fast mode: declares packets and reads the module's own emission feature
A6 App Health: fault codes and EOBD readiness monitors feature
A7 App Recordings: gzipped CSV, and a viewer for Scanmatik's own .sm2 feature
A8 App ELM327 bridge as a foreground service, so it survives a locked screen feature
A9 App Plugin catalogues: install, browse, fetch over SFTP feature
C1 Catalogue A catalogue key names a concept; a row is identified by name, id, width, formula and unit fix
C2 Catalogue Variants carry the module they belong to, and modules carry a CAN address feature
R1 Research The GDS2 vehicle database (vatbin.bin, 89 MB) read with the format its own loader declares feature

3. The protocol, as established

3.1 The frame

The adapter is a plain TCP server on 192.168.81.1:777 once the phone has joined its
access point, which is named DIRECT-SCANMATIK-#<serial>. Every message is a 16-byte
header followed by data:

seq u16 | token u16 | h4 u32 | h8 u32 | op u8 | len u16 | chk u8

and the next message begins at align(16 + len, 4).

chk is a one-byte checksum over the opcode and length. The two long words are the
part that mattered: without them the adapter closes the connection on the first
malformed message, which from the outside is indistinguishable from a broken socket.

  • h8 is the sum of the data as little-endian 32-bit words — including the
    padding
    , which is not zero. A block of 305 data bytes ends in 1e a1 f1, and
    zeroing it changes the signature.
  • h4 is a CRC with reflected polynomial 0x9960034C. It was first fitted as an
    affine function of the payload, which worked for one shape of message and silently
    failed for others; identifying the polynomial closed it properly. The chain for a
    message of arbitrary length is anchored at the last bit of the padded data,
    which is what allows a message of any size to be signed rather than only replayed.

Being able to construct messages rather than replay captured ones is what made
everything after this possible.

3.2 The channel

Opening the bus is a 0x50 message: the speed as a u32 at data+134, the filter count at
142, and 59-byte filter records from 305. A filter is a mask, a pattern, and a type —
pass, block, or flow control.

The app used to open the channel with a single PASS mask=0 pattern=0, which is "send
me everything". Measured against the factory tool:

GDS2        9 addresses,  99.6 % of it the emission it asked for
the app    51 addresses,  1 340 frames/s,  173 decoy frames/s

Those 173 frames a second are what made the app lose races against its own answers.
The release builds a channel with four pass filters — 0x7E8..0x7EF, 0x640..0x65F,
0x540..0x55F, 0x5E8 — signs it, and the adapter accepts it. Verified at the car on
14 September: with the filters in place the frame rate drops to nothing while idle and
the VIN still reads whole through it.

3.3 The bus is GMLAN

Three assumptions carried over from UDS cost a day each.

  • TesterPresent has no sub-function. 3E 00 is answered 7F 3E 12, sub-function
    not supported. It is a bare 3E.
  • A module emits on a different address from the one it answers on. Module 0x24X
    answers on 0x64X and emits on 0x54X; the engine answers on 0x7E8 and emits on
    0x5E8. Streaming looked completely dead until this was found — the frames were
    arriving the whole time, on an address nothing was listening to.
  • A write carries the CAN frame, not a payload. The eight bytes of a bus write are
    the frame itself. Sending flow control as 08 30 00 — a length byte and the frame —
    meant multi-frame answers never continued, and the VIN came back as its first four
    characters.

3.4 Streaming

The factory tool does not poll. It declares a packet with 2C, naming the identifiers
and their order, and tells the module to emit it with AA 04. Measured over one
factory session: 480 requests from the tester against 167 447 frames pushed back,
across seven packets.

Both commands travel as ISO-TP single frames, which carry seven bytes. That caps a
declaration at two identifiers and a start command at five packets — a limit learned
the hard way, from a payload that went out with a PCI byte promising nine bytes and
seven behind it.

A module told to emit then hears nothing more from the tester, so it drops the session
and stops sending after about five seconds. The stream has to be held open with a 3E
every two seconds, exactly like a sweep.


4. The app

Link. Joins the adapter's access point from inside the app, so mobile data can stay
on and the socket is pinned to the right network. Opens the channel, polls the battery
off the adapter rather than the bus.

Identification. Sweeps for modules that answer, then reads the 1A block from each
one. The VIN answered consistently from eight different modules on the test vehicle.

Live data. The catalogue is chosen by module first and variant second. A marque
catalogue is every configuration the manufacturer ever shipped — 21 381 parameters for
Opel across 221 variants — and offered flat it is not a list, it is a reason to close
the screen. Grouped by module it is a dozen readable names, with the ones this car
answered on first.

Ask this car. The catalogue cannot say which configuration is parked outside: the
GDS2 packages carry no model-to-variant table. So the module is asked. The probe walks
every identifier the module's catalogue names, keeps what answers, and stores it
against the VIN. On the test vehicle: 2 638 identifiers asked, 204 rows kept of the
engine's 5 249 — a 96 % cut, and it agrees with what the factory tool's own session log
says this car is.

Fast mode. Declares packets and reads the module's own emission, at about a hundred
frames a second against the four or five a second that polling shares between
everythi...

Read more