1 /*
2 * Copyright (c) 2006-2025, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2024-06-17 QT-one first version
9 */
10
11 #include "board.h"
12
13 #ifdef BSP_USING_TEST
14
15 /* Task stack */
16 #define THREAD_PRIORITY 25
17 #define THREAD_STACK_SIZE 512
18 #define THREAD_TIMESLICE 5
19
20 /* Test pins */
21 #define TEST_LED0_PIN GET_PIN(C, 14)
22 #define TEST_LED1_PIN GET_PIN(C, 15)
23 #define TEST_LED2_PIN GET_PIN(C, 1)
24
25 #define TEST_WAKEUP_PIN GET_PIN(B, 12)
26 #define TEST_KEY1_PIN GET_PIN(D, 1)
27 #define TEST_KEY2_PIN GET_PIN(D, 2)
28
29 #define TEST_OTHER_PIN GET_PIN(B, 12)
30 #define TEST_OUTPUT_PIN GET_PIN(C, 1)
31
32 #define TEST_INPUT_PIN GET_PIN(D, 1)
33 #define TEST_INT_PIN GET_PIN(D, 2)
34 #define TEST_RES_PIN GET_PIN(C, 1)
35
36
37 /* Event flags */
38 #define TEST_GPIO_INT_ENV (1 << 10)
39 #define TEST_GPIO_KEY_ENV (1 << 15)
40 static struct rt_event led_event; /* LED event */
41 #define TASK_KILL_FLAG (1 << 10)
42 static struct rt_event task_event; /* Task event */
43
44 /* EEPROM Read/Write Data Structure */
45 typedef union
46 {
47 rt_uint8_t data[30];
48 struct
49 {
50 rt_uint8_t write_addr;
51 char write_date[29];
52 }in_data;
53 }eeprom_write_type;
54 /* Semaphore variables */
55 static struct rt_semaphore rx_sem;
56
57 /* Mutually exclusive variables */
58 static rt_mutex_t task_mutex = RT_NULL; /* task mutex */
59
60 /* device handle */
61 #ifdef BSP_USING_UART
62 static rt_device_t serial;
63 #endif
64 #ifdef BSP_USING_WDT
65 static rt_device_t wdt_dev;
66 #endif
67 #ifdef BSP_USING_I2C
68 static struct rt_i2c_bus_device *i2c_dev;
69 #endif
70 #ifdef BSP_USING_SPI
71 static struct rt_spi_device *spi_dev;
72 #endif
73
74 /* In-file function declarations */
75 //static void sys_run_dir(void *parameter);
76 //static void gpio_output_test(void *parameter);
77 //static void gpio_input_test(void *parameter);
78 //static void key_iqr_handle(void *args);
79
80 /* Task registration */
task_registration(void)81 int task_registration(void)
82 {
83 // USB_Configuration(RT_NULL);
84 /* Create a dynamic mutex */
85 task_mutex = rt_mutex_create("task_mutex", RT_IPC_FLAG_FIFO);
86 if (task_mutex == RT_NULL)
87 {
88 rt_kprintf("rt_mutex_create error.\n");
89 return -1;
90 }
91 /* Create a task event */
92 if(rt_event_init(&task_event,"task_event",RT_IPC_FLAG_FIFO) != RT_EOK)
93 {
94 rt_kprintf("rt_mutex_create error.\n");
95 return -1;
96 }
97 return 0;
98 }
99 INIT_BOARD_EXPORT(task_registration);
100
101 /* System operation indicator */
102 #ifdef BSP_USING_GPIO
sys_run_dir(void * parameter)103 static void sys_run_dir(void *parameter)
104 {
105 rt_uint32_t e;
106 rt_pin_mode(TEST_LED2_PIN, PIN_MODE_OUTPUT);
107 while(1)
108 {
109 if(rt_event_recv(&task_event,TASK_KILL_FLAG,
110 RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
111 RT_WAITING_NO, &e) == RT_EOK)
112 {
113 rt_thread_t tid = rt_thread_self();
114 rt_thread_delete(tid);
115 }
116 rt_pin_write(TEST_LED2_PIN, PIN_LOW);
117 rt_thread_mdelay(500);
118 rt_pin_write(TEST_LED2_PIN, PIN_HIGH);
119 rt_thread_mdelay(500);
120 }
121 }
122
sys_run_task(int argc,char * argv[])123 static int sys_run_task(int argc, char *argv[])
124 {
125 if(argc == 2)
126 {
127 if(rt_strcmp(argv[1],"start") == 0)
128 {
129 if(rt_mutex_take(task_mutex, RT_WAITING_NO) != RT_EOK)
130 {
131 rt_kprintf("The test thread is occupied.\n");
132 return -RT_ERROR;
133 }
134 else
135 {
136 /* Register the system indicator task */
137 rt_thread_t sys_led_task = rt_thread_create("sys_led_task",
138 sys_run_dir, RT_NULL,
139 THREAD_STACK_SIZE,
140 THREAD_PRIORITY, THREAD_TIMESLICE);
141 if (sys_led_task != RT_NULL)
142 rt_thread_startup(sys_led_task);
143 rt_kprintf("The sys run task is registered.\n");
144 }
145 }
146 else if(rt_strcmp(argv[1],"end") == 0)
147 {
148 rt_event_send(&task_event,TASK_KILL_FLAG);
149 rt_mutex_release(task_mutex);
150 rt_kprintf("The sys run task has been deleted.\n");
151 }
152 }
153 else
154 {
155 rt_kprintf("Necessary parameters are missing.\n");
156 rt_kprintf("You can use the following commands.\n");
157 rt_kprintf("%s start\n",__func__);
158 rt_kprintf("%s end\n",__func__);
159 return -1;
160 }
161 return -1;
162 }
163 MSH_CMD_EXPORT(sys_run_task, sys run task operation);
164
165 /* Gpio output test */
gpio_output_test(void * parameter)166 static void gpio_output_test(void *parameter)
167 {
168 rt_uint32_t e;
169 rt_pin_mode(TEST_OUTPUT_PIN, PIN_MODE_OUTPUT);
170 while(1)
171 {
172 if(rt_event_recv(&task_event,TASK_KILL_FLAG,
173 RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
174 RT_WAITING_NO, &e) == RT_EOK)
175 {
176 rt_thread_t tid = rt_thread_self();
177 rt_thread_delete(tid);
178 }
179 rt_pin_write(TEST_OUTPUT_PIN, PIN_LOW);
180 rt_thread_mdelay(500);
181 rt_pin_write(TEST_OUTPUT_PIN, PIN_HIGH);
182 rt_thread_mdelay(500);
183 }
184 }
185
gpio_output_task(int argc,char * argv[])186 static int gpio_output_task(int argc, char *argv[])
187 {
188 if(argc == 2)
189 {
190 if(rt_strcmp(argv[1],"start") == 0)
191 {
192 if(rt_mutex_take(task_mutex, RT_WAITING_NO) != RT_EOK)
193 {
194 rt_kprintf("The test thread is occupied.\n");
195 return -RT_ERROR;
196 }
197 else
198 {
199 /* Gpio output test tasks */
200 rt_thread_t gpio_output_task = rt_thread_create("gpio_output_task",
201 gpio_output_test, RT_NULL,
202 THREAD_STACK_SIZE,
203 THREAD_PRIORITY, THREAD_TIMESLICE);
204 if (gpio_output_task != RT_NULL)
205 rt_thread_startup(gpio_output_task);
206 rt_kprintf("The gpio output task is registered.\n");
207 }
208 }
209 else if(rt_strcmp(argv[1],"end") == 0)
210 {
211 rt_event_send(&task_event,TASK_KILL_FLAG);
212 rt_mutex_release(task_mutex);
213 rt_kprintf("The gpio output task has been deleted.\n");
214 }
215 }
216 else
217 {
218 rt_kprintf("Necessary parameters are missing.\n");
219 rt_kprintf("You can use the following commands.\n");
220 rt_kprintf("%s start\n",__func__);
221 rt_kprintf("%s end\n",__func__);
222 return -1;
223 }
224 return -1;
225 }
226 MSH_CMD_EXPORT(gpio_output_task, gpio output task operation);
227 /* Gpio input test */
key_iqr_handle(void * args)228 static void key_iqr_handle(void *args)
229 {
230 /* gpio iqr fun */
231 rt_event_send(&led_event,TEST_GPIO_INT_ENV);
232 }
233
gpio_input_test(void * parameter)234 static void gpio_input_test(void *parameter)
235 {
236 uint8_t led_flag = PIN_LOW;
237 rt_uint32_t e;
238
239 rt_pin_mode(TEST_RES_PIN, PIN_MODE_OUTPUT);
240 rt_pin_write(TEST_RES_PIN, PIN_LOW);
241
242 rt_pin_mode(TEST_WAKEUP_PIN,PIN_MODE_INPUT_PULLDOWN);
243 rt_pin_mode(TEST_INPUT_PIN,PIN_MODE_INPUT_PULLUP);
244
245 rt_pin_attach_irq(TEST_INT_PIN,PIN_IRQ_MODE_FALLING,key_iqr_handle,RT_NULL);
246 rt_pin_irq_enable(TEST_INT_PIN,PIN_IRQ_ENABLE);
247
248 if(rt_event_init(&led_event,"led_event",RT_IPC_FLAG_FIFO) != RT_EOK)
249 {
250 rt_kprintf("rt_mutex_create error.\n");
251 }
252 while(1)
253 {
254 if(PIN_LOW == rt_pin_read(TEST_INPUT_PIN))
255 {
256 while(PIN_LOW == rt_pin_read(TEST_INPUT_PIN));
257 rt_event_send(&led_event,TEST_GPIO_KEY_ENV);
258 }
259 if(rt_event_recv(&led_event,(TEST_GPIO_INT_ENV|TEST_GPIO_KEY_ENV),
260 RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
261 RT_WAITING_NO, &e) == RT_EOK)
262 {
263 led_flag = (led_flag == PIN_LOW)?PIN_HIGH:PIN_LOW;
264 rt_pin_write(TEST_RES_PIN, led_flag);
265 }
266 if(rt_event_recv(&task_event,TASK_KILL_FLAG,
267 RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
268 RT_WAITING_NO, &e) == RT_EOK)
269 {
270 rt_thread_t tid = rt_thread_self();
271 rt_thread_delete(tid);
272 }
273 }
274 }
275
gpio_input_task(int argc,char * argv[])276 static int gpio_input_task(int argc, char *argv[])
277 {
278 if(argc == 2)
279 {
280 if(rt_strcmp(argv[1],"start") == 0)
281 {
282 if(rt_mutex_take(task_mutex, RT_WAITING_NO) != RT_EOK)
283 {
284 rt_kprintf("The test thread is occupied.\n");
285 return -RT_ERROR;
286 }
287 /* Gpio input test tasks */
288 rt_thread_t gpio_input_task = rt_thread_create("gpio_input_task",
289 gpio_input_test, RT_NULL,
290 THREAD_STACK_SIZE,
291 THREAD_PRIORITY, THREAD_TIMESLICE);
292 if (gpio_input_task != RT_NULL)
293 rt_thread_startup(gpio_input_task);
294 rt_kprintf("The gpio input task is registered.\n");
295 }
296 else if(rt_strcmp(argv[1],"end") == 0)
297 {
298 rt_event_send(&task_event,TASK_KILL_FLAG);
299 rt_mutex_release(task_mutex);
300 rt_kprintf("The gpio input task has been deleted.\n");
301 }
302 }
303 else
304 {
305 rt_kprintf("Necessary parameters are missing.\n");
306 rt_kprintf("You can use the following commands.\n");
307 rt_kprintf("%s start\n",__func__);
308 rt_kprintf("%s end\n",__func__);
309 return -1;
310 }
311 return -1;
312 }
313 MSH_CMD_EXPORT(gpio_input_task, gpio input task operation);
314 #endif
315 /* uart test */
316 #ifdef BSP_USING_UART
uart_iqr_handle(rt_device_t dev,rt_size_t size)317 static rt_err_t uart_iqr_handle(rt_device_t dev, rt_size_t size)
318 {
319 /* Serial port callback function */
320 rt_sem_release(&rx_sem);
321 return RT_EOK;
322 }
323
uart_thread(void * parameter)324 static void uart_thread(void *parameter)
325 {
326 char ch;
327 while (1)
328 {
329 /* Serial port readout */
330 while (rt_device_read(serial, -1, &ch, 1) != 1)
331 {
332 /* semaphore blocking */
333 rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
334 }
335 /* Output the data obtained from the serial port */
336 rt_device_write(serial, 0, &ch, 1);
337 rt_device_write(serial,0,"\n",1);
338 }
339 }
340
uart_task(int argc,char * argv[])341 static int uart_task(int argc, char *argv[])
342 {
343 rt_err_t ret = RT_EOK;
344
345 char uart_name[RT_NAME_MAX] = "uart1";
346 char str[] = "hello RT-Thread!\r\n";
347 if (argc == 3)
348 {
349 if(rt_strcmp(argv[2],"start") == 0)
350 {
351 rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
352 }
353 else
354 {
355 rt_kprintf("Necessary parameters are missing.\n");
356 rt_kprintf("You can use the following commands.\n");
357 rt_kprintf("%s <uart name> start\n",__func__);
358 rt_kprintf("%s <uart name> end\n",__func__);
359 return -1;
360 }
361 }
362 else if(argc == 2)
363 {
364 if(rt_strcmp(argv[1],"start") == 0)
365 {
366 }
367 else
368 {
369 rt_kprintf("Necessary parameters are missing.\n");
370 rt_kprintf("You can use the following commands.\n");
371 rt_kprintf("%s start\n",__func__);
372 rt_kprintf("%s end\n",__func__);
373 return -1;
374 }
375 }
376 else
377 {
378 rt_kprintf("Incomplete instruction.\n");
379 rt_kprintf("You can use the following commands.\n");
380 rt_kprintf("%s <uart name> start/end\n",__func__);
381 rt_kprintf("or\n");
382 rt_kprintf("%s start/end\n",__func__);
383 return -1;
384 }
385 /* Find Serial Devices */
386 serial = rt_device_find(uart_name);
387 if (!serial)
388 {
389 rt_kprintf("find %s failed!\n", uart_name);
390 return -RT_ERROR;
391 }
392 /* Initializing a Signal */
393 rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
394 /* Open the serial device with read/write and interrupt reception. */
395 rt_device_open(serial, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
396 /* Setting the receive callback function */
397 rt_device_set_rx_indicate(serial, uart_iqr_handle);
398 /* Send String */
399 rt_device_write(serial, 0, str, (sizeof(str) - 1));
400 /* Creating a serial thread */
401 rt_thread_t thread = rt_thread_create("serial",
402 uart_thread, RT_NULL,
403 THREAD_STACK_SIZE,
404 THREAD_PRIORITY, THREAD_TIMESLICE);
405 if (thread != RT_NULL)
406 rt_thread_startup(thread);
407
408 return ret;
409 }
410 MSH_CMD_EXPORT(uart_task, uart device sample);
411 #endif
412 /* hw/sw iic test */
413 #ifdef BSP_USING_I2C
i2c_thread(void * parameter)414 static void i2c_thread(void *parameter)
415 {
416 uint8_t write_addr = 0x00;
417 eeprom_write_type eeprom_date;
418 char send_dat[] = "i2c write eeprom";
419 char read_dat[20] = {0};
420 struct rt_i2c_msg msg1[2];
421
422 eeprom_date.in_data.write_addr = write_addr;
423 rt_strncpy(eeprom_date.in_data.write_date, send_dat, rt_strlen(send_dat));
424
425 msg1[0].addr = 0x51;
426 msg1[0].flags = RT_I2C_WR;
427 msg1[0].buf = eeprom_date.data;
428 msg1[0].len = (rt_strlen(send_dat) + 1);
429 if (rt_i2c_transfer(i2c_dev, msg1, 1) == 1)
430 {
431 rt_kprintf("eeprom write succeed!\n");
432 rt_kprintf("write_dat = %s\r\n",send_dat);
433 }
434 else
435 {
436 rt_kprintf("eeprom write error!\n");
437 }
438 msg1[0].addr = 0x51;
439 msg1[0].flags = RT_I2C_WR;
440 msg1[0].buf = &write_addr;
441 msg1[0].len = 1;
442
443 msg1[1].addr = 0x51;
444 msg1[1].flags = RT_I2C_RD;
445 msg1[1].buf = (uint8_t *)read_dat;
446 msg1[1].len = rt_strlen(send_dat);
447
448 if (rt_i2c_transfer(i2c_dev, msg1, 2) == 2)
449 {
450 rt_kprintf("eeprom read succeed!\n");
451 rt_kprintf("read_dat = %s\r\n",read_dat);
452 }
453 else
454 {
455 rt_kprintf("eeprom read error!\n");
456 }
457 }
458
i2c_task(int argc,char * argv[])459 static int i2c_task(int argc, char *argv[])
460 {
461 rt_err_t ret = RT_EOK;
462
463 char i2c_name[RT_NAME_MAX] = "hw_i2c1";
464 if (argc == 3)
465 {
466 if(rt_strcmp(argv[2],"start") == 0)
467 {
468 rt_strncpy(i2c_name, argv[1], RT_NAME_MAX);
469 }
470 else
471 {
472 rt_kprintf("Necessary parameters are missing.\n");
473 rt_kprintf("You can use the following commands.\n");
474 rt_kprintf("%s <i2c name> start\n",__func__);
475 rt_kprintf("%s <i2c name> end\n",__func__);
476 return -1;
477 }
478 }
479 else if(argc == 2)
480 {
481 if(rt_strcmp(argv[1],"start") == 0)
482 {
483 }
484 else
485 {
486 rt_kprintf("Necessary parameters are missing.\n");
487 rt_kprintf("You can use the following commands.\n");
488 rt_kprintf("%s start\n",__func__);
489 rt_kprintf("%s end\n",__func__);
490 return -1;
491 }
492 }
493 else
494 {
495 rt_kprintf("Incomplete instruction.\n");
496 rt_kprintf("You can use the following commands.\n");
497 rt_kprintf("%s <i2c name> start/end\n",__func__);
498 rt_kprintf("or\n");
499 rt_kprintf("%s start/end\n",__func__);
500 return -1;
501 }
502 /* Find I2C Devices */
503 i2c_dev = (struct rt_i2c_bus_device *)rt_device_find(i2c_name);
504 if (!i2c_dev)
505 {
506 rt_kprintf("find %s failed!\n", i2c_name);
507 return -RT_ERROR;
508 }
509 /* Execute I2C read/write eeprom function */
510 i2c_thread(RT_NULL);
511 return ret;
512 }
513 MSH_CMD_EXPORT(i2c_task, i2c device sample);
514 #endif
515 /* spi test */
516 #ifdef BSP_USING_SPI
spi_thread(void * parameter)517 static void spi_thread(void *parameter)
518 {
519 rt_uint8_t w25x_read_id = 0x9F;
520 rt_uint8_t id[5] = {0};
521
522 /* Use rt_spi_send_then_recv() to send commands to read IDs */
523 rt_spi_take_bus(spi_dev);
524 rt_spi_take(spi_dev);
525 rt_spi_send_then_recv(spi_dev, &w25x_read_id, 1, id, 3);
526 rt_spi_release(spi_dev);
527 rt_spi_release_bus(spi_dev);
528 rt_kprintf("use rt_spi_send_then_recv() read MX25L6406 ID is:0x%X%X%X\n", id[0], id[1], id[2]);
529 }
530
spi_task(int argc,char * argv[])531 static int spi_task(int argc, char *argv[])
532 {
533 rt_err_t ret = RT_EOK;
534 struct rt_spi_configuration cfg;
535 char spi_name[RT_NAME_MAX] = "spi1";
536 char flash_name[RT_NAME_MAX] = "flash";
537
538 if (argc == 3)
539 {
540 if(rt_strcmp(argv[2],"start") == 0)
541 {
542 rt_strncpy(spi_name, argv[1], RT_NAME_MAX);
543 }
544 else
545 {
546 rt_kprintf("Necessary parameters are missing.\n");
547 rt_kprintf("You can use the following commands.\n");
548 rt_kprintf("%s <spi name> start\n",__func__);
549 rt_kprintf("%s <spi name> end\n",__func__);
550 return -1;
551 }
552 }
553 else if(argc == 2)
554 {
555 if(rt_strcmp(argv[1],"start") == 0)
556 {
557 }
558 else
559 {
560 rt_kprintf("Necessary parameters are missing.\n");
561 rt_kprintf("You can use the following commands.\n");
562 rt_kprintf("%s start\n",__func__);
563 rt_kprintf("%s end\n",__func__);
564 return -1;
565 }
566 }
567 else
568 {
569 rt_kprintf("Incomplete instruction.\n");
570 rt_kprintf("You can use the following commands.\n");
571 rt_kprintf("%s <spi name> start/end\n",__func__);
572 rt_kprintf("or\n");
573 rt_kprintf("%s start/end\n",__func__);
574 return -1;
575 }
576 /* Binding CS pin */
577 ret = rt_hw_spi_device_attach(spi_name,flash_name,HT_GPIOD,GPIO_PIN_0);
578 if(ret != RT_EOK)
579 {
580 rt_kprintf("Failed CS pin binding for %s!\n", spi_name);
581 return -RT_ERROR;
582 }
583 /* Find flash devices */
584 spi_dev = (struct rt_spi_device*)rt_device_find(flash_name);
585 if (!spi_dev)
586 {
587 rt_kprintf("find %s failed!\n", spi_name);
588 return -RT_ERROR;
589 }
590 /* Configuring the SPI Bus */
591 cfg.data_width = 8;
592 cfg.mode = RT_SPI_MASTER | RT_SPI_MODE_3 | RT_SPI_MSB;
593 cfg.max_hz = 8;
594 rt_spi_configure(spi_dev,&cfg);
595 rt_kprintf("SPI0 initialization succeeded!\n");
596
597 /* Execute flash read and write functions */
598 spi_thread(RT_NULL);
599 rt_device_unregister((rt_device_t)spi_dev);
600 return ret;
601 }
602 MSH_CMD_EXPORT(spi_task, spi device sample);
603 #endif
604 /* adc test */
605 #ifdef BSP_USING_ADC
adc_test(void * parameter)606 static void adc_test(void *parameter)
607 {
608 rt_uint32_t adc0_ch6_val,adc0_ch7_val;
609 rt_adc_device_t adc_dev = (rt_adc_device_t)rt_device_find("adc0");
610 if (!adc_dev)
611 {
612 rt_kprintf("No ADC0 device found!\n");
613 }
614 else
615 {
616 rt_adc_enable(adc_dev,ADC_CH_6);
617 rt_adc_enable(adc_dev,ADC_CH_7);
618 }
619 while(1)
620 {
621 adc0_ch6_val = rt_adc_read(adc_dev,6);
622 adc0_ch7_val = rt_adc_read(adc_dev,7);
623 rt_kprintf("adc0_ch6_val = %d\n",adc0_ch6_val);
624 rt_kprintf("adc0_ch7_val = %d\n",adc0_ch7_val);
625 rt_thread_mdelay(50);
626 }
627 }
628
adc_task(int argc,char * argv[])629 static int adc_task(int argc, char *argv[])
630 {
631 if(argc == 2)
632 {
633 if(rt_strcmp(argv[1],"start") == 0)
634 {
635 /* Adc test tasks */
636 rt_thread_t adc_task = rt_thread_create("adc_task",
637 adc_test, RT_NULL,
638 THREAD_STACK_SIZE,
639 THREAD_PRIORITY, THREAD_TIMESLICE);
640 if (adc_task != RT_NULL)
641 rt_thread_startup(adc_task);
642 rt_kprintf("The adc task is registered.\n");
643 }
644 else if(rt_strcmp(argv[1],"end") == 0)
645 {
646 rt_event_send(&task_event,TASK_KILL_FLAG);
647 rt_kprintf("The adc task has been deleted.\n");
648 }
649 }
650 else
651 {
652 rt_kprintf("Necessary parameters are missing.\n");
653 rt_kprintf("You can use the following commands.\n");
654 rt_kprintf("%s start\n",__func__);
655 rt_kprintf("%s end\n",__func__);
656 return -1;
657 }
658 return -1;
659 }
660 MSH_CMD_EXPORT(adc_task, adc task operation);
661 #endif
662 /* wdt test */
663 #ifdef BSP_USING_WDT
wdt_test(void)664 static void wdt_test(void)
665 {
666 rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, RT_NULL);
667 }
668
wdt_task(int argc,char * argv[])669 static int wdt_task(int argc, char *argv[])
670 {
671 rt_err_t ret = -RT_ERROR;
672 rt_uint16_t wdt_time = 5;
673 char dev_name[] = "wdt";
674 if(argc == 2)
675 {
676 if(rt_strcmp(argv[1],"start") == 0)
677 {
678 /* Find wdt devices */
679 wdt_dev = rt_device_find(dev_name);
680 if(wdt_dev == RT_NULL)
681 {
682 rt_kprintf("No corresponding equipment found.\n");
683 return -1;
684 }
685 /* Configuring the Watchdog */
686 ret = rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &wdt_time);
687 if(ret != RT_EOK)
688 {
689 rt_kprintf("wdt configuration failed.\n");
690 return -1;
691 }
692 /* Start the Watchdog */
693 ret = rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_START, RT_NULL);
694 if(ret != RT_EOK)
695 {
696 rt_kprintf("wdt start failed.\n");
697 return -1;
698 }
699 /* Setting up idle threads */
700 rt_thread_idle_sethook(wdt_test);
701 rt_kprintf("Watchdog started successfully.\n");
702 }
703 else if(rt_strcmp(argv[1],"stop") == 0)
704 {
705 /* Verify device handle */
706 if(wdt_dev == RT_NULL)
707 {
708 rt_kprintf("Device handle does not exist.\n");
709 return -1;
710 }
711 /* Stop the Watchdog */
712 ret = rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_STOP, RT_NULL);
713 if(ret != RT_EOK)
714 {
715 rt_kprintf("wdt start failed.\n");
716 return -1;
717 }
718 /* Hook function to delete idle threads */
719 rt_thread_idle_delhook(wdt_test);
720 rt_kprintf("Watchdog has stopped.\n");
721 }
722 }
723 else
724 {
725 rt_kprintf("Necessary parameters are missing.\n");
726 rt_kprintf("You can use the following commands.\n");
727 rt_kprintf("%s start\n",__func__);
728 rt_kprintf("%s stop\n",__func__);
729 return -1;
730 }
731 return -1;
732 }
733 MSH_CMD_EXPORT(wdt_task, wdt task operation);
734 #endif
735 /* usbd test */
736 #ifdef BSP_USING_USBD
usbd_test(void * parameter)737 static void usbd_test(void *parameter)
738 {
739 rt_device_t dev = RT_NULL;
740 char dev_name[] = "vcom";
741 char buf[] = "usbd vcom test!\r\n";
742
743 dev = rt_device_find(dev_name);
744
745 if (dev)
746 {
747 rt_device_open(dev, RT_DEVICE_FLAG_RDWR);
748 }
749 else
750 {
751 rt_kprintf("Device with name %s not found.\n",dev_name);
752 rt_thread_t tid = rt_thread_self();
753 rt_thread_delete(tid);
754 }
755 while (1)
756 {
757 rt_device_write(dev, 0, buf, rt_strlen(buf));
758 rt_thread_mdelay(500);
759 }
760 }
761
usbd_task(int argc,char * argv[])762 static int usbd_task(int argc, char *argv[])
763 {
764 rt_err_t ret = -RT_ERROR;
765
766 if(argc == 2)
767 {
768 if(rt_strcmp(argv[1],"start") == 0)
769 {
770 /* Gpio input test tasks */
771 rt_thread_t usbd_vcom_task = rt_thread_create("usbd_vcom_task",
772 usbd_test, RT_NULL,
773 THREAD_STACK_SIZE,
774 THREAD_PRIORITY, THREAD_TIMESLICE);
775 if (usbd_vcom_task != RT_NULL)
776 {
777 rt_thread_startup(usbd_vcom_task);
778 rt_kprintf("The usbd vcom task is registered.\n");
779 }
780 else
781 {
782 rt_kprintf("usbd vcom task registration failed.\n");
783 }
784 ret = RT_EOK;
785 }
786 else if(rt_strcmp(argv[1],"stop") == 0)
787 {
788 ret = RT_EOK;
789 }
790 }
791 else
792 {
793 rt_kprintf("Necessary parameters are missing.\n");
794 rt_kprintf("You can use the following commands.\n");
795 rt_kprintf("%s start\n",__func__);
796 rt_kprintf("%s stop\n",__func__);
797 }
798 return ret;
799 }
800 MSH_CMD_EXPORT(usbd_task, usbd task operation);
801
802
803 #endif
804 #endif /* BSP_USING_TEST */
805