Subversion Repositories Code-Repo

Rev

Rev 209 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 209 Rev 212
Line 16... Line 16...
16 
 
 16 
 
17 
void Cube_Init(CUBE_DATA *data, char BC) {
 17 
void Cube_Init(CUBE_DATA *data, char BC) {
18 
    cube_data_ptr = data;
 18 
    cube_data_ptr = data;
19 
    cube_data_ptr->current_layer = 0;
 19 
    cube_data_ptr->current_layer = 0;
20 
    cube_data_ptr->rotation_counter = 0;
 20 
    cube_data_ptr->rotation_counter = 0;
- 
 
 21 
    cube_data_ptr->frame_state = IDLE;
- 
 
 22 
    cube_data_ptr->frame_escape = 0;
21 
 
 23 
 
22 
    SFT_D = 0;
 24 
    SFT_D = 0;
23 
    SFT_S = 0;
 25 
    SFT_S = 0;
24 
    SFT_K = 0;
 26 
    SFT_K = 0;
25 
    SFT_R = 0;
 27 
    SFT_R = 0;
Line 60... Line 62...
60 
    }
 62 
    }
61 
    // Write to the GCS register
 63 
    // Write to the GCS register
62 
    SPI1_Write(cube_data_ptr->GCS_WRITE[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
 64 
    SPI1_Write(cube_data_ptr->GCS_WRITE[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
63 
}
 65 
}
64 
 
 66 
 
- 
 
 67 
////////////////////////
- 
 
 68 
// Callback functions //
- 
 
 69 
////////////////////////
- 
 
 70 
 
65 
void Cube_DCS_Write_Callback(void) {
 71 
void Cube_DCS_Write_Callback(void) {
66 
    // GSLAT must be >7ms after DCS write
 72 
    // GSLAT must be >7ms after DCS write
67 
    Delay_MS(7);
 73 
    Delay_MS(7);
68 
    GSLAT = 0;
 74 
    GSLAT = 0;
69 
    Cube_Delay();
 75 
    Cube_Delay();
Line 99... Line 105...
99 
 
 105 
 
100 
    cube_data_ptr->current_layer = (cube_data_ptr->current_layer == CUBE_LAYER_COUNT-1)
 106 
    cube_data_ptr->current_layer = (cube_data_ptr->current_layer == CUBE_LAYER_COUNT-1)
101 
            ? 0 : cube_data_ptr->current_layer + 1;
 107 
            ? 0 : cube_data_ptr->current_layer + 1;
102 
}
 108 
}
103 
 
 109 
 
- 
 
 110 
////////////////////////////
- 
 
 111 
// Cube control functions //
- 
 
 112 
////////////////////////////
- 
 
 113 
 
104 
void Cube_Write_DCS(char BC) {
 114 
void Cube_Write_DCS(char BC) {
105 
    XBLNK = 0;
 115 
    XBLNK = 0;
106 
    int i,j;
 116 
    int i,j;
107 
    // Write configuration data to the DC/BC/FC/UD registers
 117 
    // Write configuration data to the DC/BC/FC/UD registers
108 
    unsigned char DCS[GCS_LAYER_SIZE] = {0};
 118 
    unsigned char DCS[GCS_LAYER_SIZE] = {0};
Line 429... Line 439...
429 
        cube_data_ptr->rotation_counter = (cube_data_ptr->rotation_counter == 0)
 439 
        cube_data_ptr->rotation_counter = (cube_data_ptr->rotation_counter == 0)
430 
                ? CUBE_ROTATIONS - 1 : cube_data_ptr->rotation_counter - 1;
 440 
                ? CUBE_ROTATIONS - 1 : cube_data_ptr->rotation_counter - 1;
431 
    }
 441 
    }
432 
}
 442 
}
433 
 
 443 
 
- 
 
 444 
///////////////////////////////
- 
 
 445 
// Overlay control functions //
- 
 
 446 
///////////////////////////////
434 
 
 447 
 
435 
void Cube_Overlay_Clear(void) {
 448 
void Cube_Overlay_Clear(void) {
436 
    int i,j;
 449 
    int i,j;
437 
    for (i = 0; i < CUBE_LAYER_COUNT; i++)
 450 
    for (i = 0; i < CUBE_LAYER_COUNT; i++)
438 
        for (j = 0; j < GCS_LAYER_SIZE; j++)
 451 
        for (j = 0; j < GCS_LAYER_SIZE; j++)
Line 660... Line 673...
660 
            }
 673 
            }
661 
        }
 674 
        }
662 
    }
 675 
    }
663 
}
 676 
}
664 
 
 677 
 
- 
 
 678 
////////////////////////////
- 
 
 679 
// Text control functions //
- 
 
 680 
////////////////////////////
665 
 
 681 
 
666 
void Cube_Text_Init(char *string, char length, int R, int G, int B) {
 682 
void Cube_Text_Init(char *string, char length, int R, int G, int B) {
667 
    // Ensure that the length of the string does not exceed the storage buffer
 683 
    // Ensure that the length of the string does not exceed the storage buffer
668 
    if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;
 684 
    if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;
669 
 
 685 
 
Line 713... Line 729...
713 
            cube_data_ptr->string_index += 1;
 729 
            cube_data_ptr->string_index += 1;
714 
        }
 730 
        }
715 
    } else {
 731 
    } else {
716 
        cube_data_ptr->string_line += 1;
 732 
        cube_data_ptr->string_line += 1;
717 
    }
 733 
    }
- 
 
 734 
}
- 
 
 735 
 
- 
 
 736 
/////////////////////////////////////////////
- 
 
 737 
// Functions for processing streaming data //
- 
 
 738 
/////////////////////////////////////////////
- 
 
 739 
 
- 
 
 740 
void Cube_Data_In(char c) {
- 
 
 741 
    // Reset upon receiving the start char
- 
 
 742 
    if (c == CUBE_START_CHAR) {
- 
 
 743 
        cube_data_ptr->frame_length = 0;
- 
 
 744 
        cube_data_ptr->frame_index = 0;
- 
 
 745 
        cube_data_ptr->frame_checksum = 0;
- 
 
 746 
        cube_data_ptr->frame_command = 0;
- 
 
 747 
        cube_data_ptr->frame_state = READ_LENGTH_MSB;
- 
 
 748 
    } else {
- 
 
 749 
        // If the input is the escape char, XOR the next char received
- 
 
 750 
        if (c == CUBE_ESCAPE_CHAR) {
- 
 
 751 
            cube_data_ptr->frame_escape = 1;
- 
 
 752 
            return;
- 
 
 753 
        }
- 
 
 754 
        // XOR the input char if needed
- 
 
 755 
        if (cube_data_ptr->frame_escape) {
- 
 
 756 
            c ^= CUBE_ESCAPE_XOR;
- 
 
 757 
            cube_data_ptr->frame_escape = 0;
- 
 
 758 
        }
- 
 
 759 
        // Process data
- 
 
 760 
        switch (cube_data_ptr->frame_state) {
- 
 
 761 
            case READ_LENGTH_MSB: // Save MSB of length
- 
 
 762 
                cube_data_ptr->frame_length |= (c << 8);
- 
 
 763 
                cube_data_ptr->frame_state = READ_LENGTH_LSB;
- 
 
 764 
                break;
- 
 
 765 
            case READ_LENGTH_LSB: // Save LSB of length
- 
 
 766 
                cube_data_ptr->frame_length |= c;
- 
 
 767 
                cube_data_ptr->frame_state = READ_COMMAND;
- 
 
 768 
                break;
- 
 
 769 
            case READ_COMMAND: // Store the command byte
- 
 
 770 
                cube_data_ptr->frame_checksum += c;
- 
 
 771 
                cube_data_ptr->frame_command = c;
- 
 
 772 
                cube_data_ptr->frame_state = READ_DATA;
- 
 
 773 
                break;
- 
 
 774 
            case READ_DATA: // Read the passed data into the buffer
- 
 
 775 
                cube_data_ptr->frame_checksum += c;
- 
 
 776 
                cube_data_ptr->frame_buffer[cube_data_ptr->frame_index] = c;
- 
 
 777 
                cube_data_ptr->frame_index++;
- 
 
 778 
                if (cube_data_ptr->frame_index == cube_data_ptr->frame_length)
- 
 
 779 
                    cube_data_ptr->frame_state = READ_CHECKSUM;
- 
 
 780 
                break;
- 
 
 781 
            case READ_CHECKSUM: // Process frame if checksum is valid
- 
 
 782 
                if (0xFF - (cube_data_ptr->frame_checksum && 0xFF) == c)
- 
 
 783 
                    Cube_Data_In_Process_Frame();
- 
 
 784 
                cube_data_ptr->frame_state = IDLE;
- 
 
 785 
                break;
- 
 
 786 
            case IDLE:
- 
 
 787 
            default:
- 
 
 788 
                // Do nothing
- 
 
 789 
                break;
- 
 
 790 
        }
- 
 
 791 
    }
- 
 
 792 
}
- 
 
 793 
 
- 
 
 794 
void Cube_Data_In_Process_Frame(void) {
- 
 
 795 
    char *frame = cube_data_ptr->frame_buffer;
- 
 
 796 
    switch (cube_data_ptr->frame_command) {
- 
 
 797 
        case CUBE_COMMAND_SET_PIXEL:
- 
 
 798 
            Cube_Set_Pixel(frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]);
- 
 
 799 
            break;
- 
 
 800 
        default:
- 
 
 801 
            break;
- 
 
 802 
    }
718 
}
 803 
}
719 

            804