Script

// defining all of the symbols
#define A {B01110000,B10001000,B10001000,B11111000,B10001000,B10001000}
#define B {B11110000,B10001000,B10001000,B11110000,B10001000,B11111000}
#define C {B11111000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define D {B11110000,B10001000,B10001000,B10001000,B10001000,B11110000}
#define E {B11111000,B10000000,B10000000,B11110000,B10000000,B11111000}
#define F {B11111000,B10000000,B10000000,B11110000,B10000000,B10000000}
#define G {B01110000,B10001000,B10000000,B10011000,B10001000,B01110000}
#define H {B10001000,B10001000,B11111000,B10001000,B10001000,B10001000}
#define I {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
#define J {B00111000,B00010000,B00010000,B00010000,B10010000,B01100000}
#define M {B10001000,B11011000,B10101000,B10101000,B10001000,B10001000}
#define N {B10001000,B11001000,B10101000,B10101000,B10011000,B10001000}
#define L {B10000000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define O {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define P {B11110000,B10001000,B10001000,B11110000,B10000000,B10000000}
#define Q {B01110000,B10001000,B10101000,B10011000,B01111000,B00001000}
#define R {B11110000,B10001000,B10001000,B11110000,B10001000,B10001000}
#define S {B01110000,B10001000,B01100000,B00010000,B10001000,B01110000}
#define K {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
#define T {B11111000,B00100000,B00100000,B00100000,B00100000,B00100000}
#define U {B10001000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define V {B10001000,B10001000,B10001000,B10001000,B01010000,B00100000}
#define W {B10001000,B10001000,B10101000,B10101000,B10101000,B01010000}
#define X {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
#define Y {B10001000,B01010000,B00100000,B00100000,B00100000,B00100000}
#define Z {B11111000,B00001000,B00110000,B01100000,B10000000,B11111000}
#define LA{B00000000,B01110000,B00001000,B01111000,B10001000,B01111000}
#define LB{B10000000,B10000000,B10110000,B11001000,B10001000,B11110000}
#define LC{B00000000,B01110000,B10000000,B10000000,B10001000,B01110000}
#define LD{B00001000,B00001000,B01111000,B10001000,B10001000,B01111000}
#define LE{B00000000,B01110000,B10001000,B11111000,B10000000,B01110000}
#define LF{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
#define LG{B00000000,B01111000,B10001000,B01111000,B00001000,B01110000}
#define LH{B10000000,B10000000,B10110000,B11001000,B10001000,B10001000}
#define LI{B00100000,B00000000,B01100000,B00100000,B00100000,B01111000}
#define LJ{B00010000,B00000000,B00111000,B00010000,B10010000,B01100000}
#define LK{B10000000,B10010000,B10100000,B11000000,B10100000,B10010000}
#define LL{B01100000,B00100000,B00100000,B00100000,B00100000,B01111000}
#define LM{B00000000,B00000000,B11010000,B10101000,B10101000,B10001000}
#define LN{B00000000,B00000000,B10110000,B11001000,B10001000,B10001000}
#define LO{B00000000,B01110000,B10001000,B10001000,B10001000,B01110000}
#define LP{B00000000,B11110000,B10001000,B11110000,B10000000,B10000000}
#define LQ{B00000000,B01101000,B10011000,B01111000,B00001000,B00001000}
#define LR{B00000000,B00000000,B10110000,B11001000,B10000000,B10000000}
#define LS{B00000000,B01110000,B10000000,B01110000,B00001000,B11110000}
#define LT{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
#define LU{B00000000,B00000000,B10001000,B10001000,B10011000,B01101000}
#define LV{B00000000,B00000000,B10001000,B10001000,B01010000,B00100000}
#define LW{B00000000,B00000000,B10001000,B10101000,B10101000,B01010000}
#define LX{B00000000,B10001000,B01010000,B00100000,B01010000,B10001000}
#define LY{B00000000,B10001000,B10001000,B01111000,B00001000,B01110000}
#define LZ{B00000000,B11111000,B00010000,B00100000,B01000000,B11111000}
#define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define NUM0{B01110000,B10011000,B10101000,B10101000,B11001000,B01110000}
#define DEVIDE{B00001000,B00010000,B00100000,B00100000,B01000000,B10000000}
#define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
#define DOT{B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
#define COMA{B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
#define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
#define QUASTION{B01110000,B10001000,B00010000,B00100000,B00000000,B00100000}
#define MARK{B00100000,B01110000,B01110000,B00100000,B00000000,B00100000}
int latchPin = 10; //latch pin of the shift register

int clockPin = 13; //clock pin of the shift register
int dataPin = 11; //data pin of the shift register
int clock = 9; //clock pin of the 4017 counter
int Reset = 8; //reset pin of the 4017 counter
// setting the pins for easy operation with PORTB

int latchPinPORTB = latchPin - 8;
int clockPinPORTB = clockPin - 8;
int dataPinPORTB = dataPin - 8;

int i = 0;
int incomingByte[44];// the incoming words go here
byte scrolling_word[6][3];// this is for the scrolling text
int array_turn=0;
byte patterns[100][6];
byte dummy_array[70][6]
={A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,SPACE,NUM0,NUM1,NUM2,NUM3,NUM4,NU
M5,NUM6,NUM7,NUM8,NUM9,DEVIDE,TWODOTS,DOT,COMA,LINE,QUASTION,MARK,LA,LB,LC,LD,L
E,LF,LG,LH,LI,LJ,LK,LL,LM,LN,LO,LP,LQ,LR,LS,LT,LU,LV,LW,LX,LY,LZ};
void setup(){
Serial.begin(9600);//starting communicatino with the PC at 9600 boud
// config for all the pins
pinMode(dataPin,OUTPUT);
pinMode(clockPin,OUTPUT);
pinMode(latchPin,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(Reset,OUTPUT);
//reseting the 4017 counter
digitalWrite(Reset,HIGH);
digitalWrite(Reset,LOW);
setupSPI();//starting SPI communication
}
void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){ // the main

funcion for displaying and scrolling the word
i = 0;
for(int first=0;first<6;first++){ // reseting the scrolling_word array
for(int second=0;second<5;second++)
scrolling_word[first][second] = 0x00;
}
for(int x=0;x<num_patterns;x++){//main loop that goes over all of the symbols

for(int scroll=0;scroll<6;scroll++){// loop for scrolling, each symbols scrolls for 6 columns
for(int r=0;r<6;r++){//going over all of the rows
// this is the scrolling function it's like making a 3 byte word to scroll al once.
scrolling_word[r][2] = (scrolling_word[r][2] << 1)+((scrolling_word[r][1] & 0x80) >> 7);
scrolling_word[r][1] = (scrolling_word[r][1] << 1)+((scrolling_word[r][0] & 0x80) >> 7);
scrolling_word[r][0] = (scrolling_word[r][0] << 1)+(((word_print[x][r]<<scroll)&0x80)>>7);
}
for(int t=0;t<delay_langth;t++){// a delay loop that just shows the same frame over and over to
create a delay
for(int y=0;y<6;y++){// the scaning loop that goes over all 6 rows
if(i == 6){//if the 4017 counter counts up to 6 reset it
i = 0;// resetinf the counter
}
latchOff();// starint the communication with the shift registers
spi_transfer(scrolling_word[y][2]);// sending info
spi_transfer(scrolling_word[y][1]);
latchOn();
delayMicroseconds(800);//a small delay for each row
latchOff();// clearing the shift registers to make sure we will not get a ghosting effect
spi_transfer(0);
spi_transfer(0);
spi_transfer(0);
latchOn();
// advensing the 4017 counter by one( we just send a positive pulse)
digitalWrite(clock,HIGH);
digitalWrite(clock,LOW);
i++;
}
}
}
}
finish_scroll(delay_langth);// calling for a function to finish scrolling the last 4 symbols
}
void finish_scroll(int delay_scroll){// this function finishs the scrolling and it's very similar to the
display_word function
for (int n=0;n<26;n++){
for(int h=0;h<6;h++){
scrolling_word[h][2] = (scrolling_word[h][2] << 1) | ((scrolling_word[h][1] & 0x80) >> 7);
scrolling_word[h][1] = (scrolling_word[h][1] << 1) | ((scrolling_word[h][0] & 0x80) >> 7);
scrolling_word[h][0] = (scrolling_word[h][0] << 1) | 0 ;
}
for(int t=0;t<delay_scroll;t++){
for(int y=0;y<6;y++){
if(i == 6){
i = 0;
}
latchOff();
latchOn();
delayMicroseconds(800);
latchOff();
spi_transfer(0);
spi_transfer(0);
spi_transfer(0);
latchOn();
digitalWrite(clock,HIGH);
digitalWrite(clock,LOW);
i++;
}
}
}
}
void loop() {
// send data only when you receive data:

if(Serial.available() > 0){
delay(100);
incomingByte[array_turn] = Serial.read();// putting the symbol in the array
array_turn++;//counting the number of incomming symbols

}
else{
//this part is for getting the info we got and putting it in a form we could work with
if(array_turn != 0){
for(int az=0;az<array_turn;az++){//for latters
if((incomingByte[az] > 64 && incomingByte[az] < 91) || (incomingByte[az] > 96 &&
incomingByte[az] < 123)){
if(incomingByte[az] > 64 && incomingByte[az] < 91){
for(int lal=0;lal<6;lal++)
patterns[az][lal] = dummy_array[incomingByte[az] - 65][lal];
}
else{//for numbers
for(int lal=0;lal<6;lal++)
patterns[az][lal] = dummy_array[incomingByte[az] - 53][lal];
}}
else{// for odd symbols
switch(incomingByte[az]){
case 32://space
for(int lol=0;lol<6;lol++)
patterns[az][lol] = dummy_array[26][lol];
break;
case 33://mark
break;
case 45://line
break;
case 44://coma
break;
case 46://dot
break;
case 47://dvide
break;
case 48://0
break;
case 49://1
break;
case 50://2
break;
case 51://3
break;
case 52://4
break;
case 53://5
break;
case 54://6
break;
case 55://7
break;
case 56://8
break;
case 57://9
break;
case 58://tow dots

break;
case 63://quastion
break;
default:
break;
}
}
}
}
display_word(1,patterns,array_turn,15);
array_turn =0;
}
}
//display_word(1,patterns,43,15);// calls for the display_pattern function and says that int loop =
15(if you do more loop the pattern whould scrrol slower).
void latchOn(){
bitSet(PORTB,latchPinPORTB);
}
void latchOff(){
bitClear(PORTB,latchPinPORTB);
}
void setupSPI(){// setting all the registers for SPI cummunication

byte clr;
SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
//SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
SPCR &= ~( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
clr=SPSR; // clear SPI status reg
clr=SPDR; // clear SPI data reg
SPSR |= (1<<SPI2X); // set prescaler bits
//SPSR &= ~(1<<SPI2X); // clear prescaler bits
delay(10);
}
byte spi_transfer(byte data)
{
SPDR = data;
while (!(SPSR & (1<<SPIF)))
// Start the transmission

// Wait the end of the transmission
{
};
return SPDR;
}
// return the received byte, we don't need that

Script

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Script

Uploaded by

Copyright:

Available Formats

// defining all of the symbols

int latchPin = 10; //latch pin of the shift register

// setting the pins for easy operation with PORTB

int dataPinPORTB = dataPin - 8;

void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){ // the main

for(int x=0;x<num_patterns;x++){//main loop that goes over all of the symbols

// send data only when you receive data:

array_turn++;//counting the number of incomming symbols

case 58://tow dots

void setupSPI(){// setting all the registers for SPI cummunication

// Start the transmission

// return the received byte, we don't need that

You might also like