[This stuff is part of my Car PC project]
What is DashCommand?
DashCommand is a commercial, real-time OBDII application for Windows. Its designed for virtual instruments on touchscreens and in full-screen mode; basically for in-car gauge applications. I use it as part of my Car PC for my digital gauges (with my PC hooked into the car via a USB OBDII reader).
DashCommand, itself a cheap app, is part of a product suite that also includes some higher-end packages for in-shop and tuning use. I picked it, and still use it, because:
- it is designed explicitly for fullscreen/touchscreen use, so does handy things like launch right into fullscreen/menuless mode on startup
- its connectivity is pretty good (it always manages to find the OBDII device properly)
- the actual dashboard display is totally customizable with a custom drawing/layout app (the DashXL Editor)
- despite the slightly un-sexy dashboards you usually see on Palmer’s site and in their examples, you can make the dashboards look really really good with a bit of work
There are frankly also some less awesome things about it:
- the editor is fairly clunky; you can do awesome things with it, but the toolset isn’t really up to par with what you might be used to from mainstream layout apps like Omnigraffle or Visio (e.g., moving groups of objects, lining things up, etc., is almost all done manually, and gets very tedious)
- the support isn’t consistent (and there’s been a new version “real soon now” for ages)
- I’ve had, and still have, a few latency problems with a large number of measurements, and the tool doesn’t offer a way to tweak priorities/frequency
- there are features of DashXL that are only available in the more expensive scanning products from Palmer, not in DashCommand (to the point above)
- if DashXL was an actual published and supported text-based file format, some of the limitations of the visual editor wouldn’t be such a big deal
All of that said, I still think its pretty much the best option for building highly custom virtual dashboards for in-car Windows Car PC systems. I had toyed with the idea of building a daemon (likely in Java) to read OBDII parameters and present them on the network, then building a Flash or Flex front-end to display those (since there are a lot of nice Flash gauges out on the web). In the end, though, I wanted something that wouldn’t require so much time and energy to get working. So with that, I’d recommend DashCommand to others with the same constraints.
My MAZDASPEED 3 has all-amber interior/dash lighting, so my whole Car PC setup matches that. That involved skinning DashCommand along with everything else. I made both a DashCommand “skin”, which controls the main buttons and options in the non-dashboard part of the interface, as well as two different “dashboards” (the things with the actual gauges). Both are pretty simple once you get the hang of them, though the customization can be overly tedious with the provided editor, as noted above.
My Skin looks like this:
The skin asset is just a ZIP archive of individual DashXL files (.dxl), one for each of the main UI elements. I just pulled apart the example skins to see how that worked. Drop the ZIP in your skins directory and then load it up through the app’s settings interface.
For the Dashboards, here’s my “Mazda Factory” dashboard, which I made to look mostly harmonious with the actual factory gauges in my car:
And the DashXL file…
And lastly, this is what I actually drive around with most of the time — its not the most readable but I like it aesthetically. I was going for a simple aircraft-style style display, with the linear-scrolling speedometer on the left:
And the DashXL file…note that you should have the Monaco font on your system for this to look like the screenshot above:
Feel free to download and customize, any feedback’s welcome of course. I am still debugging these a bit, so there may certainly be issues here and there. Let me know in the comments if you do try to use these and how it goes.
Embedding in Centrafuse
Since I use Centrafuse for my front-end, getting my virtual gauges integrated was a simple manner of adding DashCommand as an external application, launching in fullscreen mode, and setting the app itself to launch in fullscreen, hidden-mouse mode (DashCommand has command-line flags available for this). The only moderately non-trivial aspect of the whole thing was designing my dashboards to have an aspect ratio that maps to the dimensions of my screen with Centrafuse title bars and nav controls. In other words, though DashCommand can scale the UI to the appropriate rectangle when its loaded, I set my dashboards to have fixed aspect ratios to ensure that my gauge display always looks optimal when running inside Centrafuse’s frame.