经过初步了解，HPM6750有一种低功耗模式，叫做掉电状态，此时CPU会处于停止状态，但是一单有外部中断，则马上恢复。
不过掉电状态的时候，RAM中的数据都会都是，所以掉电状态不能进行调试，需要直接将固件烧录到代码中。

经过一番尝试，在RGB-LED灯的实例基础上，结合掉电状态进行测试。
预期如下：
1. 板子启动后，RGB-LED呼吸灯自动启动
2. 按PBUTN按键 16秒以后，RGB-LED呼吸灯停止
3. 一会后，再按PBUTN或者WBUTN按键0.5秒以上，则RGB-LED呼吸灯恢复。

实际参考的两个例子如下：
1. samples/RGB-LED
2. samples/drivers/butn

合并后的代码如下：
  1. /*
  2. * Copyright (c) 2021 HPMicro
  3. *
  4. * SPDX-License-Identifier: BSD-3-Clause
  5. *
  6. */
  8. #include <stdio.h>
  9. #include "board.h"
  10. #include "hpm_debug_console.h"
  11. #include "hpm_clock_drv.h"
  12. #include "hpm_pwm_drv.h"
  13. #include "hpm_butn_drv.h"
  14. #include "hpm_bpor_drv.h"
  16. #define TEST_BPOR HPM_BPOR
  17. #define TEST_BPOR_POWER_ON_CAUSE bpor_power_on_cause_wbutn
  19. #ifdef BOARD_RED_PWM
  20. #define RED_PWM_IRQ BOARD_RED_PWM_IRQ
  21. #define RED_PWM BOARD_RED_PWM
  22. #define RED_PWM_CMP BOARD_RED_PWM_CMP
  23. #define RED_PWM_CMP_INITIAL_ZERO BOARD_RED_PWM_CMP_INITIAL_ZERO
  24. #define RED_PWM_OUT BOARD_RED_PWM_OUT
  25. #define RED_PWM_CLOCK_NAME BOARD_RED_PWM_CLOCK_NAME
  26. #else
  27. #error BOARD_RED_PWM needs to be defined
  28. #endif
  30. #ifdef BOARD_GREEN_PWM
  31. #define GREEN_PWM_IRQ BOARD_GREEN_PWM_IRQ
  32. #define GREEN_PWM BOARD_GREEN_PWM
  33. #define GREEN_PWM_CMP BOARD_GREEN_PWM_CMP
  34. #define GREEN_PWM_CMP_INITIAL_ZERO BOARD_GREEN_PWM_CMP_INITIAL_ZERO
  35. #define GREEN_PWM_OUT BOARD_GREEN_PWM_OUT
  37. #define GREEN_PWM_CLOCK_NAME BOARD_BLUE_PWM_CLOCK_NAME
  38. #else
  39. #error BOARD_GREEN_PWM needs to be defined
  40. #endif
  42. #ifdef BOARD_BLUE_PWM
  43. #define BLUE_PWM_IRQ BOARD_BLUE_PWM_IRQ
  44. #define BLUE_PWM BOARD_BLUE_PWM
  45. #define BLUE_PWM_CMP BOARD_BLUE_PWM_CMP
  46. #define BLUE_PWM_CMP_INITIAL_ZERO BOARD_BLUE_PWM_CMP_INITIAL_ZERO
  47. #define BLUE_PWM_OUT BOARD_BLUE_PWM_OUT
  48. #define BLUE_PWM_CLOCK_NAME BOARD_BLUE_PWM_CLOCK_NAME
  49. #else
  50. #error BOARD_BLUE_PWM needs to be defined
  51. #endif
  53. #define PWM_PERIOD_IN_MS (1U)
  54. #define PWM_DUTY_STEP_COUNT (1000U)
  56. typedef struct {
  57.     PWM_Type *pwm;
  58.     uint32_t reload;
  59.     uint32_t step;
  60.     bool pwm_cmp_initial_zero;
  61.     uint8_t pwm_irq;
  62.     uint8_t pwm_cmp;
  63.     uint8_t pwm_ch;
  64. } led_pwm_t;
  66. typedef enum {
  67.     red = BOARD_RGB_RED,
  68.     green = BOARD_RGB_GREEN,
  69.     blue = BOARD_RGB_BLUE
  70. } led_index_t;
  72. led_pwm_t leds[3];
  73. uint32_t reload;
  74. volatile bool do_update;
  75. volatile led_index_t current;
  77. void pwm_isr(void)
  78. {
  79.     pwm_clear_status(leds[current].pwm, PWM_IRQ_HALF_RELOAD);
  80.     do_update = true;
  81. }
  83. SDK_DECLARE_EXT_ISR_M(RED_PWM_IRQ, pwm_isr)
  84. #if (GREEN_PWM_IRQ != RED_PWM_IRQ)
  85. SDK_DECLARE_EXT_ISR_M(GREEN_PWM_IRQ, pwm_isr)
  86. #endif
  87. #if (BLUE_PWM_IRQ != RED_PWM_IRQ) && (GREEN_PWM_IRQ != BLUE_PWM_IRQ)
  88. SDK_DECLARE_EXT_ISR_M(BLUE_PWM_IRQ, pwm_isr)
  89. #endif
  91. void config_pwm(PWM_Type * ptr, uint8_t pin, uint8_t cmp_index, uint32_t reload, bool cmp_initial_zero, uint8_t hw_event_cmp, bool off_level_high)
  92. {
  93.     pwm_cmp_config_t cmp_config = {0};
  94.     pwm_config_t pwm_config = {0};
  96.     pwm_stop_counter(ptr);
  97.     pwm_get_default_pwm_config(ptr, &pwm_config);
  98.     pwm_get_default_cmp_config(ptr, &cmp_config);
  100.     pwm_config.enable_output = false;
  101.     pwm_config.dead_zone_in_half_cycle = 0;
  102.     pwm_config.invert_output = !(cmp_initial_zero && off_level_high);
  104.     /*
  105.      * reload and start counter
  106.      */
  107.     pwm_set_reload(ptr, 0, reload);
  108.     pwm_set_start_count(ptr, 0, 0);
  110.     cmp_config.mode = pwm_cmp_mode_output_compare;
  112.     cmp_config.cmp = cmp_initial_zero ? 0 : reload + 1;
  113.     cmp_config.update_trigger = pwm_shadow_register_update_on_modify;
  115.     /* config initial compare value which should take affect immediately */
  116.     pwm_config_cmp(ptr, cmp_index, &cmp_config);
  118.     /* update trigger type so that compare value will be updated on hardware event (RELOAD) */
  119.     cmp_config.update_trigger = pwm_shadow_register_update_on_hw_event;
  120.     /*
  121.      * config pwm as output driven by cmp
  122.      */
  123.     if (status_success != pwm_setup_waveform(ptr, pin, &pwm_config, cmp_index, &cmp_config, 1)) {
  124.         printf("failed to setup waveform\n");
  125.         while(1);
  126.     }
  128.     /*
  129.      * config hw event
  130.      */
  131.     cmp_config.cmp = reload - 1;
  132.     cmp_config.update_trigger = pwm_shadow_register_update_on_hw_event;
  133.     pwm_load_cmp_shadow_on_match(ptr, hw_event_cmp, &cmp_config);
  134. }
  136. void turn_on_rgb_led(led_index_t i)
  137. {
  138.     PWM_Type *pwm;
  139.     uint8_t pwm_cmp;
  140.     uint32_t initial;
  142.     /* make sure cmp value is set to initial, before enabling output */
  143.     pwm = leds[i].pwm;
  144.     pwm_cmp = leds[i].pwm_cmp;
  145.     initial = leds[i].pwm_cmp_initial_zero ? 0 : (leds[i].reload + 1);
  146.     pwm_update_raw_cmp_edge_aligned(pwm, pwm_cmp, initial);
  148.     board_enable_output_rgb_led(i);
  149. }
  151. void turn_off_rgb_led(led_index_t i)
  152. {
  153.     board_disable_output_rgb_led(i);
  154. }
  156. void update_rgb_led(void)
  157. {
  158.     uint32_t duty;
  159.     bool increase_step = true;
  160.     PWM_Type *pwm;
  161.     uint32_t reload, pwm_cmp, step;
  163.     step = leds[current].step;
  164.     reload = leds[current].reload;
  165.     pwm = leds[current].pwm;
  166.     pwm_cmp = leds[current].pwm_cmp;
  167.     duty = step;
  169.     pwm_enable_irq(pwm, PWM_IRQ_HALF_RELOAD);
  170.     turn_on_rgb_led(current);
  171.     while(!(!increase_step && (duty < 2 * step))) {
  172.         if (increase_step && (duty + step > reload)) {
  173.             increase_step = false;
  174.         }
  176.         if (increase_step) {
  177.             duty += step;
  178.         } else {
  179.             duty -= step;
  180.         }
  182.         while (!do_update) {
  183.             ;
  184.         }
  185.         pwm_update_raw_cmp_edge_aligned(pwm, pwm_cmp, duty);
  186.         do_update = false;
  187.     }
  188.     turn_off_rgb_led(current);
  189.     pwm_disable_irq(pwm, PWM_IRQ_HALF_RELOAD);
  190. }
  192. int main(void){
  193.     uint32_t freq;
  194.     uint32_t hw_event_cmp;
  196.     board_init();
  197.     init_butn_pins();
  198.     board_init_rgb_pwm_pins();
  199.     printf("rgb led example\n");
  201.     freq = clock_get_frequency(RED_PWM_CLOCK_NAME);
  202.     leds[red].reload = freq / 1000 * PWM_PERIOD_IN_MS - 1;
  203.     leds[red].pwm = RED_PWM;
  204.     leds[red].pwm_ch = RED_PWM_OUT;
  205.     leds[red].pwm_cmp = RED_PWM_CMP;
  206.     leds[red].pwm_cmp_initial_zero = RED_PWM_CMP_INITIAL_ZERO;
  207.     leds[red].pwm_irq = RED_PWM_IRQ;
  208.    
  209.     freq = clock_get_frequency(GREEN_PWM_CLOCK_NAME);
  210.     leds[green].reload = freq / 1000 * PWM_PERIOD_IN_MS - 1;
  211.     leds[green].pwm = GREEN_PWM;
  212.     leds[green].pwm_ch = GREEN_PWM_OUT;
  213.     leds[green].pwm_cmp = GREEN_PWM_CMP;
  214.     leds[green].pwm_cmp_initial_zero = GREEN_PWM_CMP_INITIAL_ZERO;
  215.     leds[green].pwm_irq = GREEN_PWM_IRQ;
  217.     freq = clock_get_frequency(BLUE_PWM_CLOCK_NAME);
  218.     leds[blue].reload = freq / 1000 * PWM_PERIOD_IN_MS - 1;
  219.     leds[blue].pwm = BLUE_PWM;
  220.     leds[blue].pwm_ch = BLUE_PWM_OUT;
  221.     leds[blue].pwm_cmp = BLUE_PWM_CMP;
  222.     leds[blue].pwm_cmp_initial_zero = BLUE_PWM_CMP_INITIAL_ZERO;
  223.     leds[blue].pwm_irq = BLUE_PWM_IRQ;
  225.     hw_event_cmp = PWM_SOC_CMP_MAX_COUNT;
  226.     for (uint8_t i = 0; i < PWM_SOC_CMP_MAX_COUNT; i++) {
  227.         if ((i != RED_PWM_CMP) && (i != GREEN_PWM_CMP) && (i != BLUE_PWM_CMP)) {
  228.             continue;
  229.         }
  230.         hw_event_cmp = i;
  231.         break;
  232.     }
  233.     if (hw_event_cmp == PWM_SOC_CMP_MAX_COUNT) {
  234.         printf("Failed to find a comparator for hardware event\n");
  235.         while (1) {
  236.         };
  237.     }
  239.     for (uint8_t i = 0; i < ARRAY_SIZE(leds); i++) {
  240.         leds[i].step = leds[i].reload / PWM_DUTY_STEP_COUNT;
  241.         config_pwm(leds[i].pwm, leds[i].pwm_ch, leds[i].pwm_cmp, leds[i].reload, leds[i].pwm_cmp_initial_zero, hw_event_cmp, BOARD_LED_OFF_LEVEL);
  242.         pwm_start_counter(leds[i].pwm);
  243.         intc_m_enable_irq_with_priority(leds[i].pwm_irq, 1);
  244.     }
  246.     bpor_select_power_on_cause(TEST_BPOR, TEST_BPOR_POWER_ON_CAUSE);
  247.     printf("Please press PBUTN 16s to enter power down mode, then press PBUTN or WBUTN 0.5s to wake up from power down mode.\n");
  248.    
  249.     current = red;
  250.     while(1) {
  251.         update_rgb_led();
  252.         do_update = false;
  253.         current = (current + 1) % (blue + 1);
  254.     }
  255.     return 0;
  256. }

上述代码中，RGB-LED的呼吸灯模式，主要就是启用了PWM来进行控制，核心设置为：
  1. #define PWM_PERIOD_IN_MS (1U)
  2. #define PWM_DUTY_STEP_COUNT (1000U)
  6. freq = clock_get_frequency(RED_PWM_CLOCK_NAME);
  7.     leds[red].reload = freq / 1000 * PWM_PERIOD_IN_MS - 1;
  8.     leds[red].pwm = RED_PWM;
  9.     leds[red].pwm_ch = RED_PWM_OUT;
  10.     leds[red].pwm_cmp = RED_PWM_CMP;
  11.     leds[red].pwm_cmp_initial_zero = RED_PWM_CMP_INITIAL_ZERO;
  12.     leds[red].pwm_irq = RED_PWM_IRQ;
其中PWM脉宽计数终值为1000，周期为1秒，实际运行时，形成了很好的呼吸灯的效果。
然后在update_rgb_led()中，启用对应的pwm输出，从而控制对应的灯。

而掉电模式，则主要由如下部分配置和处理：
  1. #define TEST_BPOR HPM_BPOR
  2. #define TEST_BPOR_POWER_ON_CAUSE bpor_power_on_cause_wbutn
  4. bpor_select_power_on_cause(TEST_BPOR, TEST_BPOR_POWER_ON_CAUSE);

将以上代码编译烧录到开发板，然后使用数字功率计测试不同状态下的运行功耗。
1. 正常运行情况下：
image.png
此时的运行电压为4.8V，电流为220+-2ma

2. 掉电状态：
按PBUTN16秒以上，呼吸灯熄灭，进入掉电状态：
image.png
此时的运行电压为4.8V，电流为76+-1ma

3. 恢复正常运行：
按PBUTN或者WBUTN 0.5秒以上，系统恢复，呼吸灯重新开始闪烁
image.png
此时的运行电压为4.8V，电流为220+-2ma

具体的操作过程视频如下：


通过上面的测试步骤，可以清晰得到，掉电状态下，系统功耗约为正常运行状态下的1/3。
因为上述测试，仅为PWM电量RGB-LED，所以功耗比不是特别大。
如果是运行更多的外设，功耗更大的情况下，那么就会更加的明显。
后续会进一步测试，获得更多的数据。