How to multiplex a matrix of LED's.

These tutorials demonstrate how to multiplex 64 LED's, arranged as a matrix of 8x8, we use one port to 'source' the columns, and another port to 'sink' the rows. So the Multiplex LED board requires two port connections, one for rows and one for columns - notice that NEITHER of these have the 0V or 5V pins connected, they aren't used at all. The technique of multiplexing allows you to individually access any one LED, or any combination of LED's, with just sixteen output pins.

It's also worth noting that we're driving the LED's entirely from the PIC, which is why I chose 150 ohm current limiting resistors, this keeps the current down to within the PIC's individual pin limits, and also within the overall chip limits - but both are pushed pretty close!, this is done to get as much brightness as possible from the LED's, whilst minimising the component count on the board. Because of the current requirements the processor board MUST have a 7805 regulator, a 78L05 won't provide enough current.

The technique used for the display is to show each section in turn, so we display row 1, then row 2, then row 3, and continue through the other five rows - as long as we do this fast enough you can't see any flickering - this obviously restricts what else the program can be doing, as we must refresh the display regularly enough to prevent visible flicker. As with the previous 7 segment multiplexing tutorial, I'm again using timer driven interrupts in order to transparently refresh the LED matrix - and the code is basically very similar (and simply modified from it).

The interrupts are generated by Timer2, which is set to give an interrupt roughly every 16mS. Interrupts in a PIC cause the program to stop what it's doing, save it's current location, and jump to the 'Interrupt Vector' - which on a PIC is address 0x0004. The interrupt routine then does what it needs to do and exits using the 'REFIE' (REturn From IntErrupt) command - this works rather like a normal 'RETURN' in that it returns the program to where it was when the interrupt was called. An important point to bear in mind when using interrupts is that you mustn't change anything the main program is using - for that reason the first thing we must do is save various resisters - the W register, the PCLATH register, and the STATUS register - these are saved in data registers allocated for their use, and are restored before the routine exits via 'RETFIE'.

The interrupt routine is shown below, the first 5 lines save the registers mentioned above, the 'swapf' command is used as it doesn't affect the STATUS register, there's not much point saving the register if we've already changed it!. Next we check is the interrupt was generated by the timer or not, in this case we're only using one interrupt source (TIMER2) - but often you may be using multiple interrupt sources, if it's not TIMER2 we simply jump to the EXIT routine, which restores the registers saved and exits via RETFIE.

Now we start the actual interrupt routine itself, the first thing we have to do is reset TIMER2 - once it's triggered an interrupt it turns itself off, so we turn it back on here (bcf PIR1,TMR2IF). Next we start our display routine, first we need to find out which display we're updating - in this case we're selecting one of eight display ROWS in turn, we do this by simply checking which was the previous display (using seven 'btfss' instructions, with each one jumping to a different routine to set the new ROW to be displayed) - I originally tried to do this directly using the PORT register, but it didn't really work, so I added a GPR (row_pos) which I use to store the position. We only need seven tests, because if those seven fail it MUST be the eighth one that was the previous row. The actual values for the eight columns are stored in the variables 'zero', 'one', 'two' etc. Each of the eight row display routines (Do_Zero etc.) first turns OFF the previous row, which will blank the complete display, then preload the column data from the respective register. Lastly it turns that row ON, to display the data for that row. There's probably no need to blank the display before displaying the new row?, but it ensures that only one row at a time is ever displayed - and it only costs 400nS extra time with a 20MHz clock.

; Interrupt vector

ORG 0x0004


INT
movwf w_temp ; Save W register
swapf STATUS,W ; Swap status to be saved into W
movwf s_temp ; Save STATUS register
movfw PCLATH
movwf p_temp ; Save PCLATH

btfss PIR1,TMR2IF ; Flag set if TMR2 interrupt
goto INTX ; Jump if not timed out

; Timer (TMR2) timeout every 16 milliseconds


bcf PIR1,TMR2IF ; Clear the calling flag


btfss row_pos, 0 ;check which ROW was last
goto Do_One
btfss row_pos, 1 ;check which ROW was last
goto Do_Two
btfss row_pos, 2 ;check which ROW was last
goto Do_Three
btfss row_pos, 3 ;check which ROW was last
goto Do_Four
btfss row_pos, 4 ;check which ROW was last
goto Do_Five
btfss row_pos, 5 ;check which ROW was last
goto Do_Six
btfss row_pos, 6 ;check which ROW was last
goto Do_Seven

Do_Zero movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf zero, w
movwf COL_PORT ;load columns
bcf row_pos, 0
bcf ROW_PORT, 0 ;turn ON row zero
goto INTX

Do_One movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf one, w
movwf COL_PORT ;load columns
bcf row_pos, 1
bcf ROW_PORT, 1 ;turn ON row one
goto INTX

Do_Two movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf two, w
movwf COL_PORT ;load columns
bcf row_pos, 2
bcf ROW_PORT, 2 ;turn ON row two
goto INTX

Do_Three movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf three, w
movwf COL_PORT ;load columns
bcf row_pos, 3
bcf ROW_PORT, 3 ;turn ON row three
goto INTX

Do_Four movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf four, w
movwf COL_PORT ;load columns
bcf row_pos, 4
bcf ROW_PORT, 4 ;turn ON row four
goto INTX

Do_Five movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf five, w
movwf COL_PORT ;load columns
bcf row_pos, 5
bcf ROW_PORT, 5 ;turn ON row five
goto INTX

Do_Six movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf six, w
movwf COL_PORT ;load columns
bcf row_pos, 6
bcf ROW_PORT, 6 ;turn ON row six
goto INTX

Do_Seven movlw 0xFF
movwf ROW_PORT ;turn off all rows
movwf row_pos
movf seven, w
movwf COL_PORT ;load columns
bcf row_pos, 7
bcf ROW_PORT, 7 ;turn ON row seven


INTX
movfw p_temp
movwf PCLATH ; Restore PCLATH
swapf s_temp,W
movwf STATUS ; Restore STATUS register - restores bank
swapf w_temp,F
swapf w_temp,W ; Restore W register
retfie


The interrupt routine above is complete and working, but it requires TIMER2 setting up before it can work, this is done in the 'Initialise' section of the program, which is the first section called when the program runs. This first turns the analogue inputs off, then sets the direction registers for the Ports to all outputs, then sets TIMER2 to the correct time, you will notice there's two lines (with one commented out) for setting the value of T2CON - if you comment out the second one, and use the first one, it makes the interrupt routine timing too slow - you can actually see the digits flickering, first one then the other - worth doing so you can see what's going on. After that we set up PR2, this sets the value that the timer counts to before it times out - then we enable TIMER2 interrupts by setting the TMR2IE flag in register PIE1. This still isn't enough, so finally we write to the INTCON register to enable 'Peripheral Interrupts' and 'Global Interrupts'.

Initialise BANKSEL ADCON1 ;disable analogue inputs
movlw 0x06
movwf ADCON1
BANKSEL PORTA
bsf STATUS, RP0 ;select bank 1
movlw b'00000000' ;Set port data directions, data output
movwf ROW_TRIS
movwf COL_TRIS
bcf STATUS, RP0 ;select bank 0

clrf COL_PORT ;turn OFF all LED's
movlw 0xFF
movwf ROW_PORT

call Clear ;clear display registers

; Set up Timer 2.

;movlw b'01111110' ; Post scale /16, pre scale /16, TMR2 ON
movlw b'00010110' ; Post scale /4, pre scale /16, TMR2 ON
movwf T2CON

bsf STATUS, RP0 ;select bank 1

movlw .249 ; Set up comparator
movwf PR2

bsf PIE1,TMR2IE ; Enable TMR2 interrupt

bcf STATUS, RP0 ;select bank 0

; Global interrupt enable

bsf INTCON,PEIE ; Enable all peripheral interrupts
bsf INTCON,GIE ; Global interrupt enable

bcf STATUS, RP0 ;select bank 0


This is the main section of the first program, as you can see there's not a great deal to it, all it does it display a 'square' using the outer layer of LED's, delay 1 second, then 'invert' the display (make lit ones dark, and dark ones lit), and delay a further second, then loop back, this give a simple flashing square pattern on the display. As with the previous interrupt multiplexing tutorial, the display function is handled totally transparently by the interrupt routine - all we need to do is place the values required in the eight display data registers.

Main call Square ;display a square
call Delay1Sec
call Invert ;and clear it
call Delay1Sec
goto Main ;endless loop

Tutorial 13.1

This tutorial flashes an inverting 'square' at 1 second intervals. To display a pattern, we simply write it to the eight data registers, zero is the bottom line, and seven is the top. To invert the display we simple XOR the display registers with 0xFF.

Tutorial 13.2

Where the previous tutorial used just eight display registers, this second one uses two sets of eight - one is the same as before (the actual registers which get displayed), the second is a duplicate set - labelled zero1 to seven 1. This allows a range of simple effects by changing from one to the other, and this tutorial gives routines for scrolling in all four directions, and displaying numeric digits. The code presented scrolls the digits 0 to 9 from left to right, right to left, bottom to top, and top to bottom, on the display. It's pretty obvious how the other routines can be used, just load the second set of registers, and call them as you wish. Here's a 20 second video clip of the scrolling in action LED1.WMV

Tutorial 13.3

Following on from the previous tutorial, this one adds the rest of the ASCII character set, including upper and lower case letters. The fonts used is based on the Hitachi text LCD character set - but as I've an extra line I've added true descenders on those characters which have them. Rather then the previous simple method of storing the character maps, this tutorial stores them in a large table - as the table exceeds the normal 256 byte table limit, we use an extended 16 bit table to provide sufficient room for all the data, this also overcomes the 256 byte boundary problem. The tutorial itself simply scrolls the entire character set (starting with a space) from left to right.

Tutorial 13.4

This is tutorial 13.3 with an extra table added, which is used to store a string to be displayed - the string scrolls across the display from right to left, the string can easily be changed, and as before is stored as a large table - you just need to add a 0x00 at the end to signify the end of the string.