Last month we presented our multi-digit display system. This month we provide a flexible PCB for large and small displays.

When we first started the Mega Digits project, one key focus we had was flexibility. This is why we settled on an Arduino in the engine room (since we can load up all sorts of sketches to perform all sorts of tasks), and a stackable 74HC595 driver to take care of the heavy lifting. The combination of these make for a very powerful and versatily system indeed!

However, when it came time to creating a circuit board for this project, we wanted to make sure it was as useful as it could be, for various applications. Since most of the high power LED strip and other light sources that are most convenient for a project like this are 12V powered, we have adapted for 12V power too. The result is a simple, yet powerful driver board, suitable for 12V applications.

THE BROAD OVERVIEW

For this installment of Mega Digits, we'll focus on the circuit board and how it works, getting a single digit running with our circuit board. Next month we'll progress to full blown construction of a finished project using multiple modules.

We'll be the first to admit that there are other solutions out there, and they're all great too. However we wanted flexibility, and overall power, that isn't common amongst the other systems available. For this reason, we have created a single PCB that is designed for use at two different power levels. After all, the same basic circuit can be used for 30cm high digits, or 1m high digits!

HOW IT WORKS

In part one, we created a powerful, daisy-chain approach to driving the display digits. In reality, 4-way 7-segment displays are reasonably easy to come by these days. Using our circuit for standard-size digits isn't really the best solution, however this was never the intention. Mega Digits, after all, don't really come in tiny packages - we want to create something HUGE. At the very least, larger than standard!

The 74HC595 driver is suitable for direct-powering of small devices with up to 35mA of current per segment. Fine for a standard digit, but not really much for anything larger. Therefore, we need to use some transistors to step things up to a more practical, Mega Digit suitable level.

Unfortunately this raises a question of "how much current do we need", which, until we have a firm application is a tough one to answer. So we decided to keep things versatile. We have integrated a TO-92 package option, as well as a TO-220 option, with a preference for 12V power input. This opens the door to use just about any 12V lighting available on the market, be it flexible strip, 12V CCFL tubes, or anything else you like. Indeed, while our Arduino code is intended for digits and clock functions, you can also implement this as a great 12V lighting controller. But, were getting off track now, aren't we. The key point is driving 12V lighting, that you can arrange into a 7-segment style pattern to achieve a huge display digit (which is probably then replicated several times to achieve the number of digits you want to have). As the 74HC595 does the heavy lifting, you can have many separate banks of digits from a single Arduino if you want to, for a large scoreboard, date/time display, temperature display, or whatever else you have a need for.

THE 12V SUPPLY

In our initial design, we simply used the Arduino as the power source. We didn't need an excessive amount of power, so it worked just fine. Things get a little tricky as we step it up however. As often happens with Arduino systems these days, we have a need for 12V power (for the light strips), and 5V power (for the Arduino, as well as the 74HC595). As a result, we have flipped things around. You'll need a suitable 12V source to drive the display anyway, so we simply tap that so there's no independent 5V supply required. By using a 78L05 5V regulator, you have a clean and reliable 5V rail. This is fed directly to the 74HC595 for power, but you can also optionally provide it through the jumpers to power your Arduino as well.

If you're daisy-chaining multiple units together as we expect, you only need to do this from one of the boards. Again, we're trying to keep the boards versatile for most purposes. The best option would be to solder a link or use headers and a jumper on your first digit, providing power to the Arduino.

THE PCB DESIGN

We have selected two suitable transistors with their appropriate resistor values. In reality you can use many different types of transistors for this application. Simply make sure your transistor has the same pin orientation as those used here, and select an appropriate pair of resistors for each. However we have selected two based on their relatively low cost, and suitability for the power levels we want to achieve.

The PCB (and your 12V power supply) is really the limiting factor for this design, as the copper tracks can only take so much current. We would suggest the copper track limit for the TO220 circuit is 5A per segment, however we'd suggest a circuit-limit of 20A total, and you should not exceed this. Of course, that's PLENTY of current unless you're running digits on an aircraft runway! Considering most LED strip is approximately 1A per metre, that gives you a single-strip size, capable of 4m high digits (or 2m high running two lengths of strip for each segment, etc). With 20A per PCB, we could go to 6m high. That's 4 x 3m segments = 12A + 3 x 2m horizontal segments = 6A for a total of 18A. That's pretty MEGA!

We have also kept implementation of multiple units straight forward. They are designed to be mounted side-by-side. You can then link the modules very easily. Of course, using nylon spacers, you can easily stack them on top of each other. The only thing you'll have to do differently is wire the DATA OUT pin on JP2 to the DATA IN pin on JP1 on the next board in the stack. A 6-way ribbon cable and two 5-way pin-sockets, or IDCs running from the serial out to the next serial in achieves this neatly.

In order to provide plenty of power capability, half the top and all of the bottom of the PCB has a copper flood. This is an on-purpose design consideration, to provide as little voltage drop, and as much power as possible. It does mean that our PCB itself becomes something of a capacitor, but it's not an issue for this circuit.

You will notice that both transistor options share two pads. In order to achieve this we have specifically selected transistors which have pinouts compatible with this idea. If you're using different transistors to our selections, please be cautious of this as the mounting requirements may differ.

Our BD649 TO-220 package transistors received the most consideration, so they could easily utilise a large, common heatsink if you were really pushing them to their limits with your display.

The Build

We have broken the parts list into common parts, as well as the few parts that change between the BIG and BIGGER versions. Common components and optional hardware are shown, as are the relevant parts depending on your current requirement.

The parts here are not extremely critical in terms of their specifications. We have selected two common NPN transistors that can be obtained easily and at a relatively low cost.

Some of you will wonder why we didn't use a ULN2003 or similar device. In reality, we wanted a single versatile PCB. Using the transistor pads for the low and high current versions was the most straight forward option to make the board compatible for both. Since a ULN2003 comes in a DIP package, it would require an entirely different layout consideration. It's also important to note that while each segment is rated 500mA, the total chip current can't exceed 2.5A. This is probably ok for many purposes, but not really the spirit of the large digits we're aiming for.

REF:	Parts Required:	Jaycar	Altronics
R1-8	8 x 10kΩ Resistor	RR2798	R7582
C1	1 x 1µF Capacitor	RE6032	R4718
D1-8	8 x 1N4004 Diode	ZR1004	Z0109
IC1	1 x 74HC595 Integrated Circuit	ZC4895	Z8924
IC2	1 x 78L05 Voltage Regulator	ZV1539	Z0460
PCB	1 x DIYODE Custom PCB

OPTIONAL:
J1	Jumper (soldered link can be used also)
JP1-2	Pin Header / Stackable Header

Go big - 500mA PER SEGMENT:

REF:	Additional Parts Required:	Jaycar	Altronics
R9-16	8 x 1kΩ Resistor	RR0572	R7558
T1A-T8A	8 x 2N2222 NPN Transistor	ZT2298	Z1166

go bigger - 3,000mA PER SEGMENT:

REF:	Additional Parts Required:	Jaycar	Altronics
R9-16	8 x 270Ω Resistor	RR0558	R7039
T1-T8	8 x BD649 NPN Transistor	ZT2198	-

Note: A heatsink is recommended on the GO BIGGER circuit.

You'll also require jumper wires and standard prototyping hardware.

ASSEMBLY

This circuit can be made on breadboard or prototype board, however the custom PCB makes assembly very straight forward. It's a double-sided PCB design as noted previously, to provide plenty of copper for throughput of the current required for the display elements.

The usual rule for manual assembly is "hardware, passive, active", meaning that you can fit the jumpers / headers first if they're being used, and any other fixed hardware.

PASSIVE COMPONENTS: The resistors and capacitors come next. While we haven't specified a polarised capacitor for C1, if you're using a polarised electrolytic capacitor, take care to orient it correctly (it's fairly simple to see which side is ground, for your negative marks to line up with).

ACTIVE COMPONENTS: Your active components should be the last into your board, but most importantly - the 74HC595 which is static sensitive. For this reason, you should solder your diodes and transistors onto the board first. Take care with orientation of the diodes.

When inserting the 74HC595, take careful care with orientation. Use a grounding strap, or at the very least touch a grounded device to reduce potential static damage (the metal on a computer, or a soldering iron control box - not the hot part!).

NOTE: You can also perform the tests in the next section BEFORE installing the 74HC595 as an additional precaution.

TESTING

Before applying power to your LED strips, take a careful look at your solder joints to look for bad joints, bridged tracks, or anything else out of the ordinary. Once you are satisfied with your assembly, you can apply 12V power.

Assuming correct assembly, you should be able to perform the following tests with your multimeter (most measurements are against ground / 0V).

• If you have used the 5V regulator and jumper to provide 5V power, measure the 5V jumper pin to ensure you have 5V. If you find more than 5V, DO NOT CONNECT to your Arduino.
• Check that you have 5V on pin 16 of the 74HC595 (or it's solder pad if you're testing prior to installation).
• Check for any voltages on the common tracks between JP1 and JP2 (other than the 5V pin). You should not see anything other than logic-level voltages (and should be floating if IC1 is not yet inserted).

These checks are relatively basic, but will help you avoid sending voltage to your Arduino you don't want, and potentially avoid letting the smoke out of the 74HC595 too. Because 12V is virtually "everywhere" on the PCB, it's easier than usual to find a shorted track sending 12V somewhere unexpected.

WIRING LED STRIPS

Regardless of the specific type of 12V LED strip you're using, they're all fairly straight forward. If you're using enclosed strip with bare wire ends, you may have to wire a little differently to us. In our examples, we're using bare PCB strip that can be cut into small sections, sold on a roll. This strip is becoming fairly common.

We will create templates for layout of our strip sections in Part 3 next month, but it's fairly straight forward to arrange them into a seven segment type pattern.

Note: You may have noticed our board has eight outputs. This is to handle the "dot" segment usually found on a seven segment display for use as a decimal. If you're going to create a display that utilises the decimal we've got you covered.

As our system is Common Anode, we can wire all the positive sides of the strip together. Then we simply wire each negative output (which is switched on and off by the 74HC595) to our relevant segment.

For our wiring example here however, we'll use segmented LED strip. These are quite straight forward devices. Each section contains three SMD (Surface Mount Device) LEDs, and associated 150ohm SMD current-limiting resistors. All of the sections are connected in series. At either end of a section are two copper pads where you can connect the required 12V DC power supply. The strips are sold in one continuous strip, so you need to cut strips at a per segment interval, to suit your requirements. There is a gap between each pair of segments where you should cut [1]. You can connect the 12V supply to the whole strip to test it if you want, but BEWARE; they are REALLY bright, so protect your eyes!

1

Remember, that what we are building is a large 7-segment display and each segment is made from sections of LED strips. As mentioned earlier, we built the prototype on a piece of cardboard. This allowed easy mounting of the Arduino UNO and the breadboard too. You could use timber or plastic, for example.

Given that the LED strips have an adhesive backing we laid them out appropriately, then removed the backing and stuck them down. You can (gently) pry them off the cardboard (or alternate surface) once stuck on, but if they’re on cardboard you’ll rip off bits of the surface so they won’t stick as well the second time - but they will stick.

As the strip sections are 50mm long we settled on six LED sections high, by two LED sections wide. We began by cutting four 3-sections pieces and three 2-sections pieces. The 3-section pieces form the vertical segments of our display and the 2-section pieces form the horizontal segments. We decided to create a common anode design with a simple transistor switch for each segment. Each LED section has a positive (anode) and a negative terminal (cathode). As we need to connect the anodes together we laid the strips out with the anodes on the “inside”, closest to each other. This makes it easy to interconnect them with a small piece of wire [2]. The common anode is then connected to +12V [3].

The cathodes now control illumination of each segment. It's important to note that we have used Jumper wires for our prototype to check everything is working adequately. However you should use wires that are suitable for the amount of current running to each segment. The anode can potentially carry eight times the segment current, and the cable needs to be rated as such.

TESTING THE DIGIT

Without an Arduino providing data, you're not going to get a whole lot of activity on the digit. Now is a good time to connect your Arduino, and load up our counter sketch from the resources, and see what happens.

Only five connections are required to control the display from an Arduino. Take care to use the SERIAL IN side of the board, which is on the right hand side looking top down with the transistors at the top.

PCB	ARDUINO
DATA	14
CLOCK	12
LATCH	8
5V	5V
GND	GND

Providing everything has been constructed and your circuit is working as intended, you should see your giant digit spring to life and start counting!

If your Arduino doesn't switch on, ensure you have your regulator installed and the jumper installed also. If you're not getting any counting, check the serial output with the Arduino connected to computer.

If your Arduino code is working, check over the PCB for soldering errors and misplaced components.

WHERE TO FROM HERE?

Here we have the potential for HUGE displays. MASSIVE displays in fact. In reality, the 3A "GO BIGGER" system is really capable of much more, with adequate heatsinking and perhaps different transistors.

Next month, we'll finalise everything into a full working system. Because the size of your display digits are still flexible to your own purpose and desire, we can't make cases or wiring guides much clearer. However we'll complete the switching mechanisms into a box, and create a full-scale system complete with control box, and some construction templates for making digits specifically to certain specifications.

Part 1