Repository navigation
Releases
Beta v0.4.3
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.apkandandroid-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 theh8sum. - 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
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-vauxhallplugin.
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
opendash 0.4.1 — the ELM327 bridge that a real scan tool can use
Context: one commit in
opendashon 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 nowOK.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 acknowledgedATCAF0and ignored it, so that length byte went to the module
as the service:03 A9 81 12arrived as service03and came back "not supported".- Receive filters. Before each module it sets
ATCMandATCF(orATCRA). For
the engine, mask5FFover5E8lets both0x7E8and0x5E8through, because GM
modules answerA9with one stored code per frame on0x5E8, not in a reply on
0x7E8. A request-and-answer exchange can never show them.
3. What the bridge does now
ATCAF0carries 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, untilATST
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 afterATCFC0. - 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 13for a single frame, and
for a longer answer its length and then numbered lines (014,0: 49 02 …). A client
checking that the answer to0100begins with41 00decided there was no car.
Headers on still prints the frames, protocol byte and padding included. ATBIis 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; and0x20, 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 DATAand 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,ATCRAwildcards, a refused write in both modes, and
ATZputting 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-vauxhallplugin 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:35000as 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
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 inopendash-plugins, four inscanmatik-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-vauxhallplugin. 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
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 inopendash-plugins, sixteen inscanmatik-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
$AEDeviceControl 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
.sm2that 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...
Beta v0.2.0
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
inopendash, two inopendash-plugins, four inscanmatik-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:
- a foreground service — the ELM327 bridge had one; the part that writes the file had
nothing; - 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_LATENCYon Q+,WIFI_MODE_FULL_HIGH_PERFbelow); - 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...
Beta v0.1.0
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) andscanmatik-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:
- 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; - 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; - 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.
h8is 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 in1e a1 f1, and
zeroing it changes the signature.h4is a CRC with reflected polynomial0x9960034C. 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 00is answered7F 3E 12, sub-function
not supported. It is a bare3E. - A module emits on a different address from the one it answers on. Module
0x24X
answers on0x64Xand emits on0x54X; the engine answers on0x7E8and 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 as08 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...