Pre-release on the beta channel. Devices on that channel install it from their own page (System > Firmware update); the files below are for a manual upload.
WiCAN PRO 6.0.0-beta.12
Supported device: WiCAN PRO only. Home Assistant: v6 requires the ha-wican integration 2.0.0-beta1 or later.
Before you update
- Units already on this partition layout (v6 (settings and storage LittleFS)) update in place.
- Units coming from firmware 4.40.0 to 4.51.0 (factory v4.x (one 6 MB FAT storage)): the first boot restarts once more and the stored files, logs and the saved configuration are reset.
- A device that ran 6.0.0-beta.5 has its OBD chip on firmware V2.3.22. Open Quick Setup's vehicle step (or System > Maintenance) after the update and let it write V2.3.24: until then, an app that uses the automatic OBD protocol only connects after the device has been unplugged and plugged back in, and a restart of the device breaks it again.
- Running the Audi Q4 e-tron, Skoda Enyaq or Elroq, VW ID or Porsche Taycan profile on 6.0.0-beta.1 to beta.6: update now, or poll the standard PIDs only until you do. Those profiles made the OBD chip write its EEPROM on every poll cycle (fixed in beta.7), and on a chip written that often the reset WiCAN sent at every wake from sleep could destroy what the chip stores (issue #1023, fixed in beta.10).
- Coming from a v6 alfa or beta: settings, profiles and files are kept; the standard PID rows are re-numbered at the first start. A custom PID you wrote on a v6 alfa or beta against a single-frame reply reads one byte too far: run Test a PID (B0 is the first byte after the CAN id) and move each B index up by one, or re-import the published profile.
- A beta.1 device that parked itself (LED breathing red) updates from safe mode: hold the button until the LED turns sky blue, then yellow, join the device's own access point (its name starts with
WiCAN_, password@meatpi#), openhttp://192.168.0.10and upload the firmware there. Settings are kept. - Coming from firmware 4.x: the stored files, logs and the saved configuration are erased by the new partition layout; download a backup first (System > Maintenance > Configuration backup). The device restarts once more on its first start.
- In case of a boot loop, perform a factory reset.
New since beta.11
- VW TP 2.0 as a J2534 protocol of its own (
TP2_0_PS). A J2534 application can now open a TP 2.0 channel (SAE J2534-2, protocol id 0x800E) and leave the transport to WiCAN. The device sets the connection up (REQUEST_CONNECTION), splits a message into telegrams and puts a received one together, acknowledges blocks, sends again what the ECU asks for again, and keeps the connection alive with a connection test once a second, as SAE J2819 describes it. Up to four connections at once, messages of up to 4092 bytes, broadcast requests, andGET_DEVICE_INFOto ask what the device supports. Until now a tool had to do the transport itself on a raw CAN channel, with one round trip to the PC for every block acknowledgement, which is what made a TP 2.0 reflash slow over WiFi. The application supplies every data byte of a message, including the two length bytes a VW ECU expects in front of it, and reads the ECU's answer with its two length bytes in front. Tested against a model of an ECU that follows SAE J2819 and against a published exchange of a real engine ECU, not yet on a car. From Windows it needs driver 1.8.0 or later (the driver entry below): driver 1.7 does not know the protocol. Contributed by @EliasKotlyar (meatpi-components #4). - ISO 15765 flow control on a J2534 channel follows the standard: an answer in one go by default, and the tool can set it (
ISO15765_BS,ISO15765_STMIN). When an ECU answers a request with more than one CAN frame, the interface tells it how to send the rest: how many frames in a block, and the gap between frames. A J2534 tool sets the two withSET_CONFIG. Until now WiCAN acknowledged that and sent BS 8 / STmin 1 ms whatever the tool set, so a long answer arrived eight frames at a time, one frame a millisecond. The values a tool sets are used now, for the ECUs it has open on that channel and the ones it opens after, andGET_CONFIGreads the values in use. With BS 0 / STMIN 0 the ECU sends the whole answer in one go: on the bench a 4095-byte answer was with the tool 0.16 s after the request, against 0.72 s. A channel now opens with BS 0 / STMIN 0, the defaults SAE J2534-1 names, so this reaches a tool that sets nothing as well: with this firmware its long answers arrive in one go, whatever the driver version. If a tool or an ECU needs the old pace, setISO15765_BS8 andISO15765_STMIN1. An ECU that sends without a pause is the hardest case for the device's CAN reception; this version also deepens the receive queue for it (see the bug fixes below), and with that 4095-byte answers arrive whole while the device writes its flash. A value out of range (ISO15765_BSabove 0xFF, a reservedISO15765_STMIN) is refused withERR_INVALID_IOCTL_VALUE. WiCAN's own UDS tool and scripts keep BS 8 / STmin 1 ms. From Windows it needs driver 1.10.0 (the next entry). Contributed by @EliasKotlyar (meatpi-components #3). - Windows J2534 driver 1.10.0. The installer in drivers/j2534 is updated (
wican_j2534_setup_1.10.0.exe, SHA-2560d606eedefac64e9fa2b8f2ca596147ea6d101c68856accd5f75a2648f53c1b4). It adds the TP 2.0 protocol of the entry above (TP2_0_PS): the DLL hands a TP 2.0 channel to the WiCAN and passes messages through untouched,GET_DEVICE_INFOtells an application what the device supports, and a write to an id without a connection returnsERR_NO_CONNECTION_ESTABLISHED. TP 2.0 needs this firmware version or later; everything else in the driver works with the firmware driver 1.7 worked with. One change reaches every tool: on CAN, ISO15765 and J1850 VPW channelsPassThruReadMsgsnow returns the messages it has once nothing more arrived for 4 ms, where it used to wait for the full count until its timeout. A flasher that asks for a whole TP 2.0 block in one read on a raw CAN channel waited out that timeout at every block end; a read that got nothing still waits its timeout. The installer also writes aTP2_0registry value besideCANandISO15765. And the driver sendsISO15765_BSandISO15765_STMINof an ISO15765 channel to the WiCAN and reads them back from it (the entry above); up to 1.8 it acknowledged both and answered 8 and 1 by itself. On firmware before this version the two are still acknowledged without effect, andGET_CONFIGsays so: it reads 8 and 1. If you use udsoncan: its J2534 connection sets BS 0x20 / STMIN 0, so with this driver and firmware its long answers arrive 32 frames at a time without a gap. And it returns SAE J2534-1's numbers for the seven return codes of the entry below, andERR_BUFFER_OVERFLOWfromPassThruReadMsgswhen received messages were lost, in the device or in the driver's own queue. The loss report from the device needs this firmware version or later.PassThruOpenon a WiCAN that another tool is using returnsERR_DEVICE_IN_USE. The TP 2.0 protocol and the flow control values were contributed by @EliasKotlyar (wican-j2534-driver #2, #1). - Scripts can read a raw CAN frame, stop and start the CAN bus, and pulse the CAN transmit line. Five new functions on the Scripts page.
can_rx(id, timeout_ms)waits for one frame with that id and hands its bytes to the script; until now a script could send a raw frame withcan_txand never read one.can_stop()andcan_start()park and restart WiCAN's CAN controller. With the bus stopped,digitalWrite(CAN_TX, HIGH or LOW)anddigitalPWM(CAN_TX, ontime_ms, offtime_ms, rounds)drive the transmit line by hand, for a device that expects timed pulses on the bus lines instead of CAN frames;digitalPWM(CAN_TX, 1.6, 0.4, 10)sends ten dominant pulses of 1.6 ms. The bus is started again by itself when the script ends. Two things to know. The pulses go onto the bus the connector is plugged into and destroy the frames of the other devices on it for as long as they last: use this on a bench, not in a car that is driving. AndCAN_TXis the only pin a script may drive: every other pin of the board runs a part of the device. The reference on the Scripts page lists the functions, and there is an example, "Pulse a CAN pin". Contributed by @EliasKotlyar (meatpi-components #2). - How often WiCAN searches for its WiFi network is a setting, and Access point + Station says what it costs. In Access point + Station mode the two share one radio. While the WiFi network is out of reach (in the car, away from home), WiCAN looks for it again and again, and each search takes the radio away from the devices on its access point for a moment: on the bench three pauses of about a third of a second per search, now and then one of more than a second. The time between two searches was fixed at 30 s. It is now the station setting "Search interval" (Settings, WiFi, the station card, Show advanced): 10 s to 1 hour, 30 s by default. A longer interval means fewer pauses, and a later reconnect once the network is back in reach; the first tries after a loss stay fast whatever the value. The WiFi mode card shows a warning while Access point + Station is selected, with the advice behind its info button: for live CAN data on the road use Access point only, or raise the interval.
/api/wifi/statusreports the interval in force and counts the searches (sta_attempt.search_interval_s,sta_attempt.tries). - Measured: how full a CAN bus WiCAN can take. A bus is full when one frame follows the other with no gap. On the bench, with the bus kept full for ten seconds and one slcan client reading over TCP, WiCAN lost no frame up to 10,400 frames a second: that is every bus at 500 kbit/s, whatever its frames, and a bus at 1 Mbit/s full of 8-byte frames (8,400 a second). A car's own traffic is far below that, 1,000 to 2,500 frames a second. The first frames are lost at about 12,000 a second (2 in 10,000), which takes a 1 Mbit/s bus full of frames with four data bytes or fewer, and the most classic CAN can carry at all, 20,833 empty frames a second, costs 11 to 18 %. Every lost frame is counted (
rx_missed,rx_overrun,dispatch_dropson/api/can), the client keeps its connection and nothing restarts. While a bus is that full the web page answers slowly, in one to three seconds, and above 12,000 frames a second it may not answer until the bus lets go. These numbers hold once WiCAN has been up for a while and is not writing its flash. On a 1 Mbit/s bus full of 8-byte frames, the first seconds after WiCAN starts and a large upload to its storage can each cost a few frames, each one counted: up to 18 of some 80,000 frames on the bench, nearly always in the CAN controller's own buffer (rx_overrun). On a full 500 kbit/s bus one frame in one run. - Every loss on the data path can be read from the web API.
GET /api/bridgesnow shows, for each end of a running connection, what that end lost (losses): frames a client's burst could not get onto the CAN bus, bytes the USB serial port lost while the device wrote its flash, messages CAN over MQTT threw away, chunks a Bluetooth or console queue had no room for. Until now most of these were only in a log line or on the console. No change in the web UI.
Bug fixes since beta.11
- slcan over TCP (port 3333) lost its connection on a phone. With a busy CAN bus bridged to the slcan server, a phone lost the connection again and again, in bursts, about once a minute while driving, and a laptop on a good WiFi link held it. The app saw a clean close and could connect again at once; ELM327 on port 35000 beside it was not touched. The cause was in WiCAN: a client that acknowledged no data for about 150 ms was taken for dead and closed, and a phone's WiFi radio is away that long many times an hour (a scan for networks, power saving, a weak link). On the bench, at 1,100 frames a second, a client whose acknowledgements came 166 ms late was closed every time. WiCAN could also cause the pause itself: set up as access point and station with a home network that is out of reach (in the car), it looks for that network every 30 to 65 s, and each look silences its access point for a moment. With a client on the access point of 6.0.0-beta.11 that closed the connection 17 times in 14 minutes on the bench. Such a client now keeps its connection and its frames: up to 64 KB wait for it, about 2.6 s of that bus, and are sent in order when it is back. On the bench, acknowledgements 300 ms and 600 ms late lose no frame. When a client stays away longer, the frames that no longer fit are dropped and counted (
tx_dropsof the server on/api/sockets, and a line in the log), and only a client that takes nothing for 10 s is closed. One client that is behind no longer holds back another on the same server. This holds for every TCP server (ELM327 on 35000 and GVRET too). Reported on 6.0.0-beta.11. Until you update: let the app connect again when the connection closes, the server takes it back at once; if the phone is on WiCAN's own access point in the car, setting the WiFi mode to access point only stops WiCAN's search for the home network. Contributed by @EliasKotlyar (meatpi-components #2): the pull request is what ended the closes, and the buffer that keeps the frames was built on top of it. - A burst of frames written to the slcan server was only partly sent. When a client wrote more than about 20 CAN frames at once to the slcan server (a whole ISO-TP block of a long write to an ECU, a recorded log played back), WiCAN put the first ones on the bus and dropped most of the rest: of 400 frames written in one go, 161 to 209 reached the bus on the bench. The CAN controller holds 16 frames at a time and refused the next one at once, and the frames behind a refused one in the same read were dropped with it. The server now passes a burst on at the pace the bus takes it and holds the client back meanwhile, with TCP's own flow control, so nothing is dropped: 400 and 2,000 frames written in one go all reach the bus, and the frames the bus sends to the client meanwhile arrive too (2,000 frames written into a bus streaming 2,000 frames a second: all on the bus, none of the stream lost). The GVRET and RealDash servers send through the same path. The order of a burst is kept on a busy bus as well: until now a frame that lost arbitration to another node was sent again behind up to 15 of the frames written after it (of 2,000 frames written into a bus carrying 2,000 frames a second, 349 left out of place), which reached every sender of the device, not only the servers. If the bus line frees no room at all for 100 ms the frames are dropped as before, with a line in the log. Found on 6.0.0-beta.11 while testing the fix above. Until you update: let the client send about 16 frames at a time.
- J2534: a long ISO 15765 request stopped after 16 frames, and so did a block of raw CAN frames. When a J2534 tool wrote a message of more than 118 bytes on an ISO15765 channel (a block of a flash download, a long write) to an ECU whose flow control asks for no gap between frames (
30 00 00, which many ECUs answer), WiCAN sent the first frame, 16 or 17 consecutive frames, and then nothing: the write came backERR_TIMEOUTafter 1.7 to 5.5 s. An ECU that asks for a gap of 1 ms or more was not affected, which is why this hid. The same limit cutPassThruWriteMsgswith many raw CAN frames in one call: of 40 or 100 frames, 17 reached the bus and the call returnedERR_FAILED. The cause is the one of the entry above: the CAN controller holds 16 frames at a time, and both senders took its refusal of the next frame as a failure. Both wait for room now. On the bench requests of 125, 1,000 and 4,000 bytes to an ECU answering30 00 00arrive whole (4,000 bytes in 0.14 s, against 1.1 s with a 1 ms gap), and 121 raw frames in one call all reach the bus, in order. Found on 6.0.0-beta.11 by reading the other senders after the slcan fix, then reproduced. Until you update: there is no setting for it; a tool that paces its own frames on a raw CAN channel (16 at a time) is not affected. - CAN frames were lost while the device wrote its flash on a busy bus. When WiCAN erases a part of its flash (a saved setting, a file uploaded to it, its configuration backup), everything in it stops for about 23 ms except the interrupt that receives CAN frames, and the frames of that time wait in a queue. The queue held 64 frames, which a bus above about 2700 frames a second fills in that time; the frames beyond it were lost and counted as
rx_missedon the CAN status. On the bench a bus at its full 500 kbit/s rate lost 553 of 40,000 frames while three files were uploaded to the device. The queue now holds 256 frames (64 ms at 500 kbit/s) and the same test loses none. It costs 3.8 KB of internal memory. The queue of a J2534 channel behind it grew the same way; it dropped frames the device itself had kept. So did the queue that feeds the slcan, GVRET, RealDash, WebSocket and MQTT connections, which had stayed at 32 frames: a client reading a bus at 2,000 frames a second lost 384 frames while three files were uploaded (886 at 3,000, none at 1,100, counted asdispatch_dropson the CAN status), and loses none now. Most car buses stay below that rate, so most users never met this; a logger or a J2534 tool on a saturated bus could. - A rule that posts to an
https://address restarted the device. A rule on the Automate page whose action ishttp.postto anhttps://URL, for example a bump posted to a Home Assistant webhook, restarted WiCAN the first time it fired, and the crash report readA stack overflow in task em_worker. Three such restarts in a row, each within ten minutes of its start, park the device (LED breathing red), so a rule that fires often could take a device out. The task that runs a rule's network actions had 4 KB of stack, and the encrypted connection of an https post needs about 4.5 KB. A post to a plainhttp://address fitted, and so did a post that failed before the connection was made (no network yet), which is why a rule could seem to work at first. The task now has 16 KB, of which an https post leaves about 12 KB unused. Reported on 6.0.0-beta.10 and reproduced on 6.0.0-beta.11. Until you update: let the rule publish over MQTT (mqtt.publish), or post to a plainhttp://address on your own network. (#1067) - A WebSocket client that stopped reading held up every other client of its channel, and the other direction with them. One browser tab on the CAN monitor that was put to sleep, or one client of
/ws/can(or of any other WebSocket channel) on a slow link, stopped the data for every other client of that channel for up to 5 s at a time, and what the others wrote was held too. On the bench, with a bus at 1,100 frames a second: beside one client that took nothing, a client that kept reading lost 11,000 to 13,000 of about 30,000 frames; beside one that took 2 KB a second it got a third of its frames; and of 750 lines written the other way, half reached the bus. The cause was the one behind the first fix above: a send that waited for the slow client. A WebSocket client that is behind now keeps its connection, up to 64 KB wait for it and are sent in order when it is back, what no longer fits is dropped whole and counted (tx_dropsof the channel on/api/ws, and a line in the log), and only a client that takes nothing for 10 s is closed. On the bench the client that keeps reading then loses no frame beside either kind of slow client, and every line written reaches the bus.tx_dropson/api/wschanges its meaning with this: it counted clients removed after a failed send and now counts frames dropped for a client that was behind. - With the admin password on, no WebSocket worked. The terminal, the CAN monitor, the live values and the log of the web page each run on a WebSocket. With "Admin password" enabled they connected, and then every message on the open connection was answered with an HTTP 401 error written into the WebSocket itself: the password check ran again for each message, and a message carries no password. A connection that gave the password when it opened is now trusted for as long as it lasts. Until you update: the admin password and the pages above do not work together.
- A WebSocket message above 4 KB ended the connection without a reason. The connection was reset. It is now closed with the WebSocket close code for it (1009, message too big).
- A firmware file installed from the web page could be undone by a power cut. On units that came with version 6 (their bootloader can fall back to the previous firmware), a file installed with the manual upload stayed "unconfirmed" until the next restart you asked for: a power cut, a reset or a crash before that made WiCAN start the OLD firmware again, even after hours on the new one. An update from the release list was confirmed after 10 minutes without a crash; an uploaded file is now confirmed the same way. Units updated over the air from 4.x keep their old bootloader, which never falls back, and were not affected. Until you update: after a manual upload, press Restart once.
- CAN over MQTT lost frames on a busy bus, cut long messages short, and one broken message stopped all later ones. Three faults of the CAN to MQTT connection. With the default batch of 24 frames, 4 of every 28 received frames were dropped on the way to the broker, uncounted. A message published TO the bus with more than 8 frames sent the first 8 only. And a message that arrived cut or malformed left the parser waiting for its end, so nothing published after it reached the bus until a restart. All three are fixed: every received frame is published, every frame of a message is sent (or none, when one of them is malformed), and a cut message is dropped and counted. The
mqtt_canconsole command shows three more loss counters (tx-cut,tx-oversize,rx-batch). - slcan: the tail of an over-long line could be sent to the bus as a frame. A line longer than an slcan line can be was cut at 48 characters and what followed was read as a new line, so 48 characters of anything followed by
t1001AAput frame 0x100 on the bus. Such a line is now dropped whole, up to its end. - SavvyCAN (GVRET): the time sync answer was always 0. It now carries the device's microsecond clock, the same one the frame timestamps use.
- Input the device refused did not show anywhere. A malformed slcan line, bytes that are not GVRET or a RealDash frame with a bad checksum were dropped in silence. They now count in the connection's
codec_errorson/api/bridges, which stayed 0 whatever arrived. - J2534: a PC that vanished kept the adapter busy until it was restarted. WiCAN serves one J2534 tool at a time. When the PC disappeared without closing the connection (a pulled cable, a laptop that went to sleep, WiFi out of range), WiCAN went on waiting for it and no tool could connect again until the device was restarted. It now checks whether a silent tool is still there and gives the session up when it is not: about 25 seconds after the PC vanished, about 6 seconds when WiCAN was sending to it at that moment. A tool that is connected and simply quiet keeps its session, and a second tool still cannot take over while the first one is connected, so nothing can interrupt a flash.
- J2534: a long ISO 15765 write held up everything else. While WiCAN sent a long message (a block of a flash download can be on the bus for seconds), no received message of any channel reached the tool, and on a busy bus the ones that did not fit were lost. Periodic messages (a tester present, for example) stopped for the whole write and then went out in one burst, and other timers inside the device waited as long. On the bench, during a write of 2.2 seconds: 244 of 500 received frames lost and both periodic messages silent before; none lost, none held back, and both periodic messages on time now.
- J2534: a tool is told when received messages were lost. Each channel keeps 256 received frames for the tool. When the tool reads slower than the bus delivers (a slow WiFi link, a tool that stops reading for a moment), the oldest frames are dropped, and until now nothing said so. With driver 1.10.0
PassThruReadMsgsreturnsERR_BUFFER_OVERFLOWtogether with the first messages behind the gap, as SAE J2534-1 describes, and the device counts the lost messages on its J2534 status (rx_lost). - J2534: a periodic message ended only with the session. A periodic message of a channel that was disconnected stayed stored and went out again on the next channel the tool connected.
PassThruDisconnectnow ends the periodic messages of its channel. - J2534: seven return codes had the wrong number.
ERR_INVALID_BAUDRATEcame back as 0x18 where SAE J2534-1 has 0x19,ERR_NO_FLOW_CONTROLas 0x16 (0x17),ERR_INVALID_FILTER_IDas 0x15 (0x16),ERR_NOT_UNIQUEas 0x17 (0x18),ERR_MSG_PROTOCOL_IDas 0x14 (0x15),ERR_INVALID_DEVICE_IDas 0x19 (0x1A), and "another tool is connected" as 0x1A where the standard hasERR_DEVICE_IN_USE, 0x0E. A tool that looked the number up in the standard reported the wrong reason for a failure. Driver 1.10.0 returns the standard's numbers, with this firmware and with older ones. A tool that runs on an older driver gets the numbers it always got. - CAN over MQTT: one message is always one JSON object. With a small
batch_frameson a busy bus the device could put two or more batches into one MQTT message, which a JSON parser refuses. Each batch is a message of its own again. The default of 24 frames a batch was not affected. - The CAN interface could stop transmitting after repeated bus-offs. A frame that was being sent at the moment of a bus-off was never given up, and after sixteen such bus-offs without a restart of the interface nothing was transmitted any more until the device was restarted. The frame is now given up and counted (
tx_loston/api/can). - A reset during a CAN fault. When the device took its CAN interface off a bus it could not read right after it had transmitted, it could freeze and be restarted by its watchdog. Found on the bench with repeated bus-offs; fixed.
- Log over TCP (port 5515) no longer drops a client whose link stalls for a moment. A client that falls behind keeps its connection and gets its lines once the link is back (up to 64 KB wait for it); lines that no longer fit are dropped for that client only and counted; a second client is not held back; a client that takes nothing for 10 seconds is closed and the log says so.
- USB serial (the ELM327 port over USB): a short command no longer waits 20 ms. Every command of a few bytes from a PC took 20 ms longer than needed before it reached the OBD chip; it now goes on in about 2 ms.
- USB serial (the ELM327 port over USB): a fast stream from the PC lost a few bytes now and then. Data that arrives faster than one command at a time (60 KB at 50 KB a second on the bench) lost about 40 bytes in one stream of twelve, with nothing else going on in the device. It is the cause the OBD chip's port had (fixed in beta.10), and the same fix. A short command was never affected. Bytes that arrive while the device writes its flash can still be lost; they are counted (
rx_overrunson/api/bridges). - Bluetooth: a busy CAN bus on the data pipe made the phone lose the connection. With a connection row that puts a CAN bus on Bluetooth (slcan, RealDash, GVRET or the raw records), the bus makes more data than a Bluetooth link carries as soon as it is busy. WiCAN drops what the link does not take, which is meant. But while it did, a command the app sent could go unanswered: WiCAN had used up the memory its Bluetooth stack answers from. The app waited, and the phone ended the connection 30 seconds later. On the bench (a bus at 2,000 frames a second as slcan text): of the writes sent during the flood the first few were answered, then one was not, in every run. Notifications now keep to a small memory pool of their own. On the bench every write is answered (within a second, behind the data already on its way) and the connection stays.
- Bluetooth: an overloaded data pipe could deliver half a line. What did not fit the transmit queue was cut in the middle of what the connection row had handed over, so an app could read the start of one slcan line glued to another (19 such pieces among 13,525 lines on the bench), and a reader of the binary record formats read every later record from the wrong place. A packet the link did not take within 100 ms was dropped without a count. What is dropped now is dropped whole (whole lines, whole records), what is queued is delivered, and every dropped byte is counted:
pipeon/api/ble(tx_drops,tx_drop_bytes). On the bench the count matches what did not arrive to the byte. - The log filled with Bluetooth lines during a Bluetooth stream. The Bluetooth stack wrote two lines for every packet it sent, about 130 a second during a stream, so the device's log kept only the last few seconds and anything else, an error included, was gone from it. Those lines are off now (the stack logs warnings and errors only).
- The web page stalled while a busy CAN bus was streamed to a client. With a full bus going out over slcan, RealDash, GVRET or a WebSocket, the web page and the API answered slowly: a request that takes 25 ms took 0.2 to 0.5 s, single ones 2 to 6 s. Two causes. Every few CAN frames left as a network packet of their own, about 950 a second, and handling them took one of the two CPU cores whole. And the web server ran on the same core as WiFi and the CAN receiver in some starts of the device and on the other core in others. A stream's frames now leave together every 3 ms (about 390 larger packets a second; an OBD request and its answer are not delayed), and the web server always runs on the core that has time. On the bench, with a full bus at 500 and at 1000 kbit/s, the slowest answer is now 0.56 s.
- A burst written over a WebSocket lost most of its frames. A client that wrote faster than the CAN bus carries (6000 slcan lines at once over
/ws/can) got 2,167 of them onto the bus; the rest was dropped in pieces, in the middle of messages. What the bus has not taken yet now waits (128 KB), and a message that does not fit even there is dropped whole and counted (rx_dropson/api/ws). The same burst arrives complete and in order. - A page that only listened was disconnected when other pages were opened. The CAN monitor, the log and the live values each hold a WebSocket and send nothing over it. The web server has seven places; when it needed one it closed the connection that had not SENT anything for the longest time, which was always one of those. A connection that is receiving data now counts as in use, so an idle plain connection goes instead.
New since beta.10
- Windows J2534 driver 1.7.0. The installer in drivers/j2534 is updated. A PassThru tool that asks for the battery voltage (
READ_VBATT) now gets the voltage WiCAN measures, in millivolts; driver 1.6 answered 12.0 V by itself and never asked the device. This needs WiCAN firmware 6.0.0-beta.10 or later: against older firmware the driver reports that the firmware has to be updated instead of inventing a value. The driver is now free software under the GNU General Public License, version 3, with its source at wican-j2534-driver, and its installer opens with a disclaimer that has to be accepted before anything is installed: the driver passes on whatever the tool sends to the car, ECU reprogramming included, and is used at your own risk. The disclaimer and the licence are installed next to the driver. The page the installer ends on no longer says that reflashing is blocked until a switch is turned on: that switch went with the firmware of 2026-10-27, and the WiCAN forwards everything a tool sends once the J2534 server is enabled. - CAN filters can be added and edited in the web UI. A CAN filter reads a frame the car sends by itself, without asking for it: a CAN ID, how long to listen for it, and one or more values decoded from the frame's data bytes. Until now a filter could only arrive with a vehicle profile, from a DBC file or through the Raw Config tab. On the Automate page, under Parameters, the Vehicle Specific tab and the Custom PIDs tab now each have a CAN filters list under their PIDs: Add CAN filter adds one, every field of a filter can be edited (the filters a vehicle profile brought too, and more can be added beside them), a filter can be switched off or removed, and its live value shows in the list. The filters on Vehicle Specific belong to the vehicle: choosing another profile replaces them, as it replaces the vehicle-specific PIDs. The filters on Custom PIDs stay. The CAN ID is typed as in the 4.x firmware:
0x284in hex or644in decimal, and the field then shows it in hex. The box above the lists now says Search (it said Filter) and searches the PIDs and the filters. As before, nothing reaches the device until Apply Configuration. - Test for a CAN filter. Each filter has a Test button, like a PID: WiCAN listens once for the frame and shows what it sent to the OBD chip, the frame it received, its data bytes as the expressions count them (B0 is the first data byte) and every decoded value, or says that no frame with that CAN ID came in the listen time. The car has to be on and sending the frame.
- The switch of a tab now covers its CAN filters. With Poll vehicle-specific PIDs off the vehicle's CAN filters rest, with Poll custom PIDs off the custom ones. Before this version a CAN filter went on whatever these two switches said. If you had switched one of them off and count on a CAN filter being read, switch it on again and switch off the PIDs you do not want one by one.
- Home Assistant can update its settings on a WiCAN it cannot reach. The integration registers its address and the post interval by calling the WiCAN. A car that is asleep when Home Assistant starts, or a car on LTE without a VPN, cannot be called: a new post interval or a new address of Home Assistant never arrived, and Home Assistant kept a "device unreachable" repair open although data was coming in. WiCAN now says with every push which set of settings it holds, and Home Assistant can send the current ones back in its answer to that push; WiCAN uses them from the next push on. There is nothing to set up on the WiCAN. It needs version 2.0.0-beta1 or later of the integration (the link at the top); with an older one nothing changes. WiCAN takes such settings only over HTTPS to Home Assistant's name (the certificate and its name are checked), or from an address on the home network or a VPN. It does not take them over plain HTTP across the internet, and not from a Wi-Fi network marked untrusted unless the push went over HTTPS to a name. With Manual URL override switched on, WiCAN keeps its own settings, as before.
- A WiCAN removed in Home Assistant stops pushing. Home Assistant can only tell a WiCAN to stop by calling it. A car that was asleep or away when its device was removed in Home Assistant could not be called: it went on pushing, and showed every push as delivered, because Home Assistant accepts a push to a webhook it no longer knows. Home Assistant now answers such a push with "removed" (HTTP 410), and WiCAN then clears its Home Assistant webhook and stops pushing. The Home Assistant card on the Automate page says why; add the device in Home Assistant again to resume. It needs version 2.0.0-beta1 or later of the integration (the link at the top); with an older one nothing changes. WiCAN acts on the answer only from where it would also take settings: over HTTPS to Home Assistant's name, or from an address on the home network or a VPN. With Manual URL override switched on, WiCAN keeps its webhook.
Bug fixes since beta.10
- The Logger stopped recording on a WiCAN that was short of internal memory, on a good SD card. The Logger page then showed no file name while Dropped kept rising, System Monitor listed the fault
logger_storage_errorwith the detailparams, the newest log file could not be downloaded (file in use), and only a restart brought logging back, until the next time. Three things came together. The Logger gave its 4 KB write buffer back every time it closed its file (at every new file, and every time the web page read the file that is being written) and could not get it again once internal memory had no block of that size left. When memory was so low that a write to the card failed, closing the file left it locked until the next restart, for the Logger and for a download alike. And with next to no memory left, opening a file restarted the device (abort() ... task "dl_writer"in the crash report). The Logger now takes its buffer once, when it starts, and keeps it; a file whose close fails is released; and the Logger no longer opens a file when there is no memory for it: it waits, keeps what it can in its queue, and goes on by itself when memory is back. If it had to wait, the fault's detail readsparams: out of internal RAM, so that nobody looks for the cause on the card. Reported on 6.0.0-beta.5. On that version Bluetooth together with a VPN leaves about 5 KB of internal memory (measured on the bench, and the reading in the report); the same settings leave about 58 KB on this version. - A good log file could be set aside as corrupt, or deleted, when internal memory ran out. With no memory for the SD card driver a read from the card came back empty, the SQLite format took that for a damaged file, and the Logger set the file aside (
.corrupt) or, when even the rename failed, deleted it to go on. While WiCAN cannot read its card for want of memory the Logger now leaves the file alone and tries again later. - A download from the SD card returned an empty file and left the file locked when internal memory was low. Since 6.0.0-beta.6 a download read the card through a helper task that is created when needed and needs 4 KB of internal memory; when there was none, the download answered with nothing and never closed the file, which stayed locked until the restart. If it was the log file being written, the Logger could not continue (
logger_storage_error). Downloads from the card no longer need that task. - Low internal memory was never reported. The fault
internal_ram_low(free internal memory under 8 KB, or its lowest point since the start under 4 KB, with the numbers in its detail) exists since the first v6 betas, but the check behind it was never started, so System Monitor never showed it. It is started now. If you see it, the features in use need more internal memory than this WiCAN has: switch off one you do not need (Bluetooth and a VPN are the largest), and send the detail with a report. - A CAN filter read only part of some frames. WiCAN listened for a filter's frame with the OBD chip treating every frame as a diagnostic message, in which the first byte is a length. A frame whose first data byte was 01 to 07 was therefore cut to that many bytes, and a value further back in the frame stayed empty for as long as that byte had such a value (a counter or a gear, for example), while the same frame was read whole when the byte had another value. The frame is now read whole whatever it starts with. Found on the bench while testing the new CAN filters list; it affected filters from a vehicle profile and from a DBC file in every earlier v6 beta. The 4.x firmware read such frames whole.
- A CAN filter with a 29-bit ID read nothing on a car that uses 11-bit IDs, and the other way round. WiCAN listened for a filter's frame on whatever protocol the OBD chip was on at that moment, and the chip only lets through IDs of that protocol's length. A filter with a 29-bit ID (above 0x7FF) therefore never saw its frame on a car whose diagnostic protocol uses 11-bit IDs. And with a vehicle profile whose PIDs switch between the two kinds of protocol themselves, a filter stopped updating behind a PID of the other kind. WiCAN now puts the chip on the 11-bit or the 29-bit protocol of the same speed for the moment it listens and back afterwards, as the 4.x firmware did.
- The device log filled with one warning per push when Home Assistant or a data destination is reached over HTTPS by its IP address. With an address such as
https://192.168.1.10:8123WiCAN verifies the certificate's chain but cannot compare its name with an IP address, and the network library logged a warning about that at every connection. With a push every 15 seconds the log held little else and the warning count kept climbing. WiCAN now says it once after each start. How the certificate is checked has not changed. Found while testing the Home Assistant integration against a Home Assistant whose own web server has SSL on. - Two warnings in the device log at every start of Home Assistant. The integration asks WiCAN for its recorded log whenever it starts or reconnects. With Store and forward off there is nothing to hand over, and WiCAN answered correctly but logged two warnings each time. The answer is the same; it no longer leaves a line in the log.
- Four Home Assistant sensors of a WiCAN never showed a value. The integration gives every WiCAN the diagnostic sensors Sleep mode, CAN protocol, ECU PID count and AutoPID loop, but no firmware sent the values behind them, so all four stayed Unknown. WiCAN now sends them with every status: whether Power Saving is on, the vehicle protocol in use (for example
ISO 15765-4 CAN, 11-bit, 500 kbit/s, orAutomaticwhile WiCAN leaves the choice to its search), the number of PIDs loaded, and whether AutoPID is running, paused or stopped. Found while setting up a WiCAN PRO on a new Home Assistant 2026.11.1 the way a first-time user does.
Earlier betas
- What changed in 6.0.0-beta.10 and in the betas before it is in the notes of 6.0.0-beta.11.
New features in v6
- New UI design, Quick Setup, improved AutoPID, CAN logger (raw CAN, SQLite, binary, JSON), Dashboard and CAN monitor
- Tailscale VPN; VPN split tunnel (up to 8 routes, .conf import, replaces the Allowed IP and Mask fields, #975); Pause VPN per WiFi network (#976)
- USB devices: ESPNetLink, GPS, USB to Ethernet adapter. ESPNetLink made easy: USB data mode (RNDIS) by default, the header shows the dongle and its LTE/GPS state, a dedicated page, SIM PIN entry, a hint when the GPS gets no fix, a Quick Setup path with no home WiFi; a console-only dongle is detected, and the USB port power is cycled once when a dongle never enumerates
- DTC trouble codes, DBC signals, Rules and Events, Scripting, UDS Tools, J2534, File Manager (SD card and internal flash), System logs and System Monitor pages
- AutoPID and Quick Setup support ISO 27145 (WWH-OBD) vehicles, such as Euro VI Sprinters over 3.5 t that answer only 22F4xx on 29-bit CAN (#298, reported by @billybigpotatoes, protocol findings by @CzarofAK)
- Full configuration Backup and Restore (settings, vehicle profiles and PIDs, code databases, DBC files, scripts, dashboard layout), optional removal of sensitive data, optional encryption, copies on the internal flash and SD card with a checksum per part (#979)
- Logger clock history: every clock step journaled on the SD card, queued records re-based, the clock context on the History chart and the file list (#984)
- ABRP: paced deliveries (5 s minimum, backoff on HTTP 429), a coverage view of the ABRP fields your vehicle provides, ABRP's own error text
- Connections: a socket server that no connection uses is flagged with a one-click CAN bus row. About 10 KB of internal RAM freed (long-lived state in PSRAM)
Bug fixes in v6
- Fixed settings not persisting when upgrading from v4.51 to v6.00
- Fixed USB GPS not reporting until "Dongle console" was enabled; GPS is read by default with its own switch (#978)
- "Download Config" did not include AutoPID PIDs or vehicle profiles; replaced by Backup and Restore (#979)
- Fixed writing over an existing file on the SD card; fixed the File Manager's capacity for cards over 4 GB (a 32 GB card showed 976 MB, #982)
- Fixed console commands that fail with an internal error printing nothing (#980)
- Home Assistant: the station IP in the webhook payload (#977); no second full payload after registration; vpn_status no longer reads past its table while the VPN is connected (#985)
- Fixed SD logger timestamps shifting by one or two hours depending on whether the time server answered at boot (#984)
- Fixed a crash when an ESPNetLink or USB Ethernet adapter disconnected during a USB power repair cycle
- Fixed an encrypted backup made with "Remove sensitive data" restoring blank secrets (#986); the automatic backup copy losing its settings 20 s after a factory reset (#987); a backup silently leaving out some files (#989)
- Fixed the VPN settings migration routing the Allowed IPs network instead of the tunnel subnet (#988); after an Alfa-04 upgrade with the old fields set, check the Routes list once
- Fixed slcan over TCP connecting but receiving nothing when the socket server had no CAN bus connection row
- Fixed J2534 "no comm with the bus" with Automatic bit rate on a bus that only answers when asked: the tester's bit rate is adopted
- Fixed the USB device mode (WiCAN as a network adapter to a PC) leaving a stale USB transfer across a restart
Known issues
- A few published vehicle profiles carry rows that never read right on any firmware version (an i3 and Mini state of charge, the bZ4X cell list, a Volvo XC40 state of charge, the pack voltage ranges of the 800 V Hyundai, Kia, Genesis and Xpeng cars). They are being corrected on the profile side.
- A TP 2.0 (VW) reflash by a tool that does the transport itself on a raw CAN channel runs at one round trip per block acknowledgement (about 3 ms over USB, 28 ms over WiFi): flash over the USB cable, or use the TP 2.0 protocol of this version (
TP2_0_PS). - The ESPNetLink cannot update itself yet; it updates through a WiCAN PRO. A dongle on firmware 1.20 or older must be flashed once over USB.
- J2534: J1850 PWM and K-line are not supported; J1850 VPW is request and response only, no 4x speed.
- A firmware upload started within ten minutes of an update may show that update as "not yet verified" on the Updates card until the ten-minute mark.
Bench: RELEASE TEST PASS, 15 steps (skipped: r12), 6 min, 2026-11-19 13:10:49 UTC.
Source: meatpiHQ/wican-fw v6.0.0p-beta.12, built with meatpiHQ/meatpi-components v6.0.0p-beta.12. To build this release, check out those two tags.
Update instructions
- Firmware 6.x: open the device page, System > Firmware update > Check for updates, or upload
wican-fw_obd_pro_v6.0.0-beta.12.binby hand. - Firmware 4.x: open the configuration page, System tab, Firmware Update section, upload
wican-fw_obd_pro_v6.0.0-beta.12.binand press Update. The first boot restarts once more; see Before you update. - Home Assistant: the MeatPi integration offers this version in the Firmware update entity.
In case of a boot loop
Perform a factory reset.
Home Assistant
Firmware 6.x requires the meatpi-multi-device branch of the ha-wican integration.
Contributors: ConorIA billybigpotatoes jtruland jeremysells CzarofAK eljeeb anthonysecco KoljaWindeler nuaimat mikedembek JJHW149 83noit EliasKotlyar