BCD Converter

Digit encoding reference

Six of the sixteen nibble values are unused in BCD, which is where the roughly 20% storage overhead comes from. A byte holds 0-99 in packed BCD against 0-255 in plain binary.

Packed versus unpacked

Packed BCD puts two digits in a byte: 1234 becomes the two bytes 12 34. Unpacked BCD gives each digit its own byte with the high nibble zeroed, so the same number is 01 02 03 04 - four bytes. Packed halves the storage and is what hardware registers use; unpacked is easier to index, easier to print, and what you convert to before driving a display.

An odd digit count has to be padded, because a byte holds two nibbles. The convention is a leading zero nibble, so 123 packs as 01 23. Some financial formats instead use the low nibble of the last byte as a sign, which is why COBOL packed-decimal fields end in 0x0C for positive and 0x0D for negative.

Why BCD survives

BCD is less efficient than binary and slower to do arithmetic in, and it is still everywhere. Real-time clock chips - the DS1307, DS3231, PCF8523 - report seconds, minutes, hours and date as BCD registers, because the part drives a display more often than it does arithmetic and BCD makes digit extraction a shift and a mask. Seven-segment decoder ICs take BCD directly.

The other reason is exactness. Decimal fractions like 0.1 have no finite binary representation, so a binary float accumulates error in a way that shows up on a bank statement. Decimal-coded formats do not, which is why IBM mainframe packed decimal, IEEE 754 decimal floating point and every serious money type are decimal underneath.

The cost is arithmetic. Adding two BCD numbers as binary can produce a nibble above 9, so hardware needs a decimal-adjust step: add 6 to any nibble that overflowed. x86 exposed this as the DAA instruction; on ARM you do it in software, which is a large part of why BCD arithmetic is avoided outside the domains that need it.

The classic RTC bug

uint8_t raw = i2c_read(DS1307_SECONDS);   /* 0x25 */
uint8_t wrong = raw;                       /* 37 - reads as binary */
uint8_t right = (raw >> 4) * 10 + (raw & 0x0F);  /* 25 */

Code Examples

#include <stdint.h>

/* Packed BCD byte -> binary, the RTC read path */
uint8_t bcd_to_bin(uint8_t bcd) {
    return (uint8_t)((bcd >> 4) * 10 + (bcd & 0x0F));
}

/* Binary -> packed BCD, the RTC write path */
uint8_t bin_to_bcd(uint8_t bin) {
    return (uint8_t)(((bin / 10) << 4) | (bin % 10));
}

/* Validate before trusting a nibble */
int bcd_valid(uint8_t bcd) {
    return (bcd >> 4) <= 9 && (bcd & 0x0F) <= 9;
}

Frequently Asked Questions

Related Tools