Wed, 07 Nov 2018 20:00:52 +0100
more stuff
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
1 | #include "stdio.h" |
4
219766126afb
another attempt using a more complete support of the protocol and async serial stuff
David Douard <david.douard@logilab.fr>
parents:
3
diff
changeset
|
2 | |
21 | 3 | #include <mbed.h> |
4 | #include <rtos.h> | |
5 | #include <string> | |
4
219766126afb
another attempt using a more complete support of the protocol and async serial stuff
David Douard <david.douard@logilab.fr>
parents:
3
diff
changeset
|
6 | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
7 | #include "Terminal6x8.h" |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
8 | #include "Mono19x27.h" |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
9 | #include "Mono15x22.h" |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
10 | #include "Arial12x12.h" |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
11 | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
12 | #include "SSD1322.h" |
5 | 13 | #include "hp34comm.h" |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
14 | |
19 | 15 | #include "QEI.h" |
18
4fd621551d55
[full replacement] implement a state machine for Rx
David Douard <david.douard@logilab.fr>
parents:
17
diff
changeset
|
16 | #include "Keypad.h" |
4fd621551d55
[full replacement] implement a state machine for Rx
David Douard <david.douard@logilab.fr>
parents:
17
diff
changeset
|
17 | |
19 | 18 | /******************************************************/ |
19 | /* L432KC */ | |
20 | /******************************************************/ | |
17
162fe523c37d
almost working... before killing the 87C51...
David Douard <david.douard@logilab.fr>
parents:
13
diff
changeset
|
21 | #if (defined STM32L432xx) |
8 | 22 | // display |
23 | #define DSP_MOSI PA_7 //A6 | |
19 | 24 | #define DSP_MISO PA_6 //A5 |
8 | 25 | #define DSP_SCLK PA_5 //A4 |
26 | #define DSP_CS PB_0 //D3 | |
27 | #define DSP_RST PB_5 //D11 | |
28 | #define DSP_DC PB_4 //D12 | |
19 | 29 | |
11 | 30 | // UART for RX (CPU->DP) and TX (DP->CPU) combined |
18
4fd621551d55
[full replacement] implement a state machine for Rx
David Douard <david.douard@logilab.fr>
parents:
17
diff
changeset
|
31 | #define HP_TX PA_9 // serial1 TX |
8 | 32 | #define HP_RX PA_10 // serial1 RX |
19 | 33 | |
34 | // RST pin (handle this by hand) | |
35 | #define HP_RST PA_0 | |
36 | ||
8 | 37 | // misc |
19 | 38 | #define DBGPIN NC |
39 | ||
40 | // encoder | |
41 | #define KP_ENC1 PA_8 | |
42 | #define KP_ENC2 PA_11 | |
8 | 43 | |
19 | 44 | // keypad |
45 | #define KP_R0 PA_1 | |
46 | #define KP_R1 PA_3 | |
47 | #define KP_R2 PA_4 | |
48 | #define KP_R3 PA_12 | |
17
162fe523c37d
almost working... before killing the 87C51...
David Douard <david.douard@logilab.fr>
parents:
13
diff
changeset
|
49 | |
19 | 50 | #define KP_C0 D4 |
51 | #define KP_C1 D5 | |
52 | #define KP_C2 D6 | |
53 | #define KP_C3 D7 | |
54 | #define KP_C4 D8 | |
55 | ||
56 | /******************************************************/ | |
57 | /* F446RE */ | |
58 | /******************************************************/ | |
8 | 59 | #elif defined STM32F446xx |
19 | 60 | // UART |
61 | // USBTX PA_2 | |
62 | // USBRX PA_3 | |
8 | 63 | // display |
21 | 64 | #define DSP_MOSI PB_15 // blue |
19 | 65 | #define DSP_MISO NC |
21 | 66 | #define DSP_SCLK PB_13 // yellow |
67 | #define DSP_CS PB_12 // green | |
68 | #define DSP_RST PB_5 // green | |
69 | #define DSP_DC PB_4 // red | |
19 | 70 | |
8 | 71 | // UART for RX (CPU->DP) |
19 | 72 | #define HP_RX PC_11 // serial3 RX |
73 | #define HP_TX PC_10 // serial3 TX | |
74 | ||
75 | // RST pin (handle this by hand) | |
76 | #define HP_RST PC_12 | |
77 | ||
78 | // encoder | |
79 | #define KP_ENC1 PC_4 | |
80 | #define KP_ENC2 PC_5 | |
81 | ||
82 | // keypad | |
83 | #define KP_R0 PC_0 // I-6 | |
84 | #define KP_R1 PC_1 // II-5 | |
85 | #define KP_R2 PC_2 // I-5 | |
86 | #define KP_R3 PC_3 // II-4 | |
87 | ||
88 | ||
89 | #define KP_C0 PB_0 // I-4 | |
90 | #define KP_C1 PA_6 // I-2 | |
91 | #define KP_C2 PA_7 // I-3 | |
22 | 92 | #define KP_C3 PA_10 // I-1 |
19 | 93 | #define KP_C4 PD_2 // II-1 |
8 | 94 | |
95 | // misc | |
19 | 96 | #define DBGPIN PC_6 |
8 | 97 | |
98 | #endif | |
99 | ||
13
0fdeed7c083e
make USB (debug) serial console depend only on HAVE_PC compile variable
David Douard <david.douard@logilab.fr>
parents:
12
diff
changeset
|
100 | #ifdef HAVE_PC |
0fdeed7c083e
make USB (debug) serial console depend only on HAVE_PC compile variable
David Douard <david.douard@logilab.fr>
parents:
12
diff
changeset
|
101 | Serial pc(USBTX, USBRX); |
0fdeed7c083e
make USB (debug) serial console depend only on HAVE_PC compile variable
David Douard <david.douard@logilab.fr>
parents:
12
diff
changeset
|
102 | #endif |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
103 | |
19 | 104 | SSD1322 *dsp; |
105 | HPSerial *hp; | |
8 | 106 | volatile uint8_t must_refresh; |
107 | Thread tdsp, tloop; | |
19 | 108 | Ticker blinker; |
109 | Timeout rst_delay; | |
110 | Timeout splashscreen_timer; | |
8 | 111 | DigitalOut led(LED1); |
19 | 112 | InterruptIn rst(HP_RST); |
113 | ||
114 | QEI qenc(KP_ENC1, KP_ENC2, NC, 16); | |
115 | volatile uint8_t knob; | |
116 | volatile bool splashscreen; | |
117 | ||
118 | ||
119 | typedef enum { | |
120 | KEY_NONE=0, | |
121 | KEY_PRESSED, | |
122 | KEY_RELEASED | |
123 | } key_event_t; | |
124 | ||
125 | typedef struct keycode { | |
126 | uint8_t row; | |
127 | uint8_t col; | |
128 | key_event_t keyevent; | |
129 | } keycode_t; | |
130 | ||
131 | volatile keycode_t cur_keycode; | |
5 | 132 | |
19 | 133 | PinName kp_rows[] = { |
134 | KP_R0, | |
135 | KP_R1, | |
136 | KP_R2, | |
137 | KP_R3 | |
138 | }; | |
139 | ||
140 | PinName kp_colums[] = { | |
141 | KP_C0, KP_C1, | |
142 | KP_C2, KP_C3, | |
143 | KP_C4 | |
144 | }; | |
18
4fd621551d55
[full replacement] implement a state machine for Rx
David Douard <david.douard@logilab.fr>
parents:
17
diff
changeset
|
145 | |
19 | 146 | DigitalIn kp_in[] = { |
147 | KP_R0, | |
148 | KP_R1, | |
149 | KP_R2, | |
150 | KP_R3 | |
151 | }; | |
152 | ||
153 | DigitalOut kp_out[] = { | |
154 | KP_C0, KP_C1, | |
155 | KP_C2, KP_C3, | |
156 | KP_C4 | |
157 | }; | |
158 | ||
159 | uint8_t kp_nrows = sizeof(kp_in)/sizeof(kp_in[0]); | |
160 | uint8_t kp_ncols = sizeof(kp_out)/sizeof(kp_out[0]); | |
161 | ||
162 | void kp_cb(uint8_t row, uint8_t col); | |
163 | void kr_cb(uint8_t row, uint8_t col); | |
164 | ||
165 | Keypad *kpad; | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
166 | uint8_t curchar; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
167 | uint8_t cmd; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
168 | uint8_t nchars; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
169 | char buffer[MAX_BUFF+1]; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
170 | |
8 | 171 | void timeout_h() { |
172 | led = !led; | |
173 | } | |
174 | ||
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
175 | typedef struct _DSP |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
176 | { |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
177 | uint8_t cmd; |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
178 | uint8_t color; |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
179 | uint8_t bgcolor; |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
180 | uint8_t x0; |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
181 | uint8_t y0; |
5 | 182 | uint8_t fmt; // 0x01=>ascii, 0x02=>hex, 0x04=>bits, 0x08=>flags, 0x80=>ignore |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
183 | uint8_t maxsize; |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
184 | uint8_t width; |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
185 | const unsigned char* font; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
186 | char buffer[MAX_BUFF+1]; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
187 | } DSP; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
188 | |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
189 | static DSP table[] = |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
190 | { |
5 | 191 | { 0x00, 0xF, 0x0, 0, 0, 0x01, MAX_BUFF, 245, Mono19x27}, // main display |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
192 | { 0x0C, 0xF, 0x0,204, 38, 0x01, 3, 45, Mono15x22}, // channels display |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
193 | // { 0x01, 0xF, 0x0, 0, 0, 0x80, MAX_BUFF, 0, Terminal6x8}, |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
194 | // { 0x02, 0xF, 0x0, 0, 0, 0x80, MAX_BUFF, 0, Terminal6x8}, |
22 | 195 | { 0x0A, 0xF, 0x0, 0, 57, 0x08, 4, 0, Terminal6x8}, // flags + bits |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
196 | // { 0xFF, 0xF, 0x0, 0, 0, 0x80, MAX_BUFF, 0, Terminal6x8}, |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
197 | }; |
2 | 198 | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
199 | // 9x10 |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
200 | const unsigned char icon_alarm[] __attribute__((aligned (2))) = |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
201 | { |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
202 | 0x1c, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
203 | 0x3e, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
204 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
205 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
206 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
207 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
208 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
209 | 0x7f, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
210 | 0xff, 0x80, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
211 | 0x10, 0x0 |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
212 | }; |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
213 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
214 | const unsigned char icon_curve[] __attribute__((aligned (2))) = |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
215 | { |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
216 | 0x80, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
217 | 0x80, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
218 | 0x80, 0x80, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
219 | 0x81, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
220 | 0x9e, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
221 | 0xa0, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
222 | 0xc0, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
223 | 0x80, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
224 | 0x80, 0x0, |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
225 | 0xff, 0x80 |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
226 | }; |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
227 | |
2 | 228 | typedef struct _FLAG |
229 | { | |
230 | uint8_t flag; | |
8 | 231 | uint16_t zone; |
2 | 232 | uint8_t x; |
233 | uint8_t y; | |
234 | const char* msg; | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
235 | const unsigned char* icon; |
2 | 236 | } FLAG; |
237 | ||
5 | 238 | typedef struct _FRAME |
239 | { | |
8 | 240 | uint16_t flag; |
5 | 241 | uint8_t x0; |
242 | uint8_t y0; | |
243 | uint8_t x1; | |
244 | uint8_t y1; | |
245 | } FRAME; | |
246 | ||
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
247 | static const FLAG flags[] = |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
248 | { |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
249 | // flag, zone, x0, y0, msg, icon |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
250 | // right-side icons area |
21 | 251 | { 0x00, 0x02, 0, 0, NULL, icon_alarm}, // F1.0 |
252 | { 0x01, 0x02, 0, 11, NULL, icon_curve}, // F1.1 | |
22 | 253 | //{ 0x14, 0x02, 0, 0, "4W"}, // F2.4 |
254 | //{ 0x15, 0x02, 0, 8, "OC"}, // F2.5 | |
255 | ||
21 | 256 | // F1.2 == Channel frame |
257 | { 0x03, 0x04, 1, 2, "Channel"}, // F1.3 | |
258 | // F1.7 == Alarm frame | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
259 | |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
260 | // col 1 |
21 | 261 | { 0x34, 0x10, 0, 0, "MON"}, // F4.4 |
262 | { 0x33, 0x10, 0, 8, "VIEW"}, // F4.3 | |
263 | { 0x35, 0x10, 0, 16, "SCAN"}, // F4.5 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
264 | |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
265 | //col 2 |
21 | 266 | { 0x32, 0x20, 0, 0, "*"}, // F4.2 |
22 | 267 | { 0x36, 0x20, 0, 8, "CONFIG"}, // F4.6 |
268 | { 0x27, 0x20, 0, 16, "ERROR"}, // F3.7 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
269 | |
8 | 270 | // col 3 |
21 | 271 | { 0x41, 0x040, 0, 0, "ADRS"}, // F4.1 |
272 | { 0x40, 0x040, 0, 8, "RMT"}, // F4.0 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
273 | |
8 | 274 | // col 4 |
21 | 275 | { 0x26, 0x080, 0, 0, "EXT"}, // F3.6 |
276 | { 0x25, 0x080, 0, 8, "ONCE"}, // F3.5 | |
19 | 277 | |
21 | 278 | { 0x23, 0x080, 0, 16, "MEM"}, // F3.3 |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
279 | |
19 | 280 | |
8 | 281 | // col 5 |
21 | 282 | { 0x14, 0x100, 0, 0, "4W"}, // F2.4 |
283 | { 0x15, 0x100, 0, 8, "OC"}, // F2.5 | |
22 | 284 | { 0x22, 0x100, 0, 16, "LAST"}, // F3.2 |
21 | 285 | { 0x21, 0x100, 0, 16, "MIN"}, // F3.1 |
286 | { 0x20, 0x100, 0, 16, "MAX"}, // F3.0 | |
287 | { 0x17, 0x100, 0, 16, "AVG"}, // F2.7 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
288 | |
21 | 289 | { 0x05, 0x08, 0, 0, "Alarm"}, // F1.5 |
290 | { 0x06, 0x08, 0, 10, "H"}, // F1.6 | |
291 | { 0x13, 0x08, 6, 10, "1"}, // F2.3 | |
292 | { 0x10, 0x08, 12, 10, "2"}, // F2.0 | |
293 | { 0x12, 0x08, 18, 10, "3"}, // F2.2 | |
294 | { 0x11, 0x08, 24, 10, "4"}, // F2.1 | |
295 | { 0x04, 0x08, 30, 10, "L"}, // F1.4 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
296 | |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
297 | }; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
298 | |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
299 | static const FRAME zones[] = |
22 | 300 | { // flag, x0, y0, x1, y1 |
8 | 301 | { 0x001, 0, 0, 245, 27}, // main display area |
302 | { 0x002, 246, 0, 255, 27}, // right notif area | |
303 | { 0x004, 203, 28, 255, 54}, // channels display area | |
304 | { 0x008, 160, 28, 202, 54}, // alarms area | |
305 | { 0x010, 0, 28, 32, 54}, // flags col1 | |
306 | { 0x020, 33, 28, 70, 54}, // flags col2 | |
307 | { 0x040, 71, 28, 103, 54}, // flags col3 | |
308 | { 0x080, 104, 28, 128, 54}, // flags col4 | |
309 | { 0x100, 129, 28, 159, 54}, // flags col5 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
310 | |
22 | 311 | // { 0x8000, 0, 55, 255, 63}, // flags bits display area |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
312 | }; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
313 | |
5 | 314 | static const FRAME frames[] = |
315 | { | |
21 | 316 | { 0x02, 203, 35, 255, 54}, // F1.2 - channel frame |
317 | { 0x07, 160, 28, 202, 54}, // F1.7 - alarm frame | |
5 | 318 | }; |
319 | ||
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
320 | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
321 | #ifdef DEBUG |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
322 | |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
323 | DigitalOut dbgpin(DBGPIN); |
5 | 324 | inline void pulse(uint8_t count=1, bool stayup=false) |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
325 | { |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
326 | dbgpin = 0; |
5 | 327 | wait_us(2); |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
328 | while (count--) |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
329 | { |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
330 | dbgpin = 1; |
5 | 331 | wait_us(2); |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
332 | dbgpin = 0; |
5 | 333 | wait_us(2); |
334 | } | |
335 | if (stayup) | |
336 | dbgpin = 1; | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
337 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
338 | #else |
5 | 339 | inline void pulse(uint8_t count=1, bool stayup=false) |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
340 | {} |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
341 | #endif |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
342 | |
19 | 343 | // callbacks & thread functions |
344 | void loop(); | |
345 | void copy_to_lcd(void); | |
346 | void test_dsp(); | |
347 | void reset(void); | |
348 | void reset_irq(void); | |
349 | void qei_cb(int dir); | |
350 | void end_splashscreen(void); | |
22 | 351 | void show(uint8_t, const char*, uint8_t); |
4
219766126afb
another attempt using a more complete support of the protocol and async serial stuff
David Douard <david.douard@logilab.fr>
parents:
3
diff
changeset
|
352 | |
219766126afb
another attempt using a more complete support of the protocol and async serial stuff
David Douard <david.douard@logilab.fr>
parents:
3
diff
changeset
|
353 | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
354 | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
355 | void setup() { |
8 | 356 | #ifdef HAVE_PC |
357 | pc.baud (115200); | |
358 | #endif | |
21 | 359 | |
19 | 360 | printf("\n\nSETUP\n"); |
361 | printf(" System Core Clock = %.3f MHZ\r\n", | |
8 | 362 | (float)SystemCoreClock/1000000); |
21 | 363 | |
19 | 364 | //printf("Attaching Led 1: %d\n", LED1); |
365 | //blinker.attach(callback(timeout_h), 0.5f); | |
21 | 366 | |
19 | 367 | hp = NULL; |
22 | 368 | printf("Serial communication pins\r\n"); |
369 | printf(" USBRX=%d\r\n", USBRX); | |
370 | printf(" USBTX=%d\r\n", USBTX); | |
371 | ||
21 | 372 | printf("Setup HP communication pins\r\n"); |
373 | printf(" HP_RX=%d\r\n", HP_RX); | |
19 | 374 | DigitalIn(HP_RX).mode(PullDown); |
21 | 375 | printf(" HP_TX=%d\r\n", HP_TX); |
19 | 376 | DigitalOut(HP_TX).write(1); |
21 | 377 | printf(" HP_RST=%d\r\n", HP_RST); |
19 | 378 | DigitalIn(HP_RST).mode(PullDown); |
21 | 379 | |
380 | printf(" setup QEI pins\r\n"); | |
381 | printf(" ENC1=%d\r\n", KP_ENC1); | |
19 | 382 | DigitalIn(KP_ENC1).mode(PullUp); |
21 | 383 | printf(" ENC2=%d\r\n", KP_ENC2); |
19 | 384 | DigitalIn(KP_ENC2).mode(PullUp); |
385 | qenc.attach(&qei_cb); | |
386 | ||
21 | 387 | printf(" setup Keypad\r\n"); |
19 | 388 | cur_keycode.keyevent = KEY_NONE; |
389 | uint8_t nrows = sizeof(kp_rows)/sizeof(kp_rows[0]); | |
390 | uint8_t ncols = sizeof(kp_colums)/sizeof(kp_colums[0]); | |
391 | ||
392 | kpad = new Keypad(nrows, kp_in, ncols, kp_out); | |
21 | 393 | printf(" attach Keypad callbacks\r\n"); |
19 | 394 | kpad->attach(&kp_cb, &kr_cb); |
21 | 395 | printf(" start Keypad\r\n"); |
396 | kpad->start(); | |
397 | ||
398 | printf("Setup OLED display\r\n"); | |
19 | 399 | // init the LCD |
21 | 400 | printf(" DSP_MOSI=%d\r\n", DSP_MOSI); |
401 | printf(" DSP_MISO=%d\r\n", DSP_MISO); | |
402 | printf(" DSP_SCLK=%d\r\n", DSP_SCLK); | |
403 | printf(" DSP_CS=%d\r\n", DSP_CS); | |
404 | printf(" DSP_RST=%d\r\n", DSP_RST); | |
405 | printf(" DSP_DC=%d\r\n", DSP_DC); | |
19 | 406 | dsp = new SSD1322(20000000, DSP_MOSI, DSP_MISO, DSP_SCLK, DSP_CS, |
407 | DSP_RST, DSP_DC, "SSD1322"); | |
408 | //dsp.set_orientation(3); | |
21 | 409 | printf(" configure DSP\r\n"); |
8 | 410 | // myLCD.set_font((unsigned char*) Terminal6x8); |
411 | // myLCD.claim(stdout); // send stdout to the LCD display | |
412 | // myLCD.claim(stderr); // send stderr to the LCD display | |
413 | dsp->background(Black); // set background to black | |
414 | dsp->foreground(0xF); | |
415 | dsp->cls(); | |
19 | 416 | |
8 | 417 | cmd = 0xFF; |
418 | curchar = 0; | |
419 | nchars = 0; | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
420 | |
8 | 421 | for (uint8_t i=0; i<sizeof(table)/sizeof(table[0]); ++i) |
422 | memset(table[i].buffer, 0, MAX_BUFF+1); | |
19 | 423 | |
21 | 424 | printf(" display splash screen\r\n"); |
8 | 425 | dsp->locate(30, 10); |
426 | dsp->set_font((unsigned char*)Mono19x27); | |
427 | dsp->printf("HP34970A"); | |
428 | dsp->set_font((unsigned char*)Terminal6x8); | |
429 | dsp->locate(90, 40); | |
430 | dsp->printf("David Douard"); | |
431 | dsp->copy_to_lcd(); | |
19 | 432 | |
21 | 433 | printf("Starting LCD thread\r\n"); |
19 | 434 | tdsp.start(©_to_lcd); |
435 | ||
22 | 436 | printf("Starting Event thread\r\n"); |
437 | tloop.start(&loop); | |
438 | ||
439 | dsp->clrbuff(); | |
440 | show(0x00, "HH:MM:\tSS\t:mmmm", 15); // main dsp | |
441 | show(0x0C, "888", 3); // channel dsp | |
442 | show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags | |
21 | 443 | |
444 | printf("Attaching timers\r\n"); | |
22 | 445 | splashscreen = true; |
19 | 446 | splashscreen_timer.attach(callback(&end_splashscreen), 2); |
447 | rst.fall(&reset_irq); | |
21 | 448 | |
449 | printf("SETUP DONE\r\n"); | |
19 | 450 | } |
8 | 451 | |
19 | 452 | void end_splashscreen(void) |
453 | { | |
22 | 454 | printf("End of splash screen CB\r\n"); |
455 | //dsp->cls(); | |
19 | 456 | splashscreen = false; |
457 | } | |
458 | ||
459 | void reset_irq(void) | |
460 | { | |
21 | 461 | rst_delay.attach(callback(&reset), 0.1); |
19 | 462 | } |
463 | ||
464 | void reset(void) | |
465 | { | |
466 | if (DigitalIn(HP_RST).read() == 0) { | |
467 | if (hp == NULL) { | |
21 | 468 | printf("setup HP communication handler\r\n"); |
19 | 469 | hp = new HPSerial(HP_TX, HP_RX); |
470 | } | |
21 | 471 | |
472 | printf("!! RST !! (gstate=%d, state=%d)\r\n", | |
19 | 473 | hp->gstate(), hp->state()); |
474 | //printf("Value is ... %X\n", hp->search()); | |
475 | hp->startup(); | |
476 | } | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
477 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
478 | |
4
219766126afb
another attempt using a more complete support of the protocol and async serial stuff
David Douard <david.douard@logilab.fr>
parents:
3
diff
changeset
|
479 | void copy_to_lcd(void) { |
19 | 480 | //uint8_t mask=1; |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
481 | |
5 | 482 | while(1) { |
483 | pulse(0, true); | |
19 | 484 | if ((splashscreen == false) && (must_refresh)) { |
8 | 485 | must_refresh = 0; |
19 | 486 | //Thread::wait(20); // give a bit of time for some more cmds |
8 | 487 | dsp->copy_to_lcd(); |
488 | } | |
489 | ||
490 | /* | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
491 | if (must_refresh & mask) { |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
492 | for(uint8_t i=0; i<sizeof(zones)/sizeof(zones[0]); i++) |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
493 | if (zones[i].flag == mask) { |
8 | 494 | dsp->copy_to_lcd(zones[i].x0/4, (zones[i].x1+3)/4, |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
495 | zones[i].y0, zones[i].y1); |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
496 | must_refresh &= ~mask; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
497 | break; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
498 | } |
5 | 499 | } |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
500 | mask = mask << 1; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
501 | if (mask == 0) { |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
502 | mask = 1; |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
503 | } |
8 | 504 | */ |
5 | 505 | pulse(0, false); |
8 | 506 | Thread::wait(30); |
5 | 507 | } |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
508 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
509 | |
19 | 510 | void show(uint8_t cmd, const char *intxt, uint8_t nchar=0) { |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
511 | uint8_t i, len; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
512 | uint16_t bgcolor, fgcolor; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
513 | char *oldv; |
22 | 514 | char *txt, *txtp; |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
515 | |
21 | 516 | |
22 | 517 | if (cmd == 0xFF) // cls |
518 | { | |
519 | dsp->clrbuff(); | |
520 | } | |
521 | else | |
522 | { | |
19 | 523 | txt = (char *)malloc(strlen(intxt)+1); |
524 | strcpy(txt, intxt); | |
22 | 525 | txtp = txt; |
526 | ||
5 | 527 | pulse(1, true); |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
528 | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
529 | len = MAX_BUFF; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
530 | |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
531 | for (i=0; i<sizeof(table)/sizeof(table[0]); ++i) { |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
532 | if (table[i].cmd == cmd) { |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
533 | bgcolor = table[i].bgcolor; |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
534 | fgcolor = table[i].color; |
8 | 535 | dsp->background(bgcolor); |
536 | dsp->foreground(fgcolor); | |
537 | dsp->set_font((unsigned char*) table[i].font); | |
2 | 538 | oldv = table[i].buffer; |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
539 | |
8 | 540 | dsp->locate(table[i].x0, table[i].y0); |
5 | 541 | |
22 | 542 | if (table[i].fmt & 0x01 ) |
543 | { | |
544 | if (strncmp(oldv, txt, table[i].maxsize) != 0) | |
545 | { | |
546 | // ascii | |
547 | if (table[i].width > 0) | |
548 | dsp->fillrect(table[i].x0, | |
549 | table[i].y0, | |
550 | table[i].x0 + table[i].width, | |
551 | table[i].y0 + table[i].font[2], | |
552 | bgcolor); | |
553 | for (uint8_t k=0; ;k++) | |
554 | { | |
555 | if (txtp[k] == 0x00) | |
556 | { | |
557 | dsp->printf(txtp); | |
558 | break; | |
559 | } | |
560 | if (txtp[k] == 0x09) | |
561 | { // \t is a special char for 'unselected' display value | |
562 | txtp[k] = 0x00; | |
563 | dsp->printf(txtp); | |
19 | 564 | |
22 | 565 | if (fgcolor == table[i].color) |
566 | fgcolor /= 2; | |
567 | else | |
568 | fgcolor = table[i].color; | |
569 | dsp->foreground(fgcolor); | |
570 | txtp = &(txtp[k+1]); | |
571 | k = 0; | |
572 | } | |
573 | } | |
574 | if (cmd == 0x00) // main area | |
575 | must_refresh |= 0x01; | |
576 | if (cmd == 0x0C) // channels area | |
577 | must_refresh |= 0x04; | |
578 | } | |
5 | 579 | } |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
580 | /* |
5 | 581 | if (table[i].fmt & 0x02 ) { |
582 | // hex | |
2 | 583 | for (uint8_t j=0;; j++) { |
584 | if (txt[j] == 0x00) | |
585 | break; | |
8 | 586 | dsp->printf("%02X ", txt[j]); |
2 | 587 | } |
588 | for (uint8_t j=3*strlen(txt); j<table[i].maxsize; j++) | |
8 | 589 | dsp->printf(" "); |
5 | 590 | } |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
591 | */ |
22 | 592 | if (table[i].fmt & 0x08 ) |
593 | { | |
594 | // flags | |
595 | for (uint8_t j=0; j<max(nchar, table[i].maxsize) ; j++) | |
596 | { | |
597 | for (uint8_t k=0; k<8; k++) | |
598 | { | |
599 | if (1) | |
600 | { //(txt[j] & (1 << k) ) != (oldv[j] & (1 << k))) { | |
601 | if (txtp[j] & (1 << k)) | |
602 | dsp->foreground(fgcolor); | |
603 | else | |
604 | dsp->foreground(bgcolor); | |
5 | 605 | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
606 | /* |
5 | 607 | for (uint8_t l=0; |
608 | l<(sizeof(frames)/sizeof(frames[0])); ++l) { | |
609 | if (frames[l].flag & ((j<<4) + k)) | |
8 | 610 | dsp->fillrect(frames[l].x0, frames[l].y0, |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
611 | frames[l].x1, frames[l].y1, |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
612 | fgcolor/8); |
5 | 613 | else |
8 | 614 | dsp->fillrect(frames[l].x0, frames[l].y0, |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
615 | frames[l].x1, frames[l].y1, |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
616 | bgcolor); |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
617 | |
5 | 618 | } |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
619 | */ |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
620 | |
22 | 621 | for (uint8_t l=0; |
622 | l<(sizeof(flags)/sizeof(flags[0])); ++l) | |
623 | { | |
624 | if (flags[l].flag == ((j<<4) + k)) { | |
625 | for (uint8_t m=0; m<(sizeof(zones)/sizeof(zones[0])); m++) | |
626 | { | |
627 | if (flags[l].zone == zones[m].flag) { | |
628 | if (flags[l].msg != NULL) | |
629 | { // a string | |
630 | dsp->locate(flags[l].x + zones[m].x0, | |
631 | flags[l].y + zones[m].y0); | |
632 | dsp->printf(flags[l].msg);} | |
633 | else | |
634 | { // an icon | |
635 | Bitmap_s pic = {9, 10, 2, (char*) flags[l].icon}; | |
636 | dsp->Bitmap_BW(pic, | |
637 | flags[l].x + zones[m].x0, | |
638 | flags[l].y + zones[m].y0); | |
639 | } | |
640 | must_refresh |= zones[m].flag; | |
641 | break; | |
642 | } | |
643 | } | |
644 | break; | |
645 | } | |
646 | } | |
647 | } | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
648 | } |
2 | 649 | } |
650 | } | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
651 | |
5 | 652 | for(uint8_t j=0; j<table[i].maxsize; j++) |
22 | 653 | oldv[j] = txt[j]; |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
654 | break; |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
655 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
656 | } |
19 | 657 | free(txt); |
8 | 658 | //dsp->copy_to_lcd(); |
5 | 659 | pulse(1, false); |
22 | 660 | } |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
661 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
662 | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
663 | void test_dsp() |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
664 | { |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
665 | const FRAME *z; |
22 | 666 | printf("TEST DSP\r\n"); |
667 | dsp->cls(); | |
668 | printf("TEST DSP #2\r\n"); | |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
669 | show(0x00, "8g8g8g8g8g8g8", 13); // main dsp |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
670 | show(0x0C, "888", 3); // channel dsp |
5 | 671 | show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags |
8 | 672 | dsp->copy_to_lcd(); |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
673 | wait(3); |
8 | 674 | dsp->cls(); |
22 | 675 | printf("TEST DSP #3\r\n"); |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
676 | |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
677 | for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++) |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
678 | { |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
679 | z = &zones[i]; |
8 | 680 | dsp->fillrect(z->x0, z->y0, z->x1, z->y1, 4+i); |
681 | dsp->locate(z->x0+1, z->y0+1); | |
682 | dsp->printf("%d", i); | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
683 | } |
8 | 684 | |
685 | /* | |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
686 | for (uint8_t i=0; i<(sizeof(zones)/sizeof(zones[0])); i++) |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
687 | { |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
688 | z = &zones[i]; |
8 | 689 | printf("Zone %d [%x]: %d, %d, %d, %d\n", i, z->flag, |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
690 | z->x0, z->y0, z->x1, z->y1); |
8 | 691 | must_refresh = z->flag; |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
692 | wait(1); |
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
693 | } |
8 | 694 | printf("Done\n"); |
7
5cf4034ba4e0
attempt to update display by bloc
David Douard <david.douard@logilab.fr>
parents:
5
diff
changeset
|
695 | wait(2); |
8 | 696 | printf("Copy ALL\n"); |
697 | dsp->copy_to_lcd(); | |
698 | */ | |
699 | wait(2); | |
700 | dsp->cls(); | |
22 | 701 | printf("TEST DSP DONE\r\n"); |
3
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
702 | } |
a3233abe730e
beginning of a working display using the 3.2 OLED module
David Douard <david.douard@logilab.fr>
parents:
2
diff
changeset
|
703 | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
704 | |
19 | 705 | void loop() |
706 | { // run over and over | |
8 | 707 | unsigned int err[8]; |
708 | for (uint8_t i=0; i<8; i++) | |
709 | err[i] = 0; | |
19 | 710 | int p, pp; |
21 | 711 | p = 0; |
712 | pp = 0; | |
8 | 713 | while(1) { |
19 | 714 | if (knob != 0) |
21 | 715 | { |
716 | if (hp != NULL) | |
717 | { | |
718 | printf("Sending keycode %X\r\n", knob); | |
719 | hp->sendkey(knob); | |
720 | printf(" DONE\r\n"); | |
721 | } | |
722 | knob = 0; | |
19 | 723 | } |
724 | ||
725 | if (cur_keycode.keyevent != KEY_NONE) | |
21 | 726 | { |
727 | printf("Keycode %dx%d: %s\r\n", | |
728 | cur_keycode.row, cur_keycode.col, | |
729 | cur_keycode.keyevent==KEY_PRESSED?"pressed":"released"); | |
730 | cur_keycode.keyevent = KEY_NONE; | |
731 | } | |
19 | 732 | |
733 | p = qenc.getPulses(); | |
21 | 734 | if (p != pp) |
735 | { | |
736 | printf("Pulses = %d\r\n", p); | |
19 | 737 | pp = p; |
738 | } | |
21 | 739 | |
19 | 740 | if ((hp != NULL) && (hp->cmd_available())) |
741 | { | |
21 | 742 | HPSerial::CMD cmd; |
743 | if (hp->pop(cmd)) | |
744 | { | |
745 | led = 1; | |
746 | for (uint8_t i=0; i<7; i++) | |
747 | if (hp->nerrors(i) > err[i]) { | |
748 | printf("ERR: %d/%d/%d/%d/%d/%d/%d\r\n", | |
749 | hp->nerrors(0), | |
750 | hp->nerrors(1), | |
751 | hp->nerrors(2), | |
752 | hp->nerrors(3), | |
753 | hp->nerrors(4), | |
754 | hp->nerrors(5), | |
755 | hp->nerrors(6) | |
756 | ); | |
757 | break; | |
758 | } | |
759 | for (uint8_t i=0; i<7; i++) | |
760 | err[i] = hp->nerrors(i); | |
19 | 761 | |
21 | 762 | printf("CMD[%d] %02X", (int)cmd.id, cmd.cmd); |
19 | 763 | |
21 | 764 | if ((cmd.cmd == 0x00) || (cmd.cmd == 0x0C)) |
765 | printf(": '%s'\r\n", cmd.value); | |
766 | else { | |
767 | printf(":"); | |
768 | for (uint8_t i=0; i<cmd.size; i++) | |
769 | printf("%02x ", cmd.value[i]); | |
770 | printf("\r\n"); | |
771 | } | |
772 | show(cmd.cmd, cmd.value, cmd.size); | |
773 | led = 0; | |
774 | } | |
775 | } | |
776 | //else | |
17
162fe523c37d
almost working... before killing the 87C51...
David Douard <david.douard@logilab.fr>
parents:
13
diff
changeset
|
777 | Thread::wait(1); |
5 | 778 | } |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
779 | } |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
780 | |
19 | 781 | void qei_cb(int dir) |
782 | { | |
783 | if(dir == 1) // turn right | |
784 | knob = 0x80; | |
785 | else // turn left | |
786 | knob = 0x83; | |
787 | } | |
788 | ||
789 | void kp_cb(uint8_t row, uint8_t col) | |
790 | { | |
791 | cur_keycode.row = row; | |
792 | cur_keycode.col = col; | |
793 | cur_keycode.keyevent = KEY_PRESSED; | |
794 | } | |
795 | ||
796 | void kr_cb(uint8_t row, uint8_t col) | |
797 | { | |
798 | cur_keycode.row = row; | |
799 | cur_keycode.col = col; | |
800 | cur_keycode.keyevent = KEY_RELEASED; | |
801 | } | |
802 | ||
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
803 | int main() |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
804 | { |
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
805 | setup(); |
21 | 806 | printf("Main loop (noop)\r\n"); |
19 | 807 | while(1) |
22 | 808 | { |
809 | timeout_h(); | |
810 | wait(1); | |
811 | } | |
1
3021fc79cc3b
kinf of working prototype using a ILI9341 based TFT
David Douard <david.douard@logilab.fr>
parents:
diff
changeset
|
812 | } |