105 |
105 |
106 void refresh_display(void); |
106 void refresh_display(void); |
107 |
107 |
108 void timeout_h() { |
108 void timeout_h() { |
109 #if defined(HAS_LED) |
109 #if defined(HAS_LED) |
110 led = !led; |
110 led = !led; |
111 #endif |
111 #endif |
112 } |
112 } |
113 |
113 |
114 #ifdef DEBUG |
114 #ifdef DEBUG |
115 |
115 |
116 DigitalOut dbgpin(DBGPIN); |
116 DigitalOut dbgpin(DBGPIN); |
117 inline void pulse(uint8_t count=1, bool stayup=false) |
117 inline void pulse(uint8_t count=1, bool stayup=false) |
118 { |
118 { |
119 dbgpin = 0; |
119 dbgpin = 0; |
120 wait_us(2); |
120 wait_us(2); |
121 while (count--) |
121 while (count--) |
122 { |
122 { |
123 dbgpin = 1; |
123 dbgpin = 1; |
124 wait_us(2); |
124 wait_us(2); |
125 dbgpin = 0; |
125 dbgpin = 0; |
126 wait_us(2); |
126 wait_us(2); |
127 } |
127 } |
128 if (stayup) |
128 if (stayup) |
129 dbgpin = 1; |
129 dbgpin = 1; |
130 } |
130 } |
131 #else |
131 #else |
132 inline void pulse(uint8_t count=1, bool stayup=false) |
132 inline void pulse(uint8_t count=1, bool stayup=false) |
133 {} |
133 {} |
134 #endif |
134 #endif |
135 |
135 |
136 // callbacks & thread functions |
136 // callbacks & thread functions |
137 void loop(); |
|
138 void reset(void); |
137 void reset(void); |
139 void reset_irq(void); |
138 void reset_irq(void); |
140 void qei_cb(int dir); |
139 void qei_cb(int dir); |
141 void end_splashscreen(void); |
140 void end_splashscreen(void); |
142 |
141 |
143 /* |
142 /* |
144 #if defined(HAVE_PC) |
143 #if defined(HAVE_PC) |
145 FileHandle *mbed::mbed_override_console(int fd) |
144 FileHandle *mbed::mbed_override_console(int fd) |
146 { |
145 { |
147 return static_cast<FileHandle*> (&pc); |
146 return static_cast<FileHandle*> (&pc); |
148 } |
147 } |
149 #endif |
148 #endif |
150 */ |
149 */ |
151 |
150 |
152 void setup() { |
151 void setup() { |
153 #if defined(HAVE_PC) |
152 #if defined(HAVE_PC) |
154 #if defined(TARGET_NUCLEO_F446RE) |
153 #if defined(TARGET_NUCLEO_F446RE) |
155 pc.set_baud(115200); |
154 pc.set_baud(115200); |
156 #endif |
155 #endif |
157 |
156 |
158 /* |
157 /* |
159 #if defined(TARGET_HP34970_FP_F303RD) |
158 #if defined(TARGET_HP34970_FP_F303RD) |
160 pc.init(); |
159 pc.init(); |
161 pc.connect(); |
160 pc.connect(); |
162 #endif |
161 #endif |
163 */ |
162 */ |
164 #endif |
163 #endif |
165 |
164 |
166 printf("\n\nSETUP\n"); |
165 printf("\n\nSETUP\n"); |
167 printf(" System Core Clock = %.3f MHZ\r\n", |
166 printf(" System Core Clock = %.3f MHZ\r\n", |
168 (float)SystemCoreClock/1000000); |
167 (float)SystemCoreClock/1000000); |
169 |
168 |
170 /* |
169 /* |
171 #if defined(HAS_LED) |
170 #if defined(HAS_LED) |
172 printf("Attaching Led 1: %d\n", LED1); |
171 printf("Attaching Led 1: %d\n", LED1); |
173 blinker.attach(callback(timeout_h), 0.5f); |
172 blinker.attach(callback(timeout_h), 0.5f); |
174 #endif |
173 #endif |
175 */ |
174 */ |
176 |
175 |
177 hp = NULL; |
176 hp = NULL; |
178 #if defined(TARGET_NUCLEO_F446RE) |
177 #if defined(TARGET_NUCLEO_F446RE) |
179 printf("Serial communication pins\r\n"); |
178 printf("Serial communication pins\r\n"); |
180 printf(" USBRX=%d\r\n", USBRX); |
179 printf(" USBRX=%d\r\n", USBRX); |
181 printf(" USBTX=%d\r\n", USBTX); |
180 printf(" USBTX=%d\r\n", USBTX); |
182 #endif |
181 #endif |
183 #if defined(TARGET_HP34970_FP_F303RD) |
182 #if defined(TARGET_HP34970_FP_F303RD) |
184 printf("Serial communication via USB\r\n"); |
183 printf("Serial communication via USB\r\n"); |
185 #endif |
184 #endif |
186 |
185 |
187 printf("Setup HP communication pins\r\n"); |
186 printf("Setup HP communication pins\r\n"); |
188 printf(" HP_RX=%d\r\n", HP_RX); |
187 printf(" HP_RX=%d\r\n", HP_RX); |
189 DigitalIn(HP_RX).mode(PullDown); |
188 DigitalIn(HP_RX).mode(PullDown); |
190 printf(" HP_TX=%d\r\n", HP_TX); |
189 printf(" HP_TX=%d\r\n", HP_TX); |
191 DigitalOut(HP_TX).write(1); |
190 DigitalOut(HP_TX).write(1); |
192 printf(" HP_RST=%d\r\n", HP_RST); |
191 printf(" HP_RST=%d\r\n", HP_RST); |
193 DigitalIn(HP_RST).mode(PullDown); |
192 DigitalIn(HP_RST).mode(PullDown); |
194 |
193 |
195 printf(" setup QEI pins\r\n"); |
194 printf(" setup QEI pins\r\n"); |
196 printf(" ENC1=%d\r\n", KP_ENC1); |
195 printf(" ENC1=%d\r\n", KP_ENC1); |
197 DigitalIn(KP_ENC1).mode(PullDown); |
196 DigitalIn(KP_ENC1).mode(PullDown); |
198 printf(" ENC2=%d\r\n", KP_ENC2); |
197 printf(" ENC2=%d\r\n", KP_ENC2); |
199 DigitalIn(KP_ENC2).mode(PullDown); |
198 DigitalIn(KP_ENC2).mode(PullDown); |
200 qenc.attach(&qei_cb); |
199 qenc.attach(&qei_cb); |
201 |
200 |
202 printf(" setup Keypad\r\n"); |
201 printf(" setup Keypad\r\n"); |
203 //cur_keycode.keyevent = KEY_NONE; |
202 //cur_keycode.keyevent = KEY_NONE; |
204 |
203 |
205 shift = false; |
204 shift = false; |
206 kpad = new Keypad(KP_NROWS, kp_rows, KP_NCOLS, kp_columns); |
205 kpad = new Keypad(KP_NROWS, kp_rows, KP_NCOLS, kp_columns); |
207 printf(" attach Keypad callbacks\r\n"); |
206 printf(" attach Keypad callbacks\r\n"); |
208 kpad->attach(&kp_cb, &kr_cb); |
207 kpad->attach(&kp_cb, &kr_cb); |
209 printf(" start Keypad\r\n"); |
208 printf(" start Keypad\r\n"); |
210 kpad->start(); |
209 kpad->start(); |
211 |
210 |
212 printf("Setup OLED display\r\n"); |
211 printf("Setup OLED display\r\n"); |
213 // init the LCD |
212 // init the LCD |
214 printf(" DSP_MOSI=%d\r\n", DSP_MOSI); |
213 printf(" DSP_MOSI=%d\r\n", DSP_MOSI); |
215 printf(" DSP_MISO=%d\r\n", DSP_MISO); |
214 printf(" DSP_MISO=%d\r\n", DSP_MISO); |
216 printf(" DSP_SCLK=%d\r\n", DSP_SCLK); |
215 printf(" DSP_SCLK=%d\r\n", DSP_SCLK); |
217 printf(" DSP_CS=%d\r\n", DSP_CS); |
216 printf(" DSP_CS=%d\r\n", DSP_CS); |
218 printf(" DSP_RST=%d\r\n", DSP_RST); |
217 printf(" DSP_RST=%d\r\n", DSP_RST); |
219 printf(" DSP_DC=%d\r\n", DSP_DC); |
218 printf(" DSP_DC=%d\r\n", DSP_DC); |
220 dsp = new Display(20000000, DSP_MOSI, DSP_MISO, DSP_SCLK, DSP_CS, |
219 dsp = new Display(20000000, DSP_MOSI, DSP_MISO, DSP_SCLK, DSP_CS, |
221 DSP_RST, DSP_DC, "SSD1322"); |
220 DSP_RST, DSP_DC, "SSD1322"); |
222 |
221 |
223 //curcmd = 0xFF; |
222 //curcmd = 0xFF; |
224 curchar = 0; |
223 curchar = 0; |
225 nchars = 0; |
224 nchars = 0; |
226 |
225 |
227 for (uint8_t i=0; i<sizeof(table)/sizeof(table[0]); ++i) |
226 for (uint8_t i=0; i<sizeof(table)/sizeof(table[0]); ++i) |
228 memset(table[i].buffer, 0, MAX_BUFF+1); |
227 memset(table[i].buffer, 0, MAX_BUFF+1); |
229 |
228 |
230 printf(" display splash screen\r\n"); |
229 printf(" display splash screen\r\n"); |
231 dsp->show_splashscreen(); |
230 dsp->show_splashscreen(); |
232 |
231 |
233 printf("Starting LCD thread\r\n"); |
232 printf("Starting LCD thread\r\n"); |
234 tdsp.start(&refresh_display); |
233 tdsp.start(&refresh_display); |
235 |
234 |
236 //printf("Starting Event thread\r\n"); |
235 /* |
237 //tloop.start(&loop); |
236 dsp->clrbuff(); |
238 |
237 show(0x00, "HH:MM:\tSS\t:mmmm", 15); // main dsp |
239 /* |
238 show(0x0C, "888", 3); // channel dsp |
240 dsp->clrbuff(); |
239 show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags |
241 show(0x00, "HH:MM:\tSS\t:mmmm", 15); // main dsp |
240 */ |
242 show(0x0C, "888", 3); // channel dsp |
241 |
243 show(0x0A, "\xFF\xFF\xFF\xFF", 4); // all flags |
242 printf("Attaching timers\r\n"); |
244 */ |
243 splashscreen = true; |
245 |
244 splashscreen_timer.attach(callback(&end_splashscreen), 2ms); |
246 printf("Attaching timers\r\n"); |
245 rst.fall(&reset_irq); |
247 splashscreen = true; |
246 |
248 splashscreen_timer.attach(callback(&end_splashscreen), 2ms); |
247 printf("SETUP DONE\r\n"); |
249 rst.fall(&reset_irq); |
|
250 |
|
251 printf("SETUP DONE\r\n"); |
|
252 } |
248 } |
253 |
249 |
254 void end_splashscreen(void) |
250 void end_splashscreen(void) |
255 { |
251 { |
256 // print is forbidden here because we are in an ISR context here |
252 // print is forbidden here because we are in an ISR context here |
257 //printf("End of splash screen CB\r\n"); |
253 //printf("End of splash screen CB\r\n"); |
258 splashscreen = false; |
254 splashscreen = false; |
259 } |
255 } |
260 |
256 |
261 void reset_irq(void) |
257 void reset_irq(void) |
262 { |
258 { |
263 rst_delay.attach(callback(&reset), 1ms); |
259 rst_delay.attach(callback(&reset), 1ms); |
264 } |
260 } |
265 |
261 |
266 void reset(void) |
262 void reset(void) |
267 { |
263 { |
268 if (DigitalIn(HP_RST).read() == 0) { |
264 if (DigitalIn(HP_RST).read() == 0) { |
269 if (hp == NULL) { |
265 if (hp == NULL) { |
270 printf("setup HP communication handler\r\n"); |
266 printf("setup HP communication handler\r\n"); |
271 hp = new HPSerial(HP_TX, HP_RX); |
267 hp = new HPSerial(HP_TX, HP_RX); |
272 } |
268 } |
273 |
269 |
274 printf("!! RST !! (gstate=%d, state=%d)\r\n", |
270 printf("!! RST !! (gstate=%d, state=%d)\r\n", |
275 hp->gstate(), hp->state()); |
271 hp->gstate(), hp->state()); |
276 //printf("Value is ... %X\n", hp->search()); |
272 //printf("Value is ... %X\n", hp->search()); |
277 hp->startup(); |
273 hp->startup(); |
278 } |
274 } |
279 } |
275 } |
280 |
276 |
281 void refresh_display(void) { |
277 void refresh_display(void) { |
282 //uint8_t mask=1; |
278 //uint8_t mask=1; |
283 |
279 |
284 while(1) { |
280 while(1) { |
285 pulse(0, true); |
281 pulse(0, true); |
286 if (splashscreen == false) { |
282 if (splashscreen == false) { |
287 //Thread::wait(20); // give a bit of time for some more cmds |
283 //Thread::wait(20); // give a bit of time for some more cmds |
288 dsp->copy_to_lcd(); |
284 dsp->copy_to_lcd(); |
289 } |
285 } |
290 |
286 |
291 /* |
287 /* |
292 if (must_refresh & mask) { |
288 if (must_refresh & mask) { |
293 for(uint8_t i=0; i<sizeof(zones)/sizeof(zones[0]); i++) |
289 for(uint8_t i=0; i<sizeof(zones)/sizeof(zones[0]); i++) |
294 if (zones[i].flag == mask) { |
290 if (zones[i].flag == mask) { |
295 dsp->copy_to_lcd(zones[i].x0/4, (zones[i].x1+3)/4, |
291 dsp->copy_to_lcd(zones[i].x0/4, (zones[i].x1+3)/4, |
296 zones[i].y0, zones[i].y1); |
292 zones[i].y0, zones[i].y1); |
297 must_refresh &= ~mask; |
293 must_refresh &= ~mask; |
298 break; |
294 break; |
299 } |
295 } |
300 } |
296 } |
301 mask = mask << 1; |
297 mask = mask << 1; |
302 if (mask == 0) { |
298 if (mask == 0) { |
303 mask = 1; |
299 mask = 1; |
304 } |
300 } |
305 */ |
301 */ |
306 pulse(0, false); |
302 pulse(0, false); |
307 |
303 |
308 ThisThread::sleep_for(30ms); |
304 ThisThread::sleep_for(30ms); |
309 } |
305 } |
310 } |
306 } |
311 |
307 |
312 void loop() |
308 void mainloop() |
313 { // run over and over |
309 { // run over and over |
314 keycode_t key = {0, 0, KEY_NONE}; |
310 keycode_t key = {0, 0, KEY_NONE}; |
315 |
311 |
316 unsigned int err[8]; |
312 unsigned int err[8]; |
317 for (uint8_t i=0; i<8; i++) |
313 for (uint8_t i=0; i<8; i++) |
318 err[i] = 0; |
314 err[i] = 0; |
319 int p, pp; // rot encoder pulse counters |
315 int p, pp; // rot encoder pulse counters |
320 p = 0; |
316 p = 0; |
321 pp = 0; |
317 pp = 0; |
322 |
318 |
323 while(1) { |
319 while(1) { |
324 p = qenc.getPulses(); |
320 p = qenc.getPulses(); |
325 if (p != pp) |
321 if (p != pp) |
326 { |
322 { |
327 dsp->locate(0, 0); |
323 dsp->locate(0, 0); |
328 dsp->printf("Pulses = %d ", p); |
324 dsp->printf("Pulses = %d ", p); |
329 dsp->copy_to_lcd(); |
325 dsp->copy_to_lcd(); |
330 pp = p; |
326 pp = p; |
331 } |
327 } |
332 |
328 |
333 if (knob != 0) |
329 if (knob != 0) |
334 { |
330 { |
335 if (hp != NULL) |
331 if (hp != NULL) |
336 { |
332 { |
337 printf("Sending keycode %X\r\n", knob); |
333 printf("Sending keycode %X\r\n", knob); |
338 hp->sendkey(knob); |
334 hp->sendkey(knob); |
339 printf(" DONE\r\n"); |
335 printf(" DONE\r\n"); |
340 } |
336 } |
341 else |
337 else |
342 { |
338 { |
343 dsp->locate(70, 0); |
339 dsp->locate(70, 0); |
344 dsp->printf("Knob = %X ", knob); |
340 dsp->printf("Knob = %X ", knob); |
345 dsp->copy_to_lcd(); |
341 dsp->copy_to_lcd(); |
346 } |
342 } |
347 knob = 0; |
343 knob = 0; |
348 } |
344 } |
349 |
345 |
350 if (!key_buf.empty()) //cur_keycode.keyevent != KEY_NONE) |
346 if (!key_buf.empty()) //cur_keycode.keyevent != KEY_NONE) |
351 { |
347 { |
352 key_buf.pop(key); |
348 key_buf.pop(key); |
353 printf("Keycode %dx%d: %s\r\n", |
349 printf("Keycode %dx%d: %s\r\n", |
354 key.row, key.col, key.keyevent==KEY_PRESSED?"pressed":"released"); |
350 key.row, key.col, key.keyevent==KEY_PRESSED?"pressed":"released"); |
355 if (hp != NULL) { |
351 if (hp != NULL) { |
356 uint8_t keycode = kp_mapping[key.row][key.col]; |
352 uint8_t keycode = kp_mapping[key.row][key.col]; |
357 if (key.keyevent == KEY_RELEASED) |
353 if (key.keyevent == KEY_RELEASED) |
358 keycode |= 0x40; // bit 6: key relased |
354 keycode |= 0x40; // bit 6: key relased |
359 if (shift) |
355 if (shift) |
360 keycode |= 0x20; // bit 5: key shifted |
356 keycode |= 0x20; // bit 5: key shifted |
361 |
357 |
362 hp->sendkey(kp_mapping[key.row][key.col]); |
358 hp->sendkey(kp_mapping[key.row][key.col]); |
363 } |
359 } |
364 else |
360 else |
365 { |
361 { |
366 dsp->locate(140, 0); |
362 dsp->locate(140, 0); |
367 dsp->printf("KC: %dx%d[0x%s%X] %s", |
363 dsp->printf("KC: %dx%d[0x%s%X] %s", |
368 key.row, key.col, |
364 key.row, key.col, |
369 kp_mapping[key.row][key.col] <= 0x0F ? "0" : "", |
365 kp_mapping[key.row][key.col] <= 0x0F ? "0" : "", |
370 kp_mapping[key.row][key.col], |
366 kp_mapping[key.row][key.col], |
371 key.keyevent==KEY_PRESSED ? "PRE" : "REL"); |
367 key.keyevent==KEY_PRESSED ? "PRE" : "REL"); |
372 dsp->copy_to_lcd(); |
368 dsp->copy_to_lcd(); |
373 } |
369 } |
374 // cur_keycode.keyevent = KEY_NONE; |
370 // cur_keycode.keyevent = KEY_NONE; |
375 } |
371 } |
376 |
372 |
377 |
373 |
378 if ((hp != NULL) && (hp->cmd_available())) |
374 if ((hp != NULL) && (hp->cmd_available())) |
379 { |
375 { |
380 HPSerial::CMD cmd; |
376 HPSerial::CMD cmd; |
381 if (hp->pop(cmd)) |
377 if (hp->pop(cmd)) |
382 { |
378 { |
383 #if defined(HAS_LED) |
379 #if defined(HAS_LED) |
384 led = 1; |
380 led = 1; |
385 #endif |
381 #endif |
386 for (uint8_t i=0; i<7; i++) |
382 for (uint8_t i=0; i<7; i++) |
387 if (hp->nerrors(i) > err[i]) { |
383 if (hp->nerrors(i) > err[i]) { |
388 printf("ERR: %d/%d/%d/%d/%d/%d/%d\r\n", |
384 printf("ERR: %d/%d/%d/%d/%d/%d/%d\r\n", |
389 hp->nerrors(0), |
385 hp->nerrors(0), |
390 hp->nerrors(1), |
386 hp->nerrors(1), |
391 hp->nerrors(2), |
387 hp->nerrors(2), |
392 hp->nerrors(3), |
388 hp->nerrors(3), |
393 hp->nerrors(4), |
389 hp->nerrors(4), |
394 hp->nerrors(5), |
390 hp->nerrors(5), |
395 hp->nerrors(6) |
391 hp->nerrors(6) |
396 ); |
392 ); |
397 break; |
393 break; |
398 } |
394 } |
399 for (uint8_t i=0; i<7; i++) |
395 for (uint8_t i=0; i<7; i++) |
400 err[i] = hp->nerrors(i); |
396 err[i] = hp->nerrors(i); |
401 |
397 |
402 printf("CMD[%d] %02X", (int)cmd.id, cmd.cmd); |
398 printf("CMD[%d] %02X", (int)cmd.id, cmd.cmd); |
403 |
399 |
404 // 0x00: main display |
400 // 0x00: main display |
405 // 0x0C: channel display |
401 // 0x0C: channel display |
406 if ((cmd.cmd == 0x00) || (cmd.cmd == 0x0C)) |
402 if ((cmd.cmd == 0x00) || (cmd.cmd == 0x0C)) |
407 printf(": '%s'\r\n", cmd.value); |
403 printf(": '%s'\r\n", cmd.value); |
408 else { |
404 else { |
409 printf(":"); |
405 printf(":"); |
410 for (uint8_t i=0; i<cmd.size; i++) |
406 for (uint8_t i=0; i<cmd.size; i++) |
411 printf("%02x ", cmd.value[i]); |
407 printf("%02x ", cmd.value[i]); |
412 printf("\r\n"); |
408 printf("\r\n"); |
413 } |
409 } |
414 |
410 |
415 if (cmd.cmd == 0x01) { |
411 if (cmd.cmd == 0x01) { |
416 // clear a flag |
412 // clear a flag |
417 if (cmd.value[0] == 0x0E) { |
413 if (cmd.value[0] == 0x0E) { |
418 // clear the Shift flag |
414 // clear the Shift flag |
419 shift = false; |
415 shift = false; |
420 } |
416 } |
421 } else if (cmd.cmd == 0x86) { |
417 } else if (cmd.cmd == 0x86) { |
422 // shutdown |
418 // shutdown |
423 // TODO |
419 // TODO |
424 } else { |
420 } else { |
425 // display related commands |
421 // display related commands |
426 dsp->show(cmd.cmd, cmd.value, cmd.size); |
422 dsp->show(cmd.cmd, cmd.value, cmd.size); |
427 } |
423 } |
428 #if defined(HAS_LED) |
424 #if defined(HAS_LED) |
429 led = 0; |
425 led = 0; |
430 #endif |
426 #endif |
431 } |
427 } |
432 } |
428 } |
433 //else |
429 //else |
434 ThisThread::sleep_for(1ms); |
430 ThisThread::sleep_for(1ms); |
435 } |
431 } |
436 } |
432 } |
437 |
433 |
438 void qei_cb(int dir) |
434 void qei_cb(int dir) |
439 { |
435 { |
440 if(dir == 1) // turn right |
436 if(dir == 1) // turn right |
441 knob = 0x80; |
437 knob = 0x80; |
442 else // turn left |
438 else // turn left |
443 knob = 0x81; // 83? |
439 knob = 0x81; // 83? |
444 } |
440 } |
445 |
441 |
446 void kp_cb(uint8_t row, uint8_t col) |
442 void kp_cb(uint8_t row, uint8_t col) |
447 { |
443 { |
448 keycode_t key; |
444 keycode_t key; |
449 key.row = row; |
445 key.row = row; |
450 key.col = col; |
446 key.col = col; |
451 key.keyevent = KEY_PRESSED; |
447 key.keyevent = KEY_PRESSED; |
452 if(!key_buf.full()) |
448 if(!key_buf.full()) |
453 key_buf.push(key); |
449 key_buf.push(key); |
454 } |
450 } |
455 |
451 |
456 void kr_cb(uint8_t row, uint8_t col) |
452 void kr_cb(uint8_t row, uint8_t col) |
457 { |
453 { |
458 keycode_t key; |
454 keycode_t key; |
459 key.row = row; |
455 key.row = row; |
460 key.col = col; |
456 key.col = col; |
461 key.keyevent = KEY_RELEASED; |
457 key.keyevent = KEY_RELEASED; |
462 if(!key_buf.full()) |
458 if(!key_buf.full()) |
463 key_buf.push(key); |
459 key_buf.push(key); |
464 } |
460 } |
465 |
461 |
466 int main() |
462 int main() |
467 { |
463 { |
468 setup(); |
464 setup(); |
469 printf("Main loop (noop)\r\n"); |
465 printf("Main loop (noop)\r\n"); |
470 loop(); |
466 mainloop(); |
471 /* |
467 } |
472 while(1) |
|
473 { |
|
474 timeout_h(); |
|
475 ThisThread::sleep_for(1ms); |
|
476 } |
|
477 */ |
|
478 } |
|