1 /*
2 * File : test_driver.h
3 * Copyright (c) 2006-2021, RT-Thread Development Team
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Change Logs:
8 * Date Author Notes
9 * 2019-07-29 zdzn first version
10 */
11
12 #include <rtthread.h>
13 #include <rtdevice.h>
14 #include <rthw.h>
15 #include <string.h>
16 #include <drivers/hwtimer.h>
17 #include <raspi.h>
18 #include <sys/time.h>
19
20 #ifdef BSP_USING_HDMI
21 #include "drv_fb.h"
22 #endif
23
test_hdmi()24 void test_hdmi()
25 {
26 rt_kprintf("Hello Test hdmi!\n");
27 #ifdef BSP_USING_HDMI
28 print_fb_info();
29 #ifdef BSP_USING_HDMI_DISPLAY
30 rt_kprintf("hdmi is tested!\n");
31 #else
32 rt_console_set_device("hdmi");
33 rt_kprintf("hdmi is testing!\n");
34 #endif
35 rt_kprintf("search hdmi device");
36 rt_device_t hdmi = rt_device_find("hdmi");
37 if (hdmi == RT_NULL)
38 {
39 rt_kprintf("cannot find hdmi device");
40 }
41 int color = COLOR_YELLOW;
42 rt_kprintf("begin test hdmi deivice");
43 rt_graphix_ops(hdmi) -> set_pixel((char *)&color, 5, 5);
44
45 rt_graphix_ops(hdmi) -> get_pixel((char *)&color, 5, 5);
46 rt_kprintf("color is %x\n",color);
47 rt_graphix_ops(hdmi) -> draw_hline((char *)&color, 10, 100, 10);
48 color = COLOR_GREEN;
49 rt_graphix_ops(hdmi) -> draw_vline((char *)&color, 10, 10, 100);
50 int colors[100];
51 int i=0;
52 for (; i < 20; i++) colors[i] = COLOR_RED;
53 rt_graphix_ops(hdmi) -> blit_line((char *)colors, 20, 20, 20);
54
55 #endif
56 }
57
58 #ifdef RT_USING_SMP
59 #define _CPUS_NR RT_CPUS_NR
60 #else
61 #define _CPUS_NR 1
62 #endif
63
64 #ifdef RT_USING_SMP
65 static rt_uint8_t rt_thread_stack[_CPUS_NR][128];
66 static struct rt_thread smp[_CPUS_NR];
smp_test_entry()67 void smp_test_entry()
68 {
69 rt_kprintf("cpu %d is running.\n",rt_hw_cpu_id());
70 }
71 #endif
72
test_cpusmp(void)73 void test_cpusmp(void)
74 {
75 rt_kprintf("Hello Test SMP!\n");
76 #ifdef RT_USING_SMP
77 int i;
78 char test_name[RT_NAME_MAX];
79 for (i = 0; i < _CPUS_NR; i++)
80 {
81 rt_sprintf(test_name, "smp%d", i);
82 rt_thread_init(&smp[i],
83 test_name,
84 smp_test_entry,
85 RT_NULL,
86 &rt_thread_stack[i][0],
87 sizeof(rt_thread_stack[i]),
88 RT_THREAD_PRIORITY_MAX - 2,
89 32);
90 rt_thread_control(&smp[i], RT_THREAD_CTRL_BIND_CPU, (void*)i);
91 /* startup */
92 rt_thread_startup(&smp[i]);
93 rt_thread_delay(RT_TICK_PER_SECOND);
94 }
95 #endif
96 }
97
98 #ifdef BSP_USING_PIN
99 #define TEST_PIN_OUT 33
100 #define TEST_PIN_IN 37
101
gpio_rising_test()102 void gpio_rising_test()
103 {
104 rt_kprintf("gpio rising irq function ok!\n");
105 }
106 #endif
107
test_gpio(void)108 void test_gpio(void)
109 {
110 #ifdef BSP_USING_PIN
111 rt_uint32_t ret;
112 rt_kprintf("Hello Test GPIO!\n");
113
114 rt_pin_mode(TEST_PIN_OUT, PIN_MODE_OUTPUT);
115 rt_pin_write(TEST_PIN_OUT, PIN_HIGH);
116 rt_pin_mode(TEST_PIN_IN, PIN_MODE_INPUT);
117
118 ret = rt_pin_read(TEST_PIN_IN);
119 rt_kprintf("common high input test read result: %d\n",ret);
120
121 rt_pin_write(TEST_PIN_OUT, PIN_LOW);
122 ret = rt_pin_read(TEST_PIN_IN);
123 rt_kprintf("common low input test read result: %d\n",ret);
124
125 rt_pin_mode(TEST_PIN_IN, PIN_MODE_INPUT_PULLDOWN);
126 rt_pin_attach_irq(TEST_PIN_IN, PIN_IRQ_MODE_RISING, gpio_rising_test, RT_NULL);
127 rt_pin_irq_enable(TEST_PIN_IN, PIN_IRQ_ENABLE);
128 rt_pin_write(TEST_PIN_OUT, PIN_HIGH);
129
130 rt_pin_irq_enable(TEST_PIN_IN, PIN_IRQ_DISABLE);
131 #endif
132 }
133
134 #ifdef BSP_USING_I2C1
135 #define DS3231_I2C_BUS_NAME "i2c1"
136 #define DS3231_ADDR 0x68
137 struct rt_i2c_bus_device *i2c_bus = RT_NULL;
read_regs(struct rt_i2c_bus_device * bus,rt_uint8_t len,rt_uint8_t * buf)138 static rt_err_t read_regs(struct rt_i2c_bus_device *bus, rt_uint8_t len, rt_uint8_t *buf)
139 {
140 struct rt_i2c_msg msgs;
141 msgs.addr = DS3231_ADDR;
142 msgs.flags = RT_I2C_RD;
143 msgs.buf = buf;
144 msgs.len = len;
145
146 if (rt_i2c_transfer(bus, &msgs, 1) == 1)
147 return RT_EOK;
148 else
149 return -RT_ERROR;
150 }
151 #endif
152
test_i2c(void)153 void test_i2c(void)
154 {
155 #ifdef BSP_USING_I2C1
156 rt_kprintf("Hello Test I2C!\n");
157 char name[RT_NAME_MAX];
158 rt_uint8_t buf[]={0x00,0x00,0x43,0x15,0x05,0x01,0x03,0x19};
159
160 rt_strncpy(name, DS3231_I2C_BUS_NAME, RT_NAME_MAX);
161 i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(name);
162 if (i2c_bus == RT_NULL)
163 rt_kprintf("can't find %s device!\n", name);
164 else
165 {
166 read_regs(i2c_bus, 7, buf);
167 buf[0] = buf[0]&0x7F; //sec
168 buf[1] = buf[1]&0x7F; //min
169 buf[2] = buf[2]&0x3F; //hour
170 buf[3] = buf[3]&0x07; //week
171 buf[4] = buf[4]&0x3F; //day
172 buf[5] = buf[5]&0x1F; //mouth
173 //year/month/day
174 rt_kprintf("20%02x-%02x-%02x ",buf[6],buf[5],buf[4]);
175 //hour:minute/second
176 rt_kprintf("%02x:%02x:%02x \n",buf[2],buf[1],buf[0]);
177 }
178 #endif
179 }
180
181 #define W25Q_SPI_DEVICE_NAME "spi0.0"
test_spi(void)182 void test_spi(void)
183 {
184 #ifdef BSP_USING_SPI
185 rt_kprintf("Hello Test SPI!\n");
186 struct rt_spi_device *spi0_dev0;
187 struct rt_spi_device *spi0_dev1;
188
189 char name0[RT_NAME_MAX];
190 char name1[RT_NAME_MAX];
191
192 rt_uint8_t w25x_read_id = 0x90;
193 rt_uint8_t id[5] = {0};
194
195 rt_strncpy(name0, "spi0.0", RT_NAME_MAX);
196 rt_strncpy(name1, "spi0.1", RT_NAME_MAX);
197
198 spi0_dev0 = (struct rt_spi_device *)rt_device_find(name0);
199 spi0_dev1 = (struct rt_spi_device *)rt_device_find(name1);
200
201
202 if (!spi0_dev0 || !spi0_dev1)
203 {
204 rt_kprintf("spi sample run failed! can't find %s device!\n", name0);
205 }
206 else
207 {
208 struct rt_spi_message msg1, msg2;
209
210 msg1.send_buf = &w25x_read_id;
211 msg1.recv_buf = RT_NULL;
212 msg1.length = 1;
213 msg1.cs_take = 1;
214 msg1.cs_release = 0;
215 msg1.next = &msg2;
216
217 msg2.send_buf = RT_NULL;
218 msg2.recv_buf = id;
219 msg2.length = 5;
220 msg2.cs_take = 0;
221 msg2.cs_release = 1;
222 msg2.next = RT_NULL;
223
224 rt_spi_transfer_message(spi0_dev0, &msg1);
225 rt_kprintf("use rt_spi_transfer_message() read w25q ID is:%x%x\n", id[3], id[4]);
226
227 }
228 #endif
229 }
230
231 #ifdef BSP_USING_SYSTIMER
232 #define TIMER "timer1"
233
timer_timeout_cb(rt_device_t dev,rt_size_t size)234 static rt_err_t timer_timeout_cb(rt_device_t dev, rt_size_t size)
235 {
236 rt_kprintf("enter hardware timer isr\n");
237 return 0;
238 }
239 #endif
test_hwtimer(void)240 rt_err_t test_hwtimer(void)
241 {
242 #ifdef BSP_USING_SYSTIMER
243 rt_kprintf("Hello Test HW Timer!\n");
244 rt_err_t err;
245 rt_hwtimerval_t val;
246 rt_device_t dev = RT_NULL;
247 rt_tick_t tick;
248 rt_hwtimer_mode_t mode;
249 int t = 5;
250
251 if ((dev = rt_device_find(TIMER)) == RT_NULL)
252 {
253 rt_kprintf("No Device: %s\n", TIMER);
254 return -1;
255 }
256
257 if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
258 {
259 rt_kprintf("Open %s Fail\n", TIMER);
260 return -1;
261 }
262
263 mode = HWTIMER_MODE_PERIOD;
264 err = rt_device_control(dev, HWTIMER_CTRL_MODE_SET, &mode);
265
266 tick = rt_tick_get();
267 rt_kprintf("Start Timer> Tick: %d\n", tick);
268
269 val.sec = t;
270 val.usec = 0;
271 rt_kprintf("SetTime: Sec %d, Usec %d\n", val.sec, val.usec);
272 if (rt_device_write(dev, 0, &val, sizeof(val)) != sizeof(val))
273 {
274 rt_kprintf("SetTime Fail\n");
275 goto EXIT;
276 }
277 rt_kprintf("Sleep %d sec\n", t);
278 rt_thread_delay(t*RT_TICK_PER_SECOND);
279
280 err = rt_device_control(dev, HWTIMER_CTRL_STOP, RT_NULL);
281 rt_kprintf("Timer Stoped\n");
282
283 rt_device_read(dev, 0, &val, sizeof(val));
284 rt_kprintf("Read: Sec = %d, Usec = %d\n", val.sec, val.usec);
285
286 rt_device_set_rx_indicate(dev, timer_timeout_cb);
287
288 mode = HWTIMER_MODE_PERIOD;
289 err = rt_device_control(dev, HWTIMER_CTRL_MODE_SET, &mode);
290
291 val.sec = t;
292 val.usec = 0;
293 rt_kprintf("SetTime: Sec %d, Usec %d\n", val.sec, val.usec);
294 if (rt_device_write(dev, 0, &val, sizeof(val)) != sizeof(val))
295 {
296 rt_kprintf("SetTime Fail\n");
297 goto EXIT;
298 }
299
300 rt_thread_delay((t *5 + 1)*RT_TICK_PER_SECOND);
301
302 EXIT:
303 err = rt_device_close(dev);
304 rt_kprintf("Close %s\n", TIMER);
305
306 return err;
307 #endif
308 }
309
310 #ifdef RT_USING_WDT
311 #define WDT_DEVICE_NAME "wdg" /* the name of the watchdog device */
312 static rt_device_t wdg_dev; /* handle of the watchdog device */
idle_hook(void)313 static void idle_hook(void)
314 {
315 /* Feed the dog in the callback function of the idle thread */
316 rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, NULL);
317 //rt_kprintf("feed the dog!\n ");
318 }
319
test_wdt(void)320 rt_err_t test_wdt(void)
321 {
322 rt_kprintf("Hello Test WDT!\n");
323 rt_err_t ret = RT_EOK;
324 rt_uint32_t timeout = 1; /* the overflow time */
325 char device_name[RT_NAME_MAX];
326 rt_strncpy(device_name, WDT_DEVICE_NAME, RT_NAME_MAX);
327 /* find the watchdog device based on the device's name and obtain the device handle */
328 wdg_dev = rt_device_find(device_name);
329 if (!wdg_dev)
330 {
331 rt_kprintf("find %s failed!\n", device_name);
332 return -RT_ERROR;
333 }
334 /* initialize the device */
335 ret = rt_device_init(wdg_dev);
336 if (ret != RT_EOK)
337 {
338 rt_kprintf("initialize %s failed!\n", device_name);
339 return -RT_ERROR;
340 }
341 /* set the overflow time of the watch dog */
342 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &timeout);
343 if (ret != RT_EOK)
344 {
345 rt_kprintf("set %s timeout failed!\n", device_name);
346 return -RT_ERROR;
347 }
348 /* start the watchdog */
349 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_START, RT_NULL);
350 if (ret != RT_EOK)
351 {
352 rt_kprintf("start %s failed!\n", device_name);
353 return -RT_ERROR;
354 }
355 /* set idle thread callback function */
356 rt_thread_idle_sethook(idle_hook);
357
358 return ret;
359
360 }
361 #else
test_wdt(void)362 rt_err_t test_wdt(void)
363 {
364 return RT_EOK;
365 }
366 #endif
367
test_rtc(void)368 int test_rtc(void)
369 {
370 #ifdef BSP_USING_RTC
371 rt_kprintf("Hello Test RTC!\n");
372 rt_uint8_t i;
373 time_t now;
374
375 rt_err_t ret = RT_EOK;
376
377 rt_kprintf("[RTC Test]RTC Test Start...\n");
378 rt_thread_delay(RT_TICK_PER_SECOND);
379 rt_kprintf("[RTC Test]Set RTC 2017-04-01 12:30:46\n\n");
380 rt_thread_delay(RT_TICK_PER_SECOND);
381
382 ret = set_date(2017, 4, 1);
383 if (ret != RT_EOK)
384 {
385 rt_kprintf("[RTC Test]Set RTC Date failed\n");
386 return -RT_ERROR;
387 }
388
389 rt_thread_delay(RT_TICK_PER_SECOND);
390
391 ret = set_time(12, 30, 46);
392 if (ret != RT_EOK)
393 {
394 rt_kprintf("[RTC Test]Set RTC Time failed\n");
395 return -RT_ERROR;
396 }
397
398 rt_thread_delay(RT_TICK_PER_SECOND);
399
400 for (i = 0; i < 10; i++)
401 {
402 rt_kprintf("[RTC Test]Read RTC Date and Time: ");
403 now = time(RT_NULL);
404 rt_kprintf("%s", ctime(&now));
405
406 rt_thread_delay(RT_TICK_PER_SECOND);
407 }
408
409 rt_kprintf("\n");
410 #endif
411 return RT_EOK;
412 }
413
test_device(int argc,char ** argv)414 void test_device(int argc, char**argv)
415 {
416 if (0 == strcmp(argv[1],"smp"))
417 {
418 test_cpusmp();
419 return;
420 }
421 if (0 == strcmp(argv[1],"gpio"))
422 {
423 test_gpio();
424 return;
425 }
426
427 if (0 == strcmp(argv[1],"i2c"))
428 {
429 test_i2c();
430 return;
431 }
432
433 if (0 == strcmp(argv[1],"spi"))
434 {
435 test_spi();
436 return;
437 }
438
439 if (0 == strcmp(argv[1],"hwtimer"))
440 {
441 test_hwtimer();
442 return;
443 }
444
445 if (0 == strcmp(argv[1],"wdt"))
446 {
447 test_wdt();
448 return;
449 }
450
451 if (0 == strcmp(argv[1],"rtc"))
452 {
453 test_rtc();
454 return;
455 }
456 if (0 == strcmp(argv[1],"hdmi"))
457 {
458 test_hdmi();
459 return;
460 }
461 rt_kprintf("param err, please entry test_device <smp|gpio|i2c|spi|hwtimer|wdt|rtc|hdmi>\n");
462 }
463 MSH_CMD_EXPORT(test_device, sample: test_device <smp|gpio|i2c|spi|hwtimer|wdt|rtc>);
464