Skip to content

Beta v0.3.0

Choose a tag to compare

@PabloSoage PabloSoage released this 20 Sep 23:18
· 14 commits to main since this release

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 with 0, and that integer is the whole
    difference.
  • A round change costs 1 832 ms, not the 200 that had been assumed.
  • Host tests, which this project did not have: junit, a test source set, and the
    shapes that have actually turned up — five columns and four, quoted names, namesakes
    told apart by identifier, gzip by signature, negatives and exponents and sixteen-digit
    decimals, CRLF, a row straddling the buffer refill, a recording torn off mid-row, and a
    .sm2 record split across a sector seam.

7. Dependencies

The whole version catalogue moved, in step with the other Android project that builds on
the same machine — bumping one and not the other is how a Gradle sync starts failing for
reasons that have nothing to do with the app.

from to
Android Gradle Plugin 9.4.0 9.4.1
Kotlin 2.2.10 2.4.20
Compose BOM 2026.06.01 2026.09.00
AppCompat 1.7.1 1.8.0
sshj 0.38.0 0.40.0
Bouncy Castle 1.78.1 1.86
SLF4J 2.0.13 2.0.19

Bouncy Castle 1.86 breaks the release build, and the error does not make it obvious
why: it started shipping META-INF/LICENSE.md in each of its three artefacts, and three
identical files at one path is a failed mergeReleaseJavaResource rather than a warning.
Those META-INF licences and notices are now excluded from the package. That is not
dropping the licences: they stay in the sources, and an APK has nowhere to show a
META-INF file anyway.

A dead alias also goes: kotlin-android was declared in the catalogue and referenced by
nothing, because the Compose plugin already brings the Kotlin Android one with it.


8. Upgrading

  • Re-import the opel-vauxhall profiles. The catalogue revision moved several times
    and it now publishes two: one for driving, with rounds and road speed pinned into every
    one of them, and one for reproducing a fault — a single round, 32 magnitudes, nothing
    rotating.
  • The first launch finds no known vehicle until you adopt one or scan; after that the live
    screen works with no car connected.

Measured against an Opel Astra J 1.7 CDTI (A17DTJ) in five sessions with the vehicle
present, 17–21 September 2026. Two hours and twenty-one minutes of driving recorded
through the app in four files, 14.5 million readings. Release APK built and verified with
the new version catalogue.