Construct a number from 0-999.9 using 5 data bytes of a MIDI SysEx message

Question

I'm sending MIDI messages to a proprietary turntable that has an LCD screen on it. The normal software sends out updates via MIDI SysEx to display the current tempo on the LCD. The MIDI is being received on a MKL25Z128VLK4, Cortex-M0+/ARMv6-M device. (I did disassemble the firmware .bin after digging in its guts for the type of chip it's using, but the result of that was ~30k lines of assembly) The LCD model number is inaccessible without desoldering

At this point, I can successfully update the screen but I'm having trouble figuring out the pattern from a given number and I'm hoping someone else has experience with this.

Here's what I have found so far:

Setting a single byte to anything from 9-126 results in 00.0

  BPM   B1    B2    B3    B4
 00.0   0     0     0     0
 00.0   0     0     0     1
 00.0   0     0     0     2
 00.0   0     0     0     3
 00.0   0     0     0     4
 00.0   0     0     0     5
 00.0   0     0     0     6
 00.0   0     0     0     7
 00.0   0     0     0     8
 00.0   0     0     0    16
 00.0   0     0     0    32
 00.0   0     0     0    64
 00.1   0     0     0   127
 00.1   0     0     1     0
 00.3   0     0     2     0
 00.4   0     0     3     0
 00.6   0     0     4     0
 00.8   0     0     5     0
 00.9   0     0     6     0
 01.1   0     0     7     0
 01.2   0     0     8     0
 00.0   0     0    16     0
 00.0   0     0    32     0
 00.0   0     0    64     0
 02.4   0     0   127     0
 02.5   0     1     0     0
 05.1   0     2     0     0
 07.6   0     3     0     0
 10.2   0     4     0     0
 12.8   0     5     0     0
 16.3   0     6     0     0
 17.9   0     7     0     0
 20.4   0     8     0     0
 00.0   0    16     0     0
 00.0   0    32     0     0
 00.0   0    64     0     0
 38.4   0   127     0     0
 40.9   1     0     0     0
 81.9   2     0     0     0
122.8   3     0     0     0
163.8   4     0     0     0
204.8   5     0     0     0
245.7   6     0     0     0
286.7   7     0     0     0
327.6   8     0     0     0
 00.0  16     0     0     0
 00.0  32     0     0     0
 00.0  64     0     0     0
614.4 127     0     0     0

Turning on multiple bytes adds them together with sometimes strange results

 40.9   1     0     0     0
 00.1   0     0     1     0
 41.1   1     0     1     0

 81.9   2     0     0     0
 00.1   0     0     1     0
 82.0   2     0     1     0

I'm wondering if there's some floating point or bitwise maths going on that I'm just not well versed in, and if so what are the real numbers and data types used for the calculations? I feel understanding this is crucial to solving this problem without a massive lookup table or gutting it and writing my own controller

Answer 1

Binary

MIDI data bytes are 7 bits, meaning they can have decimal values from 0 to 127.

In a 7-bit binary number:

• the bit on the right represents a decimal value of 1.
• the next bit to the left represents a decimal value of 2.
• the next bits to the left represent decimal values of 4, 8, 16, 32, and 64.

Decimal values from 0 to 127 can be expressed in seven bits, where each bit is a 0 or 1.

binary   decimal
0000001  1 = 1
0000010  2 = 2
0000011  3 = 2 + 1
0000100  4 = 4
0000101  5 = 4 + 1
0000110  6 = 4 + 2
0000111  7 = 4 + 2 + 1
0001000  8 = 8
0001001  9 = 8 + 1
...
1111111  127 = 64 + 32 + 16 + 8 + 4 + 2 + 1

Pattern

From the results you described, I suspect the turntable only cares about the lowest 4 bits in each byte. In other words, only the bits with decimal values of 1, 2, 4, and 8 will have an effect on the tempo display. This means only byte values 0 to 15 are useful.

I suspect the turntable is using the following pattern:

B1  B2  B3  B4  tempo  display
 0   0   0   0   .00     .0
 0   0   0   1   .01      "
 0   0   0   2   .02      "
 0   0   0   3   .03      "
 0   0   0   4   .04      "
 0   0   0   5   .05      "
 0   0   0   6   .06      "
 0   0   0   7   .07      "
 0   0   0   8   .08      "
 0   0   0   9   .09      "
 0   0   0  10   .10     .1
 0   0   0  11   .11      "
 0   0   0  12   .12      "
 0   0   0  13   .13      "
 0   0   0  14   .14      "
 0   0   0  15   .15      "
 0   0   1   0   .16      "
 0   0   1   1   .17      "
 0   0   1   2   .18      "
 0   0   1   3   .19      "
 0   0   1   4   .20     .2
...

The byte values represent tempo values in .01 units, but when the turntable displays the tempo, it hides the last digit.

This hidden digit explains why turning on multiple bytes doesn't always produce the sum of the tempos displayed by the individual byte values.

B1  B2  B3  B4  tempo  display
 1   0   0   0  40.96   40.9
 0   0   1   0    .16     .1
 1   0   1   0  41.12   41.1

Bitwise math

When only some bits are used, bitwise math is indeed useful.

For example, here's some Javascript to convert a tempo to the needed byte values:

t = 123.4;

v = 100 * t;

b1 = (v >> 12) & 15;
b2 = (v >> 8) & 15;
b3 = (v >> 4) & 15;
b4 = v & 15;

console.log(b1, b2, b3, b4);

x & 15 is a bitwise AND, in this case, to keep only the lowest four bits.

x >> 4 is a right shift, in this case shifting the value 4 bits to the right, which discards the lowest four bits. This has the same effect as dividing by 16 and discarding the remainder.

Here's some Javascript to convert the byte values to the displayed tempo:

b1 = 3;
b2 = 0;
b3 = 3;
b4 = 4;

b1 = b1 & 15;
b2 = b2 & 15;
b3 = b3 & 15;
b4 = b4 & 15;

v = 16*16*16*b1 + 16*16*b2 + 16*b3 + b4;

t = parseInt(v / 10) / 10;

console.log(t);

In your web browser, you can go to about:blank, then press F12 and go to Console to enter these small Javascript calculations. (For your safety, enter about:blank in the address box, and never run code from strangers if you don't understand it.)