Results 1 to 10 of 17

Thread: Gauge Cluster Tester Mark II

Hybrid View

Previous Post Previous Post   Next Post Next Post
  1. #1
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    246
    Blog Entries
    25

    Lightbulb Gauge Cluster Tester Mark II

    It's been a few months since the first Gauge Cluster Tester was finalized. It has served me well during capacitor replacement but it's also limited in certain ways. A significant amount of manual work is required for every build (drilling, printing, cutting, etc.) and only six of the many functions of the cluster are supported.

    The good experience with the Open Source tool KiCAD for circuit design and layout in combination with the ease of getting professional PCB manufactured motivated me to make a second, more sophisticated, try with the following key requirements:
    • Support of all gauge cluster functions
    • Simple and intuitive user interface
    • Small form factor
    • Quicker build-up


    Due to the sheer amount of pins, an Arduino MEGA became necessary. Connection to the cluster was to be realized by means of the original green JAE connectors. These are surprisingly economic considering their price and amount of pins they carry.
    It was decided rather quickly that the design should be without the need for a case as these are notoriously hard to manufacture unless you're the owner of a 3D printer (which I am not). The tester should therefore centre around a robust PCB carrying all the components.
    Regarding the user interface there were some diverse discussions between engineering friends of mine until it was settled to use a 2x16 character LCD together with a turn-and-push rotary encoder. Often used together they provide an easy-to-figure-out way of selecting and changing values on the display while keeping the load for the microcontroller acceptable (in comparison to a graphical display).


    Click image for larger version. 

Name:	IMAG4159s.jpg 
Views:	1446 
Size:	68.5 KB 
ID:	14101
    A rough idea

    Unfortunately these LCDs tend to have a poor viewing angle and a slow response. Both makes for an unpleasant user experience. Therefore compatible OLED display was chosen, which is a true joy to look at and still being affordable. As every idea requires at least a proof of concept before making a decision, that was carried out by connecting everything to an Arduino and writing a prototype software:



    An element is selected by turning the knob. Pressing the knob allows to change its value, either directly (if it's a switchable element like an indicator light) or by turning the knob again (like RPM or speed). Should be easy to figure out, even without a manual. After the main components are decided, it's time to arrange them roughly and see about the form factor. The result was in an acceptable range even including the JAE connectors.

    As there are two different pin-outs of the gauge cluster (1991-1995 and 1996-2005), as well as different functions depending on build year and options (AT, Tip-Tronic, Targa, ..) carefully preparation of a pin table is essential. Buying the Honda NSX Electrical Trouble Shooting Manual from 1997 and 1992 helped to gather the required information.

    Almost all of the 60 pins available at the cluster are in use and realize the following functionality (1997)


    • Temperature, Oil Pressure and Fuel Gauge (resistance controlled)
    • Illumination (PWM controlled)
    • ~30 indicators lights (various controls via battery voltage and ground)
    • Shift Indicator Display (battery voltage controlled logic)
    • Roof Lock Logic (ground controlled logic input and output)
    • Courtesy Light Logic (ground controlling output)
    • Neutral/Park Logic (ground controlling output)
    • Speed gauge (battery voltage rectangle)
    • Tachometer (ground controlled rectangle)


    Click image for larger version. 

Name:	IMAG3554s.jpg 
Views:	912 
Size:	108.0 KB 
ID:	14100
    1997 AT JDM Cluster

    To realize all these in a truly universal fashion would require output drivers that can supply battery voltage, ground at currents up to 2 Ampere and even work as in input, PWM controlled by the microcontroller. Such a realization would be possible but quite expensive and certainly colliding with the requirement of a small form factor as well as ease of build-up.

    Based on the pin analysis, it turned out that it's sufficient to provide roughly 16 battery voltage and 40 ground drivers with currents up to about 100 mA. These are available as integrated circuits with 8 outputs each, making it just seven components on the PCB. The output pins provided by the cluster were decided not to be considered in this build.

    Next is the PCB layout. As two different pin-outs need to be supported, but the output drivers are fixed to either supplying battery voltage or ground, there are going to be two different sets of connection cables. This, on the other hand, allows to optimize the layout as the cable will take care about connecting the correct pins between cluster and tester.
    It took a few months to realize this level of complexity (and gave me the chance to learn a lot about the tools involved). The result is the following layout on a 140 x 140 mm PCB with two layers:

    Click image for larger version. 

Name:	screenshot_2.jpg 
Views:	781 
Size:	48.7 KB 
ID:	14102
    Circuit Design and Layout

    After printing it 1:1 on paper, the parts (that have to be sourced from at least three different sellers) could be placed to check the correct dimensions before ordering the PCB. Everything worked-out fine at the the order was placed.

    Click image for larger version. 

Name:	GaugeTester2.jpg 
Views:	722 
Size:	46.9 KB 
ID:	14105
    3D simulation of the PCB

    While the PCB was being manufactured (which took about two weeks) a crimping tool for the JAE connectors was selected and obtained. Professional equipment found for this task was exceptionally expensive and out of budget for such a project. The Japanese company ENGINEER was found to provide a hand crimp tool that supports the rather exotic 2.0 mm die size: The PA20. It's of decent quality and has served me well so far.

    Click image for larger version. 

Name:	IMAG4204s.jpg 
Views:	1213 
Size:	107.6 KB 
ID:	14104
    Tool and Result

    After the PCB arrived the components were added and soldered. It felt fascinating how exact the parts fitted - the 30 pin JAE connectors, for example, just dropped-in. No comparison to hand-made and drilled PCBs. The display and the rotary encoder worked right away and changing the output of the Arduino's pins could be verified using a multimeter.

    Click image for larger version. 

Name:	IMAG4428s.jpg 
Views:	1063 
Size:	85.8 KB 
ID:	14106
    so far, so good

    Up to this point, everything went rather smooth but the last 10 % towards the final result are said to be the hardest. After adding the output drivers, getting the cluster from the car and staring to build the connection cable as well as extending the software, several issues came up. These are going to be addressed in the next update to this thread, where each of the clusters functions are going to be show-cased.
    Nevertheless, the concept is proven to work and just a few minor changes are going to be required to get it fully running.

    During work on the project it became clear that the hardware itself is probably able to drive a range of 1990s gauge clusters from Honda and potentially other vehicles manufactures as well. Unfortunately I don't have any of those to build matching cables and software but it might be a nice collaboration project in case there is interest.


    Note
    Don't hesitate to let me know you impression of the project as well as ideas on how to improve it further. Especially the software is highly flexible and even making the tester controllable via USB is a possibility (even though I'm not planning to build a super-car simulator yet). Especially interesting are typical use-cases during servicing and/or calibration of the gauge cluster.
    Last edited by Heineken; 04-03-2022 at 04:18 PM. Reason: typos
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  2. #2

    Default

    will it be possible to buy it in the future - I am interested

  3. #3
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    246
    Blog Entries
    25

    Default

    It's not a problem to build up more of them once the design is finished, but that level is not reached yet. Stay tuned
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  4. #4
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    246
    Blog Entries
    25

    Default

    After initial operation was confirmed, it's time to install the driver chips and attach the individual wires towards the cluster to test the corresponding functionality. Easiest are the indicator lights. Most of them are controlled by providing ground to the corresponding pin. The Arduino pin goes low, so does the output driver and the indicator lights up. Pressing the button enables/disables the indicator light who's name is on the first line of the display.



    Three wires can be seen on above video because battery power (ignition) and ground needs to be supplied additionally. Other indicators have a separate power supply or need battery voltage applied to their pin to light up. The user interface is the same but the underlying realization differs.

    To handle this in Software, a multi-level architecture was implemented. A top level module called "Display" controls the screen based on information from the module "Element". This reduces complexity as many elements use the same display (e.g. on/off for all indicator lights).

    Name:  _display_8cpp__incl.png
Views: 1122
Size:  8.4 KB


    The module "Element" defines different types of elements (e.g. "switch" for on/off ) and creates the connection to the corresponding signal.

    Name:  _element_8cpp__incl.png
Views: 1286
Size:  7.5 KB

    The state of each element is retrieved from the module called "Knob". It handles the rotational encoder, and its push-button functionality. Not a trivial task as calculating an element's value from the knob's rotation position requires constant adaptation, e.g. when switching from element selection (top line on the screen) to modifying the element's value (e.g. on/off) and back again. De-bouncing the push-button is required, too. Implementing it in a sensible way is important towards a good user interface as slow reacting buttons or unintended glitches are not a quality indicator.

    Name:  _knob_8cpp__incl.png
Views: 570
Size:  4.8 KB


    Each pin and its electrical properties are configured in the module "Signal". It tries to hide most of the electrical properties (e.g. corresponding Arduino pins, inverse logic, etc.) as long as they are not required on element level.

    Name:  _signal_8cpp__incl.png
Views: 583
Size:  8.4 KB

    For readers with a less software-centric background this probably not that interesting but it shows that architecture and design doesn't stop at the hardware level. Even such rather trivial software (when done right) is a dedicated, complex and valuable task on its own.

    Above diagrams were created using Doxygen. It's a well known Open Source tool to document and analyse source code. Using it helps to create a clean software design and makes the resulting code easier to use.
    Last edited by Heineken; 29-12-2020 at 04:30 PM. Reason: typos
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  5. #5
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    246
    Blog Entries
    25

    Default

    The last message was quite software heavy. so now it's back to more traditional electro-mechanics. Let's talk about the three small gauges on the cluster, namely oil pressure, temperature and fuel level. All of them have three things in common: They have the same working principle behind them. The cluster provides a voltage and the sensor has a specific resistance depending on what he's currently measuring.

    Click image for larger version. 

Name:	screenshot.png 
Views:	1071 
Size:	205.8 KB 
ID:	14119

    The combination of the cluster's voltage and the resistance of the sensor creates a current that moves the gauge's needle. But how does the Gauge Cluster Tester simulate a resistance?
    That's where the abbreviation "PWM" comes into play. It's short for "Pulse Width Modulation" and provides a nice way out of this dilemma.

    For those not familiar with the term, it means that the cluster's voltage towards the sensor is periodically connected to ground instead of through a fixed resistance. As the dial is of low agility it can't follow and settles for a kind of average. This average is roughly the time the signal was connected to ground vs. the time it was not connected.
    Not exactly a brand new invention and commonly used in many places where power or current control is required. It's especially popular due to its simplicity and low losses.

    The only downside are audible harmonics created at the gauge's coils by the high switching frequency. Sound's little bit like a modern train or tram driving off the station.
    Beside this, the control works remarkably well. The Arduino natively supports this type of output and no additional or special output drivers are required.

    It's been relatively simple to obtain reference values for the PWM output and store them in the tester. Based on these, a rather simple and intuitive user interface was implemented:


    Last edited by Heineken; 01-01-2021 at 11:04 AM. Reason: Typos
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  6. #6
    Join Date
    Apr 2004
    Location
    West Sussex
    Posts
    4,534

    Default

    Good work Heineken.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •