Subversion Repositories Code-Repo

Compare Revisions

Problem with comparison.

Ignore whitespace Rev HEAD → Rev 215

/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