/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c |
---|
0,0 → 1,844 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "CUBE.h" |
#include "SPI1.h" |
#include "glcdfont.h" |
#include "UART1.h" |
static CUBE_DATA *cube_data_ptr; |
inline void Cube_Delay() { |
// Small delay to ensure that latch speeds are < 30Mhz |
Nop(); |
Nop(); |
Nop(); |
} |
void Cube_Init(CUBE_DATA *data, char BC) { |
cube_data_ptr = data; |
cube_data_ptr->current_layer = 0; |
cube_data_ptr->rotation_counter = 0; |
cube_data_ptr->frame_state = IDLE; |
cube_data_ptr->frame_escape = 0; |
SFT_D = 0; |
SFT_S = 0; |
SFT_K = 0; |
SFT_R = 0; |
GSLAT = 0; |
XBLNK = 0; |
SFT_D_TRIS = 0; |
SFT_S_TRIS = 0; |
SFT_K_TRIS = 0; |
SFT_R_TRIS = 0; |
GSLAT_TRIS = 0; |
XBLNK_TRIS = 0; |
// Clear the shift register |
Cube_Delay(); |
SFT_K = 1; |
Cube_Delay(); |
SFT_K = 0; |
Cube_Delay(); |
SFT_S = 1; |
Cube_Delay(); |
SFT_S = 0; |
Cube_Delay(); |
SFT_R = 1; |
Cube_Write_DCS(BC); |
Cube_Clear(); |
Cube_Overlay_Clear(); |
} |
void Cube_Timer_Interrupt(void) { |
// OR values in the overlay array with the display array |
int i,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]; |
} |
} |
// Write to the GCS register |
SPI1_Write(cube_data_ptr->GCS_WRITE[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback); |
} |
//////////////////////// |
// Callback functions // |
//////////////////////// |
void Cube_DCS_Write_Callback(void) { |
// GSLAT must be >7ms after DCS write |
Delay_MS(7); |
GSLAT = 0; |
Cube_Delay(); |
GSLAT = 1; |
Cube_Delay(); |
GSLAT = 0; |
} |
void Cube_GCS_Write_Callback(void) { |
// Disable LED output and latch in written data to GCS |
XBLNK = 0; |
Cube_Delay(); |
GSLAT = 1; |
// Set the shift register to turn on the current layer |
int 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; |
Cube_Delay(); |
SFT_K = 1; |
Cube_Delay(); |
SFT_K = 0; |
} |
Cube_Delay(); |
SFT_S = 1; |
Cube_Delay(); |
SFT_S = 0; |
Cube_Delay(); |
// Enable LED output |
XBLNK = 1; |
Cube_Delay(); |
GSLAT = 0; |
cube_data_ptr->current_layer = (cube_data_ptr->current_layer == CUBE_LAYER_COUNT-1) |
? 0 : cube_data_ptr->current_layer + 1; |
} |
//////////////////////////// |
// Cube control functions // |
//////////////////////////// |
void Cube_Write_DCS(char BC) { |
XBLNK = 0; |
int i,j; |
// Write configuration data to the DC/BC/FC/UD registers |
unsigned char DCS[GCS_LAYER_SIZE] = {0}; |
for (i = 0; i < 8; i++) { |
int offset = i * GCS_REG_SIZE; |
for (j = 0; j < 21; j++) { |
DCS[offset + j] = 0xFF; // Dot correction |
} |
// Warning: do not set BC > 0x6F |
DCS[offset + 21] = BC; // Global red brightness |
DCS[offset + 22] = BC; // Global green brightness |
DCS[offset + 23] = BC; // Global blue brightness |
// DC low range, auto repeat, no timing reset, 8 bit counter mode |
DCS[offset + 24] = 0x68; // 0110 1000 |
} |
GSLAT = 1; |
SPI1_Write(DCS, GCS_LAYER_SIZE, &Cube_DCS_Write_Callback); |
Delay_MS(10); // Delay until the entire DCS write is finished |
} |
void Cube_Clear(void) { |
int i,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) { |
// Set all pixels in the cube to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int 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; |
for (k = 0; k < 4; k++) { |
int 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; |
cube_data_ptr->GCS[i][k_var+3] = B & 0xFF; |
cube_data_ptr->GCS[i][k_var+4] = (R << 4) | (B >> 8); |
cube_data_ptr->GCS[i][k_var+5] = R >> 4; |
cube_data_ptr->GCS[i][k_var+6] = G & 0xFF; |
cube_data_ptr->GCS[i][k_var+7] = (B << 4) | (G >> 8); |
cube_data_ptr->GCS[i][k_var+8] = B >> 4; |
} |
} |
} |
} |
void Cube_Set_Layer(int layer, int R, int G, int B) { |
// Set all pixels in the specified layer to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int i,j; |
for (i = 0; i < CUBE_ROW_COUNT; i++) { |
int i_var = i * GCS_REG_SIZE; |
for (j = 0; j < 4; j++) { |
int 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; |
cube_data_ptr->GCS[layer][j_var+3] = B & 0xFF; |
cube_data_ptr->GCS[layer][j_var+4] = (R << 4) | (B >> 8); |
cube_data_ptr->GCS[layer][j_var+5] = R >> 4; |
cube_data_ptr->GCS[layer][j_var+6] = G & 0xFF; |
cube_data_ptr->GCS[layer][j_var+7] = (B << 4) | (G >> 8); |
cube_data_ptr->GCS[layer][j_var+8] = B >> 4; |
} |
} |
} |
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS[layer][var+0] = R & 0xFF; |
cube_data_ptr->GCS[layer][var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS[layer][var+2] = G >> 4; |
cube_data_ptr->GCS[layer][var+3] = B & 0xFF; |
cube_data_ptr->GCS[layer][var+4] = (cube_data_ptr->GCS[layer][var+4] & 0xF0) | (B >> 8); |
break; |
case 1: |
cube_data_ptr->GCS[layer][var+4] = (cube_data_ptr->GCS[layer][var+4] & 0x0F) | (R << 4); |
cube_data_ptr->GCS[layer][var+5] = R >> 4; |
cube_data_ptr->GCS[layer][var+6] = G & 0xFF; |
cube_data_ptr->GCS[layer][var+7] = (B << 4) | (G >> 8); |
cube_data_ptr->GCS[layer][var+8] = B >> 4; |
break; |
} |
} |
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); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
*R = cube_data_ptr->GCS[layer][var+0] | ((cube_data_ptr->GCS[layer][var+1] & 0x0F) << 8); |
*G = (cube_data_ptr->GCS[layer][var+1] >> 4) | (cube_data_ptr->GCS[layer][var+2] << 4); |
*B = cube_data_ptr->GCS[layer][var+3] | ((cube_data_ptr->GCS[layer][var+4] & 0x0F) << 8); |
break; |
case 1: |
*R = (cube_data_ptr->GCS[layer][var+4] >> 4) | (cube_data_ptr->GCS[layer][var+5] << 4); |
*G = cube_data_ptr->GCS[layer][var+6] | ((cube_data_ptr->GCS[layer][var+7] & 0x0F) << 8); |
*B = (cube_data_ptr->GCS[layer][var+7] >> 4) | (cube_data_ptr->GCS[layer][var+8] << 4); |
break; |
} |
} |
void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int 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) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
case 0: |
// Rotate outermost layer |
Cube_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 0, 1, layer, 0, 0); |
Cube_Move_Pixel(layer, 0, 2, layer, 0, 1); |
Cube_Move_Pixel(layer, 0, 3, layer, 0, 2); |
Cube_Move_Pixel(layer, 0, 4, layer, 0, 3); |
Cube_Move_Pixel(layer, 0, 5, layer, 0, 4); |
Cube_Move_Pixel(layer, 0, 6, layer, 0, 5); |
Cube_Move_Pixel(layer, 0, 7, layer, 0, 6); |
Cube_Move_Pixel(layer, 1, 7, layer, 0, 7); |
Cube_Move_Pixel(layer, 2, 7, layer, 1, 7); |
Cube_Move_Pixel(layer, 3, 7, layer, 2, 7); |
Cube_Move_Pixel(layer, 4, 7, layer, 3, 7); |
Cube_Move_Pixel(layer, 5, 7, layer, 4, 7); |
Cube_Move_Pixel(layer, 6, 7, layer, 5, 7); |
Cube_Move_Pixel(layer, 7, 7, layer, 6, 7); |
Cube_Move_Pixel(layer, 7, 6, layer, 7, 7); |
Cube_Move_Pixel(layer, 7, 5, layer, 7, 6); |
Cube_Move_Pixel(layer, 7, 4, layer, 7, 5); |
Cube_Move_Pixel(layer, 7, 3, layer, 7, 4); |
Cube_Move_Pixel(layer, 7, 2, layer, 7, 3); |
Cube_Move_Pixel(layer, 7, 1, layer, 7, 2); |
Cube_Move_Pixel(layer, 7, 0, layer, 7, 1); |
Cube_Move_Pixel(layer, 6, 0, layer, 7, 0); |
Cube_Move_Pixel(layer, 5, 0, layer, 6, 0); |
Cube_Move_Pixel(layer, 4, 0, layer, 5, 0); |
Cube_Move_Pixel(layer, 3, 0, layer, 4, 0); |
Cube_Move_Pixel(layer, 2, 0, layer, 3, 0); |
Cube_Move_Pixel(layer, 1, 0, layer, 2, 0); |
Cube_Set_Pixel(layer, 1, 0, origin_R, origin_G, origin_B); |
break; |
case 1: |
// Rotate second to outermost layer |
Cube_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 1, 2, layer, 1, 1); |
Cube_Move_Pixel(layer, 1, 3, layer, 1, 2); |
Cube_Move_Pixel(layer, 1, 4, layer, 1, 3); |
Cube_Move_Pixel(layer, 1, 5, layer, 1, 4); |
Cube_Move_Pixel(layer, 1, 6, layer, 1, 5); |
Cube_Move_Pixel(layer, 2, 6, layer, 1, 6); |
Cube_Move_Pixel(layer, 3, 6, layer, 2, 6); |
Cube_Move_Pixel(layer, 4, 6, layer, 3, 6); |
Cube_Move_Pixel(layer, 5, 6, layer, 4, 6); |
Cube_Move_Pixel(layer, 6, 6, layer, 5, 6); |
Cube_Move_Pixel(layer, 6, 5, layer, 6, 6); |
Cube_Move_Pixel(layer, 6, 4, layer, 6, 5); |
Cube_Move_Pixel(layer, 6, 3, layer, 6, 4); |
Cube_Move_Pixel(layer, 6, 2, layer, 6, 3); |
Cube_Move_Pixel(layer, 6, 1, layer, 6, 2); |
Cube_Move_Pixel(layer, 5, 1, layer, 6, 1); |
Cube_Move_Pixel(layer, 4, 1, layer, 5, 1); |
Cube_Move_Pixel(layer, 3, 1, layer, 4, 1); |
Cube_Move_Pixel(layer, 2, 1, layer, 3, 1); |
Cube_Set_Pixel(layer, 2, 1, origin_R, origin_G, origin_B); |
break; |
case 2: |
// Rotate second to innermost layer |
Cube_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 2, 3, layer, 2, 2); |
Cube_Move_Pixel(layer, 2, 4, layer, 2, 3); |
Cube_Move_Pixel(layer, 2, 5, layer, 2, 4); |
Cube_Move_Pixel(layer, 3, 5, layer, 2, 5); |
Cube_Move_Pixel(layer, 4, 5, layer, 3, 5); |
Cube_Move_Pixel(layer, 5, 5, layer, 4, 5); |
Cube_Move_Pixel(layer, 5, 4, layer, 5, 5); |
Cube_Move_Pixel(layer, 5, 3, layer, 5, 4); |
Cube_Move_Pixel(layer, 5, 2, layer, 5, 3); |
Cube_Move_Pixel(layer, 4, 2, layer, 5, 2); |
Cube_Move_Pixel(layer, 3, 2, layer, 4, 2); |
Cube_Set_Pixel(layer, 3, 2, origin_R, origin_G, origin_B); |
break; |
case 3: |
// Rotate innermost layer |
Cube_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 3, 4, layer, 3, 3); |
Cube_Move_Pixel(layer, 4, 4, layer, 3, 4); |
Cube_Move_Pixel(layer, 4, 3, layer, 4, 4); |
Cube_Set_Pixel(layer, 4, 3, origin_R, origin_G, origin_B); |
break; |
} |
} else { |
switch(shell) { |
case 0: |
// Rotate outermost layer |
Cube_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 1, 0, layer, 0, 0); |
Cube_Move_Pixel(layer, 2, 0, layer, 1, 0); |
Cube_Move_Pixel(layer, 3, 0, layer, 2, 0); |
Cube_Move_Pixel(layer, 4, 0, layer, 3, 0); |
Cube_Move_Pixel(layer, 5, 0, layer, 4, 0); |
Cube_Move_Pixel(layer, 6, 0, layer, 5, 0); |
Cube_Move_Pixel(layer, 7, 0, layer, 6, 0); |
Cube_Move_Pixel(layer, 7, 1, layer, 7, 0); |
Cube_Move_Pixel(layer, 7, 2, layer, 7, 1); |
Cube_Move_Pixel(layer, 7, 3, layer, 7, 2); |
Cube_Move_Pixel(layer, 7, 4, layer, 7, 3); |
Cube_Move_Pixel(layer, 7, 5, layer, 7, 4); |
Cube_Move_Pixel(layer, 7, 6, layer, 7, 5); |
Cube_Move_Pixel(layer, 7, 7, layer, 7, 6); |
Cube_Move_Pixel(layer, 6, 7, layer, 7, 7); |
Cube_Move_Pixel(layer, 5, 7, layer, 6, 7); |
Cube_Move_Pixel(layer, 4, 7, layer, 5, 7); |
Cube_Move_Pixel(layer, 3, 7, layer, 4, 7); |
Cube_Move_Pixel(layer, 2, 7, layer, 3, 7); |
Cube_Move_Pixel(layer, 1, 7, layer, 2, 7); |
Cube_Move_Pixel(layer, 0, 7, layer, 1, 7); |
Cube_Move_Pixel(layer, 0, 6, layer, 0, 7); |
Cube_Move_Pixel(layer, 0, 5, layer, 0, 6); |
Cube_Move_Pixel(layer, 0, 4, layer, 0, 5); |
Cube_Move_Pixel(layer, 0, 3, layer, 0, 4); |
Cube_Move_Pixel(layer, 0, 2, layer, 0, 3); |
Cube_Move_Pixel(layer, 0, 1, layer, 0, 2); |
Cube_Set_Pixel(layer, 0, 1, origin_R, origin_G, origin_B); |
break; |
case 1: |
// Rotate second to outermost layer |
Cube_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 2, 1, layer, 1, 1); |
Cube_Move_Pixel(layer, 3, 1, layer, 2, 1); |
Cube_Move_Pixel(layer, 4, 1, layer, 3, 1); |
Cube_Move_Pixel(layer, 5, 1, layer, 4, 1); |
Cube_Move_Pixel(layer, 6, 1, layer, 5, 1); |
Cube_Move_Pixel(layer, 6, 2, layer, 6, 1); |
Cube_Move_Pixel(layer, 6, 3, layer, 6, 2); |
Cube_Move_Pixel(layer, 6, 4, layer, 6, 3); |
Cube_Move_Pixel(layer, 6, 5, layer, 6, 4); |
Cube_Move_Pixel(layer, 6, 6, layer, 6, 5); |
Cube_Move_Pixel(layer, 5, 6, layer, 6, 6); |
Cube_Move_Pixel(layer, 4, 6, layer, 5, 6); |
Cube_Move_Pixel(layer, 3, 6, layer, 4, 6); |
Cube_Move_Pixel(layer, 2, 6, layer, 3, 6); |
Cube_Move_Pixel(layer, 1, 6, layer, 2, 6); |
Cube_Move_Pixel(layer, 1, 5, layer, 1, 6); |
Cube_Move_Pixel(layer, 1, 4, layer, 1, 5); |
Cube_Move_Pixel(layer, 1, 3, layer, 1, 4); |
Cube_Move_Pixel(layer, 1, 2, layer, 1, 3); |
Cube_Set_Pixel(layer, 1, 2, origin_R, origin_G, origin_B); |
break; |
case 2: |
// Rotate second to innermost layer |
Cube_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 3, 2, layer, 2, 2); |
Cube_Move_Pixel(layer, 4, 2, layer, 3, 2); |
Cube_Move_Pixel(layer, 5, 2, layer, 4, 2); |
Cube_Move_Pixel(layer, 5, 3, layer, 5, 2); |
Cube_Move_Pixel(layer, 5, 4, layer, 5, 3); |
Cube_Move_Pixel(layer, 5, 5, layer, 5, 4); |
Cube_Move_Pixel(layer, 4, 5, layer, 5, 5); |
Cube_Move_Pixel(layer, 3, 5, layer, 4, 5); |
Cube_Move_Pixel(layer, 2, 5, layer, 3, 5); |
Cube_Move_Pixel(layer, 2, 4, layer, 2, 5); |
Cube_Move_Pixel(layer, 2, 3, layer, 2, 4); |
Cube_Set_Pixel(layer, 2, 3, origin_R, origin_G, origin_B); |
break; |
case 3: |
// Rotate innermost layer |
Cube_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B); |
Cube_Move_Pixel(layer, 4, 3, layer, 3, 3); |
Cube_Move_Pixel(layer, 4, 4, layer, 4, 3); |
Cube_Move_Pixel(layer, 3, 4, layer, 4, 4); |
Cube_Set_Pixel(layer, 3, 4, origin_R, origin_G, origin_B); |
break; |
} |
} |
} |
} |
void Cube_Rotate(char direction) { |
// Rotate outermost layer |
Cube_Rotate_Shell(0, direction); |
// Rotate second to outermost layer |
if ((cube_data_ptr->rotation_counter != 1) && (cube_data_ptr->rotation_counter != 5)) { |
Cube_Rotate_Shell(1, direction); |
} |
// Rotate second to innermost layer |
if ((cube_data_ptr->rotation_counter != 0) && (cube_data_ptr->rotation_counter != 2) && |
(cube_data_ptr->rotation_counter != 4) && (cube_data_ptr->rotation_counter != 6)) { |
Cube_Rotate_Shell(2, direction); |
} |
// Rotate innermost layer |
if ((cube_data_ptr->rotation_counter == 3) || (cube_data_ptr->rotation_counter == 7)) { |
Cube_Rotate_Shell(3, direction); |
} |
if (direction == 0) { |
cube_data_ptr->rotation_counter = (cube_data_ptr->rotation_counter == CUBE_ROTATIONS - 1) |
? 0 : cube_data_ptr->rotation_counter + 1; |
} else { |
cube_data_ptr->rotation_counter = (cube_data_ptr->rotation_counter == 0) |
? CUBE_ROTATIONS - 1 : cube_data_ptr->rotation_counter - 1; |
} |
} |
/////////////////////////////// |
// Overlay control functions // |
/////////////////////////////// |
void Cube_Overlay_Clear(void) { |
int 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) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF; |
cube_data_ptr->GCS_OVERLAY[layer][var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS_OVERLAY[layer][var+2] = G >> 4; |
cube_data_ptr->GCS_OVERLAY[layer][var+3] = B & 0xFF; |
cube_data_ptr->GCS_OVERLAY[layer][var+4] = (cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0xF0) | (B >> 8); |
break; |
case 1: |
cube_data_ptr->GCS_OVERLAY[layer][var+4] = (cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0x0F) | (R << 4); |
cube_data_ptr->GCS_OVERLAY[layer][var+5] = R >> 4; |
cube_data_ptr->GCS_OVERLAY[layer][var+6] = G & 0xFF; |
cube_data_ptr->GCS_OVERLAY[layer][var+7] = (B << 4) | (G >> 8); |
cube_data_ptr->GCS_OVERLAY[layer][var+8] = B >> 4; |
break; |
} |
} |
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); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
*R = cube_data_ptr->GCS_OVERLAY[layer][var+0] | ((cube_data_ptr->GCS_OVERLAY[layer][var+1] & 0x0F) << 8); |
*G = (cube_data_ptr->GCS_OVERLAY[layer][var+1] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+2] << 4); |
*B = cube_data_ptr->GCS_OVERLAY[layer][var+3] | ((cube_data_ptr->GCS_OVERLAY[layer][var+4] & 0x0F) << 8); |
break; |
case 1: |
*R = (cube_data_ptr->GCS_OVERLAY[layer][var+4] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+5] << 4); |
*G = cube_data_ptr->GCS_OVERLAY[layer][var+6] | ((cube_data_ptr->GCS_OVERLAY[layer][var+7] & 0x0F) << 8); |
*B = (cube_data_ptr->GCS_OVERLAY[layer][var+7] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+8] << 4); |
break; |
} |
} |
void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int 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) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
case 0: |
// Rotate outermost layer |
Cube_Overlay_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 0, 1, layer, 0, 0); |
Cube_Overlay_Move_Pixel(layer, 0, 2, layer, 0, 1); |
Cube_Overlay_Move_Pixel(layer, 0, 3, layer, 0, 2); |
Cube_Overlay_Move_Pixel(layer, 0, 4, layer, 0, 3); |
Cube_Overlay_Move_Pixel(layer, 0, 5, layer, 0, 4); |
Cube_Overlay_Move_Pixel(layer, 0, 6, layer, 0, 5); |
Cube_Overlay_Move_Pixel(layer, 0, 7, layer, 0, 6); |
Cube_Overlay_Move_Pixel(layer, 1, 7, layer, 0, 7); |
Cube_Overlay_Move_Pixel(layer, 2, 7, layer, 1, 7); |
Cube_Overlay_Move_Pixel(layer, 3, 7, layer, 2, 7); |
Cube_Overlay_Move_Pixel(layer, 4, 7, layer, 3, 7); |
Cube_Overlay_Move_Pixel(layer, 5, 7, layer, 4, 7); |
Cube_Overlay_Move_Pixel(layer, 6, 7, layer, 5, 7); |
Cube_Overlay_Move_Pixel(layer, 7, 7, layer, 6, 7); |
Cube_Overlay_Move_Pixel(layer, 7, 6, layer, 7, 7); |
Cube_Overlay_Move_Pixel(layer, 7, 5, layer, 7, 6); |
Cube_Overlay_Move_Pixel(layer, 7, 4, layer, 7, 5); |
Cube_Overlay_Move_Pixel(layer, 7, 3, layer, 7, 4); |
Cube_Overlay_Move_Pixel(layer, 7, 2, layer, 7, 3); |
Cube_Overlay_Move_Pixel(layer, 7, 1, layer, 7, 2); |
Cube_Overlay_Move_Pixel(layer, 7, 0, layer, 7, 1); |
Cube_Overlay_Move_Pixel(layer, 6, 0, layer, 7, 0); |
Cube_Overlay_Move_Pixel(layer, 5, 0, layer, 6, 0); |
Cube_Overlay_Move_Pixel(layer, 4, 0, layer, 5, 0); |
Cube_Overlay_Move_Pixel(layer, 3, 0, layer, 4, 0); |
Cube_Overlay_Move_Pixel(layer, 2, 0, layer, 3, 0); |
Cube_Overlay_Move_Pixel(layer, 1, 0, layer, 2, 0); |
Cube_Overlay_Set_Pixel(layer, 1, 0, origin_R, origin_G, origin_B); |
break; |
case 1: |
// Rotate second to outermost layer |
Cube_Overlay_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 1, 2, layer, 1, 1); |
Cube_Overlay_Move_Pixel(layer, 1, 3, layer, 1, 2); |
Cube_Overlay_Move_Pixel(layer, 1, 4, layer, 1, 3); |
Cube_Overlay_Move_Pixel(layer, 1, 5, layer, 1, 4); |
Cube_Overlay_Move_Pixel(layer, 1, 6, layer, 1, 5); |
Cube_Overlay_Move_Pixel(layer, 2, 6, layer, 1, 6); |
Cube_Overlay_Move_Pixel(layer, 3, 6, layer, 2, 6); |
Cube_Overlay_Move_Pixel(layer, 4, 6, layer, 3, 6); |
Cube_Overlay_Move_Pixel(layer, 5, 6, layer, 4, 6); |
Cube_Overlay_Move_Pixel(layer, 6, 6, layer, 5, 6); |
Cube_Overlay_Move_Pixel(layer, 6, 5, layer, 6, 6); |
Cube_Overlay_Move_Pixel(layer, 6, 4, layer, 6, 5); |
Cube_Overlay_Move_Pixel(layer, 6, 3, layer, 6, 4); |
Cube_Overlay_Move_Pixel(layer, 6, 2, layer, 6, 3); |
Cube_Overlay_Move_Pixel(layer, 6, 1, layer, 6, 2); |
Cube_Overlay_Move_Pixel(layer, 5, 1, layer, 6, 1); |
Cube_Overlay_Move_Pixel(layer, 4, 1, layer, 5, 1); |
Cube_Overlay_Move_Pixel(layer, 3, 1, layer, 4, 1); |
Cube_Overlay_Move_Pixel(layer, 2, 1, layer, 3, 1); |
Cube_Overlay_Set_Pixel(layer, 2, 1, origin_R, origin_G, origin_B); |
break; |
case 2: |
// Rotate second to innermost layer |
Cube_Overlay_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 2, 3, layer, 2, 2); |
Cube_Overlay_Move_Pixel(layer, 2, 4, layer, 2, 3); |
Cube_Overlay_Move_Pixel(layer, 2, 5, layer, 2, 4); |
Cube_Overlay_Move_Pixel(layer, 3, 5, layer, 2, 5); |
Cube_Overlay_Move_Pixel(layer, 4, 5, layer, 3, 5); |
Cube_Overlay_Move_Pixel(layer, 5, 5, layer, 4, 5); |
Cube_Overlay_Move_Pixel(layer, 5, 4, layer, 5, 5); |
Cube_Overlay_Move_Pixel(layer, 5, 3, layer, 5, 4); |
Cube_Overlay_Move_Pixel(layer, 5, 2, layer, 5, 3); |
Cube_Overlay_Move_Pixel(layer, 4, 2, layer, 5, 2); |
Cube_Overlay_Move_Pixel(layer, 3, 2, layer, 4, 2); |
Cube_Overlay_Set_Pixel(layer, 3, 2, origin_R, origin_G, origin_B); |
break; |
case 3: |
// Rotate innermost layer |
Cube_Overlay_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 3, 4, layer, 3, 3); |
Cube_Overlay_Move_Pixel(layer, 4, 4, layer, 3, 4); |
Cube_Overlay_Move_Pixel(layer, 4, 3, layer, 4, 4); |
Cube_Overlay_Set_Pixel(layer, 4, 3, origin_R, origin_G, origin_B); |
break; |
} |
} else { |
switch(shell) { |
case 0: |
// Rotate outermost layer |
Cube_Overlay_Get_Pixel(layer, 0, 0, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 1, 0, layer, 0, 0); |
Cube_Overlay_Move_Pixel(layer, 2, 0, layer, 1, 0); |
Cube_Overlay_Move_Pixel(layer, 3, 0, layer, 2, 0); |
Cube_Overlay_Move_Pixel(layer, 4, 0, layer, 3, 0); |
Cube_Overlay_Move_Pixel(layer, 5, 0, layer, 4, 0); |
Cube_Overlay_Move_Pixel(layer, 6, 0, layer, 5, 0); |
Cube_Overlay_Move_Pixel(layer, 7, 0, layer, 6, 0); |
Cube_Overlay_Move_Pixel(layer, 7, 1, layer, 7, 0); |
Cube_Overlay_Move_Pixel(layer, 7, 2, layer, 7, 1); |
Cube_Overlay_Move_Pixel(layer, 7, 3, layer, 7, 2); |
Cube_Overlay_Move_Pixel(layer, 7, 4, layer, 7, 3); |
Cube_Overlay_Move_Pixel(layer, 7, 5, layer, 7, 4); |
Cube_Overlay_Move_Pixel(layer, 7, 6, layer, 7, 5); |
Cube_Overlay_Move_Pixel(layer, 7, 7, layer, 7, 6); |
Cube_Overlay_Move_Pixel(layer, 6, 7, layer, 7, 7); |
Cube_Overlay_Move_Pixel(layer, 5, 7, layer, 6, 7); |
Cube_Overlay_Move_Pixel(layer, 4, 7, layer, 5, 7); |
Cube_Overlay_Move_Pixel(layer, 3, 7, layer, 4, 7); |
Cube_Overlay_Move_Pixel(layer, 2, 7, layer, 3, 7); |
Cube_Overlay_Move_Pixel(layer, 1, 7, layer, 2, 7); |
Cube_Overlay_Move_Pixel(layer, 0, 7, layer, 1, 7); |
Cube_Overlay_Move_Pixel(layer, 0, 6, layer, 0, 7); |
Cube_Overlay_Move_Pixel(layer, 0, 5, layer, 0, 6); |
Cube_Overlay_Move_Pixel(layer, 0, 4, layer, 0, 5); |
Cube_Overlay_Move_Pixel(layer, 0, 3, layer, 0, 4); |
Cube_Overlay_Move_Pixel(layer, 0, 2, layer, 0, 3); |
Cube_Overlay_Move_Pixel(layer, 0, 1, layer, 0, 2); |
Cube_Overlay_Set_Pixel(layer, 0, 1, origin_R, origin_G, origin_B); |
break; |
case 1: |
// Rotate second to outermost layer |
Cube_Overlay_Get_Pixel(layer, 1, 1, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 2, 1, layer, 1, 1); |
Cube_Overlay_Move_Pixel(layer, 3, 1, layer, 2, 1); |
Cube_Overlay_Move_Pixel(layer, 4, 1, layer, 3, 1); |
Cube_Overlay_Move_Pixel(layer, 5, 1, layer, 4, 1); |
Cube_Overlay_Move_Pixel(layer, 6, 1, layer, 5, 1); |
Cube_Overlay_Move_Pixel(layer, 6, 2, layer, 6, 1); |
Cube_Overlay_Move_Pixel(layer, 6, 3, layer, 6, 2); |
Cube_Overlay_Move_Pixel(layer, 6, 4, layer, 6, 3); |
Cube_Overlay_Move_Pixel(layer, 6, 5, layer, 6, 4); |
Cube_Overlay_Move_Pixel(layer, 6, 6, layer, 6, 5); |
Cube_Overlay_Move_Pixel(layer, 5, 6, layer, 6, 6); |
Cube_Overlay_Move_Pixel(layer, 4, 6, layer, 5, 6); |
Cube_Overlay_Move_Pixel(layer, 3, 6, layer, 4, 6); |
Cube_Overlay_Move_Pixel(layer, 2, 6, layer, 3, 6); |
Cube_Overlay_Move_Pixel(layer, 1, 6, layer, 2, 6); |
Cube_Overlay_Move_Pixel(layer, 1, 5, layer, 1, 6); |
Cube_Overlay_Move_Pixel(layer, 1, 4, layer, 1, 5); |
Cube_Overlay_Move_Pixel(layer, 1, 3, layer, 1, 4); |
Cube_Overlay_Move_Pixel(layer, 1, 2, layer, 1, 3); |
Cube_Overlay_Set_Pixel(layer, 1, 2, origin_R, origin_G, origin_B); |
break; |
case 2: |
// Rotate second to innermost layer |
Cube_Overlay_Get_Pixel(layer, 2, 2, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 3, 2, layer, 2, 2); |
Cube_Overlay_Move_Pixel(layer, 4, 2, layer, 3, 2); |
Cube_Overlay_Move_Pixel(layer, 5, 2, layer, 4, 2); |
Cube_Overlay_Move_Pixel(layer, 5, 3, layer, 5, 2); |
Cube_Overlay_Move_Pixel(layer, 5, 4, layer, 5, 3); |
Cube_Overlay_Move_Pixel(layer, 5, 5, layer, 5, 4); |
Cube_Overlay_Move_Pixel(layer, 4, 5, layer, 5, 5); |
Cube_Overlay_Move_Pixel(layer, 3, 5, layer, 4, 5); |
Cube_Overlay_Move_Pixel(layer, 2, 5, layer, 3, 5); |
Cube_Overlay_Move_Pixel(layer, 2, 4, layer, 2, 5); |
Cube_Overlay_Move_Pixel(layer, 2, 3, layer, 2, 4); |
Cube_Overlay_Set_Pixel(layer, 2, 3, origin_R, origin_G, origin_B); |
break; |
case 3: |
// Rotate innermost layer |
Cube_Overlay_Get_Pixel(layer, 3, 3, &origin_R, &origin_G, &origin_B); |
Cube_Overlay_Move_Pixel(layer, 4, 3, layer, 3, 3); |
Cube_Overlay_Move_Pixel(layer, 4, 4, layer, 4, 3); |
Cube_Overlay_Move_Pixel(layer, 3, 4, layer, 4, 4); |
Cube_Overlay_Set_Pixel(layer, 3, 4, origin_R, origin_G, origin_B); |
break; |
} |
} |
} |
} |
//////////////////////////// |
// Text control functions // |
//////////////////////////// |
void Cube_Text_Init(char *string, char length, int R, int G, int 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; |
Cube_Overlay_Clear(); |
// Copy the passed data into the buffer |
int i; |
for (i = 0; i < length; i++) |
cube_data_ptr->string[i] = string[i]; |
cube_data_ptr->string_length = length; |
cube_data_ptr->string_index = 0; |
cube_data_ptr->string_line = 0; |
cube_data_ptr->string_R = R; |
cube_data_ptr->string_G = G; |
cube_data_ptr->string_B = B; |
} |
void Cube_Text_Interrupt(void) { |
int layer, 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 |
if (cube_data_ptr->string_line == 5) { |
line = 0x0; // Leave a space between characters |
} else { |
line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5) |
+ cube_data_ptr->string_line]; |
} |
// Draw the line onto (0,0) using the specified color |
for (layer = 7; layer >= 0; layer--) { |
if (line & 0x1) { |
Cube_Overlay_Set_Pixel(layer, 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); |
} |
line >>= 1; |
} |
// Increment the vertical line and the character 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) { |
cube_data_ptr->string_index = 0; |
} else { |
cube_data_ptr->string_index += 1; |
} |
} else { |
cube_data_ptr->string_line += 1; |
} |
} |
///////////////////////////////////////////// |
// Functions for processing streaming data // |
///////////////////////////////////////////// |
void Cube_Data_In(char c) { |
// Reset upon receiving the start char |
if (c == CUBE_START_CHAR) { |
cube_data_ptr->frame_length = 0; |
cube_data_ptr->frame_index = 0; |
cube_data_ptr->frame_checksum = 0; |
cube_data_ptr->frame_command = 0; |
cube_data_ptr->frame_escape = 0; |
cube_data_ptr->frame_state = READ_LENGTH_MSB; |
return; |
} |
// If the input is the escape char, XOR the next char received |
if (c == CUBE_ESCAPE_CHAR) { |
cube_data_ptr->frame_escape = 1; |
return; |
} |
// XOR the input char if needed |
if (cube_data_ptr->frame_escape) { |
c ^= CUBE_ESCAPE_XOR; |
cube_data_ptr->frame_escape = 0; |
} |
// Process data |
switch (cube_data_ptr->frame_state) { |
case IDLE: |
// Reflect the character back to the transmitter |
UART1_Write(&c, 1); |
break; |
case READ_LENGTH_MSB: // Save MSB of length |
cube_data_ptr->frame_length |= (c << 8); |
cube_data_ptr->frame_state = READ_LENGTH_LSB; |
break; |
case READ_LENGTH_LSB: // Save LSB of length |
cube_data_ptr->frame_length |= c; |
cube_data_ptr->frame_state = READ_COMMAND; |
break; |
case READ_COMMAND: // Store the command byte |
cube_data_ptr->frame_checksum += c; |
cube_data_ptr->frame_command = c; |
if (cube_data_ptr->frame_length == 1) |
cube_data_ptr->frame_state = READ_CHECKSUM; |
else |
cube_data_ptr->frame_state = READ_DATA; |
break; |
case READ_DATA: // Read the passed data into the buffer |
cube_data_ptr->frame_checksum += c; |
cube_data_ptr->frame_buffer[cube_data_ptr->frame_index] = c; |
cube_data_ptr->frame_index++; |
if (cube_data_ptr->frame_index == cube_data_ptr->frame_length - 1) |
cube_data_ptr->frame_state = READ_CHECKSUM; |
break; |
case READ_CHECKSUM: // Process frame if checksum is valid |
cube_data_ptr->frame_checksum = 0xFF - cube_data_ptr->frame_checksum; |
if (cube_data_ptr->frame_checksum == c) { |
Cube_Data_In_Process_Frame(); |
} |
cube_data_ptr->frame_state = IDLE; |
cube_data_ptr->frame_index = 0; |
cube_data_ptr->frame_length = 0; |
break; |
default: |
break; |
} |
} |
void Cube_Data_In_Process_Frame(void) { |
// Here we process received frames depending on the command |
char *frame = cube_data_ptr->frame_buffer; |
switch (cube_data_ptr->frame_command) { |
case CUBE_COMMAND_SET_BC: |
TIMER5_Stop(); |
Delay_MS(1); // Need to wait for all SPI writes to complete |
Cube_Write_DCS(frame[0]); |
TIMER5_Start(); |
break; |
case CUBE_COMMAND_CLEAR: |
Cube_Clear(); |
break; |
case CUBE_COMMAND_SET_PIXEL: |
Cube_Set_Pixel(frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]); |
break; |
case CUBE_COMMAND_SET_LAYER: |
Cube_Data_Direct_Write(frame[0], &frame[1]); |
break; |
case CUBE_COMMAND_START_TEXT: |
Cube_Text_Init(&frame[3], cube_data_ptr->frame_length - 4, frame[0], frame[1], frame[2]); |
TIMER4_Start(); |
break; |
case CUBE_COMMAND_STOP_TEXT: |
TIMER4_Stop(); |
Cube_Overlay_Clear(); |
break; |
default: |
break; |
} |
} |
void Cube_Data_Direct_Write(char layer, char *buffer) { |
int i; |
for (i = 0; i < GCS_LAYER_SIZE; i++) { |
cube_data_ptr->GCS[layer][i] = buffer[i]; |
} |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.h |
---|
0,0 → 1,125 |
#ifndef CUBE_H |
#define CUBE_H |
// Cube Parameters |
#define CUBE_ROW_COUNT 8 |
#define CUBE_COLUMN_COUNT 8 |
#define CUBE_LAYER_COUNT 8 |
#define CUBE_ROTATIONS 7 |
#define GCS_REG_SIZE 36 |
#define GCS_LAYER_SIZE (GCS_REG_SIZE*CUBE_ROW_COUNT) |
// Color Definitions |
#define RED 0x08F,0x000,0x000 |
#define ORANGE 0x08F,0x020,0x000 |
#define YELLOW 0x08F,0x08F,0x000 |
#define GREEN 0x000,0x08F,0x000 |
#define TEAL 0x000,0x08F,0x08F |
#define BLUE 0x000,0x000,0x08F |
#define PURPLE 0x08F,0x000,0x08F |
// Control Pin Declarations |
#define SFT_D_TRIS TRISBbits.TRISB15 |
#define SFT_S_TRIS TRISDbits.TRISD5 |
#define SFT_K_TRIS TRISDbits.TRISD4 |
#define SFT_R_TRIS TRISBbits.TRISB14 |
#define SFT_D PORTBbits.RB15 |
#define SFT_S PORTDbits.RD5 |
#define SFT_K PORTDbits.RD4 |
#define SFT_R PORTBbits.RB14 |
#define GSLAT_TRIS TRISDbits.TRISD9 |
#define XBLNK_TRIS TRISDbits.TRISD2 |
#define GSLAT PORTDbits.RD9 |
#define XBLNK PORTDbits.RD2 |
// String Overlay Buffer Size |
#define CUBE_STRING_MAX_LENGTH 32 |
// Data Streaming In Buffer Size |
#define CUBE_FRAME_BUFFER_SIZE 600 |
#define CUBE_START_CHAR 0x7E |
#define CUBE_ESCAPE_CHAR 0x7D |
#define CUBE_ESCAPE_XOR 0x20 |
// Data Streaming In Command Set |
#define CUBE_COMMAND_SET_BC 0x0A // [Brightness Value] |
#define CUBE_COMMAND_CLEAR 0x0B // (no data) |
#define CUBE_COMMAND_SET_PIXEL 0x10 // [Layer, Row, Column, R, G, B] |
#define CUBE_COMMAND_SET_LAYER 0x11 // [Layer, R1, G1, B1, R2, ...] |
#define CUBE_COMMAND_START_TEXT 0x20 // [R, G, B, Char1, Char2, Char3, ...] |
#define CUBE_COMMAND_STOP_TEXT 0x21 // (no data) |
typedef enum { |
IDLE, |
READ_LENGTH_MSB, |
READ_LENGTH_LSB, |
READ_COMMAND, |
READ_DATA, |
READ_CHECKSUM |
} PROCESS_STATE; |
typedef struct { |
// Variables for base cube |
unsigned char GCS[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
unsigned char GCS_OVERLAY[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
unsigned char GCS_WRITE[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
unsigned char current_layer; |
unsigned char rotation_counter; |
// Variables for the scrolling text |
unsigned char string[CUBE_STRING_MAX_LENGTH]; |
unsigned char string_length; |
unsigned char string_index; |
unsigned char string_line; |
int string_R, string_G, string_B; |
// Variables for input frame data |
PROCESS_STATE frame_state; |
unsigned char frame_buffer[CUBE_FRAME_BUFFER_SIZE]; |
char frame_checksum; |
int frame_length; |
int frame_index; |
int frame_command; |
int frame_escape; |
} CUBE_DATA; |
void Cube_Init(CUBE_DATA *data, char BC); |
void Cube_Timer_Interrupt(void); |
// Callbacks on completion of DCS/GCS writes |
void Cube_DCS_Write_Callback(void); |
void Cube_GCS_Write_Callback(void); |
// Cube control functions |
void Cube_Write_DCS(char BC); |
void Cube_Clear(void); |
void Cube_Set_All(int R, int G, int B); |
void Cube_Set_Layer(int layer, int R, int G, int B); |
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B); |
void Cube_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B); |
void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2); |
void Cube_Rotate_Shell(char shell, char direction); |
void Cube_Rotate(char direction); |
// Overlay control functions |
void Cube_Overlay_Clear(void); |
void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B); |
void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B); |
void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2); |
void Cube_Overlay_Rotate_Shell(char shell, char direction); |
// Text control functions |
void Cube_Text_Init(char *string, char length, int R, int G, int B); |
void Cube_Text_Interrupt(void); |
// Data stream in control functions |
void Cube_Data_In(char c); |
void Cube_Data_In_Process_Frame(void); |
void Cube_Data_Direct_Write(char layer, char *buffer); |
#endif /* CUBE_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.c |
---|
0,0 → 1,120 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "SPI1.h" |
static SPI1_DATA *spi_data_ptr; |
void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(char)) { |
spi_data_ptr = data; |
spi_data_ptr->buffer_out_ind = 0; |
spi_data_ptr->buffer_out_len = 0; |
spi_data_ptr->rx_callback = rx_callback; |
INTDisableInterrupts(); |
// Note: FIFO enhanced buffer depth is 4/8/16 for 32/16/8 bit widths |
// Alternative Configuration: |
// The third value is the SPI bitrate which is 1/2 the frequency of the |
// desired clock frequency. Thus 40Mhz / (20Mhz / 2) = 4. |
// Note: SPI_OPEN_TBE_NOT_FULL should only be used at >10Mhz speeds |
// SpiChnOpen(SPI_CHANNEL1, SPI_OPEN_MSTEN | SPI_OPEN_ENHBUF | SPI_OPEN_TBE_NOT_FULL | SPI_OPEN_RBF_NOT_EMPTY, 4); |
// INTSetVectorPriority(INT_SPI_1_VECTOR, INT_PRIORITY_LEVEL_6); |
// INTSetVectorSubPriority(INT_SPI_1_VECTOR, INT_SUB_PRIORITY_LEVEL_1); |
// INTClearFlag(INT_SPI1E); |
// INTClearFlag(INT_SPI1TX); |
// INTClearFlag(INT_SPI1RX); |
// FSCK = FPB / (2 * (SPIxBRG + 1)) |
IEC0CLR = 0x03800000; // Disable all SPI interrupts |
SPI1CON = 0; // Stops and resets the SPI1. |
int tmp = SPI1BUF; // Clears the receive buffer |
IFS0CLR = 0x03800000; // Clear any existing event |
IPC5CLR = 0x1F000000; // Clear the priority |
IPC5SET = 0x19000000; // Set IPL=6, Subpriority 1 |
SPI1BRG = 0x1; // Use FPB/4 clock frequency |
SPI1STATCLR = 0x40; // Clear the Overflow |
#ifndef SPI_WRITE_ONLY |
IEC0SET = 0x01800000; // Enable RX and Error interrupts |
#endif |
// Enhanced buffer, SPI on, 8 bits transfer, SMP=1, Master mode |
// SPIxTXIF set on buffer empty, SPIxRXIF set on buffer not empty |
SPI1CON = 0x18225; |
INTEnableInterrupts(); |
} |
int SPI1_Write(unsigned char *array, unsigned int count, void (*tx_callback)(void)) { |
spi_data_ptr->tx_callback = tx_callback; |
if (count > SPI1_BUFFER_SIZE) |
return 0; |
if (spi_data_ptr->buffer_out_len != 0) |
return 0; |
// Put the data to send into the outbound buffer |
spi_data_ptr->buffer_out_len = count; |
spi_data_ptr->buffer_out_ind = count-1; |
int i; |
for (i = 0; i < count; i++) { |
spi_data_ptr->buffer_out[i] = array[i]; |
} |
IEC0SET = 0x02000000; // Enable TX interrupt |
return 1; |
} |
void __ISR(_SPI_1_VECTOR, ipl6) __SPI_1_Interrupt_Handler(void) { |
#ifndef SPI_WRITE_ONLY |
// Process SPI1 error flag |
if (IFS0bits.SPI1EIF) { |
// Clear the receive overflow bit if it is set |
if (SPI1STATbits.SPIROV) { |
SPI1STATbits.SPIROV = 0; |
} |
IFS0CLR = 0x00800000; // Clear the error flag |
} |
// Process SPI1 receive flag |
if (IFS0bits.SPI1RXIF) { |
int i; |
// Read the data received from the last transfer |
int rxBufferCount = SPI1STATbits.RXBUFELM; |
for (i = 0; i < rxBufferCount; i++) { |
char c = SPI1BUF; |
// Call the RX callback function on the received data |
if (spi_data_ptr->rx_callback != NULL) |
(*spi_data_ptr->rx_callback)(c); |
} |
IFS0CLR = 0x01000000; // Clear the RX flag |
} |
#endif |
// Process SPI1 transmit flag |
if (IFS0bits.SPI1TXIF && IEC0bits.SPI1TXIE) { |
int i; |
// Disable the transmit interrupt if all data has been sent |
if (spi_data_ptr->buffer_out_len == 0) { |
IEC0CLR=0x02000000; |
if (spi_data_ptr->tx_callback != NULL) |
(*spi_data_ptr->tx_callback)(); |
} else { |
// Start transmitting the data in the buffer |
int txBufferFree = 16 - SPI1STATbits.TXBUFELM; |
if (spi_data_ptr->buffer_out_len > txBufferFree) { |
for (i = 0; i < txBufferFree; i++) { |
SPI1BUF = spi_data_ptr->buffer_out[spi_data_ptr->buffer_out_ind]; |
spi_data_ptr->buffer_out_ind--; |
} |
spi_data_ptr->buffer_out_len -= txBufferFree; |
} else { |
for (i = 0; i < spi_data_ptr->buffer_out_len; i++) { |
SPI1BUF = spi_data_ptr->buffer_out[spi_data_ptr->buffer_out_ind]; |
spi_data_ptr->buffer_out_ind--; |
} |
spi_data_ptr->buffer_out_len = 0; |
} |
} |
IFS0CLR = 0x02000000; // Clear the TX flag |
} |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.c |
---|
0,0 → 1,106 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "UART1.h" |
static UART1_DATA *uart_data_ptr; |
/* Note: BRGH values are different from PIC18! |
* |
* Baud Rate Calculation (BRGH = 0): |
* Baud Rate = PerfBusFreq / (16 * (BRG + 1)) |
* BRG = PerfBusFreq / (16 * Baud Rate) - 1 |
* |
* Baud Rate Calculation (BRGH = 1): |
* Baud Rate = PerfBusFreq / (4 * (BRG + 1)) |
* BRG = PerfBusFreq / (4 * Baud Rate) - 1 |
*/ |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)) { |
uart_data_ptr = data; |
uart_data_ptr->rx_callback = rx_callback; |
uart_data_ptr->buffer_out_len = 0; |
uart_data_ptr->buffer_out_ind = 0; |
INTDisableInterrupts(); |
IEC0CLR = 0x1C000000; // Disable all UART1 interrupts |
IFS0CLR = 0x1C000000; // Clear any existing events |
IPC6SET = 0x00000009; // Set Priority = 2, Subpriority = 1 |
U1MODE = 0x00008000; // UART enabled, BRGH = 0 |
U1STA = 0x00009400; // TX interrupt on buffer empty, RX interrupt on buffer not empty |
U1BRG = 42; // Set baud rate to 115200 @ 80MHz |
IEC0SET = 0x0C000000; // Enable the RX and Error interrupts |
INTEnableInterrupts(); |
TRISDbits.TRISD14 = 0; |
PORTDbits.RD14 = 0; |
} |
int UART1_Write(char *string, int length) { |
if (length > UART1_BUFFER_SIZE) |
return 0; |
if (uart_data_ptr->buffer_out_len != 0) |
return 0; |
// Put the data to send into the outbound buffer |
uart_data_ptr->buffer_out_len = length; |
uart_data_ptr->buffer_out_ind = 0; |
int i; |
for (i = 0; i < length; i++) { |
uart_data_ptr->buffer_out[i] = string[i]; |
} |
IEC0SET = 0x10000000; // Enable TX interrupt |
return 1; |
} |
void __ISR(_UART_1_VECTOR, ipl2) __UART_1_Interrupt_Handler(void) { |
PORTDbits.RD14 = 1; |
// Process UART1 error flag |
if (IFS0bits.U1EIF) { |
if (U1STAbits.PERR) { // Process parity error |
} |
if (U1STAbits.FERR) { // Process frame error |
} |
if (U1STAbits.OERR) { // Process receive buffer overrun error |
U1STAbits.OERR = 0; // Clear the overrun error if set |
} |
IFS0CLR = 0x04000000; // Clear the error flag |
} |
// Process UART1 recieve flag |
if (IFS0bits.U1RXIF) { |
// Read the data received from the last transfer |
while (U1STAbits.URXDA) { |
char c = U1RXREG; |
// Call the RX callback function on each received data |
if (uart_data_ptr->rx_callback != NULL) { |
(*uart_data_ptr->rx_callback)(c); |
} |
} |
IFS0CLR = 0x08000000; // Clear the recieve flag |
} |
// Process UART1 transmit flag |
if (IFS0bits.U1TXIF && IEC0bits.U1TXIE) { |
// Disable the transmit interrupt if all data has been sent |
if (uart_data_ptr->buffer_out_ind == uart_data_ptr->buffer_out_len) { |
IEC0CLR = 0x10000000; |
uart_data_ptr->buffer_out_len = 0; |
} else { |
// Start filling the transmit buffer |
while (!U1STAbits.UTXBF) { |
U1TXREG = uart_data_ptr->buffer_out[uart_data_ptr->buffer_out_ind]; |
uart_data_ptr->buffer_out_ind++; |
if (uart_data_ptr->buffer_out_ind == uart_data_ptr->buffer_out_len) |
break; |
} |
} |
IFS0CLR = 0x10000000; // Clear the transmit flag |
} |
PORTDbits.RD14 = 0; |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/main.c |
---|
0,0 → 1,583 |
// <editor-fold defaultstate="collapsed" desc="Configuration Bits"> |
/* ------------------------------------------------------------ */ |
/* PIC32 Configuration Settings */ |
/* ------------------------------------------------------------ */ |
/* Oscillator Settings */ |
#pragma config FNOSC = PRIPLL // Oscillator Selection Bits |
#pragma config POSCMOD = EC // Primary Oscillator Configuration |
#pragma config FPLLIDIV = DIV_2 // PLL Input Divider |
#pragma config FPLLMUL = MUL_20 // PLL Multiplier |
#pragma config FPLLODIV = DIV_1 // PLL Output Divider |
#pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (timers/UART/SPI/I2C) |
#pragma config FSOSCEN = OFF // Secondary Oscillator Enable |
/* Clock Control Settings */ |
#pragma config IESO = OFF // Internal/External Clock Switch Over |
#pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection |
#pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin |
/* USB Settings */ |
#pragma config UPLLEN = ON // USB PLL Enable |
#pragma config UPLLIDIV = DIV_2 // USB PLL Input Divider |
#pragma config FVBUSONIO = OFF // USB VBUS ON Selection |
#pragma config FUSBIDIO = OFF // USB USID Selection |
/* Other Peripheral Device Settings */ |
#pragma config FWDTEN = OFF // Watchdog Timer Enable |
#pragma config WDTPS = PS1024 // Watchdog Timer Postscaler |
#pragma config FSRSSEL = PRIORITY_7 // SRS Interrupt Priority |
#pragma config FCANIO = OFF // CAN I/O Pin Select (default/alternate) |
#pragma config FETHIO = ON // Ethernet I/O Pin Select (default/alternate) |
#pragma config FMIIEN = OFF // Ethernet MII/RMII select (OFF=RMII) |
/* Code Protection Settings */ |
#pragma config CP = OFF // Code Protect |
#pragma config BWP = OFF // Boot Flash Write Protect |
#pragma config PWP = OFF // Program Flash Write Protect |
/* Debug Settings */ |
#pragma config ICESEL = ICS_PGx1 // ICE/ICD Comm Channel Select (on-board debugger) |
/* ------------------------------------------------------------ */ |
// </editor-fold> |
#include <xc.h> |
#include <plib.h> |
#include <stdlib.h> |
#include "defines.h" |
#include "UART1.h" |
#include "SPI1.h" |
#include "TIMER4.h" |
#include "TIMER5.h" |
#include "CUBE.h" |
#include "BTN.h" |
void BTN1_Interrupt(void); |
void BTN2_Interrupt(void); |
void BTN3_Interrupt(void); |
void Animation_Solid_Colors(int iterations, int delay_ms); |
void Animation_Layer_Alternate(int iterations, int delay_ms); |
void Animation_Pixel_Alternate(int iterations, int delay_ms); |
void Animation_Full_Color_Sweep(int iterations, int delay_us); |
void Animation_Row_Column_Sweep(int iterations, int delay_ms); |
void Animation_Pixel_Sweep(int iterations, int delay_ms); |
void Animation_Pseudo_Random_Colors(int iterations,int delay_ms); |
void Animation_Random_Colors(int iterations, int delay_ms); |
void Animation_Cube_In_Cube(int iterations, int delay_ms); |
void Animation_Double_Rotation(int iterations, int delay_ms); |
void Delay_MS(unsigned int delay_ms) { |
// Delays the CPU for the given amount of time. |
// Note: Watch out for integer overflow! (max delay_ms = 107374) ?? |
unsigned int delay = delay_ms * MS_TO_CT_TICKS; |
unsigned int startTime = ReadCoreTimer(); |
while ((unsigned int)(ReadCoreTimer() - startTime) < delay) {}; |
} |
void Delay_US(unsigned int delay_us) { |
// Delays the CPU for the given amount of time. |
// Note: Watch out for integer overflow! |
unsigned int delay = delay_us * US_TO_CT_TICKS; |
unsigned int startTime = ReadCoreTimer(); |
while ((unsigned int)(ReadCoreTimer() - startTime) < delay) {}; |
} |
int main() { |
/* Configure the target for maximum performance at 80 MHz. */ |
// Note: This overrides the peripheral clock to 80Mhz regardless of config |
SYSTEMConfigPerformance(CPU_CLOCK_HZ); |
// Configure the interrupts for multiple vectors |
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR); |
// Set all analog I/O pins to digital |
AD1PCFGSET = 0xFFFF; |
// Initialize the SPI1 module |
SPI1_DATA spi_data; |
SPI1_Init(&spi_data, NULL); |
// Initialize the UART1 module |
UART1_DATA uart_data; |
UART1_Init(&uart_data, &Cube_Data_In); |
// Initializs the PWM2 output to 20MHz |
PWM2_Init(); |
PWM2_Start(); |
// Initialize the cube variables |
CUBE_DATA cube_data; |
Cube_Init(&cube_data, 0x40); |
// Start the cube update layer interrupt |
// 2083 = 60Hz, 500 = 250Hz, 250 = 500Hz |
TIMER5_DATA timer_5_data; |
TIMER5_Init(&timer_5_data, &Cube_Timer_Interrupt, 500); |
TIMER5_Start(); |
// Start the overlay rotation interrupt |
TIMER4_DATA timer_4_data; |
TIMER4_Init(&timer_4_data, &Cube_Text_Interrupt, 120000); |
// Process button inputs |
BTN_DATA btn_data; |
BTN_Init(&btn_data, &BTN1_Interrupt, &BTN2_Interrupt, &BTN3_Interrupt); |
// Begin display |
// Cube_Set_All(RED); |
// Delay_MS(6000); |
// Cube_Set_All(GREEN); |
// Delay_MS(6000); |
// Cube_Set_All(BLUE); |
// Delay_MS(6000); |
// char start_text[] = "Cube Initialized\r\n"; |
// UART1_Write(start_text, 18); |
// Set the overlay text |
// char text_string[] = "Welcome to the CCM Lab "; |
// Cube_Text_Init(text_string, 26, 0xFF, 0xFF, 0xFF); |
// TIMER4_Start(); |
// Loop through some preset animations |
while(1) { |
// Animation_Solid_Colors(2,300); |
// Animation_Layer_Alternate(2,300); |
// Animation_Pixel_Alternate(1,200); |
// Animation_Full_Color_Sweep(2,1000); |
// Animation_Row_Column_Sweep(2,40); |
// Animation_Cube_In_Cube(4,300); |
// Animation_Double_Rotation(2,40); |
// Animation_Pseudo_Random_Colors(10,300); |
// Animation_Random_Colors(10,300); |
} |
} |
// Function call on button 1 press to change refresh rate |
void BTN1_Interrupt(void) { |
static char state; |
state = (state == 4) ? 0 : state + 1; |
TIMER5_Stop(); |
switch (state) { |
case 0: |
TIMER5_Init(NULL, &Cube_Timer_Interrupt, 500); // 250Hz |
break; |
case 1: |
TIMER5_Init(NULL, &Cube_Timer_Interrupt, 2083); // 60Hz |
break; |
case 2: |
TIMER5_Init(NULL, &Cube_Timer_Interrupt, 4166); // 30Hz |
break; |
case 3: |
TIMER5_Init(NULL, &Cube_Timer_Interrupt, 12498); // 10Hz |
break; |
case 4: |
TIMER5_Init(NULL, &Cube_Timer_Interrupt, 24996); // 5Hz |
break; |
} |
TIMER5_Start(); |
} |
// Function call on button 2 press to change brightness |
void BTN2_Interrupt(void) { |
static char state; |
state = (state == 6) ? 0 : state + 1; |
TIMER5_Stop(); |
Delay_MS(1); // Need to wait for all SPI writes to complete |
char BC; |
switch (state) { |
case 0: |
BC = 0x01; |
break; |
case 1: |
BC = 0x08; |
break; |
case 2: |
BC = 0x10; |
break; |
case 3: |
BC = 0x20; |
break; |
case 4: |
BC = 0x40; |
break; |
case 5: |
BC = 0x80; |
break; |
case 6: |
BC = 0xFF; |
break; |
} |
Cube_Write_DCS(BC); |
TIMER5_Start(); |
} |
// Function call on button 3 press to change text scroll speed |
void BTN3_Interrupt(void) { |
static char state; |
state = (state == 4) ? 0 : state + 1; |
TIMER4_Stop(); |
switch (state) { |
case 0: |
TIMER4_Init(NULL, &Cube_Text_Interrupt, 209712); |
break; |
case 1: |
TIMER4_Init(NULL, &Cube_Text_Interrupt, 180000); |
break; |
case 2: |
TIMER4_Init(NULL, &Cube_Text_Interrupt, 150000); |
break; |
case 3: |
TIMER4_Init(NULL, &Cube_Text_Interrupt, 120000); |
break; |
case 4: |
TIMER4_Init(NULL, &Cube_Text_Interrupt, 90000); |
break; |
} |
TIMER4_Start(); |
} |
void Animation_Solid_Colors(int iterations, int delay_ms) { |
int i; |
for (i = 0; i < iterations; i++) { |
Cube_Set_All(RED); |
Delay_MS(delay_ms); |
Cube_Set_All(GREEN); |
Delay_MS(delay_ms); |
Cube_Set_All(BLUE); |
Delay_MS(delay_ms); |
} |
} |
void Animation_Layer_Alternate(int iterations, int delay_ms) { |
int i,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
if (i % 3 == 0) |
Cube_Set_Layer(i,RED); |
else if (i % 3 == 1) |
Cube_Set_Layer(i,GREEN); |
else |
Cube_Set_Layer(i,BLUE); |
} |
Delay_MS(delay_ms); |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
if (i % 3 == 0) |
Cube_Set_Layer(i,GREEN); |
else if (i % 3 == 1) |
Cube_Set_Layer(i,BLUE); |
else |
Cube_Set_Layer(i,RED); |
} |
Delay_MS(delay_ms); |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
if (i % 3 == 0) |
Cube_Set_Layer(i,BLUE); |
else if (i % 3 == 1) |
Cube_Set_Layer(i,RED); |
else |
Cube_Set_Layer(i,GREEN); |
} |
Delay_MS(delay_ms); |
} |
} |
void Animation_Pixel_Alternate(int iterations, int delay_ms) { |
int i,j,k,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
Cube_Clear(); |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
int var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,RED); |
else if (var % 3 == 1) |
Cube_Set_Pixel(i,j,k,GREEN); |
else |
Cube_Set_Pixel(i,j,k,BLUE); |
} |
} |
Delay_MS(delay_ms); |
Cube_Clear(); |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
int var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,GREEN); |
else if (var % 3 == 1) |
Cube_Set_Pixel(i,j,k,BLUE); |
else |
Cube_Set_Pixel(i,j,k,RED); |
} |
} |
Delay_MS(delay_ms); |
Cube_Clear(); |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
int var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,BLUE); |
else if (var % 3 == 1) |
Cube_Set_Pixel(i,j,k,RED); |
else |
Cube_Set_Pixel(i,j,k,GREEN); |
} |
} |
Delay_MS(delay_ms); |
} |
} |
} |
void Animation_Full_Color_Sweep(int iterations, int delay_us) { |
int i,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < 0x0FF; i+=2) { |
Cube_Set_All(i,0,0); |
Delay_US(delay_us); |
} |
for (i = 0; i < 0x0FF; i+=2) { |
Cube_Set_All(0x0FF,i,0); |
Delay_US(delay_us); |
} |
for (i = 0x0FF; i >= 0; i-=2) { |
Cube_Set_All(i,0x0FF,0); |
Delay_US(delay_us); |
} |
for (i = 0; i < 0x0FF; i+=2) { |
Cube_Set_All(0,0x0FF,i); |
Delay_US(delay_us); |
} |
for (i = 0; i < 0x0FF; i+=2) { |
Cube_Set_All(i,0x0FF,0x0FF); |
Delay_US(delay_us); |
} |
for (i = 0x0FF; i >= 0; i-=2) { |
Cube_Set_All(0x0FF,i,0x0FF); |
Delay_US(delay_us); |
} |
for (i = 0x0FF; i >= 0; i-=2) { |
Cube_Set_All(i,0,0x0FF); |
Delay_US(delay_us); |
} |
for (i = 0x100; i >= 0; i-=2) { |
Cube_Set_All(0,0,i); |
Delay_US(delay_us); |
} |
} |
} |
void Animation_Row_Column_Sweep(int iterations, int delay_ms) { |
int i,j,k,a,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < 3; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
Cube_Clear(); |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) |
if (i % 3 == 0) |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,j,k,RED); |
else if (i % 3 == 1) |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,j,k,GREEN); |
else |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,j,k,BLUE); |
Delay_MS(delay_ms); |
} |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
Cube_Clear(); |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) |
if (i % 3 == 0) |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,k,j,RED); |
else if (i % 3 == 1) |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,k,j,GREEN); |
else |
for (a = 0; a < CUBE_LAYER_COUNT; a++) |
Cube_Set_Pixel(a,k,j,BLUE); |
Delay_MS(delay_ms); |
} |
for (j = CUBE_LAYER_COUNT-1; j >= 0; j--) { |
Cube_Clear(); |
if (i % 3 == 0) { |
for (k = 0; k < CUBE_LAYER_COUNT; k++) |
if (k == j) |
Cube_Set_Layer(k,RED); |
} else if (i % 3 == 1) { |
for (k = 0; k < CUBE_LAYER_COUNT; k++) |
if (k == j) |
Cube_Set_Layer(k,GREEN); |
} else { |
for (k = 0; k < CUBE_LAYER_COUNT; k++) |
if (k == j) |
Cube_Set_Layer(k,BLUE); |
} |
Delay_MS(delay_ms); |
} |
} |
} |
} |
void Animation_Pixel_Sweep(int iterations, int delay_ms) { |
int i,j,k,z,a; |
for (z = 0; z < iterations; z++) { |
for (a = 0; a < 3; a++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
Cube_Clear(); |
if (a % 3 == 0) { |
Cube_Set_Pixel(i,j,k,RED); |
} else if (a % 3 == 1) { |
Cube_Set_Pixel(i,j,k,GREEN); |
} else { |
Cube_Set_Pixel(i,j,k,BLUE); |
} |
Delay_MS(delay_ms); |
} |
} |
} |
} |
} |
} |
void Animation_Pseudo_Random_Colors(int iterations, int delay_ms) { |
int i,j,k,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
unsigned int a = rand(); |
if (a % 5 == 0) |
Cube_Set_Pixel(i,j,k,RED); |
else if (a % 5 == 1) |
Cube_Set_Pixel(i,j,k,GREEN); |
else if (a % 5 == 2) |
Cube_Set_Pixel(i,j,k,BLUE); |
else if (a % 5 == 3) |
Cube_Set_Pixel(i,j,k,PURPLE); |
else if (a % 5 == 4) |
Cube_Set_Pixel(i,j,k,YELLOW); |
else |
Cube_Set_Pixel(i,j,k,ORANGE); |
} |
} |
} |
Delay_MS(delay_ms); |
} |
} |
void Animation_Random_Colors(int iterations, int delay_ms) { |
int i,j,k,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF); |
} |
} |
} |
Delay_MS(delay_ms); |
} |
} |
void Animation_Cube_In_Cube(int iterations, int delay_ms) { |
int z,x,i,j,k; |
for (z = 0; z < iterations; z++) { |
for (x = 0; x < 5; x++) { |
Cube_Clear(); |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
if ((x == 0 || x == 4)&&(i == 0 || i == 7)) { |
Cube_Set_Layer(i,RED); |
} else if ((x == 1 || x == 4)&&(i == 1 || i == 6)) { |
for (j = 1; j < CUBE_ROW_COUNT-1; j++) |
for (k = 1; k < CUBE_COLUMN_COUNT-1; k++) |
Cube_Set_Pixel(i,j,k,YELLOW); |
} else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) { |
for (j = 2; j < CUBE_ROW_COUNT-2; j++) |
for (k = 2; k < CUBE_COLUMN_COUNT-2; k++) |
Cube_Set_Pixel(i,j,k,GREEN); |
} else if ((x == 3 || x == 4)&&(i == 3 || i == 4)) { |
for (j = 3; j < CUBE_ROW_COUNT-3; j++) |
for (k = 3; k < CUBE_COLUMN_COUNT-3; k++) |
Cube_Set_Pixel(i,j,k,BLUE); |
} |
if ((x == 0 || x == 4)&&(i > 0 && i < 8)) { |
for (j = 0; j < 8; j++) { |
Cube_Set_Pixel(i,j,0,RED); |
Cube_Set_Pixel(i,j,7,RED); |
Cube_Set_Pixel(i,0,j,RED); |
Cube_Set_Pixel(i,7,j,RED); |
} |
} |
if ((x == 1 || x == 4)&&(i > 1 && i < 7)) { |
for (j = 1; j < 7; j++) { |
Cube_Set_Pixel(i,j,1,YELLOW); |
Cube_Set_Pixel(i,j,6,YELLOW); |
Cube_Set_Pixel(i,1,j,YELLOW); |
Cube_Set_Pixel(i,6,j,YELLOW); |
} |
} |
if ((x == 2 || x == 4)&&(i > 2 && i < 6)) { |
for (j = 2; j < 6; j++) { |
Cube_Set_Pixel(i,j,2,GREEN); |
Cube_Set_Pixel(i,j,5,GREEN); |
Cube_Set_Pixel(i,2,j,GREEN); |
Cube_Set_Pixel(i,5,j,GREEN); |
} |
} |
} |
Delay_MS(delay_ms); |
} |
} |
} |
void Animation_Double_Rotation(int iterations, int delay_ms) { |
Cube_Clear(); |
int i,x,y,z; |
for (z = 0; z < 3; z++) { |
switch (z % 3) { |
case 0: |
for (y = 0; y < CUBE_LAYER_COUNT; y++) { |
Cube_Set_Pixel(y,0,0,RED); |
Cube_Set_Pixel(y,1,1,RED); |
Cube_Set_Pixel(y,2,2,RED); |
Cube_Set_Pixel(y,3,3,RED); |
Cube_Set_Pixel(y,4,4,RED); |
Cube_Set_Pixel(y,5,5,RED); |
Cube_Set_Pixel(y,6,6,RED); |
Cube_Set_Pixel(y,7,7,RED); |
} |
break; |
case 1: |
for (y = 0; y < CUBE_LAYER_COUNT; y++) { |
Cube_Set_Pixel(y,0,0,GREEN); |
Cube_Set_Pixel(y,1,1,GREEN); |
Cube_Set_Pixel(y,2,2,GREEN); |
Cube_Set_Pixel(y,3,3,GREEN); |
Cube_Set_Pixel(y,4,4,GREEN); |
Cube_Set_Pixel(y,5,5,GREEN); |
Cube_Set_Pixel(y,6,6,GREEN); |
Cube_Set_Pixel(y,7,7,GREEN); |
} |
break; |
case 2: |
for (y = 0; y < CUBE_LAYER_COUNT; y++) { |
Cube_Set_Pixel(y,0,0,BLUE); |
Cube_Set_Pixel(y,1,1,BLUE); |
Cube_Set_Pixel(y,2,2,BLUE); |
Cube_Set_Pixel(y,3,3,BLUE); |
Cube_Set_Pixel(y,4,4,BLUE); |
Cube_Set_Pixel(y,5,5,BLUE); |
Cube_Set_Pixel(y,6,6,BLUE); |
Cube_Set_Pixel(y,7,7,BLUE); |
} |
break; |
} |
for (i = 0; i < iterations; i++) { |
for (x = 0; x < 28; x++) { |
Delay_MS(delay_ms); |
Cube_Rotate(0); |
} |
} |
} |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-default.mk |
---|
0,0 → 1,210 |
# |
# Generated Makefile - do not edit! |
# |
# Edit the Makefile in the project folder instead (../Makefile). Each target |
# has a -pre and a -post target defined where you can add customized code. |
# |
# This makefile implements configuration specific macros and targets. |
# Include project Makefile |
ifeq "${IGNORE_LOCAL}" "TRUE" |
# do not include local makefile. User is passing all local related variables already |
else |
include Makefile |
# Include makefile containing local settings |
ifeq "$(wildcard nbproject/Makefile-local-default.mk)" "nbproject/Makefile-local-default.mk" |
include nbproject/Makefile-local-default.mk |
endif |
endif |
# Environment |
MKDIR=gnumkdir -p |
RM=rm -f |
MV=mv |
CP=cp |
# Macros |
CND_CONF=default |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
IMAGE_TYPE=debug |
OUTPUT_SUFFIX=elf |
DEBUGGABLE_SUFFIX=elf |
FINAL_IMAGE=dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
else |
IMAGE_TYPE=production |
OUTPUT_SUFFIX=hex |
DEBUGGABLE_SUFFIX=elf |
FINAL_IMAGE=dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
endif |
# Object Directory |
OBJECTDIR=build/${CND_CONF}/${IMAGE_TYPE} |
# Distribution Directory |
DISTDIR=dist/${CND_CONF}/${IMAGE_TYPE} |
# Object Files Quoted if spaced |
OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o ${OBJECTDIR}/UART1.o |
POSSIBLE_DEPFILES=${OBJECTDIR}/main.o.d ${OBJECTDIR}/SPI1.o.d ${OBJECTDIR}/TIMER5.o.d ${OBJECTDIR}/CUBE.o.d ${OBJECTDIR}/PWM2.o.d ${OBJECTDIR}/BTN.o.d ${OBJECTDIR}/TIMER4.o.d ${OBJECTDIR}/UART1.o.d |
# Object Files |
OBJECTFILES=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o ${OBJECTDIR}/UART1.o |
CFLAGS= |
ASFLAGS= |
LDLIBSOPTIONS= |
############# Tool locations ########################################## |
# If you copy a project from one host to another, the path where the # |
# compiler is installed may be different. # |
# If you open this project with MPLAB X in the new host, this # |
# makefile will be regenerated and the paths will be corrected. # |
####################################################################### |
# fixDeps replaces a bunch of sed/cat/printf statements that slow down the build |
FIXDEPS=fixDeps |
.build-conf: ${BUILD_SUBPROJECTS} |
${MAKE} ${MAKE_OPTIONS} -f nbproject/Makefile-default.mk dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
MP_PROCESSOR_OPTION=32MX795F512L |
MP_LINKER_FILE_OPTION= |
# ------------------------------------------------------------------------------------ |
# Rules for buildStep: assemble |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
else |
endif |
# ------------------------------------------------------------------------------------ |
# Rules for buildStep: assembleWithPreprocess |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
else |
endif |
# ------------------------------------------------------------------------------------ |
# Rules for buildStep: compile |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
${OBJECTDIR}/main.o: main.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/main.o.d |
@${FIXDEPS} "${OBJECTDIR}/main.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/main.o.d" -o ${OBJECTDIR}/main.o main.c |
${OBJECTDIR}/SPI1.o: SPI1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/SPI1.o.d |
@${FIXDEPS} "${OBJECTDIR}/SPI1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/SPI1.o.d" -o ${OBJECTDIR}/SPI1.o SPI1.c |
${OBJECTDIR}/TIMER5.o: TIMER5.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/TIMER5.o.d |
@${FIXDEPS} "${OBJECTDIR}/TIMER5.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER5.o.d" -o ${OBJECTDIR}/TIMER5.o TIMER5.c |
${OBJECTDIR}/CUBE.o: CUBE.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/CUBE.o.d |
@${FIXDEPS} "${OBJECTDIR}/CUBE.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/CUBE.o.d" -o ${OBJECTDIR}/CUBE.o CUBE.c |
${OBJECTDIR}/PWM2.o: PWM2.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/PWM2.o.d |
@${FIXDEPS} "${OBJECTDIR}/PWM2.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/PWM2.o.d" -o ${OBJECTDIR}/PWM2.o PWM2.c |
${OBJECTDIR}/BTN.o: BTN.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/BTN.o.d |
@${FIXDEPS} "${OBJECTDIR}/BTN.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/BTN.o.d" -o ${OBJECTDIR}/BTN.o BTN.c |
${OBJECTDIR}/TIMER4.o: TIMER4.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/TIMER4.o.d |
@${FIXDEPS} "${OBJECTDIR}/TIMER4.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER4.o.d" -o ${OBJECTDIR}/TIMER4.o TIMER4.c |
${OBJECTDIR}/UART1.o: UART1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/UART1.o.d |
@${FIXDEPS} "${OBJECTDIR}/UART1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/UART1.o.d" -o ${OBJECTDIR}/UART1.o UART1.c |
else |
${OBJECTDIR}/main.o: main.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/main.o.d |
@${FIXDEPS} "${OBJECTDIR}/main.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/main.o.d" -o ${OBJECTDIR}/main.o main.c |
${OBJECTDIR}/SPI1.o: SPI1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/SPI1.o.d |
@${FIXDEPS} "${OBJECTDIR}/SPI1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/SPI1.o.d" -o ${OBJECTDIR}/SPI1.o SPI1.c |
${OBJECTDIR}/TIMER5.o: TIMER5.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/TIMER5.o.d |
@${FIXDEPS} "${OBJECTDIR}/TIMER5.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER5.o.d" -o ${OBJECTDIR}/TIMER5.o TIMER5.c |
${OBJECTDIR}/CUBE.o: CUBE.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/CUBE.o.d |
@${FIXDEPS} "${OBJECTDIR}/CUBE.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/CUBE.o.d" -o ${OBJECTDIR}/CUBE.o CUBE.c |
${OBJECTDIR}/PWM2.o: PWM2.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/PWM2.o.d |
@${FIXDEPS} "${OBJECTDIR}/PWM2.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/PWM2.o.d" -o ${OBJECTDIR}/PWM2.o PWM2.c |
${OBJECTDIR}/BTN.o: BTN.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/BTN.o.d |
@${FIXDEPS} "${OBJECTDIR}/BTN.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/BTN.o.d" -o ${OBJECTDIR}/BTN.o BTN.c |
${OBJECTDIR}/TIMER4.o: TIMER4.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/TIMER4.o.d |
@${FIXDEPS} "${OBJECTDIR}/TIMER4.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER4.o.d" -o ${OBJECTDIR}/TIMER4.o TIMER4.c |
${OBJECTDIR}/UART1.o: UART1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/UART1.o.d |
@${FIXDEPS} "${OBJECTDIR}/UART1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/UART1.o.d" -o ${OBJECTDIR}/UART1.o UART1.c |
endif |
# ------------------------------------------------------------------------------------ |
# Rules for buildStep: compileCPP |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
else |
endif |
# ------------------------------------------------------------------------------------ |
# Rules for buildStep: link |
ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX}: ${OBJECTFILES} nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} dist/${CND_CONF}/${IMAGE_TYPE} |
${MP_CC} $(MP_EXTRA_LD_PRE) -mdebugger -D__MPLAB_DEBUGGER_PK3=1 -mprocessor=$(MP_PROCESSOR_OPTION) -o dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} ${OBJECTFILES_QUOTED_IF_SPACED} -Wl,--defsym=__MPLAB_BUILD=1$(MP_EXTRA_LD_POST)$(MP_LINKER_FILE_OPTION),--defsym=__ICD2RAM=1,--defsym=__MPLAB_DEBUG=1,--defsym=__DEBUG=1,--defsym=__MPLAB_DEBUGGER_PK3=1,--report-mem |
else |
dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX}: ${OBJECTFILES} nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} dist/${CND_CONF}/${IMAGE_TYPE} |
${MP_CC} $(MP_EXTRA_LD_PRE) -mprocessor=$(MP_PROCESSOR_OPTION) -o dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${DEBUGGABLE_SUFFIX} ${OBJECTFILES_QUOTED_IF_SPACED} -Wl,--defsym=__MPLAB_BUILD=1$(MP_EXTRA_LD_POST)$(MP_LINKER_FILE_OPTION),--report-mem |
${MP_CC_DIR}\\xc32-bin2hex dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${DEBUGGABLE_SUFFIX} |
endif |
# Subprojects |
.build-subprojects: |
# Subprojects |
.clean-subprojects: |
# Clean Targets |
.clean-conf: ${CLEAN_SUBPROJECTS} |
${RM} -r build/default |
${RM} -r dist/default |
# Enable dependency checking |
.dep.inc: .depcheck-impl |
DEPFILES=$(shell mplabwildcard ${POSSIBLE_DEPFILES}) |
ifneq (${DEPFILES},) |
include ${DEPFILES} |
endif |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-genesis.properties |
---|
0,0 → 1,8 |
# |
#Sat Aug 10 23:28:16 EDT 2013 |
default.com-microchip-mplab-nbide-toolchainXC32-XC32LanguageToolchain.md5=6b4fa04caf3910c7c3a4666b1aea8c5c |
default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\xc32\\v1.20\\bin |
com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=415494acd195d89b2f6d7a36797a5ab4 |
default.languagetoolchain.version=1.20 |
host.platform=windows |
conf.ids=default |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/configurations.xml |
---|
0,0 → 1,186 |
<?xml version="1.0" encoding="UTF-8"?> |
<configurationDescriptor version="62"> |
<logicalFolder name="root" displayName="root" projectFiles="true"> |
<logicalFolder name="HeaderFiles" |
displayName="Header Files" |
projectFiles="true"> |
<itemPath>defines.h</itemPath> |
<itemPath>SPI1.h</itemPath> |
<itemPath>TIMER5.h</itemPath> |
<itemPath>CUBE.h</itemPath> |
<itemPath>BTN.h</itemPath> |
<itemPath>PWM2.h</itemPath> |
<itemPath>TIMER4.h</itemPath> |
<itemPath>glcdfont.h</itemPath> |
<itemPath>UART1.h</itemPath> |
</logicalFolder> |
<logicalFolder name="LinkerScript" |
displayName="Linker Files" |
projectFiles="true"> |
</logicalFolder> |
<logicalFolder name="SourceFiles" |
displayName="Source Files" |
projectFiles="true"> |
<itemPath>main.c</itemPath> |
<itemPath>SPI1.c</itemPath> |
<itemPath>TIMER5.c</itemPath> |
<itemPath>CUBE.c</itemPath> |
<itemPath>PWM2.c</itemPath> |
<itemPath>BTN.c</itemPath> |
<itemPath>TIMER4.c</itemPath> |
<itemPath>UART1.c</itemPath> |
</logicalFolder> |
<logicalFolder name="ExternalFiles" |
displayName="Important Files" |
projectFiles="false"> |
<itemPath>Makefile</itemPath> |
</logicalFolder> |
</logicalFolder> |
<projectmakefile>Makefile</projectmakefile> |
<confs> |
<conf name="default" type="2"> |
<toolsSet> |
<developmentServer>localhost</developmentServer> |
<targetDevice>PIC32MX795F512L</targetDevice> |
<targetHeader></targetHeader> |
<targetPluginBoard></targetPluginBoard> |
<platformTool>PK3OBPlatformTool</platformTool> |
<languageToolchain>XC32</languageToolchain> |
<languageToolchainVersion>1.20</languageToolchainVersion> |
<platform>3</platform> |
</toolsSet> |
<compileType> |
<linkerTool> |
<linkerLibItems> |
</linkerLibItems> |
</linkerTool> |
<loading> |
<useAlternateLoadableFile>false</useAlternateLoadableFile> |
<alternateLoadableFile></alternateLoadableFile> |
</loading> |
</compileType> |
<makeCustomizationType> |
<makeCustomizationPreStepEnabled>false</makeCustomizationPreStepEnabled> |
<makeCustomizationPreStep></makeCustomizationPreStep> |
<makeCustomizationPostStepEnabled>false</makeCustomizationPostStepEnabled> |
<makeCustomizationPostStep></makeCustomizationPostStep> |
<makeCustomizationPutChecksumInUserID>false</makeCustomizationPutChecksumInUserID> |
<makeCustomizationEnableLongLines>false</makeCustomizationEnableLongLines> |
<makeCustomizationNormalizeHexFile>false</makeCustomizationNormalizeHexFile> |
</makeCustomizationType> |
<C32> |
<property key="additional-warnings" value="false"/> |
<property key="enable-app-io" value="false"/> |
<property key="enable-omit-frame-pointer" value="false"/> |
<property key="enable-symbols" value="true"/> |
<property key="enable-unroll-loops" value="true"/> |
<property key="exclude-floating-point" value="false"/> |
<property key="extra-include-directories" value=""/> |
<property key="generate-16-bit-code" value="false"/> |
<property key="isolate-each-function" value="false"/> |
<property key="make-warnings-into-errors" value="false"/> |
<property key="optimization-level" value="-O1"/> |
<property key="place-data-into-section" value="false"/> |
<property key="post-instruction-scheduling" value="default"/> |
<property key="pre-instruction-scheduling" value="default"/> |
<property key="preprocessor-macros" value=""/> |
<property key="strict-ansi" value="false"/> |
<property key="support-ansi" value="false"/> |
<property key="use-cci" value="false"/> |
<property key="use-indirect-calls" value="false"/> |
</C32> |
<C32-AS> |
<property key="assembler-symbols" value=""/> |
<property key="enable-symbols" value="true"/> |
<property key="exclude-floating-point-library" value="false"/> |
<property key="expand-macros" value="false"/> |
<property key="extra-include-directories-for-assembler" value=""/> |
<property key="extra-include-directories-for-preprocessor" value=""/> |
<property key="false-conditionals" value="false"/> |
<property key="keep-locals" value="false"/> |
<property key="list-assembly" value="false"/> |
<property key="list-source" value="false"/> |
<property key="list-symbols" value="false"/> |
<property key="oXC32asm-list-to-file" value="false"/> |
<property key="omit-debug-dirs" value="false"/> |
<property key="omit-forms" value="false"/> |
<property key="preprocessor-macros" value=""/> |
<property key="warning-level" value=""/> |
</C32-AS> |
<C32-LD> |
<property key="additional-options-use-response-files" value="false"/> |
<property key="enable-check-sections" value="false"/> |
<property key="exclude-floating-point-library" value="false"/> |
<property key="exclude-standard-libraries" value="false"/> |
<property key="extra-lib-directories" value=""/> |
<property key="generate-16-bit-code" value="false"/> |
<property key="generate-cross-reference-file" value="false"/> |
<property key="heap-size" value=""/> |
<property key="input-libraries" value=""/> |
<property key="linker-symbols" value=""/> |
<property key="map-file" value=""/> |
<property key="no-startup-files" value="false"/> |
<property key="oXC32ld-extra-opts" value=""/> |
<property key="optimization-level" value=""/> |
<property key="preprocessor-macros" value=""/> |
<property key="remove-unused-sections" value="false"/> |
<property key="report-memory-usage" value="true"/> |
<property key="stack-size" value=""/> |
<property key="symbol-stripping" value=""/> |
<property key="trace-symbols" value=""/> |
<property key="warn-section-align" value="false"/> |
</C32-LD> |
<C32CPP> |
<property key="additional-warnings" value="false"/> |
<property key="check-new" value="false"/> |
<property key="eh-specs" value="true"/> |
<property key="enable-app-io" value="false"/> |
<property key="enable-omit-frame-pointer" value="false"/> |
<property key="enable-symbols" value="true"/> |
<property key="enable-unroll-loops" value="true"/> |
<property key="exceptions" value="true"/> |
<property key="exclude-floating-point" value="false"/> |
<property key="extra-include-directories" value=""/> |
<property key="generate-16-bit-code" value="false"/> |
<property key="isolate-each-function" value="false"/> |
<property key="make-warnings-into-errors" value="false"/> |
<property key="optimization-level" value="-O1"/> |
<property key="place-data-into-section" value="false"/> |
<property key="post-instruction-scheduling" value="default"/> |
<property key="pre-instruction-scheduling" value="default"/> |
<property key="preprocessor-macros" value=""/> |
<property key="rtti" value="true"/> |
<property key="strict-ansi" value="false"/> |
<property key="use-cci" value="false"/> |
<property key="use-indirect-calls" value="false"/> |
</C32CPP> |
<C32Global> |
<property key="legacy-libc" value="false"/> |
<property key="save-temps" value="false"/> |
</C32Global> |
<PK3OBPlatformTool> |
<property key="AutoSelectMemRanges" value="auto"/> |
<property key="SecureSegment.SegmentProgramming" value="FullChipProgramming"/> |
<property key="ToolFirmwareFilePath" |
value="Press to browse for a specific firmware version"/> |
<property key="ToolFirmwareOption.UseLatestFirmware" value="true"/> |
<property key="memories.bootflash" value="false"/> |
<property key="memories.configurationmemory" value="false"/> |
<property key="memories.eeprom" value="false"/> |
<property key="memories.id" value="false"/> |
<property key="memories.programmemory" value="true"/> |
<property key="memories.programmemory.end" value="0x1d07ffff"/> |
<property key="memories.programmemory.start" value="0x1d000000"/> |
<property key="poweroptions.powerenable" value="false"/> |
<property key="programoptions.eraseb4program" value="true"/> |
<property key="programoptions.preserveeeprom" value="false"/> |
<property key="programoptions.preserveprogramrange" value="false"/> |
<property key="programoptions.preserveprogramrange.end" value="0x1d0001ff"/> |
<property key="programoptions.preserveprogramrange.start" value="0x1d000000"/> |
<property key="programoptions.usehighvoltageonmclr" value="false"/> |
<property key="programoptions.uselvpprogramming" value="false"/> |
<property key="voltagevalue" value="3.25"/> |
</PK3OBPlatformTool> |
</conf> |
</confs> |
</configurationDescriptor> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/configurations.xml |
---|
0,0 → 1,25 |
<?xml version="1.0" encoding="UTF-8"?> |
<configurationDescriptor version="62"> |
<projectmakefile>Makefile</projectmakefile> |
<defaultConf>0</defaultConf> |
<confs> |
<conf name="default" type="2"> |
<platformToolSN>:=MPLABCommUSB:=04D8:=8108:=0002:=Digilent:=CerebotMX7CK:=D459520:=x:=en</platformToolSN> |
<languageToolchainDir>C:\Program Files (x86)\Microchip\xc32\v1.20\bin</languageToolchainDir> |
<mdbdebugger version="1"> |
<placeholder1>place holder 1</placeholder1> |
<placeholder2>place holder 2</placeholder2> |
</mdbdebugger> |
<runprofile version="6"> |
<args></args> |
<rundir></rundir> |
<buildfirst>true</buildfirst> |
<console-type>0</console-type> |
<terminal-type>0</terminal-type> |
<remove-instrumentation>0</remove-instrumentation> |
<environment> |
</environment> |
</runprofile> |
</conf> |
</confs> |
</configurationDescriptor> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/private.properties |
---|
--- nbproject/private/private.xml (nonexistent) |
+++ nbproject/private/private.xml (revision 215) |
@@ -0,0 +1,4 @@ |
+<?xml version="1.0" encoding="UTF-8"?> |
+<project-private xmlns="http://www.netbeans.org/ns/project-private/1"> |
+ <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/1"/> |
+</project-private> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-impl.mk |
---|
0,0 → 1,69 |
# |
# Generated Makefile - do not edit! |
# |
# Edit the Makefile in the project folder instead (../Makefile). Each target |
# has a pre- and a post- target defined where you can add customization code. |
# |
# This makefile implements macros and targets common to all configurations. |
# |
# NOCDDL |
# Building and Cleaning subprojects are done by default, but can be controlled with the SUB |
# macro. If SUB=no, subprojects will not be built or cleaned. The following macro |
# statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf |
# and .clean-reqprojects-conf unless SUB has the value 'no' |
SUB_no=NO |
SUBPROJECTS=${SUB_${SUB}} |
BUILD_SUBPROJECTS_=.build-subprojects |
BUILD_SUBPROJECTS_NO= |
BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}} |
CLEAN_SUBPROJECTS_=.clean-subprojects |
CLEAN_SUBPROJECTS_NO= |
CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}} |
# Project Name |
PROJECTNAME=Cerebot_32MX7_LED_Cube |
# Active Configuration |
DEFAULTCONF=default |
CONF=${DEFAULTCONF} |
# All Configurations |
ALLCONFS=default |
# build |
.build-impl: .build-pre |
${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-conf |
# clean |
.clean-impl: .clean-pre |
${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .clean-conf |
# clobber |
.clobber-impl: .clobber-pre .depcheck-impl |
${MAKE} SUBPROJECTS=${SUBPROJECTS} CONF=default clean |
# all |
.all-impl: .all-pre .depcheck-impl |
${MAKE} SUBPROJECTS=${SUBPROJECTS} CONF=default build |
# dependency checking support |
.depcheck-impl: |
# @echo "# This code depends on make tool being used" >.dep.inc |
# @if [ -n "${MAKE_VERSION}" ]; then \ |
# echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \ |
# echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \ |
# echo "include \$${DEPFILES}" >>.dep.inc; \ |
# echo "endif" >>.dep.inc; \ |
# else \ |
# echo ".KEEP_STATE:" >>.dep.inc; \ |
# echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \ |
# fi |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-local-default.mk |
---|
0,0 → 1,37 |
# |
# Generated Makefile - do not edit! |
# |
# |
# This file contains information about the location of compilers and other tools. |
# If you commmit this file into your revision control server, you will be able to |
# to checkout the project and build it from the command line with make. However, |
# if more than one person works on the same project, then this file might show |
# conflicts since different users are bound to have compilers in different places. |
# In that case you might choose to not commit this file and let MPLAB X recreate this file |
# for each user. The disadvantage of not commiting this file is that you must run MPLAB X at |
# least once so the file gets created and the project can be built. Finally, you can also |
# avoid using this file at all if you are only building from the command line with make. |
# You can invoke make with the values of the macros: |
# $ makeMP_CC="/opt/microchip/mplabc30/v3.30c/bin/pic30-gcc" ... |
# |
SHELL=cmd.exe |
PATH_TO_IDE_BIN=C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/ |
# Adding MPLAB X bin directory to path. |
PATH:=C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/:$(PATH) |
# Path to java used to run MPLAB X when this makefile was created |
MP_JAVA_PATH="C:\Program Files (x86)\Microchip\MPLABX\sys\java\jre1.6.0_32-windows-x64\java-windows/bin/" |
OS_CURRENT="$(shell uname -s)" |
MP_CC="C:\Program Files (x86)\Microchip\xc32\v1.20\bin\xc32-gcc.exe" |
MP_CPPC="C:\Program Files (x86)\Microchip\xc32\v1.20\bin\xc32-g++.exe" |
# MP_BC is not defined |
MP_AS="C:\Program Files (x86)\Microchip\xc32\v1.20\bin\xc32-as.exe" |
MP_LD="C:\Program Files (x86)\Microchip\xc32\v1.20\bin\xc32-ld.exe" |
MP_AR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin\xc32-ar.exe" |
DEP_GEN=${MP_JAVA_PATH}java -jar "C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/extractobjectdependencies.jar" |
MP_CC_DIR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin" |
MP_CPPC_DIR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin" |
# MP_BC_DIR is not defined |
MP_AS_DIR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin" |
MP_LD_DIR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin" |
MP_AR_DIR="C:\Program Files (x86)\Microchip\xc32\v1.20\bin" |
# MP_BC_DIR is not defined |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-variables.mk |
---|
0,0 → 1,13 |
# |
# Generated - do not edit! |
# |
# NOCDDL |
# |
CND_BASEDIR=`pwd` |
# default configuration |
CND_ARTIFACT_DIR_default=dist/default/production |
CND_ARTIFACT_NAME_default=Cerebot_32MX7_LED_Cube.production.hex |
CND_ARTIFACT_PATH_default=dist/default/production/Cerebot_32MX7_LED_Cube.production.hex |
CND_PACKAGE_DIR_default=${CND_DISTDIR}/default/package |
CND_PACKAGE_NAME_default=cerebot32mx7ledcube.tar |
CND_PACKAGE_PATH_default=${CND_DISTDIR}/default/package/cerebot32mx7ledcube.tar |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Package-default.bash |
---|
0,0 → 1,73 |
#!/bin/bash -x |
# |
# Generated - do not edit! |
# |
# Macros |
TOP=`pwd` |
CND_CONF=default |
CND_DISTDIR=dist |
TMPDIR=build/${CND_CONF}/${IMAGE_TYPE}/tmp-packaging |
TMPDIRNAME=tmp-packaging |
OUTPUT_PATH=dist/${CND_CONF}/${IMAGE_TYPE}/Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
OUTPUT_BASENAME=Cerebot_32MX7_LED_Cube.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
PACKAGE_TOP_DIR=cerebot32mx7ledcube/ |
# Functions |
function checkReturnCode |
{ |
rc=$? |
if [ $rc != 0 ] |
then |
exit $rc |
fi |
} |
function makeDirectory |
# $1 directory path |
# $2 permission (optional) |
{ |
mkdir -p "$1" |
checkReturnCode |
if [ "$2" != "" ] |
then |
chmod $2 "$1" |
checkReturnCode |
fi |
} |
function copyFileToTmpDir |
# $1 from-file path |
# $2 to-file path |
# $3 permission |
{ |
cp "$1" "$2" |
checkReturnCode |
if [ "$3" != "" ] |
then |
chmod $3 "$2" |
checkReturnCode |
fi |
} |
# Setup |
cd "${TOP}" |
mkdir -p ${CND_DISTDIR}/${CND_CONF}/package |
rm -rf ${TMPDIR} |
mkdir -p ${TMPDIR} |
# Copy files and create directories and links |
cd "${TOP}" |
makeDirectory ${TMPDIR}/cerebot32mx7ledcube/bin |
copyFileToTmpDir "${OUTPUT_PATH}" "${TMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}" 0755 |
# Generate tar file |
cd "${TOP}" |
rm -f ${CND_DISTDIR}/${CND_CONF}/package/cerebot32mx7ledcube.tar |
cd ${TMPDIR} |
tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/package/cerebot32mx7ledcube.tar * |
checkReturnCode |
# Cleanup |
cd "${TOP}" |
rm -rf ${TMPDIR} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/project.properties |
---|
--- nbproject/project.xml (nonexistent) |
+++ nbproject/project.xml (revision 215) |
@@ -0,0 +1,16 @@ |
+<?xml version="1.0" encoding="UTF-8"?> |
+<project xmlns="http://www.netbeans.org/ns/project/1"> |
+ <type>com.microchip.mplab.nbide.embedded.makeproject</type> |
+ <configuration> |
+ <data xmlns="http://www.netbeans.org/ns/make-project/1"> |
+ <name>Cerebot_32MX7</name> |
+ <creation-uuid>a23479a1-6afc-4362-a20c-e5ddcf3c7815</creation-uuid> |
+ <make-project-type>0</make-project-type> |
+ <c-extensions>c</c-extensions> |
+ <cpp-extensions/> |
+ <header-extensions>h</header-extensions> |
+ <sourceEncoding>ISO-8859-1</sourceEncoding> |
+ <make-dep-projects/> |
+ </data> |
+ </configuration> |
+</project> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CubeInterface.py |
---|
0,0 → 1,260 |
import serial |
from CubeRawCommands import * |
# Constants |
CUBE_LAYER_COUNT = 8 |
CUBE_ROW_COUNT = 8 |
CUBE_COLUMN_COUNT = 8 |
CUBE_ROTATIONS = 7 |
GCS_REG_SIZE = 36 |
GCS_LAYER_SIZE = GCS_REG_SIZE * CUBE_ROW_COUNT |
# 3 bytes per LED, 1536 total for the cube |
cube_buffer = bytearray(CUBE_LAYER_COUNT*GCS_LAYER_SIZE) |
rotation_counter = 0 |
# Specify the serial port to connect to |
serial_port = serial.Serial() |
'''Opens the serial port for sending commands through.''' |
def Cube_Init(port, baudrate): |
serial_port.port = port |
serial_port.baudrate = baudrate |
serial_port.open() |
'''Clears the local buffer for LED values.''' |
def Cube_Clear(): |
for i in range(len(cube_buffer)): |
cube_buffer[i] = 0 |
'''Sets a specific pixel in the local buffer.''' |
def Cube_Set_Pixel(layer, row, column, R, G, B): |
# Set the specified pixel to the given color |
R &= 0x0FFF |
G &= 0x0FFF |
B &= 0x0FFF |
var = row * GCS_REG_SIZE + (column // 2 * 9) |
offset = (layer * GCS_LAYER_SIZE) + var |
if column % 2 == 0: |
cube_buffer[offset+0] = R & 0xFF |
cube_buffer[offset+1] = ((G << 4) | (R >> 8)) & 0xFF |
cube_buffer[offset+2] = G >> 4 |
cube_buffer[offset+3] = B & 0xFF |
cube_buffer[offset+4] = ((cube_buffer[offset+4] & 0xF0) | (B >> 8)) & 0xFF |
elif column % 2 == 1: |
cube_buffer[offset+4] = ((cube_buffer[offset+4] & 0x0F) | (R << 4)) & 0xFF |
cube_buffer[offset+5] = R >> 4 |
cube_buffer[offset+6] = G & 0xFF |
cube_buffer[offset+7] = ((B << 4) | (G >> 8)) & 0xFF |
cube_buffer[offset+8] = B >> 4 |
'''Retreives a specific pixel in the local buffer.''' |
def Cube_Get_Pixel(layer, row, column): |
# Get and return the color for the specified pixel |
R = G = B = 0 |
var = row * GCS_REG_SIZE + (column // 2 * 9) |
offset = (layer * GCS_LAYER_SIZE) + var |
if column % 2 == 0: |
R = cube_buffer[offset+0] | ((cube_buffer[offset+1] & 0x0F) << 8); |
G = (cube_buffer[offset+1] >> 4) | (cube_buffer[offset+2] << 4); |
B = cube_buffer[offset+3] | ((cube_buffer[offset+4] & 0x0F) << 8); |
elif column % 2 == 1: |
R = (cube_buffer[offset+4] >> 4) | (cube_buffer[offset+5] << 4); |
G = cube_buffer[offset+6] | ((cube_buffer[offset+7] & 0x0F) << 8); |
B = (cube_buffer[offset+7] >> 4) | (cube_buffer[offset+8] << 4); |
return [R,G,B] |
'''Moves a value from one pixel to another in the local buffer.''' |
def Cube_Move_Pixel(layer_1, row_1, column_1, layer_2, row_2, column_2): |
old = Cube_Get_Pixel(layer1, row_1, column_1) |
Cube_Set_Pixel(layer_2, row_2, column_2, old[0], old[1], old[2]) |
'''Rotates the specified shell in the local buffer.''' |
def Cube_Rotate_Shell(shell, direction): |
for layer in range(CUBE_LAYER_COUNT): |
if direction == 1: |
if shell == 0: |
# Rotate outermost layer |
old = Cube_Get_Pixel(layer, 0, 0); |
Cube_Move_Pixel(layer, 0, 1, layer, 0, 0); |
Cube_Move_Pixel(layer, 0, 2, layer, 0, 1); |
Cube_Move_Pixel(layer, 0, 3, layer, 0, 2); |
Cube_Move_Pixel(layer, 0, 4, layer, 0, 3); |
Cube_Move_Pixel(layer, 0, 5, layer, 0, 4); |
Cube_Move_Pixel(layer, 0, 6, layer, 0, 5); |
Cube_Move_Pixel(layer, 0, 7, layer, 0, 6); |
Cube_Move_Pixel(layer, 1, 7, layer, 0, 7); |
Cube_Move_Pixel(layer, 2, 7, layer, 1, 7); |
Cube_Move_Pixel(layer, 3, 7, layer, 2, 7); |
Cube_Move_Pixel(layer, 4, 7, layer, 3, 7); |
Cube_Move_Pixel(layer, 5, 7, layer, 4, 7); |
Cube_Move_Pixel(layer, 6, 7, layer, 5, 7); |
Cube_Move_Pixel(layer, 7, 7, layer, 6, 7); |
Cube_Move_Pixel(layer, 7, 6, layer, 7, 7); |
Cube_Move_Pixel(layer, 7, 5, layer, 7, 6); |
Cube_Move_Pixel(layer, 7, 4, layer, 7, 5); |
Cube_Move_Pixel(layer, 7, 3, layer, 7, 4); |
Cube_Move_Pixel(layer, 7, 2, layer, 7, 3); |
Cube_Move_Pixel(layer, 7, 1, layer, 7, 2); |
Cube_Move_Pixel(layer, 7, 0, layer, 7, 1); |
Cube_Move_Pixel(layer, 6, 0, layer, 7, 0); |
Cube_Move_Pixel(layer, 5, 0, layer, 6, 0); |
Cube_Move_Pixel(layer, 4, 0, layer, 5, 0); |
Cube_Move_Pixel(layer, 3, 0, layer, 4, 0); |
Cube_Move_Pixel(layer, 2, 0, layer, 3, 0); |
Cube_Move_Pixel(layer, 1, 0, layer, 2, 0); |
Cube_Set_Pixel(layer, 1, 0, old[0], old[1], old[2]); |
elif shell == 1: |
# Rotate second to outermost layer |
old = Cube_Get_Pixel(layer, 1, 1); |
Cube_Move_Pixel(layer, 1, 2, layer, 1, 1); |
Cube_Move_Pixel(layer, 1, 3, layer, 1, 2); |
Cube_Move_Pixel(layer, 1, 4, layer, 1, 3); |
Cube_Move_Pixel(layer, 1, 5, layer, 1, 4); |
Cube_Move_Pixel(layer, 1, 6, layer, 1, 5); |
Cube_Move_Pixel(layer, 2, 6, layer, 1, 6); |
Cube_Move_Pixel(layer, 3, 6, layer, 2, 6); |
Cube_Move_Pixel(layer, 4, 6, layer, 3, 6); |
Cube_Move_Pixel(layer, 5, 6, layer, 4, 6); |
Cube_Move_Pixel(layer, 6, 6, layer, 5, 6); |
Cube_Move_Pixel(layer, 6, 5, layer, 6, 6); |
Cube_Move_Pixel(layer, 6, 4, layer, 6, 5); |
Cube_Move_Pixel(layer, 6, 3, layer, 6, 4); |
Cube_Move_Pixel(layer, 6, 2, layer, 6, 3); |
Cube_Move_Pixel(layer, 6, 1, layer, 6, 2); |
Cube_Move_Pixel(layer, 5, 1, layer, 6, 1); |
Cube_Move_Pixel(layer, 4, 1, layer, 5, 1); |
Cube_Move_Pixel(layer, 3, 1, layer, 4, 1); |
Cube_Move_Pixel(layer, 2, 1, layer, 3, 1); |
Cube_Set_Pixel(layer, 2, 1, old[0], old[1], old[2]); |
elif shell == 2: |
# Rotate second to innermost layer |
old = Cube_Get_Pixel(layer, 2, 2); |
Cube_Move_Pixel(layer, 2, 3, layer, 2, 2); |
Cube_Move_Pixel(layer, 2, 4, layer, 2, 3); |
Cube_Move_Pixel(layer, 2, 5, layer, 2, 4); |
Cube_Move_Pixel(layer, 3, 5, layer, 2, 5); |
Cube_Move_Pixel(layer, 4, 5, layer, 3, 5); |
Cube_Move_Pixel(layer, 5, 5, layer, 4, 5); |
Cube_Move_Pixel(layer, 5, 4, layer, 5, 5); |
Cube_Move_Pixel(layer, 5, 3, layer, 5, 4); |
Cube_Move_Pixel(layer, 5, 2, layer, 5, 3); |
Cube_Move_Pixel(layer, 4, 2, layer, 5, 2); |
Cube_Move_Pixel(layer, 3, 2, layer, 4, 2); |
Cube_Set_Pixel(layer, 3, 2, old[0], old[1], old[2]); |
elif shell == 3: |
# Rotate innermost layer |
old = Cube_Get_Pixel(layer, 3, 3); |
Cube_Move_Pixel(layer, 3, 4, layer, 3, 3); |
Cube_Move_Pixel(layer, 4, 4, layer, 3, 4); |
Cube_Move_Pixel(layer, 4, 3, layer, 4, 4); |
Cube_Set_Pixel(layer, 4, 3, old[0], old[1], old[2]); |
else: |
if shell == 0: |
# Rotate outermost layer |
old = Cube_Get_Pixel(layer, 0, 0); |
Cube_Move_Pixel(layer, 1, 0, layer, 0, 0); |
Cube_Move_Pixel(layer, 2, 0, layer, 1, 0); |
Cube_Move_Pixel(layer, 3, 0, layer, 2, 0); |
Cube_Move_Pixel(layer, 4, 0, layer, 3, 0); |
Cube_Move_Pixel(layer, 5, 0, layer, 4, 0); |
Cube_Move_Pixel(layer, 6, 0, layer, 5, 0); |
Cube_Move_Pixel(layer, 7, 0, layer, 6, 0); |
Cube_Move_Pixel(layer, 7, 1, layer, 7, 0); |
Cube_Move_Pixel(layer, 7, 2, layer, 7, 1); |
Cube_Move_Pixel(layer, 7, 3, layer, 7, 2); |
Cube_Move_Pixel(layer, 7, 4, layer, 7, 3); |
Cube_Move_Pixel(layer, 7, 5, layer, 7, 4); |
Cube_Move_Pixel(layer, 7, 6, layer, 7, 5); |
Cube_Move_Pixel(layer, 7, 7, layer, 7, 6); |
Cube_Move_Pixel(layer, 6, 7, layer, 7, 7); |
Cube_Move_Pixel(layer, 5, 7, layer, 6, 7); |
Cube_Move_Pixel(layer, 4, 7, layer, 5, 7); |
Cube_Move_Pixel(layer, 3, 7, layer, 4, 7); |
Cube_Move_Pixel(layer, 2, 7, layer, 3, 7); |
Cube_Move_Pixel(layer, 1, 7, layer, 2, 7); |
Cube_Move_Pixel(layer, 0, 7, layer, 1, 7); |
Cube_Move_Pixel(layer, 0, 6, layer, 0, 7); |
Cube_Move_Pixel(layer, 0, 5, layer, 0, 6); |
Cube_Move_Pixel(layer, 0, 4, layer, 0, 5); |
Cube_Move_Pixel(layer, 0, 3, layer, 0, 4); |
Cube_Move_Pixel(layer, 0, 2, layer, 0, 3); |
Cube_Move_Pixel(layer, 0, 1, layer, 0, 2); |
Cube_Set_Pixel(layer, 0, 1, old[0], old[1], old[2]); |
if shell == 1: |
# Rotate second to outermost layer |
old = Cube_Get_Pixel(layer, 1, 1); |
Cube_Move_Pixel(layer, 2, 1, layer, 1, 1); |
Cube_Move_Pixel(layer, 3, 1, layer, 2, 1); |
Cube_Move_Pixel(layer, 4, 1, layer, 3, 1); |
Cube_Move_Pixel(layer, 5, 1, layer, 4, 1); |
Cube_Move_Pixel(layer, 6, 1, layer, 5, 1); |
Cube_Move_Pixel(layer, 6, 2, layer, 6, 1); |
Cube_Move_Pixel(layer, 6, 3, layer, 6, 2); |
Cube_Move_Pixel(layer, 6, 4, layer, 6, 3); |
Cube_Move_Pixel(layer, 6, 5, layer, 6, 4); |
Cube_Move_Pixel(layer, 6, 6, layer, 6, 5); |
Cube_Move_Pixel(layer, 5, 6, layer, 6, 6); |
Cube_Move_Pixel(layer, 4, 6, layer, 5, 6); |
Cube_Move_Pixel(layer, 3, 6, layer, 4, 6); |
Cube_Move_Pixel(layer, 2, 6, layer, 3, 6); |
Cube_Move_Pixel(layer, 1, 6, layer, 2, 6); |
Cube_Move_Pixel(layer, 1, 5, layer, 1, 6); |
Cube_Move_Pixel(layer, 1, 4, layer, 1, 5); |
Cube_Move_Pixel(layer, 1, 3, layer, 1, 4); |
Cube_Move_Pixel(layer, 1, 2, layer, 1, 3); |
Cube_Set_Pixel(layer, 1, 2, old[0], old[1], old[2]); |
if shell == 2: |
# Rotate second to innermost layer |
old = Cube_Get_Pixel(layer, 2, 2); |
Cube_Move_Pixel(layer, 3, 2, layer, 2, 2); |
Cube_Move_Pixel(layer, 4, 2, layer, 3, 2); |
Cube_Move_Pixel(layer, 5, 2, layer, 4, 2); |
Cube_Move_Pixel(layer, 5, 3, layer, 5, 2); |
Cube_Move_Pixel(layer, 5, 4, layer, 5, 3); |
Cube_Move_Pixel(layer, 5, 5, layer, 5, 4); |
Cube_Move_Pixel(layer, 4, 5, layer, 5, 5); |
Cube_Move_Pixel(layer, 3, 5, layer, 4, 5); |
Cube_Move_Pixel(layer, 2, 5, layer, 3, 5); |
Cube_Move_Pixel(layer, 2, 4, layer, 2, 5); |
Cube_Move_Pixel(layer, 2, 3, layer, 2, 4); |
Cube_Set_Pixel(layer, 2, 3, old[0], old[1], old[2]); |
if shell == 3: |
# Rotate innermost layer |
old = Cube_Get_Pixel(layer, 3, 3); |
Cube_Move_Pixel(layer, 4, 3, layer, 3, 3); |
Cube_Move_Pixel(layer, 4, 4, layer, 4, 3); |
Cube_Move_Pixel(layer, 3, 4, layer, 4, 4); |
Cube_Set_Pixel(layer, 3, 4, old[0], old[1], old[2]); |
'''Rotates the entire cube in the local buffer.''' |
def Cube_Rotate(direction): |
# Rotate outermost layer |
Cube_Rotate_Shell(0, direction); |
# Rotate second to outermost layer |
if ((rotation_counter != 1) and (rotation_counter != 5)): |
Cube_Rotate_Shell(1, direction); |
# Rotate second to innermost layer |
if ((rotation_counter != 0) and (rotation_counter != 2) and (rotation_counter != 4) and (rotation_counter != 6)): |
Cube_Rotate_Shell(2, direction); |
# Rotate innermost layer |
if ((rotation_counter == 3) or (rotation_counter == 7)): |
Cube_Rotate_Shell(3, direction); |
if (direction == 0): |
if rotation_counter == CUBE_ROTATIONS - 1: |
rotation_counter = 0 |
else: |
rotation_counter = rotation_counter + 1 |
else: |
if rotation_counter == 0: |
rotation_counter = CUBE_ROTATIONS - 1 |
else: |
rotation_counter = rotation_counter - 1 |
'''Write the local buffer to the cube.''' |
def Cube_Update(): |
offset = 0 |
for layer in range(CUBE_LAYER_COUNT): |
serial_port.write(CMD_Set_Layer(layer, cube_buffer[offset:offset+GCS_LAYER_SIZE])) |
offset += GCS_LAYER_SIZE |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CubeMain.py |
---|
0,0 → 1,13 |
import serial,time |
from CubeRawCommands import * |
from CubeInterface import * |
if __name__ == '__main__': |
Cube_Init('COM11', 115200) |
Cube_Clear() |
Cube_Set_Pixel(0,0,0,0xFFF,0xFFF,0xFFF) |
Cube_Set_Pixel(1,0,0,0xFFF,0x000,0x000) |
Cube_Set_Pixel(0,1,0,0x000,0xFFF,0x000) |
Cube_Set_Pixel(0,0,1,0x000,0x000,0xFFF) |
Cube_Update() |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CubeRawCommands.py |
---|
0,0 → 1,44 |
'''Generates the byte array for setting the global brightness.''' |
def CMD_Set_BC(brightness): |
barray = bytearray.fromhex('7E 00 02 0A') |
barray.extend([brightness]) |
barray.extend([Calculate_Checksum(barray)]) |
return barray |
'''Generates the byte array for clearing all pixels.''' |
def CMD_Clear(): |
return bytearray.fromhex('7E 00 01 0B F4') |
'''Generates the command for setting a specific pixel.''' |
def CMD_Set_Pixel(layer, row, column, r, g, b): |
barray = bytearray.fromhex('7E 00 07 10') |
barray.extend([layer,row,column,r,g,b,]) |
barray.extend([Calculate_Checksum(barray)]) |
return barray |
'''Generates the command for setting an entire layer.''' |
def CMD_Set_Layer(layer, leds): |
barray = bytearray.fromhex('7E 01 22 11') |
barray.extend([layer]) |
barray.extend(leds) |
barray.extend([Calculate_Checksum(barray)]) |
return barray |
'''Generates the command for setting the rotating overlay text.''' |
def CMD_Start_Text(r, g, b, string): |
length = len(string) + 4 |
barray = bytearray.fromhex('7E 00') |
barray.extend([length, 0x20, r, g, b]) |
barray.extend(string.encode()) |
barray.extend([Calculate_Checksum(barray)]) |
return barray |
'''Generates the command for stopping the rotating overlay text.''' |
def CMD_Stop_Text(): |
return bytes.fromhex('7E 00 01 21 DE') |
def Calculate_Checksum(barray): |
s = 0 |
for entry in range(3,len(barray)): |
s += barray[entry] |
return 255 - (s & 0xFF) |
/PIC Stuff/Cerebot_32MX7_LED_Cube/BTN.c |
---|
0,0 → 1,63 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "BTN.h" |
static BTN_DATA *btn_data_ptr; |
void BTN_Init(BTN_DATA *data, void (*callback_1)(void), void (*callback_2)(void), void (*callback_3)(void)) { |
btn_data_ptr = data; |
btn_data_ptr->callback_function_1 = callback_1; |
btn_data_ptr->callback_function_2 = callback_2; |
btn_data_ptr->callback_function_3 = callback_3; |
BTN1_TRIS = 1; |
BTN2_TRIS = 1; |
BTN3_TRIS = 1; |
INTDisableInterrupts(); |
CNCONSET = 0x8000; // Turn on change notice interrupt |
#if defined CEREBOT_32MX7 |
CNENSET = 0x80300; // Set interrupt on CN8/9/19 |
#elif defined CEREBOT_MX7CK |
CNENSET = 0x00300; // Set interrupt on CN8/9 |
#endif |
int tmp = BTN1_PORT; |
tmp = BTN2_PORT; |
tmp = BTN3_PORT; |
IPC6SET = 0xD0000; // Set priority level = 3, sub-priority level = 1 |
IFS1CLR = 0x1; // Clear interrupt flag |
IEC1SET = 0x1; // Enable interrupt |
INTEnableInterrupts(); |
} |
void __ISR(_CHANGE_NOTICE_VECTOR, ipl3) __CN_Interrupt_Handler(void) { |
// Upon interrupt, debounce input and call saved function |
if (BTN1_PORT == 1) { |
Delay_MS(BTN_DEBOUNCE_MS); |
if (BTN1_PORT == 1) { |
if (btn_data_ptr->callback_function_1 != NULL) |
(*btn_data_ptr->callback_function_1)(); |
} |
} |
if (BTN2_PORT == 1) { |
Delay_MS(BTN_DEBOUNCE_MS); |
if (BTN2_PORT == 1) { |
if (btn_data_ptr->callback_function_2 != NULL) |
(*btn_data_ptr->callback_function_2)(); |
} |
} |
#ifdef CEREBOT_32MX7 |
if (BTN3_PORT == 1) { |
Delay_MS(BTN_DEBOUNCE_MS); |
if (BTN3_PORT == 1) { |
if (btn_data_ptr->callback_function_3 != NULL) |
(*btn_data_ptr->callback_function_3)(); |
} |
} |
#endif |
IFS1CLR = 0x1; // Clear interrupt flag |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/BTN.h |
---|
0,0 → 1,31 |
#ifndef BTN_H |
#define BTN_H |
// BTN1 = CN8, BTN2 = CN9, BTN3 = CN19 (32MX7 only) |
// BTN1 = RG6, BTN2 = RG7, BTN3 = RD13 (32MX7 only) |
// Note: Write to PORTx is effectively the same as write to LATx |
#define BTN1_TRIS TRISGbits.TRISG6 |
#define BTN1_PORT PORTGbits.RG6 |
#define BTN2_TRIS TRISGbits.TRISG7 |
#define BTN2_PORT PORTGbits.RG7 |
#if defined CEREBOT_32MX7 |
#define BTN3_TRIS TRISDbits.TRISD13 |
#define BTN3_PORT PORTDbits.RD13 |
#elif defined CEREBOT_MX7CK |
#define BTN3_TRIS TRISAbits.TRISA0 |
#define BTN3_PORT PORTAbits.RA0 |
#endif |
#define BTN_DEBOUNCE_MS 1 |
typedef struct { |
void (*callback_function_1)(void); |
void (*callback_function_2)(void); |
void (*callback_function_3)(void); |
} BTN_DATA; |
void BTN_Init(BTN_DATA *data, void (*callback_1)(void), void (*callback_2)(void), void (*callback_3)(void)); |
#endif /* BTN_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.h |
---|
0,0 → 1,22 |
#ifndef SPI1_H |
#define SPI1_H |
#define SPI1_BUFFER_SIZE 300 |
#define SPI_WRITE_ONLY |
typedef struct { |
char buffer_out[SPI1_BUFFER_SIZE]; |
int buffer_out_ind; |
int buffer_out_len; |
void (*tx_callback)(void); |
void (*rx_callback)(char); |
} SPI1_DATA; |
void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(char)); |
// Note: SPI1_Write() writes MSB -> LSB! |
int SPI1_Write(unsigned char *array, unsigned int count, void (*tx_callback)(void)); |
#endif /* SPI1_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.h |
---|
0,0 → 1,17 |
#ifndef UART1_H |
#define UART1_H |
#define UART1_BUFFER_SIZE 128 |
typedef struct { |
void (*rx_callback)(char c); |
char buffer_out[UART1_BUFFER_SIZE]; |
int buffer_out_ind; |
int buffer_out_len; |
} UART1_DATA; |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)); |
int UART1_Write(char *string, int length); |
#endif /* UART1_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/defines.h |
---|
0,0 → 1,211 |
// PIC32MX795F512L |
// Uncomment ONE of the following: |
//#define CEREBOT_32MX7 |
#define CEREBOT_MX7CK |
// Power supply must be 5V for proper operation of the board! |
#define CPU_CLOCK_HZ 80000000UL |
#define PERIPHERAL_CLOCK_HZ 80000000UL |
#define CPU_CT_HZ (CPU_CLOCK_HZ/2UL) |
#define MS_TO_CT_TICKS (CPU_CLOCK_HZ/2000UL) |
#define US_TO_CT_TICKS (CPU_CLOCK_HZ/2000000UL) |
#define ADDRESS_EEPROM 0x50 |
// LED1 = G12, LED2 = G13, LED3 = G14, LED4 = G15 (active high) |
#define LED1_TRIS TRISGbits.TRISG12 |
#define LED1_PORT PORTGbits.RG12 |
#define LED2_TRIS TRISGbits.TRISG13 |
#define LED2_PORT PORTGbits.RG13 |
#define LED3_TRIS TRISGbits.TRISG14 |
#define LED3_PORT PORTGbits.RG14 |
#define LED4_TRIS TRISGbits.TRISG15 |
#define LED4_PORT PORTGbits.RG15 |
void Delay_MS(unsigned int delay_ms); |
void Delay_US(unsigned int delay_us); |
// <editor-fold desc="PMOD to MCU Pinouts"> |
/* |
JA-01 AN2/C2IN-/CN4/RB2 RB02 |
JA-02 AN3/C2IN+/CN5/RB3 RB03 |
JA-03 AN4/C1IN-/CN6/RB4 RB04 |
JA-04 PGEC2/AN6/OCFA/RB6 RB06 |
JA-07 PGED2/AN7/RB7 RB07 |
JA-08 AN8/C1OUT/RB8 RB08 |
JA-09 AN9/C2OUT/RB9 RB09 |
JA-10 CVrefout/PMA13/AN10/RB10 RB10 |
* |
JB-01 PMD0/RE0 RE00 |
JB-02 PMD1/RE1 RE01 |
JB-03 PMD2/RE2 RE02 |
JB-04 PMD3/RE3 RE03 |
JB-07 PMD4/RE4 RE04 |
JB-08 PMD5/RE5 RE05 |
JB-09 PMD6/RE6 RE06 |
JB-10 PMD7/RE7 RE07 |
* |
JC-01 T2CK/RC1 RC01 |
JC-02 C2RX/PMD8/RG0 RG00 |
JC-03 C2TX/ETXERR/PMD9/RG1 RG01 |
JC-04 ETXCLK/PMD15/CN16/RD7 RD07 |
JC-07 AN15/ERXD3/AETXD2/OCFB/PMALL/PMA0/CN12/RB15 RB15 (SFT_D) |
JC-08 PMRD/CN14/RD5 RD05 (SFT_S) |
JC-09 OC5/PMWR/CN13/RD4 RD04 (SFT_K) |
JC-10 AN14/ERXD2/AETXD3/PMALH/PMA1/RB14 RB14 (SFT_R) |
* |
JD-01 SS1/IC2/RD9 RD09 (GSLAT) |
JD-02 SDO1/OC1/INT0/RD0 RD00 (GSSIN) |
JD-03 T5CK/SDI1/RC4 RC04 (GSSOUT) |
JD-04 SCK1/IC3/PMCS2/PMA15/RD10 RD10 (GSSCK) |
JD-07 OC2/RD1 RD01 (PWMCK) |
JD-08 OC3/RD2 RD02 (XBLNK) |
JD-09 OC4/RD3 RD03 |
JD-10 ETXD2/IC5/PMD12/RD12 RD12 |
* |
JE-01 AETXD0/SS3/U4RX/U1CTS/CN20/RD14 RD14 |
JE-02 SCL3/SDO3/U1TX/RF8 RF08 |
JE-03 SDA3/SDI3/U1RX/RF2 RF02 |
JE-04 AETXD1/SCK3/U4TX/U1RTS/CN21/RD15 RD15 |
JE-07 TRCLK/RA6 RA06 on 32MX7 or INT1/RF8 on MX7CK |
JE-08 TRD3/RA7 RA07 |
JE-09 Vref-/CVref-/AERXD2/PMA7/RA9 RA09 |
JE-10 Vref+/CVref+/AERXD3/PMA6/RA10 RA10 |
* |
JF-01 AC1RX/SS4/U5RX/U2CTS/RF12 RF12 shared with CAN1 Transceiver (JP-1) |
JF-02 SCL5/SDO4/U2TX/PMA8/CN18/RF5 RF05 |
JF-03 SDA5/SDI4/U2RX/PMA9/CN17/RF4 RF04 |
JF-04 AC1TX/SCK4/U5TX/U2RTS/RF13 RF13 shared with CAN1 Transceiver (JP-2) |
JF-07 TMS/RA0 RA00 on 32MX7 or INT2/RF9 on MX7CK |
JF-08 TCK/RA1 RA01 |
JF-09 TDI/RA4 RA04 |
JF-10 TDO/RA5 RA05 |
N/A SCL2/RA2 RA02 I2C bus #2, not shared with Pmod connector |
N/A SDA2/RA3 RA03 I2C bus #2, not shared with Pmod connector |
N/A AETXCLK/SCL1/INT3/RA14 RA14 I2C Bus #1, not shared with Pmod connector |
N/A AETXEN/SDA1/INT4/RA15 RA15 I2C Bus #1, not shared with Pmod connector |
N/A PGED1/AN0/CN2/RB0 RB00 Used by debug circuit, PGC |
N/A PGEC1/AN1/CN3/RB1 RB01 Used by debug circuit, PGD |
N/A AN5/C1IN+/VBUSON/CN7/RB5 RB05 USB VBUSON |
N/A AN11/ERXERR/AETXERR/PMA12/RB11 RB11 Ethernet PHY |
N/A AN12/ERXD0/AECRS/PMA11/RB12 RB12 Ethernet PHY |
N/A AN13/ERXD1/AECOL/PMA10/RB13 RB13 Ethernet PHY |
N/A OSC1/CLKI/RC12 RC12 Primary Oscillator Crystal |
N/A SOSCI/CN1/RC13 RC13 Secondary Oscillator Crystal |
N/A SOSCO/T1CK/CN0/RC14 RC14 Secondary Oscillator Crystal |
N/A OSC2/CLKO/RC15 RC15 Primary Oscillator Crystal |
N/A ETXEN/PMD14/CN15/RD6 RD06 Ethernet PHY |
N/A RTCC/EMDIO/AEMDIO/IC1/RD8 RD08 Ethernet PHY |
N/A EMDC/AEMDC/IC4/PMCS1/PMA14/RD11 RD11 Ethernet PHY |
N/A ETXD3/PMD13/CN19/RD13 RD13 BTN3 |
N/A AERXD0/INT1/RE8 RE08 USB Overcurrent detect |
N/A AERXD1/INT2/RE9 RE09 Ethernet PHY Reset |
N/A C1RX/ETXD1/PMD11/RF0 RF00 Ethernet PHY |
N/A C1TX/ETXD0/PMD10/RF1 RF01 Ethernet PHY |
N/A USBID/RF3 RF03 USBID (USB-4) |
N/A D+/RG2 RG02 D+ (USB-3) |
N/A D-/RG3 RG03 D- (USB-2) |
N/A ECOL/SCK2/U6TX/U3RTS/PMA5/CN8/RG6 RG06 BTN1 |
N/A ECRS/SDA4/SDI2/U3RX/PMA4/CN9/RG7 RG07 BTN2 |
N/A ERXDV/AERXDV/ECRSDV/AECRSDV/SCL4/SDO2/U3TX/PMA3/CN10/RG8 RG08 Ethernet PHY |
N/A ERXCLK/AERXCLK/EREFCLK/AEREFCLK/SS2/U6RX/U3CTS/PMA2/CN11/RG9 RG09 Ethernet PHY |
N/A TRD1/RG12 RG12 LED1 |
N/A TRD0/RG13 RG13 LED2 |
N/A TRD2/RG14 RG14 LED3 |
N/A AERXERR/RG15 RG15 LED4 |
*/ |
// </editor-fold> |
// <editor-fold defaultstate="collapsed" desc="Connectors"> |
/* |
J1 - Serial USB Misc Connections (MX7CK only) |
* This header contains other FTDI UART function pins (CTS, DSR, DCD, RI) |
J2 - Serial USB Connector (MX7CK only) |
* This connector is connected to UART1 or PMOD JE |
J7 - I2C port daisy chain connector |
* On the Cerebot 32MX7, this connector provides access to the I2C signals, power and ground for I2C2. |
* On the Cerebot MX7CK, this connector provides access to the I2C signals, power and ground for I2C1 + INT3/4. |
J8 - I2C port daisy chain connector |
* On the Cerebot 32MX7, this connector provides access to the I2C signals, power and ground for I2C1. |
* On the Cerebot MX7CK, this connector provides access to the I2C signals, power and ground for I2C2. |
EEPROM is changed to this port on the MX7CK |
J9 - CAN #1 Connector |
* This connector is used to access the signals for CAN #1. |
J10 - CAN #2 Connector |
* This connector is used to access the signals for CAN #2. |
J11 - Ethernet Connector |
* This connector provides access to the 10/100 Ethernet port. |
J12-J14 |
* Do Not Use. |
J15 - Debug USB Connector |
* This connector is used to connect the on-board programming and |
debug circuit to the PC for use with the MPLAB IDE. |
J16 - Power supply source select |
* This jumper is used to select the source of main board power. |
Place a shorting block in the upper, ?USB? position to have the |
board powered from the USB device connector, J19. |
Place a shorting block in the center, ?EXT? position to have the |
board powered from one of the external power connectors, J17 or J18. |
Place a shorting block in the lower, ?DBG? position to have the |
board powered from the debug USB connector, J15. |
J17 - External Power Connector |
* This is a 2.5mm x 5.5mm, center positive, coax power connector used to |
provide external power to the board. The optional Digilent 5V Switching |
Power Supply is connected here. |
J18 - External Power Connector |
* This is a screw terminal connector used to provide external power to |
the board. Be sure to observe proper polarity (marked near the connector) |
when providing power via this connector, or damage to the board and/or |
connected devices may result. |
J19 - USB Device / OTG Connector |
* This is a USB micro-AB connector. It is used when using the PIC32MX795 |
microcontroller to implement a USB device or OTG Host/Device. |
J20 - USB Host Connector |
* This is a standard sized USB type A connector. This connector is used to |
connect USB devices to the board when using the PIC32MX795 microcontroller |
to implement an embedded USB host. |
*/ |
// </editor-fold> |
// <editor-fold defaultstate="collapsed" desc="Jumpers"> |
/* |
JP1 & JP2 - CAN or Pmod Select |
* These jumpers select microcontroller signals RF12 and RF13 for use with CAN |
#1 or Pmod connector JF. Place these jumpers in the CAN position to use CAN |
#1. Place the jumpers in the PMOD position to use then with Pmod connector JF. |
JP3 & JP4 - Pull-up enable for I2C port #2 |
* These two jumpers are used to enable/disable the pull-up resistors on I2C |
port #2. Insert shorting blocks on these two jumpers to enable the pull-up |
resistors. Remove the shorting blocks to disable the pull-up resistors. Only |
a single device on the I2C bus should have the pull-up resistors enabled. |
JP5 - CAN #1 Termination |
* This jumper is used to enable/disable the 120 ohm termination resistor for |
CAN #1. Insert the shorting block to enable the termination resistor, remove |
it to disable the termination resistor. |
JP6 - CAN #1 5V0 Enable |
* This jumper is used to enable/disable providing 5V to the CAN #1 connector. |
Insert the shorting block to connect the board 5V0 supply to pins 9 & 10 of |
CAN #1 connector. Remove the shorting block to disconnect the 5V0 supply. |
JP7 - CAN #2 Termination |
* This jumper is used to enable/disable the 120 ohm termination resistor for |
CAN #2. Insert the shorting block to enable the termination resistor, remove |
it to disable the termination resistor. |
JP8 - CAN #1 5V0 Enable |
* This jumper is used to enable/disable providing 5V to the CAN #1 connector. |
Insert the shorting block to connect the board 5V0 supply to pins 9 & 10 of |
CAN #1 connector. Remove the shorting block to disconnect the 5V0 supply. |
JP9 - Do Not Use |
JP10 - USB Host Power Select |
* This jumper is used to select which host connector is powered when host power |
is enabled. Place the shorting block in the ?MICRO? position to supply power |
to the USB micro-AB OTG Connector, J19. Place the shorting block in the ?A? |
position to supply power to the USB type A Host Connector, J20. |
JP11 - Programmer Serial Select (MX7CK only) |
* Remove the jumper to disconnect the USB serial converter's connection to the |
MCLR pin. Disconnecting this when using the built in debugger is recommended. |
JP17 - Do Not Use |
*/ |
// </editor-fold> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER4.c |
---|
0,0 → 1,57 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "TIMER4.h" |
static TIMER4_DATA *timer_data_ptr; |
void TIMER4_Init(TIMER4_DATA *data, void (*callback)(void), unsigned int time_us) { |
if (data != NULL) // if ptr is null, use existing data |
timer_data_ptr = data; |
timer_data_ptr->callback_function = callback; |
INTDisableInterrupts(); |
T4CON = 0x0; |
// PR5 is 16 bits wide, so we need to determine what pre-scaler to use |
int time; |
if (time_us < 13107) { |
time = 5 * time_us; |
T4CONSET = 0x0040; // Prescaler at 1:16 |
} else if (time_us < 26214) { |
time = 2.5 * time_us; |
T4CONSET = 0x0050; // Prescaler at 1:32 |
} else if (time_us < 52428) { |
time = 1.25 * time_us; |
T4CONSET = 0x0060; // Prescaler at 1:64 |
} else { |
time = 0.3125 * time_us; // Minimum time_us of 209712 |
T4CONSET = 0x0070; // Prescaler at 1:256 |
} |
Nop(); |
TMR4 = 0x0; // Clear timer register |
PR4 = time; // Load period register |
IPC4SET = 0x00000011; // Set priority level = 4, sub-priority level = 1 |
IFS0CLR = 0x00010000; // Clear timer interrupt flag |
IEC0SET = 0x00010000; // Enable timer interrupt |
INTEnableInterrupts(); |
} |
void TIMER4_Start(void) { |
T4CONSET = 0x8000; // Start timer |
} |
void TIMER4_Stop(void) { |
T4CONCLR = 0x8000; // Stop timer |
} |
void __ISR(_TIMER_4_VECTOR, ipl4) __TIMER_4_Interrupt_Handler(void) { |
// Call the saved callback function |
(*timer_data_ptr->callback_function)(); |
IFS0CLR = 0x00010000; // Clear the timer interrupt flag |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER4.h |
---|
0,0 → 1,13 |
#ifndef TIMER4_H |
#define TIMER4_H |
typedef struct { |
void (*callback_function)(void); |
} TIMER4_DATA; |
void TIMER4_Init(TIMER4_DATA *data, void (*callback)(void), unsigned int time_us); |
void TIMER4_Start(void); |
void TIMER4_Stop(void); |
#endif /* TIMER4_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER5.c |
---|
0,0 → 1,57 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "TIMER5.h" |
static TIMER5_DATA *timer_data_ptr; |
void TIMER5_Init(TIMER5_DATA *data, void (*callback)(void), unsigned int time_us) { |
if (data != NULL) // if ptr is null, use existing data |
timer_data_ptr = data; |
timer_data_ptr->callback_function = callback; |
INTDisableInterrupts(); |
T5CON = 0x0; |
// PR5 is 16 bits wide, so we need to determine what pre-scaler to use |
int time; |
if (time_us < 13107) { |
time = 5 * time_us; |
T5CONSET = 0x0040; // Prescaler at 1:16 |
} else if (time_us < 26214) { |
time = 2.5 * time_us; |
T5CONSET = 0x0050; // Prescaler at 1:32 |
} else if (time_us < 52428) { |
time = 1.25 * time_us; |
T5CONSET = 0x0060; // Prescaler at 1:64 |
} else { // Minimum time_us of 209712 |
time = 0.3125 * time_us; |
T5CONSET = 0x0070; // Prescaler at 1:256 |
} |
Nop(); |
TMR5 = 0x0; // Clear timer register |
PR5 = time; // Load period register |
IPC5SET = 0x00000011; // Set priority level = 4, sub-priority level = 1 |
IFS0CLR = 0x00100000; // Clear timer interrupt flag |
IEC0SET = 0x00100000; // Enable timer interrupt |
INTEnableInterrupts(); |
} |
void TIMER5_Start(void) { |
T5CONSET = 0x8000; // Start timer |
} |
void TIMER5_Stop(void) { |
T5CONCLR = 0x8000; // Stop timer |
} |
void __ISR(_TIMER_5_VECTOR, ipl4) __TIMER_5_Interrupt_Handler(void) { |
// Call the saved callback function |
(*timer_data_ptr->callback_function)(); |
IFS0CLR = 0x00100000; // Clear the timer interrupt flag |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER5.h |
---|
0,0 → 1,13 |
#ifndef TIMER5_H |
#define TIMER5_H |
typedef struct { |
void (*callback_function)(void); |
} TIMER5_DATA; |
void TIMER5_Init(TIMER5_DATA *data, void (*callback)(void), unsigned int time_us); |
void TIMER5_Start(void); |
void TIMER5_Stop(void); |
#endif /* TIMER5_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/glcdfont.h |
---|
0,0 → 1,264 |
#ifndef FONT5X7_H |
#define FONT5X7_H |
// Standard ASCII 5x7 font |
// LSB = top of vertical line, 5 lines from left to right |
const char font[] = { |
0x00, 0x00, 0x00, 0x00, 0x00, |
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, |
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, |
0x1C, 0x3E, 0x7C, 0x3E, 0x1C, |
0x18, 0x3C, 0x7E, 0x3C, 0x18, |
0x1C, 0x57, 0x7D, 0x57, 0x1C, |
0x1C, 0x5E, 0x7F, 0x5E, 0x1C, |
0x00, 0x18, 0x3C, 0x18, 0x00, |
0xFF, 0xE7, 0xC3, 0xE7, 0xFF, |
0x00, 0x18, 0x24, 0x18, 0x00, |
0xFF, 0xE7, 0xDB, 0xE7, 0xFF, |
0x30, 0x48, 0x3A, 0x06, 0x0E, |
0x26, 0x29, 0x79, 0x29, 0x26, |
0x40, 0x7F, 0x05, 0x05, 0x07, |
0x40, 0x7F, 0x05, 0x25, 0x3F, |
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, |
0x7F, 0x3E, 0x1C, 0x1C, 0x08, |
0x08, 0x1C, 0x1C, 0x3E, 0x7F, |
0x14, 0x22, 0x7F, 0x22, 0x14, |
0x5F, 0x5F, 0x00, 0x5F, 0x5F, |
0x06, 0x09, 0x7F, 0x01, 0x7F, |
0x00, 0x66, 0x89, 0x95, 0x6A, |
0x60, 0x60, 0x60, 0x60, 0x60, |
0x94, 0xA2, 0xFF, 0xA2, 0x94, |
0x08, 0x04, 0x7E, 0x04, 0x08, |
0x10, 0x20, 0x7E, 0x20, 0x10, |
0x08, 0x08, 0x2A, 0x1C, 0x08, |
0x08, 0x1C, 0x2A, 0x08, 0x08, |
0x1E, 0x10, 0x10, 0x10, 0x10, |
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, |
0x30, 0x38, 0x3E, 0x38, 0x30, |
0x06, 0x0E, 0x3E, 0x0E, 0x06, |
0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x5F, 0x00, 0x00, |
0x00, 0x07, 0x00, 0x07, 0x00, |
0x14, 0x7F, 0x14, 0x7F, 0x14, |
0x24, 0x2A, 0x7F, 0x2A, 0x12, |
0x23, 0x13, 0x08, 0x64, 0x62, |
0x36, 0x49, 0x56, 0x20, 0x50, |
0x00, 0x08, 0x07, 0x03, 0x00, |
0x00, 0x1C, 0x22, 0x41, 0x00, |
0x00, 0x41, 0x22, 0x1C, 0x00, |
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, |
0x08, 0x08, 0x3E, 0x08, 0x08, |
0x00, 0x80, 0x70, 0x30, 0x00, |
0x08, 0x08, 0x08, 0x08, 0x08, |
0x00, 0x00, 0x60, 0x60, 0x00, |
0x20, 0x10, 0x08, 0x04, 0x02, |
0x3E, 0x51, 0x49, 0x45, 0x3E, |
0x00, 0x42, 0x7F, 0x40, 0x00, |
0x72, 0x49, 0x49, 0x49, 0x46, |
0x21, 0x41, 0x49, 0x4D, 0x33, |
0x18, 0x14, 0x12, 0x7F, 0x10, |
0x27, 0x45, 0x45, 0x45, 0x39, |
0x3C, 0x4A, 0x49, 0x49, 0x31, |
0x41, 0x21, 0x11, 0x09, 0x07, |
0x36, 0x49, 0x49, 0x49, 0x36, |
0x46, 0x49, 0x49, 0x29, 0x1E, |
0x00, 0x00, 0x14, 0x00, 0x00, |
0x00, 0x40, 0x34, 0x00, 0x00, |
0x00, 0x08, 0x14, 0x22, 0x41, |
0x14, 0x14, 0x14, 0x14, 0x14, |
0x00, 0x41, 0x22, 0x14, 0x08, |
0x02, 0x01, 0x59, 0x09, 0x06, |
0x3E, 0x41, 0x5D, 0x59, 0x4E, |
0x7C, 0x12, 0x11, 0x12, 0x7C, |
0x7F, 0x49, 0x49, 0x49, 0x36, |
0x3E, 0x41, 0x41, 0x41, 0x22, |
0x7F, 0x41, 0x41, 0x41, 0x3E, |
0x7F, 0x49, 0x49, 0x49, 0x41, |
0x7F, 0x09, 0x09, 0x09, 0x01, |
0x3E, 0x41, 0x41, 0x51, 0x73, |
0x7F, 0x08, 0x08, 0x08, 0x7F, |
0x00, 0x41, 0x7F, 0x41, 0x00, |
0x20, 0x40, 0x41, 0x3F, 0x01, |
0x7F, 0x08, 0x14, 0x22, 0x41, |
0x7F, 0x40, 0x40, 0x40, 0x40, |
0x7F, 0x02, 0x1C, 0x02, 0x7F, |
0x7F, 0x04, 0x08, 0x10, 0x7F, |
0x3E, 0x41, 0x41, 0x41, 0x3E, |
0x7F, 0x09, 0x09, 0x09, 0x06, |
0x3E, 0x41, 0x51, 0x21, 0x5E, |
0x7F, 0x09, 0x19, 0x29, 0x46, |
0x26, 0x49, 0x49, 0x49, 0x32, |
0x03, 0x01, 0x7F, 0x01, 0x03, |
0x3F, 0x40, 0x40, 0x40, 0x3F, |
0x1F, 0x20, 0x40, 0x20, 0x1F, |
0x3F, 0x40, 0x38, 0x40, 0x3F, |
0x63, 0x14, 0x08, 0x14, 0x63, |
0x03, 0x04, 0x78, 0x04, 0x03, |
0x61, 0x59, 0x49, 0x4D, 0x43, |
0x00, 0x7F, 0x41, 0x41, 0x41, |
0x02, 0x04, 0x08, 0x10, 0x20, |
0x00, 0x41, 0x41, 0x41, 0x7F, |
0x04, 0x02, 0x01, 0x02, 0x04, |
0x40, 0x40, 0x40, 0x40, 0x40, |
0x00, 0x03, 0x07, 0x08, 0x00, |
0x20, 0x54, 0x54, 0x78, 0x40, |
0x7F, 0x28, 0x44, 0x44, 0x38, |
0x38, 0x44, 0x44, 0x44, 0x28, |
0x38, 0x44, 0x44, 0x28, 0x7F, |
0x38, 0x54, 0x54, 0x54, 0x18, |
0x00, 0x08, 0x7E, 0x09, 0x02, |
0x18, 0xA4, 0xA4, 0x9C, 0x78, |
0x7F, 0x08, 0x04, 0x04, 0x78, |
0x00, 0x44, 0x7D, 0x40, 0x00, |
0x20, 0x40, 0x40, 0x3D, 0x00, |
0x7F, 0x10, 0x28, 0x44, 0x00, |
0x00, 0x41, 0x7F, 0x40, 0x00, |
0x7C, 0x04, 0x78, 0x04, 0x78, |
0x7C, 0x08, 0x04, 0x04, 0x78, |
0x38, 0x44, 0x44, 0x44, 0x38, |
0xFC, 0x18, 0x24, 0x24, 0x18, |
0x18, 0x24, 0x24, 0x18, 0xFC, |
0x7C, 0x08, 0x04, 0x04, 0x08, |
0x48, 0x54, 0x54, 0x54, 0x24, |
0x04, 0x04, 0x3F, 0x44, 0x24, |
0x3C, 0x40, 0x40, 0x20, 0x7C, |
0x1C, 0x20, 0x40, 0x20, 0x1C, |
0x3C, 0x40, 0x30, 0x40, 0x3C, |
0x44, 0x28, 0x10, 0x28, 0x44, |
0x4C, 0x90, 0x90, 0x90, 0x7C, |
0x44, 0x64, 0x54, 0x4C, 0x44, |
0x00, 0x08, 0x36, 0x41, 0x00, |
0x00, 0x00, 0x77, 0x00, 0x00, |
0x00, 0x41, 0x36, 0x08, 0x00, |
0x02, 0x01, 0x02, 0x04, 0x02, |
0x3C, 0x26, 0x23, 0x26, 0x3C, |
0x1E, 0xA1, 0xA1, 0x61, 0x12, |
0x3A, 0x40, 0x40, 0x20, 0x7A, |
0x38, 0x54, 0x54, 0x55, 0x59, |
0x21, 0x55, 0x55, 0x79, 0x41, |
0x21, 0x54, 0x54, 0x78, 0x41, |
0x21, 0x55, 0x54, 0x78, 0x40, |
0x20, 0x54, 0x55, 0x79, 0x40, |
0x0C, 0x1E, 0x52, 0x72, 0x12, |
0x39, 0x55, 0x55, 0x55, 0x59, |
0x39, 0x54, 0x54, 0x54, 0x59, |
0x39, 0x55, 0x54, 0x54, 0x58, |
0x00, 0x00, 0x45, 0x7C, 0x41, |
0x00, 0x02, 0x45, 0x7D, 0x42, |
0x00, 0x01, 0x45, 0x7C, 0x40, |
0xF0, 0x29, 0x24, 0x29, 0xF0, |
0xF0, 0x28, 0x25, 0x28, 0xF0, |
0x7C, 0x54, 0x55, 0x45, 0x00, |
0x20, 0x54, 0x54, 0x7C, 0x54, |
0x7C, 0x0A, 0x09, 0x7F, 0x49, |
0x32, 0x49, 0x49, 0x49, 0x32, |
0x32, 0x48, 0x48, 0x48, 0x32, |
0x32, 0x4A, 0x48, 0x48, 0x30, |
0x3A, 0x41, 0x41, 0x21, 0x7A, |
0x3A, 0x42, 0x40, 0x20, 0x78, |
0x00, 0x9D, 0xA0, 0xA0, 0x7D, |
0x39, 0x44, 0x44, 0x44, 0x39, |
0x3D, 0x40, 0x40, 0x40, 0x3D, |
0x3C, 0x24, 0xFF, 0x24, 0x24, |
0x48, 0x7E, 0x49, 0x43, 0x66, |
0x2B, 0x2F, 0xFC, 0x2F, 0x2B, |
0xFF, 0x09, 0x29, 0xF6, 0x20, |
0xC0, 0x88, 0x7E, 0x09, 0x03, |
0x20, 0x54, 0x54, 0x79, 0x41, |
0x00, 0x00, 0x44, 0x7D, 0x41, |
0x30, 0x48, 0x48, 0x4A, 0x32, |
0x38, 0x40, 0x40, 0x22, 0x7A, |
0x00, 0x7A, 0x0A, 0x0A, 0x72, |
0x7D, 0x0D, 0x19, 0x31, 0x7D, |
0x26, 0x29, 0x29, 0x2F, 0x28, |
0x26, 0x29, 0x29, 0x29, 0x26, |
0x30, 0x48, 0x4D, 0x40, 0x20, |
0x38, 0x08, 0x08, 0x08, 0x08, |
0x08, 0x08, 0x08, 0x08, 0x38, |
0x2F, 0x10, 0xC8, 0xAC, 0xBA, |
0x2F, 0x10, 0x28, 0x34, 0xFA, |
0x00, 0x00, 0x7B, 0x00, 0x00, |
0x08, 0x14, 0x2A, 0x14, 0x22, |
0x22, 0x14, 0x2A, 0x14, 0x08, |
0xAA, 0x00, 0x55, 0x00, 0xAA, |
0xAA, 0x55, 0xAA, 0x55, 0xAA, |
0x00, 0x00, 0x00, 0xFF, 0x00, |
0x10, 0x10, 0x10, 0xFF, 0x00, |
0x14, 0x14, 0x14, 0xFF, 0x00, |
0x10, 0x10, 0xFF, 0x00, 0xFF, |
0x10, 0x10, 0xF0, 0x10, 0xF0, |
0x14, 0x14, 0x14, 0xFC, 0x00, |
0x14, 0x14, 0xF7, 0x00, 0xFF, |
0x00, 0x00, 0xFF, 0x00, 0xFF, |
0x14, 0x14, 0xF4, 0x04, 0xFC, |
0x14, 0x14, 0x17, 0x10, 0x1F, |
0x10, 0x10, 0x1F, 0x10, 0x1F, |
0x14, 0x14, 0x14, 0x1F, 0x00, |
0x10, 0x10, 0x10, 0xF0, 0x00, |
0x00, 0x00, 0x00, 0x1F, 0x10, |
0x10, 0x10, 0x10, 0x1F, 0x10, |
0x10, 0x10, 0x10, 0xF0, 0x10, |
0x00, 0x00, 0x00, 0xFF, 0x10, |
0x10, 0x10, 0x10, 0x10, 0x10, |
0x10, 0x10, 0x10, 0xFF, 0x10, |
0x00, 0x00, 0x00, 0xFF, 0x14, |
0x00, 0x00, 0xFF, 0x00, 0xFF, |
0x00, 0x00, 0x1F, 0x10, 0x17, |
0x00, 0x00, 0xFC, 0x04, 0xF4, |
0x14, 0x14, 0x17, 0x10, 0x17, |
0x14, 0x14, 0xF4, 0x04, 0xF4, |
0x00, 0x00, 0xFF, 0x00, 0xF7, |
0x14, 0x14, 0x14, 0x14, 0x14, |
0x14, 0x14, 0xF7, 0x00, 0xF7, |
0x14, 0x14, 0x14, 0x17, 0x14, |
0x10, 0x10, 0x1F, 0x10, 0x1F, |
0x14, 0x14, 0x14, 0xF4, 0x14, |
0x10, 0x10, 0xF0, 0x10, 0xF0, |
0x00, 0x00, 0x1F, 0x10, 0x1F, |
0x00, 0x00, 0x00, 0x1F, 0x14, |
0x00, 0x00, 0x00, 0xFC, 0x14, |
0x00, 0x00, 0xF0, 0x10, 0xF0, |
0x10, 0x10, 0xFF, 0x10, 0xFF, |
0x14, 0x14, 0x14, 0xFF, 0x14, |
0x10, 0x10, 0x10, 0x1F, 0x00, |
0x00, 0x00, 0x00, 0xF0, 0x10, |
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, |
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, |
0xFF, 0xFF, 0xFF, 0x00, 0x00, |
0x00, 0x00, 0x00, 0xFF, 0xFF, |
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, |
0x38, 0x44, 0x44, 0x38, 0x44, |
0x7C, 0x2A, 0x2A, 0x3E, 0x14, |
0x7E, 0x02, 0x02, 0x06, 0x06, |
0x02, 0x7E, 0x02, 0x7E, 0x02, |
0x63, 0x55, 0x49, 0x41, 0x63, |
0x38, 0x44, 0x44, 0x3C, 0x04, |
0x40, 0x7E, 0x20, 0x1E, 0x20, |
0x06, 0x02, 0x7E, 0x02, 0x02, |
0x99, 0xA5, 0xE7, 0xA5, 0x99, |
0x1C, 0x2A, 0x49, 0x2A, 0x1C, |
0x4C, 0x72, 0x01, 0x72, 0x4C, |
0x30, 0x4A, 0x4D, 0x4D, 0x30, |
0x30, 0x48, 0x78, 0x48, 0x30, |
0xBC, 0x62, 0x5A, 0x46, 0x3D, |
0x3E, 0x49, 0x49, 0x49, 0x00, |
0x7E, 0x01, 0x01, 0x01, 0x7E, |
0x2A, 0x2A, 0x2A, 0x2A, 0x2A, |
0x44, 0x44, 0x5F, 0x44, 0x44, |
0x40, 0x51, 0x4A, 0x44, 0x40, |
0x40, 0x44, 0x4A, 0x51, 0x40, |
0x00, 0x00, 0xFF, 0x01, 0x03, |
0xE0, 0x80, 0xFF, 0x00, 0x00, |
0x08, 0x08, 0x6B, 0x6B, 0x08, |
0x36, 0x12, 0x36, 0x24, 0x36, |
0x06, 0x0F, 0x09, 0x0F, 0x06, |
0x00, 0x00, 0x18, 0x18, 0x00, |
0x00, 0x00, 0x10, 0x10, 0x00, |
0x30, 0x40, 0xFF, 0x01, 0x01, |
0x00, 0x1F, 0x01, 0x01, 0x1E, |
0x00, 0x19, 0x1D, 0x17, 0x12, |
0x00, 0x3C, 0x3C, 0x3C, 0x3C, |
0x00, 0x00, 0x00, 0x00, 0x00, |
}; |
#endif |
/PIC Stuff/Cerebot_32MX7_LED_Cube/PWM2.c |
---|
0,0 → 1,23 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "PWM2.h" |
void PWM2_Init(void) { |
OC2CON = 0x0000; |
OC2R = 0x0001; // PWM initial duty cycle |
OC2RS = 0x0001; // PWM duty cycle |
OC2CON = 0x0006; // PWM off, 16-bit, timer 2, fault pin disabled |
IFS0CLR = 0x00000100; // Disable Timer 2 interrupt |
T2CONSET = 0x8000; // Turn on Timer 2 |
PR2 = 0x0003; // PWM period ~ 16-20Mhz |
} |
void PWM2_Start(void) { |
OC2CONSET = 0x8000; |
} |
void PWM2_Stop(void) { |
OC2CONCLR = 0x8000; |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/PWM2.h |
---|
0,0 → 1,9 |
#ifndef PWM2_H |
#define PWM2_H |
void PWM2_Init(void); |
void PWM2_Start(void); |
void PWM2_Stop(void); |
#endif /* PWM2_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/Makefile |
---|
0,0 → 1,108 |
# |
# There exist several targets which are by default empty and which can be |
# used for execution of your targets. These targets are usually executed |
# before and after some main targets. They are: |
# |
# .build-pre: called before 'build' target |
# .build-post: called after 'build' target |
# .clean-pre: called before 'clean' target |
# .clean-post: called after 'clean' target |
# .clobber-pre: called before 'clobber' target |
# .clobber-post: called after 'clobber' target |
# .all-pre: called before 'all' target |
# .all-post: called after 'all' target |
# .help-pre: called before 'help' target |
# .help-post: called after 'help' target |
# |
# Targets beginning with '.' are not intended to be called on their own. |
# |
# Main targets can be executed directly, and they are: |
# |
# build build a specific configuration |
# clean remove built files from a configuration |
# clobber remove all built files |
# all build all configurations |
# help print help mesage |
# |
# Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and |
# .help-impl are implemented in nbproject/makefile-impl.mk. |
# |
# Available make variables: |
# |
# CND_BASEDIR base directory for relative paths |
# CND_DISTDIR default top distribution directory (build artifacts) |
# CND_BUILDDIR default top build directory (object files, ...) |
# CONF name of current configuration |
# CND_ARTIFACT_DIR_${CONF} directory of build artifact (current configuration) |
# CND_ARTIFACT_NAME_${CONF} name of build artifact (current configuration) |
# CND_ARTIFACT_PATH_${CONF} path to build artifact (current configuration) |
# CND_PACKAGE_DIR_${CONF} directory of package (current configuration) |
# CND_PACKAGE_NAME_${CONF} name of package (current configuration) |
# CND_PACKAGE_PATH_${CONF} path to package (current configuration) |
# |
# NOCDDL |
# Environment |
MKDIR=mkdir |
CP=cp |
CCADMIN=CCadmin |
RANLIB=ranlib |
# build |
build: .build-post |
.build-pre: |
# Add your pre 'build' code here... |
.build-post: .build-impl |
# Add your post 'build' code here... |
# clean |
clean: .clean-post |
.clean-pre: |
# Add your pre 'clean' code here... |
.clean-post: .clean-impl |
# Add your post 'clean' code here... |
# clobber |
clobber: .clobber-post |
.clobber-pre: |
# Add your pre 'clobber' code here... |
.clobber-post: .clobber-impl |
# Add your post 'clobber' code here... |
# all |
all: .all-post |
.all-pre: |
# Add your pre 'all' code here... |
.all-post: .all-impl |
# Add your post 'all' code here... |
# help |
help: .help-post |
.help-pre: |
# Add your pre 'help' code here... |
.help-post: .help-impl |
# Add your post 'help' code here... |
# include project implementation makefile |
include nbproject/Makefile-impl.mk |
# include project make variables |
include nbproject/Makefile-variables.mk |