// const int columnPins[] = {10,11,12,15,16,17,18,19};
// const int rowPins[] = {2,3,4,5,6,7,8,9};

// int pixel = 0;
// int columnLevel = 0;
// int rowLevel = 0;

// void setup() {
//   // put your setup code here, to run once:
//   for (int i =0; i < 8; i++)
//   {
//     pinMode(columnPins[i], OUTPUT);
//     pinMode(rowPins[i], OUTPUT);
//   }
// }

// void loop() {
//   // put your main code here, to run repeatedly:
//   pixel += 1;
//   if (pixel > 63)
//     pixel = 0;
  
//   columnLevel = pixel / 8;
//   rowLevel = pixel % 8;

//   for (int column = 0; column < 8; column++)
//   {
//     digitalWrite(columnPins[column], LOW);
//     for (int row = 0; row < 8; row++)
//     {
//       if (columnLevel > column)
//       {
//         digitalWrite(rowPins[row], HIGH);
//       } 
//       else if (columnLevel == column && rowLevel >= row)
//       {
//         digitalWrite(rowPins[row], HIGH);
//       }
//       else
//       {
//         digitalWrite(columnPins[column], LOW);
//       }
//       delayMicroseconds(500);
//       digitalWrite(rowPins[row], LOW);
//     }
//     digitalWrite(columnPins[column], HIGH);
//   }
// }

/*

Q2. To design LED matrix with few features. Make a proper connection for 8×8 LED Matrix 
with resistors to the microcontroller. The LED matrix have to be constructed manually by using 
64  units  of  LED  as  8×8  LED  Matrix.    Display  your  name  and  scroll  from  right  to  left 
continuously. (Require demonstration) 

*/

#define ROW_1 2
#define ROW_2 3
#define ROW_3 4
#define ROW_4 5
#define ROW_5 6
#define ROW_6 7
#define ROW_7 8
#define ROW_8 9

#define COL_1 10
#define COL_2 11
#define COL_3 12
#define COL_4 15
#define COL_5 16
#define COL_6 17
#define COL_7 18
#define COL_8 19

const byte rows[] = {
    ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8
};
const byte col[] = {
  COL_1,COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8
};

byte ALL[] = {
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111
  };

byte EX[] = {
  B00000000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00000000,
  B00010000,
  B00000000
  };


byte A[] = {
  B00000000,
  B00111100,
  B01100110,
  B01100110,
  B01111110,
  B01100110,
  B01100110,
  B01100110
};

byte B[] = {
  B01111000,
  B01001000,
  B01001000,
  B01110000,
  B01001000,
  B01000100,
  B01000100,
  B01111100
  };

byte C[] = {
  B00000000,
  B00011110,
  B00100000,
  B01000000,
  B01000000,
  B01000000,
  B00100000,
  B00011110
  };

byte D[] = {
  B00000000,
  B00111000,
  B00100100,
  B00100010,
  B00100010,
  B00100100,
  B00111000,
  B00000000
  };

byte E[] = {
  B00000000,
  B00111100,
  B00100000,
  B00111000,
  B00100000,
  B00100000,
  B00111100,
  B00000000
  };

byte F[] = {
  B00000000,
  B00111100,
  B00100000,
  B00111000,
  B00100000,
  B00100000,
  B00100000,
  B00000000
  };

byte G[] = {
  B00000000,
  B00111110,
  B00100000,
  B00100000,
  B00101110,
  B00100010,
  B00111110,
  B00000000
  };

byte H[] = {
  B00000000,
  B00100100,
  B00100100,
  B00111100,
  B00100100,
  B00100100,
  B00100100,
  B00000000
  };

byte I[] = {
  B00000000,
  B00111000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00111000,
  B00000000
  };

byte J[] = {
  B00000000,
  B00011100,
  B00001000,
  B00001000,
  B00001000,
  B00101000,
  B00111000,
  B00000000
  };

byte K[] = {
  B00000000,
  B00100100,
  B00101000,
  B00110000,
  B00101000,
  B00100100,
  B00100100,
  B00000000
  };

byte L[] = {
  B00000000,
  B00100000,
  B00100000,
  B00100000,
  B00100000,
  B00100000,
  B00111100,
  B00000000
  };

byte M[] = {
  B00000000,
  B00000000,
  B01000100,
  B10101010,
  B10010010,
  B10000010,
  B10000010,
  B00000000
  };

byte N[] = {
  B00000000,
  B00100010,
  B00110010,
  B00101010,
  B00100110,
  B00100010,
  B00000000,
  B00000000
  };

byte O[] = {
  B00000000,
  B00111100,
  B01000010,
  B01000010,
  B01000010,
  B01000010,
  B00111100,
  B00000000
  };

byte P[] = {
  B00000000,
  B00111000,
  B00100100,
  B00100100,
  B00111000,
  B00100000,
  B00100000,
  B00000000
  };

byte Q[] = {
  B00000000,
  B00111100,
  B01000010,
  B01000010,
  B01000010,
  B01000110,
  B00111110,
  B00000001
  };

byte R[] = {
  B00000000,
  B00111000,
  B00100100,
  B00100100,
  B00111000,
  B00100100,
  B00100100,
  B00000000
  };

byte S[] = {
  B00000000,
  B00111100,
  B00100000,
  B00111100,
  B00000100,
  B00000100,
  B00111100,
  B00000000
  };

byte T[] = {
  B00000000,
  B01111100,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00000000
  };

byte U[] = {
  B00000000,
  B01000010,
  B01000010,
  B01000010,
  B01000010,
  B00100100,
  B00011000,
  B00000000
  };

byte V[] = {
  B00000000,
  B00100010,
  B00100010,
  B00100010,
  B00010100,
  B00010100,
  B00001000,
  B00000000
  };

byte W[] = {
  B00000000,
  B10000010,
  B10010010,
  B01010100,
  B01010100,
  B00101000,
  B00000000,
  B00000000
  };

byte X[] = {
  B00000000,
  B01000010,
  B00100100,
  B00011000,
  B00011000,
  B00100100,
  B01000010,
  B00000000
  };

byte Y[] = {
  B00000000,
  B01000100,
  B00101000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00000000
  };

byte Z[] = {
  B00000000,
  B00111100,
  B00000100,
  B00001000,
  B00010000,
  B00100000,
  B00111100,
  B00000000
  };

void setup() 
{
  Serial.begin(9600);
  
  for (byte i = 2; i <= 19; i++)
    pinMode(i, OUTPUT);
}

void loop() {
  drawScreen(A);
}

void  drawScreen(byte buffer2[]) { 
  for (byte i = 0; i < 8; i++) {
    digitalWrite(rows[i], HIGH);   
    for (byte a = 0; a < 8; a++) {
      digitalWrite(col[a], (~buffer2[i] >> a) & 0x01);
      delayMicroseconds(100);          
      digitalWrite(col[a], HIGH);
    }
    digitalWrite(rows[i], LOW);     
  }
}