Go Down

Topic: Arduino Scrolling 56x8 LED matrix (Read 29 times) previous topic - next topic

fatalkeyv

hi Hari!

ive replicate your led matrix using your codes and only 74HC595 on both sides

but for some reason the output i got inverted and not like yours?

is there any reason for that?

spikie

hey,
maybe i can help ;)

  if (isOn)
   bitmap[row][zone] =  bitmap[row][zone] | colBit;
 else
   bitmap[row][zone] =  bitmap[row][zone] & (~colBit);

change the | colBit; with the & (~colBit); in the code and try again?

fatalkeyv

#47
Dec 17, 2010, 07:22 pm Last Edit: Dec 17, 2010, 07:54 pm by fatalkeyv Reason: 1
thanks!

ive added a switch, i can invert the fonts as i wish now =)

perast

hi

I try to use numbers and letters, but does not work. Is there anyone who can help me?


Code: [Select]
/*
  Arduino 56x8 scrolling LED Matrix
 
Scrolls any message on up to seven (or more?) 8x8 LED matrices.
Adjust the bitmap array below to however many matrices you want to use.
You can start with as few as two.

The circuit:
* 1 8-bit shift register (SN74HC595) to drive the rows of all displays.
* N power 8-bit shift registers (TPIC6C595) to drive the columns (1 chip per display)
* N 8x8 LED matrix display (rows=Anodes, cold=cathodes)
* N * 8 470ohm resistors, one for each column of each display
* 1 10K resistor
* A big breadboard, or several small ones
* Lots and lots of wires. AT LEAST 16 wires for each display.
* If you plan on driving more than 8 displays, you should add 8 transistors to drive the rows because
potentially you would be lighting up the whole row at one time (56 LEDs at once in my case, 8*n in your case)

Wiring tips:
* Key to success is to put the chips on the left and/or right of the matrix rather than above or below.
This would allow you to run wires above and below the matrix without covering any of them.
* I used several power bus breadboard strips above and below the matrix so all row wires never has to cross the matrix.
* Wire up each matrix one at a time, turning on the Ardunio to verify your work before proceeding to the next matrix.
Correcting your work after you have 32 wires over it is very difficult.
* Circuit is available at:
http://g33k.blogspot.com/2010/02/arduino-56x8-scrolling-led-matrix.html

Created Feb 2010
By Hari Wiguna
http://g33k.blogspot.com/

Based on things I learn from the Arduino website.
Special credit to aspro648 creating the alphabet that I use.
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1203747843/22

Creative Commons Attribution-Share Alike 3.0 United States License

*/
// I kept these version notes to show you that it doesn't just all magically happen.  I start simple and keep adding more.
//v01 - Just see if we can drive one matrix, one dot at a time.  Forget multiplexing for now.
//v02 - All three displays show same pattern because they are all tied to same data line.
//v03 - Second and third 595 inputs are tied to outputs of previous, so now shiftout three bytes instead of one.
//v04 - Let's multiplex.  This version has no bleeding, but still flickers quite a bit.
//v05 - Flicker is reduced by using delayMicroseconds() instead of delay().  Flipping both latches HIGH at same time increases brightess of all LEDs.
//v06 - let's animate! (none of this code is in v09, I removed them because they're unrelated to the marquee.
//v07 - We got a scrolling message marquee!
//v08 - Now with SEVEN matrices! 56x8 pixels
//v09 - Add comments and remove experimental code
//v10 - Fixed search and replace error in Plot.  Thanks to Capacea for catching this error.

//-- Columns (Negative Cathodes) --
int latchPin1 = 2; //Arduino pin connected to Green 10 RCK of TPIC6C595
int clockPin1 = 3; //Arduino pin connected to Yellow 15 SRCK of TPIC6C595
int dataPin1 = 4;  //Arduino pin connected to Blue 2 SER IN of TPIC6C595

//-- Rows (Positive Anodes) --
int latchPin2 = 5; //Arduino pinn connected to Green Latch 12 ST_CP / RCK of 74HC595
int clockPin2 = 6; //Arduino pin connected to Yellow Clock 11 SH_CP / SCK of 74HC595
int dataPin2 = 7;  //Arduino pin connected to Blue Data 14 DS / SI of 74HC595

//=== B I T M A P ===
//Bits in this array represents one LED of the matrix
// 8 is # of rows, 7 is # of LED matrix we have
byte bitmap[8][4]; // Change the 7 to however many matrices you want to use.
int numZones = sizeof(bitmap) / 8; // I will refer to each group of 8 columns (represented by one matrix) as a Zone.
int maxZoneIndex = numZones-1;
int numCols = numZones * 8;

//=== F O N T ===
// Font courtesy of aspro648
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1203747843/22
// First char is @, next is A, B, etc.  Only lower case, no symbols. 
// The @ will display as space character.
byte alphabets[][5] = {
  {0,0,0,0,0},                          // spatie      ASCII 32
  {0,0,253,0,0},                        // uitroepteken  ASCII 33
  {0,96,0,96,0},                        // "           ASCII 34
  {20,127,20,127,20},                   // #           ASCII 35
  {36,42,127,42,18},                    // $           ASCII 36
  {17,2,4,8,17},                        // %           ASCII 37
  {54,73,85,34,5},                      // &           ASCII 38
  {0,0,104,112,0},                      // '           ASCII 39
  {28,34,65},                           // (           ASCII 40
  {65,34,28},                           // )           ASCII 41
  {20,8,62,8,20},                       // *           ASCII 42
  {8,8,62,8,8},                         // +           ASCII 43
  {0,0,5,6,0},                          // ,           ASCII 44
  {8,8,8,8,8},                          // -           ASCII 45
  {0,0,1,0,0},                          // .           ASCII 46
  {1,2,4,8,16},                         // /           ASCII 47
  {62,69,73,81,62},                     // 0           ASCII 48
  {0,33,127,1,0},                       // 1           ASCII 49
  {33,67,69,73,49},                     // 2           ASCII 50
  {66,65,81,105,70},                    // 3           ASCII 51
  {12,20,36,127,4},                     // 4           ASCII 52
  {113,81,81,81,78},                    // 5           ASCII 53
  {30,41,73,73,6},                      // 6           ASCII 54
  {64,64,79,80,96},                     // 7           ASCII 55
  {54,73,73,73,54},                     // 8           ASCII 56
  {48,73,73,74,60},                     // 9           ASCII 57
  {0,0,54,54,0},                        // :           ASCII 58
  {0,0,53,54,0},                        // ;           ASCII 59
  {0,8,20,34,65},                       // <           ASCII 60
  {20,20,20,20,20},                     // =           ASCII 61
  {0,65,34,20,8},                       // >           ASCII 62
  {32,64,69,72,48},                     // ?           ASCII 63
  {38,73,77,65,62},                     // @           ASCII 64
  {31,36,68,36,31},                     // A           ASCII 65
  {127,73,73,73,54},                    // B           ASCII 66
  {62,65,65,65,34},                     // C           ASCII 67
  {127,65,65,34,28},                    // D           ASCII 68
  {127,73,73,65,65},                    // E           ASCII 69
  {127,72,72,72,64},                    // F           ASCII 70
  {62,65,65,69,38},                     // G           ASCII 71
  {127,8,8,8,127},                      // H           ASCII 72
  {0,65,127,65,0},                      // I           ASCII 73
  {2,1,1,1,126},                        // J           ASCII 74
  {127,8,20,34,65},                     // K           ASCII 75
  {127,1,1,1,1},                        // L           ASCII 76
  {127,32,16,32,127},                   // M           ASCII 77
  {127,32,16,8,127},                    // N           ASCII 78
  {62,65,65,65,62},                     // O           ASCII 79
  {127,72,72,72,48},                    // P           ASCII 80
  {62,65,69,66,61},                     // Q           ASCII 81
  {127,72,76,74,49},                    // R           ASCII 82
  {50,73,73,73,38},                     // S           ASCII 83
  {64,64,127,64,64},                    // T           ASCII 84
  {126,1,1,1,126},                      // U           ASCII 85
  {124,2,1,2,124},                      // V           ASCII 86
  {126,1,6,1,126},                      // W           ASCII 87
  {99,20,8,20,99},                      // X           ASCII 88
  {96,16,15,16,96},                     // Y           ASCII 89
  {67,69,73,81,97},                     // Z           ASCII 90
  {0,127,65,65,0},                      // [           ASCII 91
  {0,0,0,0,0},                          // \           ASCII 92
  {0,65,65,127,0},                      // ]           ASCII 93
  {16,32,64,32,16},                     // ^           ASCII 94
  {1,1,1,1,1},                          // _           ASCII 95
  {0,64,32,16,0},                       // `           ASCII 96
  {2,21,21,21,15},                      // a           ASCII 97
  {127,5,9,9,6},                        // b           ASCII 98
  {14,17,17,17,2},                      // c           ASCII 99
  {6,9,9,5,127},                        // d           ASCII 100
  {14,21,21,21,12},                     // e           ASCII 101
  {8,63,72,64,32},                      // f           ASCII 102
  {24,37,37,37,62},                     // g           ASCII 103
  {127,8,16,16,15},                     // h           ASCII 104
  {0,0,47,0,0},                         // i           ASCII 105
  {2,1,17,94,0},                        // j           ASCII 106
  {127,4,10,17,0},                      // k           ASCII 107
  {0,65,127,1,0},                       // l           ASCII 108
  {31,16,12,16,31},                     // m           ASCII 109
  {31,8,16,16,15},                      // n           ASCII 110
  {14,17,17,17,14},                     // o           ASCII 111
  {31,20,20,20,8},                      // p           ASCII 112
  {8,20,20,12,31},                      // q           ASCII 113
  {31,8,16,16,8},                       // r           ASCII 114
  {2,21,21,21,9},                       // s           ASCII 115
  {16,126,17,1,2},                      // t           ASCII 116
  {30,1,1,2,31},                        // u           ASCII 117
  {28,2,1,2,28},                        // v           ASCII 118
  {30,1,6,1,30},                        // w           ASCII 119
  {17,10,4,10,17},                      // x           ASCII 120
  {24,5,5,5,30},                        // y           ASCII 121
  {17,19,21,25,17},                     // z           ASCII 122
  {0,0,8,54,65},                        // {           ASCII 123
  {0,0,127,0,0},                        // |           ASCII 124
  {65,54,8,0,0},                        // }           ASCII 125
};


//=== S E T U P ===

void setup() {
  pinMode(latchPin1, OUTPUT);
  pinMode(clockPin1, OUTPUT);
  pinMode(dataPin1, OUTPUT);

  pinMode(latchPin2, OUTPUT);
  pinMode(clockPin2, OUTPUT);
  pinMode(dataPin2, OUTPUT);
 
  //-- Clear bitmap --
  for (int row = 0; row < 8; row++) {
    for (int zone = 0; zone <= maxZoneIndex; zone++) {
      bitmap[row][zone] = 255;
    }
  }
}

//=== F U N C T I O N S ===

// This routine takes whatever we've setup in the bitmap array and display it on the matrix
void RefreshDisplay()
{
  for (int row = 0; row < 8; row++) {
    int rowbit = 1 << row;
    digitalWrite(latchPin2, LOW);  //Hold latchPin LOW for as long as we're transmitting data
    shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit);   //Transmit data

    //-- Start sending column bytes --
    digitalWrite(latchPin1, LOW);  //Hold latchPin LOW for as long as we're transmitting data

    //-- Shift out to each matrix (zone is 8 columns represented by one matrix)
    for (int zone = maxZoneIndex; zone >= 0; zone--) {
      shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]);
    }

    //-- Done sending Column bytes, flip both latches at once to eliminate flicker
    digitalWrite(latchPin1, HIGH);  //Return the latch pin high to signal chip that it no longer needs to listen for information
    digitalWrite(latchPin2, HIGH);  //Return the latch pin high to signal chip that it no longer needs to listen for information

    //-- Wait a little bit to let humans see what we've pushed out onto the matrix --
    delayMicroseconds(500);
  }
}

// Converts row and colum to actual bitmap bit and turn it off/on
void Plot(int col, int row, bool isOn)
{
  int zone = col / 8;
  int colBitIndex = col % 8;
  byte colBit = 1 << colBitIndex;
  if (isOn)
    bitmap[row][zone] =  bitmap[row][zone] & (~colBit);
  else
    bitmap[row][zone] =  bitmap[row][zone] | colBit;
}

// Plot each character of the message one column at a time, updated the display, shift bitmap left.
void AlphabetSoup()
{
  char msg[] = "!#$%&-=0123456789ABCDEFGHIJKLMNOPQRSTUVXY ";

  for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++)
  {
    int alphabetIndex = msg[charIndex] - '0';
    if (alphabetIndex < 0) alphabetIndex=0;
   
    //-- Draw one character of the message --
    // Each character is only 5 columns wide, but I loop two more times to create 2 pixel space betwen characters
    for (int col = 0; col < 7; col++)
    {
      for (int row = 0; row < 8; row++)
      {
        // Set the pixel to what the alphabet say for columns 0 thru 4, but always leave columns 5 and 6 blank.
        bool isOn = 0;
        if (col<5) isOn = bitRead( alphabets[alphabetIndex][col], 7-row ) == 1;
        Plot( numCols-1, row, isOn); // We ALWAYS draw on the rightmost column, the shift loop below will scroll it leftward.
      }
     
      //-- The more times you repeat this loop, the slower we would scroll --
      for (int refreshCount=0; refreshCount < 10; refreshCount++)
        RefreshDisplay();

      //-- Shift the bitmap one column to left --
      for (int row=0; row<8; row++)
      {
        for (int zone=0; zone < numZones; zone++)
        {
          // This right shift would show as a left scroll on display because leftmost column is represented by least significant bit of the byte.
          bitmap[row][zone] = bitmap[row][zone] >> 1;
         
          // Roll over lowest bit from the next zone as highest bit of this zone.
          if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone+1],0));
        }
      }
    }
  }
}

//=== L O O P ===

void loop() {
  AlphabetSoup();
}
 
 
 

Go Up