Is there any IC that can be use to convert 9 bit binary code to seven segment display? EX: 100101100->300 I want to display 300 in seven segment display when 100101100 binary code applied to input.I want to do this only using ICs not using microcontrollers.

  • 1
    \$\begingroup\$ Why don't you want to use a microcontroller? That would probably be the best and cheapest option. \$\endgroup\$ – starblue Feb 19 '11 at 11:10
  • \$\begingroup\$ A microcontroller is the obvious choice. Since you have given no justification for why you don't want to use one, we can only assume that it is for silly religious reasons and therefore ignore that spec. \$\endgroup\$ – Olin Lathrop May 9 '17 at 15:41
  • 1
    \$\begingroup\$ 100101100 is not BCD for 300, 001100000000 is \$\endgroup\$ – old_timer May 9 '17 at 18:55
  • \$\begingroup\$ 100101100 is just binary...not binary coded decimal. and the ic you are looking for is called a microcontroller, esp since you have to do division (or multiplication by 1/10) if you want decimal. \$\endgroup\$ – old_timer May 9 '17 at 18:59

I can think of three ways to do this. I'll start from the most expensive and complicated and work my way down.

  1. All Logic IC's: Use a parallel-load 9-bit up/down binary counter (such as 3x 74hc190) and a 3-digit resettable BCD counter (3x 74hc163). Load the binary counter with your 9-bit number, and clear the BCD counter to 0. Clock both counters until the binary counter reaches zero. Load the output of the BCD counter into a latch, and then feed it to a BCD-7seg decoder. Repeat.
    • Pros:
      • Meets requirement of only using standard logic IC's
      • Requires no programming
    • Cons:
      • Expensive (The counter chips are about $1-2 each)
      • Prone to wiring failure
      • Requires a clock signal of 31kHz for 60Hz refresh
      • Requires 8-12 Logic IC's (I'll draw a schematic later)

  2. ROM Look-Up Table: Use a small parallel asynchronous FLASH memory (such as this one) to take all data inputs as an address, and then program the ROM to generate BCD outputs for 2 digits. Feed the result into a BCD-to-7seg decoder. Alternatively, use one ROM to generate a single decimal digit decoded into 7-segment pins.
    • Pros:
      • Fairly cheap price per digit
      • Scales better
      • Fast (but speed doesn't really matter)
      • Simple to wire/design
    • Cons:
      • Each ROM requires different programming
      • Need to buy a much larger ROM than needed
      • Programming requires computer automation.

  3. Microcontroller: A simple microcontroller with enough inputs and outputs can convert the binary number into BCD, and then encode it into 7-segment control signals. The cheapest solution (My digikey search picked out this PIC) will multiplex the output digits. You may need transistors to drive the common anode/cathode of your 7-segment displays, but those can be cheap transistors.
    • Pros:
      • The cheapest solution at $1.50 - $2.00 total
      • Simple Wiring
      • Ease of implementing Binary->BCD algorithm in software
      • Easy to add more functionality
      • Least expensive system for driving the display
    • Cons:
      • A chip programmer is required
      • You need to write software (not just a hardware problem)
      • The cheapest solution requires digit multiplexing, which is more complicated than direct drive.

I'll draw up some schematics later


I afraid there are no such standard chips. While there are BCD to 7segment chips, it will be hard to extract individual digits, as this would require 'divide by 10' chips.

Also, CPLDs are here for you.

If you can generate separate digits instead of single 9-bit number, you will be able to use standard chips.

  • \$\begingroup\$ +1 for pointing out that the source data is binary, not binary coded decimal, which makes logic-based conversions complicated. But any type of ROM chip for a lookup table is an easy solution. \$\endgroup\$ – Chris Stratton Feb 19 '11 at 15:22

Perhaps the easiest way would be to make a conversion table and put it into EPROM or FLASH with at least 9 address and 12 data lines. Otherwise CPLD or small FPGA (opencores.org has some HDL for this).

If you really wanted to do this using discrete ICs, you would have to construct a state machine implementing the algorithm, which would be the most complex solution and not really different from microcontroller except for increased price, size and complexity.

  • \$\begingroup\$ A ROM-based lookup table is the traditional solution, using whatever programmable ROM technology is cheapest and easiest for you to deal with. Though it will probably be more expensive and require more work to build a device programmer than modern micro controllers. Multi-digit displays are often multiplexed - easy with a micro, though with a ROM you could have a two-bit "digit" address input driven by an oscillator and counter and use that to alternately lookup one of the three digits during its turn to be displayed. Otherwise you'll need a fairly wide ROM. \$\endgroup\$ – Chris Stratton Feb 19 '11 at 15:24

Your example input, 100101100, is raw binary for 300, not binary coded decimal; BCD for 300 would be 0011 0000 0000. If you want to display numbers that are actually BCD, that's relatively straightforward. But if your inputs are really binary, it's a more complex problem.

To get from raw binary to decimal groupings, which will be necessary to drive the display, you effectively have to do base conversion, which entails doing some integer division. While you can accomplish this with logic IC's, it will take a boat load of them to do it, which implies a LOT of wiring, which means lots of opportunities for debugging.

Unless there's a compelling reason to use logic IC's, this would be an ideal task for an 8-bit microcontroller.


I don't think you can solve this easily with 1 IC. You could look at the MAX7231 chips, but they seem old and very expensive. You maybe can use the HEF4511 (or DS8669) if you can find a 10-bit <> BCD encoder of some sort. Also, you'd have a hard time creating it in such a way.

You may also be able to write down the boolean formulas for the 10-bit code to 3x a BCD output. I wouldn't expect that to be very simple, because 10 inputs to 3x4 outputs seems a lot of work.

I suppose you're doing this 'just for fun', doing this in the engineering world is not very cost effective. You probably need a 7 segment signal + 3 displays and 10 bits input. This is about 20 I/O. A simple PIC or AVR with 24 or 28 pins can handle that (or a CLPD if you require faster processing - however displays are for human eyes, so they don't have to be ultra fast).


It's not to hard to set up a CPLD or FPGA to convert binary data shifted MSB-first into decimal data. The core building block is a module with clock, data, and clear inputs, four latches D0-D3, and a combinatorial next-carry output. Cascade the blocks as one would a shift register. After the binary value is shifted in, the registers will hold the equivalent in BCD.

; Carry if >= 5
NextCarry = D3 | D2 & D1 | D2 & D0

; Will be 8 or 9 iff input was 4 or 9
D3 := !D3 & D2 & !D1 & !D0 | D3 & D0

; Will be 4-7 iff input was 2-3 or 7-8
D2 := !D3 & !D2 & D1 | !D3 & D2 & D1 & D0 | D3 & !D0

; Will be 2-3 or 6-7 iff input was 1, 3, 6, or 8
D1 := !D3 & !D2 & D0 | !D3 & D2 & D1 & !D0 | D3 & !D0

; Will be odd iff carry-in is set
D0 := CarryIn

Note that it's necessary to clear the register before each use; shifting in zeroes will NOT suffice. Clearing circuitry is not shown, but should be obvious.


As it happens, there is a circuit which does exactly what you want - assuming you are using TTL logic levels and 4 DIP ICs fits your "any IC" requirement. That circuit is the 74185, and the exact configuration you want can be found in Figure 6 on page 7. There are a few drawbacks, of course. To begin with, the 74185 is 30 years old and is definitely obsolete. However, you can get them on eBay. Second, you'll need 4 of them, and that will run you more than 20 bucks. Third, the total power required will be 5 volts at 300 to 400 mA.

But other than that, it's pretty straightforward. And for what it's worth, it's actually in line with the spirit of some of the other answers. As the data sheet states, the IC is actually a 32 x 8 PROM.

Otherwise, for single-chip memories you're out of luck. Although the lsb does not require transformation, an output of 300 needs 9 IC outputs, and you just won't find (E)(E)PROMS with more than 8 outputs.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.