21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 【STM32U599J-DK测评】点灯按键跑起来
返回列表 发新帖我要提问

[STM32U5] 【STM32U599J-DK测评】点灯按键跑起来

[复制链接]
 楼主| HonestQiao 发表于 2023-12-26 00:58 | 显示全部楼层 |阅读模式
<
STM32U5, 点灯, 按键, zephyr
#申请原创#STM32U599J-DK带了一块大大的屏幕，在点亮屏幕之前，先来玩板子的第一步，点个灯再说。

一、硬件了解
iShot_2023-12-25_23.40.39.png

在开发板上，有两个可以用户使用的灯和一个用户使用的按键。

从手册上，也可以详细的了解：
iShot_2023-12-26_00.30.40.png

关于这两个LED和按键的具体定义连接的GPIO，也可以从手册查看：
415386589add84800f.png

二、dts了解
点灯这活，用不上TouchGFX，所以我直接使用Zephyr点灯了。
在Zephyr中，STM32U599J-DK直接使用stm32u5a9j_dk的配置，对应的dts中有关于LED和按键的配置：
iShot_2023-12-26_00.33.45.png

为它们定义的别名如下：
808786589af187d943.png

在Zephyr中，可以用简短的别名，快速定位设备。

三、点灯代码
直接贴点两个灯的代码：
复制
  1. #include <zephyr/kernel.h>
    

  2. #include <zephyr/drivers/gpio.h>
    


  3. 

  4. /* 1000 msec = 1 sec */
    

  5. #define SLEEP_TIME_MS   1000
    


  6. 

  7. // 定义设备
    

  8. #define LED0_NODE DT_ALIAS(led0)
    

  9. #define LED1_NODE DT_ALIAS(led1)
    


  10. 

  11. // 定义设备变量
    

  12. static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios);
    

  13. static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios);
    


  14. 


  15. 

  16. int main(void)
    

  17. {
    

  18.         int ret;
    


  19. 

  20.         // 初始化检查
    

  21.         if (!gpio_is_ready_dt(&led0)) {
    

  22.                 return 0;
    

  23.         }
    


  24. 

  25.         ret = gpio_pin_configure_dt(&led0, GPIO_OUTPUT_ACTIVE);
    

  26.         if (ret < 0) {
    

  27.                 return 0;
    

  28.         }
    


  29. 

  30.         if (!gpio_is_ready_dt(&led1)) {
    

  31.                 return 0;
    

  32.         }
    


  33. 

  34.         ret = gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE);
    

  35.         if (ret < 0) {
    

  36.                 return 0;
    

  37.         }
    


  38. 

  39.         // 设置初始状态：低电平
    

  40.         ret = gpio_pin_set_dt(&led0, 0);
    

  41.         if (ret < 0) {
    

  42.                 return 0;
    

  43.         }
    

  44.         // 设置初始状态：高电平
    

  45.         ret = gpio_pin_set_dt(&led1, 1);
    

  46.         if (ret < 0) {
    

  47.                 return 0;
    

  48.         }
    


  49. 

  50.         while (1) {
    

  51.                 // 翻转状态
    

  52.                 ret = gpio_pin_toggle_dt(&led0);
    

  53.                 if (ret < 0) {
    

  54.                         return 0;
    

  55.                 }
    

  56.                 // 翻转状态
    

  57.                 ret = gpio_pin_toggle_dt(&led1);
    

  58.                 if (ret < 0) {
    

  59.                         return 0;
    

  60.                 }
    

  61.                 k_msleep(SLEEP_TIME_MS);
    

  62.         }
    

  63.         return 0;
    

  64. }


上述代码的逻辑，非常明确，具体步骤如下：
  • 通过宏定义DT_ALIAS 和设备别名，快速定位设备
  • 通过宏定义 GPIO_DT_SPEC_GET ，设置设备变量
  • 通过 gpio_is_ready_dt() 检查GPIO是否准备好
  • 通过gpio_pin_configure_dt()配置输入输出状态
  • 通过gpio_pin_set_dt()设置GPIO的状态
  • 通过gpio_pin_toggle_dt()翻转GPIO的状态
  • 在循环中，没翻转一次状态，就通过k_msleep()延时SLEEP_TIME_MS对应的时间


因为设置了两个灯的初始状态，一个是点亮，一个是熄灭，所以在循环中，翻转状态后，两个灯就形成交替亮灭的实际表现了。

上述代码，参考samples/basic/blinky进行，做好对应的prj.conf、CMakeLists.txt配置，然后使用下面的命令编译：
复制
  1. west build -p=always -b stm32u5a9j_dk
编译完成后，使用下面的命令烧录：
复制
  1. west flash
也可以使用pyocd烧录：
复制
  1. pyocd flash --erase chip --target stm32u5a5zjtxq build/zephyr/zephyr.hex


烧录完成后，运行效果如下：
01.gif

四、按键控制翻转的速度
下一步，我们把按键的功能，给添加进来，用按键控制交替的速度，也就是延时的时间，每按键一次，则延时时间变短，交替速度变快。

具体的代码如下：
复制
  1. #include <zephyr/kernel.h>
    

  2. #include <zephyr/drivers/gpio.h>
    


  3. 

  4. /* 1000 msec = 1 sec */
    

  5. #define SLEEP_TIME_MS   1000
    

  6. #define SLEEP_TIME_MS_MIN   100
    


  7. 

  8. #define LED0_NODE DT_ALIAS(led0)
    

  9. #define LED1_NODE DT_ALIAS(led1)
    


  10. 

  11. #define SW0_NODE        DT_ALIAS(sw0)
    

  12. static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET_OR(SW0_NODE, gpios,
    

  13.                                                               {0});
    

  14. static struct gpio_callback button_cb_data;
    


  15. 

  16. int sleep_time = SLEEP_TIME_MS;
    


  17. 

  18. static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios);
    

  19. static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios);
    


  20. 

  21. bool push_status = true;
    

  22. void button_pressed(const struct device *dev, struct gpio_callback *cb,
    

  23.                     uint32_t pins)
    

  24. {
    

  25.         if (push_status) {
    

  26.                 return;
    

  27.         }
    

  28.         push_status = true;
    

  29.         printk("Button pressed at %" PRIu32 "\n", k_cycle_get_32());
    

  30.         sleep_time -= 100;
    

  31.         if (sleep_time<SLEEP_TIME_MS_MIN) {
    

  32.                 sleep_time = SLEEP_TIME_MS;
    

  33.         }
    

  34.         printk("Sleep time is at %d\n", sleep_time);
    

  35.         push_status = false;
    

  36. }
    


  37. 

  38. int main(void)
    

  39. {
    

  40.         int ret;
    


  41. 


  42. 

  43.         if (!gpio_is_ready_dt(&button)) {
    

  44.                 printk("Error: button device %s is not ready\n",
    

  45.                        button.port->name);
    

  46.                 return 0;
    

  47.         }
    


  48. 

  49.         ret = gpio_pin_configure_dt(&button, GPIO_INPUT);
    

  50.         if (ret != 0) {
    

  51.                 printk("Error %d: failed to configure %s pin %d\n",
    

  52.                        ret, button.port->name, button.pin);
    

  53.                 return 0;
    

  54.         }
    


  55. 

  56.         ret = gpio_pin_interrupt_configure_dt(&button,
    

  57.                                               GPIO_INT_EDGE_TO_ACTIVE);
    

  58.         if (ret != 0) {
    

  59.                 printk("Error %d: failed to configure interrupt on %s pin %d\n",
    

  60.                         ret, button.port->name, button.pin);
    

  61.                 return 0;
    

  62.         }
    


  63. 

  64.         gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
    

  65.         gpio_add_callback(button.port, &button_cb_data);
    

  66.         printk("Set up button at %s pin %d\n", button.port->name, button.pin);
    


  67. 

  68.         if (!gpio_is_ready_dt(&led0)) {
    

  69.                 return 0;
    

  70.         }
    


  71. 

  72.         ret = gpio_pin_configure_dt(&led0, GPIO_OUTPUT_ACTIVE);
    

  73.         if (ret < 0) {
    

  74.                 return 0;
    

  75.         }
    


  76. 

  77.         if (!gpio_is_ready_dt(&led1)) {
    

  78.                 return 0;
    

  79.         }
    


  80. 

  81.         ret = gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE);
    

  82.         if (ret < 0) {
    

  83.                 return 0;
    

  84.         }
    


  85. 

  86.         ret = gpio_pin_set_dt(&led0, 0);
    

  87.         if (ret < 0) {
    

  88.                 return 0;
    

  89.         }
    

  90.         ret = gpio_pin_set_dt(&led1, 1);
    

  91.         if (ret < 0) {
    

  92.                 return 0;
    

  93.         }
    


  94. 

  95.         push_status = false;
    

  96.         while (1) {
    

  97.                 ret = gpio_pin_toggle_dt(&led0);
    

  98.                 if (ret < 0) {
    

  99.                         return 0;
    

  100.                 }
    

  101.                 ret = gpio_pin_toggle_dt(&led1);
    

  102.                 if (ret < 0) {
    

  103.                         return 0;
    

  104.                 }
    

  105.                 k_msleep(sleep_time);
    

  106.         }
    

  107.         return 0;
    

  108. }


在上述代码中，按键处理的核心部分如下：
1. 定义：
复制
  1. #define SW0_NODE        DT_ALIAS(sw0)
    

  2. static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET_OR(SW0_NODE, gpios,
    

  3.                                                               {0});
    

  4. static struct gpio_callback button_cb_data;
    


  5. 

  6. static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios);
    

  7. static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios);
定义的方式，和按键的方式类似，不过对应按钮，多了一些专门的设置，如上面的button_cb_data，表示按键定义后的回调数据。

2. 按键按下后的处理
复制
  1. int sleep_time = SLEEP_TIME_MS;
    

  2. bool push_status = true;
    

  3. void button_pressed(const struct device *dev, struct gpio_callback *cb,
    

  4.                     uint32_t pins)
    

  5. {
    

  6.         if (push_status) {
    

  7.                 return;
    

  8.         }
    

  9.         push_status = true;
    

  10.         printk("Button pressed at %" PRIu32 "\n", k_cycle_get_32());
    

  11.         sleep_time -= 100;
    

  12.         if (sleep_time<SLEEP_TIME_MS_MIN) {
    

  13.                 sleep_time = SLEEP_TIME_MS;
    

  14.         }
    

  15.         printk("Sleep time is at %d\n", sleep_time);
    

  16.         push_status = false;
    

  17. }
上述调用，会在按键按下后，被回调。
在这个调用中，会递减延时时间sleep_time，直到最小值后，再从最大值开始，往复循环。

3. 按键初始化检查和回调配置
复制
  1.  if (!gpio_is_ready_dt(&button)) {
    

  2.                 printk("Error: button device %s is not ready\n",
    

  3.                        button.port->name);
    

  4.                 return 0;
    

  5.         }
    


  6. 

  7.         ret = gpio_pin_configure_dt(&button, GPIO_INPUT);
    

  8.         if (ret != 0) {
    

  9.                 printk("Error %d: failed to configure %s pin %d\n",
    

  10.                        ret, button.port->name, button.pin);
    

  11.                 return 0;
    

  12.         }
    


  13. 

  14.         ret = gpio_pin_interrupt_configure_dt(&button,
    

  15.                                               GPIO_INT_EDGE_TO_ACTIVE);
    

  16.         if (ret != 0) {
    

  17.                 printk("Error %d: failed to configure interrupt on %s pin %d\n",
    

  18.                         ret, button.port->name, button.pin);
    

  19.                 return 0;
    

  20.         }
    


  21. 

  22.         gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
    

  23.         gpio_add_callback(button.port, &button_cb_data);
    

  24.         printk("Set up button at %s pin %d\n", button.port->name, button.pin);
上述代码，和led一样做了初始化的检查，然后设置了对应的回调。

4. 循环部分使用设置的延时时间：
复制
  1.         push_status = false;
    

  2.         while (1) {
    

  3.                 ret = gpio_pin_toggle_dt(&led0);
    

  4.                 if (ret < 0) {
    

  5.                         return 0;
    

  6.                 }
    

  7.                 ret = gpio_pin_toggle_dt(&led1);
    

  8.                 if (ret < 0) {
    

  9.                         return 0;
    

  10.                 }
    

  11.                 k_msleep(sleep_time);
    

  12.         }


5. 实际效果
将上述代码保存后，然后编译烧录，实际运行的效果如下。
首先我们看一下串口的输出：
iShot_2023-12-26_00.53.31.png

可以看到，按键一下，则sleep time就减少100，低于100，则回到1000。单位为ms。

LED灯实际闪烁的效果如下：
02.gif

五、总结
好了，点灯和按键的处理，就到这里了。
感兴趣的话，还可以试试通过按键，进行PWM调光，也就是控制LED的亮点效果。

回复 赏

举报

相关帖子
MessageRing 发表于 2024-1-12 16:48 | 显示全部楼层
自带屏幕长什么样啊
回复 赏

举报

 楼主| HonestQiao 发表于 2024-1-18 15:33 | 显示全部楼层
之前的文章发过：【STM32U599J-DK测评】华丽的开箱 - STM32/STM8单片机论坛 - ST MCU意法半导体官方技术支持论坛 - 21ic电子技术开**坛

6570765a8d4578898c.png
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

HonestQiao

42

主题

110

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部