Scrolling text in LED dotmatrix display

Introduction:
Multiplexed displays are electronic displays where the entire display is not driven at one time. Instead, sub-units of the display (typically, rows or columns for a dot matrix display or individual characters for a character orientated display, occasionally individual display elements) are multiplexed, that is, driven one at a time, but the electronics and the persistence of vision combine to make the viewer believe the entire display is continuously active.

10x8 LED dot matrix display:
   Below figure illustrates the construction of a 10x8 LED dot matrix display.

 Working:

In the above figure, the rows are negative and columns are positive. Now, if I connect a single column to positive 3V and a single row to negative (0v), then the LED in place of the intersection of the corresponding row and column will glow. Now , if we select a single column(means a + volt at selected column) , say column 1 and multiple rows (means connect 0V to few selected rows), say row 1,2 & 8, then the selected 1,2 and 8 LEDs in column 1 will glow. Now if i shift the column(means shifting the positive voltage from column 1 to column 2), and if i change the row data ,then the new data will be displayed in column 2.

    Now, if i continuously shift the column and provide row data corresponding to each column, then i can display the different row data (8 bit) in different columns...

  . So, if one frame(10 column shift) is completed within 1/16 th of a second, then due to the persistence of vision of our eye, we will feel the entire columns are activated at a time, and thus we will see all the ten -8bit data corresponding to the 10 columns , at a time.........

    Now, if a set of 8bit data (say 5x8 ) represents a letter, say , 'F' then we will see letter 'F' in the display.

SCROLLING TEXT IN 10x8 LED DOT MATRIX DISPLAY

DOWNLOAD COMPLETE SOURCE CODE + CIRCUIT DIAGRAM + HEX CODE (all in a ZIP  archive) FROM BELOW:










Circuit  explanation:

   In the above circuit, the PIC16F877A provides the 8 bit row data. CD4017 is used to select the column one by one. Now, for shifting the column position, a clock is provided by the PIC to the CD4017. On every clock, the column is shifted .(from right to left in this case).

  Note:

    Here, I used a PIC16F877A microcontroller and a CD4017 johnson counter. But the 40 pin PIC16F877A is having more number of PORT pins, and thus there is no need of the CD4017 for this small display, and i could use some other port pins of the PIC to work as a johnson counter. But any way, i used a CD4017 just because, in the same circuit board, i could use other free PORT pins for some other purpose like LCD interfacing, USRT, SPI, PWM etc later...

    
Programming:

I am using Hi-Tech C compiler with MPLAB IDE for compiling the embedded C program and thereby generating the hex file which is to be loaded/burned to the PIC. There are many other C compilers, but i started with Hi-Tech C and I like it. So I am continuing with it....

Before doing a scrolling text,what i did is a still letter display.

Program to display a still letter 'F' in the display (example)

/* To display a still letter 'F' in the display */
#include<pic.h>
#define _XTAL_FREQ 20e6
__CONFIG(0x3F3A);
unsigned char i;
void clock()
{
    RB6=1;
    RB6=0;
}
void reset()
{
    RB7=1;
    RB7=0;
}
void display(unsigned char c)
{
    PORTD=c;          /* to display 1/5th of letter                                              */
    __delay_ms(1);    /* to display the data in a column for 1ms                        */
    PORTD=255;      /* to blank the display                                                     */
    clock();                /* to give a clock to CD4017 for column multiplexing      */
}
void pic_init()
{
    TRISD=0;
    TRISB6=0;
    TRISB7=0;
}
/* MAIN FUNCTION */
void main()
{
    __delay_ms(100);
    pic_init();                /* to set out ports                                            */
    while(1)
    {
        reset();               /* to jump to first column from right              */
        display(0x7f);    /* 1/5 portion of letter F                                 */
        display(0x6f);    /* 1/5 portion of letter F                                 */
        display(0x6f);    /* 1/5 portion of letter F                                 */
        display(0x6f);    /* 1/5 portion of letter F                                  */
        display(0x01);   /* 1/5 portion of letter F                                  */
        reset();               /* to jump to first column from right               */
    }
}
/*program end */

The above photo shows the letter 'F' in my 10x8 LED dotmatrix display . 

       In the photo we can observe that the first 1/5 th of the letter is less brighter than the other 4 columns. Now, the last column is the brightest column compared to other 4. This happens due to the unequal loading in different columns. In first 1/5 th of the letter requires more number of LEDs to be active. This result in increased current. If the current increases, the voltage drop inside the CD4017 and PIC  increases and thus the voltage across LED will be reduced which results in the unequal brightness. I can rectify this problem by some hardware modifications. But any way, i feel better choice is software modification. This problem is solved in scrolling text program, by including a scanning with in the column. So, at an instant, only a single LED will be active with in a column. This could be compared to the horizontal scanning in a TV.(even though here it is vertical).

Scrolling text in this 10x8 LED dot matrix display:

In the case of scrolling display we need to create a buffer of 10 bytes and need to store the data to be displayed in a frame. Then after displaying a frame, we need to shift the data with in the array as shown below.

for(i=9;i>0;i--)
{
    array[i]=array[i-1];
} 

The above code shift the data in the array which is to be displayed as next shifted frame. Now, array[0] (the data to be displayed in first column from the right) is loaded with new data, which will be a fraction (1/5) of a 5x8 font. Now the new frame array is displayed for a particular interval of time (depending on the variable speed and delays used in the program). 
   Brightness is equalized by activating the column LEDs one by one , using a scanning with in the column.

for(j=0;j<9;j++)
{
    PORTD=~(array[i]&(p));__delay_ms(.1);p<<=1;
}

PROGRAM

/* Scrolling text in 10x8 LED dot matrix display */
#include<pic.h>
#define _XTAL_FREQ 20e6
__CONFIG(0x3F3A);
char array[10],p,j,s,i,still;
void clock(){ RB6=1;RB6=0;}
void reset(){ RB7=1;RB7=0;}
void scroll(char a,char b,char c,char d,char e)            //display function //
{
    short int count=6;
    while(count>0)
    {
        array[0]=~a;
        a=b;b=c;c=d;d=e;e=255;
        reset();
        for(s=0;s<still;s++)
        {
            for(i=0;i<10;i++)
            {
                p=1;
                for(j=0;j<9;j++)
                {
                    PORTD=~(array[i]&(p));__delay_ms(.1);p<<=1;
                }
                clock();
            }
        }
        for(i=9;i>0;i--)
        {
            array[i]=array[i-1];
        }
        count--;
    }
}
////////////////////////FONT DATA////////////////////////
void A(){scroll(0xC1,  0xB7,   0x77,   0xB7,   0xC1);}   //letter A
void B(){scroll(0x01,  0x6D,   0x6D,   0x6D,   0x93);}   //letter B
void C(){scroll(0x83,  0x7D,   0x7D,   0x7D,   0xBB);}  //  "
void D(){scroll(0x01,  0x7D,   0x7D,   0xBB,   0xC7);}
void E(){scroll(0x01,  0x6D,   0x6D,   0x6D,   0x7D);}
void F(){scroll(0x01,  0x6F,   0x6F,   0x6F,   0x7F);}
void G(){scroll(0x83,  0x7D,   0x65,   0x6D,   0xA3);}
void H(){scroll(0x01,  0xEF,   0xEF,   0xEF,   0x01);}
void I(){scroll(0x7D,  0x7D,   0x1,   0x7D,   0x7D);}
void J(){scroll(0xF3,  0x7D,   0x7D,   0x03,   0x7F);}
void K(){scroll(0x01,  0xEF,   0xD7,   0xBB,   0x7D);}
void L(){scroll(0x01,  0xFD,   0xFD,   0xFD,   0xFD);}
void M(){scroll(0x01,  0xBF,   0xDF,   0xBF,   0x01);}
void N(){scroll(0x01,  0xBF,   0xDF,   0xEF,   0x01);}
void O(){scroll(0x83,  0x7D,   0x7D,   0x7D,   0x83);}
void P(){scroll(0x01,  0x6F,   0x6F,   0x6F,   0x9F);}
void Q(){scroll(0x83,  0x7D,   0x75,   0x79,   0x81);}
void R(){scroll(0x01,  0x6F,   0x6F,   0x6F,   0x91);}
void S(){scroll(0x9B,  0x6D,   0x6D,   0x6D,   0xB3);}
void T(){scroll(0x7F,  0x7F,   0x01,   0x7F,   0x7F);}
void U(){scroll(0x03,  0xFD,   0xFD,   0xFD,   0x03);}
void V(){scroll(0x07,  0xFB,   0xFD,   0xFB,   0x07);}
void W(){scroll(0x01,  0xFB,   0xF7,   0xFB,   0x01);}
void X(){scroll(0x39,  0xD7,   0xEF,   0xD7,   0x39);}
void Y(){scroll(0x3F,  0xDF,   0xE1,   0xDF,   0x3F);}
void Z(){scroll(0x79,  0x75,   0x6D,   0x5D,   0x3D);}    //letter Z
void D0(){scroll(0x83,  0x7D,   0x7D,   0x7D,   0x83);}  //NUM 0
void D1(){scroll(0xDD,  0xBD,   0x1,   0xFD,   0xFD);}
void D2(){scroll(0xBD,  0x79,   0x75,   0x6D,   0x9D);}
void D3(){scroll(0x7B,  0x7D,   0x5D,   0x4D,   0x33);}
void D4(){scroll(0xCF,  0xAF,   0x6F,   0xEF,   0x1);}
void D5(){scroll(0xB,  0x5D,   0x5D,   0x5D,   0x63);}
void D6(){scroll(0x83,  0x6D,   0x6D,   0x6D,   0xB3);}
void D7(){scroll(0x79,  0x77,   0x6F,   0x5F,   0x3F);}
void D8(){scroll(0x93,  0x6D,   0x6D,   0x6D,   0x93);}
void D9(){scroll(0x9B,  0x6D,   0x6D,   0x6D,   0x83);}  //NUM 9
void SP(){scroll(255,255,255,255,255);}               //SPACE
/////////////////////////////////////////
void main()
{
    TRISD=0;
    TRISB6=0;
    TRISB7=0;
    still=20; //SPEED CONTROL
    while(1)
    {
        A(); B(); C(); D(); E(); F(); G(); H(); I(); J();
        K(); L(); M(); N(); O(); P(); SP(); SP();
        /* etc etc etc  */
    }
}
//PROGRAM END//

In the above code, we can see that each font is a function. But that is not a good way. Better method is a look up table implementation for the font data so that they could be easily fetched without any if else condition and this decrease the access time and increase the efficiency..

////////////////////////////////////////////////////////////////////
/* Scrolling text in 10x8 LED dot matrix display                  */
/* Improved code compared to previous one                         */
/*Implemented a look up table for font to increase the access time*/
/*vinodstanur@gmail.com http://blog.vinu.co.in                    */
////////////////////////////////////////////////////////////////////
#include<pic.h>
#define _XTAL_FREQ 20e6
__CONFIG(0x3F3A);
char array[10],p,j,s,i,still;
extern const char font_5x7[95][5];
void clock(){ RB6=1;RB6=0;}
void reset(){ RB7=1;RB7=0;}
void scroll(char a,char b,char c,char d,char e)            //display function //
{
    short int count=6;
    while(count>0)
    {
        array[0]=a;
        a=b;b=c;c=d;d=e;e=0;
        reset();
        for(s=0;s<still;s++)
        {
            for(i=0;i<10;i++)
            {
                p=1;
                for(j=0;j<9;j++)
                {
                    PORTD=~(array[i]&(p));__delay_ms(.1);p<<=1;
                }
                clock();
            }
        }
        for(i=9;i>0;i--)
        {
            array[i]=array[i-1];
        }
        count--;
    }
}

void printf(const char *p)
{
    while(*p) {
        scroll(font_5x7[*p-' '][0],font_5x7[*p-' '][1],font_5x7[*p-' '][2],font_5x7[*p-' '][3],font_5x7[*p-' '][4]);
        p++;
    }
}
//SPACE
/////////////////////////////////////////
void main()
{
    TRISD=0;
    TRISB6=0;
    TRISB7=0;
    still=20; //SPEED CONTROL
    while(1)
    {
        printf("HELLO WORLD ");
        printf("I am testing font..*!~_+=-/\\,.7895WMvuy....");
        
    }
}

//look up table for font//
const char font_5x7[95][5] = {
    {0x00,0x00,0x00,0x00,0x00}, //
    {0x00,0x00,0x7a,0x00,0x00}, // !
    {0x00,0x70,0x00,0x70,0x00}, // "
    {0x14,0x3e,0x14,0x3e,0x14}, // #
    {0x10,0x2a,0x3e,0x2a,0x04}, // $
    {0x64,0x08,0x10,0x26,0x00}, // %
    {0x14,0x2a,0x14,0x02,0x00}, // &
    {0x00,0x00,0x70,0x00,0x00}, // '
    {0x00,0x3c,0x42,0x00,0x00}, // (
    {0x00,0x42,0x3c,0x00,0x00}, // )
    {0x00,0x2a,0x1c,0x2a,0x00}, // *
    {0x08,0x08,0x3e,0x08,0x08}, // +
    {0x00,0x01,0x06,0x04,0x00}, // ,
    {0x08,0x08,0x08,0x08,0x00}, // -
    {0x00,0x06,0x06,0x00,0x00}, // .
    {0x04,0x08,0x10,0x20,0x00}, // /
    {0x00,0x3c,0x42,0x3c,0x00}, // 0
    {0x00,0x22,0x7e,0x02,0x00}, // 1
    {0x22,0x46,0x4a,0x32,0x00}, // 2
    {0x44,0x52,0x52,0x6c,0x00}, // 3
    {0x18,0x28,0x7e,0x08,0x00}, // 4
    {0x74,0x52,0x52,0x4c,0x00}, // 5
    {0x3c,0x52,0x52,0x0c,0x00}, // 6
    {0x40,0x46,0x58,0x60,0x00}, // 7
    {0x2c,0x52,0x52,0x2c,0x00}, // 8
    {0x30,0x4a,0x4a,0x3c,0x00}, // 9
    {0x00,0x36,0x36,0x00,0x00}, // :
    {0x01,0x36,0x34,0x00,0x00}, // ;
    {0x00,0x08,0x14,0x22,0x00}, // <
    {0x14,0x14,0x14,0x14,0x00}, // =
    {0x00,0x22,0x14,0x08,0x00}, // >
    {0x00,0x20,0x4a,0x30,0x00}, // ?
    {0x3c,0x42,0x5a,0x38,0x00}, // @
    {0x3e,0x48,0x48,0x3e,0x00}, // A
    {0x7e,0x52,0x52,0x2c,0x00}, // B
    {0x3c,0x42,0x42,0x24,0x00}, // C
    {0x7e,0x42,0x42,0x3c,0x00}, // D
    {0x7e,0x52,0x52,0x42,0x00}, // E
    {0x7e,0x50,0x50,0x40,0x00}, // F
    {0x3c,0x42,0x4a,0x2e,0x00}, // G
    {0x7e,0x10,0x10,0x7e,0x00}, // H
    {0x00,0x42,0x7e,0x42,0x00}, // I
    {0x04,0x02,0x02,0x7c,0x00}, // J
    {0x7e,0x18,0x24,0x42,0x00}, // K
    {0x7e,0x02,0x02,0x02,0x00}, // L
    {0x7e,0x30,0x30,0x7e,0x00}, // M
    {0x7e,0x30,0x0c,0x7e,0x00}, // N
    {0x3c,0x42,0x42,0x3c,0x00}, // O
    {0x7e,0x48,0x48,0x30,0x00}, // P
    {0x3c,0x46,0x42,0x3d,0x00}, // Q
    {0x7e,0x48,0x4c,0x32,0x00}, // R
    {0x24,0x52,0x4a,0x24,0x00}, // S
    {0x00,0x40,0x7e,0x40,0x00}, // T
    {0x7c,0x02,0x02,0x7c,0x00}, // U
    {0x78,0x06,0x06,0x78,0x00}, // V
    {0x7e,0x0c,0x0c,0x7e,0x00}, // W
    {0x66,0x18,0x18,0x66,0x00}, // X
    {0x00,0x70,0x0e,0x70,0x00}, // Y
    {0x46,0x4a,0x52,0x62,0x00}, // Z
    {0x00,0x7e,0x42,0x42,0x00}, // [
    {0x20,0x10,0x08,0x04,0x00}, // "\"
    {0x00,0x42,0x42,0x7e,0x00}, // ]
    {0x00,0x20,0x40,0x20,0x00}, // ^
    {0x02,0x02,0x02,0x02,0x00}, // _
    {0x00,0x40,0x20,0x00,0x00}, // `
    {0x0c,0x12,0x14,0x1e,0x00}, // a
    {0x7e,0x12,0x12,0x0c,0x00}, // b
    {0x0c,0x12,0x12,0x00,0x00}, // c
    {0x0c,0x12,0x12,0x7e,0x00}, // d
    {0x0c,0x16,0x1a,0x08,0x00}, // e
    {0x08,0x3e,0x48,0x20,0x00}, // f
    {0x0a,0x15,0x15,0x19,0x00}, // g
    {0x7e,0x10,0x10,0x0e,0x00}, // h
    {0x00,0x12,0x5e,0x02,0x00}, // i
    {0x00,0x02,0x01,0x5e,0x00}, // j
    {0x7e,0x08,0x14,0x02,0x00}, // k
    {0x00,0x42,0x7e,0x02,0x00}, // l
    {0x1e,0x08,0x18,0x0e,0x00}, // m
    {0x1e,0x10,0x10,0x0e,0x00}, // n
    {0x0c,0x12,0x12,0x0c,0x00}, // o
    {0x1f,0x12,0x12,0x0c,0x00}, // p
    {0x0c,0x12,0x12,0x1f,0x00}, // q
    {0x1e,0x10,0x10,0x08,0x00}, // r
    {0x0a,0x1a,0x16,0x14,0x00}, // s
    {0x10,0x7c,0x12,0x02,0x00}, // t
    {0x1c,0x02,0x02,0x1e,0x00}, // u
    {0x00,0x1c,0x02,0x1c,0x00}, // v
    {0x1e,0x06,0x06,0x1e,0x00}, // w
    {0x12,0x0c,0x0c,0x12,0x00}, // x
    {0x18,0x05,0x02,0x1c,0x00}, // y
    {0x12,0x16,0x1a,0x12,0x00}, // z
{0x00,0x10,0x3c,0x42,0x00}, // {
        {0x00,0x00,0x7e,0x00,0x00}, // |
{0x00,0x42,0x3c,0x10,0x00}, // }
    {0x20,0x40,0x20,0x40,0x00}, // ~
};

VIDEO OF SCROLLING TEXT (taken through my mobile)