Continue to Site

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.

Register Log in
  • 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.

scrolling text to left, right/ fade-in/out, wipe-in/out

Status
Not open for further replies.
I just went through both code and will try something really soon! like 1 hr from now. It will be a clone of the first post in this topic...
 
Just wanted to tell you to expect a nice video from me in about 20 minutes. Its only 1 5x7 brick but scrolls nicely including a POT to control the speed. All code was hand written... (Except FONT) heh
 
Last edited:
supra_2010 said:
In get_element procedure, u can used keyword inc(y) instead of y++

Ur codes is Ok! But thank. That will will helped newbies.
Click to expand...


ur codes is looked perfectly. The only thing u called is between top to void main

U should put one line by line not single line
If u do line by line, the microprocessor will executes faster then slower.
It is bad readable for readers
 
im converting it now. My cam does HD size so its like 400MB gonna convert it and upload to youtube might tak 20 min from now... heh but you will like trust me!!

EDIT: UPDATE:

17:00 minutes remaining on upload process... its 70MB
 
Last edited:
Might sound confusing but i loop a certain amount of times showing the same buffer then use the ADC to read the POT and then some math to give me a max of 100 from a full turn...

MyDIvisor = 1023 / 100;
then get the ADC result and divide it by the above and it will give me a value of 0-100 on a full turn....

Using that i simple loop the new result from dividing so i can loop it 1-101 times... hence the speed heh...

UPDATE
This is my ADC code
Code: 
unsigned char GetADC(void){
unsigned int TempXY,TempD;

    TempD = 0x03FF / 100;

    ADCON0bits.GO = 1;          //Start the conversion
    while(ADCON0bits.DONE);     //Wait until it’s done
    TempXY = (int)(((int)ADRESH << 8)| ADRESL) / TempD;

    return TempXY;
}

//.... I call like:

Addon = GetADC();

//.... I use value like

for(b=0;b<1+Addon;b++)

I have to use 1+Addon so i can get a minimum value of 1 cuz then it wont loop heh
 
Last edited:
Just bought another PCB to wire up 1 more block to it. If i can get 2 to work good then i should be able to use my main 4 Matrix board.... which has 4 5x7 Matrixs...
 
New 3 blocks:
YouTube - LED Matrix Test 3

Code: 
void ChkBtn(void){
	if(UP){
		Delay100TCYx(20);
		while(UP);
		if(Speed<95){
			Speed++;
		}	
	}

	if(DOWN){
		while(DOWN);
		Delay100TCYx(20);
		if(Speed>1){
			Speed--;
		}
	}
}

The above is what checks the buttons...

Speed is a GLOBAL variable.

Code: 
	LoadStr((unsigned rom char *)"AtomSoft@gmail.com");
	SCROLL_LEN = strlen(StringBuff);        //StringBuff is GLOBAL it contains a copy of the string above from LOADSTR
	SCROLL_LEN = (SCROLL_LEN * 6)+30;
	
	Speed = 20;

	while(1){
		for(n=0; n<SCROLL_LEN; n++){      
			for(b=0;b<Speed;b++){        //THIS IS WHERE SPEED FITS IN
				ChkBtn();
				for(m=0; m<16; m++){
					if(((m+n) > (SCROLL_LEN-15)) || (m+n)<15){
						COL = 0;
					} else {
						COL = Buffer[(n+m-15)];
					}

					CLK = 1;
					Nop();Nop();
					CLK = 0;

					Delay100TCYx(25);//50
				}
			}
		}
	}
 
AtomSoft said:
New 3 blocks:
YouTube - LED Matrix Test 3

Code: 
void ChkBtn(void){
	if(UP){
		Delay100TCYx(20);
		while(UP);
		if(Speed<95){
			Speed++;
		}	
	}

	if(DOWN){
		while(DOWN);
		Delay100TCYx(20);
		if(Speed>1){
			Speed--;
		}
	}
}

The above is what checks the buttons...

Speed is a GLOBAL variable.

Code: 
	LoadStr((unsigned rom char *)"AtomSoft@gmail.com");
	SCROLL_LEN = strlen(StringBuff);        //StringBuff is GLOBAL it contains a copy of the string above from LOADSTR
	SCROLL_LEN = (SCROLL_LEN * 6)+30;
	
	Speed = 20;

	while(1){
		for(n=0; n<SCROLL_LEN; n++){      
			for(b=0;b<Speed;b++){        //THIS IS WHERE SPEED FITS IN
				ChkBtn();
				for(m=0; m<16; m++){
					if(((m+n) > (SCROLL_LEN-15)) || (m+n)<15){
						COL = 0;
					} else {
						COL = Buffer[(n+m-15)];
					}

					CLK = 1;
					Nop();Nop();
					CLK = 0;

					Delay100TCYx(25);//50
				}
			}
		}
	}
Click to expand...

Do u used ASCII code to search for this..."AtomSoft@gmail.com"
or u just used this....LoadStr((unsigned rom char *)"AtomSoft@gmail.com");?
 
Ill post entire code heh:

NOTE: There might be old code in here heh

Code: 
/* *****************************************************************************
;                                                                             *
;    Filename:                     				                              *
;    Date:                                         	                          *
;    File Version: 001                                                        *
;                                                                             *
;    Author:   Jason Lopez                                                    *
;    Company:  AtomSoft                                                       *
;                                                                             *
;***************************************************************************** */

#include <p18f2525.h>
#include <delays.h>
#include <string.h>
#pragma config WDT = OFF, LVP = OFF, OSC = INTIO67, XINST = OFF

unsigned char GetADC(void);
void setSpeed(void);

unsigned char Addon=0;
/************************************
Prototypes
*************************************/
unsigned rom char speedtest[18] ={
     0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E, 
     0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, 
     0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,
};
void main(void);
unsigned rom char Font[96][6] =
{
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
    { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
    { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
    { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
    { 0x00, 0x23, 0x13, 0x08, 0x64, 0x62 },   // %
    { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
    { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 },   // '
    { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
    { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
    { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
    { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
    { 0x00, 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,
    { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10 },   // -
    { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
    { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
    { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
    { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
    { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
    { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
    { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
    { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x00, 0x02, 0x04, 0x08, 0x10, 0x20 },   // back slash
    { 0x00, 0x00, 0x41, 0x41, 0x7f, 0x00 },   // ]
    { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
    { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
    { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
    { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
    { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x00, 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g
    { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
    { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
    { 0x00, 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j
    { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
    { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
    { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x00, 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p
    { 0x00, 0x08, 0x14, 0x14, 0x18, 0x7C },   // q
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
    { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
    { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
    { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
    { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
    { 0x00, 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y
    { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
    { 0x00, 0x00, 0x08, 0x36, 0x41, 0x00 },   // {
    { 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00 },   // |
    { 0x00, 0x00, 0x41, 0x36, 0x08, 0x00 },   // }
    { 0x00, 0x04, 0x02, 0x04, 0x08, 0x04 },   // ~
    { 0x00, 0x00, 0x00, 0x36, 0x00, 0x00 }   // ¦
};

void LoadStr(unsigned rom char *string);
void ChkBtn(void);

unsigned char strLen;
unsigned char Buffer[120];
unsigned char StringBuff[20];
unsigned char Speed=0;

#define UP    PORTAbits.RA1
#define DOWN  PORTAbits.RA2

#define COL   LATB
#define CLK   LATCbits.LATC3

/************************************
Main
*************************************/
void main(void){

unsigned char x,y,z,l;
unsigned char m,b;
unsigned int n;
unsigned char SCROLL_LEN = 0;

	OSCCON=0x72;			//8MHz clock
	OSCTUNEbits.PLLEN=0;			//disable PLL
	while(!OSCCONbits.IOFS);		//wait for osc stable


	TRISA = TRISB = TRISC = 0;
	LATA = LATB = LATC = 0;
	TRISAbits.TRISA1 = 1;
	TRISAbits.TRISA2 = 1;

	ADCON0 = 1;
    ADCON1 = 0x0F;	
	
	LoadStr((unsigned rom char *)"AtomSoft@gmail.com");
	SCROLL_LEN = strlen(StringBuff);
	SCROLL_LEN = (SCROLL_LEN * 6)+30;
	
	Speed = 20;

	while(1){
		for(n=0; n<SCROLL_LEN; n++){
			for(b=0;b<Speed;b++){
				ChkBtn();
				for(m=0; m<16; m++){
					if(((m+n) > (SCROLL_LEN-15)) || (m+n)<15){
						COL = 0;
					} else {
						COL = Buffer[(n+m-15)];
					}

					CLK = 1;
					Nop();Nop();
					CLK = 0;

					Delay100TCYx(25);//50
				}
			}
		}
	}
}
void ChkBtn(void){
	if(UP){
		Delay100TCYx(20);
		while(UP);
		if(Speed<95){
			Speed++;
		}	
	}

	if(DOWN){
		while(DOWN);
		Delay100TCYx(20);
		if(Speed>1){
			Speed--;
		}
	}
}
void LoadStr(unsigned rom char *string){
char x,y,z;
unsigned char temp = 0;

	for(x=0;x<120;x++){
		Buffer[x]=0;
	}

	for(x=0;x<20;x++){
		StringBuff[x]=0;
	}

	y=0;
	z=0;
	while(*string){
		StringBuff[z++]=*string;
		for(x=0;x<6;x++){
		temp = *string;
			Buffer[y+x]=Font[(temp-0x20)][x];
		}
		string++;
		y+=6;
	}
}
 
That y u used unsigned rom char Font[96][6] to search for LOADSTR.
What what i was going to do this "SUPRA" after executed, the compiler started searching for beginning of "S" character and continuing next to "STUVWXYZ" instead of "SUPRA"
Thank.
 
What i did was load the string into a variable called StringBuff so i can get the length of the string so i can place the correct amount of spaces in front and end so it scrolls in and out.... Then after that i have it look for each letter and place the whole letter in another buffer called BUFFER it does this to all the letters in the string this way it doesnt have to look for it everytime. It has it set and can just loop through BUFFER to display entire message.

The only thing is the 4017s are funny ... they dont work as i expected. They seem to be not accurate if you ask me. I might have to slow it down more... but you can always control speed anyway...

I tried using 74HC595 but was more work heh... I think if i had a 32 bit shift register it would be simpler.

EDIT:
I have to admit i must learn to stick to 1 thing at a time to ensure i fully grasp it to the point where i dont have to refer to the datasheet unless its for a pinout.
 
Last edited:
Status
Not open for further replies.

Similar threads

J
  • Question
How to find out RAM usage in Embedded Electronic Control Unit (ECU) ?
Replies
8
Views
2K
Nigel Goodwin
Nigel Goodwin
B
  • Question
Saving text data in *.txt file on sd card picaxe 20x2 microcontroler
Replies
7
Views
5K
Bartosz Wypych
B
sk001
  • Question
How to find the direction of target in complex environment?
Replies
7
Views
2K
sk001
sk001
A
ASM: Cure a 202 Warning - Argument out of range. Least significant bits used.
2
Replies
31
Views
4K
rjenkinsgb
rjenkinsgb
J
  • Question
Does J1939 standard require ECU to transmit binary one's for unused signals in a J1939 message?
Replies
15
Views
1K
jani12
J

Latest threads

New Articles From Microcontroller Tips

Back
Top