【产品应用】AWorksLP 样例详解（MR6450）—— HWTimer

/**
 * rief 硬件定时器中断服务函数。
 * param[in] p_arg : 任务参数
 */
static void mytimer_isr (void *p_arg)
{
  aw_gpio_toggle((int)p_arg);
  aw_kprintf("enter isr 

");
}


/**
 * rief hwtimer 测试函数
 */
aw_local void* __task_handle (void *arg)
{
  int             fd;
  aw_err_t          ret;
  uint32_t          count = 5;
  aw_hwtimer_rate_t     p_intr_freq;


  p_intr_freq.rate_denominator = 5;
  p_intr_freq.rate_numerator = 1;


  fd = aw_open(CONFIG_DEMO_HWTIMER_PEROID_DEV_NAME, AW_O_RDWR, 0);
  if (fd < 0) {
    aw_kprintf("hwtimer open failed:%d 

", fd);
    while(1);
  }


  ret = aw_hwtimer_period_intr_freq_set_frac(fd, &p_intr_freq);
  while (count) {
    aw_hwtimer_period_wait(fd, 500);
    mytimer_isr(arg);
    count --;
  }


  // 配置每秒中断2次
  ret = aw_hwtimer_period_intr_freq_set(fd, 2);


  ret = aw_hwtimer_period_start(fd);
  if (ret != AW_OK) {
    aw_kprintf("Timer allocation fail!
");
  }


  ret = aw_hwtimer_period_wait(fd, AW_WAIT_FOREVER);


  while (1) {
    aw_hwtimer_period_wait(fd, AW_WAIT_FOREVER);
    mytimer_isr(arg);
  }


  for (;;) {
    aw_mdelay(1000);
  }
  aw_close(fd);


  return 0;
}

aw_local void* __task_handle (void *arg)
{
    uint32_t     count = 0;
    int          fd, led_fd;
    int          ret;
    uint32_t     start_count;
    
    fd = aw_open(CONFIG_DEMO_HWTIMER_PEROID_DEV_NAME, AW_O_RDWR, 0);
    if (fd < 0) {
        aw_kprintf("hwtimer open fail! :%d
",fd);
        return;
    }
    /* 打开设备会点亮LED */
    led_fd = aw_open("/dev/led_run", AW_O_RDWR, 0);
    if (led_fd < 0) {
        aw_kprintf("led open fail! :%d
", led_fd);
        aw_close(fd);
        return;
    }
    ret = aw_hwtimer_count_rate_get(fd, &start_count);
    if (ret != AW_OK) {
        aw_kprintf("Timer count rate get fail!
");
        aw_close(fd);
        aw_close(led_fd);
        return;
    }
    // 设置时钟频率
    ret = aw_hwtimer_count_rate_set(fd, start_count/2);
    if (ret != AW_OK) {
        aw_kprintf("Timer count rate set fail!
");
        aw_close(fd);
        aw_close(led_fd);
        return;
    }
    ret = aw_hwtimer_count_start(fd);
    if (ret != AW_OK) {
        aw_kprintf("Timer start fail!
");
        aw_close(fd);
        aw_close(led_fd);
        return;
    }
    for (;;) {  
        aw_led_toggle(led_fd);
        aw_mdelay(500);
        aw_led_toggle(led_fd);
        aw_hwtimer_count_get(fd, &count);
        aw_kprintf("Count is %d
", count);
    }
    aw_close(fd);
    aw_close(led_fd);
    return 0;
}

aw_local void* __task_handle (void *arg)
{
    int                 i;
    int                 fd;
    aw_err_t            ret;
    aw_timespec_t       timespec;
    aw_timestamp_t      start_timestamp, stop_timestamp;
    aw_timestamp_freq_t timestamp_freq;
    uint64_t            delay_ns, diff;
    uint32_t            ns_numerator = 1000000000;


    timestamp_freq = aw_timestamp_freq_get();
    while (0 == (timestamp_freq % 10)) {
        timestamp_freq /= 10;
        ns_numerator /= 10;
}


    fd = aw_open(CONFIG_DEMO_HWTIMER_DELAY_DEV_NAME, AW_O_RDWR, 0);
    if (fd < 0) {
        aw_kprintf("hwtimer open failed:%d 

", fd);
        while(1);
    }


    delay_ns = 2001000;
    for (i = 0; i < 100; i++) {
        timespec.tv_sec = delay_ns / 1000000000u;
        timespec.tv_nsec = (uint32_t)(delay_ns % 1000000000u);


        start_timestamp = aw_timestamp_get();
        ret = aw_hwtimer_delay(fd, ×pec);
        if (ret !=AW_OK) {
            aw_kprintf("hwtimer delay failed:%d 

", ret);
        }
        aw_barrier();
        stop_timestamp = aw_timestamp_get();


        stop_timestamp -= start_timestamp;
        diff = stop_timestamp;
        diff *= ns_numerator;
        diff /= timestamp_freq;


        diff = diff - delay_ns;
        aw_kprintf(
                "hwtimer_delay delay = %u,diff = %u ns
",
                (uint32_t)delay_ns,
                (uint32_t)diff);
        delay_ns += 100000;
    }
    aw_close(fd);
    return 0;
}

/* 单边沿触发*/
static void test_cap_single_edge(
        int fd,
        int gpio_cap,
        uint32_t ms,
        aw_hwtimer_cap_config_t *p_config,
        int is_rising)
{
    uint64_t                    cap_val1, cap_val2;
    aw_err_t                    ret;


    // 制造两次上升沿
    mk_edge(gpio_cap, 5);
    aw_task_delay(ms);
    mk_edge(gpio_cap, 5);


    // 此时应该产生了两次捕获事件
    // 把它们读出来
    ret = aw_hwtimer_cap_read(fd, &cap_val1, AW_WAIT_FOREVER);
    if (AW_OK != ret) {
        aw_kprintf("cap read cap_val1 failed 
");
        return;
    }
    ret = aw_hwtimer_cap_read(fd, &cap_val2, AW_WAIT_FOREVER);
    if (AW_OK != ret) {
        aw_kprintf("cap read cap_val2 failed 
");
        return;
    }


    cap_val2 -= cap_val1;
    cap_val2 *= 1000000;
    cap_val2 /= p_config->sample_rate;


    if (is_rising) {
        aw_kprintf("two rising edge between %u ms 
", ms + 5);
    }
    else {
        aw_kprintf("two falling edge between %u ms 
", ms + 5);
    }
    aw_kprintf("two capture events between %llu us 
", cap_val2);
}


static void demo_cap_base(int gpio_cap)
{
    int                         fd;
    aw_err_t                    ret;
    aw_hwtimer_cap_config_t    config;


    // 使得测试GPIO输出为0
    aw_gpio_set(gpio_cap, 0);


    fd = aw_open(CONFIG_DEMO_HWTIMER_CAP_DEV_NAME, AW_O_RDWR, 0);
    if (fd < 0) {
        aw_kprintf("cap open failed!
");
        return;
    }


    // 获取捕获定时器的配置
    ret = aw_hwtimer_cap_config_get(fd, &config);
    if (ret != AW_OK) {
        aw_kprintf("cap config get failed...
");
        aw_close(fd);
        return ;
    }


#if CONFIG_SINGLE_EDGE
    int is_rising;
    // 配置为上升沿触发捕获
    config.cap_edge_flags = AW_CAPTURE_RISING_EDGE;
    is_rising = 1;
    ret = aw_hwtimer_cap_config_set(fd, &config);
    if (ret != AW_OK) {
        aw_kprintf("cap config set failed...
");
        aw_close(fd);
        return ;
    }


    ret = aw_hwtimer_cap_start(fd);
    if (ret != AW_OK) {
        aw_kprintf("cap start failed...
");
        aw_close(fd);
        return ;
    }
    test_cap_single_edge(fd, gpio_cap, 20, &config, is_rising);
#endif


    aw_close(fd);
}