Controlling an LED matrix

[Slicko]

Just wondering if anybody has any advice with regard to controlling an LED matrix via a PIC16F877A or similar device.

I'm still in the learning stages with C and am trying to write a program that will control an LED matrix. It doesn't really matter what size at the moment, i'm just starting with the basics and working my way up.

Lets presume a 5x5 matrix.

The basic code i've got so far is below. I've used the Switch Case statement to achieve it, which isn't what I wanted to do. I want code that will allow me to create an array of the 'font' arrays that contain the coordinates of needed LEDs. I know you can't put an array inside an array in C, but are there different methods that achieve the same result?

[asmboy]

this kind of application is usually done with multiplexing of the led on states - often with SPI for row/column addresses and a set of decoders --
and is much more complex in the time domain than what you have done so far.

ALSO - the "font" is best described by an array of bit mapped values - not quasi rendered as you have tried so far -a it will consume too many clock cycles when you try tos cale it up


you might show a SCHEMATIC - so we can see what is going on in the BIG picture.

[Slicko]

Thanks for the reply,

Yeah I know the final thing will be much more complicated than what I have so far, I'm just not sure how to get to that point yet.

really basic schematic of just the port b and port c outputs to the LEDs:



Also with this obviously a LOW bit at any of the B pins would signify that it's on so the LEDs on that row can switch on.

So far most things i've found on the internet just give you pre-made source code which i'm sure will work, but it doesn't help me understand it. So far it's been a bit of a trial and error task

EDIT: Oh and I found this page as an example of people who have already done it. I've downloaded their source code but my knowledge of C isn't great yet so I'm finding it pretty difficult to follow / work out how they've achieved what they have.

[Ttelmah]

The big problem with what you show, is the lack of any series resistors.
Assuming red LED's, Vf will typically be perhaps 2.2v. Output high voltage, and low voltage will be being limited by the PIC 'maxima' at something like 25mA. Potentially not good for the PIC, pulling either the -ve drive or +ve drive (depending on which one current limits first....), outside their recommended drive range......

Best Wishes

[Slicko]

I didn't include anything in the schematic but the basic pin connections. In reality you'd have series resistors to set the current and use transistors as switches with the emitters connected to supply voltage, base connected to each of the PICs C pins, and emitters connected to the corresponding LED matrix column. In a 5x5 matrix this means the maximum current draw at any time would be around 125mA.

It isn't really the schematic design i'm worried about, it's just the software for driving it. the code I've got in my first post should be sufficient in creating an image on the matrix, but isn't very accurate, and will start taking up LOOOTS of space once more characters / images are coded into it.

Is it better to use interrupts? How would I go about making and using an array of bitmapped values?

[Slicko]

I've realised I can do it using a multi-dimensional array.

I can place all the 'fonts' in a separate fonts.h file and then the for loop in main can search through and grab the right one. I presume after this I can modify it to accept more characters per scan than the one?

[Mike Walne]

Matrix basics,

You're right, you need to use transistors to drive enough current through your LED matrix (emitter to power rail, base (via resistor) to PIC and collector to LED matrix). As already said, you essentially multiplex the drives. I usually use pnp devices with current limiting resistors to drive the anodes of each row to the +5V rail, and npn's to drive the cathodes in columns to the 0V ground rail.

Suppose you have an 8*8 matrix and you want say 10mA average current through a lit LED. Each column is only on ~10% of the total time, therfore each LED passes ~100mA when lit. If all the LEDs in one column are lit then the npn device for that column needs to handle 800mA easily. In other words all the column drivers have to handle the 800mA, and the row drivers & limit resistors 100mA. The whole thing soon scales up to very big currents requiring careful attention to supply decoupling etc. You may find that you get problems with turning bipolar transistors off fast enough (charge storage effect). In that event, you either use Baker clamps or migrate to FETs.

It's easier to get a stable display by using a timer driven interrupt. Suppose you interrupt at say 1kHz. After 8 interrupts the pattern for the 8*8 matrix repeats. Your display should then update at 125Hz without visible flicker. Using an interrupt in this way frees up the PIC to do other jobs. Let's assume that all the rows are driven from one port and all the columns from another port. The column data is simply 0x80, 0x40, 0x20 ....0x01 repeat from 0x80. The row data is stored in an 8 element array row_data. The row_data array is a mimic of the LED matrix display. You pass all the row_data and column_data to the display in byte sized chunks.


Sequence for interrupt goes:-

1) Turn off all columns
2) Send new_row_data to row port.
3) Send new_column_data to column port.
4) Look up the next new_row_data from row_data array so that new_row_data is ready for the next pass.
5) Work out the next new_column_data again ready for next pass.
6) Any other tasks then leave.

The dead time between activating each column avoids leakage from one column to the next.
You could let main do the looking up processes 4 & 5.



The main loop looks after the row_data array.

You can scroll the image horizontally by shifting the data in the row_data array.
For the above I've assumed that row_data[0] is output when column 0 is active etc.

You could also achieve scrolling by outputting row_data[0] when in column 1 is active, then column 2 etc. This way you're using the row_data array as a circular buffer. Looking after the relationship between row_data and column_data is more complex, but is a lot faster than shifting data around in the row_data array. (Probably helps to have the more elements in the array than columns.)

You appear to be only considering expanding to a wider matrix. For a wider matrix you use a bigger row_data array, a higher interrupt frequency, and may have to go to external decoders to drive the extra columns. For a large matrix the peak current through the LEDs can be quite substantial, its important that the column drivers don't get stuck. It's worthwhile to check drivers before actually connecting to the LED matrix, or try using seriously larger value limit resistors for testing (there's only one per row).

Good luck (and happy new year).

Mike

[ckielstra]

[temtronic]

Be sure to use a HIGH current power supply !! As pointed out, current demands are huge for LEDs compared to the PIC. Something like a regulated 'wallwart' good for 4 AMPS would be a good choice.
Also add good 'filtering' caps., ie: .001mfd, .1mfd, 10mfd, near PIC as well as each driver transistor.
If you don't, 'noise' from switching the LEDS can (and will) cause the PIC to 'go funny'....

[Slicko]

Thanks for all the feedback / advice. I need to order some components and I'll get on with testing the code, and let you know how I get on

I mainly need to get more confident with C, so I'm still reading a lot trying to learn as much as I can.

Happy new year!