Decimal to BCD Converter

Working of Binary Coded Decimal — BCD Encoding Rules and Bit Patterns

Working of Binary Coded Decimal relies on one simple rule: map every decimal digit to its 4-bit equivalent, and concatenate the results. Because there are only ten valid decimal digits (0–9), only ten of the sixteen possible 4-bit patterns are used. The remaining six patterns — 1010 through 1111 (representing 10–15 in pure binary) — are invalid in standard BCD encoding and are sometimes called pseudo-tetrads or pseudo-tetrades.

BCD Encoding Rules

• Each decimal digit occupies exactly 4 bits (one nibble).
• Valid BCD patterns run from 0000 (decimal 0) to 1001 (decimal 9).
• Invalid BCD patterns — 1010 to 1111 — do not represent any valid digit. If they appear in BCD data, they indicate an error or a reserved special purpose (such as a sign indicator or decimal-point marker in extended BCD variants).
• Multi-digit decimals are encoded left to right, one nibble per digit, with no carry between digits.
• The decimal point itself is not encoded as a nibble; instead, its position is tracked implicitly, using a fixed-point convention, or by assigning a pseudo-tetrad a special meaning.

Truth Table for Binary Coded Decimal

Truth Table for Binary Coded Decimal — the complete mapping of every valid decimal digit to its BCD code and binary breakdown:

Numbers with a Decimal Point

Handling fractional decimal values in BCD requires a deliberate strategy because the decimal point is not itself a binary digit. Three common approaches exist:

• Pseudo-tetrad marker: Assign one of the six invalid patterns (e.g., 1010) to represent the decimal point position.
• Fixed-point convention: Always encode a fixed number of digits before and after the point, padding with leading or trailing zeros as necessary. For instance, 5.7 stored as a two-digit-dot-one-digit fixed-point number becomes 0000 0101 . 0111.
• Implicit position: Store the BCD digits without the point and record the point position separately in a control byte or header field.

Using the simple dot-separator notation, the number 5.7 in BCD is written as 0101 . 0111 — each side of the decimal point is encoded independently using the standard nibble mapping.

Common Arithmetic Operations on BCD Numbers

Because BCD preserves decimal digit boundaries, arithmetic operations require special handling that differs from standard binary arithmetic. The four core operations — addition, subtraction, multiplication, and division — each have a defined procedure to ensure the result remains a valid BCD code.

1. BCD Addition

To add two BCD numbers, add the corresponding nibbles as if they were standard 4-bit binary values. If the sum of any nibble pair exceeds 9 (i.e., the result is greater than 1001), add the correction factor 0110 (decimal 6) to bring the result back into the valid BCD range. This step compensates for the six unused patterns (1010–1111).

BCD Addition Example: 45 + 37 = 82

  0100 0101   (45)
+ 0011 0111   (37)
-----------
  0111 1100   (7 12 — invalid BCD, digit exceeds 9)

  0111 1100   (Invalid result)
+ 0000 0110   (Add correction factor 0110)
------------
  1000 0010   (82 — valid BCD result)

The lower nibble produced 12 (binary 1100), which is an invalid BCD pattern. Adding the correction factor 6 converts it to a carry plus 2, yielding the correct answer 1000 0010 (82 in BCD).

2. BCD Subtraction

BCD subtraction follows the same digit-by-digit approach. If a digit being subtracted is larger than the digit above it, borrow from the next higher nibble and apply a correction. When the difference is a valid BCD digit (0–9), no correction is needed.

BCD Subtraction Example: 47 − 23 = 24

  0100 0111   (47)
- 0010 0011   (23)
-------------
  0010 0100   (24 — valid BCD result)

Final BCD Result: 0010 0100, representing decimal 24.

3. BCD Multiplication

BCD multiplication is handled by converting the BCD digits to their binary equivalents, performing standard binary multiplication, and then converting the binary product back to BCD. This approach avoids the complexity of direct BCD multiplication logic.

BCD Multiplication Example: 5 × 3 = 15

    0101   (5 in binary)
×  0011   (3 in binary)
---------
  0000 1111   (15 in binary)

Convert 15 to BCD:
1 → 0001
5 → 0101
15 in BCD: 0001 0101

Final BCD Result: 0001 0101, representing decimal 15.

4. BCD Division

BCD division mirrors the multiplication process: convert both operands to binary, perform binary division, and convert the quotient back to BCD. Any remainder must also be converted back to BCD if a fractional BCD result is required.

BCD Division Example: 18 ÷ 3 = 6

  0001 1000   (18 in binary)
÷     0011   (3 in binary)
------------
  0000 0110   (6 in binary)

Convert 6 to BCD: 6 → 0110

Final BCD Result: 0110, representing decimal 6.

Where BCD Is Used: Real-World Applications of Binary-Coded Decimal

Despite the rise of floating-point arithmetic and high-density binary storage, BCD remains an active standard across several industries because it eliminates the translation overhead between human-readable decimal and machine-internal binary.

1. Digital Displays

1. Digital Displays — Seven-segment LED and LCD displays in clocks, stopwatches, calculators, multimeters, and digital thermometers decode BCD directly. A dedicated BCD-to-seven-segment decoder IC (such as the 7447 or CD4511) accepts a 4-bit BCD nibble and drives the correct segments to show the corresponding decimal digit, entirely eliminating software-based number-to-character conversion.

2. Embedded Systems

2. Embedded Systems — Microcontrollers that must interact with human operators through decimal keypads or numeric readouts often store internal state variables in BCD. This strategy avoids run-time conversion, reduces code complexity, and lowers the risk of rounding artefacts in safety-critical or timing-sensitive embedded applications such as industrial timers and process controllers.

3. Data Conversion and Storage

3. Data Conversion: Financial and banking software relies on BCD (particularly packed BCD) to store monetary amounts without the floating-point rounding errors inherent in IEEE-754 representations. The classic example is that the value 7.1 cannot be expressed exactly in standard binary floating-point, yet it converts to BCD code without any loss of precision. Barcode scanners and RFID readers also use BCD internally when encoding numeric product identifiers.

4. Arithmetic Operations in Hardware

Dedicated BCD arithmetic units are embedded in older CPUs (including the Intel x86 family's DAA and DAS instructions), programmable logic controllers (PLCs), and mainframe processors. These units perform addition and subtraction directly on BCD values, using built-in correction logic to handle nibble overflow, which simplifies the hardware design for applications that live entirely in the decimal domain.

5. Control Systems

5. Control Systems — Industrial control panels, building-management systems, and SCADA interfaces frequently display process variables (temperatures, pressures, flow rates) as decimal numbers on BCD-driven readout panels. BCD allows the control logic to output numeric data directly to the display driver without a separate binary-to-decimal conversion stage, reducing system latency and component count.

BCD and Invalid Bit Patterns — Understanding Pseudo-Tetrades

Of the 16 possible 4-bit combinations, BCD only legitimately uses 10. The six unused patterns — 1010 (10), 1011 (11), 1100 (12), 1101 (13), 1110 (14), and 1111 (15) — are collectively called pseudo-tetrades or pseudo-tetrads. In standard BCD arithmetic, encountering one of these patterns signals either a calculation error or an overflow condition that requires the correction factor to be applied.

Some extended BCD systems deliberately assign pseudo-tetrades a special meaning: for example, one pattern might indicate a positive sign, another a negative sign, and another the position of a decimal point. This technique allows a single BCD stream to carry both numeric data and formatting metadata without needing a separate control channel. However, any system that uses pseudo-tetrades for special purposes must document those assignments explicitly, because different standards assign different meanings to these patterns.

When you use this tool on this page, the output will never contain a pseudo-tetrad, because it encodes only valid decimal digits (0–9). If you are decoding externally sourced BCD data and encounter one of these patterns, consult the originating system's documentation to determine whether the pattern represents an error or a special symbol.

Related Conversion Tools for Binary-Coded Decimal and Digital Number Systems

If you are working with BCD and related binary codes, the following tools complement the decimal to bcd converter and cover the full range of conversions you are likely to need:

• BCD to Decimal Converter — Reverse the process: convert BCD nibble groups back to their original decimal representation instantly.
• Decimal to Excess-3 Converter — Encode decimal digits using the self-complementing Excess-3 (XS-3) code, where each digit is represented as its BCD value plus 3.
• BCD to Excess-3 Converter — Translate directly between BCD and Excess-3 without passing through the decimal stage.
• Excess-3 to Decimal Converter — Decode Excess-3 encoded values back to human-readable decimal numbers.
• BCD Addition Calculator — Perform digit-by-digit BCD addition with automatic correction factor application and step-by-step solution output.
• Even Parity Calculator — Compute the even parity bit for binary data words, essential for error detection in digital communication and storage systems.
• Gray Code to Binary Converter — Convert Gray code (reflected binary) values to standard binary, commonly used in rotary encoders and error-minimising digital circuits.
• Decimal to ASCII Converter — Translate decimal character codes into their ASCII equivalents, useful for text encoding, protocol analysis, and embedded firmware development.