ruuvi_nrf5_sdk15_rtc_mcu.c

Go to the documentation of this file.

 
#include "ruuvi_driver_enabled_modules.h"
#include "ruuvi_interface_rtc.h"
#if RUUVI_NRF5_SDK15_RTC_ENABLED
#include "nrf5_sdk15_config.h"
#include "ruuvi_driver_error.h"
#include "ruuvi_driver_sensor.h"
#include "ruuvi_interface_log.h"
#include "ruuvi_nrf5_sdk15_error.h"
#include "nrf.h"
static inline void LOGW (const char * const msg)
{
    ri_log (RI_LOG_LEVEL_WARNING, msg);
}
 
#ifdef NRF5_SDK15_RTC_INSTANCE
#include "nrf_drv_rtc.h"
#include "nrf_drv_clock.h"
#include <stdint.h>
#include <stdbool.h>
 
const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE (NRF5_SDK15_RTC_INSTANCE);
static uint64_t ticks = 0;
static bool m_is_init = false;
 
static void rtc_handler (nrf_drv_rtc_int_type_t int_type)
{
    if (int_type == NRF_DRV_RTC_INT_OVERFLOW)
    {
        // nRF RTC is 24 bits wide.
        ticks += (1 << 24);
    }
}
 
rd_status_t ri_rtc_init (void)
{
    if (true == m_is_init) { return RD_ERROR_INVALID_STATE; }
 
    ret_code_t err_code = NRF_SUCCESS;
 
    // Initialize clock if not already initialized
    if (false == nrf_drv_clock_init_check()) { err_code |= nrf_drv_clock_init(); }
 
    // Request LFCLK for RTC
    nrf_drv_clock_lfclk_request (NULL);
    nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG;
    config.prescaler = 0;
    ticks = 0;
    err_code = nrf_drv_rtc_init (&rtc, &config, rtc_handler);
    //Power on RTC instance before clearing the counter and enabling overflow
    nrf_drv_rtc_enable (&rtc);
    nrf_drv_rtc_counter_clear (&rtc);
    nrf_drv_rtc_overflow_enable (&rtc, true);
 
    if (NRF_SUCCESS == err_code) { m_is_init = true; }
 
    return ruuvi_nrf5_sdk15_to_ruuvi_error (err_code);
}
 
rd_status_t ri_rtc_uninit (void)
{
    if (true == m_is_init)
    {
        m_is_init = false;
        nrf_drv_rtc_uninit (&rtc);
        nrf_drv_clock_lfclk_release();
    }
 
    return RD_SUCCESS;
}
 
uint64_t ri_rtc_millis (void)
{
    if (false == m_is_init) { return RD_UINT64_INVALID; }
 
    uint64_t ms = nrf_drv_rtc_counter_get (&rtc) + ticks;
    return ( (ms * 1000) / 32768);
}
 
// If HW-RTC is not available, try timer.
#elif RUUVI_NRF5_SDK15_TIMER_ENABLED
#include "ruuvi_interface_timer.h"
#define DUMMY_RTC_INTERVAL 1024
static ri_timer_id_t counter_timer; 
static volatile uint64_t m_dummy;   
static void counter_handler (void * p_context)
{
    uint64_t mask = ~ ( (uint64_t) DUMMY_RTC_INTERVAL - 1);
    m_dummy &= mask;
    m_dummy += DUMMY_RTC_INTERVAL;
}
 
rd_status_t ri_rtc_init (void)
{
    m_dummy = 0;
    LOGW ("Using timer-tick based RTC\r\n");
    // Use timer interrupts at 1024 ms to increment RTC.
    rd_status_t err_code = RD_SUCCESS;
 
    if (!ri_timer_is_init())
    {
        err_code = ri_timer_init();
    }
 
    if (NULL == counter_timer)
    {
        err_code |= ri_timer_create (&counter_timer,
                                     RI_TIMER_MODE_REPEATED,
                                     counter_handler);
    }
 
    err_code |= ri_timer_start (counter_timer, DUMMY_RTC_INTERVAL, NULL);
    return (RD_SUCCESS == err_code) ? RD_SUCCESS :
           RD_ERROR_NOT_SUPPORTED;
}
 
rd_status_t ri_rtc_uninit (void)
{
    m_dummy = 0;
 
    if (NULL != counter_timer)  { ri_timer_stop (counter_timer); }
 
    return RD_SUCCESS;
}
 
uint64_t ri_rtc_millis (void)
{
    return m_dummy++;
}
 
// If timer is not available, use plain counter.
#else
// TODO
#endif
#endif