User Rating 0.0 ★★★★★

Total Usage 0 times

Category Code Utilities

BCD Mode

Input Format

BCD Input Binary: 01000101 01001001 | Hex: 45 49 | Decimal: 69, 73

Byte-by-Byte Breakdown

#	Input Byte	Binary	Nibble(s)	Digit(s)	ASCII	Status

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Binary-Coded Decimal (BCD) encodes each decimal digit into a fixed number of binary bits, typically 4 bits per digit. Misinterpreting BCD data as straight binary produces values that drift silently from the intended decimal - a class of bug that corrupts financial records, sensor telemetry, and legacy mainframe data without triggering obvious errors. This tool decodes both packed BCD (two digits per byte, 8 bits total) and unpacked BCD (one digit per byte, upper nibble zeroed or zoned) into readable ASCII text. It also handles EBCDIC-coded decimal mapping for mainframe interchange scenarios.

Conversion validates every nibble against the legal BCD range 0000 - 1001 (decimal 0 - 9). Nibbles outside this range - 1010 through 1111 - are flagged as invalid rather than silently truncated. The tool accepts binary, hexadecimal, and decimal byte representations. Note: this converter assumes unsigned BCD with no sign nibble. Signed BCD variants (where the last nibble encodes sign) require separate handling.

Formulas

Packed BCD stores two decimal digits in a single 8-bit byte. The upper nibble holds the tens digit, the lower nibble holds the units digit. Extraction and ASCII conversion proceed as follows:

d_high = (byte >> 4) ∧ 0x0F

d_low = byte ∧ 0x0F

ASCII_char = d + 0x30

Where d_high is the upper nibble (bits 7 - 4), d_low is the lower nibble (bits 3 - 0), and 0x30 (48 decimal) is the ASCII code for the character "0". Each nibble must satisfy 0 ≤ d ≤ 9; any value outside this range is not a valid BCD digit.

For unpacked BCD, each byte carries one digit in the lower nibble. The upper nibble is typically a zone field - 0011 in ASCII-zoned BCD (0x30 - 0x39) or 1111 in EBCDIC-zoned BCD (0xF0 - 0xF9). The conversion strips the zone:

d = byte ∧ 0x0F

Where byte is the full 8-bit unpacked BCD value. The result d is then converted to ASCII by adding 0x30.

Reference Data

Decimal Digit	BCD (4-bit)	Unpacked BCD Byte (Hex)	Packed BCD (2 digits/byte example)	ASCII Code (Dec)	ASCII Char
0	0000	0x30	0x00 (with 0)	48	0
1	0001	0x31	0x01	49	1
2	0010	0x32	0x02	50	2
3	0011	0x33	0x03	51	3
4	0100	0x34	0x04	52	4
5	0101	0x35	0x05	53	5
6	0110	0x36	0x06	54	6
7	0111	0x37	0x07	55	7
8	1000	0x38	0x08	56	8
9	1001	0x39	0x09	57	9
Common Packed BCD Byte Examples (two digits per byte)
12	0001 0010	-	0x12	49, 50	12
45	0100 0101	-	0x45	52, 53	45
78	0111 1000	-	0x78	55, 56	78
90	1001 0000	-	0x90	57, 48	90
99	1001 1001	-	0x99	57, 57	99
Invalid BCD Nibbles (cause conversion errors)
-	1010 (A)	0x0A	Invalid	-	Error
-	1011 (B)	0x0B	Invalid	-	Error
-	1100 (C)	0x0C	Sign nibble (+)	-	Sign
-	1101 (D)	0x0D	Sign nibble (−)	-	Sign
-	1110 (E)	0x0E	Invalid	-	Error
-	1111 (F)	0x0F	Unsigned sign / fill	-	Fill

Frequently Asked Questions

Packed BCD stores two decimal digits per byte - one in the upper nibble (bits 7-4) and one in the lower nibble (bits 3-0). This is space-efficient: the value 42 is stored as a single byte 0x42. Unpacked BCD uses one full byte per digit. The lower nibble holds the digit (0-9) and the upper nibble is a zone code - typically 0x3 for ASCII-zoned systems or 0xF for EBCDIC-zoned systems. Unpacked BCD is easier to process but uses twice the storage.

BCD encodes decimal digits 0-9 only. A 4-bit nibble can represent 0-15 (0x0-0xF), but values 10-15 (0xA - 0xF) have no corresponding decimal digit. In some signed BCD conventions, nibbles 0xC and 0xD serve as positive and negative sign indicators in the last byte, and 0xF may act as an unsigned filler. Values 0xA, 0xB, and 0xE are always invalid and indicate corrupted data or a non-BCD encoding.

In ASCII-zoned BCD (used on most modern systems), the upper nibble of each unpacked byte is 0x3, producing byte values 0x30-0x39 - which happen to be the ASCII codes for "0" - "9". In EBCDIC-zoned BCD (IBM mainframes), the upper nibble is 0xF, producing byte values 0xF0-0xF9. The lower nibble in both cases holds the actual digit. This converter handles both zone conventions by masking off the upper nibble.

This tool processes unsigned BCD data. In signed packed BCD, the last nibble encodes the sign (0xC for positive, 0xD for negative, 0xF for unsigned). If you input signed BCD data, the sign nibble will be flagged as an invalid digit. To handle signed BCD, strip the final nibble manually and apply the sign to the resulting decimal string before conversion.

Three formats are supported. Binary: strings of 0s and 1s, optionally separated by spaces (e.g., '0100 0101'). Hexadecimal: pairs of hex characters, optionally space-separated (e.g., '45 90 12'). Decimal bytes: comma-separated decimal byte values from 0-255 (e.g., '69, 144, 18'). All formats are parsed into raw bytes before BCD decoding is applied.

BCD operates on 4-bit nibbles. For packed BCD, each byte requires exactly 8 bits (2 nibbles = 2 digits). For unpacked BCD, each byte is also 8 bits (1 zone nibble + 1 digit nibble). If your binary string (after removing spaces) does not divide evenly into 8-bit groups, the converter cannot form complete bytes and will report an error. Pad with leading zeros to reach a multiple of 8 bits.