1 /*
2 * Copyright (c) 2006-2021, 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(C,6)
15
main(void)16 int main(void)
17 {
18 int count = 1;
19
20 rt_pin_mode(LED_PIN, PIN_MODE_OUTPUT);
21 while (count++)
22 {
23 rt_pin_write(LED_PIN, PIN_HIGH);
24 rt_thread_mdelay(500);
25 rt_pin_write(LED_PIN, PIN_LOW);
26 rt_thread_mdelay(500);
27 }
28
29 return RT_EOK;
30 }
31
32 #ifdef BSP_USING_GPIO
33 #define KEY1_PIN GET_PIN(C,5)
key1_cb(void * args)34 void key1_cb(void *args)
35 {
36 rt_kprintf("key1 irq!\n");
37 }
pin_sample(int argc,char * argv[])38 static int pin_sample(int argc, char *argv[])
39 {
40 rt_pin_mode(KEY1_PIN, PIN_IRQ_MODE_FALLING);
41 rt_pin_attach_irq(KEY1_PIN, PIN_IRQ_MODE_FALLING, key1_cb, RT_NULL);
42 rt_pin_irq_enable(KEY1_PIN, PIN_IRQ_ENABLE);
43
44 return RT_EOK;
45 }
46 MSH_CMD_EXPORT(pin_sample, pin sample);
47 #endif
48
49 #ifdef BSP_USING_ADC
50 #define ADC_DEV_NAME "adc1"
51 #define ADC_DEV_CHANNEL 0
52 #define REFER_VOLTAGE 330
53 #define CONVERT_BITS (1 << 12)
54
adc_vol_sample(int argc,char * argv[])55 static int adc_vol_sample(int argc, char *argv[])
56 {
57 rt_adc_device_t adc_dev;
58 rt_uint32_t value, vol;
59 rt_err_t ret = RT_EOK;
60
61 adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
62 if (adc_dev == RT_NULL)
63 {
64 rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME);
65 return -RT_ERROR;
66 }
67
68 ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
69
70 value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
71 rt_kprintf("the value is :%d,", value);
72
73 vol = value * REFER_VOLTAGE / CONVERT_BITS;
74 rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
75
76 ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);
77
78 return ret;
79 }
80 MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample);
81 #endif
82
83 #ifdef BSP_USING_TIM
84 #define HWTIMER_DEV_NAME "timer0"
85
timeout_cb(rt_device_t dev,rt_size_t size)86 static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
87 {
88 rt_kprintf("this is hwtimer timeout callback fucntion!\n");
89 rt_kprintf("tick is :%d !\n", rt_tick_get());
90
91 return 0;
92 }
93
hwtimer_sample(int argc,char * argv[])94 static int hwtimer_sample(int argc, char *argv[])
95 {
96 rt_err_t ret = RT_EOK;
97 rt_hwtimerval_t timeout_s;
98 rt_device_t hw_dev = RT_NULL;
99 rt_hwtimer_mode_t mode;
100
101 hw_dev = rt_device_find(HWTIMER_DEV_NAME);
102 if (hw_dev == RT_NULL)
103 {
104 rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
105 return -RT_ERROR;
106 }
107
108 ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
109 if (ret != RT_EOK)
110 {
111 rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
112 return ret;
113 }
114
115 rt_device_set_rx_indicate(hw_dev, timeout_cb);
116
117 mode = HWTIMER_MODE_PERIOD;
118 //mode = HWTIMER_MODE_ONESHOT;
119 ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
120 if (ret != RT_EOK)
121 {
122 rt_kprintf("set mode failed! ret is :%d\n", ret);
123 return ret;
124 }
125
126 timeout_s.sec = 2;
127 timeout_s.usec = 0;
128
129 if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
130 {
131 rt_kprintf("set timeout value failed\n");
132 return -RT_ERROR;
133 }
134
135 rt_thread_mdelay(3500);
136
137 rt_device_read(hw_dev, 0, &timeout_s, sizeof(timeout_s));
138 rt_kprintf("Read: Sec = %d, Usec = %d\n", timeout_s.sec, timeout_s.usec);
139
140 return ret;
141 }
142 MSH_CMD_EXPORT(hwtimer_sample, hwtimer sample);
143 #endif
144
145 #ifdef BSP_USING_PWM
146 #define PWM_DEV_NAME "pwm0" /* PWM设备名称 */
147 #define PWM_DEV_CHANNEL 0 /* PWM通道 */
148
149 struct rt_device_pwm *pwm_dev; /* PWM设备句柄 */
150
pwm_sample(int argc,char * argv[])151 static int pwm_sample(int argc, char *argv[])
152 {
153 rt_uint32_t period, pulse;
154
155 period = 500000; /* 周期为0.5ms,单位为纳秒ns */
156 pulse = 250000; /* PWM脉冲宽度值,单位为纳秒ns */
157
158 pwm_dev = (struct rt_device_pwm *)rt_device_find(PWM_DEV_NAME);
159 if (pwm_dev == RT_NULL)
160 {
161 rt_kprintf("pwm sample run failed! can't find %s device!\n", PWM_DEV_NAME);
162 return -RT_ERROR;
163 }
164
165 rt_pwm_set(pwm_dev, PWM_DEV_CHANNEL, period, pulse);
166 rt_pwm_enable(pwm_dev, PWM_DEV_CHANNEL);
167 return RT_EOK;
168 }
169 MSH_CMD_EXPORT(pwm_sample, pwm sample);
170 #endif
171
172 #ifdef BSP_USING_RTC
173 #include <sys/time.h>
rtc_sample(int argc,char * argv[])174 static int rtc_sample(int argc, char *argv[])
175 {
176 rt_err_t ret = RT_EOK;
177 time_t now;
178
179 ret = set_date(2020, 2, 28);
180 if (ret != RT_EOK)
181 {
182 rt_kprintf("set RTC date failed\n");
183 return ret;
184 }
185
186 ret = set_time(23, 59, 55);
187 if (ret != RT_EOK)
188 {
189 rt_kprintf("set RTC time failed\n");
190 return ret;
191 }
192
193 //rt_thread_mdelay(3000);
194 now = time(RT_NULL);
195 rt_kprintf("%s\n", ctime(&now));
196
197 return ret;
198 }
199 MSH_CMD_EXPORT(rtc_sample, rtc sample);
200 #endif
201
202 #ifdef BSP_USING_WDT
203 #define WDT_DEVICE_NAME "wdt"
204
205 static rt_device_t wdg_dev;
206
idle_hook(void)207 static void idle_hook(void)
208 {
209 rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, RT_NULL);
210 rt_kprintf("feed the dog!\n ");
211 }
212
wdt_sample(int argc,char * argv[])213 static int wdt_sample(int argc, char *argv[])
214 {
215 rt_err_t ret = RT_EOK;
216 rt_uint32_t timeout = 2;
217 char device_name[RT_NAME_MAX];
218
219 if (argc == 2)
220 {
221 rt_strncpy(device_name, argv[1], RT_NAME_MAX);
222 }
223 else
224 {
225 rt_strncpy(device_name, WDT_DEVICE_NAME, RT_NAME_MAX);
226 }
227 wdg_dev = rt_device_find(device_name);
228 if (!wdg_dev)
229 {
230 rt_kprintf("find %s failed!\n", device_name);
231 return -RT_ERROR;
232 }
233 ret = rt_device_init(wdg_dev);
234 if (ret != RT_EOK)
235 {
236 rt_kprintf("initialize %s failed!\n", device_name);
237 return -RT_ERROR;
238 }
239 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &timeout);
240 if (ret != RT_EOK)
241 {
242 rt_kprintf("set %s timeout failed!\n", device_name);
243 return -RT_ERROR;
244 }
245 ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_START, RT_NULL);
246 if (ret != RT_EOK)
247 {
248 rt_kprintf("start %s failed!\n", device_name);
249 return -RT_ERROR;
250 }
251 rt_thread_idle_sethook(idle_hook);
252
253 return ret;
254 }
255 MSH_CMD_EXPORT(wdt_sample, wdt sample);
256 #endif
257
258 #ifdef BSP_USING_SPI
259 #define W25Q_SPI_DEVICE_NAME "spi00"
260 #define W25Q_FLASH_NAME "norflash0"
261
262 #include "drv_spi.h"
263 #ifdef RT_USING_SFUD
264 #include "dev_spi_flash_sfud.h"
265
rt_hw_spi_flash_init(void)266 static int rt_hw_spi_flash_init(void)
267 {
268 rt_hw_spi_device_attach("spi0", W25Q_SPI_DEVICE_NAME, GPIOP, PIN22);
269
270 if (RT_NULL == rt_sfud_flash_probe(W25Q_FLASH_NAME, W25Q_SPI_DEVICE_NAME))
271 {
272 return -RT_ERROR;
273 };
274
275 return RT_EOK;
276 }
277 INIT_COMPONENT_EXPORT(rt_hw_spi_flash_init);
278
spi_w25q_sample(int argc,char * argv[])279 static void spi_w25q_sample(int argc, char *argv[])
280 {
281 struct rt_spi_device *spi_dev_w25q;
282 char name[RT_NAME_MAX];
283 rt_uint8_t w25x_read_id = 0x90;
284 rt_uint8_t id[5] = {0};
285
286 if (argc == 2)
287 {
288 rt_strncpy(name, argv[1], RT_NAME_MAX);
289 }
290 else
291 {
292 rt_strncpy(name, W25Q_SPI_DEVICE_NAME, RT_NAME_MAX);
293 }
294
295 /* 查找 spi 设备获取设备句柄 */
296 spi_dev_w25q = (struct rt_spi_device *)rt_device_find(name);
297 struct rt_spi_configuration cfg;
298 cfg.data_width = 8;
299 cfg.mode = RT_SPI_MASTER | RT_SPI_MODE_0 | RT_SPI_MSB;
300 cfg.max_hz = 30 * 1000 * 1000; /* 20M */
301
302 rt_spi_configure(spi_dev_w25q, &cfg);
303 if (!spi_dev_w25q)
304 {
305 rt_kprintf("spi sample run failed! can't find %s device!\n", name);
306 }
307 else
308 {
309 /* 方式1：使用 rt_spi_send_then_recv()发送命令读取ID */
310 rt_spi_send_then_recv(spi_dev_w25q, &w25x_read_id, 1, id, 5);
311 rt_kprintf("use rt_spi_send_then_recv() read w25q ID is:%x%x\n", id[3], id[4]);
312
313 /* 方式2：使用 rt_spi_transfer_message()发送命令读取ID */
314 struct rt_spi_message msg1, msg2;
315
316 msg1.send_buf = &w25x_read_id;
317 msg1.recv_buf = RT_NULL;
318 msg1.length = 1;
319 msg1.cs_take = 1;
320 msg1.cs_release = 0;
321 msg1.next = &msg2;
322
323 msg2.send_buf = RT_NULL;
324 msg2.recv_buf = id;
325 msg2.length = 5;
326 msg2.cs_take = 0;
327 msg2.cs_release = 1;
328 msg2.next = RT_NULL;
329
330 rt_spi_transfer_message(spi_dev_w25q, &msg1);
331 rt_kprintf("use rt_spi_transfer_message() read w25q ID is:%x%x\n", id[3], id[4]);
332 }
333 }
334 MSH_CMD_EXPORT(spi_w25q_sample, spi w25q sample);
335
336 #ifdef RT_USING_DFS_ELMFAT
337 #include <dfs_file.h>
338 #include <unistd.h>
spi_flash_elmfat_sample(void)339 static void spi_flash_elmfat_sample(void)
340 {
341 int fd, size;
342 struct statfs elm_stat;
343 char str[] = "elmfat mount to W25Q flash.\r\n", buf[80];
344
345 if (dfs_mkfs("elm", W25Q_FLASH_NAME) == 0)
346 rt_kprintf("make elmfat filesystem success.\n");
347
348 if (dfs_mount(W25Q_FLASH_NAME, "/", "elm", 0, 0) == 0)
349 rt_kprintf("elmfat filesystem mount success.\n");
350
351 if (statfs("/", &elm_stat) == 0)
352 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
353 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
354
355 if (mkdir("/user", 0x777) == 0)
356 rt_kprintf("make a directory: '/user'.\n");
357
358 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
359
360 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
361 if (fd >= 0)
362 {
363 if (write(fd, str, sizeof(str)) == sizeof(str))
364 rt_kprintf("Write data done.\n");
365
366 close(fd);
367 }
368
369 fd = open("/user/test.txt", O_RDONLY);
370 if (fd >= 0)
371 {
372 size = read(fd, buf, sizeof(buf));
373
374 close(fd);
375
376 if (size == sizeof(str))
377 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
378 }
379 }
380 MSH_CMD_EXPORT(spi_flash_elmfat_sample, spi flash elmfat sample);
381 #endif
382 #endif
383 #endif
384
385 #ifdef BSP_USING_SPI
386 #ifdef RT_USING_SPI_MSD
387 #define SD_SPI_DEVICE_NAME "spi10"
388 #define SDCARD_NAME "sd0"
389
390 #include "drv_spi.h"
391 #include "dev_spi_msd.h"
392 #include <dfs_file.h>
393 #include <unistd.h>
394
rt_hw_spi1_tfcard(void)395 static int rt_hw_spi1_tfcard(void)
396 {
397 rt_hw_spi_device_attach("spi1", SD_SPI_DEVICE_NAME, GPIOB, PIN6);
398 return msd_init(SDCARD_NAME, SD_SPI_DEVICE_NAME);
399 }
400 INIT_DEVICE_EXPORT(rt_hw_spi1_tfcard);
401
elmfat_sample(void)402 static void elmfat_sample(void)
403 {
404 int fd, size;
405 struct statfs elm_stat;
406 char str[] = "elmfat mount to sdcard.", buf[80];
407
408 if (dfs_mkfs("elm", SDCARD_NAME) == 0)
409 rt_kprintf("make elmfat filesystem success.\n");
410
411 if (dfs_mount(SDCARD_NAME, "/", "elm", 0, 0) == 0)
412 rt_kprintf("elmfat filesystem mount success.\n");
413
414 if (statfs("/", &elm_stat) == 0)
415 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
416 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
417
418 if (mkdir("/user", 0x777) == 0)
419 rt_kprintf("make a directory: '/user'.\n");
420
421 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
422
423 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
424 if (fd >= 0)
425 {
426 if (write(fd, str, sizeof(str)) == sizeof(str))
427 rt_kprintf("Write data done.\n");
428
429 close(fd);
430 }
431
432 fd = open("/user/test.txt", O_RDONLY);
433 if (fd >= 0)
434 {
435 size = read(fd, buf, sizeof(buf));
436
437 close(fd);
438
439 if (size == sizeof(str))
440 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
441 }
442 }
443 MSH_CMD_EXPORT(elmfat_sample, elmfat sample);
444 #endif
445 #endif
446
447 #ifdef BSP_USING_SDIO
448 #define SDCARD_NAME "sd0"
449
450 #include <dfs_file.h>
451 #include <unistd.h>
452
sdio_elmfat_sample(void)453 static void sdio_elmfat_sample(void)
454 {
455 int fd, size;
456 struct statfs elm_stat;
457 char str[] = "elmfat mount to sdcard.\n", buf[80];
458
459 if (dfs_mkfs("elm", SDCARD_NAME) == 0)
460 rt_kprintf("make elmfat filesystem success.\n");
461
462 if (dfs_mount(SDCARD_NAME, "/", "elm", 0, 0) == 0)
463 rt_kprintf("elmfat filesystem mount success.\n");
464
465 if (statfs("/", &elm_stat) == 0)
466 rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n",
467 elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);
468
469 if (mkdir("/user", 0x777) == 0)
470 rt_kprintf("make a directory: '/user'.\n");
471
472 rt_kprintf("Write string '%s' to /user/test.txt.\n", str);
473
474 fd = open("/user/test.txt", O_WRONLY | O_CREAT);
475 if (fd >= 0)
476 {
477 if (write(fd, str, sizeof(str)) == sizeof(str))
478 rt_kprintf("Write data done.\n");
479
480 close(fd);
481 }
482
483 fd = open("/user/test.txt", O_RDONLY);
484 if (fd >= 0)
485 {
486 size = read(fd, buf, sizeof(buf));
487
488 close(fd);
489
490 if (size == sizeof(str))
491 rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
492 }
493 }
494 MSH_CMD_EXPORT(sdio_elmfat_sample, sdio elmfat sample);
495 #endif
496
497 #ifdef RT_USING_HWCRYPTO
crypto_sample(void)498 static void crypto_sample(void)
499 {
500 rt_uint8_t temp[] = {0, 1, 2, 3, 4, 5, 6, 7};
501 struct rt_hwcrypto_ctx *ctx;
502 rt_uint32_t result = 0;
503 struct hwcrypto_crc_cfg cfg =
504 {
505 .last_val = 0x0,
506 .poly = 0x04C11DB7,
507 .width = 8,
508 .xorout = 0x00000000,
509 .flags = 0,
510 };
511
512 ctx = rt_hwcrypto_crc_create(rt_hwcrypto_dev_default(), HWCRYPTO_CRC_CRC32);
513 rt_hwcrypto_crc_cfg(ctx, &cfg);
514 result = rt_hwcrypto_crc_update(ctx, temp, sizeof(temp));
515 rt_kprintf("result: 0x%08x \n", result);
516 rt_hwcrypto_crc_destroy(ctx);
517 }
518 MSH_CMD_EXPORT(crypto_sample, crypto sample);
519 #endif
520
521 #ifdef BSP_USING_NOR_FLASH
522 #define NORFLASH_DEV_NAME "nor"
norflash_sample(int argc,char * argv[])523 static int norflash_sample(int argc, char *argv[])
524 {
525 rt_err_t ret = RT_EOK;
526 rt_device_t hw_dev = RT_NULL;
527
528 hw_dev = rt_device_find(NORFLASH_DEV_NAME);
529 if (hw_dev == RT_NULL)
530 {
531 rt_kprintf("norflash sample run failed! can't find %s device!\n", NORFLASH_DEV_NAME);
532 return -RT_ERROR;
533 }
534 else
535 {
536 rt_kprintf("norflash sample run success! find %s device!\n", NORFLASH_DEV_NAME);
537 }
538
539 ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
540 if (ret != RT_EOK)
541 {
542 rt_kprintf("open %s device failed!\n", NORFLASH_DEV_NAME);
543 return ret;
544 }
545 else
546 {
547 rt_kprintf("open %s device success!\n", NORFLASH_DEV_NAME);
548 }
549
550 struct rt_mtd_nor_device *hw_nor;
551 hw_nor = RT_MTD_NOR_DEVICE(hw_dev);
552 long id = hw_nor->ops->read_id(hw_nor);
553 rt_kprintf("id = %08x!\n", id);
554 // rt_device_set_rx_indicate(hw_dev, timeout_cb);
555
556 // mode = HWTIMER_MODE_PERIOD;
557 // //mode = HWTIMER_MODE_ONESHOT;
558 // ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
559 // if (ret != RT_EOK)
560 // {
561 // rt_kprintf("set mode failed! ret is :%d\n", ret);
562 // return ret;
563 // }
564
565 // timeout_s.sec = 2;
566 // timeout_s.usec = 0;
567
568 // if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
569 // {
570 // rt_kprintf("set timeout value failed\n");
571 // return -RT_ERROR;
572 // }
573
574 // rt_thread_mdelay(3500);
575
576 // rt_device_read(hw_dev, 0, &timeout_s, sizeof(timeout_s));
577 // rt_kprintf("Read: Sec = %d, Usec = %d\n", timeout_s.sec, timeout_s.usec);
578
579 return ret;
580 }
581 MSH_CMD_EXPORT(norflash_sample, norflash sample);
582 #endif
583