Best (eg fastest) way to convert BCD values to Integers

[easytarget]

I have been working with a Real Time Clock that returns it's time values in Binary Coded Decimal format;

[eg: (for the uninitiated) when you read the 'seconds' byte, the digits are recorded in the lower four bits (nibble) of the byte, and the tens are similarly held by the upper four bits. so if the clock value is 15 seconds it is retrieved as a single byte with upper four bits = 0b0001, lower four bits = 0b0101, the actual byte value you see is decimal integer 21, or 0x15 in hexadecimal.]

I'm wondering if there is any more efficient way to convert from the BDC value to integer (and v.versa) than the pair of lambda's I came up with:

byte_to_bcd = lambda x : 16 * (x // 10) + (x % 10)
bcd_to_byte = lambda x : 10 * (x >> 4 & 0xF) + (x & 0xF)

I want to return the clock integer values (eg 6 bytes, YMD:hms, all bcd coded) as fast as possible following an interrupt, so I'm interested in any speedup, especially to the byte_to_bcd function, that I can find.

[GitHubsSilverBullet]

By far the fastest would be to use a translation array (back and forth)
Costs two times 256 bytes.

[robert-hh]

In this case 60 and 90 bytes, since the seconds/minutes range is 0-59

[easytarget]

Unfortunately the year is also BCD coded, so I get 254 bytes total. Still not bad.

[robert-hh]

If space is tight, you can copy the low order bit and access the tables with values shifted 1 bit right. The table would contain only the even numbers, reducing it's size by 2. That works since 10 and 16 have 2 as common divider.

bcd_val = bcd_table[bin _val >> 1] | (bin _val & 1)

Depending on the platform not be faster than division + modulus.

[sosi-deadeye]

I don't know if it's faster, but if you multiply by a value of the power of 2, then you could use shift operations instead.

>>> math.log2(16)
4.0

So, you could shift by 4 instead of multiply by 16

byte_to_bcd = lambda x: ((x // 10) << 4) + (x % 10)
bcd_to_byte = lambda x: (x >> 4) * 10 + (x & 0x0F)

But I don't know what the compiler does and if a shift operation if faster than a multiplication.

Two weeks ago, I found this: https://graphics.stanford.edu/~seander/bithacks.html
Very helpful

[robert-hh]

The most "expensive" operations are division and modulus. Many compilers would replace multiplication with and division by a power of two with shifts. I do not know however, if the MicroPython compiler supports these shortcuts.

[GitHubsSilverBullet]

Using ARM assembler one could shift-left once and then shift-left twice into a new register. Then add'em up to have the original value multiplied by 10. Won't get much faster.

[easytarget]

OOh, thanks everybody for replies.
I was only considering solving this algorithmically, but translation via arrays sounds better.

I'm going to do a test with translation (byte)arrays. I'll report the results back here for interests sake if nothing else.

[easytarget]

I put together a couple of tests; tables beat logic+arithmetic by 2.5x (or so).

MPY: soft reboot
MicroPython v1.27.0 on 2025-12-09; Generic ESP32P4 module with WIFI module of external ESP32C6 with ESP32P4
Type "help()" for more information.

>>> import bcd_to_byte
Converting BCD to Bytes; 10000 conversions
table: 4630 μs
maths: 13772  μs

>>> import byte_to_bcd
Converting Bytes to BCD; 10000 conversions
table: 4723 μs
maths: 12023 μs
>>> 

Not exactly surprising of course; what did surprise me is how much of a difference it makes by putting the bytearrays in a const(), it essentially doubles the speed on my esp32p4 devboard.

byte_to_bcd.py

from time import ticks_us

# fill a tuple with 0 -> 100 in integers
bytecount = 100 * tuple(range(100))

# bytearray mapping integers to BCD values
byte_bcd_table = const(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19 !"#$%&\'()0123456789@ABCDEFGHIPQRSTUVWXY`abcdefghipqrstuvwxy\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99')

def baseline():
    start = ticks_us()
    for x in bytecount:
        _ = x
    return ticks_us() - start

def table_pointer():
    start = ticks_us()
    for x in bytecount:
        _ = byte_bcd_table[x]
    return ticks_us() - start

def shift_manipulate():
    start = ticks_us()
    for x in bytecount:
        _ = 16 * (x // 10) + (x % 10)
    return ticks_us() - start

base = baseline()
print("Converting Bytes to BCD; {} conversions".format(len(bytecount)))
print('table:', table_pointer() - base, 'μs')
print('maths:', shift_manipulate() - base, 'μs')

bcd_to_byte.py

from time import ticks_us

# fill a tuple with 0 -> 100 in BCD
bcdcount = 100 * [int(str(x),16) for x in range(100)]

# bytearray mapping BCD to integers
bcd_byte_table = const(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\x00\x00\x00\x00\x00\x00\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x00\x00\x00\x00\x00\x00\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x00\x00\x00\x00\x00\x00\x1e\x1f !"#$%&\'\x00\x00\x00\x00\x00\x00()*+,-./01\x00\x00\x00\x00\x00\x0023456789:;\x00\x00\x00\x00\x00\x00<=>?@ABCDE\x00\x00\x00\x00\x00\x00FGHIJKLMNO\x00\x00\x00\x00\x00\x00PQRSTUVWXY\x00\x00\x00\x00\x00\x00Z[\\]^_`abc')

def baseline():
    start = ticks_us()
    for x in bcdcount:
        _ = x
    return ticks_us() - start

def table_pointer():
    start = ticks_us()
    for x in bcdcount:
        _ = bcd_byte_table[x]
    return ticks_us() - start

def shift_manipulate():
    start = ticks_us()
    for x in bcdcount:
        _ = 10 * (x >> 4 & 0xF) + (x & 0xF)
    return ticks_us() - start

base = baseline()
print("Converting BCD to Bytes; {} conversions".format(len(bcdcount)))
print('table:', table_pointer() - base, 'μs')
print('maths:', shift_manipulate() - base, 'μs')