Subversion Repositories Code-Repo

Rev

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

Rev 200 Rev 201
Line 3... Line 3...
3 
#include "defines.h"
 3 
#include "defines.h"
4 
#include "CUBE.h"
 4 
#include "CUBE.h"
5 
#include "SPI1.h"
 5 
#include "SPI1.h"
6 
 
 6 
 
7 
static CUBE_DATA *cube_data_ptr;
 7 
static CUBE_DATA *cube_data_ptr;
8 
static unsigned char current_layer;
 - 
 
9 
 
 8 
 
10 
inline void Cube_Delay() {
 9 
inline void Cube_Delay() {
11 
    // Small delay to ensure that latch speeds are < 30Mhz
 10 
    // Small delay to ensure that latch speeds are < 30Mhz
12 
    Nop();
 11 
    Nop();
13 
    Nop();
 12 
    Nop();
14 
    Nop();
 13 
    Nop();
15 
}
 14 
}
16 
 
 15 
 
17 
void Cube_Init(CUBE_DATA *data, char BC) {
 16 
void Cube_Init(CUBE_DATA *data, char BC) {
18 
    cube_data_ptr = data;
 17 
    cube_data_ptr = data;
19 
    current_layer = 0;
 18 
    cube_data_ptr->current_layer = 0;
20 
 
 19 
 
21 
    SFT_D = 0;
 20 
    SFT_D = 0;
22 
    SFT_S = 0;
 21 
    SFT_S = 0;
23 
    SFT_K = 0;
 22 
    SFT_K = 0;
24 
    SFT_R = 0;
 23 
    SFT_R = 0;
Line 48... Line 47...
48 
    Cube_Clear();
 47 
    Cube_Clear();
49 
}
 48 
}
50 
 
 49 
 
51 
void Cube_Timer_Interrupt(void) {
 50 
void Cube_Timer_Interrupt(void) {
52 
    // Write to the GCS register
 51 
    // Write to the GCS register
53 
    SPI1_Write(cube_data_ptr->GCS[current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
 52 
    SPI1_Write(cube_data_ptr->GCS[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback);
54 
}
 53 
}
55 
 
 54 
 
56 
void Cube_DCS_Write_Callback(void) {
 55 
void Cube_DCS_Write_Callback(void) {
57 
    // GSLAT must be >7ms after DCS write
 56 
    // GSLAT must be >7ms after DCS write
58 
    Delay_MS(7);
 57 
    Delay_MS(7);
Line 70... Line 69...
70 
    GSLAT = 1;
 69 
    GSLAT = 1;
71 
    // Set the shift register to turn on the current layer
 70 
    // Set the shift register to turn on the current layer
72 
    int i;
 71 
    int i;
73 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 72 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
74 
        Cube_Delay();
 73 
        Cube_Delay();
75 
        SFT_D = (i == CUBE_LAYER_COUNT - current_layer - 1) ? 1 : 0;
 74 
        SFT_D = (i == CUBE_LAYER_COUNT - cube_data_ptr->current_layer - 1) ? 1 : 0;
76 
        Cube_Delay();
 75 
        Cube_Delay();
77 
        SFT_K = 1;
 76 
        SFT_K = 1;
78 
        Cube_Delay();
 77 
        Cube_Delay();
79 
        SFT_K = 0;
 78 
        SFT_K = 0;
80 
    }
 79 
    }
Line 86... Line 85...
86 
    // Enable LED output
 85 
    // Enable LED output
87 
    XBLNK = 1;
 86 
    XBLNK = 1;
88 
    Cube_Delay();
 87 
    Cube_Delay();
89 
    GSLAT = 0;
 88 
    GSLAT = 0;
90 
 
 89 
 
91 
    current_layer = (current_layer == CUBE_LAYER_COUNT-1) ? 0 : current_layer + 1;
 90 
    cube_data_ptr->current_layer = (cube_data_ptr->current_layer == CUBE_LAYER_COUNT-1)
- 
 
 91 
            ? 0 : cube_data_ptr->current_layer + 1;
92 
}
 92 
}
93 
 
 93 
 
94 
void Cube_Write_DCS(char BC) {
 94 
void Cube_Write_DCS(char BC) {
- 
 
 95 
    // Ensure that the brightness isnt set too high
95 
    if (BC > CUBE_MAX_BRIGHTNESS)
 96 
    if (BC > CUBE_MAX_BRIGHTNESS)
96 
        BC = CUBE_MAX_BRIGHTNESS;
 97 
        BC = CUBE_MAX_BRIGHTNESS;
97 
 
 98 
 
98 
    XBLNK = 0;
 99 
    XBLNK = 0;
99 
    int i,j;
 100 
    int i,j;
Line 115... Line 116...
115 
        DCS[offset + 24] = 0x68; // 0110 1000
 116 
        DCS[offset + 24] = 0x68; // 0110 1000
116 
    }
 117 
    }
117
118
118 
    GSLAT = 1;
 119 
    GSLAT = 1;
119 
    SPI1_Write(DCS, GCS_LAYER_SIZE, &Cube_DCS_Write_Callback);
 120 
    SPI1_Write(DCS, GCS_LAYER_SIZE, &Cube_DCS_Write_Callback);
120 
    Delay_MS(8); // Delay until the entire DCS write is finished
 121 
    Delay_MS(10); // Delay until the entire DCS write is finished
121 
}
 122 
}
122 
 
 123 
 
123 
void Cube_Clear(void) {
 124 
void Cube_Clear(void) {
124 
    int i,j;
 125 
    int i,j;
125 
    for (i = 0; i < CUBE_LAYER_COUNT; i++)
 126 
    for (i = 0; i < CUBE_LAYER_COUNT; i++)
126 
        for (j = 0; j < GCS_LAYER_SIZE; j++)
 127 
        for (j = 0; j < GCS_LAYER_SIZE; j++)
127 
            cube_data_ptr->GCS[i][j] = 0x00;
 128 
            cube_data_ptr->GCS[i][j] = 0x00;
128 
}
 129 
}
129 
 
 130 
 
130 
void Cube_Set_All(int R, int G, int B) {
 131 
void Cube_Set_All(int R, int G, int B) {
- 
 
 132 
    // Set all pixels in the cube to the given color
131 
    R &= 0x0FFF;
 133 
    R &= 0x0FFF;
132 
    G &= 0x0FFF;
 134 
    G &= 0x0FFF;
133 
    B &= 0x0FFF;
 135 
    B &= 0x0FFF;
134 
    int i,j,k;
 136 
    int i,j,k;
135 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 137 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
Line 150... Line 152...
150 
        }
 152 
        }
151 
    }
 153 
    }
152 
}
 154 
}
153 
 
 155 
 
154 
void Cube_Set_Layer(int layer, int R, int G, int B) {
 156 
void Cube_Set_Layer(int layer, int R, int G, int B) {
- 
 
 157 
    // Set all pixels in the specified layer to the given color
155 
    R &= 0x0FFF;
 158 
    R &= 0x0FFF;
156 
    G &= 0x0FFF;
 159 
    G &= 0x0FFF;
157 
    B &= 0x0FFF;
 160 
    B &= 0x0FFF;
158 
    int i,j;
 161 
    int i,j;
159 
    for (i = 0; i < CUBE_ROW_COUNT; i++) {
 162 
    for (i = 0; i < CUBE_ROW_COUNT; i++) {
Line 172... Line 175...
172 
        }
 175 
        }
173 
    }
 176 
    }
174 
}
 177 
}
175 
 
 178 
 
176 
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) {
 179 
void Cube_Set_Pixel(int layer, int row, int column, int R, int G, int B) {
- 
 
 180 
    // Set the specified pixel to the given color
177 
    R &= 0x0FFF;
 181 
    R &= 0x0FFF;
178 
    G &= 0x0FFF;
 182 
    G &= 0x0FFF;
179 
    B &= 0x0FFF;
 183 
    B &= 0x0FFF;
180 
    int var = row * GCS_REG_SIZE + (column / 2 * 9);
 184 
    int var = row * GCS_REG_SIZE + (column / 2 * 9);
181 
    switch (column % 2) {
 185 
    switch (column % 2) {