212 lines
6.9 KiB
C
212 lines
6.9 KiB
C
/**
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2018 Infineon Technologies AG
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE
|
|
*
|
|
*
|
|
* \file
|
|
*
|
|
* \brief This file implements the platform abstraction layer APIs for os event/scheduler.
|
|
*
|
|
* \addtogroup grPAL
|
|
* @{
|
|
*/
|
|
|
|
/**********************************************************************************************************************
|
|
* HEADER FILES
|
|
*********************************************************************************************************************/
|
|
#include <stdbool.h>
|
|
#include "stdlib.h"
|
|
#include "stdio.h"
|
|
#include "optiga/pal/pal_os_event.h"
|
|
#include "nrf_rtc.h"
|
|
#include "nrf_drv_rtc.h"
|
|
#include "nrf_delay.h"
|
|
#include "nrf_pwr_mgmt.h"
|
|
|
|
/**********************************************************************************************************************
|
|
* MACROS
|
|
*********************************************************************************************************************/
|
|
|
|
/*********************************************************************************************************************
|
|
* LOCAL DATA
|
|
*********************************************************************************************************************/
|
|
/// @cond hidden
|
|
/// Callback function when timer elapses
|
|
static volatile register_callback callback_registered = NULL;
|
|
/// Pointer to store upper layer callback context (For example: Ifx i2c context)
|
|
static void * callback_ctx;
|
|
/// Flag to indicate to the delay function when the timer has elapsed
|
|
static volatile bool timer_elapsed = false;
|
|
|
|
/// Flag to indicate if the the RTC was already initialized, re-init. causes an NRF_ERROR
|
|
static bool m_rtc2_is_initialized = false;
|
|
static const nrf_drv_rtc_t rtc2 = NRF_DRV_RTC_INSTANCE(2);
|
|
static nrf_drv_rtc_config_t m_rtc2_config = NRF_DRV_RTC_DEFAULT_CONFIG;
|
|
#define RTC_CLOCK_FREQUENCY 32768
|
|
// Set the prescaler to approximately get 0.25 ms intervals
|
|
// 32768Hz/8 = 4096 Hz -> 0.2441us
|
|
// it's a 24bit counter, so it will overflow every ~68min
|
|
#define RTC_PRESCALER 8
|
|
#define RTC_TICK_FREQ (RTC_CLOCK_FREQUENCY/RTC_PRESCALER)
|
|
|
|
/**
|
|
* Timer callback handler.
|
|
*
|
|
* This get called from the TIMER elapse event.<br>
|
|
* Once the timer expires, the registered callback funtion gets called from the timer event handler, if
|
|
* the call back is not NULL.<br>
|
|
*
|
|
*\param[in] args Callback argument
|
|
*
|
|
*/
|
|
static void ifx_rtc_handler(nrf_drv_rtc_int_type_t int_type)
|
|
{
|
|
volatile register_callback callback;
|
|
(void)nrf_drv_rtc_cc_disable(&rtc2, int_type);
|
|
switch(int_type)
|
|
{
|
|
case NRF_DRV_RTC_INT_COMPARE0:
|
|
// handler for register_callback_oneshot
|
|
if (callback_registered != NULL)
|
|
{
|
|
callback = callback_registered;
|
|
callback_registered = NULL;
|
|
callback(callback_ctx);
|
|
}
|
|
|
|
break;
|
|
case NRF_DRV_RTC_INT_COMPARE1:
|
|
// handler for delay_in_milliseconds
|
|
timer_elapsed = true;
|
|
break;
|
|
default:
|
|
// Do nothing
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// @endcond
|
|
|
|
void pal_os_event_init()
|
|
{
|
|
if (m_rtc2_is_initialized == true)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// set prescaler so that a tick is approximately 1ms
|
|
m_rtc2_config.prescaler = RTC_PRESCALER;
|
|
|
|
// Initialize the RTC2 driver instance
|
|
APP_ERROR_CHECK(nrf_drv_rtc_init(&rtc2, &m_rtc2_config, ifx_rtc_handler));
|
|
|
|
// Power on RTC instance
|
|
nrf_drv_rtc_enable(&rtc2);
|
|
|
|
m_rtc2_is_initialized = true;
|
|
}
|
|
|
|
/**
|
|
* Platform specific event call back registration function to trigger once when timer expires.
|
|
* <br>
|
|
*
|
|
* <b>API Details:</b>
|
|
* This function registers the callback function supplied by the caller.<br>
|
|
* It triggers a timer with the supplied time interval in microseconds.<br>
|
|
* Once the timer expires, the registered callback function gets called.<br>
|
|
*
|
|
* \param[in] callback Callback function pointer
|
|
* \param[in] callback_args Callback arguments
|
|
* \param[in] time_us time in micro seconds to trigger the call back
|
|
*
|
|
*/
|
|
void pal_os_event_register_callback_oneshot(register_callback callback,
|
|
void* callback_args,
|
|
uint32_t time_us)
|
|
{
|
|
callback_registered = callback;
|
|
callback_ctx = callback_args;
|
|
|
|
// parentheses are set this way to avoid overflow when multiplying time_us with something
|
|
uint32_t future_ticks = (time_us/(1000*1000/RTC_TICK_FREQ));
|
|
|
|
// we can't reliably set an interrupt less than two ticks ahead, as per NRF52832 datasheet, p. 245
|
|
// do busy waiting instead
|
|
if(future_ticks < 2) {
|
|
nrf_delay_us(time_us);
|
|
ifx_rtc_handler(NRF_DRV_RTC_INT_COMPARE0);
|
|
return;
|
|
}
|
|
|
|
// add current tick value
|
|
future_ticks += nrf_drv_rtc_counter_get(&rtc2);
|
|
|
|
// Set the compare register to trigger approximately at time_us
|
|
APP_ERROR_CHECK(nrf_drv_rtc_cc_set(&rtc2, NRF_DRV_RTC_INT_COMPARE0, future_ticks, true));
|
|
}
|
|
|
|
/**
|
|
* Get the current time in milliseconds<br>
|
|
*
|
|
*
|
|
* \retval uint32_t time in milliseconds
|
|
*/
|
|
uint32_t pal_os_timer_get_time_in_milliseconds(void)
|
|
{
|
|
return nrf_drv_rtc_counter_get(&rtc2)*1000/RTC_TICK_FREQ;
|
|
}
|
|
|
|
/**
|
|
* Function to wait or delay until the given milliseconds time
|
|
*
|
|
* \param[in] milliseconds Delay value in milliseconds
|
|
*
|
|
*/
|
|
void pal_os_timer_delay_in_milliseconds(uint16_t milliseconds)
|
|
{
|
|
timer_elapsed = false;
|
|
uint32_t future_ticks = milliseconds*(RTC_TICK_FREQ/1000);
|
|
|
|
// we can't reliably set an interrupt less than two ticks ahead, as per NRF52832 datasheet, p. 245
|
|
// do busy waiting instead
|
|
if(future_ticks < 2) {
|
|
nrf_delay_ms(milliseconds);
|
|
return;
|
|
}
|
|
|
|
// add current tick value
|
|
future_ticks += nrf_drv_rtc_counter_get(&rtc2);
|
|
|
|
// Set the compare register to trigger in approximately milliseconds
|
|
APP_ERROR_CHECK(nrf_drv_rtc_cc_set(&rtc2, NRF_DRV_RTC_INT_COMPARE1, future_ticks, true));
|
|
while(!timer_elapsed)
|
|
{
|
|
nrf_pwr_mgmt_run();
|
|
}
|
|
timer_elapsed = false;
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|