Arduino LED Clock

This is a discussion on Arduino LED Clock within the C++ Programming forums, part of the General Programming Boards category; I just built a 24x6 LED Matrix and it's made to scroll words across the LEDs. The words can be ...

  1. #1
    Registered User
    Join Date
    Oct 2011
    Posts
    7

    Arduino LED Clock

    I just built a 24x6 LED Matrix and it's made to scroll words across the LEDs. The words can be changed with the program that was provided to us but I want to take it further. Is there any way I can make it display the time or date? I really have no experience with coding so I might be asking a little much here. Here's the given code:

    Code:
    #define A {B10001000,B10001000,B11111000,B10001000,B10001000,B01110000}                                            }
    #define B {B11110000,B10001000,B10001000,B11110000,B10001000,B11110000}
    #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 {B10000000,B10000000,B11110000,B10000000,B10000000,B11111000}
    #define G {B01110000,B10001000,B10011000,B10000000,B10001000,B01110000}
    #define H {B10001000,B10001000,B10001000,B11111000,B10001000,B10001000}
    #define I {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
    #define J {B01100000,B00010000,B00010000,B00010000,B00010000,B00111000}
    #define M {B10001000,B10001000,B10101000,B10101000,B11011000,B10001000}
    #define N {B10001000,B10011000,B10101000,B10101000,B11001000,B10001000}
    #define L {B11111000,B10000000,B10000000,B10000000,B10000000,B10000000}
    #define O {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
    #define P {B10000000,B10000000,B11110000,B10001000,B10001000,B11110000}
    #define Q {B01101000,B10010000,B10101000,B10001000,B10001000,B01110000}
    #define R {B10001000,B10001000,B11110000,B10001000,B10001000,B11110000}
    #define S {B01110000,B10001000,B00010000,B01100000,B10001000,B01110000}
    #define K {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
    #define T {B00100000,B00100000,B00100000,B00100000,B00100000,B11111000}
    #define U {B01110000,B10001000,B10001000,B10001000,B10001000,B10001000}
    #define V {B00100000,B01010000,B10001000,B10001000,B10001000,B10001000}
    #define W {B01010000,B10101000,B10101000,B10101000,B10001000,B10001000}
    #define X {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
    #define Y {B00100000,B00100000,B00100000,B00100000,B01010000,B10001000}
    #define Z {B11111000,B10000000,B01100000,B00110000,B00001000,B11111000}
    #define LA{B01111000,B10001000,B01111000,B00001000,B01110000,B00000000}
    #define LB{B11110000,B10001000,B11001000,B10110000,B10000000,B10000000}
    #define LC{B01110000,B10001000,B10000000,B10000000,B01110000,B00000000}
    #define LD{B01111000,B10001000,B10001000,B01111000,B00001000,B00001000}
    #define LE{B01110000,B10000000,B11111000,B10001000,B01110000,B00000000}
    #define LF{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
    #define LG{B01110000,B00001000,B01111000,B10001000,B01111000,B00000000}
    #define LH{B10001000,B10001000,B11001000,B10110000,B10000000,B10000000}
    #define LI{B01111000,B00100000,B00100000,B01100000,B00100000,B00100000}
    #define LJ{B01100000,B10010000,B00010000,B00111000,B00000000,B00010000}
    #define LK{B10010000,B10100000,B11000000,B10100000,B10010000,B10000000}
    #define LL{B01111000,B00100000,B00100000,B00100000,B00100000,B01100000}
    #define LM{B10001000,B10101000,B10101000,B11010000,B00000000,B00000000}
    #define LN{B10001000,B10001000,B11001000,B10110000,B00000000,B00000000}
    #define LO{B01110000,B10001000,B10001000,B10001000,B01110000,B00000000}
    #define LP{B10000000,B10000000,B11110000,B10001000,B11110000,B00000000}
    #define LQ{B00001000,B00001000,B01111000,B10011000,B01101000,B00000000}
    #define LR{B10000000,B10000000,B11001000,B10110000,B00000000,B00000000}
    #define LS{B11110000,B00001000,B01110000,B10000000,B01110000,B00000000}
    #define LT{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
    #define LU{B01101000,B10011000,B10001000,B10001000,B00000000,B00000000}
    #define LV{B00100000,B01010000,B10001000,B10001000,B00000000,B00000000}
    #define LW{B01010000,B10101000,B10101000,B10001000,B00000000,B00000000}
    #define LX{B10001000,B01010000,B00100000,B01010000,B10001000,B00000000}
    #define LY{B01110000,B00001000,B01111000,B10001000,B10001000,B00000000}
    #define LZ{B11111000,B01000000,B00100000,B00010000,B11111000,B00000000}
    #define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
    #define NUM0{B01110000,B11001000,B10101000,B10101000,B10011000,B01110000}
    #define NUM1{B01110000,B00100000,B00100000,B10100000,B01100000,B00100000}
    #define NUM2{B1111000,B10000000,B01110000,B00001000,B10001000,B01110000}
    #define NUM3{B11110000,B00001000,B01111000,B00001000,B00001000,B11110000}
    #define NUM4{B00001000,B00001000,B11111000,B10001000,B10001000,B10001000}
    #define NUM5{B01110000,B10001000,B00001000,B11110000,B10000000,B11111000}
    #define NUM6{B11111000,B10001000,B10001000,B11111000,B10000000,B11111000}
    #define NUM7{B00001000,B00001000,B01111000,B00001000,B00001000,B11111000}
    #define NUM8{B11111000,B10001000,B10001000,B11111000,B10001000,B11111000}
    #define NUM9{B11111000,B00001000,B00001000,B11111000,B10001000,B11111000}
    #define DIVIDE{B10000000,B01000000,B00100000,B00100000,B00010000,B00001000}
    #define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
    #define DOT{B01100000,B01100000,B00000000,B00000000,B00000000,B00000000}
    #define COMA{B00110000,B00110000,B00110000,B00000000,B00000000,B00000000}
    #define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
    #define QUESTION{B00100000,B00000000,B00100000,B00010000,B10001000,B01110000}
    #define MARK{B00100000,B00000000,B00100000,B01110000,B01110000,B00100000}
    //IF YOU WANT TO MAKE ANY MORE SYMBOLS (SMILEY FACES, ETC.) YOU WOULD NEED TO DEFINE THEM IN THIS LOCATION
    
    
    int latchPin = 10;
    int clockPin = 13;
    int dataPin = 11;
    int clock = 9;
    int Reset = 8;
    int latchPinPORTB = latchPin - 8;
    int clockPinPORTB = clockPin - 8;
    int dataPinPORTB = dataPin - 8;
    int i = 0;
    long scrolling_word[6];
    int array_turn=0;
    byte your_text[15][6]={D,O,SPACE,N,O,T,SPACE,D,I,S,T,U,R,B};//THIS IS THE PLACE THAT YOU TYPE YOUR DESIRED TEXT, 
    //MAKE SURE TO USE THE CORRECTLY NAMED SYMBOLS THAT YOU INITIALIZED UP ABOVE
    
    
    
    
    void setup(){
      Serial.begin(9600);
      pinMode(dataPin,OUTPUT);
      pinMode(clockPin,OUTPUT);
      pinMode(latchPin,OUTPUT);
      pinMode(clock,OUTPUT);
      pinMode(Reset,OUTPUT);
      digitalWrite(Reset,HIGH);
      digitalWrite(Reset,LOW);
      setupSPI();
    }
    
    
    void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){// this function displays your symbols
      i = 0;// resets the counter fot the 4017
      for(int g=0;g<6;g++)//resets the the long int where your word goes
        scrolling_word[g] = 0;
      for(int x=0;x<num_patterns;x++){//main loop, goes over your symbols
       // you will need to find a better way to make the symbols scroll my way is limited for 24 columns
    
    
       for(int r=0;r<6;r++)//puts the buildes the first symbol
          scrolling_word[r] |= word_print[x][r]; 
        for (int z=0;z<6;z++){//the sctolling action
            for(int p=0;p<6;p++)
              scrolling_word[p] = scrolling_word[p] << 1;
    // end of the scrolling funcion
          for(int t=0;t<delay_langth;t++){// delay function, it just loops over the same display
            for(int y=0;y<6;y++){// scaning the display
              if(i == 6){// counting up to 6 with the 4017
                digitalWrite(Reset,HIGH);
                digitalWrite(Reset,LOW);
                i = 0;
              }
              latchOff();
              spi_transfer(make_word(0x01000000,y));// sending the data
              spi_transfer(make_word(0x00010000,y));
              spi_transfer(make_word(0x00000100,y));
              latchOn();
              delayMicroseconds(800);//waiting a bit
              latchOff();
              spi_transfer(0);// clearing the data
              spi_transfer(0);
              spi_transfer(0);
              latchOn();
              digitalWrite(clock,HIGH);//counting up with the 4017
              digitalWrite(clock,LOW);
              i++;
            }
          }
        }
      }
      finish_scroll(delay_langth);
    }
    
    
    void finish_scroll(int delay_scroll){// this function is the same as the funcion above, it just finishing scrolling
      for (int n=0;n<24;n++){
            for(int h=0;h<6;h++)
              scrolling_word[h] = scrolling_word[h] << 1;
          for(int w=0;w<delay_scroll;w++){
            for(int k=0;k<6;k++){
              if(i == 6){
                digitalWrite(Reset,HIGH);
                digitalWrite(Reset,LOW);
                i = 0;
              }
              latchOff();
              spi_transfer(make_word(0x01000000,k));
              spi_transfer(make_word(0x00010000,k));
              spi_transfer(make_word(0x00000100,k));
              latchOn();
              delayMicroseconds(800);
              latchOff();
              spi_transfer(0);
              spi_transfer(0);
              spi_transfer(0);
              latchOn();
              digitalWrite(clock,HIGH);
              digitalWrite(clock,LOW);
              i++;
            }
          }
        }
    }
    
    
    byte make_word (long posistion,byte turn){
      byte dummy_word = 0;
      for(int q=0;q<8;q++){
        if(scrolling_word[turn] & (posistion<<q))
          dummy_word |= 0x01<<q;
      }
      return dummy_word;
    }   
    
    
    
    
      void loop() {
    
    
            display_word(1,your_text,14,15); //IF YOU CHANGE THE TEXT, YOU ALSO NEED TO UPDATE THE TEXT STRING LENGTH, DO THAT HERE.
           // TO DO IT, CHANGE THE 13 TO HOW EVER LONG YOUR STATEMENT IS.
            // calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrole slower).
       
           }
      
      
    
    
    void latchOn(){
      bitSet(PORTB,latchPinPORTB);
    }
    
    
    void latchOff(){
      bitClear(PORTB,latchPinPORTB);
    }
    
    
    
    
    void setupSPI(){
      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;              // Start the transmission
      while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
      {
      };
      return SPDR;              // return the received byte, we don't need that
    }

  2. #2
    Registered User
    Join Date
    Sep 2011
    Posts
    38
    I haven't played with Arduino for a long time, but this might help. Getting local time from window using C++

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Arduino project programming question
    By qtip2293 in forum C++ Programming
    Replies: 10
    Last Post: 10-10-2011, 04:57 PM
  2. moving multiple servos through Arduino board
    By cross-side in forum C Programming
    Replies: 26
    Last Post: 02-17-2011, 11:08 PM
  3. Arduino programming
    By Terese in forum C++ Programming
    Replies: 5
    Last Post: 12-11-2010, 01:03 PM
  4. #if !CLOCK
    By rsockey in forum C Programming
    Replies: 4
    Last Post: 11-10-2009, 12:51 PM
  5. clock
    By leinad079 in forum C Programming
    Replies: 2
    Last Post: 04-12-2003, 10:10 AM

Tags for this Thread


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21