/PIC Stuff/Cerebot_32MX7_LED_Cube/ANIMATIONS.c |
---|
2,8 → 2,8 |
#include "ANIMATIONS.h" |
#include "CUBE.h" |
void Animation_Solid_Colors(int iterations, int delay_ms) { |
int i; |
void Animation_Solid_Colors(uint8_t iterations, uint16_t delay_ms) { |
uint8_t i; |
for (i = 0; i < iterations; i++) { |
Cube_Set_All(RED); |
Delay_MS(delay_ms); |
14,8 → 14,8 |
} |
} |
void Animation_Layer_Alternate(int iterations, int delay_ms) { |
int i,z; |
void Animation_Layer_Alternate(uint8_t iterations, uint16_t delay_ms) { |
uint8_t i,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
if (i % 3 == 0) |
47,14 → 47,14 |
} |
} |
void Animation_Pixel_Alternate(int iterations, int delay_ms) { |
int i,j,k,z; |
void Animation_Pixel_Alternate(uint8_t iterations, uint16_t delay_ms) { |
uint8_t 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; |
int32_t var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,RED); |
else if (var % 3 == 1) |
67,7 → 67,7 |
Cube_Clear(); |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
int var = (j * 8) + k; |
int32_t var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,GREEN); |
else if (var % 3 == 1) |
80,7 → 80,7 |
Cube_Clear(); |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
for (k = 0; k < CUBE_COLUMN_COUNT; k++) { |
int var = (j * 8) + k; |
int32_t var = (j * 8) + k; |
if (var % 3 == 0) |
Cube_Set_Pixel(i,j,k,BLUE); |
else if (var % 3 == 1) |
94,8 → 94,8 |
} |
} |
void Animation_Full_Color_Sweep(int iterations, int delay_us) { |
int i,z; |
void Animation_Full_Color_Sweep(uint8_t iterations, uint16_t delay_us) { |
int16_t i,z; |
for (z = 0; z < iterations; z++) { |
for (i = 0; i < 0x0FF; i+=2) { |
Cube_Set_All(i,0,0); |
125,7 → 125,7 |
Cube_Set_All(i,0,0x0FF); |
Delay_US(delay_us); |
} |
for (i = 0x100; i >= 0; i-=2) { |
for (i = 0x0FF; i >= 0; i-=2) { |
Cube_Set_All(0,0,i); |
Delay_US(delay_us); |
} |
132,8 → 132,8 |
} |
} |
void Animation_Row_Column_Sweep(int iterations, int delay_ms) { |
int i,j,k,a,z; |
void Animation_Row_Column_Sweep(uint8_t iterations, uint16_t delay_ms) { |
uint8_t 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++) { |
164,7 → 164,7 |
Cube_Set_Pixel(a,k,j,BLUE); |
Delay_MS(delay_ms); |
} |
for (j = CUBE_LAYER_COUNT-1; j >= 0; j--) { |
for (j = CUBE_LAYER_COUNT; j != 0; j--) { |
Cube_Clear(); |
if (i % 3 == 0) { |
for (k = 0; k < CUBE_LAYER_COUNT; k++) |
185,8 → 185,8 |
} |
} |
void Animation_Pixel_Sweep(int iterations, int delay_ms) { |
int i,j,k,z,a; |
void Animation_Pixel_Sweep(uint8_t iterations, uint16_t delay_ms) { |
uint8_t 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++) { |
208,13 → 208,13 |
} |
} |
void Animation_Pseudo_Random_Colors(int iterations, int delay_ms) { |
int i,j,k,z; |
void Animation_Pseudo_Random_Colors(uint8_t iterations, uint16_t delay_ms) { |
uint8_t 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(); |
uint32_t a = rand(); |
if (a % 5 == 0) |
Cube_Set_Pixel(i,j,k,RED); |
else if (a % 5 == 1) |
234,8 → 234,8 |
} |
} |
void Animation_Random_Colors(int iterations, int delay_ms) { |
int i,j,k,z; |
void Animation_Random_Colors(uint8_t iterations, uint16_t delay_ms) { |
uint8_t 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++) { |
248,8 → 248,8 |
} |
} |
void Animation_Cube_In_Cube(int iterations, int delay_ms) { |
int z,x,i,j,k; |
void Animation_Cube_In_Cube(uint8_t iterations, uint16_t delay_ms) { |
uint8_t z,x,i,j,k; |
for (z = 0; z < iterations; z++) { |
for (x = 0; x < 5; x++) { |
Cube_Clear(); |
300,9 → 300,9 |
} |
} |
void Animation_Double_Rotation(int iterations, int delay_ms) { |
void Animation_Double_Rotation(uint8_t iterations, uint16_t delay_ms) { |
Cube_Clear(); |
int i,x,y,z; |
uint8_t i,x,y,z; |
for (z = 0; z < 3; z++) { |
switch (z % 3) { |
case 0: |
/PIC Stuff/Cerebot_32MX7_LED_Cube/ANIMATIONS.h |
---|
1,16 → 1,16 |
#ifndef ANIMATIONS_H |
#define ANIMATIONS_H |
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 Animation_Solid_Colors(uint8_t iterations, uint16_t delay_ms); |
void Animation_Layer_Alternate(uint8_t iterations, uint16_t delay_ms); |
void Animation_Pixel_Alternate(uint8_t iterations, uint16_t delay_ms); |
void Animation_Full_Color_Sweep(uint8_t iterations, uint16_t delay_us); |
void Animation_Row_Column_Sweep(uint8_t iterations, uint16_t delay_ms); |
void Animation_Pixel_Sweep(uint8_t iterations, uint16_t delay_ms); |
void Animation_Pseudo_Random_Colors(uint8_t iterations,uint16_t delay_ms); |
void Animation_Random_Colors(uint8_t iterations, uint16_t delay_ms); |
void Animation_Cube_In_Cube(uint8_t iterations, uint16_t delay_ms); |
void Animation_Double_Rotation(uint8_t iterations, uint16_t delay_ms); |
#endif /* ANIMATIONS_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/BTN.c |
---|
1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "BTN.h" |
24,7 → 22,7 |
#elif defined CEREBOT_MX7CK |
CNENSET = 0x00300; // Set interrupt on CN8/9 |
#endif |
int tmp = BTN1_PORT; |
int32_t tmp = BTN1_PORT; |
tmp = BTN2_PORT; |
tmp = BTN3_PORT; |
IPC6SET = 0xD0000; // Set priority level = 3, sub-priority level = 1 |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c |
---|
1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "CUBE.h" |
#include "SPI1.h" |
15,7 → 13,7 |
Nop(); |
} |
void Cube_Init(CUBE_DATA *data, char BC) { |
void Cube_Init(CUBE_DATA *data, uint8_t BC) { |
cube_data_ptr = data; |
cube_data_ptr->current_layer = 0; |
cube_data_ptr->rotation_counter = 0; |
55,7 → 53,8 |
void Cube_Timer_Interrupt(void) { |
// OR values in the overlay array with the display array |
int i,j; |
uint8_t i; |
uint16_t j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < GCS_LAYER_SIZE; j++) { |
cube_data_ptr->GCS_WRITE[i][j] = cube_data_ptr->GCS[i][j] | cube_data_ptr->GCS_OVERLAY[i][j]; |
85,7 → 84,7 |
Cube_Delay(); |
GSLAT = 1; |
// Set the shift register to turn on the current layer |
int i; |
uint8_t i; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
Cube_Delay(); |
SFT_D = (i == CUBE_LAYER_COUNT - cube_data_ptr->current_layer - 1) ? 1 : 0; |
112,13 → 111,13 |
// Cube control functions // |
//////////////////////////// |
void Cube_Write_DCS(char BC) { |
void Cube_Write_DCS(uint8_t BC) { |
XBLNK = 0; |
int i,j; |
uint8_t i,j; |
// Write configuration data to the DC/BC/FC/UD registers |
unsigned char DCS[GCS_LAYER_SIZE] = {0}; |
uint8_t DCS[GCS_LAYER_SIZE] = {0}; |
for (i = 0; i < 8; i++) { |
int offset = i * GCS_REG_SIZE; |
uint16_t offset = i * GCS_REG_SIZE; |
for (j = 0; j < 21; j++) { |
DCS[offset + j] = 0xFF; // Dot correction |
139,23 → 138,24 |
} |
void Cube_Clear(void) { |
int i,j; |
uint8_t i; |
uint16_t j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) |
for (j = 0; j < GCS_LAYER_SIZE; j++) |
cube_data_ptr->GCS[i][j] = 0x00; |
} |
void Cube_Set_All(int R, int G, int B) { |
void Cube_Set_All(uint16_t R, uint16_t G, uint16_t B) { |
// Set all pixels in the cube to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int i,j,k; |
uint8_t i,j,k; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < CUBE_ROW_COUNT; j++) { |
int j_var = j * GCS_REG_SIZE; |
uint16_t j_var = j * GCS_REG_SIZE; |
for (k = 0; k < 4; k++) { |
int k_var = j_var + (k * 9); |
uint16_t k_var = j_var + (k * 9); |
cube_data_ptr->GCS[i][k_var+0] = R & 0xFF;; |
cube_data_ptr->GCS[i][k_var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS[i][k_var+2] = G >> 4; |
170,16 → 170,16 |
} |
} |
void Cube_Set_Layer(int layer, int R, int G, int B) { |
void Cube_Set_Layer(uint8_t layer, uint16_t R, uint16_t G, uint16_t B) { |
// Set all pixels in the specified layer to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int i,j; |
uint8_t i,j; |
for (i = 0; i < CUBE_ROW_COUNT; i++) { |
int i_var = i * GCS_REG_SIZE; |
uint16_t i_var = i * GCS_REG_SIZE; |
for (j = 0; j < 4; j++) { |
int j_var = i_var + (j * 9); |
uint16_t j_var = i_var + (j * 9); |
cube_data_ptr->GCS[layer][j_var+0] = R & 0xFF;; |
cube_data_ptr->GCS[layer][j_var+1] = (G << 4) | (R >> 8); |
cube_data_ptr->GCS[layer][j_var+2] = G >> 4; |
193,12 → 193,12 |
} |
} |
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) { |
void Cube_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS[layer][var+0] = R & 0xFF; |
217,8 → 217,8 |
} |
} |
void Cube_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) { |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
void Cube_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) { |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
234,17 → 234,18 |
} |
} |
void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
void Cube_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int prev_R, prev_G, prev_B; |
uint16_t prev_R, prev_G, prev_B; |
Cube_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B); |
Cube_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B); |
} |
void Cube_Rotate_Shell(char shell, char direction) { |
void Cube_Rotate_Shell(uint8_t shell, uint8_t direction) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
uint8_t layer; |
uint16_t origin_R, origin_G, origin_B; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
416,7 → 417,7 |
} |
} |
void Cube_Rotate(char direction) { |
void Cube_Rotate(uint8_t direction) { |
// Rotate outermost layer |
Cube_Rotate_Shell(0, direction); |
// Rotate second to outermost layer |
447,18 → 448,20 |
/////////////////////////////// |
void Cube_Overlay_Clear(void) { |
int i,j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) |
for (j = 0; j < GCS_LAYER_SIZE; j++) |
uint16_t i,j; |
for (i = 0; i < CUBE_LAYER_COUNT; i++) { |
for (j = 0; j < GCS_LAYER_SIZE; j++) { |
cube_data_ptr->GCS_OVERLAY[i][j] = 0x00; |
} |
} |
} |
void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B) { |
void Cube_Overlay_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) { |
// Set the specified pixel to the given color |
R &= 0x0FFF; |
G &= 0x0FFF; |
B &= 0x0FFF; |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
case 0: |
cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF; |
477,8 → 480,8 |
} |
} |
void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) { |
int var = row * GCS_REG_SIZE + (column / 2 * 9); |
void Cube_Overlay_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) { |
uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9); |
switch (column % 2) { |
// Concatenate lower byte and upper byte of each color channel |
case 0: |
494,17 → 497,18 |
} |
} |
void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) { |
void Cube_Overlay_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) { |
// Copies data from pixel 1 to pixel 2 |
// Note: destination pixel value is overwritten |
int prev_R, prev_G, prev_B; |
uint16_t prev_R, prev_G, prev_B; |
Cube_Overlay_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B); |
Cube_Overlay_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B); |
} |
void Cube_Overlay_Rotate_Shell(char shell, char direction) { |
void Cube_Overlay_Rotate_Shell(uint8_t shell, uint8_t direction) { |
// Shell is the layer to rotate, with the outermost being 0 |
int layer, origin_R, origin_G, origin_B;; |
uint8_t layer; |
uint16_t origin_R, origin_G, origin_B;; |
for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) { |
if (direction) { |
switch(shell) { |
680,7 → 684,7 |
// Text control functions // |
//////////////////////////// |
void Cube_Text_Init(char *string, char length, int R, int G, int B) { |
void Cube_Text_Init(uint8_t *string, uint8_t length, uint16_t R, uint16_t G, uint16_t B) { |
// Ensure that the length of the string does not exceed the storage buffer |
if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH; |
687,7 → 691,7 |
Cube_Overlay_Clear(); |
// Copy the passed data into the buffer |
int i; |
uint8_t i; |
for (i = 0; i < length; i++) |
cube_data_ptr->string[i] = string[i]; |
cube_data_ptr->string_length = length; |
699,14 → 703,15 |
} |
void Cube_Text_Interrupt(void) { |
int layer, line; |
uint8_t layer; |
uint16_t line; |
// Rotate before drawing the new line at (0,0) |
Cube_Overlay_Rotate_Shell(0, 0); |
// Get the next vertical line of the character currently being drawn |
// Get the next vertical line of the int8_tacter currently being drawn |
if (cube_data_ptr->string_line == 5) { |
line = 0x0; // Leave a space between characters |
line = 0x0; // Leave a space between int8_tacters |
} else { |
line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5) |
+ cube_data_ptr->string_line]; |
713,17 → 718,17 |
} |
// Draw the line onto (0,0) using the specified color |
for (layer = 7; layer >= 0; layer--) { |
for (layer = 8; layer != 0; layer--) { |
if (line & 0x1) { |
Cube_Overlay_Set_Pixel(layer, 0, 0, cube_data_ptr->string_R, |
Cube_Overlay_Set_Pixel(layer-1, 0, 0, cube_data_ptr->string_R, |
cube_data_ptr->string_G, cube_data_ptr->string_B); |
} else { |
Cube_Overlay_Set_Pixel(layer, 0, 0, 0x00, 0x00, 0x00); |
Cube_Overlay_Set_Pixel(layer-1, 0, 0, 0x00, 0x00, 0x00); |
} |
line >>= 1; |
} |
// Increment the vertical line and the character as needed |
// Increment the vertical line and the int8_tacter as needed |
if (cube_data_ptr->string_line == 5) { |
cube_data_ptr->string_line = 0; |
if (cube_data_ptr->string_index == cube_data_ptr->string_length-1) { |
740,8 → 745,8 |
// Functions for processing streaming data // |
///////////////////////////////////////////// |
void Cube_Data_In(char c) { |
// Reset upon receiving the start char |
void Cube_Data_In(uint8_t c) { |
// Reset upon receiving the start int8_t |
if (c == CUBE_START_CHAR) { |
cube_data_ptr->frame_length = 0; |
cube_data_ptr->frame_index = 0; |
751,12 → 756,12 |
cube_data_ptr->frame_state = READ_LENGTH_MSB; |
return; |
} |
// If the input is the escape char, XOR the next char received |
// If the input is the escape int8_t, XOR the next int8_t received |
if (c == CUBE_ESCAPE_CHAR) { |
cube_data_ptr->frame_escape = 1; |
return; |
} |
// XOR the input char if needed |
// XOR the input int8_t if needed |
if (cube_data_ptr->frame_escape) { |
c ^= CUBE_ESCAPE_XOR; |
cube_data_ptr->frame_escape = 0; |
764,7 → 769,7 |
// Process data |
switch (cube_data_ptr->frame_state) { |
case IDLE: |
// Reflect the character back to the transmitter |
// Reflect the int8_tacter back to the transmitter |
UART1_Write(&c, 1); |
break; |
case READ_LENGTH_MSB: // Save MSB of length |
806,7 → 811,7 |
void Cube_Data_In_Process_Frame(void) { |
// Here we process received frames depending on the command |
char *frame = cube_data_ptr->frame_buffer; |
uint8_t *frame = cube_data_ptr->frame_buffer; |
switch (cube_data_ptr->frame_command) { |
case CUBE_COMMAND_SET_BC: |
TIMER5_Stop(); |
836,6 → 841,6 |
} |
} |
void Cube_Data_Direct_Write_All(char *buffer) { |
void Cube_Data_Direct_Write_All(uint8_t *buffer) { |
memcpy(cube_data_ptr->GCS, buffer, CUBE_LAYER_COUNT * GCS_LAYER_SIZE); |
} |
/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.h |
---|
64,30 → 64,30 |
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; |
uint8_t GCS[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
uint8_t GCS_OVERLAY[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
uint8_t GCS_WRITE[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
uint8_t current_layer; |
uint8_t 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; |
uint8_t string[CUBE_STRING_MAX_LENGTH]; |
uint8_t string_length; |
uint8_t string_index; |
uint8_t string_line; |
uint16_t 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; |
uint8_t frame_buffer[CUBE_FRAME_BUFFER_SIZE]; |
uint8_t frame_checksum; |
uint32_t frame_length; |
uint32_t frame_index; |
uint32_t frame_command; |
uint32_t frame_escape; |
} CUBE_DATA; |
void Cube_Init(CUBE_DATA *data, char BC); |
void Cube_Init(CUBE_DATA *data, uint8_t BC); |
void Cube_Timer_Interrupt(void); |
// Callbacks on completion of DCS/GCS writes |
95,31 → 95,31 |
void Cube_GCS_Write_Callback(void); |
// Cube control functions |
void Cube_Write_DCS(char BC); |
void Cube_Write_DCS(uint8_t 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); |
void Cube_Set_All(uint16_t R, uint16_t G, uint16_t B); |
void Cube_Set_Layer(uint8_t layer, uint16_t R, uint16_t G, uint16_t B); |
void Cube_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B); |
void Cube_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B); |
void Cube_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2); |
void Cube_Rotate_Shell(uint8_t shell, uint8_t direction); |
void Cube_Rotate(uint8_t 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); |
void Cube_Overlay_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B); |
void Cube_Overlay_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B); |
void Cube_Overlay_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2); |
void Cube_Overlay_Rotate_Shell(uint8_t shell, uint8_t direction); |
// Text control functions |
void Cube_Text_Init(char *string, char length, int R, int G, int B); |
void Cube_Text_Init(uint8_t *string, uint8_t length, uint16_t R, uint16_t G, uint16_t B); |
void Cube_Text_Interrupt(void); |
// Data stream in control functions |
void Cube_Data_In(char c); |
void Cube_Data_In(uint8_t c); |
void Cube_Data_In_Process_Frame(void); |
void Cube_Data_Direct_Write_All(char *buffer); |
void Cube_Data_Direct_Write_All(uint8_t *buffer); |
#endif /* CUBE_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/PWM2.c |
---|
1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "PWM2.h" |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.c |
---|
1,11 → 1,9 |
#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)) { |
void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(uint8_t)) { |
spi_data_ptr = data; |
spi_data_ptr->buffer_out_ind = 0; |
spi_data_ptr->buffer_out_len = 0; |
29,7 → 27,7 |
// 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 |
uint32_t tmp = SPI1BUF; // Clears the receive buffer |
IFS0CLR = 0x03800000; // Clear any existing event |
IPC5CLR = 0x1F000000; // Clear the priority |
IPC5SET = 0x19000000; // Set IPL=6, Subpriority 1 |
45,7 → 43,7 |
INTEnableInterrupts(); |
} |
int SPI1_Write(char *array, int length, void (*tx_callback)(void)) { |
uint8_t SPI1_Write(uint8_t *array, uint32_t length, void (*tx_callback)(void)) { |
spi_data_ptr->tx_callback = tx_callback; |
if (length > SPI1_BUFFER_OUT_SIZE) |
56,7 → 54,7 |
// Put the data to send into the outbound buffer |
spi_data_ptr->buffer_out_len = length; |
spi_data_ptr->buffer_out_ind = length-1; |
int i; |
int32_t i; |
for (i = 0; i < length; i++) { |
spi_data_ptr->buffer_out[i] = array[i]; |
} |
77,11 → 75,11 |
// Process SPI1 receive flag |
if (IFS0bits.SPI1RXIF) { |
int i; |
int32_t i; |
// Read the data received from the last transfer |
int rxBufferCount = SPI1STATbits.RXBUFELM; |
int32_t rxBufferCount = SPI1STATbits.RXBUFELM; |
for (i = 0; i < rxBufferCount; i++) { |
char c = SPI1BUF; |
int8_t c = SPI1BUF; |
// Call the RX callback function on the received data |
if (spi_data_ptr->rx_callback != NULL) |
(*spi_data_ptr->rx_callback)(c); |
92,7 → 90,7 |
// Process SPI1 transmit flag |
if (IFS0bits.SPI1TXIF && IEC0bits.SPI1TXIE) { |
int i; |
int32_t i; |
// Disable the transmit interrupt if all data has been sent |
if (spi_data_ptr->buffer_out_len == 0) { |
IEC0CLR=0x02000000; |
100,7 → 98,7 |
(*spi_data_ptr->tx_callback)(); |
} else { |
// Start transmitting the data in the buffer |
int txBufferFree = 16 - SPI1STATbits.TXBUFELM; |
int32_t 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]; |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.h |
---|
7,17 → 7,17 |
#define SPI_WRITE_ONLY |
typedef struct { |
char buffer_out[SPI1_BUFFER_OUT_SIZE]; |
int buffer_out_ind; |
int buffer_out_len; |
uint8_t buffer_out[SPI1_BUFFER_OUT_SIZE]; |
uint32_t buffer_out_ind; |
uint32_t buffer_out_len; |
void (*tx_callback)(void); |
void (*rx_callback)(char); |
void (*rx_callback)(uint8_t); |
} SPI1_DATA; |
void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(char)); |
void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(uint8_t)); |
// Note: SPI1_Write() writes MSB -> LSB! |
int SPI1_Write(char *array, int length, void (*tx_callback)(void)); |
uint8_t SPI1_Write(uint8_t *array, uint32_t length, void (*tx_callback)(void)); |
#endif /* SPI1_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI4.c |
---|
1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "SPI4.h" |
20,7 → 18,7 |
// FSCK = FPB / (2 * (SPIxBRG + 1)) |
IEC1CLR = 0x00000700; // Disable all SPI interrupts |
SPI4CON = 0; // Stops and resets the SPI4. |
int tmp = SPI4BUF; // Clears the receive buffer |
uint32_t tmp = SPI4BUF; // Clears the receive buffer |
IFS1CLR = 0x00000700; // Clear any existing event |
IPC8CLR = 0x0000001F; // Clear the priority |
IPC8SET = 0x0000001A; // Set IPL=6, Subpriority 2 |
35,7 → 33,7 |
INTEnableInterrupts(); |
} |
int SPI4_Read(int length, void (*rx_callback)(char, char *)) { |
uint8_t SPI4_Read(uint32_t length, void (*rx_callback)(uint8_t, uint8_t *)) { |
spi_data_ptr->rx_callback = rx_callback; |
// Ensure that the receiving buffer is large enough |
54,7 → 52,7 |
return 1; |
} |
int SPI4_Write(char *array, int length, void (*tx_callback)(void)) { |
uint8_t SPI4_Write(uint8_t *array, uint32_t length, void (*tx_callback)(void)) { |
spi_data_ptr->tx_callback = tx_callback; |
// We only care about the transmit length if we are sending data |
71,7 → 69,7 |
// Copy only if we are actually going to transmit data |
if (!spi_data_ptr->write_blank) { |
int i; |
int32_t i; |
for (i = 0; i < length; i++) { |
spi_data_ptr->buffer_out[i] = array[i]; |
} |
92,11 → 90,11 |
// Process SPI4 receive flag |
if (IFS1bits.SPI4RXIF) { |
int i; |
uint32_t i; |
// Read the data received from the last transfer |
int rxBufferCount = SPI4STATbits.RXBUFELM; |
uint32_t rxBufferCount = SPI4STATbits.RXBUFELM; |
for (i = 0; i < rxBufferCount; i++) { |
char c = SPI4BUF; |
int8_t c = SPI4BUF; |
// Put the received data into the buffer |
if (spi_data_ptr->buffer_in_len != 0) { |
spi_data_ptr->buffer_in[spi_data_ptr->buffer_in_ind] = c; |
115,7 → 113,7 |
// Process SPI4 transmit flag |
if (IFS1bits.SPI4TXIF && IEC1bits.SPI4TXIE) { |
int i; |
int32_t i; |
// Disable the transmit interrupt if all data has been sent |
if (spi_data_ptr->buffer_out_len == 0) { |
IEC1CLR=0x00000400; |
125,7 → 123,7 |
(*spi_data_ptr->tx_callback)(); |
} else { |
// Start transmitting the data in the buffer |
int txBufferFree = 16 - SPI4STATbits.TXBUFELM; |
int32_t txBufferFree = 16 - SPI4STATbits.TXBUFELM; |
if (spi_data_ptr->buffer_out_len > txBufferFree) { |
for (i = 0; i < txBufferFree; i++) { |
if (spi_data_ptr->write_blank) { |
/PIC Stuff/Cerebot_32MX7_LED_Cube/SPI4.h |
---|
5,22 → 5,22 |
#define SPI4_BUFFER_IN_SIZE 10 |
typedef struct { |
char buffer_out[SPI4_BUFFER_OUT_SIZE]; |
int buffer_out_ind; |
int buffer_out_len; |
char write_blank; |
uint8_t buffer_out[SPI4_BUFFER_OUT_SIZE]; |
uint32_t buffer_out_ind; |
uint32_t buffer_out_len; |
uint8_t write_blank; |
char buffer_in[SPI4_BUFFER_IN_SIZE]; |
int buffer_in_ind; |
int buffer_in_len; |
uint8_t buffer_in[SPI4_BUFFER_IN_SIZE]; |
uint32_t buffer_in_ind; |
uint32_t buffer_in_len; |
void (*tx_callback)(void); |
void (*rx_callback)(char, char *); |
void (*rx_callback)(uint8_t, uint8_t *); |
} SPI4_DATA; |
void SPI4_Init(SPI4_DATA *data); |
int SPI4_Read(int length, void (*rx_callback)(char, char *)); |
int SPI4_Write(char *array, int length, void (*tx_callback)(void)); |
uint8_t SPI4_Read(uint32_t length, void (*rx_callback)(uint8_t, uint8_t *)); |
uint8_t SPI4_Write(uint8_t *array, uint32_t length, void (*tx_callback)(void)); |
#endif /* SPI4_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER4.c |
---|
1,11 → 1,9 |
#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) { |
void TIMER4_Init(TIMER4_DATA *data, void (*callback)(void), uint32_t time_us) { |
if (data != NULL) // if ptr is null, use existing data |
timer_data_ptr = data; |
15,8 → 13,8 |
T4CON = 0x0; |
// PR5 is 16 bits wide, so we need to determine what pre-scaler to use |
int time; |
// PR4 is 16 bits wide, so we need to determine what pre-scaler to use |
uint16_t time; |
if (time_us < 13107) { |
time = 5 * time_us; |
T4CONSET = 0x0040; // Prescaler at 1:16 |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER4.h |
---|
5,7 → 5,7 |
void (*callback_function)(void); |
} TIMER4_DATA; |
void TIMER4_Init(TIMER4_DATA *data, void (*callback)(void), unsigned int time_us); |
void TIMER4_Init(TIMER4_DATA *data, void (*callback)(void), uint32_t time_us); |
void TIMER4_Start(void); |
void TIMER4_Stop(void); |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER5.c |
---|
1,11 → 1,9 |
#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) { |
void TIMER5_Init(TIMER5_DATA *data, void (*callback)(void), uint32_t time_us) { |
if (data != NULL) // if ptr is null, use existing data |
timer_data_ptr = data; |
16,7 → 14,7 |
T5CON = 0x0; |
// PR5 is 16 bits wide, so we need to determine what pre-scaler to use |
int time; |
uint16_t time; |
if (time_us < 13107) { |
time = 5 * time_us; |
T5CONSET = 0x0040; // Prescaler at 1:16 |
/PIC Stuff/Cerebot_32MX7_LED_Cube/TIMER5.h |
---|
5,7 → 5,7 |
void (*callback_function)(void); |
} TIMER5_DATA; |
void TIMER5_Init(TIMER5_DATA *data, void (*callback)(void), unsigned int time_us); |
void TIMER5_Init(TIMER5_DATA *data, void (*callback)(void), uint32_t time_us); |
void TIMER5_Start(void); |
void TIMER5_Stop(void); |
/PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.c |
---|
1,5 → 1,3 |
#include <xc.h> |
#include <plib.h> |
#include "defines.h" |
#include "UART1.h" |
16,7 → 14,7 |
* BRG = PerfBusFreq / (4 * Baud Rate) - 1 |
*/ |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)) { |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(uint8_t)) { |
uart_data_ptr = data; |
uart_data_ptr->rx_callback = rx_callback; |
uart_data_ptr->buffer_out_len = 0; |
45,7 → 43,7 |
PORTDbits.RD14 = 0; |
} |
int UART1_Write(char *string, int length) { |
uint8_t UART1_Write(uint8_t *string, uint32_t length) { |
if (length > UART1_BUFFER_SIZE) |
return 0; |
if (uart_data_ptr->buffer_out_len != 0) |
54,7 → 52,7 |
// 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; |
uint8_t i; |
for (i = 0; i < length; i++) { |
uart_data_ptr->buffer_out[i] = string[i]; |
} |
82,7 → 80,7 |
if (IFS0bits.U1RXIF) { |
// Read the data received from the last transfer |
while (U1STAbits.URXDA) { |
char c = U1RXREG; |
uint8_t c = U1RXREG; |
// Call the RX callback function on each received data |
if (uart_data_ptr->rx_callback != NULL) { |
(*uart_data_ptr->rx_callback)(c); |
/PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.h |
---|
4,14 → 4,14 |
#define UART1_BUFFER_SIZE 128 |
typedef struct { |
void (*rx_callback)(char c); |
void (*rx_callback)(uint8_t c); |
char buffer_out[UART1_BUFFER_SIZE]; |
int buffer_out_ind; |
int buffer_out_len; |
uint8_t buffer_out[UART1_BUFFER_SIZE]; |
uint32_t buffer_out_ind; |
uint32_t buffer_out_len; |
} UART1_DATA; |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)); |
int UART1_Write(char *string, int length); |
void UART1_Init(UART1_DATA *data, void (*rx_callback)(uint8_t)); |
uint8_t UART1_Write(uint8_t *string, uint32_t length); |
#endif /* UART1_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/defines.h |
---|
1,5 → 1,12 |
// PIC32MX795F512L |
#ifndef DEFINES_H |
#define DEFINES_H |
#include <xc.h> |
#include <plib.h> |
#include <stdint.h> |
// Uncomment ONE of the following: |
//#define CEREBOT_32MX7 |
#define CEREBOT_MX7CK |
24,8 → 31,8 |
#define LED4_TRIS TRISGbits.TRISG15 |
#define LED4_PORT PORTGbits.RG15 |
void Delay_MS(unsigned int delay_ms); |
void Delay_US(unsigned int delay_us); |
void Delay_MS(uint32_t delay_ms); |
void Delay_US(uint32_t delay_us); |
// <editor-fold desc="PMOD to MCU Pinouts"> |
/* |
209,3 → 216,5 |
JP17 - Do Not Use |
*/ |
// </editor-fold> |
#endif /* DEFINES_H */ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/glcdfont.h |
---|
4,7 → 4,7 |
// Standard ASCII 5x7 font |
// LSB = top of vertical line, 5 lines from left to right |
const char font[] = { |
const uint8_t font[] = { |
0x00, 0x00, 0x00, 0x00, 0x00, |
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, |
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, |
/PIC Stuff/Cerebot_32MX7_LED_Cube/main.c |
---|
35,9 → 35,6 |
/* ------------------------------------------------------------ */ |
// </editor-fold> |
#include <xc.h> |
#include <plib.h> |
#include <stdlib.h> |
#include "defines.h" |
#include "UART1.h" |
#include "SPI1.h" |
52,23 → 49,23 |
void BTN2_Interrupt(void); |
void BTN3_Interrupt(void); |
void Delay_MS(unsigned int delay_ms) { |
void Delay_MS(uint32_t 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) {}; |
uint32_t delay = delay_ms * MS_TO_CT_TICKS; |
uint32_t startTime = ReadCoreTimer(); |
while ((uint32_t)(ReadCoreTimer() - startTime) < delay) {}; |
} |
void Delay_US(unsigned int delay_us) { |
void Delay_US(uint32_t 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) {}; |
uint32_t delay = delay_us * US_TO_CT_TICKS; |
uint32_t startTime = ReadCoreTimer(); |
while ((uint32_t)(ReadCoreTimer() - startTime) < delay) {}; |
} |
int main() { |
int32_t main() { |
// WARNING!! THIS BOARD WILL RESET EVERY 1048.576s DUE TO THE WDT!! |
/* Configure the target for maximum performance at 80 MHz. */ |
125,11 → 122,11 |
// Delay_MS(2000); |
// Animation_Pseudo_Random_Colors(10,300); |
// char start_text[] = "Cube Initialized\r\n"; |
// int8_t start_text[] = "Cube Initialized\r\n"; |
// UART1_Write(start_text, 18); |
// Set the overlay text |
char text_string[] = "Welcome to the AMP Lab "; |
uint8_t text_string[] = "Welcome to the AMP Lab "; |
Cube_Text_Init(text_string, 27, 0xFF, 0xFF, 0xFF); |
TIMER4_Start(); |
151,7 → 148,7 |
// Function call on button 1 press to change refresh rate |
void BTN1_Interrupt(void) { |
static char state; |
static uint8_t state; |
state = (state == 4) ? 0 : state + 1; |
TIMER5_Stop(); |
switch (state) { |
176,11 → 173,11 |
// Function call on button 2 press to change brightness |
void BTN2_Interrupt(void) { |
static char state; |
static uint8_t state; |
state = (state == 6) ? 0 : state + 1; |
TIMER5_Stop(); |
Delay_MS(1); // Need to wait for all SPI writes to complete |
char BC; |
uint8_t BC; |
switch (state) { |
case 0: |
BC = 0x01; |
210,7 → 207,7 |
// Function call on button 3 press to change text scroll speed |
void BTN3_Interrupt(void) { |
static char state; |
static uint8_t state; |
state = (state == 4) ? 0 : state + 1; |
TIMER4_Stop(); |
switch (state) { |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-default.mk |
---|
45,17 → 45,17 |
DISTDIR=dist/${CND_CONF}/${IMAGE_TYPE} |
# Source Files Quoted if spaced |
SOURCEFILES_QUOTED_IF_SPACED=main.c SPI1.c TIMER5.c CUBE.c PWM2.c BTN.c TIMER4.c UART1.c SPI4.c ANIMATIONS.c |
SOURCEFILES_QUOTED_IF_SPACED=main.c SPI1.c TIMER5.c CUBE.c PWM2.c BTN.c TIMER4.c UART1.c SPI4.c ANIMATIONS.c I2C1.c |
# 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 ${OBJECTDIR}/SPI4.o ${OBJECTDIR}/ANIMATIONS.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 ${OBJECTDIR}/SPI4.o.d ${OBJECTDIR}/ANIMATIONS.o.d |
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 ${OBJECTDIR}/SPI4.o ${OBJECTDIR}/ANIMATIONS.o ${OBJECTDIR}/I2C1.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 ${OBJECTDIR}/SPI4.o.d ${OBJECTDIR}/ANIMATIONS.o.d ${OBJECTDIR}/I2C1.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 ${OBJECTDIR}/SPI4.o ${OBJECTDIR}/ANIMATIONS.o |
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 ${OBJECTDIR}/SPI4.o ${OBJECTDIR}/ANIMATIONS.o ${OBJECTDIR}/I2C1.o |
# Source Files |
SOURCEFILES=main.c SPI1.c TIMER5.c CUBE.c PWM2.c BTN.c TIMER4.c UART1.c SPI4.c ANIMATIONS.c |
SOURCEFILES=main.c SPI1.c TIMER5.c CUBE.c PWM2.c BTN.c TIMER4.c UART1.c SPI4.c ANIMATIONS.c I2C1.c |
CFLAGS= |
151,6 → 151,12 |
@${RM} ${OBJECTDIR}/ANIMATIONS.o |
@${FIXDEPS} "${OBJECTDIR}/ANIMATIONS.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}/ANIMATIONS.o.d" -o ${OBJECTDIR}/ANIMATIONS.o ANIMATIONS.c |
${OBJECTDIR}/I2C1.o: I2C1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/I2C1.o.d |
@${RM} ${OBJECTDIR}/I2C1.o |
@${FIXDEPS} "${OBJECTDIR}/I2C1.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}/I2C1.o.d" -o ${OBJECTDIR}/I2C1.o I2C1.c |
else |
${OBJECTDIR}/main.o: main.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
212,6 → 218,12 |
@${RM} ${OBJECTDIR}/ANIMATIONS.o |
@${FIXDEPS} "${OBJECTDIR}/ANIMATIONS.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}/ANIMATIONS.o.d" -o ${OBJECTDIR}/ANIMATIONS.o ANIMATIONS.c |
${OBJECTDIR}/I2C1.o: I2C1.c nbproject/Makefile-${CND_CONF}.mk |
@${MKDIR} ${OBJECTDIR} |
@${RM} ${OBJECTDIR}/I2C1.o.d |
@${RM} ${OBJECTDIR}/I2C1.o |
@${FIXDEPS} "${OBJECTDIR}/I2C1.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}/I2C1.o.d" -o ${OBJECTDIR}/I2C1.o I2C1.c |
endif |
# ------------------------------------------------------------------------------------ |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-genesis.properties |
---|
1,5 → 1,5 |
# |
#Wed Nov 13 12:09:13 EST 2013 |
#Mon Dec 09 23:33:34 EST 2013 |
default.com-microchip-mplab-nbide-toolchainXC32-XC32LanguageToolchain.md5=a7430524a414be59f5ce2a8f8797db6d |
default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\xc32\\v1.21\\bin |
com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=0d2b1469ad71adb787c711a416386331 |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/configurations.xml |
---|
15,6 → 15,7 |
<itemPath>UART1.h</itemPath> |
<itemPath>SPI4.h</itemPath> |
<itemPath>ANIMATIONS.h</itemPath> |
<itemPath>I2C1.h</itemPath> |
</logicalFolder> |
<logicalFolder name="LinkerScript" |
displayName="Linker Files" |
33,6 → 34,7 |
<itemPath>UART1.c</itemPath> |
<itemPath>SPI4.c</itemPath> |
<itemPath>ANIMATIONS.c</itemPath> |
<itemPath>I2C1.c</itemPath> |
</logicalFolder> |
<logicalFolder name="ExternalFiles" |
displayName="Important Files" |
161,6 → 163,7 |
<C32Global> |
<property key="legacy-libc" value="false"/> |
<property key="save-temps" value="false"/> |
<property key="wpo-lto" value="false"/> |
</C32Global> |
<PK3OBPlatformTool> |
<property key="AutoSelectMemRanges" value="auto"/> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/configurations.xml |
---|
4,7 → 4,7 |
<defaultConf>0</defaultConf> |
<confs> |
<conf name="default" type="2"> |
<platformToolSN>:=MPLABCommUSB:=04D8:=8108:=0002:=Digilent:=Cerebot 32MX7:=D370400:=x:=en</platformToolSN> |
<platformToolSN>:=MPLABCommUSB:=04D8:=8108:=0002:=Digilent:=CerebotMX7CK:=D459520:=x:=en</platformToolSN> |
<languageToolchainDir>C:\Program Files (x86)\Microchip\xc32\v1.21\bin</languageToolchainDir> |
<mdbdebugger version="1"> |
<placeholder1>place holder 1</placeholder1> |
/PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/private.xml |
---|
1,3 → 1,7 |
<?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"/> |
<open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/1"> |
<file>file:/C:/Users/Kevin/Documents/Code/Cerebot_32MX7_LED_Cube/main.c</file> |
<file>file:/C:/Users/Kevin/Documents/Code/Cerebot_32MX7_LED_Cube/defines.h</file> |
</open-files> |
</project-private> |