CCS C Software and Maintenance Offers
FAQFAQ   FAQForum Help   FAQOfficial CCS Support   SearchSearch  RegisterRegister 

ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

CCS does not monitor this forum on a regular basis.

Please do not post bug Reports on this forum. Send them to support@ccsinfo.com

Complete 5X7 ASCII Table for a scrooling LED Matrix display

 
Post new topic   Reply to topic    CCS Forum Index -> General CCS C Discussion
View previous topic :: View next topic  
Author Message
hillcraft



Joined: 22 Sep 2003
Posts: 101
Location: Cape Town (South africa)

View user's profile Send private message Send e-mail Visit poster's website

Complete 5X7 ASCII Table for a scrooling LED Matrix display
PostPosted: Sat Mar 13, 2004 3:00 pm     Reply with quote

Hi,

I need a full 5X7 ASCII table for a scrolling LED Matrix display.

Does anybody know where I can download a table in a similar format to the following one (Preferably C based):

1065 DATA 0,63,68,68,68,63 :REM A
1066 DATA 0,127,73,73,73,54 :REM B
1068 DATA 0,127,65,65,65,62 :REM D
1069 DATA 0,127,73,73,73,65 :REM E
1071 DATA 0,62,65,65,69,127 :REM G
1072 DATA 0,127,8,8,8,127 :REM H
1073 DATA 0,0,65,127,65,0 :REM I
1076 DATA 0,127,1,1,1,1, :REM L
1077 DATA 0,127,32,16,32,127 :REM M
1078 DATA 0,127,16,8,4,127 :REM N
1079 DATA 0,62,65,65,65,62 :REM O
1080 DATA 0,127,72,72,72,48 :REM P
1082 DATA 0,127,72,76,74,49 :REM R
1083 DATA 0,50,73,73,73,38 :REM S
1084 DATA 0,64,64,127,64,64 :REM T
1085 DATA 0,126,1,1,1,126 :REM U
1086 DATA 0,112,12,3,12,112 :REM V
1089 DATA 0,96,16,15,16,96 :REM Y
gerryc



Joined: 14 Mar 2004
Posts: 3
Location: Sydney, Australia

View user's profile Send private message

Complete 5X7 ASCII Table for a scrooling LED Matrix display
PostPosted: Sun Mar 14, 2004 3:21 am     Reply with quote

Hi,

I had to do this recently. It is a bit tricky because of the code page size limitations. It was designed to drive 4" 5 x 7 dot matrix displays using PIC16F73. The displays used in my case were tri-color types where each dot contains both red and green leds. Turning on both red & green together produces orange.
I did it by splitting the table into 3 sections. Note that the way I scanned the matrix was using a row oriented scan, top to bottom and there are therefore 7 bytes of data for each character. It is possible, by remapping the fonts to arrange them for column oriented scanning.
The code for it is shown below. I hope this helps solve your problem.

Regards,
Gerry

This is the code that is used to select the font entries from the tables:

Code:
// Retrieve the font data from the lookup tables. We have had to split the lookups
// into 3 separate tables because of the PIC's addressing limitations. The tables
// are split as follows: Font1[][] contains fonts for char codes 0x20 to 0x3f
//                       Font2[][] contains fonts for char codes 0x40 to 0x5f
//                   Font3[][] contains fonts for char codes 0x50 to 0x7f
//
// The valid display chars are 0x20 (Space) to 0x7f (DEL). Any chars
// outside of this range are simply ignored.

void LoadFont(int Ccode)
   {
   int      cdata, cidx, fidx;

   // Check if code between 0x20 and 0x3f inclusive.
   if(Ccode >= 0x20 && Ccode < 0x40) {
      Ccode -= 0x20;      // normalise the ASCII code
      Ftab = 0;         // use Font1 array
      }
   else if(Ccode >= 0x50 && Ccode < 0x60) {
      Ccode -= 0x40;      // normalise the ASCII code
      Ftab = 1;         // use Font2 array
      }
   else if(Ccode >= 0x60 && Ccode < 0x80) {
      Ccode -= 0x60;      // normalise the ASCII code
      Ftab = 2;
      }

   // Now that we have normalized the codes, we can proceed to load up the
   // display array. This is done based on the colour of the display.
   // The 1st 7 bytes are for RED leds
   // The 2nd 7 bytes are for GREEN leds
   // All entries are filled for orange (red and green leds on)

   for(cidx = 0, fidx = 0; cidx < 7; cidx++, fidx++) {
      if(Ftab == 0) cdata = Font1[Ccode][fidx];
      else if(Ftab == 1) cdata = Font2[Ccode][fidx];
      else if(Ftab == 2) cdata = Font3[Ccode][fidx];
      if(Colour & RED)
         Dbuff[cidx] = cdata;
      else Dbuff[cidx] = 0;
      if(Colour & GREEN)
         Dbuff[cidx + 7] = cdata;
      else Dbuff[cidx + 7] = 0;
      }
   }


The tables are actually declared in a header file and then just included in the main source file:

Code:
// Declare and Init the font array data
int const Font1[32][7] = {
   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,}   // 0x20, Space
   {0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04,}   // 0x21, !
   {0x09, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00,}   // 0x22, "
   {0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a,}   // 0x23, #
   {0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04,}   // 0x24, $
   {0x19, 0x19, 0x02, 0x04, 0x08, 0x13, 0x13,}   // 0x25, %
   {0x04, 0x0a, 0x0a, 0x0a, 0x15, 0x12, 0x0d,}   // 0x26, &
   {0x04, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00,}   // 0x27, '
   {0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02,}   // 0x28, (
   {0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08,}   // 0x29, )
   {0x04, 0x15, 0x0e, 0x1f, 0x0e, 0x15, 0x04,}   // 0x2a, *
   {0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00,}   // 0x2b, +
   {0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x08,}   // 0x2c, ,
   {0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,}   // 0x2d, -
   {0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c,}   // 0x2e, .
   {0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10,}   // 0x2f, /
   {0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e,}   // 0x30, 0
   {0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e,}   // 0x31, 1
   {0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f,}   // 0x32, 2
   {0x0e, 0x11, 0x01, 0x06, 0x01, 0x11, 0x0e,}   // 0x33, 3
   {0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02,}   // 0x34, 4
   {0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e,}   // 0x35, 5
   {0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e,}   // 0x36, 6
   {0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08,}   // 0x37, 7
   {0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e,}   // 0x38, 8
   {0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c,}   // 0x39, 9
   {0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00,}   // 0x3a, :
   {0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08,}   // 0x3b, ;
   {0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02,}   // 0x3c, <
   {0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00,}   // 0x3d, =
   {0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08,}   // 0x3e, >
   {0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04,}   // 0x3f, ?
   };

int const Font2[32][7] = { 
   {0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0f,}   // 0x40, @
   {0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11,}   // 0x41, A
   {0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e,}   // 0x42, B
   {0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e,}   // 0x43, C
   {0x1e, 0x09, 0x09, 0x09, 0x09, 0x09, 0x1e,}   // 0x44, D
   {0x1f, 0x10, 0x10, 0x1c, 0x10, 0x10, 0x1f,}   // 0x45, E
   {0x1f, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10,}   // 0x46, F
   {0x0e, 0x11, 0x10, 0x10, 0x13, 0x11, 0x0f,}   // 0x37, G
   {0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11,}   // 0x48, H
   {0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e,}   // 0x49, I
   {0x1f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c,}   // 0x4a, J
   {0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11,}   // 0x4b, K
   {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f,}   // 0x4c, L
   {0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11,}   // 0x4d, M
   {0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11,}   // 0x4e, N
   {0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e,}   // 0x4f, O
   {0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10,}   // 0x50, P
   {0x0e, 0x11, 0x11, 0x11, 0x15, 0x12, 0x0d,}   // 0x51, Q
   {0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11,}   // 0x52, R
   {0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e,}   // 0x53, S
   {0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,}   // 0x54, T
   {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e,}   // 0x55, U
   {0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04,}   // 0x56, V
   {0x11, 0x11, 0x11, 0x15, 0x15, 0x1b, 0x11,}   // 0x57, W
   {0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11,}   // 0x58, X
   {0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04,}   // 0x59, Y
   {0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f,}   // 0x5a, Z
   {0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e,}   // 0x5b, [
   {0x10, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01,}   // 0x5c, \
   {0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e,}   // 0x5d, ]
   {0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00,}   // 0x5e, ^
   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f,}   // 0x5f, _
   };

int const Font3[32][7] = {
   {0x04, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00,}   // 0x60, `
   {0x00, 0x0e, 0x01, 0x0d, 0x13, 0x13, 0x0d,}   // 0x61, a
   {0x10, 0x10, 0x10, 0x1c, 0x12, 0x12, 0x1c,}   // 0x62, b
   {0x00, 0x00, 0x00, 0x0e, 0x10, 0x10, 0x0e,}   // 0x63, c
   {0x01, 0x01, 0x01, 0x07, 0x09, 0x09, 0x07,}   // 0x64, d
   {0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f,}   // 0x65, e
   {0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08,}   // 0x66, f
   {0x0e, 0x11, 0x13, 0x0d, 0x01, 0x01, 0x0e,}   // 0x67, g
   {0x10, 0x10, 0x10, 0x16, 0x19, 0x11, 0x11,}   // 0x68, h
   {0x00, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e,}   // 0x69, i
   {0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c,}   // 0x6a, j
   {0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12,}   // 0x6b, k
   {0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,}   // 0x6c, l
   {0x00, 0x00, 0x0a, 0x15, 0x15, 0x11, 0x11,}   // 0x6d, m
   {0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11,}   // 0x6e, n
   {0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e,}   // 0x6f, o
   {0x00, 0x1c, 0x12, 0x12, 0x1c, 0x10, 0x10,}   // 0x70, p
   {0x00, 0x07, 0x09, 0x09, 0x07, 0x01, 0x01,}   // 0x71, q
   {0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10,}   // 0x72, r
   {0x00, 0x00, 0x0f, 0x10, 0x0e, 0x01, 0x1e,}   // 0x73, s
   {0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06,}   // 0x74, t
   {0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d,}   // 0x75, u
   {0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04,}   // 0x76, v
   {0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a,}   // 0x77, w
   {0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11,}   // 0x78, x
   {0x00, 0x11, 0x11, 0x0f, 0x01, 0x11, 0x0e,}   // 0x79, y
   {0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f,}   // 0x7a, z
   {0x06, 0x08, 0x08, 0x10, 0x08, 0x08, 0x06,}   // 0x7b, {
   {0x04, 0x04, 0x04, 0x00, 0x04, 0x04, 0x04,}   // 0x7c, |
   {0x0c, 0x02, 0x02, 0x01, 0x02, 0x02, 0x0c,}   // 0x7d, }
   {0x08, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00,}   // 0x7e, ~
   {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,}   // 0x7f, DEL
   };
hillcraft



Joined: 22 Sep 2003
Posts: 101
Location: Cape Town (South africa)

View user's profile Send private message Send e-mail Visit poster's website

5X7 Matrix
PostPosted: Sun Mar 14, 2004 12:30 pm     Reply with quote

Thanks for the info.

My program actually uses a column scan. I am sure that I can transpose your data. I have 2 problems that I have not been able to resolve. I use 74HCT164's, it seems as if the data for the next row shows up briefly on the current row before it shows up on the appropriate row. I also find that the dispaly is not really visible in daylight. I have placed a Red perspex filter over the display and it has certinly helped a lot. Have you found a way around this. Using 5x7x16 high brightness leds could be come rather costly.
Guest








PostPosted: Sun Mar 14, 2004 4:43 pm     Reply with quote

Hi,

Your problem probably lies in the fact that you do not have an inter-column blanking interval. You are probably shifting out the data for the next column before the drive for current column has been switched off,
In multiplexed displays you require a short period where the displays are blanked out completely, called the blanking interval, usually during the shift operation for the next column (or row).

For a 1KHz multiplex rate, you would typically follow the following sequence:

Shift data for column 1 and enable column driver for 900us
Switch off column driver for 100us while shifting out data for column 2
Now switch on the driver for column 2 for 900us.
Repeat this sequence until you get to column 5 and then start at column 1 again.

This scenario assumes that your data source can shift out all of you column data in under 100us, which should not be a problem if you use the SPI interface on something like the F877.

You can use lower multiplex rates, so long as you maintain a minimum of 70Hz refresh to avoid any visible flicker (350Hz for 5 columns).
I would recommend going no lower than 500Hz (2ms refresh rate).

How are things in SA? I left there in 1971 and settled in Australia.

I hope this helps to get your project going.

Regards,

Gerry
ernest



Joined: 11 Feb 2004
Posts: 51

View user's profile Send private message

Help - How to use RS232 to display characters on dot-matrix
PostPosted: Tue Nov 02, 2004 6:14 am     Reply with quote

Hello, I'm trying to build a 5x7 dot-matrix display using PIC16F877A. So far, I've been able to display scrolling characters on the dot matrix. But it would be much better if user can change the message to be displayed by simply using the RS232.

I've written a program below but it failed to display the message. Please comment on any mistakes done in the program. Is there a better way of writing the program? All advice are much appreciated.


#if defined(__PCM__)
#include <16F877A.H>
#fuses HS,NOWDT,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_A4, rcv=PIN_A5) //use portA instead

#IFNDEF EXP_OUT_ENABLE
#define EXP_OUT_ENABLE PIN_C2
#define EXP_OUT_CLOCK PIN_C1
#define EXP_OUT_DO PIN_C0
#define NUMBER_OF_74595 3 //trying out with 3 ICs
#ENDIF
#include <74595_V02.C>

#byte port_a=5
#byte port_b=6
#byte port_c=7
#byte port_d=8


// TO DISPLAY 5X7 DOT MATRIX CHARACTER
//char const msg[80]={0,0, 127,8,8,8,127, 0,56,84,84,84,24, 0,65,127,64, 0,65,127,64, 0,56,68,68,68,56, 0,88,56,0, 127,8,4,4,120, 0,56,68,68,68,56, 0,60,64,48,64,60, 0,0,32,84,84,84,56, 0,124,8,4,4,8, 0,56,84,84,84,24, 0,0,60,64,64,32,124, 0,2,1,81,9,6};
// ==> ABLE TO DISPLAY: "Hello,how are u?"
// the '0' was placed in front of every char. to give spacing of 1column

char msg[40];
char s1[16];
void get_line1() { // to acquire 16 char.
s1[0]=getc();
printf("\ts1==> %C",s1[0]);
s1[1]=getc();
printf("%C",s1[1]);
s1[2]=getc();
printf("%C",s1[2]);
s1[3]=getc();
printf("%C",s1[3]);
s1[4]=getc();
printf("%C",s1[4]);
s1[5]=getc();
printf("%C",s1[5]);
s1[6]=getc();
printf("%C",s1[6]);
s1[7]=getc();
printf("%C",s1[7]);
s1[8]=getc();
printf("%C",s1[8]);
s1[9]=getc();
printf("%C",s1[9]);
s1[10]=getc();
printf("%C",s1[10]);
s1[11]=getc();
printf("%C",s1[11]);
s1[12]=getc();
printf("%C",s1[12]);
s1[13]=getc();
printf("%C",s1[13]);
s1[14]=getc();
printf("%C",s1[14]);
s1[15]=getc();
printf("%C",s1[15]);
}

char const ascii_char3[6][3] = {
{ 0,11,7 } // ' [0]
{ 0,88,56 } // , [1]
{ 0,96,96 } // . [2]
{ 0,54,54 } // : [3]
{ 0,91,59 } // ; [4]
{ 0,7,11 } // ` [5]
};

char const ascii_char4[11][4] = {
{ 0, 7, 0, 7 } // " [0]
{ 0,28,34,65 } // ( [1]
{ 0,65,34,28 } // ) [2]
{ 0,66,127,64 } // 1 [3]
{ 0,65.127,65 } // I (Capital i)
{ 0,127,65,65 } // [ [5]
{ 0,65,65,127 } // ] [6]
{ 0,68,125,64 } // i [7]
{ 0,65,127,64 } // l (Small L)
{ 0,8,54,65 } // { [9]
{ 0,65,54,8 } // } [10]
};

char const ascii_char5[8][5] = {
{ 0, 8,62, 8, 8 } // + [0]
{ 0,8,20,34,65 } // < [1]
{ 0,65,34,20,8 } // > [2]
{ 0,56,68,68,68 } // c [3]
{ 0,32,64,68,61 } // j [4]
{ 0,127,16,40,68} // k [5]
{ 0, 4,63,68,68 } // t [6]
{ 0, 2, 1, 2,42 } // ~ [7]
};

char const ascii_char6[30][6] = {
{ 0, 20,127,20,127,20 } // DEC 35 '#' [0]
{ 0, 36, 42, 127, 42, 18 } // 36D '$' [1]
{ 0, 39, 21, 107, 84, 114 } // 37D '%' [2]
{ 0, 54, 73, 86, 32, 80 } // 38D '&' [3]
{} //0, 11, 7 // 39H [4]
{} //0, 28, 34, 65 // 40D [5]
{} //0, 65, 34, 28 // 41D [6]
{ 0, 42, 28, 127, 28, 42 } // 42D '*' [7]
{} //0, 8, 62, 8, 8 // 43D [8]
{} //0, 88, 56 // 44D [9]
{ 0, 8,8,8,8,8 } // 45D '-' [10]
{} //0, 96, 96 // 46D [11]
{ 0, 32, 16, 8, 4, 2 } // 47D '/' [12]
{ 0, 62, 81, 73, 69, 62 } // 48D '0' [13]
{} //0,66, 127, 64 // 49D [14]
{ 0, 114, 73, 73, 73, 70 } // 50D '2' [15]
{ 0, 34, 65, 73, 73, 54 } // 51D '3' [16]
{ 0, 24, 20, 18, 127, 16 } // 52D '4' [17]
{ 0, 39, 69, 69, 69, 57 } // 53D '5' [18]
{ 0, 120, 74, 73, 73, 48 } // 54D '6' [19]
{ 0, 1, 113, 9, 5, 3 } // 55D '7' [20]
{ 0, 54, 73, 73, 73, 54 } // 56D '8' [21]
{ 0, 6, 73, 73, 41, 30 } // 57D '9' [22]
{} //0, 54, 54 // 58D [23]
{} //0, 91, 59 // 59D [24]
{} //0, 8, 20, 34, 65 // 60D [25]
{ 0, 20, 20, 20, 20, 20 } // 61D [26]
{} //0, 65, 34, 20, 8 // 62D [27]
{ 0, 2, 1, 81, 9, 6 } // 63D [28]
{ 0, 50, 73, 121, 65, 62 } // 64D [29]
};

char const ascii_char7[31][6] = {
{ 0, 124, 18, 17, 18, 124 } // 65
{ 0, 65, 127, 73, 73, 54 } // 66
{ 0, 62, 65, 65, 65, 34 } // 67
{ 0, 65, 127, 65, 65, 62 } // 68
{ 0, 127, 73, 73, 65, 65 } // 69
{ 0, 127, 9, 9, 1, 1 } // 70
{ 0, 62, 65, 73, 73, 58 } // 71
{ 0, 127, 8, 8, 8, 127 } // 72
{ } // 0, 65, 127, 65 // 73 X
{ 0, 32, 64, 65, 63, 1 } // 74
{ 0, 127, 8, 20, 34, 65 } // 75
{ 0, 127, 64, 64, 64, 64 } // 76
{ 0, 127, 2, 12, 2, 127 } // 77
{ 0, 127, 2, 4, 8, 127 } // 78
{ 0, 62, 65, 65, 65, 62 } // 79
{ 0, 127, 9, 9, 9, 6 } // 80
{ 0, 62, 9, 81, 33, 94 } // 81
{ 0, 127, 9, 25, 41, 70 } // 82
{ 0, 38, 73, 73, 73, 50 } // 83
{ 0, 1,1,127, 1, 1 } // 84
{ 0, 63, 64, 64, 64, 63 } // 85
{ 0, 7, 24, 96, 24, 7 } // 86
{ 0, 127, 32, 24, 32, 127 } // 87
{ 0, 99, 20, 8, 20, 99 } // 88
{ 0, 3, 4, 120, 4, 3 } // 89
{ 0 97, 81, 73, 69, 67 } // 90
{ } // 0, 127, 65, 65 // 91 X
{ 0, 2, 4, 8, 16, 32 } // 92
{ } //0, 65, 65, 127 // 93 X
{ 0, 4, 2, 1, 2, 4 } // 94
{ 0, 64, 64, 64, 64, 64 } // 95
};

char const ascii_char8[26][6] = {
{ 0, 32, 84, 84, 84, 56 } // 97
{ 0, 127, 40, 68, 68, 556 } // 98
{ } // 0, 56, 68, 68, 68 // 99 X
{ 0, 56, 68, 68, 40, 127 } // 100
{ 0, 56, 84, 84, 84, 24 } // 101
{ 0, 8, 63, 9, 9, 2 } // 102
{ 0, 8, 84, 84, 84, 60 } // 103
{ 0, 127, 8, 4, 4, 120 } // 104
{ } // 0, 68, 125, 64 // 105 X
{ } // 0, 32, 64, 68, 61 // 106 X
{ } // 0, 127, 16, 40, 68 // 107 X
{ } //0, 65, 127, 64 // 108 X
{ 0, 124, 4, 120, 4, 120 } // 109
{ 0, 124, 8, 4, 4, 120 } // 110
{ 0, 56, 68, 68, 68, 56 } // 111
{ 0, 124, 20, 20, 20, 8 } // 112
{ 0, 8, 20, 20, 20, 124 } // 113
{ 0, 124, 8, 4, 4, 8 } // 114
{ 0, 72, 84, 84, 84, 36 } // 115
{ } //0, 4, 63, 68, 68 // 116 X
{ 0, 60, 64, 64, 32, 124 } // 117
{ 0, 28, 32, 64, 32, 28 } // 118
{ 0, 60, 64, 48, 64, 60 } // 119
{ 0, 68, 40, 16, 40, 68 } // 120
{ 0, 12,80, 80, 80, 60 } // 121
{ 0, 36, 100, 84, 76, 36 } // 122
};


main()
{
int n = 0;
int mask[4];
int data[4];
int delaycount;
int startposition;
int index;
int i = 0; int x = 0; int y = 0; // x=counter for row, y=counter for column ie. [x][y]
int z = 0; // to count size of msg[]
mask[0] = 0x01; mask[1] = 0x00; mask[2] = 0x00; mask[3] = 0x00;

set_tris_b(0); //set portb to outputs
set_tris_c(0); //set portc to outputs
set_tris_d(0);
port_b = 0;
port_c = 0; //zero port c
startposition = 0;

msg[0] = ascii_char6[1][0]; // $
msg[1] = ascii_char6[1][1];
msg[2] = ascii_char6[1][2];
msg[3] = ascii_char6[1][3];
msg[4] = ascii_char6[1][4];
msg[5] = ascii_char6[1][5];

msg[6] = ascii_char6[22][0]; // 9
msg[7] = ascii_char6[22][1];
msg[8] = ascii_char6[22][2];
msg[9] = ascii_char6[22][3];
msg[10] = ascii_char6[22][4];
msg[11] = ascii_char6[22][5];

msg[12] = ascii_char5[7][0]; // ~
msg[13] = ascii_char5[7][1];
msg[14] = ascii_char5[7][2];
msg[15] = ascii_char5[7][3];
msg[16] = ascii_char5[7][4];

msg[17] = ascii_char3[2][0]; // .
msg[18] = ascii_char3[2][1];
msg[19] = ascii_char3[2][2];

msg[20] = ascii_char4[7][0]; // i
msg[21] = ascii_char4[7][1];
msg[22] = ascii_char4[7][2];
msg[23] = ascii_char4[7][3];

z = sizeof(msg);


do
{

if(!input(PIN_E1)) // if RE1 == LOW (pressed)
{
printf("\r\nEnter the char.: ");
get_line1(); // acquire 16 char.
n = 0; z=0;

for(n=0; n<8 ; n++) // allow display of 8 char.
{

if(s1[n]==32) // ' BLANK ' ==> 1 column
{ msg[n]=0; z+=1;}


if(s1[n]==33) // ' ! ' ==> 2 columns incl.LEADING SPACE
{ msg[n]=0;
msg[n+1]=95;
z+=2; }

// ==> 5 columns incl. LEADING SPACE
if((s1[n]==43)&&(s1[n]==60)&&(s1[n]==62)&&(s1[n]==99)&&(s1[n]==106)&&(s1[n]==107)&&(s1[n]==116)&&(s1[n]==126))
{
if(s1[n]==43)
x = 0;
if(s1[n]==60)
x = 1;
if(s1[n]==62)
x = 2;
if(s1[n]==99)
x = 3;
if(s1[n]==106)
x = 4;
if(s1[n]==107)
x = 5;
if(s1[n]==116)
x = 6;
if(s1[n]==126)
x = 7;

for(y=0;y<5;y++)
{
msg[z+y] = ascii_char5[x][y];
}
z+=5;
} // end of IF s1 compare for 5columns


// ==> 4 columns incl. LEADING SPACE
if((s1[0]==34) && (s1[0]==40) && (s1[0]==41) && (s1[0]==49) && (s1[0]==73) && (s1[0]==91) && (s1[0]==93)
&& (s1[0]==105) && (s1[0]==108) && (s1[0]==123) && (s1[0]==125))
{
switch(s1[n])
{
case 34: x=0; break;
case 40: x=1; break;
case 41: x=2; break;
case 49: x=3; break;
case 73: x=4; break;
case 91: x=5; break;
case 93: x=6; break;
case 105: x=7; break;
case 108: x=8; break;
case 123: x=9; break;
case 125: x=10; break;
}

for(y=0;y<4;y++)
{
msg[z+y] = ascii_char4[x][y];
}
z+=4;
} // end of IF s1 compare for 4columns


// ==> 3 columns incl. LEADING SPACE
if((s1[n]==39) && (s1[n]==44) && (s1[n]==46) && (s1[n]==58) && (s1[n]==59) && (s1[n]==96))
{
switch(s1[n])
{
case 39: x=0; break;
case 44: x=1; break;
case 46: x=2; break;
case 58: x=3; break;
case 59: x=4; break;
case 96: x=5; break;
}

for(y=0;y<3;y++)
{
msg[z+y] = ascii_char3[x][y];
}
z+=3;
} // end of IF s1 compare for 3columns

} //END OF for-loop for n-flag

} // END of INPUT(PIN_E1)




delaycount=5;
while (delaycount)
{
index = startposition;


for (i=0;i<32;i++) // we have 32 columns to drive //for (i=0;i<32;i++) //
{
// store our mask in an array. we need to do this because
// the call to write_expanded_outputs will destroy the value
// passed in.
data[0] = mask[0]; // store which column we are driving
data[1] = mask[1]; // in an array
data[2] = mask[2];
data[3] = mask[3];

if(!input(PIN_E2)) // to allow user to FREEZE DISPLAY/SCROLLING when RE2==LOW
delaycount = 4;

index = i + startposition; // point to the next pattern to display
if (index >= z) //sizeof(msg)) // make sure that we don't exceed the array
index -= z; //sizeof(msg);

// port_b = 0; // disable driving the LEDs
//port_d = 0; // use port d to drive ROWS
port_d=0;
write_expanded_outputs(data); // enable our column driver



// port_b = msg[index]; // drive our LEDs
port_d = msg[index];

if (shift_left(mask,4,0))
mask[0] = 0x01;
delay_us(750); // adjust this value to control the drive time
//for the leds
}

--delaycount; // decrement our delay loop counter
}

++startposition; // Point to the next data pattern

if (startposition >= sizeof(msg)) // make sure that we don't exceed the array
startposition = 0;

// if(!input(PIN_E1)) // to allow user to FORCE the display to RETURN to ORIGIN when RE1==LOW
// {
// startposition = 2; // reset starting position with OFFSET of 2 (otherwise 2 trash column will be shown)
// index = 0; // reset index
// i = 0; // reset i count
// }

} while(1); // END while(1)
} // END main()

THANK YOU.
ernest



Joined: 11 Feb 2004
Posts: 51

View user's profile Send private message

Help - How to use RS232 to display characters on dot-matrix
PostPosted: Tue Nov 02, 2004 6:14 am     Reply with quote

Hello, I'm trying to build a 5x7 dot-matrix display using PIC16F877A. So far, I've been able to display scrolling characters on the dot matrix. But it would be much better if user can change the message to be displayed by simply using the RS232.

I've written a program below but it failed to display the message. Please comment on any mistakes done in the program. Is there a better way of writing the program? All advice are much appreciated.


#if defined(__PCM__)
#include <16F877A.H>
#fuses HS,NOWDT,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_A4, rcv=PIN_A5) //use portA instead

#IFNDEF EXP_OUT_ENABLE
#define EXP_OUT_ENABLE PIN_C2
#define EXP_OUT_CLOCK PIN_C1
#define EXP_OUT_DO PIN_C0
#define NUMBER_OF_74595 3 //trying out with 3 ICs
#ENDIF
#include <74595_V02.C>

#byte port_a=5
#byte port_b=6
#byte port_c=7
#byte port_d=8


// TO DISPLAY 5X7 DOT MATRIX CHARACTER
//char const msg[80]={0,0, 127,8,8,8,127, 0,56,84,84,84,24, 0,65,127,64, 0,65,127,64, 0,56,68,68,68,56, 0,88,56,0, 127,8,4,4,120, 0,56,68,68,68,56, 0,60,64,48,64,60, 0,0,32,84,84,84,56, 0,124,8,4,4,8, 0,56,84,84,84,24, 0,0,60,64,64,32,124, 0,2,1,81,9,6};
// ==> ABLE TO DISPLAY: "Hello,how are u?"
// the '0' was placed in front of every char. to give spacing of 1column

char msg[40];
char s1[16];
void get_line1() { // to acquire 16 char.
s1[0]=getc();
printf("\ts1==> %C",s1[0]);
s1[1]=getc();
printf("%C",s1[1]);
s1[2]=getc();
printf("%C",s1[2]);
s1[3]=getc();
printf("%C",s1[3]);
s1[4]=getc();
printf("%C",s1[4]);
s1[5]=getc();
printf("%C",s1[5]);
s1[6]=getc();
printf("%C",s1[6]);
s1[7]=getc();
printf("%C",s1[7]);
s1[8]=getc();
printf("%C",s1[8]);
s1[9]=getc();
printf("%C",s1[9]);
s1[10]=getc();
printf("%C",s1[10]);
s1[11]=getc();
printf("%C",s1[11]);
s1[12]=getc();
printf("%C",s1[12]);
s1[13]=getc();
printf("%C",s1[13]);
s1[14]=getc();
printf("%C",s1[14]);
s1[15]=getc();
printf("%C",s1[15]);
}

char const ascii_char3[6][3] = {
{ 0,11,7 } // ' [0]
{ 0,88,56 } // , [1]
{ 0,96,96 } // . [2]
{ 0,54,54 } // : [3]
{ 0,91,59 } // ; [4]
{ 0,7,11 } // ` [5]
};

char const ascii_char4[11][4] = {
{ 0, 7, 0, 7 } // " [0]
{ 0,28,34,65 } // ( [1]
{ 0,65,34,28 } // ) [2]
{ 0,66,127,64 } // 1 [3]
{ 0,65.127,65 } // I (Capital i)
{ 0,127,65,65 } // [ [5]
{ 0,65,65,127 } // ] [6]
{ 0,68,125,64 } // i [7]
{ 0,65,127,64 } // l (Small L)
{ 0,8,54,65 } // { [9]
{ 0,65,54,8 } // } [10]
};

char const ascii_char5[8][5] = {
{ 0, 8,62, 8, 8 } // + [0]
{ 0,8,20,34,65 } // < [1]
{ 0,65,34,20,8 } // > [2]
{ 0,56,68,68,68 } // c [3]
{ 0,32,64,68,61 } // j [4]
{ 0,127,16,40,68} // k [5]
{ 0, 4,63,68,68 } // t [6]
{ 0, 2, 1, 2,42 } // ~ [7]
};

char const ascii_char6[30][6] = {
{ 0, 20,127,20,127,20 } // DEC 35 '#' [0]
{ 0, 36, 42, 127, 42, 18 } // 36D '$' [1]
{ 0, 39, 21, 107, 84, 114 } // 37D '%' [2]
{ 0, 54, 73, 86, 32, 80 } // 38D '&' [3]
{} //0, 11, 7 // 39H [4]
{} //0, 28, 34, 65 // 40D [5]
{} //0, 65, 34, 28 // 41D [6]
{ 0, 42, 28, 127, 28, 42 } // 42D '*' [7]
{} //0, 8, 62, 8, 8 // 43D [8]
{} //0, 88, 56 // 44D [9]
{ 0, 8,8,8,8,8 } // 45D '-' [10]
{} //0, 96, 96 // 46D [11]
{ 0, 32, 16, 8, 4, 2 } // 47D '/' [12]
{ 0, 62, 81, 73, 69, 62 } // 48D '0' [13]
{} //0,66, 127, 64 // 49D [14]
{ 0, 114, 73, 73, 73, 70 } // 50D '2' [15]
{ 0, 34, 65, 73, 73, 54 } // 51D '3' [16]
{ 0, 24, 20, 18, 127, 16 } // 52D '4' [17]
{ 0, 39, 69, 69, 69, 57 } // 53D '5' [18]
{ 0, 120, 74, 73, 73, 48 } // 54D '6' [19]
{ 0, 1, 113, 9, 5, 3 } // 55D '7' [20]
{ 0, 54, 73, 73, 73, 54 } // 56D '8' [21]
{ 0, 6, 73, 73, 41, 30 } // 57D '9' [22]
{} //0, 54, 54 // 58D [23]
{} //0, 91, 59 // 59D [24]
{} //0, 8, 20, 34, 65 // 60D [25]
{ 0, 20, 20, 20, 20, 20 } // 61D [26]
{} //0, 65, 34, 20, 8 // 62D [27]
{ 0, 2, 1, 81, 9, 6 } // 63D [28]
{ 0, 50, 73, 121, 65, 62 } // 64D [29]
};

char const ascii_char7[31][6] = {
{ 0, 124, 18, 17, 18, 124 } // 65
{ 0, 65, 127, 73, 73, 54 } // 66
{ 0, 62, 65, 65, 65, 34 } // 67
{ 0, 65, 127, 65, 65, 62 } // 68
{ 0, 127, 73, 73, 65, 65 } // 69
{ 0, 127, 9, 9, 1, 1 } // 70
{ 0, 62, 65, 73, 73, 58 } // 71
{ 0, 127, 8, 8, 8, 127 } // 72
{ } // 0, 65, 127, 65 // 73 X
{ 0, 32, 64, 65, 63, 1 } // 74
{ 0, 127, 8, 20, 34, 65 } // 75
{ 0, 127, 64, 64, 64, 64 } // 76
{ 0, 127, 2, 12, 2, 127 } // 77
{ 0, 127, 2, 4, 8, 127 } // 78
{ 0, 62, 65, 65, 65, 62 } // 79
{ 0, 127, 9, 9, 9, 6 } // 80
{ 0, 62, 9, 81, 33, 94 } // 81
{ 0, 127, 9, 25, 41, 70 } // 82
{ 0, 38, 73, 73, 73, 50 } // 83
{ 0, 1,1,127, 1, 1 } // 84
{ 0, 63, 64, 64, 64, 63 } // 85
{ 0, 7, 24, 96, 24, 7 } // 86
{ 0, 127, 32, 24, 32, 127 } // 87
{ 0, 99, 20, 8, 20, 99 } // 88
{ 0, 3, 4, 120, 4, 3 } // 89
{ 0 97, 81, 73, 69, 67 } // 90
{ } // 0, 127, 65, 65 // 91 X
{ 0, 2, 4, 8, 16, 32 } // 92
{ } //0, 65, 65, 127 // 93 X
{ 0, 4, 2, 1, 2, 4 } // 94
{ 0, 64, 64, 64, 64, 64 } // 95
};

char const ascii_char8[26][6] = {
{ 0, 32, 84, 84, 84, 56 } // 97
{ 0, 127, 40, 68, 68, 556 } // 98
{ } // 0, 56, 68, 68, 68 // 99 X
{ 0, 56, 68, 68, 40, 127 } // 100
{ 0, 56, 84, 84, 84, 24 } // 101
{ 0, 8, 63, 9, 9, 2 } // 102
{ 0, 8, 84, 84, 84, 60 } // 103
{ 0, 127, 8, 4, 4, 120 } // 104
{ } // 0, 68, 125, 64 // 105 X
{ } // 0, 32, 64, 68, 61 // 106 X
{ } // 0, 127, 16, 40, 68 // 107 X
{ } //0, 65, 127, 64 // 108 X
{ 0, 124, 4, 120, 4, 120 } // 109
{ 0, 124, 8, 4, 4, 120 } // 110
{ 0, 56, 68, 68, 68, 56 } // 111
{ 0, 124, 20, 20, 20, 8 } // 112
{ 0, 8, 20, 20, 20, 124 } // 113
{ 0, 124, 8, 4, 4, 8 } // 114
{ 0, 72, 84, 84, 84, 36 } // 115
{ } //0, 4, 63, 68, 68 // 116 X
{ 0, 60, 64, 64, 32, 124 } // 117
{ 0, 28, 32, 64, 32, 28 } // 118
{ 0, 60, 64, 48, 64, 60 } // 119
{ 0, 68, 40, 16, 40, 68 } // 120
{ 0, 12,80, 80, 80, 60 } // 121
{ 0, 36, 100, 84, 76, 36 } // 122
};


main()
{
int n = 0;
int mask[4];
int data[4];
int delaycount;
int startposition;
int index;
int i = 0; int x = 0; int y = 0; // x=counter for row, y=counter for column ie. [x][y]
int z = 0; // to count size of msg[]
mask[0] = 0x01; mask[1] = 0x00; mask[2] = 0x00; mask[3] = 0x00;

set_tris_b(0); //set portb to outputs
set_tris_c(0); //set portc to outputs
set_tris_d(0);
port_b = 0;
port_c = 0; //zero port c
startposition = 0;

msg[0] = ascii_char6[1][0]; // $
msg[1] = ascii_char6[1][1];
msg[2] = ascii_char6[1][2];
msg[3] = ascii_char6[1][3];
msg[4] = ascii_char6[1][4];
msg[5] = ascii_char6[1][5];

msg[6] = ascii_char6[22][0]; // 9
msg[7] = ascii_char6[22][1];
msg[8] = ascii_char6[22][2];
msg[9] = ascii_char6[22][3];
msg[10] = ascii_char6[22][4];
msg[11] = ascii_char6[22][5];

msg[12] = ascii_char5[7][0]; // ~
msg[13] = ascii_char5[7][1];
msg[14] = ascii_char5[7][2];
msg[15] = ascii_char5[7][3];
msg[16] = ascii_char5[7][4];

msg[17] = ascii_char3[2][0]; // .
msg[18] = ascii_char3[2][1];
msg[19] = ascii_char3[2][2];

msg[20] = ascii_char4[7][0]; // i
msg[21] = ascii_char4[7][1];
msg[22] = ascii_char4[7][2];
msg[23] = ascii_char4[7][3];

z = sizeof(msg);


do
{

if(!input(PIN_E1)) // if RE1 == LOW (pressed)
{
printf("\r\nEnter the char.: ");
get_line1(); // acquire 16 char.
n = 0; z=0;

for(n=0; n<8 ; n++) // allow display of 8 char.
{

if(s1[n]==32) // ' BLANK ' ==> 1 column
{ msg[n]=0; z+=1;}


if(s1[n]==33) // ' ! ' ==> 2 columns incl.LEADING SPACE
{ msg[n]=0;
msg[n+1]=95;
z+=2; }

// ==> 5 columns incl. LEADING SPACE
if((s1[n]==43)&&(s1[n]==60)&&(s1[n]==62)&&(s1[n]==99)&&(s1[n]==106)&&(s1[n]==107)&&(s1[n]==116)&&(s1[n]==126))
{
if(s1[n]==43)
x = 0;
if(s1[n]==60)
x = 1;
if(s1[n]==62)
x = 2;
if(s1[n]==99)
x = 3;
if(s1[n]==106)
x = 4;
if(s1[n]==107)
x = 5;
if(s1[n]==116)
x = 6;
if(s1[n]==126)
x = 7;

for(y=0;y<5;y++)
{
msg[z+y] = ascii_char5[x][y];
}
z+=5;
} // end of IF s1 compare for 5columns


// ==> 4 columns incl. LEADING SPACE
if((s1[0]==34) && (s1[0]==40) && (s1[0]==41) && (s1[0]==49) && (s1[0]==73) && (s1[0]==91) && (s1[0]==93)
&& (s1[0]==105) && (s1[0]==108) && (s1[0]==123) && (s1[0]==125))
{
switch(s1[n])
{
case 34: x=0; break;
case 40: x=1; break;
case 41: x=2; break;
case 49: x=3; break;
case 73: x=4; break;
case 91: x=5; break;
case 93: x=6; break;
case 105: x=7; break;
case 108: x=8; break;
case 123: x=9; break;
case 125: x=10; break;
}

for(y=0;y<4;y++)
{
msg[z+y] = ascii_char4[x][y];
}
z+=4;
} // end of IF s1 compare for 4columns


// ==> 3 columns incl. LEADING SPACE
if((s1[n]==39) && (s1[n]==44) && (s1[n]==46) && (s1[n]==58) && (s1[n]==59) && (s1[n]==96))
{
switch(s1[n])
{
case 39: x=0; break;
case 44: x=1; break;
case 46: x=2; break;
case 58: x=3; break;
case 59: x=4; break;
case 96: x=5; break;
}

for(y=0;y<3;y++)
{
msg[z+y] = ascii_char3[x][y];
}
z+=3;
} // end of IF s1 compare for 3columns

} //END OF for-loop for n-flag

} // END of INPUT(PIN_E1)




delaycount=5;
while (delaycount)
{
index = startposition;


for (i=0;i<32;i++) // we have 32 columns to drive //for (i=0;i<32;i++) //
{
// store our mask in an array. we need to do this because
// the call to write_expanded_outputs will destroy the value
// passed in.
data[0] = mask[0]; // store which column we are driving
data[1] = mask[1]; // in an array
data[2] = mask[2];
data[3] = mask[3];

if(!input(PIN_E2)) // to allow user to FREEZE DISPLAY/SCROLLING when RE2==LOW
delaycount = 4;

index = i + startposition; // point to the next pattern to display
if (index >= z) //sizeof(msg)) // make sure that we don't exceed the array
index -= z; //sizeof(msg);

// port_b = 0; // disable driving the LEDs
//port_d = 0; // use port d to drive ROWS
port_d=0;
write_expanded_outputs(data); // enable our column driver



// port_b = msg[index]; // drive our LEDs
port_d = msg[index];

if (shift_left(mask,4,0))
mask[0] = 0x01;
delay_us(750); // adjust this value to control the drive time
//for the leds
}

--delaycount; // decrement our delay loop counter
}

++startposition; // Point to the next data pattern

if (startposition >= sizeof(msg)) // make sure that we don't exceed the array
startposition = 0;

// if(!input(PIN_E1)) // to allow user to FORCE the display to RETURN to ORIGIN when RE1==LOW
// {
// startposition = 2; // reset starting position with OFFSET of 2 (otherwise 2 trash column will be shown)
// index = 0; // reset index
// i = 0; // reset i count
// }

} while(1); // END while(1)
} // END main()

THANK YOU.
Mark



Joined: 07 Sep 2003
Posts: 2838
Location: Atlanta, GA

View user's profile Send private message Send e-mail

PostPosted: Tue Nov 02, 2004 11:25 am     Reply with quote

No triple posting!!!!!!!!
ernest



Joined: 11 Feb 2004
Posts: 51

View user's profile Send private message

PostPosted: Tue Nov 02, 2004 6:31 pm     Reply with quote

Sorry...just too anxious and eager to solve the problem.

Can't wait to see it working.


Thousand apologies.. Wink
Ernest
NeoMatrix



Joined: 03 May 2005
Posts: 23

View user's profile Send private message

moving message help
PostPosted: Sat Jul 30, 2005 7:23 pm     Reply with quote

hello to all


i am new tp ccs c forums n new to pic i am so much interested to build moving message display atleast for 6 chars i am kindly requesting to help me is any bedy already build can u send me the schematic so that i can study n build that mdaslamknl@yahoo.com

plssssssssss


waiting for reply
dyeatman



Joined: 06 Sep 2003
Posts: 1825
Location: Norman, OK

View user's profile Send private message

PostPosted: Sun Jul 31, 2005 9:40 am     Reply with quote

NeoMatrix,
You need to move your post to a new thread to get more interest.

You tacked it on the end of a very long post that many folks will not see.
Display posts from previous:   
Post new topic   Reply to topic    CCS Forum Index -> General CCS C Discussion All times are GMT - 6 Hours
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group