The seven-segment display decoder
Turning a 4-bit digit into a numeral
A seven-segment display decoder is a combinational circuit that maps a 4-bit binary-coded-decimal input (the digits 0 to 9) to seven outputs named a through g, each driving one bar of the numeral so the lit bars spell the digit.
A decoder turns a binary code into one specific output line, and binary-coded decimal stores one decimal digit (
0 to 9) in four bits. Put those two ideas together and you get one of the most recognizable circuits in electronics: the part that turns a 4-bit digit into the glowing bars of a numeral on a calculator, a microwave clock, or a scoreboard. It is a decoder with a twist. Instead of raising a single one-hot line, it raises the whole *set* of segment lines that draw the digit, and every one of those lines is a small boolean function you can derive with a Karnaugh map.Picture the display as seven tiny bars arranged in a figure-eight: two stacked squares that share one bar across the middle. Light the right subset of bars and you draw any digit. Light all seven and you get an
8; light only the two on the right and you get a 1. The decoder's entire job is to decide, for each input digit, which bars to switch on.The seven bars, named a to g
The segments have standard names,
a through g. Reading the figure-eight from the top: a is the bar across the top, b and c are the two bars down the right side, d is the bar across the bottom, e and f are the two bars down the left side, and g is the bar across the middle. Fixing these positions is what lets us write one truth-table column per segment.a: top bar.b: upper-right bar.c: lower-right bar.d: bottom bar.e: lower-left bar.f: upper-left bar.g: middle bar.
Which segments each digit lights
Now the heart of the lesson: for every digit
0 to 9, which of the seven bars are on? A 1 means the segment is lit, a 0 means it is dark. This table is the complete specification of the decoder, and every entry can be checked by looking at how the numeral is actually drawn.| digit | a | b | c | d | e | f | g |
|---|---|---|---|---|---|---|---|
| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 |
| 2 | 1 | 1 | 0 | 1 | 1 | 0 | 1 |
| 3 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
| 4 | 0 | 1 | 1 | 0 | 0 | 1 | 1 |
| 5 | 1 | 0 | 1 | 1 | 0 | 1 | 1 |
| 6 | 1 | 0 | 1 | 1 | 1 | 1 | 1 |
| 7 | 1 | 1 | 1 | 0 | 0 | 0 | 0 |
| 8 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| 9 | 1 | 1 | 1 | 1 | 0 | 1 | 1 |
0 lights the whole outer loop (a,b,c,d,e,f) but not the middle bar g; 1 lights only the right pair b,c; 7 lights a,b,c (a top bar and the right side); and 8 lights all seven.A couple of rows are worth pausing on. The digit
0 is the only one that lights all of the outer loop while leaving g dark, which is exactly what stops it looking like an 8. The digit 1 is the sparsest, just b and c. And the middle bar g stays dark for precisely three digits, 0, 1, and 7, the three numerals with no horizontal stroke through their waist.It is really a lookup table (so it is a decoder)
Look at the table column by column rather than row by row. Each segment (
a, b, c, ... g) is its own output, and its column is a full truth table over the four BCD input bits. So a seven-segment decoder is nothing more than seven independent boolean functions that share the same four inputs. That is why it counts as a decoder: four address-like bits go in, and a fixed pattern of output lines comes out, read straight from a stored table. You could even burn the whole table into a small ROM or PLA and skip the algebra entirely. Here, though, we derive one segment by hand so you can see the gates behind the lookup.Deriving segment a from the table
Take segment
a, the top bar. From the table it is lit for the digits 0, 2, 3, 5, 6, 7, 8, 9 and dark only for 1 and 4. Writing the input as the four BCD bits D3 D2 D1 D0 (weights 8 4 2 1) gives this sub-table, one output column for a:| D3 | D2 | D1 | D0 | a |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 |
| 0 | 0 | 0 | 1 | 0 |
| 0 | 0 | 1 | 0 | 1 |
| 0 | 0 | 1 | 1 | 1 |
| 0 | 1 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 0 | 1 | 1 | 0 | 1 |
| 0 | 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 0 | 1 |
| 1 | 0 | 0 | 1 | 1 |
a as a function of the four BCD bits, for the ten valid digits 0 to 9. It is 0 only in the rows for 1 (0001) and 4 (0100). The six input patterns 1010 to 1111 never occur in valid BCD, so they are don't-cares we may set either way to shrink the logic.Drop these into a four-variable Karnaugh map with the six invalid patterns (
10 to 15) marked as don't-cares. Grouping the 1s (and using the don't-cares wherever they help make a bigger block) gives four clean groups:- All eight cells with
D3 = 1are1or don't-care, so the whole block collapses to the single termD3(it covers digits8and9). - All eight cells with
D1 = 1are1or don't-care, giving the termD1(it covers2, 3, 6, 7). - The block where
D2 = 0andD0 = 0is all1or don't-care, givingD2'·D0'(it covers digit0). - The block where
D2 = 1andD0 = 1is all1or don't-care, givingD2·D0(it covers digit5).
OR the four groups together. The last two,
D2'·D0' and D2·D0, are exactly the two cases where D2 and D0 are equal, which is the XNOR of those two bits. So the whole segment collapses to a strikingly short expression:a = D3 + D1 + D2'·D0' + D2·D0 = D3 + D1 + (D2 XNOR D0)
That XNOR term is a nice sanity check on the whole method. Segment
a (the top bar) is off for only two digits, 1 and 4. In both, D3 and D1 are 0, and D2 and D0 disagree (1 is 0001, 4 is 0100), so D2 XNOR D0 is 0 and the top bar goes dark. For every other digit at least one of D3, D1, or the equality of D2 and D0 holds, and the bar lights.The circuit below is that expression built from real gates: an XOR and a NOT form the
D2 XNOR D0 term, and two OR gates fold in D3 and D1. Open it in the lab, dial the four bits to each digit, and confirm a matches the table.a of the decoder: a = D3 + D1 + (D2 XNOR D0), with the XNOR built as an XOR feeding a NOT. Set the four BCD inputs D3..D0 (weights 8, 4, 2, 1) to a digit; a (the top bar) should be high for every digit except 1 (0001) and 4 (0100).Seven functions, one shared input
The full decoder is just six more derivations exactly like that one, each reading its own column out of the segment table and minimizing it, all sharing the same four input bits. Some come out short (segment
c, the lower-right bar, is dark for only the digit 2, so its logic is tiny), and some are busier. Stack the seven minimized functions side by side and you have a complete BCD-to-seven-segment decoder: four wires in, seven segment drivers out, a numeral on the glass.Try it
Use the segment
a equation, a = D3 + D1 + (D2 XNOR D0), to predict the top bar for digit 4 (input 0100) and digit 6 (input 0110). Then check both against the segment table above.Answer
Digit
4 is D3 D2 D1 D0 = 0100: D3 = 0, D1 = 0, and D2 = 1 while D0 = 0, so D2 XNOR D0 = 0. The sum 0 + 0 + 0 is 0, so a = 0, the top bar is dark. The table agrees: 4 is drawn with no top stroke. Digit 6 is 0110: D1 = 1, so a = 0 + 1 + ... = 1, the top bar is lit, which also matches the table (a 6 does have a top bar). The equation reproduces the table row for row.Common mistakes. First, the digit font is a convention, not a law: some displays draw
6 without the top bar a, 7 with an extra upper-left f, or 9 without the bottom d, so a different font gives slightly different equations. Verify against the exact table you are building for. Second, the six input patterns 1010 to 1111 are not valid BCD; treating them as don't-cares is a design choice that minimizes the gates, but a real chip (like the 7447) instead defines fixed, sometimes blank or odd, patterns for them, so do not assume they are free unless your spec says so. Third, watch the display polarity: a common-cathode display lights a segment on a 1, but a common-anode display is active-low and lights on a 0, which inverts every output. Finally, segment g (the middle bar) is dark for 0, 1, and 7, not just 0, a spot people often get wrong.The seven-segment decoder is where abstract logic becomes something you can read at a glance: it is the bridge from a binary count to a human numeral, and it shows a decoder is really a stored table of boolean functions, one per output line. That same look-it-up pattern reappears in a ROM or PLA and in the control logic of a CPU. Next, feed this decoder from a counter that ticks once per second and you have built the display of a digital clock.
Frequently asked
What is a seven-segment display decoder?
It is a combinational circuit that takes a 4-bit binary-coded-decimal digit (
0 to 9) and drives seven outputs, named a through g, each controlling one bar of the numeral. The lit bars spell the digit, so 0000 lights all bars except the middle one to draw a 0, and 1000 (8) lights all seven.How is a seven-segment decoder different from a normal decoder?
A plain decoder raises exactly one one-hot output line for a given input code. A seven-segment decoder instead raises a whole *set* of output lines (the segments that draw the digit) for each input, so it is seven independent boolean functions sharing the same four input bits rather than a single one-hot selector.
What is the boolean equation for segment a?
For a standard common-cathode digit font, segment
a (the top bar) minimizes to a = D3 + D1 + (D2 XNOR D0), using the four BCD bits D3 D2 D1 D0 and treating the six invalid input patterns as don't-cares. It is high for every digit except 1 and 4, the only two with no top stroke.Why does the seven-segment decoder use don't-cares?
A 4-bit input has sixteen patterns, but valid BCD uses only ten (
0000 to 1001); the six patterns 1010 to 1111 never occur, so their outputs can be set to whatever makes the Karnaugh map groups largest. Using those don't-cares shrinks each segment's logic to fewer, simpler gates.Every lesson here builds toward one thing: a working CPU, from the transistor up.
Open the free lab →