Page 1 of 2 12 LastLast
Results 1 to 10 of 16

Thread: Gauge Cluster Tester Mark II

  1. #1
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    127
    Blog Entries
    13

    Arrow 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:	360 
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:	231 
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:	227 
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:	224 
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:	239 
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:	227 
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; 28-12-2020 at 09:24 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
    127
    Blog Entries
    13

    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
    127
    Blog Entries
    13

    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: 178
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: 175
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: 177
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: 177
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
    127
    Blog Entries
    13

    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:	146 
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,435

    Default

    Good work Heineken.

  7. #7
    Join Date
    Sep 2005
    Location
    Garden of England
    Posts
    2,602

    Default

    very neat!!
    aka Jonathan!!

    '92 charlotte green auto.... as a daily
    '37 Ford Y street rod......... something for the weekend!

    ...... if a photobucket pic is foggy, click it, and it'll take you to the clear version, yes, it's a clicking faff....

  8. #8
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    127
    Blog Entries
    13

    Default

    Thank you very much and a happy new year
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  9. #9
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    127
    Blog Entries
    13

    Default

    The RPM control signal is technically the same as in the first generation tester. A 12 V rectangle signal needs to be created and send to the cluster. Instead of a dedicated transistor circuit the 12 V output drivers are going to be used. Required frequencies are comparably low, therefore no issues were expected.

    As often as this sentence is uttered, the result isn't as expected. When trying it for the first time, the needle moved to a maximum of ~4000 RPM and fell back to 0 if a higher value was selected. Sounds like an issue with the signal quality. To further analyse it, my trusted Philips oscilloscope came to the rescue. Its doesn't offer any fancy calculations but it ideal to have a look at the overall wave form.

    Looking the the input signal from the Arduino to the output driver, everything looked fine. It's 2 V per division on the display grid making it ~4.6 V peak-to-peak. As the Arduino's logic level is 5 V, that's fine.

    Click image for larger version. 

Name:	IMAG4515s.jpg 
Views:	127 
Size:	74.3 KB 
ID:	14120
    Input Signal

    The output on the other hand didn't look very much the same. Output voltage is at an OK 12.6 V peak-to-peak but the signal doesn't look very "square". It seems the output driver has issues dropping the voltage back to 0 V after being told to do so. The higher the frequency the bigger the problem until the RPM's detection circuit calls it quits.

    Click image for larger version. 

Name:	IMAG4516s.jpg 
Views:	126 
Size:	77.0 KB 
ID:	14121
    insufficient Output Signal

    A little research in the data sheet of the output driver showed that it's a so-called Open-Emitter driver and therefore can't actively bring down voltages at its output. As the cluster's detection circuit isn't good at either above waveform is the disappointing result. The good thing: It's easy to solve. Simply adding a 1,5 kΩ resistor between ground and output of the driver. Even if the driver is at 12 V the current at the resistor is very small (8 mA or 100 mW) but helps dramatically dropping the voltage to 0 V:

    Click image for larger version. 

Name:	IMAG4517s.jpg 
Views:	126 
Size:	77.8 KB 
ID:	14122
    much better

    Integrating this resistor into the tester would be possible without a new PCB design but as it's probably not the last change required, we are going to put on the list of upcoming changes for the next PCB order. For now let's enjoy the quick response of the RPM needle when changing the corresponding value on the tester:


    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

  10. #10
    Join Date
    Jan 2018
    Location
    Near Stuttgart, Germany
    Posts
    127
    Blog Entries
    13

    Default

    The gauge cluster used in all previous videos and pictures is from a 1997 AT NSX with manual shift control at the steering wheel. Due to this, the RPM dial contains an extended shift indicator. The '3' location has been renamed to 'M' and enables a small display on the side that shows the currently selected gear.

    Click image for larger version. 

Name:	IMAG3554s.jpg 
Views:	108 
Size:	108.0 KB 
ID:	14136
    1997 AT (JDM)

    Without any bus communication and considering the electrical backwards compatibility with existing switches and ECUs, this results in an overall number of 10 pins used to control the gear indicators on the dash.
    Having individual elements to control them would be highly confusing, especially since some of the indicator lights work by connecting to ground other to battery voltage (depending on the indicator) and the three pins for the gear number display are of a rather uncommon standard used in older tabulator machines.

    The issue can be nicely solved in software, though. As mentioned in a previous message, the signal module takes care of basic pin behaviour (like connecting to ground or to battery voltage) the element module one layer above groups signals into elements to be displayed and changed by the display module. Configuring the signals properly and introducing a new gear selection element with corresponding graphics resulted in a user interface that simply scrolls through all possible options:



    Note that some of the indicators react a little slow - this is due the output pins of the Arduino not being put into the correct mode causing the outpur drivers to to be triggered insufficiently. It's already fixed and the indicators are now lighting up fast and crisp - just like they should.
    Last edited by Heineken; 02-01-2021 at 09:02 PM.
    1997 JDM Custom Order AT VIN 1400005 - Stock
    Heineken's Garage

Page 1 of 2 12 LastLast

Posting Permissions

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