The byte behind a digit

Ten bytes and you are done

The sketch's font is one line:

const uint8_t d[] = {
  0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F
};

Index 0 is the byte for a zero, index 9 for a nine. Bit 0 is segment A, bit 1 is B, and so on up to bit 6 for G. Bit 7 is the decimal point, so d[3] | 0x80 is a 3 with a point after it.

Slide through the digits. A 1 in the byte lights that bar, and the path it takes is short: the shift register output for that bit goes to one input of U2, a ULN2803A.

What U2 does with a 1

The ULN2803A is eight transistor stages, one per segment, and each one is inverting: when its input is high it sinks current from its output pin to GND. Its output goes through a resistor (75 ohm for A to G, 510 ohm for the point) to that segment's pin on the display, and the display's other end is the common anode, on the 12 V side.

So a 1 does not push current into a segment. It completes a path: 12 V through the dimmer to the anode, through the segment, through its resistor, through U2 to GND. A 0 leaves that path open.

How much current flows in a lit segment is not in any file we have, and we did not measure it. The shape of the sum is the 12 V, minus about 1 V across U2 (the datasheet gives 1.0 V typical at 200 mA), minus the segment's own forward voltage, divided by 75 ohm. U2 is rated for 500 mA per channel, and a 3.3 V logic high is enough to switch it: its input needs at most 2.4 V at 200 mA.

The one word that ruins it

shiftOut() takes a bit order, and both spellings are valid:

shiftOut(SER, CLK, MSBFIRST, d[n]);   // bit 7 goes out first
shiftOut(SER, CLK, LSBFIRST, d[n]);   // bit 0 goes out first

This board wants MSBFIRST: the bit sent first travels furthest, to QH, which is the decimal point, and the bit sent last stays in QA, which is segment A. Send the byte the other way and every bit lands on its mirror segment.

Switch the figure to LSBFIRST. The result is not a blank display or a broken one but a different, valid pattern, sometimes another digit. That is why the mistake survives: nothing looks wrong enough to suspect one word in one call.