• Welcome to our site! Electro Tech is an online community (with over 170,000 members) who enjoy talking about and building electronic circuits, projects and gadgets. To participate you need to register. Registration is free. Click here to register now.

LED Sign board

Status
Not open for further replies.

AtomSoft

Well-Known Member
Hey guys i need some help. Im trying to wrap my head around scrolling text on some LED matrixs.

Im using my LPC2148 for this but it shouldnt matter much. I can convert PIC code to it without any issues.

I have code in place to show characters on a single matrix but how would i scroll the text across the matrix?

I commented the code below for the character display i have in place but i can write strings also but it will just show the character for some time then show the next, then the next without scrolling feature.

How can i implement it?

Code:
void LEDChar(unsigned char letter,unsigned char style){
    unsigned int myData;                                  //Data Holder
    char x;                                               //loop holder
    letter -= 0x20;                                       //Deduct 0x20 from original char for array

    SETBIT(DEC,Dec_Rst);                                  //Clear the 4017 Johnson Counter
    CLRBIT(DEC,Dec_Rst);                                  //Start It

    for(x=0;x<5;x++){                                     //Loop 5 times (column)
        CLRBIT(DEC,Dec_Clk);                              //4017 Clock Low
        SETBIT(DEC,Dec_Clk);                              //4017 Clock High

        myData = 0;                                       //Clear data
        myData = (Font5x7[((letter*5) + x)] | style) ;    //Get Font Data
        myData <<= LEDS;                                  //Shift over for output to pins p1.25:p1.19
	LEDP = (LEDP & ~(0x7F<<LEDS)) | ~myData;          //Clear old pin data and place new data 
        DelayUs(1);                                       //Delay 1 us before updating new row
    }
}
 

Pommie

Well-Known Member
Most Helpful Member
A quick guess,

myData = (Font5x7[((letter*5) + ((x+offset)%6))] | style) ;

Where offset varies from 0 to 5.

Mike.
 

Nigel Goodwin

Super Moderator
Most Helpful Member
Can't help you on that processor, or in C, but my PIC tutorials show how to do scrolling in all four directions using assembler - it should be easy to see how it works, and duplicate in C.
 

3v0

Coop Build Coordinator
Forum Supporter
If this is not helpful ignore it.

Generate the image you want to display in a display sized buffer.

To scroll add an offset to the pixel address when you copy the data from the buffer to the display.

To scroll text over a fixed display OR the fixed display with the scrolled data.
 
Last edited:

AtomSoft

Well-Known Member
Thanks to all....

Pommie & 3v0:
You are so close there. I have to add 3v0 info into this. I made a buffer. about 20 chars wide (20 * 5 = 100) 100 bytes is my buffer. Now what im doing is getting the font data into this buffer instead of my char data because i tried it your way and im trying to display "Jason". I get the J but then some of the K

so i assume i need to have correct data back to back for it to work right.

Nigel ill be sure to check it out in a minute. I might use yours and convert it. I even forgot about it. Your site is very useful its great!!

Ill be sure to post some results in about 10-25 minutes.
 

Nigel Goodwin

Super Moderator
Most Helpful Member
You may be over complicating things? - I just used two 8 byte buffers, one of which (the display buffer) is written to the LED's via the interrupt routine. The scrolling routines simply scroll the second buffer over the first, a bit at a time - in one of four directions.

The font data is stored in a large table, as is a string for displaying.
 

AtomSoft

Well-Known Member
i think nigel is correct. Its overcomplicated:

This code still doesnt work. im not sure why but heh. I will try to make something later on but as simple as possible.
Code:
void LEDChar2(unsigned char *letter,unsigned char style,char offset){
    unsigned int myData;                                  //Data Holder
    char x;                                               //loop holder
    //letter -= 0x20;                                       //Deduct 0x20 from original char for array

    SETBIT(DEC,Dec_Rst);                                  //Clear the 4017 Johnson Counter
    CLRBIT(DEC,Dec_Rst);                                  //Start It

    for(x=0;x<5;x++){                                     //Loop 5 times (column)
        CLRBIT(DEC,Dec_Clk);                              //4017 Clock Low
        SETBIT(DEC,Dec_Clk);                              //4017 Clock High

        myData = 0;                                       //Clear data

        letter += ((x+offset)%6);
        myData =  *letter| style;
        myData <<= LEDS;                                  //Shift over for output to pins p1.25:p1.19
	LEDP = (LEDP & ~(0x7F<<LEDS)) | ~myData;          //Clear old pin data and place new data 
        DelayUs(1);                                       //Delay 1 us before updating new row
    }
}

void LEDString(const char *str,unsigned char style,unsigned int delay, unsigned char *buffer){
  int x;
  unsigned char temp;
  char y,z;


  delay *= 10;
  y=0;
  for(x=0;x<100;x++)
    *buffer++ = 0;
  
  buffer -= 100;

  while(*str != 0){
    temp = *str++;
    temp -= 20;

    for(x=0;x<5;x++){
      *buffer++ = Font5x7[((temp * 5) + x)];
      y++;
    }

  }

  buffer -= y;

  while(*buffer != 0){
    for(y=0;y<5;y++){
      for(x=0;x<delay;x++){
        LEDChar2(buffer,style,y);
      }
    }
    buffer++;
  }
}
 

AtomSoft

Well-Known Member
hey guys 5 minutes went by in weeks lol here is my code so far buts its funny lol for some reason the first led column lights when it wants to and the rest shows fine. Also when the scroll is done it scrolls 3 dots at the end of text not sure why either.

Can someone help me out

Code:
#include <p18Cxxx.h>
#include <delays.h>
#pragma config WDT = OFF, LVP = OFF, OSC = INTIO67


unsigned rom char MyFont [] = {
                  0x00,0x00,0x00,0x00,0x00,  // 20 space
                  0x00,0x00,0x5f,0x00,0x00,  // 21 
                  0x00,0x07,0x00,0x07,0x00,  // 22 
                  0x14,0x7f,0x14,0x7f,0x14,  // 23 
                  0x24,0x2a,0x7f,0x2a,0x12,  // 24 
                  0x23,0x13,0x08,0x64,0x62,  // 25 
                  0x36,0x49,0x55,0x22,0x50,  // 26 
                  0x00,0x05,0x03,0x00,0x00,  // 27 
                  0x00,0x1c,0x22,0x41,0x00,  // 28 
                  0x00,0x41,0x22,0x1c,0x00,  // 29 
                  0x14,0x08,0x3e,0x08,0x14,  // 2a 
                  0x08,0x08,0x3e,0x08,0x08,  // 2b 
                  0x00,0x50,0x30,0x00,0x00,  // 2c 
                  0x08,0x08,0x08,0x08,0x08,  // 2d 
                  0x00,0x60,0x60,0x00,0x00,  // 2e 
                  0x20,0x10,0x08,0x04,0x02,  // 2f 
                  0x3e,0x51,0x49,0x45,0x3e,  // 30 0
                  0x00,0x42,0x7f,0x40,0x00,  // 31 1
                  0x42,0x61,0x51,0x49,0x46,  // 32 2
                  0x21,0x41,0x45,0x4b,0x31,  // 33 3
                  0x18,0x14,0x12,0x7f,0x10,  // 34 4
                  0x27,0x45,0x45,0x45,0x39,  // 35 5
                  0x3c,0x4a,0x49,0x49,0x30,  // 36 6
                  0x01,0x71,0x09,0x05,0x03,  // 37 7
                  0x36,0x49,0x49,0x49,0x36,  // 38 8
                  0x06,0x49,0x49,0x29,0x1e,  // 39 9
                  0x00,0x36,0x36,0x00,0x00,  // 3a 
                  0x00,0x56,0x36,0x00,0x00,  // 3b 
                  0x08,0x14,0x22,0x41,0x00,  // 3c 
                  0x14,0x14,0x14,0x14,0x14,  // 3d 
                  0x00,0x41,0x22,0x14,0x08,  // 3e 
                  0x02,0x01,0x51,0x09,0x06,  // 3f 
                  0x32,0x49,0x79,0x41,0x3e,  // 40 
                  0x7e,0x11,0x11,0x11,0x7e,  // 41 A
                  0x7f,0x49,0x49,0x49,0x36,  // 42 B
                  0x3e,0x41,0x41,0x41,0x22,  // 43 C
                  0x7f,0x41,0x41,0x22,0x1c,  // 44 D
                  0x7f,0x49,0x49,0x49,0x41,  // 45 E
                  0x7f,0x09,0x09,0x09,0x01,  // 46 F
                  0x3e,0x41,0x49,0x49,0x7a,  // 47 G
                  0x7f,0x08,0x08,0x08,0x7f,  // 48 H
                  0x00,0x41,0x7f,0x41,0x00,  // 49 I
                  0x20,0x40,0x41,0x3f,0x01,  // 4a J
                  0x7f,0x08,0x14,0x22,0x41,  // 4b K
                  0x7f,0x40,0x40,0x40,0x40,  // 4c L
                  0x7f,0x02,0x0c,0x02,0x7f,  // 4d M
                  0x7f,0x04,0x08,0x10,0x7f,  // 4e N
                  0x3e,0x41,0x41,0x41,0x3e,  // 4f O
                  0x7f,0x09,0x09,0x09,0x06,  // 50 P
                  0x3e,0x41,0x51,0x21,0x5e,  // 51 Q
                  0x7f,0x09,0x19,0x29,0x46,  // 52 R
                  0x46,0x49,0x49,0x49,0x31,  // 53 S
                  0x01,0x01,0x7f,0x01,0x01,  // 54 T
                  0x3f,0x40,0x40,0x40,0x3f,  // 55 U
                  0x1f,0x20,0x40,0x20,0x1f,  // 56 V
                  0x3f,0x40,0x38,0x40,0x3f,  // 57 W
                  0x63,0x14,0x08,0x14,0x63,  // 58 X
                  0x07,0x08,0x70,0x08,0x07,  // 59 Y
                  0x61,0x51,0x49,0x45,0x43,  // 5a Z
                  0x00,0x7f,0x41,0x41,0x00,  // 5b 
                  0x02,0x04,0x08,0x10,0x20,  // 5c 
                  0x00,0x41,0x41,0x7f,0x00,  // 5d 
                  0x04,0x02,0x01,0x02,0x04,  // 5e 
                  0x40,0x40,0x40,0x40,0x40,  // 5f 
                  0x00,0x01,0x02,0x04,0x00,  // 60 
                  0x20,0x54,0x54,0x54,0x78,  // 61 a
                  0x7f,0x48,0x44,0x44,0x38,  // 62 b
                  0x38,0x44,0x44,0x44,0x20,  // 63 c
                  0x38,0x44,0x44,0x48,0x7f,  // 64 d
                  0x38,0x54,0x54,0x54,0x18,  // 65 e
                  0x08,0x7e,0x09,0x01,0x02,  // 66 f
                  0x0c,0x52,0x52,0x52,0x3e,  // 67 g
                  0x7f,0x08,0x04,0x04,0x78,  // 68 h
                  0x00,0x44,0x7d,0x40,0x00,  // 69 i
                  0x20,0x40,0x44,0x3d,0x00,  // 6a j
                  0x7f,0x10,0x28,0x44,0x00,  // 6b k
                  0x00,0x41,0x7f,0x40,0x00,  // 6c l
                  0x7c,0x04,0x18,0x04,0x78,  // 6d m
                  0x7c,0x08,0x04,0x04,0x78,  // 6e n
                  0x38,0x44,0x44,0x44,0x38,  // 6f o
                  0x7c,0x14,0x14,0x14,0x08,  // 70 p
                  0x08,0x14,0x14,0x18,0x7c,  // 71 q
                  0x7c,0x08,0x04,0x04,0x08,  // 72 r
                  0x48,0x54,0x54,0x54,0x20,  // 73 s
                  0x04,0x3f,0x44,0x40,0x20,  // 74 t
                  0x3c,0x40,0x40,0x20,0x7c,  // 75 u
                  0x1c,0x20,0x40,0x20,0x1c,  // 76 v
                  0x3c,0x40,0x30,0x40,0x3c,  // 77 w
                  0x44,0x28,0x10,0x28,0x44,  // 78 x
                  0x0c,0x50,0x50,0x50,0x3c,  // 79 y
                  0x44,0x64,0x54,0x4c,0x44,  // 7a z
                  0x00,0x08,0x36,0x41,0x00,  // 7b 
                  0x00,0x00,0x7f,0x00,0x00,  // 7c 
                  0x00,0x41,0x36,0x08,0x00,  // 7d 
                  0x10,0x08,0x08,0x10,0x08,  // 7e 
                  0x78,0x46,0x41,0x46,0x78}; // 7f 

#define LED  LATB
#define JCC  LATAbits.LATA0
#define JCR0 LATAbits.LATA1
#define ROWS 10
#define ROWS2 5
#define SPEED 25
volatile unsigned char buff[255];

void delayMS(char delay){
    for(;delay>0;delay--)
        Delay1KTCYx(2);
}

void ClockJC(void){
        JCC = 1;
        Delay10TCYx(254);
        JCC = 0;
}
void SendChar(unsigned char text){
int x,y,z;

    JCR0 = 0;

    for(x=0;x<5;x++){
        LED = MyFont[(((text-0x20) * 5)+x)];
        ClockJC();
    }

    JCR0 = 1;
}
void SendStr(unsigned rom char *text){
unsigned char x,y,z,i,q;
unsigned char count;
unsigned char spaces;
unsigned int tmp;

spaces = ROWS;
//Clear Buffer
for(x=0;x<255;x++)
    buff[x] = 0;
//Fill buffer
count = 0;
    for(x=0;x<spaces;x++){
       count++;
    }
    while(*text){
        for(x=0;x<5;x++){
            tmp = *text - 0x20;
            buff[count++] = MyFont[(tmp* 5)+x];
        }
        count++;
        text++;

    }
    buff[count++] = 0xFF;
    x=0;
    i=0;
    count = 0;

//SHOW IT
    while(!count){
        for(z=0;z<SPEED;z++){
            JCR0 = 0;
            for(y=0;y<ROWS;y++){
                if(buff[(i+(5-y))] == 0xFF){
                    count = 1;
                    break;
                } else {
                    LED = buff[(i+(5-y))];
                    ClockJC();
                }
            }
            JCR0 = 1;    
        }
        i++;
    }

}

void main(void){
int k,j,i;
    OSCCON = 0x72;              //8MHz clock
    while(!OSCCONbits.IOFS);    //Wait for OSC to become stable

    ADCON1 = 0x0F;
    TRISB = 0x00;
    TRISA = 0x00;

	while(1){
        SendStr((unsigned rom char*)"AtomSoftTech.info");
	}

}
 

AtomSoft

Well-Known Member
working nicer now ill put a vid in a lil

Code:
#include <p18Cxxx.h>
#include <delays.h>
#pragma config WDT = OFF, LVP = OFF, OSC = INTIO67


unsigned rom char MyFont [] = {
                  0x00,0x00,0x00,0x00,0x00,  // 20 space
                  0x00,0x00,0x5f,0x00,0x00,  // 21 
                  0x00,0x07,0x00,0x07,0x00,  // 22 
                  0x14,0x7f,0x14,0x7f,0x14,  // 23 
                  0x24,0x2a,0x7f,0x2a,0x12,  // 24 
                  0x23,0x13,0x08,0x64,0x62,  // 25 
                  0x36,0x49,0x55,0x22,0x50,  // 26 
                  0x00,0x05,0x03,0x00,0x00,  // 27 
                  0x00,0x1c,0x22,0x41,0x00,  // 28 
                  0x00,0x41,0x22,0x1c,0x00,  // 29 
                  0x14,0x08,0x3e,0x08,0x14,  // 2a 
                  0x08,0x08,0x3e,0x08,0x08,  // 2b 
                  0x00,0x50,0x30,0x00,0x00,  // 2c 
                  0x08,0x08,0x08,0x08,0x08,  // 2d 
                  0x00,0x60,0x60,0x00,0x00,  // 2e 
                  0x20,0x10,0x08,0x04,0x02,  // 2f 
                  0x3e,0x51,0x49,0x45,0x3e,  // 30 0
                  0x00,0x42,0x7f,0x40,0x00,  // 31 1
                  0x42,0x61,0x51,0x49,0x46,  // 32 2
                  0x21,0x41,0x45,0x4b,0x31,  // 33 3
                  0x18,0x14,0x12,0x7f,0x10,  // 34 4
                  0x27,0x45,0x45,0x45,0x39,  // 35 5
                  0x3c,0x4a,0x49,0x49,0x30,  // 36 6
                  0x01,0x71,0x09,0x05,0x03,  // 37 7
                  0x36,0x49,0x49,0x49,0x36,  // 38 8
                  0x06,0x49,0x49,0x29,0x1e,  // 39 9
                  0x00,0x36,0x36,0x00,0x00,  // 3a 
                  0x00,0x56,0x36,0x00,0x00,  // 3b 
                  0x08,0x14,0x22,0x41,0x00,  // 3c 
                  0x14,0x14,0x14,0x14,0x14,  // 3d 
                  0x00,0x41,0x22,0x14,0x08,  // 3e 
                  0x02,0x01,0x51,0x09,0x06,  // 3f 
                  0x32,0x49,0x79,0x41,0x3e,  // 40 
                  0x7e,0x11,0x11,0x11,0x7e,  // 41 A
                  0x7f,0x49,0x49,0x49,0x36,  // 42 B
                  0x3e,0x41,0x41,0x41,0x22,  // 43 C
                  0x7f,0x41,0x41,0x22,0x1c,  // 44 D
                  0x7f,0x49,0x49,0x49,0x41,  // 45 E
                  0x7f,0x09,0x09,0x09,0x01,  // 46 F
                  0x3e,0x41,0x49,0x49,0x7a,  // 47 G
                  0x7f,0x08,0x08,0x08,0x7f,  // 48 H
                  0x00,0x41,0x7f,0x41,0x00,  // 49 I
                  0x20,0x40,0x41,0x3f,0x01,  // 4a J
                  0x7f,0x08,0x14,0x22,0x41,  // 4b K
                  0x7f,0x40,0x40,0x40,0x40,  // 4c L
                  0x7f,0x02,0x0c,0x02,0x7f,  // 4d M
                  0x7f,0x04,0x08,0x10,0x7f,  // 4e N
                  0x3e,0x41,0x41,0x41,0x3e,  // 4f O
                  0x7f,0x09,0x09,0x09,0x06,  // 50 P
                  0x3e,0x41,0x51,0x21,0x5e,  // 51 Q
                  0x7f,0x09,0x19,0x29,0x46,  // 52 R
                  0x46,0x49,0x49,0x49,0x31,  // 53 S
                  0x01,0x01,0x7f,0x01,0x01,  // 54 T
                  0x3f,0x40,0x40,0x40,0x3f,  // 55 U
                  0x1f,0x20,0x40,0x20,0x1f,  // 56 V
                  0x3f,0x40,0x38,0x40,0x3f,  // 57 W
                  0x63,0x14,0x08,0x14,0x63,  // 58 X
                  0x07,0x08,0x70,0x08,0x07,  // 59 Y
                  0x61,0x51,0x49,0x45,0x43,  // 5a Z
                  0x00,0x7f,0x41,0x41,0x00,  // 5b 
                  0x02,0x04,0x08,0x10,0x20,  // 5c 
                  0x00,0x41,0x41,0x7f,0x00,  // 5d 
                  0x04,0x02,0x01,0x02,0x04,  // 5e 
                  0x40,0x40,0x40,0x40,0x40,  // 5f 
                  0x00,0x01,0x02,0x04,0x00,  // 60 
                  0x20,0x54,0x54,0x54,0x78,  // 61 a
                  0x7f,0x48,0x44,0x44,0x38,  // 62 b
                  0x38,0x44,0x44,0x44,0x20,  // 63 c
                  0x38,0x44,0x44,0x48,0x7f,  // 64 d
                  0x38,0x54,0x54,0x54,0x18,  // 65 e
                  0x08,0x7e,0x09,0x01,0x02,  // 66 f
                  0x0c,0x52,0x52,0x52,0x3e,  // 67 g
                  0x7f,0x08,0x04,0x04,0x78,  // 68 h
                  0x00,0x44,0x7d,0x40,0x00,  // 69 i
                  0x20,0x40,0x44,0x3d,0x00,  // 6a j
                  0x7f,0x10,0x28,0x44,0x00,  // 6b k
                  0x00,0x41,0x7f,0x40,0x00,  // 6c l
                  0x7c,0x04,0x18,0x04,0x78,  // 6d m
                  0x7c,0x08,0x04,0x04,0x78,  // 6e n
                  0x38,0x44,0x44,0x44,0x38,  // 6f o
                  0x7c,0x14,0x14,0x14,0x08,  // 70 p
                  0x08,0x14,0x14,0x18,0x7c,  // 71 q
                  0x7c,0x08,0x04,0x04,0x08,  // 72 r
                  0x48,0x54,0x54,0x54,0x20,  // 73 s
                  0x04,0x3f,0x44,0x40,0x20,  // 74 t
                  0x3c,0x40,0x40,0x20,0x7c,  // 75 u
                  0x1c,0x20,0x40,0x20,0x1c,  // 76 v
                  0x3c,0x40,0x30,0x40,0x3c,  // 77 w
                  0x44,0x28,0x10,0x28,0x44,  // 78 x
                  0x0c,0x50,0x50,0x50,0x3c,  // 79 y
                  0x44,0x64,0x54,0x4c,0x44,  // 7a z
                  0x00,0x08,0x36,0x41,0x00,  // 7b 
                  0x00,0x00,0x7f,0x00,0x00,  // 7c 
                  0x00,0x41,0x36,0x08,0x00,  // 7d 
                  0x10,0x08,0x08,0x10,0x08,  // 7e 
                  0x78,0x46,0x41,0x46,0x78}; // 7f 

#define LED  LATB
#define JCC  LATAbits.LATA0
#define JCR0 LATAbits.LATA1
#define JCR1 LATAbits.LATA2
#define ROWS 15
#define SPEED 5
volatile unsigned char buff[255];

void delayMS(char delay){
    for(;delay>0;delay--)
        Delay1KTCYx(2);
}

void ClockJC(void){
        JCC = 1;
        Delay10TCYx(200);
        JCC = 0;
}
void SendChar(unsigned char text){
int x,y,z;

    JCR0 = 0;

    for(x=0;x<5;x++){
        LED = MyFont[(((text-0x20) * 5)+x)];
        ClockJC();
    }

    JCR0 = 1;
}
void SendStr(unsigned rom char *text){
volatile unsigned char x,y,z,i,q;
unsigned char count;
unsigned char spaces;
unsigned int tmp;

spaces = ROWS;
//Clear Buffer
for(x=0;x<255;x++)
    buff[x] = 0;
//Fill buffer
    count = ROWS / 2;
    while(*text){
        for(x=0;x<5;x++){
            tmp = *text - 0x20;
            buff[count++] = MyFont[(tmp* 5)+x];
        }
        count++;
        text++;

    }
    count += ROWS;
    count--;
    buff[count] = 0xFF;
    x=0;
    i=0;
    count = 0;

//SHOW IT
    while(!count){
        for(z=0;z<SPEED;z++){
            for(y=0;y<ROWS;y++){
            if(y<10) {
                JCR0 = 0; //on
                JCR1 = 1; //off
            } else {
                JCR0 = 1; //off
                JCR1 = 0; //on
                if(y==10) ClockJC();
            }
                if(buff[(i+(5-y))] == 0xFF){
                    count = 1;
                    break;
                } else {
                    LED = buff[(i+(5-y))];
                    ClockJC();
                }
            }
            JCR0 = 1;   //off
            JCR1 = 1;   //off

            if(count) break;
        }
        i++;

        if(count) break;
    }

}

void main(void){
int k,j,i;
    OSCCON = 0x72;              //8MHz clock
    while(!OSCCONbits.IOFS);    //Wait for OSC to become stable

    ADCON1 = 0x0F;
    TRISB = 0x00;
    TRISA = 0x00;

    JCR0 = 1;
    JCR1 = 1; 

	while(1){
        SendStr((unsigned rom char*)"AtomSoftTech.info");
	}

}
 

AtomSoft

Well-Known Member
heh yeah i complained to myself about it too :D

I cant wire under it tho. And didnt want to make a board until i can figure how to correctly wire it. Now that i know the trick (skip pin 0 and add a clock pulse for it) i can effectively make a schematic and PCB and POOF!!! no more wire mess lol

P.S. I dont have enough wire to have it neatly wrap around and wire is too thick to go under.
 

AtomSoft

Well-Known Member
Here is my schematic. You can see why its messy... also i dont use pin 0 on either remember i add a clk in.

I dont use pin0 becuase its always on even if the reset is off. I control reset this way i can set it back to zero ASAP.

I will be using this 3 part as 1 board. Each board i do will have 3 matrixs. (I cant make a large board lol)

At the end of 17 Clocks..the first 4017 has 10 and the second has 7... i will add 3 repeated clocks to fill the 20... hence when i add another board it will skip those 3 from my first board and continue to the next one using the reset control

Each board will have a input and output header on the top or bottom so i can cascade them.

I will make a bootload for all of this and a VB program so i can select how many boards i have and update the program to respond to those newer board. Or maybe just have a 7 dip switch and a parallel in serial out type IC to send the info on how many boards i have plugged.

The max amount would be controlled by the POWER needed i guess. Since i use transistors (will be changing to Transistor array) i am not sinking or sourcing a lot of current from micro so i dont have to worry about it getting damaged.

so a 0000-0011 on the dip would show that i have 2 boards since i wont be using binary since its a hassle for a normal person to use. This would make it possible to have a max of 8 (3 matrix) boards aka 24 matrix led

24x5x7 = 840 leds and since there is about 7 leds on at 1 time it should not use too much current. I would just have to ajust the speed. And put this whole thing on a 20mhz crystal to ensure i can do that POV (mulltiplex) it well!

Anyway here is the schematic of trial 1 --- PASS!
 

Attachments

Status
Not open for further replies.

EE World Online Articles

Loading
Top