Subversion Repositories Code-Repo

Rev

Rev 113 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
113 Kevin 1 
#include "maindefs.h"
2 
#include "led_driver.h"
3 
#include "delays.h"
4 
#include <spi.h>
5 
 
6 
unsigned int led_last_value;
7 
 
8 
#ifdef _SPI2_V1
9 
/* Output Pins:
10 
 * RA0 - LED Display Latch Enable (PPS)
11 
 * RA1 - LED Display CLK (PPS)
12 
 * RA2 - LED Display DIN (PPS)
13 
 * RA3 - LED Display Output Enable (PPS)
14 
 */
15 
#endif
16 
 
17 
#ifdef _SPI2_V2
18 
/* Output Pins:
19 
 * RA0 - LED Display CLK (PPS)
20 
 * RA1 - LED Display DIN (PPS)
21 
 * RA2 - LED Display Latch Enable (PPS)
22 
 * RA3 - LED Display Output Enable (PPS)
23 
 */
24 
#endif
25 
 
26 
void led_driver_init() {
27 
#ifdef _SPI2_V1
28 
    TRISAbits.TRISA0 = 0;   // LE
29 
    TRISAbits.TRISA1 = 0;   // CLK
30 
    TRISAbits.TRISA2 = 0;   // DAT
31 
    TRISAbits.TRISA3 = 0;   // OE
32 
 
33 
    LATAbits.LATA0 = 0; // LE
34 
    LATAbits.LATA1 = 0; // CLK
35 
    LATAbits.LATA2 = 0; // DAT
36 
    LATAbits.LATA3 = 0; // OE
37 
#endif
38 
 
39 
#ifdef _SPI2_V2
114 Kevin 40 
    TRISAbits.TRISA0 = 0;   // CLK
41 
    TRISAbits.TRISA1 = 0;   // DAT
42 
    TRISAbits.TRISA2 = 0;   // LE
43 
    TRISAbits.TRISA3 = 0;   // OE
44 
 
45 
    LATAbits.LATA0 = 0; // CLK
46 
    LATAbits.LATA1 = 0; // DAT
47 
    LATAbits.LATA2 = 1; // LE
48 
    LATAbits.LATA3 = 0; // OE
49 
 
113 Kevin 50 
    RPOR0 = 10; // CLK
51 
    RPOR1 = 9;  // DATA
52 
    OpenSPI2(SPI_FOSC_4, MODE_00, SMPMID);
53 
#endif
54 
 
55 
    led_last_value = 0;
56 
    led_driver_data(0);
57 
    led_driver_data(0);
58 
}
59 
 
114 Kevin 60 
void led_driver_clock() {
113 Kevin 61 
#ifdef _SPI2_V1
62 
    LATAbits.LATA1 = 0x1; // Simple clock output toggle
63 
    Nop();
64 
    LATAbits.LATA1 = 0x0;
65 
    Nop();
114 Kevin 66 
#endif
67 
#ifdef _SPI2_V2
68 
    LATAbits.LATA0 = 0x1; // Simple clock output toggle
69 
    Nop();
70 
    LATAbits.LATA0 = 0x0;
71 
    Nop();
72 
#endif
113 Kevin 73 
}
74 
 
75 
void led_driver_data(char val) {
76 
#ifdef _SPI2_V1
77 
    int i;
78 
    LATAbits.LATA0 = 0x0; // Set latch low to pause display
79 
    for (i = 0; i < 8; i++) {
80 
        LATAbits.LATA2 = val & 0x1; // Shift out bits
81 
        led_driver_clock();
82 
        val >>= 1;
83 
    }
84 
    LATAbits.LATA0 = 0x1; // Set latch high to resume display
85 
#endif
86 
 
87 
#ifdef _SPI2_V2
88 
    WriteSPI2(val);
89 
#endif
90 
}
91 
 
92 
void led_driver_num(unsigned char data) {
93 
    unsigned char tmp = 0;
94 
    led_last_value = 0;
95 
 
96 
    // Determine right character (1s digit)
97 
    tmp = data % 10;
98 
    switch (tmp) {
114 Kevin 99 
#ifdef _SPI2_V1
113 Kevin 100 
        case 0:
101 
            led_last_value |= 0x0D70;
102 
            break;
103 
        case 1:
104 
            led_last_value |= 0x0140;
105 
            break;
106 
        case 2:
107 
            led_last_value |= 0x0E60;
108 
            break;
109 
        case 3:
110 
            led_last_value |= 0x0760;
111 
            break;
112 
        case 4:
113 
            led_last_value |= 0x0350;
114 
            break;
115 
        case 5:
116 
            led_last_value |= 0x0730;
117 
            break;
118 
        case 6:
119 
            led_last_value |= 0x0F30;
120 
            break;
121 
        case 7:
122 
            led_last_value |= 0x0170;
123 
            break;
124 
        case 8:
125 
            led_last_value |= 0x0F70;
126 
            break;
127 
        case 9:
128 
            led_last_value |= 0x0770;
129 
            break;
114 Kevin 130 
#endif
131 
#ifdef _SPI2_V2
132 
            case 0:
133 
            led_last_value |= 0x0EB0;
134 
            break;
135 
        case 1:
136 
            led_last_value |= 0x0280;
137 
            break;
138 
        case 2:
139 
            led_last_value |= 0x0670;
140 
            break;
141 
        case 3:
142 
            led_last_value |= 0x06E0;
143 
            break;
144 
        case 4:
145 
            led_last_value |= 0x0AC0;
146 
            break;
147 
        case 5:
148 
            led_last_value |= 0x0CE0;
149 
            break;
150 
        case 6:
151 
            led_last_value |= 0x0CF0;
152 
            break;
153 
        case 7:
154 
            led_last_value |= 0x0E80;
155 
            break;
156 
        case 8:
157 
            led_last_value |= 0x0EF0;
158 
            break;
159 
        case 9:
160 
            led_last_value |= 0x0EE0;
161 
            break;
162 
#endif
113 Kevin 163 
    }
164 
 
165 
    // Determine left character (10s digit)
166 
    tmp = data / 10;
167 
    switch (tmp) {
114 Kevin 168 
#ifdef _SPI2_V1
113 Kevin 169 
        case 0:
170 
            led_last_value |= 0xE00D;
171 
            break;
172 
        case 1:
173 
            led_last_value |= 0x2008;
174 
            break;
175 
        case 2:
176 
            led_last_value |= 0xC00E;
177 
            break;
178 
        case 3:
179 
            led_last_value |= 0x600E;
180 
            break;
181 
        case 4:
182 
            led_last_value |= 0x200B;
183 
            break;
184 
        case 5:
185 
            led_last_value |= 0x6007;
186 
            break;
187 
        case 6:
188 
            led_last_value |= 0xE007;
189 
            break;
190 
        case 7:
191 
            led_last_value |= 0x200D;
192 
            break;
193 
        case 8:
194 
            led_last_value |= 0xE00F;
195 
            break;
196 
        case 9:
197 
            led_last_value |= 0x600F;
198 
            break;
114 Kevin 199 
#endif
200 
#ifdef _SPI2_V2
201 
            case 0:
202 
            led_last_value |= 0xB007;
203 
            break;
204 
        case 1:
205 
            led_last_value |= 0x1004;
206 
            break;
207 
        case 2:
208 
            led_last_value |= 0x7003;
209 
            break;
210 
        case 3:
211 
            led_last_value |= 0x7006;
212 
            break;
213 
        case 4:
214 
            led_last_value |= 0xD004;
215 
            break;
216 
        case 5:
217 
            led_last_value |= 0xE006;
218 
            break;
219 
        case 6:
220 
            led_last_value |= 0xE007;
221 
            break;
222 
        case 7:
223 
            led_last_value |= 0xB004;
224 
            break;
225 
        case 8:
226 
            led_last_value |= 0xF007;
227 
            break;
228 
        case 9:
229 
            led_last_value |= 0xF006;
230 
            break;
231 
#endif
113 Kevin 232 
    }
233 
 
114 Kevin 234 
#ifdef _SPI2_V1
113 Kevin 235 
    led_driver_data(led_last_value & 0x00FF);
236 
    led_driver_data((led_last_value & 0xFF00) >> 8);
114 Kevin 237 
#endif
238 
#ifdef _SPI2_V2
239 
    led_driver_data((led_last_value & 0xFF00) >> 8);
240 
    led_driver_data(led_last_value & 0x00FF);
241 
#endif
113 Kevin 242 
}
243 
 
244 
void led_driver_show_last() {
114 Kevin 245 
#ifdef _SPI2_V1
113 Kevin 246 
    led_driver_data(led_last_value & 0x00FF);
247 
    led_driver_data((led_last_value & 0xFF00) >> 8);
114 Kevin 248 
#endif
249 
#ifdef _SPI2_V2
250 
    led_driver_data((led_last_value & 0xFF00) >> 8);
251 
    led_driver_data(led_last_value & 0x00FF);
252 
#endif
113 Kevin 253 
}