WebSVN – Code-Repo – Diff – /PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c



 
 
#include "defines.h"
#include "CUBE.h"
#include "SPI1.h"
#include "glcdfont.h"
#include "UART1.h"

    Nop();
    Nop();
    Nop();
}
 
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;
    cube_data_ptr->frame_state = IDLE;
    cube_data_ptr->frame_escape = 0;

    Cube_Overlay_Clear();
}
 
void Cube_Timer_Interrupt(void) {
    // OR values in the overlay array with the display array
    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];
        }
    }

    // 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
    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;
        Cube_Delay();
        SFT_K = 1;

 
////////////////////////////
// Cube control functions //
////////////////////////////
 
void Cube_Write_DCS(uint8_t BC) {
    XBLNK = 0;
    uint8_t i,j;
    // Write configuration data to the DC/BC/FC/UD registers
    uint8_t DCS[GCS_LAYER_SIZE] = {0};
    for (i = 0; i < 8; i++) {
        uint16_t offset = i * GCS_REG_SIZE;
 
        for (j = 0; j < 21; j++) {
            DCS[offset + j] = 0xFF; // Dot correction
        }
 

    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) {
    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(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;
    uint8_t i,j,k;
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
            uint16_t j_var = j * GCS_REG_SIZE;
            for (k = 0; k < 4; k++) {
                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;
                cube_data_ptr->GCS[i][k_var+3] = B & 0xFF;
                cube_data_ptr->GCS[i][k_var+4] = (R << 4) | (B >> 8);

            }
        }
    }
}
 
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;
    uint8_t i,j;
    for (i = 0; i < CUBE_ROW_COUNT; i++) {
        uint16_t i_var = i * GCS_REG_SIZE;
        for (j = 0; j < 4; j++) {
            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;
            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+8] = B >> 4;
        }
    }
}
 
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;
    uint16_t 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+8] = B >> 4;
            break;
    }
}
 
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:
            *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+7] >> 4) | (cube_data_ptr->GCS[layer][var+8] << 4);
            break;
    }
}
 
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
    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(uint8_t shell, uint8_t direction) {
    // Shell is the layer to rotate, with the outermost being 0
    uint8_t layer;
    uint16_t origin_R, origin_G, origin_B;
    for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {
        if (direction) {
            switch(shell) {
                case 0:
                    // Rotate outermost layer

            }
        }
    }
}
 
void Cube_Rotate(uint8_t 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);

///////////////////////////////
// Overlay control functions //
///////////////////////////////
 
void Cube_Overlay_Clear(void) {
    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(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;
    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;
            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+8] = B >> 4;
            break;
    }
}
 
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:
            *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+7] >> 4) | (cube_data_ptr->GCS_OVERLAY[layer][var+8] << 4);
            break;
    }
}
 
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
    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(uint8_t shell, uint8_t direction) {
    // Shell is the layer to rotate, with the outermost being 0
    uint8_t layer;
    uint16_t origin_R, origin_G, origin_B;;
    for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {
        if (direction) {
            switch(shell) {
                case 0:
                    // Rotate outermost layer

 
////////////////////////////
// Text control functions //
////////////////////////////
 
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;
 
    Cube_Overlay_Clear();
 
    // Copy the passed data into the buffer
    uint8_t 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_G = G;
    cube_data_ptr->string_B = B;
}
 
void Cube_Text_Interrupt(void) {
    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 int8_tacter currently being drawn
    if (cube_data_ptr->string_line == 5) {
        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];
    }
 
    // Draw the line onto (0,0) using the specified color
    for (layer = 8; layer != 0; layer--) {
        if (line & 0x1) {
            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-1, 0, 0, 0x00, 0x00, 0x00);
        }
        line >>= 1;
    }
 
    // 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) {
            cube_data_ptr->string_index = 0;
        } else {

 
/////////////////////////////////////////////
// Functions for processing streaming data //
/////////////////////////////////////////////
 
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;
        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 int8_t, XOR the next int8_t received
    if (c == CUBE_ESCAPE_CHAR) {
        cube_data_ptr->frame_escape = 1;
        return;
    }
    // XOR the input int8_t 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 int8_tacter 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;

    }
}
 
void Cube_Data_In_Process_Frame(void) {
    // Here we process received frames depending on the command
    uint8_t *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]);

        default:
            break;
    }
}
 
void Cube_Data_Direct_Write_All(uint8_t *buffer) {
    memcpy(cube_data_ptr->GCS, buffer, CUBE_LAYER_COUNT * GCS_LAYER_SIZE);
}


Rev 216	Rev 231
Line 1...	Line -...
1	`#include <xc.h>`	-
2	`#include <plib.h>`	-
3	`#include "defines.h"`	1	`#include "defines.h"`
4	`#include "CUBE.h"`	2	`#include "CUBE.h"`
5	`#include "SPI1.h"`	3	`#include "SPI1.h"`
6	`#include "glcdfont.h"`	4	`#include "glcdfont.h"`
7	`#include "UART1.h"`	5	`#include "UART1.h"`
Line 13...	Line 11...
13	`Nop();`	11	`Nop();`
14	`Nop();`	12	`Nop();`
15	`Nop();`	13	`Nop();`
16	`}`	14	`}`
17		15
18	`void Cube_Init(CUBE_DATA *data, char BC) {`	16	`void Cube_Init(CUBE_DATA *data, uint8_t BC) {`
19	`cube_data_ptr = data;`	17	`cube_data_ptr = data;`
20	`cube_data_ptr->current_layer = 0;`	18	`cube_data_ptr->current_layer = 0;`
21	`cube_data_ptr->rotation_counter = 0;`	19	`cube_data_ptr->rotation_counter = 0;`
22	`cube_data_ptr->frame_state = IDLE;`	20	`cube_data_ptr->frame_state = IDLE;`
23	`cube_data_ptr->frame_escape = 0;`	21	`cube_data_ptr->frame_escape = 0;`
Line 53...	Line 51...
53	`Cube_Overlay_Clear();`	51	`Cube_Overlay_Clear();`
54	`}`	52	`}`
55		53
56	`void Cube_Timer_Interrupt(void) {`	54	`void Cube_Timer_Interrupt(void) {`
57	`// OR values in the overlay array with the display array`	55	`// OR values in the overlay array with the display array`
-		56	`uint8_t i;`
58	`int i,j;`	57	`uint16_t j;`
59	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	58	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
60	`for (j = 0; j < GCS_LAYER_SIZE; j++) {`	59	`for (j = 0; j < GCS_LAYER_SIZE; j++) {`
61	`cube_data_ptr->GCS_WRITE[i][j] = cube_data_ptr->GCS[i][j] \| cube_data_ptr->GCS_OVERLAY[i][j];`	60	`cube_data_ptr->GCS_WRITE[i][j] = cube_data_ptr->GCS[i][j] \| cube_data_ptr->GCS_OVERLAY[i][j];`
62	`}`	61	`}`
63	`}`	62	`}`
Line 83...	Line 82...
83	`// Disable LED output and latch in written data to GCS`	82	`// Disable LED output and latch in written data to GCS`
84	`XBLNK = 0;`	83	`XBLNK = 0;`
85	`Cube_Delay();`	84	`Cube_Delay();`
86	`GSLAT = 1;`	85	`GSLAT = 1;`
87	`// Set the shift register to turn on the current layer`	86	`// Set the shift register to turn on the current layer`
88	`int i;`	87	`uint8_t i;`
89	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	88	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
90	`Cube_Delay();`	89	`Cube_Delay();`
91	`SFT_D = (i == CUBE_LAYER_COUNT - cube_data_ptr->current_layer - 1) ? 1 : 0;`	90	`SFT_D = (i == CUBE_LAYER_COUNT - cube_data_ptr->current_layer - 1) ? 1 : 0;`
92	`Cube_Delay();`	91	`Cube_Delay();`
93	`SFT_K = 1;`	92	`SFT_K = 1;`
Line 110...	Line 109...
110		109
111	`////////////////////////////`	110	`////////////////////////////`
112	`// Cube control functions //`	111	`// Cube control functions //`
113	`////////////////////////////`	112	`////////////////////////////`
114		113
115	`void Cube_Write_DCS(char BC) {`	114	`void Cube_Write_DCS(uint8_t BC) {`
116	`XBLNK = 0;`	115	`XBLNK = 0;`
117	`int i,j;`	116	`uint8_t i,j;`
118	`// Write configuration data to the DC/BC/FC/UD registers`	117	`// Write configuration data to the DC/BC/FC/UD registers`
119	`unsigned char DCS[GCS_LAYER_SIZE] = {0};`	118	`uint8_t DCS[GCS_LAYER_SIZE] = {0};`
120	`for (i = 0; i < 8; i++) {`	119	`for (i = 0; i < 8; i++) {`
121	`int offset = i * GCS_REG_SIZE;`	120	`uint16_t offset = i * GCS_REG_SIZE;`
122		121
123	`for (j = 0; j < 21; j++) {`	122	`for (j = 0; j < 21; j++) {`
124	`DCS[offset + j] = 0xFF; // Dot correction`	123	`DCS[offset + j] = 0xFF; // Dot correction`
125	`}`	124	`}`
126		125
Line 137...	Line 136...
137	`SPI1_Write(DCS, GCS_LAYER_SIZE, &Cube_DCS_Write_Callback);`	136	`SPI1_Write(DCS, GCS_LAYER_SIZE, &Cube_DCS_Write_Callback);`
138	`Delay_MS(10); // Delay until the entire DCS write is finished`	137	`Delay_MS(10); // Delay until the entire DCS write is finished`
139	`}`	138	`}`
140		139
141	`void Cube_Clear(void) {`	140	`void Cube_Clear(void) {`
-		141	`uint8_t i;`
142	`int i,j;`	142	`uint16_t j;`
143	`for (i = 0; i < CUBE_LAYER_COUNT; i++)`	143	`for (i = 0; i < CUBE_LAYER_COUNT; i++)`
144	`for (j = 0; j < GCS_LAYER_SIZE; j++)`	144	`for (j = 0; j < GCS_LAYER_SIZE; j++)`
145	`cube_data_ptr->GCS[i][j] = 0x00;`	145	`cube_data_ptr->GCS[i][j] = 0x00;`
146	`}`	146	`}`
147		147
148	`void Cube_Set_All(int R, int G, int B) {`	148	`void Cube_Set_All(uint16_t R, uint16_t G, uint16_t B) {`
149	`// Set all pixels in the cube to the given color`	149	`// Set all pixels in the cube to the given color`
150	`R &= 0x0FFF;`	150	`R &= 0x0FFF;`
151	`G &= 0x0FFF;`	151	`G &= 0x0FFF;`
152	`B &= 0x0FFF;`	152	`B &= 0x0FFF;`
153	`int i,j,k;`	153	`uint8_t i,j,k;`
154	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	154	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
155	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	155	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
156	`int j_var = j * GCS_REG_SIZE;`	156	`uint16_t j_var = j * GCS_REG_SIZE;`
157	`for (k = 0; k < 4; k++) {`	157	`for (k = 0; k < 4; k++) {`
158	`int k_var = j_var + (k * 9);`	158	`uint16_t k_var = j_var + (k * 9);`
159	`cube_data_ptr->GCS[i][k_var+0] = R & 0xFF;;`	159	`cube_data_ptr->GCS[i][k_var+0] = R & 0xFF;;`
160	`cube_data_ptr->GCS[i][k_var+1] = (G << 4) \| (R >> 8);`	160	`cube_data_ptr->GCS[i][k_var+1] = (G << 4) \| (R >> 8);`
161	`cube_data_ptr->GCS[i][k_var+2] = G >> 4;`	161	`cube_data_ptr->GCS[i][k_var+2] = G >> 4;`
162	`cube_data_ptr->GCS[i][k_var+3] = B & 0xFF;`	162	`cube_data_ptr->GCS[i][k_var+3] = B & 0xFF;`
163	`cube_data_ptr->GCS[i][k_var+4] = (R << 4) \| (B >> 8);`	163	`cube_data_ptr->GCS[i][k_var+4] = (R << 4) \| (B >> 8);`
Line 168...	Line 168...
168	`}`	168	`}`
169	`}`	169	`}`
170	`}`	170	`}`
171	`}`	171	`}`
172		172
173	`void Cube_Set_Layer(int layer, int R, int G, int B) {`	173	`void Cube_Set_Layer(uint8_t layer, uint16_t R, uint16_t G, uint16_t B) {`
174	`// Set all pixels in the specified layer to the given color`	174	`// Set all pixels in the specified layer to the given color`
175	`R &= 0x0FFF;`	175	`R &= 0x0FFF;`
176	`G &= 0x0FFF;`	176	`G &= 0x0FFF;`
177	`B &= 0x0FFF;`	177	`B &= 0x0FFF;`
178	`int i,j;`	178	`uint8_t i,j;`
179	`for (i = 0; i < CUBE_ROW_COUNT; i++) {`	179	`for (i = 0; i < CUBE_ROW_COUNT; i++) {`
180	`int i_var = i * GCS_REG_SIZE;`	180	`uint16_t i_var = i * GCS_REG_SIZE;`
181	`for (j = 0; j < 4; j++) {`	181	`for (j = 0; j < 4; j++) {`
182	`int j_var = i_var + (j * 9);`	182	`uint16_t j_var = i_var + (j * 9);`
183	`cube_data_ptr->GCS[layer][j_var+0] = R & 0xFF;;`	183	`cube_data_ptr->GCS[layer][j_var+0] = R & 0xFF;;`
184	`cube_data_ptr->GCS[layer][j_var+1] = (G << 4) \| (R >> 8);`	184	`cube_data_ptr->GCS[layer][j_var+1] = (G << 4) \| (R >> 8);`
185	`cube_data_ptr->GCS[layer][j_var+2] = G >> 4;`	185	`cube_data_ptr->GCS[layer][j_var+2] = G >> 4;`
186	`cube_data_ptr->GCS[layer][j_var+3] = B & 0xFF;`	186	`cube_data_ptr->GCS[layer][j_var+3] = B & 0xFF;`
187	`cube_data_ptr->GCS[layer][j_var+4] = (R << 4) \| (B >> 8);`	187	`cube_data_ptr->GCS[layer][j_var+4] = (R << 4) \| (B >> 8);`
Line 191...	Line 191...
191	`cube_data_ptr->GCS[layer][j_var+8] = B >> 4;`	191	`cube_data_ptr->GCS[layer][j_var+8] = B >> 4;`
192	`}`	192	`}`
193	`}`	193	`}`
194	`}`	194	`}`
195		195
196	`void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) {`	196	`void Cube_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) {`
197	`// Set the specified pixel to the given color`	197	`// Set the specified pixel to the given color`
198	`R &= 0x0FFF;`	198	`R &= 0x0FFF;`
199	`G &= 0x0FFF;`	199	`G &= 0x0FFF;`
200	`B &= 0x0FFF;`	200	`B &= 0x0FFF;`
201	`int var = row * GCS_REG_SIZE + (column / 2 * 9);`	201	`uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9);`
202	`switch (column % 2) {`	202	`switch (column % 2) {`
203	`case 0:`	203	`case 0:`
204	`cube_data_ptr->GCS[layer][var+0] = R & 0xFF;`	204	`cube_data_ptr->GCS[layer][var+0] = R & 0xFF;`
205	`cube_data_ptr->GCS[layer][var+1] = (G << 4) \| (R >> 8);`	205	`cube_data_ptr->GCS[layer][var+1] = (G << 4) \| (R >> 8);`
206	`cube_data_ptr->GCS[layer][var+2] = G >> 4;`	206	`cube_data_ptr->GCS[layer][var+2] = G >> 4;`
Line 215...	Line 215...
215	`cube_data_ptr->GCS[layer][var+8] = B >> 4;`	215	`cube_data_ptr->GCS[layer][var+8] = B >> 4;`
216	`break;`	216	`break;`
217	`}`	217	`}`
218	`}`	218	`}`
219		219
220	`void Cube_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) {`	220	`void Cube_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) {`
221	`int var = row * GCS_REG_SIZE + (column / 2 * 9);`	221	`uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9);`
222	`switch (column % 2) {`	222	`switch (column % 2) {`
223	`// Concatenate lower byte and upper byte of each color channel`	223	`// Concatenate lower byte and upper byte of each color channel`
224	`case 0:`	224	`case 0:`
225	`*R = cube_data_ptr->GCS[layer][var+0] \| ((cube_data_ptr->GCS[layer][var+1] & 0x0F) << 8);`	225	`*R = cube_data_ptr->GCS[layer][var+0] \| ((cube_data_ptr->GCS[layer][var+1] & 0x0F) << 8);`
226	`*G = (cube_data_ptr->GCS[layer][var+1] >> 4) \| (cube_data_ptr->GCS[layer][var+2] << 4);`	226	`*G = (cube_data_ptr->GCS[layer][var+1] >> 4) \| (cube_data_ptr->GCS[layer][var+2] << 4);`
Line 232...	Line 232...
232	`*B = (cube_data_ptr->GCS[layer][var+7] >> 4) \| (cube_data_ptr->GCS[layer][var+8] << 4);`	232	`*B = (cube_data_ptr->GCS[layer][var+7] >> 4) \| (cube_data_ptr->GCS[layer][var+8] << 4);`
233	`break;`	233	`break;`
234	`}`	234	`}`
235	`}`	235	`}`
236		236
237	`void Cube_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) {`	237	`void Cube_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) {`
238	`// Copies data from pixel 1 to pixel 2`	238	`// Copies data from pixel 1 to pixel 2`
239	`// Note: destination pixel value is overwritten`	239	`// Note: destination pixel value is overwritten`
240	`int prev_R, prev_G, prev_B;`	240	`uint16_t prev_R, prev_G, prev_B;`
241	`Cube_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);`	241	`Cube_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);`
242	`Cube_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);`	242	`Cube_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);`
243	`}`	243	`}`
244		244
245	`void Cube_Rotate_Shell(char shell, char direction) {`	245	`void Cube_Rotate_Shell(uint8_t shell, uint8_t direction) {`
246	`// Shell is the layer to rotate, with the outermost being 0`	246	`// Shell is the layer to rotate, with the outermost being 0`
-		247	`uint8_t layer;`
247	`int layer, origin_R, origin_G, origin_B;;`	248	`uint16_t origin_R, origin_G, origin_B;`
248	`for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {`	249	`for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {`
249	`if (direction) {`	250	`if (direction) {`
250	`switch(shell) {`	251	`switch(shell) {`
251	`case 0:`	252	`case 0:`
252	`// Rotate outermost layer`	253	`// Rotate outermost layer`
Line 414...	Line 415...
414	`}`	415	`}`
415	`}`	416	`}`
416	`}`	417	`}`
417	`}`	418	`}`
418		419
419	`void Cube_Rotate(char direction) {`	420	`void Cube_Rotate(uint8_t direction) {`
420	`// Rotate outermost layer`	421	`// Rotate outermost layer`
421	`Cube_Rotate_Shell(0, direction);`	422	`Cube_Rotate_Shell(0, direction);`
422	`// Rotate second to outermost layer`	423	`// Rotate second to outermost layer`
423	`if ((cube_data_ptr->rotation_counter != 1) && (cube_data_ptr->rotation_counter != 5)) {`	424	`if ((cube_data_ptr->rotation_counter != 1) && (cube_data_ptr->rotation_counter != 5)) {`
424	`Cube_Rotate_Shell(1, direction);`	425	`Cube_Rotate_Shell(1, direction);`
Line 445...	Line 446...
445	`///////////////////////////////`	446	`///////////////////////////////`
446	`// Overlay control functions //`	447	`// Overlay control functions //`
447	`///////////////////////////////`	448	`///////////////////////////////`
448		449
449	`void Cube_Overlay_Clear(void) {`	450	`void Cube_Overlay_Clear(void) {`
450	`int i,j;`	451	`uint16_t i,j;`
451	`for (i = 0; i < CUBE_LAYER_COUNT; i++)`	452	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
452	`for (j = 0; j < GCS_LAYER_SIZE; j++)`	453	`for (j = 0; j < GCS_LAYER_SIZE; j++) {`
453	`cube_data_ptr->GCS_OVERLAY[i][j] = 0x00;`	454	`cube_data_ptr->GCS_OVERLAY[i][j] = 0x00;`
-		455	`}`
-		456	`}`
454	`}`	457	`}`
455		458
456	`void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B) {`	459	`void Cube_Overlay_Set_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t R, uint16_t G, uint16_t B) {`
457	`// Set the specified pixel to the given color`	460	`// Set the specified pixel to the given color`
458	`R &= 0x0FFF;`	461	`R &= 0x0FFF;`
459	`G &= 0x0FFF;`	462	`G &= 0x0FFF;`
460	`B &= 0x0FFF;`	463	`B &= 0x0FFF;`
461	`int var = row * GCS_REG_SIZE + (column / 2 * 9);`	464	`uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9);`
462	`switch (column % 2) {`	465	`switch (column % 2) {`
463	`case 0:`	466	`case 0:`
464	`cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF;`	467	`cube_data_ptr->GCS_OVERLAY[layer][var+0] = R & 0xFF;`
465	`cube_data_ptr->GCS_OVERLAY[layer][var+1] = (G << 4) \| (R >> 8);`	468	`cube_data_ptr->GCS_OVERLAY[layer][var+1] = (G << 4) \| (R >> 8);`
466	`cube_data_ptr->GCS_OVERLAY[layer][var+2] = G >> 4;`	469	`cube_data_ptr->GCS_OVERLAY[layer][var+2] = G >> 4;`
Line 475...	Line 478...
475	`cube_data_ptr->GCS_OVERLAY[layer][var+8] = B >> 4;`	478	`cube_data_ptr->GCS_OVERLAY[layer][var+8] = B >> 4;`
476	`break;`	479	`break;`
477	`}`	480	`}`
478	`}`	481	`}`
479		482
480	`void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B) {`	483	`void Cube_Overlay_Get_Pixel(uint8_t layer, uint8_t row, uint8_t column, uint16_t* R, uint16_t* G, uint16_t* B) {`
481	`int var = row * GCS_REG_SIZE + (column / 2 * 9);`	484	`uint16_t var = row * GCS_REG_SIZE + (column / 2 * 9);`
482	`switch (column % 2) {`	485	`switch (column % 2) {`
483	`// Concatenate lower byte and upper byte of each color channel`	486	`// Concatenate lower byte and upper byte of each color channel`
484	`case 0:`	487	`case 0:`
485	`*R = cube_data_ptr->GCS_OVERLAY[layer][var+0] \| ((cube_data_ptr->GCS_OVERLAY[layer][var+1] & 0x0F) << 8);`	488	`*R = cube_data_ptr->GCS_OVERLAY[layer][var+0] \| ((cube_data_ptr->GCS_OVERLAY[layer][var+1] & 0x0F) << 8);`
486	`*G = (cube_data_ptr->GCS_OVERLAY[layer][var+1] >> 4) \| (cube_data_ptr->GCS_OVERLAY[layer][var+2] << 4);`	489	`*G = (cube_data_ptr->GCS_OVERLAY[layer][var+1] >> 4) \| (cube_data_ptr->GCS_OVERLAY[layer][var+2] << 4);`
Line 492...	Line 495...
492	`*B = (cube_data_ptr->GCS_OVERLAY[layer][var+7] >> 4) \| (cube_data_ptr->GCS_OVERLAY[layer][var+8] << 4);`	495	`*B = (cube_data_ptr->GCS_OVERLAY[layer][var+7] >> 4) \| (cube_data_ptr->GCS_OVERLAY[layer][var+8] << 4);`
493	`break;`	496	`break;`
494	`}`	497	`}`
495	`}`	498	`}`
496		499
497	`void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2) {`	500	`void Cube_Overlay_Move_Pixel(uint8_t layer1, uint8_t row1, uint8_t column1, uint8_t layer2, uint8_t row2, uint8_t column2) {`
498	`// Copies data from pixel 1 to pixel 2`	501	`// Copies data from pixel 1 to pixel 2`
499	`// Note: destination pixel value is overwritten`	502	`// Note: destination pixel value is overwritten`
500	`int prev_R, prev_G, prev_B;`	503	`uint16_t prev_R, prev_G, prev_B;`
501	`Cube_Overlay_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);`	504	`Cube_Overlay_Get_Pixel(layer1, row1, column1, &prev_R, &prev_G, &prev_B);`
502	`Cube_Overlay_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);`	505	`Cube_Overlay_Set_Pixel(layer2, row2, column2, prev_R, prev_G, prev_B);`
503	`}`	506	`}`
504		507
505	`void Cube_Overlay_Rotate_Shell(char shell, char direction) {`	508	`void Cube_Overlay_Rotate_Shell(uint8_t shell, uint8_t direction) {`
506	`// Shell is the layer to rotate, with the outermost being 0`	509	`// Shell is the layer to rotate, with the outermost being 0`
-		510	`uint8_t layer;`
507	`int layer, origin_R, origin_G, origin_B;;`	511	`uint16_t origin_R, origin_G, origin_B;;`
508	`for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {`	512	`for (layer = 0; layer < CUBE_LAYER_COUNT; layer++) {`
509	`if (direction) {`	513	`if (direction) {`
510	`switch(shell) {`	514	`switch(shell) {`
511	`case 0:`	515	`case 0:`
512	`// Rotate outermost layer`	516	`// Rotate outermost layer`
Line 678...	Line 682...
678		682
679	`////////////////////////////`	683	`////////////////////////////`
680	`// Text control functions //`	684	`// Text control functions //`
681	`////////////////////////////`	685	`////////////////////////////`
682		686
683	`void Cube_Text_Init(char *string, char length, int R, int G, int B) {`	687	`void Cube_Text_Init(uint8_t *string, uint8_t length, uint16_t R, uint16_t G, uint16_t B) {`
684	`// Ensure that the length of the string does not exceed the storage buffer`	688	`// Ensure that the length of the string does not exceed the storage buffer`
685	`if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;`	689	`if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;`
686		690
687	`Cube_Overlay_Clear();`	691	`Cube_Overlay_Clear();`
688		692
689	`// Copy the passed data into the buffer`	693	`// Copy the passed data into the buffer`
690	`int i;`	694	`uint8_t i;`
691	`for (i = 0; i < length; i++)`	695	`for (i = 0; i < length; i++)`
692	`cube_data_ptr->string[i] = string[i];`	696	`cube_data_ptr->string[i] = string[i];`
693	`cube_data_ptr->string_length = length;`	697	`cube_data_ptr->string_length = length;`
694	`cube_data_ptr->string_index = 0;`	698	`cube_data_ptr->string_index = 0;`
695	`cube_data_ptr->string_line = 0;`	699	`cube_data_ptr->string_line = 0;`
Line 697...	Line 701...
697	`cube_data_ptr->string_G = G;`	701	`cube_data_ptr->string_G = G;`
698	`cube_data_ptr->string_B = B;`	702	`cube_data_ptr->string_B = B;`
699	`}`	703	`}`
700		704
701	`void Cube_Text_Interrupt(void) {`	705	`void Cube_Text_Interrupt(void) {`
-		706	`uint8_t layer;`
702	`int layer, line;`	707	`uint16_t line;`
703		708
704	`// Rotate before drawing the new line at (0,0)`	709	`// Rotate before drawing the new line at (0,0)`
705	`Cube_Overlay_Rotate_Shell(0, 0);`	710	`Cube_Overlay_Rotate_Shell(0, 0);`
706		711
707	`// Get the next vertical line of the character currently being drawn`	712	`// Get the next vertical line of the int8_tacter currently being drawn`
708	`if (cube_data_ptr->string_line == 5) {`	713	`if (cube_data_ptr->string_line == 5) {`
709	`line = 0x0; // Leave a space between characters`	714	`line = 0x0; // Leave a space between int8_tacters`
710	`} else {`	715	`} else {`
711	`line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5)`	716	`line = font[(cube_data_ptr->string[cube_data_ptr->string_index] * 5)`
712	`+ cube_data_ptr->string_line];`	717	`+ cube_data_ptr->string_line];`
713	`}`	718	`}`
714		719
715	`// Draw the line onto (0,0) using the specified color`	720	`// Draw the line onto (0,0) using the specified color`
716	`for (layer = 7; layer >= 0; layer--) {`	721	`for (layer = 8; layer != 0; layer--) {`
717	`if (line & 0x1) {`	722	`if (line & 0x1) {`
718	`Cube_Overlay_Set_Pixel(layer, 0, 0, cube_data_ptr->string_R,`	723	`Cube_Overlay_Set_Pixel(layer-1, 0, 0, cube_data_ptr->string_R,`
719	`cube_data_ptr->string_G, cube_data_ptr->string_B);`	724	`cube_data_ptr->string_G, cube_data_ptr->string_B);`
720	`} else {`	725	`} else {`
721	`Cube_Overlay_Set_Pixel(layer, 0, 0, 0x00, 0x00, 0x00);`	726	`Cube_Overlay_Set_Pixel(layer-1, 0, 0, 0x00, 0x00, 0x00);`
722	`}`	727	`}`
723	`line >>= 1;`	728	`line >>= 1;`
724	`}`	729	`}`
725		730
726	`// Increment the vertical line and the character as needed`	731	`// Increment the vertical line and the int8_tacter as needed`
727	`if (cube_data_ptr->string_line == 5) {`	732	`if (cube_data_ptr->string_line == 5) {`
728	`cube_data_ptr->string_line = 0;`	733	`cube_data_ptr->string_line = 0;`
729	`if (cube_data_ptr->string_index == cube_data_ptr->string_length-1) {`	734	`if (cube_data_ptr->string_index == cube_data_ptr->string_length-1) {`
730	`cube_data_ptr->string_index = 0;`	735	`cube_data_ptr->string_index = 0;`
731	`} else {`	736	`} else {`
Line 738...	Line 743...
738		743
739	`/////////////////////////////////////////////`	744	`/////////////////////////////////////////////`
740	`// Functions for processing streaming data //`	745	`// Functions for processing streaming data //`
741	`/////////////////////////////////////////////`	746	`/////////////////////////////////////////////`
742		747
743	`void Cube_Data_In(char c) {`	748	`void Cube_Data_In(uint8_t c) {`
744	`// Reset upon receiving the start char`	749	`// Reset upon receiving the start int8_t`
745	`if (c == CUBE_START_CHAR) {`	750	`if (c == CUBE_START_CHAR) {`
746	`cube_data_ptr->frame_length = 0;`	751	`cube_data_ptr->frame_length = 0;`
747	`cube_data_ptr->frame_index = 0;`	752	`cube_data_ptr->frame_index = 0;`
748	`cube_data_ptr->frame_checksum = 0;`	753	`cube_data_ptr->frame_checksum = 0;`
749	`cube_data_ptr->frame_command = 0;`	754	`cube_data_ptr->frame_command = 0;`
750	`cube_data_ptr->frame_escape = 0;`	755	`cube_data_ptr->frame_escape = 0;`
751	`cube_data_ptr->frame_state = READ_LENGTH_MSB;`	756	`cube_data_ptr->frame_state = READ_LENGTH_MSB;`
752	`return;`	757	`return;`
753	`}`	758	`}`
754	`// If the input is the escape char, XOR the next char received`	759	`// If the input is the escape int8_t, XOR the next int8_t received`
755	`if (c == CUBE_ESCAPE_CHAR) {`	760	`if (c == CUBE_ESCAPE_CHAR) {`
756	`cube_data_ptr->frame_escape = 1;`	761	`cube_data_ptr->frame_escape = 1;`
757	`return;`	762	`return;`
758	`}`	763	`}`
759	`// XOR the input char if needed`	764	`// XOR the input int8_t if needed`
760	`if (cube_data_ptr->frame_escape) {`	765	`if (cube_data_ptr->frame_escape) {`
761	`c ^= CUBE_ESCAPE_XOR;`	766	`c ^= CUBE_ESCAPE_XOR;`
762	`cube_data_ptr->frame_escape = 0;`	767	`cube_data_ptr->frame_escape = 0;`
763	`}`	768	`}`
764	`// Process data`	769	`// Process data`
765	`switch (cube_data_ptr->frame_state) {`	770	`switch (cube_data_ptr->frame_state) {`
766	`case IDLE:`	771	`case IDLE:`
767	`// Reflect the character back to the transmitter`	772	`// Reflect the int8_tacter back to the transmitter`
768	`UART1_Write(&c, 1);`	773	`UART1_Write(&c, 1);`
769	`break;`	774	`break;`
770	`case READ_LENGTH_MSB: // Save MSB of length`	775	`case READ_LENGTH_MSB: // Save MSB of length`
771	`cube_data_ptr->frame_length \|= (c << 8);`	776	`cube_data_ptr->frame_length \|= (c << 8);`
772	`cube_data_ptr->frame_state = READ_LENGTH_LSB;`	777	`cube_data_ptr->frame_state = READ_LENGTH_LSB;`
Line 804...	Line 809...
804	`}`	809	`}`
805	`}`	810	`}`
806		811
807	`void Cube_Data_In_Process_Frame(void) {`	812	`void Cube_Data_In_Process_Frame(void) {`
808	`// Here we process received frames depending on the command`	813	`// Here we process received frames depending on the command`
809	`char *frame = cube_data_ptr->frame_buffer;`	814	`uint8_t *frame = cube_data_ptr->frame_buffer;`
810	`switch (cube_data_ptr->frame_command) {`	815	`switch (cube_data_ptr->frame_command) {`
811	`case CUBE_COMMAND_SET_BC:`	816	`case CUBE_COMMAND_SET_BC:`
812	`TIMER5_Stop();`	817	`TIMER5_Stop();`
813	`Delay_MS(1); // Need to wait for all SPI writes to complete`	818	`Delay_MS(1); // Need to wait for all SPI writes to complete`
814	`Cube_Write_DCS(frame[0]);`	819	`Cube_Write_DCS(frame[0]);`
Line 834...	Line 839...
834	`default:`	839	`default:`
835	`break;`	840	`break;`
836	`}`	841	`}`
837	`}`	842	`}`
838		843
839	`void Cube_Data_Direct_Write_All(char *buffer) {`	844	`void Cube_Data_Direct_Write_All(uint8_t *buffer) {`
840	`memcpy(cube_data_ptr->GCS, buffer, CUBE_LAYER_COUNT * GCS_LAYER_SIZE);`	845	`memcpy(cube_data_ptr->GCS, buffer, CUBE_LAYER_COUNT * GCS_LAYER_SIZE);`
841	`}`	846	`}`
842		847

Subversion Repositories Code-Repo

(root)/PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c @ 231 – Rev 216 → 231