1
\$\begingroup\$

I want to build a 9-digit 7 segment LED display with basic components. I am planning to use a 4-inch 7 segment LED display and an Arduino board for my application.

According to my understanding, I would be needing 17 I/O pins (9 pins for control lines of 9 digits and 8 pins for data lines of LED's of each segment).

  • I want to know about the electrical characteristics that I would need to consider before I rig up the circuit.
  • Would Arduino Leonardo suffice for my application?
  • Is there a need for an extra driver IC? If so, which one would be recommended?
| improve this question | | | | |
\$\endgroup\$
  • \$\begingroup\$ You can shave that 9 lines of 9 digits into 4 lines by letting the uC output binary, decode it into decade and supply into the 7 segment displays. \$\endgroup\$ – Bradman175 Jan 25 '17 at 11:18
  • \$\begingroup\$ Warning, the decimal point has a lower forward voltage. \$\endgroup\$ – Bradman175 Jan 25 '17 at 11:29
1
\$\begingroup\$

Electrical characteristics

You must consider the maximum characteristics. This includes the maximum DC forward current the display can handle. Maximum reverse voltage should also be noted down as well. 60mA max for 7 segments and 30mA max for the DP.

By the looks of it, you should be running the 7 segments at 20mA and the DP LED at 10mA to be safe.

Forward voltage should also be taken into consideration. You should be powering this display from a 12 volt supply since the forward voltage CAN BE (Vf is not consistent as it varies at different currents, make show you don't blow up the LED by overestimating the forward voltage!!! Read below to see what I mean by overestimating since in the formula of determining the series resistor, the Vf deducts the supply voltage.) a whopping 7.8V (DP is 3.9V) where it can increase all the way to 10V (DP is 5V).

Now lastly, it's using those values. You need these values in order to know what resistor to use. However it's not that simple. The forward voltage changes at different forward currents. Check the datasheet and look at the graph that shows the relation between them.

Now calculate on here and you get your resistor value.

Would an Arduino Leonardo suffice?

Currently with your method, it will just work since the Leonardo has 20 pins capable of outputting IO and you would omit pin 13 which is already connected to an LED and 1 and 2 since they're connected to Tx and Rx. However you can shave some pins down. Since you're going to be lighting the LED's one by one at a fast rate to give the illusion that they're all on at once, you can shave the 9 pins for each segment display into 4, saving 5 pins. This means you'll have more space for other stuff. You don't have to do this though otherwise you would need a BCD (or 4bit binary) to decade decoder IC.

Need any driver IC's?

Yes and no. Since your arduino runs at 5V and you would be driving the LED display at a much higher voltage, you would need to drive them. You could use a whole lot of PNP transistors and resistors in series with each base in addition to the resistors in series with the LEDs to drive them, or supplement the individual transistors together with a PNP transistor array IC which makes things a lil bit more organised.

And if you're shaving these 9 pins into 4, you would need a BCD to decimal decoder as you're driving with binary this way.

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

While it is possible to do this with a large pile of discrete logic chips, the obvious solution is a microcontroller.

The simple way to multiplex is to use 8 lines that activate each of the 8 segments across the digits, and 9 lines that activate each of the digits.

Set up a interrupt of around 5-10 kHz, and switch to a new digit each interrupt. You keep a table of the 8 segment values to write each digit. This table therefore has 9 entries. Each interrupt, you:

  1. Turn off the current (or all, if that's easier) digit enable line.

  2. Write the byte for the new digit to the 8 segment lines.

  3. Enable the digit line for the new digit.

  4. Advance the current table location by one, wrapping from the end back to the beginning.

  5. Fetch the new table value and leave it ready for step #2 of the next interrupt.

Note that sequencing thru all the digits sequentially is usually not the best approach. The flicker will be less noticeable at the same refresh rate when you interleave updates of digits. For example, instead of the sequence being digits 1 2 3 4 5 6 7 8 9, you might try 1 6 2 7 3 8 4 9 5. There are various schemes.

The foreground code can then write a new 8-bit value to a table entry at any time, and that will automatically get written to the digit instantaneously in human time.

All the above is a considerable amount of logic to hard wire, but pretty basic stuff for even a modest microcontroller. All you need from the micro is 17 output pins for this part of the task.

Now consider how you're going to generate the segment values, and the digit values before that. You really want to use a micro for this.

| improve this answer | | | | |
\$\endgroup\$

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.