1 /*
2 * Copyright (c) 2006-2022, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 */
9
10 #include <rtthread.h>
11 #include <rtdevice.h>
12 #include "board.h"
13
14 #define LED_PIN GET_PIN(B,0)
15
main(void)16 int main(void)
17 {
18 int count = 1;
19
20 rt_pin_mode(LED_PIN, PIN_MODE_OUTPUT);
21
22 while (count++)
23 {
24 rt_pin_write(LED_PIN, PIN_HIGH);
25 rt_thread_mdelay(500);
26 rt_pin_write(LED_PIN, PIN_LOW);
27 rt_thread_mdelay(500);
28 }
29
30 return RT_EOK;
31 }
32
33 #ifdef BSP_USING_GPIO
34 #define KEY1_PIN GET_PIN(A,8)
key1_cb(void * args)35 void key1_cb(void *args)
36 {
37 rt_kprintf("key1 irq!\n");
38 }
pin_sample(int argc,char * argv[])39 static int pin_sample(int argc, char *argv[])
40 {
41 rt_pin_mode(KEY1_PIN, PIN_IRQ_MODE_FALLING);
42 rt_pin_attach_irq(KEY1_PIN, PIN_IRQ_MODE_FALLING, key1_cb, RT_NULL);
43 rt_pin_irq_enable(KEY1_PIN, PIN_IRQ_ENABLE);
44
45 return RT_EOK;
46 }
47 MSH_CMD_EXPORT(pin_sample, pin sample);
48 #endif
49
50 #ifdef BSP_USING_ADC
51 #define ADC_DEV_NAME "adc0"
52 #define ADC_DEV_CHANNEL 0
53 #define REFER_VOLTAGE 330
54 #define CONVERT_BITS (1 << 12)
55
adc_vol_sample(int argc,char * argv[])56 static int adc_vol_sample(int argc, char *argv[])
57 {
58 rt_adc_device_t adc_dev;
59 rt_uint32_t value, vol;
60 rt_err_t ret = RT_EOK;
61
62 adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
63 if (adc_dev == RT_NULL)
64 {
65 rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME);
66 return -RT_ERROR;
67 }
68
69 ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
70 value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
71 rt_kprintf("the value is :%d,", value);
72 vol = value * REFER_VOLTAGE / CONVERT_BITS;
73 rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
74
75 ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);
76
77 return ret;
78 }
79 MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample);
80 #endif
81
82 #ifdef BSP_USING_DAC
83 #include <stdlib.h>
84
85 #define DAC_DEV_NAME "dac" /* DAC 设备名称 */
86 #define DAC_DEV_CHANNEL 0 /* DAC 通道 */
87 #define REFER_VOLTAGE 330 /* 参考电压 3.3V,数据精度乘以100保留2位小数*/
88 #define CONVERT_BITS (1 << 12) /* 转换位数为12位 */
89
dac_vol_sample(int argc,char * argv[])90 static int dac_vol_sample(int argc, char *argv[])
91 {
92 rt_dac_device_t dac_dev;
93 rt_uint32_t value, vol;
94 rt_err_t ret = RT_EOK;
95
96 /* 查找设备 */
97 dac_dev = (rt_dac_device_t)rt_device_find(DAC_DEV_NAME);
98 if (dac_dev == RT_NULL)
99 {
100 rt_kprintf("dac sample run failed! can't find %s device!\n", DAC_DEV_NAME);
101 return -RT_ERROR;
102 }
103
104 /* 打开通道 */
105 ret = rt_dac_enable(dac_dev, DAC_DEV_CHANNEL);
106
107 /* 设置输出值 */
108 value = atoi(argv[1]);
109 rt_dac_write(dac_dev, DAC_DEV_CHANNEL, value);
110 rt_kprintf("the value is :%d \n", value);
111
112 /* 转换为对应电压值 */
113 vol = value * REFER_VOLTAGE / CONVERT_BITS;
114 rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
115 rt_thread_mdelay(500);
116 /* 关闭通道 */
117 ret = rt_dac_disable(dac_dev, DAC_DEV_CHANNEL);
118
119 return ret;
120 }
121 /* 导出到 msh 命令列表中 */
122 MSH_CMD_EXPORT(dac_vol_sample, dac voltage convert sample);
123 #endif
124
125 #ifdef BSP_USING_CAN
126 #define CAN_DEV_NAME "can0" /* CAN 设备名称 */
127
128 static struct rt_semaphore rx_sem; /* 用于接收消息的信号量 */
129 static rt_device_t can_dev; /* CAN 设备句柄 */
130
131 /* 接收数据回调函数 */
can_rx_call(rt_device_t dev,rt_size_t size)132 static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
133 {
134 /* CAN 接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
135 rt_sem_release(&rx_sem);
136
137 return RT_EOK;
138 }
139
can_rx_thread(void * parameter)140 static void can_rx_thread(void *parameter)
141 {
142 int i;
143 rt_err_t res;
144 struct rt_can_msg rxmsg = {0};
145
146 /* 设置接收回调函数 */
147 rt_device_set_rx_indicate(can_dev, can_rx_call);
148
149 #ifdef RT_CAN_USING_HDR
150 struct rt_can_filter_item items[5] =
151 {
152 RT_CAN_FILTER_ITEM_INIT(0x100, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，hdr 为 - 1，设置默认过滤表 */
153 RT_CAN_FILTER_ITEM_INIT(0x300, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x300~0x3ff，hdr 为 - 1 */
154 RT_CAN_FILTER_ITEM_INIT(0x211, 0, 0, 0, 0x7ff, RT_NULL, RT_NULL), /* std,match ID:0x211，hdr 为 - 1 */
155 RT_CAN_FILTER_STD_INIT(0x486, RT_NULL, RT_NULL), /* std,match ID:0x486，hdr 为 - 1 */
156 {0x555, 0, 0, 0, 0x7ff, 7,} /* std,match ID:0x555，hdr 为 7，指定设置 7 号过滤表 */
157 };
158 struct rt_can_filter_config cfg = {5, 1, items}; /* 一共有 5 个过滤表 */
159 /* 设置硬件过滤表 */
160 res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
161 RT_ASSERT(res == RT_EOK);
162 #endif
163
164 while (1)
165 {
166 /* hdr 值为 - 1，表示直接从 uselist 链表读取数据 */
167 v .hdr = -1;
168 /* 阻塞等待接收信号量 */
169 rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
170 /* 从 CAN 读取一帧数据 */
171 rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
172 /* 打印数据 ID 及内容 */
173 rt_kprintf("ID:%x", rxmsg.id);
174 for (i = 0; i < 8; i++)
175 {
176 rt_kprintf("%2x", rxmsg.data[i]);
177 }
178
179 rt_kprintf("\n");
180 }
181 }
182
can_sample(int argc,char * argv[])183 int can_sample(int argc, char *argv[])
184 {
185 struct rt_can_msg msg = {0};
186 rt_err_t res;
187 rt_size_t size;
188 rt_thread_t thread;
189 char can_name[RT_NAME_MAX];
190
191 if (argc == 2)
192 {
193 rt_strncpy(can_name, argv[1], RT_NAME_MAX);
194 }
195 else
196 {
197 rt_strncpy(can_name, CAN_DEV_NAME, RT_NAME_MAX);
198 }
199 /* 查找 CAN 设备 */
200 can_dev = rt_device_find(can_name);
201 if (!can_dev)
202 {
203 rt_kprintf("find %s failed!\n", can_name);
204 return -RT_ERROR;
205 }
206
207 /* 初始化 CAN 接收信号量 */
208 rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
209
210 /* 以中断接收及发送方式打开 CAN 设备 */
211 res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
212 RT_ASSERT(res == RT_EOK);
213 /* 创建数据接收线程 */
214 thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 1024, 25, 10);
215 if (thread != RT_NULL)
216 {
217 rt_thread_startup(thread);
218 }
219 else
220 {
221 rt_kprintf("create can_rx thread failed!\n");
222 }
223
224 msg.id = 0x78; /* ID 为 0x78 */
225 msg.ide = RT_CAN_STDID; /* 标准格式 */
226 msg.rtr = RT_CAN_DTR; /* 数据帧 */
227 msg.len = 8; /* 数据长度为 8 */
228 /* 待发送的 8 字节数据 */
229 msg.data[0] = 0x00;
230 msg.data[1] = 0x11;
231 msg.data[2] = 0x22;
232 msg.data[3] = 0x33;
233 msg.data[4] = 0x44;
234 msg.data[5] = 0x55;
235 msg.data[6] = 0x66;
236 msg.data[7] = 0x77;
237 /* 发送一帧 CAN 数据 */
238 size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
239 if (size == 0)
240 {
241 rt_kprintf("can dev write data failed!\n");
242 }
243
244 return res;
245 }
246 /* 导出到 msh 命令列表中 */
247 MSH_CMD_EXPORT(can_sample, can device sample);
248 #endif
249 #ifdef BSP_USING_TIM
250 #define HWTIMER_DEV_NAME "timer0"
251
timeout_cb(rt_device_t dev,rt_size_t size)252 static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
253 {
254 rt_kprintf("this is hwtimer timeout callback fucntion!\n");
255 rt_kprintf("tick is :%d !\n", rt_tick_get());
256
257 return 0;
258 }
259
hwtimer_sample(int argc,char * argv[])260 static int hwtimer_sample(int argc, char *argv[])
261 {
262 rt_err_t ret = RT_EOK;
263 rt_hwtimerval_t timeout_s;
264 rt_device_t hw_dev = RT_NULL;
265 rt_hwtimer_mode_t mode;
266
267 hw_dev = rt_device_find(HWTIMER_DEV_NAME);
268 if (hw_dev == RT_NULL)
269 {
270 rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
271 return -RT_ERROR;
272 }
273
274 ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
275 if (ret != RT_EOK)
276 {
277 rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
278 return ret;
279 }
280
281 rt_device_set_rx_indicate(hw_dev, timeout_cb);
282
283 mode = HWTIMER_MODE_PERIOD;
284 //mode = HWTIMER_MODE_ONESHOT;
285 ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
286 if (ret != RT_EOK)
287 {
288 rt_kprintf("set mode failed! ret is :%d\n", ret);
289 return ret;
290 }
291
292 timeout_s.sec = 2;
293 timeout_s.usec = 0;
294
295 if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
296 {
297 rt_kprintf("set timeout value failed\n");
298 return -RT_ERROR;
299 }
300
301 rt_thread_mdelay(3500);
302
303 rt_device_read(hw_dev, 0, &timeout_s, sizeof(timeout_s));
304 rt_kprintf("Read: Sec = %d, Usec = %d\n", timeout_s.sec, timeout_s.usec);
305
306 return ret;
307 }
308 MSH_CMD_EXPORT(hwtimer_sample, hwtimer sample);
309 #endif
310
311 #ifdef BSP_USING_PWM
312 #define PWM_DEV_NAME "pwm0" /* PWM设备名称 */
313 #define PWM_DEV_CHANNEL 0 /* PWM通道 */
314
315 struct rt_device_pwm *pwm_dev; /* PWM设备句柄 */
316
pwm_sample(int argc,char * argv[])317 static int pwm_sample(int argc, char *argv[])
318 {
319 rt_uint32_t period, pulse;
320
321 period = 500000; /* 周期为0.5ms，单位为纳秒ns */
322 pulse = 100000; /* PWM脉冲宽度值，单位为纳秒ns */
323
324 pwm_dev = (struct rt_device_pwm *)rt_device_find(PWM_DEV_NAME);
325 if (pwm_dev == RT_NULL)
326 {
327 rt_kprintf("pwm sample run failed! can't find %s device!\n", PWM_DEV_NAME);
328 return -RT_ERROR;
329 }
330
331 rt_pwm_set(pwm_dev, PWM_DEV_CHANNEL, period, pulse);
332 rt_pwm_enable(pwm_dev, PWM_DEV_CHANNEL);
333 return RT_EOK;
334 }
335 MSH_CMD_EXPORT(pwm_sample, pwm sample);
336 #endif
337
338 #ifdef BSP_USING_RTC
339 #include "sys/time.h"
340
rtc_sample(int argc,char * argv[])341 static int rtc_sample(int argc, char *argv[])
342 {
343 rt_err_t ret = RT_EOK;
344 time_t now;
345
346 ret = set_date(2000, 2, 28);
347 if (ret != RT_EOK)
348 {
349 rt_kprintf("set RTC date failed\n");
350 return ret;
351 }
352
353 ret = set_time(23, 59, 55);
354 if (ret != RT_EOK)
355 {
356 rt_kprintf("set RTC time failed\n");
357 return ret;
358 }
359
360 rt_thread_mdelay(3000);
361 now = time(RT_NULL);
362 rt_kprintf("%s\n", ctime(&now));
363
364 return ret;
365 }
366 MSH_CMD_EXPORT(rtc_sample, rtc sample);
367 #endif
368
369 #ifdef RT_USING_WDT
370 #define WDT_DEVICE_NAME "wdt"
371
372 static rt_device_t wdg_dev;
373
idle_hook(void)374 static void idle_hook(void)
375 {
376 rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, RT_NULL);
377 rt_kprintf("feed the dog!\n ");
378 }
379
wdt_sample(int argc,char * argv[])380 static int wdt_sample(int argc, char *argv[])
381 {
382 rt_err_t ret = RT_EOK;
383 rt_uint32_t timeout = 5;
384 char device_name[RT_NAME_MAX];
385
386 if (argc == 2)
387 {
388 rt_strncpy(device_name, argv[1], RT_NAME_MAX);
389 }
390 else
391 {
392 rt_strncpy(device_name, WDT_DEVICE_NAME, RT_NAME_MAX);
393 }
394 wdg_dev = rt_device_find(device_name);
395 if (!wdg_dev)
396 {
397 rt_kprintf("find %s failed!\n", device_name);
398 return -RT_ERROR;
399 }
400 ret = rt_device_init(wdg_dev);
401 if (ret != RT_EOK)
402 {
403 rt_kprintf("initialize %s failed!\n", device_name);
404 return -RT_ERROR;
405 }
406 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &timeout);
407 if (ret != RT_EOK)
408 {
409 rt_kprintf("set %s timeout failed!\n", device_name);
410 return -RT_ERROR;
411 }
412 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_START, RT_NULL);
413 if (ret != RT_EOK)
414 {
415 rt_kprintf("start %s failed!\n", device_name);
416 return -RT_ERROR;
417 }
418 // rt_thread_idle_sethook(idle_hook);
419
420 return ret;
421 }
422 MSH_CMD_EXPORT(wdt_sample, wdt sample);
423 #endif
424
425 #ifdef BSP_USING_SPI
426 #define W25Q_SPI_DEVICE_NAME "spi00"
427 #define W25Q_FLASH_NAME "norflash0"
428
429 #include "drv_spi.h"
430 #ifdef RT_USING_SFUD
431 #include "dev_spi_flash_sfud.h"
432
rt_hw_spi_flash_init(void)433 static int rt_hw_spi_flash_init(void)
434 {
435 rt_hw_spi_device_attach("spi0", "spi00", GPIOM, PIN3);
436
437 if (RT_NULL == rt_sfud_flash_probe(W25Q_FLASH_NAME, W25Q_SPI_DEVICE_NAME))
438 {
439 return -RT_ERROR;
440 };
441
442 return RT_EOK;
443 }
444 /* 导出到自动初始化 */
445 INIT_COMPONENT_EXPORT(rt_hw_spi_flash_init);
446
spi_w25q_sample(int argc,char * argv[])447 static void spi_w25q_sample(int argc, char *argv[])
448 {
449 struct rt_spi_device *spi_dev_w25q;
450 char name[RT_NAME_MAX];
451 rt_uint8_t w25x_read_id = 0x90;
452 rt_uint8_t id[5] = {0};
453
454 if (argc == 2)
455 {
456 rt_strncpy(name, argv[1], RT_NAME_MAX);
457 }
458 else
459 {
460 rt_strncpy(name, W25Q_SPI_DEVICE_NAME, RT_NAME_MAX);
461 }
462
463 /* 查找 spi 设备获取设备句柄 */
464 spi_dev_w25q = (struct rt_spi_device *)rt_device_find(name);
465 if (!spi_dev_w25q)
466 {
467 rt_kprintf("spi sample run failed! can't find %s device!\n", name);
468 }
469 else
470 {
471 /* 方式1：使用 rt_spi_send_then_recv()发送命令读取ID */
472 rt_spi_send_then_recv(spi_dev_w25q, &w25x_read_id, 1, id, 5);
473 rt_kprintf("use rt_spi_send_then_recv() read w25q ID is:%x%x\n", id[3], id[4]);
474
475 /* 方式2：使用 rt_spi_transfer_message()发送命令读取ID */
476 struct rt_spi_message msg1, msg2;
477
478 msg1.send_buf = &w25x_read_id;
479 msg1.recv_buf = RT_NULL;
480 msg1.length = 1;
481 msg1.cs_take = 1;
482 msg1.cs_release = 0;
483 msg1.next = &msg2;
484
485 msg2.send_buf = RT_NULL;
486 msg2.recv_buf = id;
487 msg2.length = 5;
488 msg2.cs_take = 0;
489 msg2.cs_release = 1;
490 msg2.next = RT_NULL;
491
492 rt_spi_transfer_message(spi_dev_w25q, &msg1);
493 rt_kprintf("use rt_spi_transfer_message() read w25q ID is:%x%x\n", id[3], id[4]);
494 }
495 }
496 /* 导出到 msh 命令列表中 */
497 MSH_CMD_EXPORT(spi_w25q_sample, spi w25q sample);
498
499 #ifdef RT_USING_DFS_ELMFAT
500 #include <dfs_file.h>
501 #include <unistd.h>
elmfat_sample(void)502 static void elmfat_sample(void)
503 {
504 int fd, size;
505 struct statfs elm_stat;
506 char str[] = "elmfat mount to W25Q flash.\r\n", buf[80];
507
508 if (dfs_mkfs("elm", W25Q_FLASH_NAME) == 0)
509 rt_kprintf("make elmfat filesystem success.\n");
510
511 if (dfs_mount(W25Q_FLASH_NAME, "/", "elm", 0, 0) == 0)
512 rt_kprintf("elmfat filesystem mount success.\n");
513
514 if (statfs("/", &elm_stat) == 0)
515 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
516 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
517
518 if (mkdir("/user", 0x777) == 0)
519 rt_kprintf("make a directory: '/user'.\n");
520
521 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
522
523 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
524 if (fd >= 0)
525 {
526 if (write(fd, str, sizeof(str)) == sizeof(str))
527 rt_kprintf("Write data done.\n");
528
529 close(fd);
530 }
531
532 fd = open("/user/test.txt", O_RDONLY);
533 if (fd >= 0)
534 {
535 size = read(fd, buf, sizeof(buf));
536
537 close(fd);
538
539 if (size == sizeof(str))
540 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
541 }
542 }
543 MSH_CMD_EXPORT(elmfat_sample, elmfat sample);
544 #endif
545 #endif
546 #endif
547
548 #ifdef BSP_USING_SPI
549 #ifdef RT_USING_SPI_MSD
550 #define SD_SPI_DEVICE_NAME "spi00"
551 #define SDCARD_NAME "sd0"
552
553 #include "drv_spi.h"
554 #include "dev_spi_msd.h"
555 #include <dfs_file.h>
556 #include <unistd.h>
rt_hw_spi0_tfcard(void)557 static int rt_hw_spi0_tfcard(void)
558 {
559 rt_hw_spi_device_attach("spi0", SD_SPI_DEVICE_NAME, GPION, PIN1);
560 return msd_init(SDCARD_NAME, SD_SPI_DEVICE_NAME);
561 }
562 INIT_DEVICE_EXPORT(rt_hw_spi0_tfcard);
563
elmfat_sample(void)564 static void elmfat_sample(void)
565 {
566 int fd, size;
567 struct statfs elm_stat;
568 char str[] = "elmfat mount to sdcard.\r\n", buf[80];
569
570 if (dfs_mkfs("elm", SDCARD_NAME) == 0)
571 rt_kprintf("make elmfat filesystem success.\n");
572
573 if (dfs_mount(SDCARD_NAME, "/", "elm", 0, 0) == 0)
574 rt_kprintf("elmfat filesystem mount success.\n");
575
576 if (statfs("/", &elm_stat) == 0)
577 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
578 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
579
580 if (mkdir("/user", 0x777) == 0)
581 rt_kprintf("make a directory: '/user'.\n");
582
583 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
584
585 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
586 if (fd >= 0)
587 {
588 if (write(fd, str, sizeof(str)) == sizeof(str))
589 rt_kprintf("Write data done.\n");
590
591 close(fd);
592 }
593
594 fd = open("/user/test.txt", O_RDONLY);
595 if (fd >= 0)
596 {
597 size = read(fd, buf, sizeof(buf));
598
599 close(fd);
600
601 if (size == sizeof(str))
602 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
603 }
604 }
605 MSH_CMD_EXPORT(elmfat_sample, elmfat sample);
606 #endif
607 #endif
608
609 #ifdef BSP_USING_SDIO
610 #define SDCARD_NAME "sd0"
611
612 #include <dfs_file.h>
613 #include <unistd.h>
614
elmfat_sample(void)615 static void elmfat_sample(void)
616 {
617 int fd, size;
618 struct statfs elm_stat;
619 char str[] = "elmfat mount to sdcard.\n", buf[80];
620
621 if (dfs_mkfs("elm", SDCARD_NAME) == 0)
622 rt_kprintf("make elmfat filesystem success.\n");
623
624 if (dfs_mount(SDCARD_NAME, "/", "elm", 0, 0) == 0)
625 rt_kprintf("elmfat filesystem mount success.\n");
626
627 if (statfs("/", &elm_stat) == 0)
628 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
629 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
630
631 if (mkdir("/user", 0x777) == 0)
632 rt_kprintf("make a directory: '/user'.\n");
633
634 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
635
636 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
637 if (fd >= 0)
638 {
639 if (write(fd, str, sizeof(str)) == sizeof(str))
640 rt_kprintf("Write data done.\n");
641
642 close(fd);
643 }
644
645 fd = open("/user/test.txt", O_RDONLY);
646 if (fd >= 0)
647 {
648 size = read(fd, buf, sizeof(buf));
649
650 close(fd);
651
652 if (size == sizeof(str))
653 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
654 }
655 }
656 MSH_CMD_EXPORT(elmfat_sample, elmfat sample);
657 #endif
658
659 #ifdef RT_USING_HWCRYPTO
crypto_sample(void)660 static void crypto_sample(void)
661 {
662 #ifdef BSP_USING_CRC
663 rt_uint8_t temp[] = {0, 1, 2, 3, 4, 5, 6, 7};
664 struct rt_hwcrypto_ctx *ctx;
665 rt_uint32_t result = 0;
666 struct hwcrypto_crc_cfg cfg =
667 {
668 .last_val = 0x00000000,
669 .poly = 0x04C11DB7,
670 .width = 8,
671 .xorout = 0x00000000, //不支持XOR
672 .flags = 0,
673 };
674
675 ctx = rt_hwcrypto_crc_create(rt_hwcrypto_dev_default(), HWCRYPTO_CRC_CRC32);
676 rt_hwcrypto_crc_cfg(ctx, &cfg);
677
678 result = rt_hwcrypto_crc_update(ctx, temp, sizeof(temp));
679 rt_kprintf("result: 0x%08x \n", result);
680 rt_hwcrypto_crc_destroy(ctx);
681 #endif /* BSP_USING_CRC */
682
683 #ifdef BSP_USING_RNG
684 rt_uint32_t rng_result = 0;
685 int i;
686
687 for (i = 0; i < 20; i++)
688 {
689 rng_result = rt_hwcrypto_rng_update();
690 rt_kprintf("rng:0x%08x.\n", rng_result);
691 }
692 #endif /* BSP_USING_RNG */
693 }
694 MSH_CMD_EXPORT(crypto_sample, crypto sample);
695 #endif
696
697 #ifdef BSP_USING_SDRAM
698 #include <rtthread.h>
699
700 #define THREAD_PRIORITY 25
701 #define THREAD_STACK_SIZE 512
702 #define THREAD_TIMESLICE 5
703
704 /* 线程入口 */
thread1_entry(void * parameter)705 void thread1_entry(void *parameter)
706 {
707 int i;
708 char *ptr = RT_NULL; /* 内存块的指针 */
709
710 for (i = 0;; i++)
711 {
712 /* 每次分配 (1 << i) 大小字节数的内存空间 */
713 ptr = rt_malloc(1 << i);
714
715 /* 如果分配成功 */
716 if (ptr != RT_NULL)
717 {
718 rt_kprintf("get memory :%d byte\n", (1 << i));
719 /* 释放内存块 */
720 rt_free(ptr);
721 rt_kprintf("free memory :%d byte\n", (1 << i));
722 ptr = RT_NULL;
723 }
724 else
725 {
726 rt_kprintf("try to get %d byte memory failed!\n", (1 << i));
727 return;
728 }
729 }
730 }
731
dynmem_sample(void)732 int dynmem_sample(void)
733 {
734 rt_thread_t tid = RT_NULL;
735
736 /* 创建线程 1 */
737 tid = rt_thread_create("thread1",
738 thread1_entry, RT_NULL,
739 THREAD_STACK_SIZE,
740 THREAD_PRIORITY,
741 THREAD_TIMESLICE);
742 if (tid != RT_NULL)
743 rt_thread_startup(tid);
744
745 return 0;
746 }
747 /* 导出到 msh 命令列表中 */
748 MSH_CMD_EXPORT(dynmem_sample, dynmem sample);
749 #endif
750
751 #ifdef RT_USING_TOUCH
752 #include "gt9147.h"
753
754 #define THREAD_PRIORITY 25
755 #define THREAD_STACK_SIZE 512
756 #define THREAD_TIMESLICE 5
757
rt_hw_gt9147_port(void)758 int rt_hw_gt9147_port(void)
759 {
760 struct rt_touch_config config;
761 rt_uint8_t rst;
762
763 rst = GT9147_RST_PIN;
764 config.dev_name = "i2c0";
765 config.irq_pin.pin = GT9147_IRQ_PIN;
766 config.irq_pin.mode = PIN_MODE_INPUT_PULLDOWN;
767 config.user_data = &rst;
768
769 rt_hw_gt9147_init("gt9147", &config);
770
771 return 0;
772 }
773 INIT_ENV_EXPORT(rt_hw_gt9147_port);
774
775 static rt_thread_t gt9147_thread = RT_NULL;
776 static rt_sem_t gt9147_sem = RT_NULL;
777 static rt_device_t dev = RT_NULL;
778 static struct rt_touch_data *read_data;
779
780 /* 读取数据线程入口函数 */
gt9147_entry(void * parameter)781 static void gt9147_entry(void *parameter)
782 {
783 struct rt_touch_data *read_data;
784 read_data = (struct rt_touch_data *)rt_malloc(sizeof(struct rt_touch_data) * 5);
785
786 while (1)
787 {
788 /* 请求信号量 */
789 rt_sem_take(gt9147_sem, RT_WAITING_FOREVER);
790 /* 读取五个点的触摸信息 */
791 if (rt_device_read(dev, 0, read_data, 5) == 5)
792 {
793 for (rt_uint8_t i = 0; i < 5; i++)
794 {
795 if (read_data[i].event == RT_TOUCH_EVENT_DOWN || read_data[i].event == RT_TOUCH_EVENT_MOVE)
796 {
797 rt_kprintf("%d %d %d %d %d\n",
798 read_data[i].track_id,
799 read_data[i].x_coordinate,
800 read_data[i].y_coordinate,
801 read_data[i].timestamp,
802 read_data[i].width);
803 }
804 }
805 }
806 /* 打开中断 */
807 rt_device_control(dev, RT_TOUCH_CTRL_ENABLE_INT, RT_NULL);
808 }
809 }
810
811 /* 接收回调函数 */
rx_callback(rt_device_t dev,rt_size_t size)812 static rt_err_t rx_callback(rt_device_t dev, rt_size_t size)
813 {
814 /* 关闭中断 */
815 rt_device_control(dev, RT_TOUCH_CTRL_DISABLE_INT, RT_NULL);
816 /* 释放信号量 */
817 rt_sem_release(gt9147_sem);
818 return 0;
819 }
820
gt9147_sample(void)821 static int gt9147_sample(void)
822 {
823 /* 查找 Touch 设备 */
824 dev = rt_device_find("gt9147");
825
826 if (dev == RT_NULL)
827 {
828 rt_kprintf("can't find device:%s\n", "touch");
829 return -1;
830 }
831 /* 以中断的方式打开设备 */
832 if (rt_device_open(dev, RT_DEVICE_FLAG_INT_RX) != RT_EOK)
833 {
834 rt_kprintf("open device failed!");
835 return -1;
836 }
837 /* 设置接收回调 */
838 rt_device_set_rx_indicate(dev, rx_callback);
839 /* 创建信号量 */
840 gt9147_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_PRIO);
841
842 if (gt9147_sem == RT_NULL)
843 {
844 rt_kprintf("create dynamic semaphore failed.\n");
845 return -1;
846 }
847 /* 创建读取数据线程 */
848 gt9147_thread = rt_thread_create("thread1",
849 gt9147_entry,
850 RT_NULL,
851 THREAD_STACK_SIZE,
852 THREAD_PRIORITY,
853 THREAD_TIMESLICE);
854 /* 启动线程 */
855 if (gt9147_thread != RT_NULL)
856 rt_thread_startup(gt9147_thread);
857
858 return 0;
859 }
860 MSH_CMD_EXPORT(gt9147_sample, gt9147 sample);
861 #endif
862