Last active
January 3, 2018 17:17
-
-
Save tuenhidiy/9f658d13f7131b1203e9984b113c9fd7 to your computer and use it in GitHub Desktop.
Main program for 32x32 Bicolor Led Matrix using B.A.M - 4 bit method
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//************************************************************************************************************// | |
//********************* 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); | |
} | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment