The later BMW E30 may be equipped with the 4-channel Premium Sound System.

The audio head unit is the Alpine CM5908 with the 4 audio preamp outputs: Front Left, Front Right, Rear Left, Rear Right. The 4 preamp outputs are connected to the Blaupunkt amplifier (called Quadro Booster), but the Ground output wires of each channel are connected and form a single Ground wire input to the amplifier. This amplifier connection is called “Single-Ended Input”. There is nothing bad about it. If you have a newer head unit , connect the grounds of all preamp outputs (usually, RCA connectors) together. The Alpine CM5908 uses 2-pin DIN connectors for preamp outputs, they are covered with silver, which has tarnished by now: DIN 41529 connector.

4 RCA outputs.

Preamp output signals are measured in volts, usually in the range of 2-5 Volts. Older head units provided the voltage close to 2V. Newer head units provide 4V preamp outputs, which require lower gains in an amplifier; otherwise, audio from an amplifier will be too loud even at the lowest loudness levels.

Blaupunkt Quadro Booster Amplifier

The default amplifier is pretty simple. It uses 8 venerable SGS TDA2003 chips. They are still produced by Chinese companies like Unisoc.

The TDA2003 is a Class-AB amplifier chip. Each two TDA2003s are connected in the bridge configuration providing 14 Watts into each of the 4 channels.

The Remote Enable (Auto Antenna) input enables the relay that provides power to the circuit. Two inductors filter the power supply line. The TDA2003s are mounted on the heatsink.

The vertical and horizontal panels are connected using wires, which break easily. Also, there are many electrolytic capacitors that should be replaced.

Class-D Amplifier

Schematics

Kicad files

Vertical panel

The vertical panel runs traces from the main connector to the 2 board-to-board connectors.

Horizontal panel

The horizontal panel contains all components.

Protection Circuit

The protection circuit with the LM76202 protects against reverse power connections, when a car battery is connected incorrectly. It also protects from undervoltage (< 10 V) and overvoltage (> 16 V) power supply. Its Shutdown pin is connected to the Remote Enable (Auto Antenna) output from a head unit; when the signal is High, the chip provides power to the circuit.

The chip TPS3711 monitors the power voltage and sets the fault line Low when the voltage is under 11 V. It allows the microprocessor to run fault routines.

Microprocessor Circuit

The microprocessor circuit uses the chip STM32L412KBT3, which has only 32 pins. The amplifier gain is set by the switch, the selected value is read by the microprocessor at the initialization stage and the gain register is set in the amplifier chip.

TAS5414C Circuit

TAS5414C is a 4-channel D-class automotive amplifier. It’s suitable for setups with single ended inputs. Its registers can be set using I2C. During the initialization step, tests can be run to test each channel for faults. It doesn’t consume much power, so a small chip-mounted heatsink can transfer all excess heat to the existing amplifier body.

It sounds great.

Companies rarely provide full documentation for later chips. The TAS5414C is still produced with full documentation available. There are inexpensive test boards from Microe.

TAS5414 Zephyr Driver

The microprocessor does the initialization of the amplifier chip TAS5414C. It sets the registers, runs tests to find out if any of the outputs has faults, especially when speakers are not connected. When the power goes down, its fault interrupt routine sends a mute message to the amplifier chip.

The driver is written for the Zephyr RTOS, so it can be adapted to run on different processors.

TAS5414 Driver

The coolant temperature sensor

The temperature sensor is an NTC thermistor, its resistance is higher when the temperature is lower.
It was inserted into a container with liquid silicone that was subjected to freezing and heating. Temperature values were recorded. They are lower that the temperature range of the engine, I may try to measure the higher temperatures later and recalculate the results.

The Steinhart–Hart equation coefficients:
A = 0.0021390576483277567
B = 0.00011856786248721395
C = 0.000001702703922601429

Coolant temperature gauge values

The values for the reference marks, they start from 0. The supplied voltage is 5 Volts.

The coding plug pins

Communication protocol capture

The protocol can be captured using a Saleae compatible logic analyzer and the Saleae software.

The coding plug for HML087 1385468 (E30 325i M20B25 7000RPM USA)

The communication protocol description.
The pin CS is set high by a microprocessor. Then, the microprocessor sends 64 CLOCK signals. When the CLOCK signal goes from high to low, the ROM outputs data on the DATA pin.

Data from different E30 coding plugs

HML087 emulation

The communication protocol can be emulated by a microprocessor. While the Attiny family looks like an obvious choice, it’s too slow for the application. It will work with older SI boards where the CLOCK signal period is 30 µseconds, but in the newer SI boards the period is 5 µseconds.

HML087 emulator that uses the microprocessor ch32v003

Here is the software for the BMW E30 coding plug emulator that uses the RISC-V microcontroller CH32V003: https://github.com/faritka/hml087

You can check the timing diagram for the coder.

The CLOCK signal pulse period is 5.583 µs as the programmed coder was inserted into one of the latest SI boards.
When the CLOCK signal changes from HIGH to LOW, the coder reacts after 725 ns (0.725 µs) and sends 0 (LOW) on the DATA line. This delay is acceptable for the latest SI boards.

The CLOCK signal pulse period is about 30 µs for earlier SI boards, and the coder certainly works with them.

The main microprocessor for the gong is the STM32L452RET6.

The microprocessor sleeps most of the time consuming only 5 μA. When the level changes on one of its interrupt lines, a WAKEUP interrupt awakens the microprocessor. The program detects which interrupt line awakened the system and plays a corresponding WAV file on its DAC. When it stops playing, the microprocessor goes back into sleeping.

WAV files are only a few seconds each, and they are stored in the microprocessor flash. The program uses a timer to transfer bytes to the DAC according to the bit rate, usually, 16 bit/44.1kHz or 16 bit/48kHz. As the STM32 DAC is only 12-bit, some conversion is done. First, bytes are read into a memory buffer. Then, they are transferred to the DAC using a DMA channel. The program waits until it receives a transfer complete interrupt, and send a new portion of the music file to the buffer.

The DAC signal is amplified by the amplifier chip NJM2135M (MC34119).

The software uses the Real-Time Operating System Zephyr to organize multiple threads and simplify writing drivers.

The gong schema.

I used a simpler and cheaper octocouple before, and the power consumption was similar.

The audio amplifier subschema.

The gong PCB

Software: BMW E30 gong software for Zephyr RTOS and STM32

The software is written using RTOS Zephyr for the processor STM32L452RE. There are several threads that read and update the current time, check the light level and adjust the display brightness, process interrupts fired by controlling buttons. A watchdog process restarts the processor in case of a serious error.

The processor is programmed by connecting it to an STM32 Nucleo board.

The display PCB.

The processor PCB.

The power module.

The supercapacitor charger module.

Software: BMW E30 clock software for Zephyr RTOS and STM32

LED matrix

The LED indicator is the LTP-305HR 5×7 dot matrix display. It has an LED for a dot ., that is located at the column 0. So, we will start writing characters at the column 1 of the display buffer.

The HT1632C supports 32 ROWs – in our case they will be vertical columns, and 8 COMs – they will be horizontal rows.

The center of coordinates 0x0 starts at the left top.

In our case, we will use 5×7 fixed width fonts. Each character will be represented as an array of 5 uint8_t 8-bit numbers(bytes). The array will start from the leftest column. The top row will start from the most significant(the leftest) bit of a byte.

Here is the letter M displayed on the LED matrix. When a bit is set to 1, it turns on the LED at that position; when it is set to 0, it turns off the LED. The 8th bit doesn’t matter as it’s not displayed at all – we will set it to 0.

The C array for the letter M looks like this:
{Column 1, Column 2, Column 3, Column 4, Column 5}

{0b11111110, 0b01000000, 0b00110000, 0b01000000, 0b11111110}, // M

Font File

All characters for the 5×7 font are included in the file font_5x7.h

They are located according to the ASCII order starting from the character SPACE ‘ ‘, which has the decimal number 32.

#ifndef FONT_5x7_H
#define FONT_5x7_H

// The width of each font character
#define APP_FONT_WIDTH 5

const uint8_t font[][APP_FONT_WIDTH] = {
    {0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000}, // 
    {0b00000000, 0b00000000, 0b11111010, 0b00000000, 0b00000000}, // !
    {0b00000000, 0b11100000, 0b00000000, 0b11100000, 0b00000000}, // "
    {0b00101000, 0b11111110, 0b00101000, 0b11111110, 0b00101000}, // #
    {0b00101000, 0b01010100, 0b11111110, 0b01010100, 0b00101000}, // $
    {0b11000100, 0b11001000, 0b00010000, 0b00100110, 0b01000110}, // %
    {0b01101100, 0b10010010, 0b10101010, 0b01000100, 0b00001010}, // &
    {0b00000000, 0b00000000, 0b11100000, 0b00000000, 0b00000000}, // '
    {0b00000000, 0b00111000, 0b01000100, 0b10000010, 0b00000000}, // (
    {0b00000000, 0b10000010, 0b01000100, 0b00111000, 0b00000000}, // )
    {0b00101000, 0b00010000, 0b01111100, 0b00010000, 0b00101000}, // *
    {0b00010000, 0b00010000, 0b01111100, 0b00010000, 0b00010000}, // +
    {0b00000000, 0b00001010, 0b00001100, 0b00000000, 0b00000000}, // ,
    {0b00010000, 0b00010000, 0b00010000, 0b00010000, 0b00010000}, // -
    {0b00000000, 0b00000110, 0b00000110, 0b00000000, 0b00000000}, // .
    {0b00000100, 0b00001000, 0b00010000, 0b00100000, 0b01000000}, // /
    {0b01111100, 0b10000010, 0b10000010, 0b10000010, 0b01111100}, // 0
    {0b00000000, 0b01000010, 0b11111110, 0b00000010, 0b00000000}, // 1
    {0b01000010, 0b10000110, 0b10001010, 0b10010010, 0b01100010}, // 2
    {0b01000100, 0b10000010, 0b10010010, 0b10010010, 0b01101100}, // 3
    {0b00001000, 0b00011000, 0b00101000, 0b01001000, 0b11111110}, // 4
    {0b11110100, 0b10010010, 0b10010010, 0b10010010, 0b10001100}, // 5
    {0b01111100, 0b10010010, 0b10010010, 0b10010010, 0b01001100}, // 6
    {0b10000000, 0b10001110, 0b10010000, 0b10100000, 0b11000000}, // 7
    {0b01101100, 0b10010010, 0b10010010, 0b10010010, 0b01101100}, // 8
    {0b01100100, 0b10010010, 0b10010010, 0b10010010, 0b01111100}, // 9
    {0b00000000, 0b01101100, 0b01101100, 0b00000000, 0b00000000}, // :
    {0b00000000, 0b01101010, 0b01101100, 0b00000000, 0b00000000}, // ;
    {0b00010000, 0b00101000, 0b01000100, 0b10000010, 0b00000000}, // <
    {0b00101000, 0b00101000, 0b00101000, 0b00101000, 0b00101000}, // =
    {0b10000010, 0b01000100, 0b00101000, 0b00010000, 0b00000000}, // >
    {0b01000000, 0b10000000, 0b10001010, 0b10010000, 0b01100000}, // ?
    {0b01111100, 0b10000010, 0b10011000, 0b10100100, 0b01111000}, // @
    {0b01111110, 0b10010000, 0b10010000, 0b10010000, 0b01111110}, // A
    {0b11111110, 0b10010010, 0b10010010, 0b10010010, 0b01101100}, // B
    {0b01111100, 0b10000010, 0b10000010, 0b10000010, 0b01000100}, // C
    {0b11111110, 0b10000010, 0b10000010, 0b10000010, 0b01111100}, // D
    {0b11111110, 0b10010010, 0b10010010, 0b10010010, 0b10000010}, // E
    {0b11111110, 0b10010000, 0b10010000, 0b10010000, 0b10000000}, // F
    {0b01111100, 0b10000010, 0b10010010, 0b10010010, 0b01011110}, // G
    {0b11111110, 0b00010000, 0b00010000, 0b00010000, 0b11111110}, // H
    {0b00000000, 0b10000010, 0b11111110, 0b10000010, 0b00000000}, // I
    {0b00000100, 0b10000010, 0b10000010, 0b10000010, 0b11111100}, // J
    {0b11111110, 0b00010000, 0b00101000, 0b01000100, 0b10000010}, // K
    {0b11111110, 0b00000010, 0b00000010, 0b00000010, 0b00000010}, // L
    {0b11111110, 0b01000000, 0b00110000, 0b01000000, 0b11111110}, // M
    {0b11111110, 0b00100000, 0b00010000, 0b00001000, 0b11111110}, // N
    {0b01111100, 0b10000010, 0b10000010, 0b10000010, 0b01111100}, // O
    {0b11111110, 0b10010000, 0b10010000, 0b10010000, 0b01100000}, // P
    {0b01111100, 0b10000010, 0b10001010, 0b10000100, 0b01111010}, // Q
    {0b11111110, 0b10010000, 0b10011000, 0b10010100, 0b01100010}, // R
    {0b01100100, 0b10010010, 0b10010010, 0b10010010, 0b01001100}, // S
    {0b10000000, 0b10000000, 0b11111110, 0b10000000, 0b10000000}, // T
    {0b11111100, 0b00000010, 0b00000010, 0b00000010, 0b11111100}, // U
    {0b11111000, 0b00000100, 0b00000010, 0b00000100, 0b11111000}, // V
    {0b11111100, 0b00000010, 0b00111100, 0b00000010, 0b11111100}, // W
    {0b11000110, 0b00101000, 0b00010000, 0b00101000, 0b11000110}, // X
    {0b11100000, 0b00010000, 0b00001110, 0b00010000, 0b11100000}, // Y
    {0b10000110, 0b10001010, 0b10010010, 0b10100010, 0b11000010}, // Z
    {0b00000000, 0b11111110, 0b10000010, 0b00000000, 0b00000000}, // [
    {0b01000000, 0b00100000, 0b00010000, 0b00001000, 0b00000100}, /* \ */
    {0b00000000, 0b10000010, 0b11111110, 0b00000000, 0b00000000}, // ]
    {0b00100000, 0b01000000, 0b10000000, 0b01000000, 0b00100000}, // ^
    {0b00000010, 0b00000010, 0b00000010, 0b00000010, 0b00000010}, // _
    {0b00000000, 0b10000000, 0b01000000, 0b00000000, 0b00000000}, // `
    {0b00000100, 0b00101010, 0b00101010, 0b00101010, 0b00011110}, // a
    {0b11111110, 0b00010010, 0b00100010, 0b00100010, 0b00011100}, // b
    {0b00011100, 0b00100010, 0b00100010, 0b00100010, 0b00000100}, // c
    {0b00011100, 0b00100010, 0b00100010, 0b00010010, 0b11111110}, // d
    {0b00011100, 0b00101010, 0b00101010, 0b00101010, 0b00011000}, // e
    {0b00000000, 0b00010000, 0b01111110, 0b10010000, 0b01000000}, // f
    {0b00010000, 0b00101010, 0b00101010, 0b00101010, 0b00111100}, // g
    {0b11111110, 0b00010000, 0b00100000, 0b00100000, 0b00011110}, // h
    {0b00000000, 0b00100010, 0b10111110, 0b00000010, 0b00000000}, // i
    {0b00000100, 0b00000010, 0b00100010, 0b10111100, 0b00000000}, // j
    {0b11111110, 0b00001000, 0b00010100, 0b00100010, 0b00000000}, // k
    {0b00000000, 0b10000010, 0b11111110, 0b00000010, 0b00000000}, // l
    {0b00111110, 0b00100000, 0b00011110, 0b00100000, 0b00011110}, // m
    {0b00111110, 0b00010000, 0b00100000, 0b00100000, 0b00011110}, // n
    {0b00011100, 0b00100010, 0b00100010, 0b00100010, 0b00011100}, // o
    {0b00111110, 0b00101000, 0b00101000, 0b00101000, 0b00010000}, // p
    {0b00010000, 0b00101000, 0b00101000, 0b00101000, 0b00111110}, // q
    {0b00111110, 0b00010000, 0b00100000, 0b00100000, 0b00010000}, // r
    {0b00010010, 0b00101010, 0b00101010, 0b00101010, 0b00100100}, // s
    {0b00000000, 0b00100000, 0b11111100, 0b00100010, 0b00000100}, // t
    {0b00111100, 0b00000010, 0b00000010, 0b00000100, 0b00111110}, // u
    {0b00111000, 0b00000100, 0b00000010, 0b00000100, 0b00111000}, // v
    {0b00111100, 0b00000010, 0b00001100, 0b00000010, 0b00111100}, // w
    {0b00100010, 0b00010100, 0b00001000, 0b00010100, 0b00100010}, // x
    {0b00110000, 0b00001010, 0b00001010, 0b00001010, 0b00111100}, // y
    {0b00100010, 0b00100110, 0b00101010, 0b00110010, 0b00100010}, // z
    {0b00010000, 0b00010000, 0b01101100, 0b10000010, 0b10000010}, // {
    {0b00000000, 0b00000000, 0b11111110, 0b00000000, 0b00000000}, // |
    {0b10000010, 0b10000010, 0b01101100, 0b00010000, 0b00010000}, // }
    {0b01000000, 0b10000000, 0b01000000, 0b01000000, 0b10000000}, // ~
    {0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000}, // Delete
};

#endif /* FONT_5x7_H */

When we draw a character, we can subtract the value of SPACE ‘ ‘ from its decimal number and find its location in the font array. Then, we write 5 bytes of the font to the buffer.

/**
 * Draws a character at the position X
 *
 * @param uint8_t c The character to display
 * @param uint8_t x The position at the display from which to display
 */
void draw_char(uint8_t buf[], const uint8_t font[][APP_FONT_WIDTH], 
               uint8_t c, uint8_t x) 
{
    // Convert the character to an index
    c = c & 0x7F;
    if (c < ' ') {
        c = 0;
    } else {
        c -= ' ';
    }

    for (int i = x, j = 0; j < APP_FONT_WIDTH; i++, j++) {
        buf[i] = font[c][j];
    }
}

We can display a character starting from the position 1 like this:

draw_char(buf, font, 'M', 1);

When all required characters are set in the display buffer, the display buffer is sent to the HT1632C controller at once.

display_write(display_dev, 0, 0, &buf_desc, buf);

The code is available on https://github.com/faritka/zephyr-ht1632c

When you have a powerful microcontroller, there is no need to limit yourself by the capabilities of Arduino. Most Arduino programs run in a loop that checks buttons, does some calculations, connect to the Internet, etc sequentially. Coding gets complicated when you want to click on a button and process the click quickly while another function is slowly connecting and parsing a webpage.

A Real-Time operating system allows to code multiple functions and delegate the task of running them simultaneously to the OS.

Zephyr Project is a very promising project. But some sensors, displays, hardware chips don’t have drivers to interact with them yet.

An experienced programmer usually learns by reading code of sample programs. Zephyr provides many samples.

STM32 Nucleo boards

ST provides $15 evaluation boards for its family of the STM32 ARM processors called Nucleo.

I compared the list of available Nucleo boards with the list of the Nucleo boards supported by Zephyr.

I wanted a low-power microcontroller with the largest RAM and flash, and in the LQFP64 package (64 pins, 10×10 mm), which is hot-air solderable. I selected ST Nucleo L452RE for the project.

How the Holtek HT1632C works

The Holtek HT1632C is a popular display controller that can drive matrices of LEDs (one chip up to 32×8 or 24×16). The Holtek HT1632D is a newer version that can come in a smaller LQFP48 7×7 mm package that has fewer pins for rows.

Here is a typical electrical schema. The HT1632C controls the 5×7 LED matrices (with 1 additional row for a dot) with the common cathodes.

Here is how it works. To turn on the 1st top LED in the 2nd column, the HT1632C sets 1 (HIGH) on ROW1 and opens COM0, so the current flows via the current-limiting resistor to the LED and then via COM0 to the ground. The LED turns on.

The LEDs in the matrices are addressed starting from the leftest top LED.

In order to enable the 1st top LED in the 2nd column, user code must write 1 into the HT1632C RAM address matching the ROW1 and COM0 combination. According to the HT1632C controller datasheet, the address is 02H when the controller is configured as 32 ROW x 8 COM or the address is 04H when the controller is configured as 24 ROW x 16 COM.

The HT1632C communication protocol

The HT1632C uses 4 pins to communicate with a microcontroller.

• CS (chip select)
• WR (write)
• RD (read)
• DATA

This driver doesn’t read from the display controller. It only writes. So, we don’t use the RD pin.

• The CS pin is active LOW. When the microcontroller wants to communicate with the HT1632C, it sets the CS pin to the ground (LOW).
• The microcontroller sets the WR pin to LOW.
• It sends a bit (0 or 1) by setting the DATA pin to LOW (0) or HIGH (1).
• It sets the WR pin to HIGH. The HT1632C reads the DATA bit on the rising WR edge.
• The microcontroller repeats the WR LOW, DATA bit, WR HIGH sequence until all bits are sent.
• When it finishes, it sets the CS pin HIGH.

There are two modes of operation: the command mode and the write data mode.

The command mode starts with the 3 bits 100 and then the command itself.

The write data mode starts with the 3 bits 101, the RAM address, the 4 bits of data.

This driver writes the whole array of data starting from the address 00H using the Successive Address Writing Mode. It starts with the 3 bits 101, the RAM address 00H, then all 32 8-bit words or 24 16-bit words.

It’s the task of the application code to set individual bits in the matrix array. Then it sends the whole matrix array to the driver.

Here is how the command SYS EN (Turn on system oscillator) looks like on the screen of my oscilloscope.
SYS EN 100-0000-0001-0

Zephyr Application Structure

The structure of my application is based on the Zephyr Example Application.

It creates an application with a sensor driver.

I changed the string ‘example-application’ in the files to my own application name.

HT1632C Zephyr Driver Installation

Download the source from https://github.com/faritka/zephyr-ht1632c and follow instructions there.

Zephyr driver configuration files

Available configuration options are defined in the file dts/bindings/display/holtek,ht1632c.yaml.
It follows the Device Tree specifications.

The GPIOS have the phandle-array type that describes the GPIO identifier, pin, and flags. For example, the flag GPIO_OUTPUT_HIGH sets the default output as HIGH, the flag GPIO_ACTIVE_LOW means when you set the pin ACTIVE, the signal goes LOW (the CS pin is active low).

description:  Holtek HT1632C display controller

compatible: "holtek,ht1632c"

include: base.yaml

properties:
    cs-gpios:
      type: phandle-array
      required: true
      description: GPIO to which the CS pin of HT1632C is connected.

    wr-gpios:
      type: phandle-array
      required: true
      description: GPIO to which the WR pin of HT1632C is connected.

    data-gpios:
      type: phandle-array
      required: true
      description: GPIO to which the DATA pin of HT1632C is connected.

    commons-options:
      type: int
      required: true
      default: 0x00
      description: |
        0x00: N-MOS  opendrain output and 8 common option
        0x01: N-MOS  opendrain  output  and  16 common option
        0x10: P-MOS  opendrain output and 8 common option
        0x11: P-MOS  opendrain  output  and  16 common option

The test application is located in the directory app.
I created the overlay configuration file for my Nucleo L452RE board: app/boards/nucleo_l452re.overlay.

I defined the GPIOs that are connected to the HT1632C controller on the Nucleo L452RE board: CS to PB3, WR to PB5, DATA to PB4. The commons-options configures the HT1632C controller as 32×8 N-MOS. This configuration doesn’t need external transistors, the current will flow from ROWN -> resistor -> LEDs -> COMN.

/ {
    ht1632c {
        compatible = "holtek,ht1632c";
        label = "HT1632C";
        cs-gpios = <&gpiob 3 0>;
        wr-gpios = <&gpiob 5 0>;
        data-gpios = <&gpiob 4 0>;
        commons-options = <0x00>;
    };
};

Hardware delays

The HT1632C datasheet provides the table with electrical parameters.

t_CLK is 500 ns – it’s the pulse width of each WR signal
t_su is minimum 100 ns, I set it to 250 ns – it’s the delay between the setting the DATA pin and the WR pin going HIGH.

The function ht1632c_ns_to_sys_clock_hw_cycles converts nanoseconds to the processor clock cycles that must pass during those nanoseconds.

/**
 * @brief Converts nanoseconds to the number of the processor system cycles
 *
 * @param uint32_t ns Nanoseconds
 *
 */
static inline uint32_t ht1632c_ns_to_sys_clock_hw_cycles(uint32_t ns)
{
    return ((uint64_t)sys_clock_hw_cycles_per_sec() * (ns) / NSEC_PER_SEC + 1);
}

That’s what I get for the Nucleo L452RE with the 80MHz clock.

Delay tCS 33
Delay tCLK 41
Delay tSU 21
Delay tH 21
Delay tSU1 25
Delay tH1 17

The function ht1632c_delay then delays execution counting cycles.

/**
 * @brief Delays the execution waiting for processor cycles
 *
 * @param dev Pointer to device data
 * @param uint32_t cycles_to_wait How many processor cycles to wait
 *
 */
static void ht1632c_delay(uint32_t cycles_to_wait)
{
    uint32_t start = k_cycle_get_32();

    // Wait until the given number of cycles have passed
    while (k_cycle_get_32() - start < cycles_to_wait) {
    }
}

Here is the function that writes a command to the HT1632C controller.

/**
 * @brief Writes a command to HT1632C
 *
 * @param dev Pointer to device data
 * @param uint8_t command Command without the first 3 bits 100
 *
 */
static void ht1632c_write_command(struct ht1632c_data *data, 
        uint8_t command)
{
    //CS down
    ht1632c_delay(data->delays->cs);
    ht1632c_set_cs_pin(data, true);
    ht1632c_delay(data->delays->su1);
    
    //100 - command mode
    ht1632c_write_bits(data, HT1632C_COMMAND_HEADER, BIT(2));
    //the command itself
    ht1632c_write_bits(data, command, BIT(7));
    //one extra bit
    ht1632c_write_bits(data, 0, BIT(0));

    //set the DATA pin low waiting for the next command
    ht1632c_set_data_pin(data, false);

    //CS UP
    ht1632c_delay(data->delays->h1);
    ht1632c_set_cs_pin(data, false);
}

Sample program

The sample program writes the letter M, changes the brightness, and then makes the HT1632C sleep when CONFIG_PM=y and CONFIG_PM_DEVICE=y in app/prj.conf.

It's interesting to see how the second row of the letter M is half-lighted in the photo. That's because the HT1632C constantly switches ROWs and COMs ON and OFF. The human eye can't catch it, but a photo camera can.

Useful links

How to Build Drivers for Zephyr

The original electric circuit is extremely simple. There are two 1.2V NiMH coin cells, a resistor to constantly charge them, an E10 2.4V bulb, and a switch.
You can read an article about Teardown and Repair of the Simply Designed BMW E36 Glovebox Flashlight.

All white flashlights that you can get now have dead batteries. You can replace the batteries with similar NiMH batteries, and they should work for a few years.

My project replaces the original circuit with a more sophisticated circuit that has a charger chip, Li-ion 4.2V coin cells, and an LED bulb.

Electrical Circuit

The charging chip is LTC4079.

The LTC®4079 is a low quiescent current, high voltage linear charger for most battery chemistry types including Li-Ion/Polymer, LiFePO4, Lead-Acid or NiMH battery stacks up to 60V. The maximum charge current is adjustable from 10mA to 250mA with an external resistor. The battery charge voltage is set using an external resistor divider.

The chip is tiny, but it’s possible to solder the QFN chip using hot air.

Two ⌀24.5mm RJD2450ST1 200 mAh rechargeable coin cells are used.

Charging Current – Standard: 95 mA
Charging Voltage – Maximum: 4.2 V

The RJD2450ST1 has contacts for soldered wires. But it requires cutting two small slots in the plastic circle in the middle of the flashlight. The RJD2450 without contacts can be used if there is a battery spot welder for the original contacts.

The resistor divider R2=1.54MΩ and R4=249kΩ provides the 8.4V charging voltage.
The resistor divider R1=1.2MΩ and R3=130kΩ disables charging when the battery voltage goes down to less than 12.17V. V_IN(REG) = 1.190 × (1 + 1200000 ÷ 130000).
The resistor R5=12kΩ sets the charging current to 25mA. R_PROG = 297.5 ÷ 0.025. The maximum charging current for the coin cells is 95mA. When I tested this amperage by using a 3kΩ resistor, the LTC4079 was very hot as the PCB is too tiny to dissipate all heat.
The timer capacitor C2=0.1µF is set to disable charging after approximately 5½ hours. C_TIMER = 5.5 × 18.2.
The 10k NTC thermistor is NHQM103B375T5.

PCB

I used a 4-layer 1.2mm-thick PCB.

LED bulb

The flashlight uses E10 bulbs.

The default polarity of the BMW E30 flashlight bulb is to have – (negative or ground) at the tip of the bulb and to have + (positive) at the screw body. Most LED E10 bulbs have the opposite polarity: + at the tip and – at the body.

It’s relatively easy to change the wires, but the original connectors around the coin cells must be isolated well.

I checked a 1W LED light. It was really hot when it was on. The body of the flashlight is plastic and there is no airflow, so the plastic can melt.

I selected this LED: 0.5W, Screw E10, Nopolar, 12V Warm White(4300K). It can be connected to – and + both ways. It doesn’t get warm. It also has the same height as the original bulb: 22mm. It even has a lens.

Pictures

The flashlight is pretty bright and works for more than 10 hours on one charge.

There are BMW outer plastic housings for 2 and 3 poles. But they require watertight rubber housing inserts for each contact terminal.

BMW offers the sockets and wires with the housing inserts already molded around them: 61130007441 and 61130007442. You have to solder them to your existing wires and use shrink wraps to isolate them. They are pretty expensive: $8-9.

If you want to go the DIY way, rubber contact housing inserts can be 3D-printed and regular inexpensive contact sockets can be inserted in them and sealed with a glue. Contact will also look much better without soldered green-wire extensions.

This article is only about straight contacts. There are also 90° contacts, but I didn’t look for sockets for them. Some BMW sockets should be usable.

Contact Socket

The contact socket is made by TE Connectivity (formerly AMP).
At the time of writing, the silver sockets cost $0.27 each for quantities over 10. The gold sockets are of course 10 times more expensive.

T2030002008-000

TE Internal #: T2030002008-000
TE Internal Description: CEF-0.75
Contact Type : Socket
Contact Mating Area Plating Material : Silver
Wire Contact Termination Area Plating Material : Silver
Wire Size (AWG): 18
Wire Size (mm²): .75
Contact Current Rating (Max) (A): 16

This one has a slightly bigger hole for a wire: T2030002010-000

TE Internal #: T2030002010-000
TE Internal Description: CEF-1.0
Contact Type : Socket
Contact Mating Area Plating Material : Silver
Wire Contact Termination Area Plating Material : Silver
Wire Size (AWG): 18
Wire Size (mm²): 1.0
Contact Current Rating (Max) (A): 16

Check the inner hole diameters yourself: T2030002005-000 – Ø1.15mm, T2030002008-000 – Ø1.30mm, T2030002010-000 – Ø1.45mm.

There are also smaller and gold-plated sockets in the series.

There are similar contacts from other companies: Digikey heavy-duty sockets

3D-printed housing

The material is TPU (Thermoplastic polyurethane), which is flexible.

Only the upper part is cut to accommodate insertion of the socket.
The bottom part is a solid circle that wraps around the male part providing good sealing. If it were cut and glued, the adhesive bond could easily break under the stress of insertion.

Download the 3D model

Sculpteo 3D printing

I used the 3D-printing service provided by sculpteo.com
The material was TPU (flexible), HP Multi Jet Fusion Fusion (Plastic).
The price was $20 for 20 contacts plus shipping, $1 per contact.

It’s cheaper to attach more contacts to the existing design in a 3D-program if you need more contacts than to print multiple designs. The model can be joined in Freecad to produce more contacts at once. Use Boolean operation – there are YouTube videos explaining how to do it.

Here is the result.

Of course, there are other online services that provide 3D printing. But the printing material must be flexible, not rigid.

Contact installation

The 3D-insert crevices were cleaned of the excessive material dust using a knife and picks.

The wires were inserted into the sockets T2030002008-000 and they were crimped. The contact holes for wires were tight for the headlight wire gauge. The wiring diagram showed 1 mm² (16 AWG), though.

The sockets are pretty cheap to have an assortment and match different wire gauges perfectly. The biggest socket that will fit into the 3D-printed insert is T2030002015-000.

The sockets were inserted into the 3D-printed housing inserts.

The open parts of the housing inserts were glued together using the shoe cement “Petronio”. After the glue settled a little bit, the sides were pressed together. Probably, any flexible glue should be good enough. If you wish to use Super Glue, it should be used on both sides ignoring the glue instructions.

A day passed waiting until the glue hardened.

The contacts were installed successfully.

BMW E30, E32, E34, E36 connector plastic housings

The 3D-printed housing insert described in the article is compatible only with the straight contact terminal plastic housings.

• White 2-pole: 61131378401
• Gray 2-pole: 61131378402
• Yellow 2-pole: 61131378403
• Black 2-pole: 61131378400
• Black 3-pole: 61131378410

The other housings require angled contact terminals: 61131378416 (black), 61131378417 (white), 61131378418 (gray), 61131378419 (yellow).

Weld all parts together and paint them.

Download 3D model

The 6-speed transmission bracket for the E30 dimensions.

Use 4 square-headed M8X18 bolts (23711130250) to connect the bracket to the chassis.