1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "CUBE.h" |
#include "SPI1.h" |
15,7 → 13,7 |
Nop(); |
} |
|
void Cube_Init(CUBE_DATA *data, char BC) { |
void Cube_Init(CUBE_DATA *data, uint8_t BC) { |
cube_data_ptr = data; |
cube_data_ptr->current_layer = 0; |
cube_data_ptr->rotation_counter = 0; |
55,7 → 53,8 |
|
void Cube_Timer_Interrupt(void) { |
// OR values in the overlay array with the display array |
int i,j; |
uint8_t i; |
uint16_t j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < GCS_LAYER_SIZE; j++) { |
cube_data_ptr->GCS_WRITE[i][j] = cube_data_ptr->GCS[i][j] | cube_data_ptr->GCS_OVERLAY[i][j]; |
85,7 → 84,7 |
Cube_Delay(); |
GSLAT = 1; |
// Set the shift register to turn on the current layer |
int i; |
uint8_t i; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
Cube_Delay(); |
SFT_D = (i == CUBE_LAYER_COUNT - cube_data_ptr->current_layer - 1) ? 1 : 0; |
112,13 → 111,13 |
// Cube control functions // |
//////////////////////////// |
|
void Cube_Write_DCS(char BC) { |
void Cube_Write_DCS(uint8_t BC) { |
XBLNK = 0; |
int i,j; |
uint8_t i,j; |
// Write configuration data to the DC/BC/FC/UD registers |
unsigned char DCS[GCS_LAYER_SIZE] = {0}; |
uint8_t DCS[GCS_LAYER_SIZE] = {0}; |
for (i = 0; i < 8; i++) { |
int offset = i * GCS_REG_SIZE; |
uint16_t offset = i * GCS_REG_SIZE; |
|
for (j = 0; j < 21; j++) { |
DCS[offset + j] = 0xFF; // Dot correction |
139,23 → 138,24 |
} |
|
void Cube_Clear(void) { |
int i,j; |
uint8_t i; |
uint16_t j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) |
for (j = 0; j < GCS_LAYER_SIZE; j++) |
cube_data_ptr->GCS[i][j] = 0x00; |
} |
|
void Cube_Set_All(int R, int G, int B) { |
void Cube_Set_All(uint16_t R, uint16_t G, uint16_t B) { |
// Set all pixels in the cube to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int i,j,k; |
uint8_t i,j,k; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
int j_var = j * GCS_REG_SIZE; |
uint16_t j_var = j * GCS_REG_SIZE; |
for (k = 0; k < 4; k++) { |
int k_var = j_var + (k * 9); |
uint16_t k_var = j_var + (k * 9); |
cube_data_ptr->GCS[i][k_var+0] = R & 0xFF;; |
cube_data_ptr->GCS[i][k_var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS[i][k_var+2] = G >> 4; |
170,16 → 170,16 |
} |
} |
|
void Cube_Set_Layer(int layer, int R, int G, int B) { |
void Cube_Set_Layer(uint8_t layer, uint16_t R, uint16_t G, uint16_t B) { |
// Set all pixels in the specified layer to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int i,j; |
uint8_t i,j; |
for (i = 0; i < CUBE_ROW_COUNT; i++) { |
int i_var = i * GCS_REG_SIZE; |
uint16_t i_var = i * GCS_REG_SIZE; |
for (j = 0; j < 4; j++) { |
int j_var = i_var + (j * 9); |
uint16_t j_var = i_var + (j * 9); |
cube_data_ptr->GCS[layer][j_var+0] = R & 0xFF;; |
cube_data_ptr->GCS[layer][j_var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS[layer][j_var+2] = G >> 4; |
193,12 → 193,12 |
} |
} |
|
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) { |
void Cube_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS[layer][var+0] = R & 0xFF; |
217,8 → 217,8 |
} |
} |
|
void Cube_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) { |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
void Cube_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) { |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
234,17 → 234,18 |
} |
} |
|
void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
void Cube_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int prev_R, prev_G, prev_B; |
uint16_t prev_R, prev_G, prev_B; |
Cube_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B); |
Cube_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B); |
} |
|
void Cube_Rotate_Shell(char shell, char direction) { |
void Cube_Rotate_Shell(uint8_t shell, uint8_t direction) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
uint8_t layer; |
uint16_t origin_R, origin_G, origin_B; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
416,7 → 417,7 |
} |
} |
|
void Cube_Rotate(char direction) { |
void Cube_Rotate(uint8_t direction) { |
// Rotate outermost layer |
Cube_Rotate_Shell(0, direction); |
// Rotate second to outermost layer |
447,18 → 448,20 |
/////////////////////////////// |
|
void Cube_Overlay_Clear(void) { |
int i,j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) |
for (j = 0; j < GCS_LAYER_SIZE; j++) |
uint16_t i,j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < GCS_LAYER_SIZE; j++) { |
cube_data_ptr->GCS_OVERLAY[i][j] = 0x00; |
} |
} |
} |
|
void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B) { |
void Cube_Overlay_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF; |
477,8 → 480,8 |
} |
} |
|
void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) { |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
void Cube_Overlay_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) { |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
494,17 → 497,18 |
} |
} |
|
void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
void Cube_Overlay_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int prev_R, prev_G, prev_B; |
uint16_t prev_R, prev_G, prev_B; |
Cube_Overlay_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B); |
Cube_Overlay_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B); |
} |
|
void Cube_Overlay_Rotate_Shell(char shell, char direction) { |
void Cube_Overlay_Rotate_Shell(uint8_t shell, uint8_t direction) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
uint8_t layer; |
uint16_t origin_R, origin_G, origin_B;; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
680,7 → 684,7 |
// Text control functions // |
//////////////////////////// |
|
void Cube_Text_Init(char *string, char length, int R, int G, int B) { |
void Cube_Text_Init(uint8_t *string, uint8_t length, uint16_t R, uint16_t G, uint16_t B) { |
// Ensure that the length of the string does not exceed the storage buffer |
if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH; |
|
687,7 → 691,7 |
Cube_Overlay_Clear(); |
|
// Copy the passed data into the buffer |
int i; |
uint8_t i; |
for (i = 0; i < length; i++) |
cube_data_ptr->string[i] = string[i]; |
cube_data_ptr->string_length = length; |
699,14 → 703,15 |
} |
|
void Cube_Text_Interrupt(void) { |
int layer, line; |
uint8_t layer; |
uint16_t line; |
|
// Rotate before drawing the new line at (0,0) |
Cube_Overlay_Rotate_Shell(0, 0); |
|
// Get the next vertical line of the character currently being drawn |
// Get the next vertical line of the int8_tacter currently being drawn |
if (cube_data_ptr->string_line == 5) { |
line = 0x0; // Leave a space between characters |
line = 0x0; // Leave a space between int8_tacters |
} else { |
line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5) |
+ cube_data_ptr->string_line]; |
713,17 → 718,17 |
} |
|
// Draw the line onto (0,0) using the specified color |
for (layer = 7; layer >= 0; layer--) { |
for (layer = 8; layer != 0; layer--) { |
if (line & 0x1) { |
Cube_Overlay_Set_Pixel(layer, 0, 0, cube_data_ptr->string_R, |
Cube_Overlay_Set_Pixel(layer-1, 0, 0, cube_data_ptr->string_R, |
cube_data_ptr->string_G, cube_data_ptr->string_B); |
} else { |
Cube_Overlay_Set_Pixel(layer, 0, 0, 0x00, 0x00, 0x00); |
Cube_Overlay_Set_Pixel(layer-1, 0, 0, 0x00, 0x00, 0x00); |
} |
line >>= 1; |
} |
|
// Increment the vertical line and the character as needed |
// Increment the vertical line and the int8_tacter as needed |
if (cube_data_ptr->string_line == 5) { |
cube_data_ptr->string_line = 0; |
if (cube_data_ptr->string_index == cube_data_ptr->string_length-1) { |
740,8 → 745,8 |
// Functions for processing streaming data // |
///////////////////////////////////////////// |
|
void Cube_Data_In(char c) { |
// Reset upon receiving the start char |
void Cube_Data_In(uint8_t c) { |
// Reset upon receiving the start int8_t |
if (c == CUBE_START_CHAR) { |
cube_data_ptr->frame_length = 0; |
cube_data_ptr->frame_index = 0; |
751,12 → 756,12 |
cube_data_ptr->frame_state = READ_LENGTH_MSB; |
return; |
} |
// If the input is the escape char, XOR the next char received |
// If the input is the escape int8_t, XOR the next int8_t received |
if (c == CUBE_ESCAPE_CHAR) { |
cube_data_ptr->frame_escape = 1; |
return; |
} |
// XOR the input char if needed |
// XOR the input int8_t if needed |
if (cube_data_ptr->frame_escape) { |
c ^= CUBE_ESCAPE_XOR; |
cube_data_ptr->frame_escape = 0; |
764,7 → 769,7 |
// Process data |
switch (cube_data_ptr->frame_state) { |
case IDLE: |
// Reflect the character back to the transmitter |
// Reflect the int8_tacter back to the transmitter |
UART1_Write(&c, 1); |
break; |
case READ_LENGTH_MSB: // Save MSB of length |
806,7 → 811,7 |
|
void Cube_Data_In_Process_Frame(void) { |
// Here we process received frames depending on the command |
char *frame = cube_data_ptr->frame_buffer; |
uint8_t *frame = cube_data_ptr->frame_buffer; |
switch (cube_data_ptr->frame_command) { |
case CUBE_COMMAND_SET_BC: |
TIMER5_Stop(); |
836,6 → 841,6 |
} |
} |
|
void Cube_Data_Direct_Write_All(char *buffer) { |
void Cube_Data_Direct_Write_All(uint8_t *buffer) { |
memcpy(cube_data_ptr->GCS, buffer, CUBE_LAYER_COUNT * GCS_LAYER_SIZE); |
} |