Subversion Repositories Code-Repo

Rev

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

Rev 213 Rev 215
Line 682... Line 682...
682
 
682
 
683
void Cube_Text_Init(char *string, char length, int R, int G, int B) {
683
void Cube_Text_Init(char *string, char length, int R, int G, int B) {
684
    // Ensure that the length of the string does not exceed the storage buffer
684
    // 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;
685
    if (length > CUBE_STRING_MAX_LENGTH) length = CUBE_STRING_MAX_LENGTH;
686
 
686
 
-
 
687
    Cube_Overlay_Clear();
-
 
688
 
687
    // Copy the passed data into the buffer
689
    // Copy the passed data into the buffer
688
    int i;
690
    int i;
689
    for (i = 0; i < length; i++)
691
    for (i = 0; i < length; i++)
690
        cube_data_ptr->string[i] = string[i];
692
        cube_data_ptr->string[i] = string[i];
691
    cube_data_ptr->string_length = length;
693
    cube_data_ptr->string_length = length;
Line 743... Line 745...
743
    if (c == CUBE_START_CHAR) {
745
    if (c == CUBE_START_CHAR) {
744
        cube_data_ptr->frame_length = 0;
746
        cube_data_ptr->frame_length = 0;
745
        cube_data_ptr->frame_index = 0;
747
        cube_data_ptr->frame_index = 0;
746
        cube_data_ptr->frame_checksum = 0;
748
        cube_data_ptr->frame_checksum = 0;
747
        cube_data_ptr->frame_command = 0;
749
        cube_data_ptr->frame_command = 0;
-
 
750
        cube_data_ptr->frame_escape = 0;
748
        cube_data_ptr->frame_state = READ_LENGTH_MSB;
751
        cube_data_ptr->frame_state = READ_LENGTH_MSB;
749
    } else {
752
        return;
-
 
753
    }
750
        // If the input is the escape char, XOR the next char received
754
    // If the input is the escape char, XOR the next char received
751
        if (c == CUBE_ESCAPE_CHAR) {
755
    if (c == CUBE_ESCAPE_CHAR) {
752
            cube_data_ptr->frame_escape = 1;
756
        cube_data_ptr->frame_escape = 1;
753
            return;
757
        return;
754
        }
758
    }
755
        // XOR the input char if needed
759
    // XOR the input char if needed
756
        if (cube_data_ptr->frame_escape) {
760
    if (cube_data_ptr->frame_escape) {
757
            c ^= CUBE_ESCAPE_XOR;
761
        c ^= CUBE_ESCAPE_XOR;
758
            cube_data_ptr->frame_escape = 0;
762
        cube_data_ptr->frame_escape = 0;
759
        }
763
    }
760
        // Process data
764
    // Process data
761
        switch (cube_data_ptr->frame_state) {
765
    switch (cube_data_ptr->frame_state) {
762
            case IDLE:
766
        case IDLE:
763
                // Reflect the character back to the transmitter
767
            // Reflect the character back to the transmitter
764
                UART1_Write(&c, 1);
768
            UART1_Write(&c, 1);
765
                break;
769
            break;
766
            case READ_LENGTH_MSB: // Save MSB of length
770
        case READ_LENGTH_MSB: // Save MSB of length
767
                cube_data_ptr->frame_length |= (c << 8);
771
            cube_data_ptr->frame_length |= (c << 8);
768
                cube_data_ptr->frame_state = READ_LENGTH_LSB;
772
            cube_data_ptr->frame_state = READ_LENGTH_LSB;
769
                break;
773
            break;
770
            case READ_LENGTH_LSB: // Save LSB of length
774
        case READ_LENGTH_LSB: // Save LSB of length
771
                cube_data_ptr->frame_length |= c;
775
            cube_data_ptr->frame_length |= c;
772
                cube_data_ptr->frame_state = READ_COMMAND;
776
            cube_data_ptr->frame_state = READ_COMMAND;
773
                break;
777
            break;
774
            case READ_COMMAND: // Store the command byte
778
        case READ_COMMAND: // Store the command byte
775
                cube_data_ptr->frame_checksum += c;
779
            cube_data_ptr->frame_checksum += c;
776
                cube_data_ptr->frame_command = c;
780
            cube_data_ptr->frame_command = c;
-
 
781
            if (cube_data_ptr->frame_length == 1)
-
 
782
                cube_data_ptr->frame_state = READ_CHECKSUM;
-
 
783
            else
777
                cube_data_ptr->frame_state = READ_DATA;
784
                cube_data_ptr->frame_state = READ_DATA;
778
                break;
785
            break;
779
            case READ_DATA: // Read the passed data into the buffer
786
        case READ_DATA: // Read the passed data into the buffer
780
                cube_data_ptr->frame_checksum += c;
787
            cube_data_ptr->frame_checksum += c;
781
                cube_data_ptr->frame_buffer[cube_data_ptr->frame_index] = c;
788
            cube_data_ptr->frame_buffer[cube_data_ptr->frame_index] = c;
782
                cube_data_ptr->frame_index++;
789
            cube_data_ptr->frame_index++;
783
                if (cube_data_ptr->frame_index == cube_data_ptr->frame_length - 1)
790
            if (cube_data_ptr->frame_index == cube_data_ptr->frame_length - 1)
784
                    cube_data_ptr->frame_state = READ_CHECKSUM;
791
                cube_data_ptr->frame_state = READ_CHECKSUM;
785
                break;
792
            break;
786
            case READ_CHECKSUM: // Process frame if checksum is valid
793
        case READ_CHECKSUM: // Process frame if checksum is valid
787
                cube_data_ptr->frame_checksum = 0xFF - cube_data_ptr->frame_checksum;
794
            cube_data_ptr->frame_checksum = 0xFF - cube_data_ptr->frame_checksum;
788
                if (cube_data_ptr->frame_checksum == c) {
795
            if (cube_data_ptr->frame_checksum == c) {
789
                    Cube_Data_In_Process_Frame();
796
                Cube_Data_In_Process_Frame();
790
                }
797
            }
791
                cube_data_ptr->frame_state = IDLE;
798
            cube_data_ptr->frame_state = IDLE;
-
 
799
            cube_data_ptr->frame_index = 0;
-
 
800
            cube_data_ptr->frame_length = 0;
792
                break;
801
            break;
793
            default:
802
        default:
794
                break;
803
            break;
795
        }
-
 
796
    }
804
    }
797
}
805
}
798
 
806
 
799
void Cube_Data_In_Process_Frame(void) {
807
void Cube_Data_In_Process_Frame(void) {
-
 
808
    // Here we process received frames depending on the command
800
    char *frame = cube_data_ptr->frame_buffer;
809
    char *frame = cube_data_ptr->frame_buffer;
801
    switch (cube_data_ptr->frame_command) {
810
    switch (cube_data_ptr->frame_command) {
-
 
811
        case CUBE_COMMAND_SET_BC:
-
 
812
            TIMER5_Stop();
-
 
813
            Delay_MS(1); // Need to wait for all SPI writes to complete
-
 
814
            Cube_Write_DCS(frame[0]);
-
 
815
            TIMER5_Start();
-
 
816
            break;
-
 
817
        case CUBE_COMMAND_CLEAR:
-
 
818
            Cube_Clear();
-
 
819
            break;
802
        case CUBE_COMMAND_SET_PIXEL:
820
        case CUBE_COMMAND_SET_PIXEL:
803
            Cube_Set_Pixel(frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]);
821
            Cube_Set_Pixel(frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]);
804
            break;
822
            break;
-
 
823
        case CUBE_COMMAND_SET_LAYER:
-
 
824
            Cube_Data_Direct_Write(frame[0], &frame[1]);
-
 
825
            break;
-
 
826
        case CUBE_COMMAND_START_TEXT:
-
 
827
            Cube_Text_Init(&frame[3], cube_data_ptr->frame_length - 4, frame[0], frame[1], frame[2]);
-
 
828
            TIMER4_Start();
-
 
829
            break;
-
 
830
        case CUBE_COMMAND_STOP_TEXT:
-
 
831
            TIMER4_Stop();
-
 
832
            Cube_Overlay_Clear();
-
 
833
            break;
805
        default:
834
        default:
806
            break;
835
            break;
807
    }
836
    }
-
 
837
}
-
 
838
 
-
 
839
void Cube_Data_Direct_Write(char layer, char *buffer) {
-
 
840
    int i;
-
 
841
    for (i = 0; i < GCS_LAYER_SIZE; i++) {
-
 
842
        cube_data_ptr->GCS[layer][i] = buffer[i];
-
 
843
    }
808
}
844
}
809
845