Main program for 32x32 Bicolor Led Matrix using B.A.M - 4 bit method

BAM_32x32_BICOLOR_MATRIX

//************************************************************************************************************//
  
//********************* THE 32x32 BICOLOR RG LED MATRIX USING BIT ANGLE MODULATION METHOD ********************//

//************************************************************************************************************//
#include <SPI.h>
#include "bitmap.h"

#define blank_pin 3   // Defines actual BIT of PortD for blank - is Arduino UNO pin 3, MEGA pin 5
#define latch_pin 2   // Defines actual BIT of PortD for latch - is Arduino UNO pin 2, MEGA pin 4
#define clock_pin 13  // used by SPI, must be 13 SCK 13 on Arduino UNO, 52 on MEGA
#define data_pin 11   // used by SPI, must be pin MOSI 11 on Arduino UNO, 51 on MEGA

#define RowA_Pin 4
#define RowB_Pin 5
#define RowC_Pin 6
#define RowD_Pin 7

byte red[4][128];
byte green[4][128];

int level=0;//keeps track of which level we are shifting data to
int row=0;
int BAM_Bit, BAM_Counter=0; // Bit Angle Modulation variables to keep track of things

/**   An RG color template */
struct Color
{
  unsigned char red, green;

  Color(int r, int g) : red(r), green(g) {}
  Color() : red(0), green(0) {}
};

const Color redcolor       = Color(0x0F,0x00);
const Color orangecolor    = Color(0x0F,0x0F);
const Color yellowcolor    = Color(0x0F,0x09);
const Color greencolor     = Color(0x00,0x0F);
const Color clearcolor     = Color(0x00,0x00);

#define RED     0x0F,0x00
#define ORANGE  0x0F,0x04
#define YELLOW  0x0F,0x09
#define GREEN   0x00,0x0F
#define CLEAR   0x00,0x00

void setup()
{
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
SPI.setClockDivider(SPI_CLOCK_DIV2);

noInterrupts();

TCCR1A = B00000000;
TCCR1B = B00001011;
TIMSK1 = B00000010;
OCR1A = 20;

pinMode(latch_pin, OUTPUT);
pinMode(blank_pin, OUTPUT);
pinMode(data_pin, OUTPUT);
pinMode(clock_pin, OUTPUT);

pinMode(RowA_Pin, OUTPUT);
pinMode(RowB_Pin, OUTPUT);
pinMode(RowC_Pin, OUTPUT);
pinMode(RowD_Pin, OUTPUT);

SPI.begin();
interrupts();
}

void loop()
{
  for(int i=0; i<20; i++)
  {
    drawImage(32, 32, TIGER01, clearcolor, redcolor);
    delay(80);
    drawImage(32, 32, TIGER02, clearcolor, redcolor);
    delay(80);
    drawImage(32, 32, TIGER03, clearcolor, redcolor);
    delay(80);
    drawImage(32, 32, TIGER04, clearcolor, redcolor);
    delay(80);
    drawImage(32, 32, TIGER05, clearcolor, redcolor);
    delay(80);
    drawImage(32, 32, TIGER06, clearcolor, redcolor);
    delay(80); 
  }

  clearfast();
  for (int x = 0; x < 32; x++)
  {
    for (int y = 0; y < 32; y++)
    {
      LED(x,y,int (x/2),int (y/2));
      delay(50);
    }
  }
  delay(5000);
  clearfast();
  fillTable(4,8);
  delay(5000);
  clearfast();
  fillTable(8,8);
  delay(5000);
  clearfast();
  fillTable(RED);
  delay(5000);
  clearfast();
  fillTable(GREEN);
  delay(5000);
  clearfast();
  fillTable(ORANGE);
  delay(5000);
  clearfast();
  fillTable(YELLOW);
  delay(5000);
  clearfast();
}

void LED(int X, int Y, int R, int G)
{
  X = constrain(X, 0, 31); 
  Y = constrain(Y, 0, 31);
  
  R = constrain(R, 0, 15);
  G = constrain(G, 0, 15); 

  int WhichByte = int(Y*4+ X/8);
  int WhichBit = 7-(X%8);

  for (byte BAM = 0; BAM < 4; BAM++) 
  {
    bitWrite(red[BAM][WhichByte], WhichBit, bitRead(R, BAM));

    bitWrite(green[BAM][WhichByte], WhichBit, bitRead(G, BAM));
  }

}

void rowScan(byte row)
{
  
  if (row & 0x01) PORTD |= 1<<RowA_Pin;
    else PORTD &= ~(1<<RowA_Pin);
  
  if (row & 0x02) PORTD |= 1<<RowB_Pin;
    else PORTD &= ~(1<<RowB_Pin);

  if (row & 0x04) PORTD |= 1<<RowC_Pin;
    else PORTD &= ~(1<<RowC_Pin);

  if (row & 0x08) PORTD |= 1<<RowD_Pin;
    else PORTD &= ~(1<<RowD_Pin);
}

ISR(TIMER1_COMPA_vect){
  
PORTD |= ((1<<blank_pin));
if(BAM_Counter==8)
BAM_Bit++;
else
if(BAM_Counter==24)
BAM_Bit++;
else
if(BAM_Counter==56)
BAM_Bit++;

BAM_Counter++;

switch (BAM_Bit)
{
    case 0:

      //Red
      
        myTransfer(red[0][level + 0]);
        myTransfer(red[0][level + 1]);
        myTransfer(red[0][level + 2]);
        myTransfer(red[0][level + 3]);
        myTransfer(red[0][level + 64]);
        myTransfer(red[0][level + 65]);
        myTransfer(red[0][level + 66]);
        myTransfer(red[0][level + 67]);

      //Green
        
        myTransfer(green[0][level + 0]);
        myTransfer(green[0][level + 1]);
        myTransfer(green[0][level + 2]);
        myTransfer(green[0][level + 3]);
        myTransfer(green[0][level + 64]);
        myTransfer(green[0][level + 65]);
        myTransfer(green[0][level + 66]);
        myTransfer(green[0][level + 67]);

      break;
    case 1:
       
      //Red

        myTransfer(red[1][level + 0]);
        myTransfer(red[1][level + 1]);
        myTransfer(red[1][level + 2]);
        myTransfer(red[1][level + 3]);  

        myTransfer(red[1][level + 64]);
        myTransfer(red[1][level + 65]);
        myTransfer(red[1][level + 66]);
        myTransfer(red[1][level + 67]);             
      //Green

        myTransfer(green[1][level + 0]);
        myTransfer(green[1][level + 1]);
        myTransfer(green[1][level + 2]);
        myTransfer(green[1][level + 3]);
        
        myTransfer(green[1][level + 64]);
        myTransfer(green[1][level + 65]);
        myTransfer(green[1][level + 66]);
        myTransfer(green[1][level + 67]);
        
      break;
    case 2:
      
      //Red

        myTransfer(red[2][level + 0]);
        myTransfer(red[2][level + 1]);
        myTransfer(red[2][level + 2]);
        myTransfer(red[2][level + 3]);
        
        myTransfer(red[2][level + 64]);
        myTransfer(red[2][level + 65]);
        myTransfer(red[2][level + 66]);
        myTransfer(red[2][level + 67]);
                      
       //Green

        myTransfer(green[2][level + 0]);
        myTransfer(green[2][level + 1]);
        myTransfer(green[2][level + 2]);
        myTransfer(green[2][level + 3]);
        
        myTransfer(green[2][level + 64]);
        myTransfer(green[2][level + 65]);
        myTransfer(green[2][level + 66]);
        myTransfer(green[2][level + 67]);

      break;
    case 3:
      //Red

        myTransfer(red[3][level + 0]);
        myTransfer(red[3][level + 1]);
        myTransfer(red[3][level + 2]);
        myTransfer(red[3][level + 3]); 
               
        myTransfer(red[3][level + 64]);
        myTransfer(red[3][level + 65]);
        myTransfer(red[3][level + 66]);
        myTransfer(red[3][level + 67]);    

      //Green

        myTransfer(green[3][level + 0]);
        myTransfer(green[3][level + 1]);
        myTransfer(green[3][level + 2]);
        myTransfer(green[3][level + 3]);
              
        myTransfer(green[3][level + 64]);
        myTransfer(green[3][level + 65]);
        myTransfer(green[3][level + 66]);
        myTransfer(green[3][level + 67]);
        
  if(BAM_Counter==120){
  BAM_Counter=0;
  BAM_Bit=0;
  }
  break;
}

rowScan(row);

PORTD |= 1<<latch_pin;
PORTD &= ~(1<<latch_pin);
//delayMicroseconds(5); 
PORTD &= ~(1<<blank_pin);
//delayMicroseconds(5);

row++;
level = row*4;
if(row==16)
row=0;
if(level==64)
level=0;
pinMode(blank_pin, OUTPUT);

}

inline static uint8_t myTransfer(uint8_t C_data){
  SPDR = C_data;
  asm volatile("nop"); 
  asm volatile("nop");
}


void clearfast ()
{
for (unsigned char j=0; j<128; j++)
        {
        red[0][j]   = 0;
        red[1][j]   = 0;
        red[2][j]   = 0;
        red[3][j]   = 0;
        green[0][j] = 0;
        green[1][j] = 0;
        green[2][j] = 0;
        green[3][j] = 0;
        }
}

void fillTable(byte R, byte G)
{
    for (byte x=0; x<32; x++)
    {
      for (byte y=0; y<32; y++)
      {
        LED(x, y, R, G);
      }
    }
}

void drawImage(uint8_t width, uint8_t height, const uint8_t *image, Color For_color, Color Bk_color)
{
    for (uint8_t y = 0; y < height; y++)
    {
        for (uint8_t x = 0; x < width; x++)
        {
            uint8_t  WhichByte =  x/8 + y*4;
            uint8_t  WhichBit = 7-(x % 8);
            uint8_t  colorImage = bitRead(pgm_read_byte(&image[WhichByte]), WhichBit) & 1;
              if (colorImage)
                {
                LED(x, y, For_color.red, For_color.green);
                }
              else
                {
                LED(x, y, Bk_color.red, Bk_color.green);        
                }
          }
    }
}