| /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> |