mirror of https://github.com/ARMmbed/mbed-os.git
Remove app_timer and dependencies instead of adding a dependency to RTX.
Vincent Coubard
parent
ea0ae68c60
commit
847d0f6764
|
|
@ -1,350 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2012 Nordic Semiconductor ASA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list
|
||||
* of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form, except as embedded into a Nordic Semiconductor ASA
|
||||
* integrated circuit in a product or a software update for such product, must reproduce
|
||||
* the above copyright notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software without specific prior
|
||||
* written permission.
|
||||
*
|
||||
* 4. This software, with or without modification, must only be used with a
|
||||
* Nordic Semiconductor ASA integrated circuit.
|
||||
*
|
||||
* 5. Any software provided in binary or object form under this license must not be reverse
|
||||
* engineered, decompiled, modified and/or disassembled.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include "ble_conn_params.h"
|
||||
#include <stdlib.h>
|
||||
#include "nordic_common.h"
|
||||
#include "nrf_ble_hci.h"
|
||||
#include "app_timer.h"
|
||||
#include "ble_srv_common.h"
|
||||
#include "app_util.h"
|
||||
|
||||
|
||||
static ble_conn_params_init_t m_conn_params_config; /**< Configuration as specified by the application. */
|
||||
static ble_gap_conn_params_t m_preferred_conn_params; /**< Connection parameters preferred by the application. */
|
||||
static uint8_t m_update_count; /**< Number of Connection Parameter Update messages that has currently been sent. */
|
||||
static uint16_t m_conn_handle; /**< Current connection handle. */
|
||||
static ble_gap_conn_params_t m_current_conn_params; /**< Connection parameters received in the most recent Connect event. */
|
||||
APP_TIMER_DEF(m_conn_params_timer_id); /**< Connection parameters timer. */
|
||||
|
||||
static bool m_change_param = false;
|
||||
|
||||
static bool is_conn_params_ok(ble_gap_conn_params_t * p_conn_params)
|
||||
{
|
||||
// Check if interval is within the acceptable range.
|
||||
// NOTE: Using max_conn_interval in the received event data because this contains
|
||||
// the client's connection interval.
|
||||
if (
|
||||
(p_conn_params->max_conn_interval >= m_preferred_conn_params.min_conn_interval)
|
||||
&&
|
||||
(p_conn_params->max_conn_interval <= m_preferred_conn_params.max_conn_interval)
|
||||
)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void update_timeout_handler(void * p_context)
|
||||
{
|
||||
UNUSED_PARAMETER(p_context);
|
||||
|
||||
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
|
||||
{
|
||||
// Check if we have reached the maximum number of attempts
|
||||
m_update_count++;
|
||||
if (m_update_count <= m_conn_params_config.max_conn_params_update_count)
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
// Parameters are not ok, send connection parameters update request.
|
||||
err_code = sd_ble_gap_conn_param_update(m_conn_handle, &m_preferred_conn_params);
|
||||
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
|
||||
{
|
||||
m_conn_params_config.error_handler(err_code);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_update_count = 0;
|
||||
|
||||
// Negotiation failed, disconnect automatically if this has been configured
|
||||
if (m_conn_params_config.disconnect_on_fail)
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
|
||||
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
|
||||
{
|
||||
m_conn_params_config.error_handler(err_code);
|
||||
}
|
||||
}
|
||||
|
||||
// Notify the application that the procedure has failed
|
||||
if (m_conn_params_config.evt_handler != NULL)
|
||||
{
|
||||
ble_conn_params_evt_t evt;
|
||||
|
||||
evt.evt_type = BLE_CONN_PARAMS_EVT_FAILED;
|
||||
m_conn_params_config.evt_handler(&evt);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32_t ble_conn_params_init(const ble_conn_params_init_t * p_init)
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
m_conn_params_config = *p_init;
|
||||
m_change_param = false;
|
||||
if (p_init->p_conn_params != NULL)
|
||||
{
|
||||
m_preferred_conn_params = *p_init->p_conn_params;
|
||||
|
||||
// Set the connection params in stack
|
||||
err_code = sd_ble_gap_ppcp_set(&m_preferred_conn_params);
|
||||
if (err_code != NRF_SUCCESS)
|
||||
{
|
||||
return err_code;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Fetch the connection params from stack
|
||||
err_code = sd_ble_gap_ppcp_get(&m_preferred_conn_params);
|
||||
if (err_code != NRF_SUCCESS)
|
||||
{
|
||||
return err_code;
|
||||
}
|
||||
}
|
||||
|
||||
m_conn_handle = BLE_CONN_HANDLE_INVALID;
|
||||
m_update_count = 0;
|
||||
|
||||
return app_timer_create(&m_conn_params_timer_id,
|
||||
APP_TIMER_MODE_SINGLE_SHOT,
|
||||
update_timeout_handler);
|
||||
}
|
||||
|
||||
|
||||
uint32_t ble_conn_params_stop(void)
|
||||
{
|
||||
return app_timer_stop(m_conn_params_timer_id);
|
||||
}
|
||||
|
||||
|
||||
static void conn_params_negotiation(void)
|
||||
{
|
||||
// Start negotiation if the received connection parameters are not acceptable
|
||||
if (!is_conn_params_ok(&m_current_conn_params))
|
||||
{
|
||||
uint32_t err_code;
|
||||
uint32_t timeout_ticks;
|
||||
|
||||
if (m_change_param)
|
||||
{
|
||||
// Notify the application that the procedure has failed
|
||||
if (m_conn_params_config.evt_handler != NULL)
|
||||
{
|
||||
ble_conn_params_evt_t evt;
|
||||
|
||||
evt.evt_type = BLE_CONN_PARAMS_EVT_FAILED;
|
||||
m_conn_params_config.evt_handler(&evt);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_update_count == 0)
|
||||
{
|
||||
// First connection parameter update
|
||||
timeout_ticks = m_conn_params_config.first_conn_params_update_delay;
|
||||
}
|
||||
else
|
||||
{
|
||||
timeout_ticks = m_conn_params_config.next_conn_params_update_delay;
|
||||
}
|
||||
|
||||
err_code = app_timer_start(m_conn_params_timer_id, timeout_ticks, NULL);
|
||||
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
|
||||
{
|
||||
m_conn_params_config.error_handler(err_code);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Notify the application that the procedure has succeded
|
||||
if (m_conn_params_config.evt_handler != NULL)
|
||||
{
|
||||
ble_conn_params_evt_t evt;
|
||||
|
||||
evt.evt_type = BLE_CONN_PARAMS_EVT_SUCCEEDED;
|
||||
m_conn_params_config.evt_handler(&evt);
|
||||
}
|
||||
}
|
||||
m_change_param = false;
|
||||
}
|
||||
|
||||
|
||||
static void on_connect(ble_evt_t * p_ble_evt)
|
||||
{
|
||||
// Save connection parameters
|
||||
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||||
m_current_conn_params = p_ble_evt->evt.gap_evt.params.connected.conn_params;
|
||||
m_update_count = 0; // Connection parameter negotiation should re-start every connection
|
||||
|
||||
// Check if we shall handle negotiation on connect
|
||||
if (m_conn_params_config.start_on_notify_cccd_handle == BLE_GATT_HANDLE_INVALID)
|
||||
{
|
||||
conn_params_negotiation();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void on_disconnect(ble_evt_t * p_ble_evt)
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
m_conn_handle = BLE_CONN_HANDLE_INVALID;
|
||||
|
||||
// Stop timer if running
|
||||
m_update_count = 0; // Connection parameters updates should happen during every connection
|
||||
|
||||
err_code = app_timer_stop(m_conn_params_timer_id);
|
||||
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
|
||||
{
|
||||
m_conn_params_config.error_handler(err_code);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void on_write(ble_evt_t * p_ble_evt)
|
||||
{
|
||||
ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
|
||||
|
||||
// Check if this the correct CCCD
|
||||
if (
|
||||
(p_evt_write->handle == m_conn_params_config.start_on_notify_cccd_handle)
|
||||
&&
|
||||
(p_evt_write->len == 2)
|
||||
)
|
||||
{
|
||||
// Check if this is a 'start notification'
|
||||
if (ble_srv_is_notification_enabled(p_evt_write->data))
|
||||
{
|
||||
// Do connection parameter negotiation if necessary
|
||||
conn_params_negotiation();
|
||||
}
|
||||
else
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
// Stop timer if running
|
||||
err_code = app_timer_stop(m_conn_params_timer_id);
|
||||
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
|
||||
{
|
||||
m_conn_params_config.error_handler(err_code);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void on_conn_params_update(ble_evt_t * p_ble_evt)
|
||||
{
|
||||
// Copy the parameters
|
||||
m_current_conn_params = p_ble_evt->evt.gap_evt.params.conn_param_update.conn_params;
|
||||
|
||||
conn_params_negotiation();
|
||||
}
|
||||
|
||||
|
||||
void ble_conn_params_on_ble_evt(ble_evt_t * p_ble_evt)
|
||||
{
|
||||
switch (p_ble_evt->header.evt_id)
|
||||
{
|
||||
case BLE_GAP_EVT_CONNECTED:
|
||||
on_connect(p_ble_evt);
|
||||
break;
|
||||
|
||||
case BLE_GAP_EVT_DISCONNECTED:
|
||||
on_disconnect(p_ble_evt);
|
||||
break;
|
||||
|
||||
case BLE_GATTS_EVT_WRITE:
|
||||
on_write(p_ble_evt);
|
||||
break;
|
||||
|
||||
case BLE_GAP_EVT_CONN_PARAM_UPDATE:
|
||||
on_conn_params_update(p_ble_evt);
|
||||
break;
|
||||
|
||||
default:
|
||||
// No implementation needed.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32_t ble_conn_params_change_conn_params(ble_gap_conn_params_t * new_params)
|
||||
{
|
||||
uint32_t err_code;
|
||||
|
||||
m_preferred_conn_params = *new_params;
|
||||
// Set the connection params in stack
|
||||
err_code = sd_ble_gap_ppcp_set(&m_preferred_conn_params);
|
||||
if (err_code == NRF_SUCCESS)
|
||||
{
|
||||
if (!is_conn_params_ok(&m_current_conn_params))
|
||||
{
|
||||
m_change_param = true;
|
||||
err_code = sd_ble_gap_conn_param_update(m_conn_handle, &m_preferred_conn_params);
|
||||
m_update_count = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Notify the application that the procedure has succeded
|
||||
if (m_conn_params_config.evt_handler != NULL)
|
||||
{
|
||||
ble_conn_params_evt_t evt;
|
||||
|
||||
evt.evt_type = BLE_CONN_PARAMS_EVT_SUCCEEDED;
|
||||
m_conn_params_config.evt_handler(&evt);
|
||||
}
|
||||
err_code = NRF_SUCCESS;
|
||||
}
|
||||
}
|
||||
return err_code;
|
||||
}
|
||||
|
|
@ -1,314 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2012 Nordic Semiconductor ASA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list
|
||||
* of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form, except as embedded into a Nordic Semiconductor ASA
|
||||
* integrated circuit in a product or a software update for such product, must reproduce
|
||||
* the above copyright notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software without specific prior
|
||||
* written permission.
|
||||
*
|
||||
* 4. This software, with or without modification, must only be used with a
|
||||
* Nordic Semiconductor ASA integrated circuit.
|
||||
*
|
||||
* 5. Any software provided in binary or object form under this license must not be reverse
|
||||
* engineered, decompiled, modified and/or disassembled.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/** @file
|
||||
*
|
||||
* @defgroup app_timer Application Timer
|
||||
* @{
|
||||
* @ingroup app_common
|
||||
*
|
||||
* @brief Application timer functionality.
|
||||
*
|
||||
* @details This module enables the application to create multiple timer instances based on the RTC1
|
||||
* peripheral. Checking for time-outs and invokation of user time-out handlers is performed
|
||||
* in the RTC1 interrupt handler. List handling is done using a software interrupt (SWI0).
|
||||
* Both interrupt handlers are running in APP_LOW priority level.
|
||||
*
|
||||
* @details When calling app_timer_start() or app_timer_stop(), the timer operation is just queued,
|
||||
* and the software interrupt is triggered. The actual timer start/stop operation is
|
||||
* executed by the SWI0 interrupt handler. Since the SWI0 interrupt is running in APP_LOW,
|
||||
* if the application code calling the timer function is running in APP_LOW or APP_HIGH,
|
||||
* the timer operation will not be performed until the application handler has returned.
|
||||
* This will be the case, for example, when stopping a timer from a time-out handler when not using
|
||||
* the scheduler.
|
||||
*
|
||||
* @details Use the USE_SCHEDULER parameter of the APP_TIMER_INIT() macro to select if the
|
||||
* @ref app_scheduler should be used or not. Even if the scheduler is
|
||||
* not used, app_timer.h will include app_scheduler.h, so when
|
||||
* compiling, app_scheduler.h must be available in one of the compiler include paths.
|
||||
*/
|
||||
|
||||
#ifndef APP_TIMER_H__
|
||||
#define APP_TIMER_H__
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include "app_error.h"
|
||||
#include "app_util.h"
|
||||
#include "compiler_abstraction.h"
|
||||
|
||||
#define APP_TIMER_CLOCK_FREQ 32768 /**< Clock frequency of the RTC timer used to implement the app timer module. */
|
||||
#define APP_TIMER_MIN_TIMEOUT_TICKS 5 /**< Minimum value of the timeout_ticks parameter of app_timer_start(). */
|
||||
|
||||
#define APP_TIMER_NODE_SIZE 32 /**< Size of app_timer.timer_node_t (used to allocate data). */
|
||||
#define APP_TIMER_USER_OP_SIZE 24 /**< Size of app_timer.timer_user_op_t (only for use inside APP_TIMER_BUF_SIZE()). */
|
||||
#define APP_TIMER_USER_SIZE 8 /**< Size of app_timer.timer_user_t (only for use inside APP_TIMER_BUF_SIZE()). */
|
||||
#define APP_TIMER_INT_LEVELS 3 /**< Number of interrupt levels from where timer operations may be initiated (only for use inside APP_TIMER_BUF_SIZE()). */
|
||||
|
||||
/**@brief Compute number of bytes required to hold the application timer data structures.
|
||||
*
|
||||
* @param[in] OP_QUEUE_SIZE Size of queues holding timer operations that are pending execution.
|
||||
* Note that due to the queue implementation, this size must be one more
|
||||
* than the size that is actually needed.
|
||||
*
|
||||
* @return Required application timer buffer size (in bytes).
|
||||
*/
|
||||
#define APP_TIMER_BUF_SIZE(OP_QUEUE_SIZE) \
|
||||
( \
|
||||
( \
|
||||
APP_TIMER_INT_LEVELS \
|
||||
* \
|
||||
(APP_TIMER_USER_SIZE + ((OP_QUEUE_SIZE) + 1) * APP_TIMER_USER_OP_SIZE) \
|
||||
) \
|
||||
)
|
||||
|
||||
/**@brief Convert milliseconds to timer ticks.
|
||||
*
|
||||
* This macro uses 64-bit integer arithmetic, but as long as the macro parameters are
|
||||
* constants (i.e. defines), the computation will be done by the preprocessor.
|
||||
*
|
||||
* When using this macro, ensure that the
|
||||
* values provided as input result in an output value that is supported by the
|
||||
* @ref app_timer_start function. For example, when the ticks for 1 ms is needed, the
|
||||
* maximum possible value of PRESCALER must be 6, when @ref APP_TIMER_CLOCK_FREQ is 32768.
|
||||
* This will result in a ticks value as 5. Any higher value for PRESCALER will result in a
|
||||
* ticks value that is not supported by this module.
|
||||
*
|
||||
* @param[in] MS Milliseconds.
|
||||
* @param[in] PRESCALER Value of the RTC1 PRESCALER register (must be the same value that was
|
||||
* passed to APP_TIMER_INIT()).
|
||||
*
|
||||
* @return Number of timer ticks.
|
||||
*/
|
||||
#define APP_TIMER_TICKS(MS, PRESCALER)\
|
||||
((uint32_t)ROUNDED_DIV((MS) * (uint64_t)APP_TIMER_CLOCK_FREQ, ((PRESCALER) + 1) * 1000))
|
||||
|
||||
typedef struct app_timer_t { uint32_t data[CEIL_DIV(APP_TIMER_NODE_SIZE, sizeof(uint32_t))]; } app_timer_t;
|
||||
|
||||
/**@brief Timer ID type.
|
||||
* Never declare a variable of this type, but use the macro @ref APP_TIMER_DEF instead.*/
|
||||
typedef app_timer_t * app_timer_id_t;
|
||||
|
||||
/**
|
||||
* @brief Create a timer identifier and statically allocate memory for the timer.
|
||||
*
|
||||
* @param timer_id Name of the timer identifier variable that will be used to control the timer.
|
||||
*/
|
||||
#define APP_TIMER_DEF(timer_id) \
|
||||
static app_timer_t timer_id##_data = { {0} }; \
|
||||
static const app_timer_id_t timer_id = &timer_id##_data
|
||||
|
||||
|
||||
/**@brief Application time-out handler type. */
|
||||
typedef void (*app_timer_timeout_handler_t)(void * p_context);
|
||||
|
||||
/**@brief Type of function for passing events from the timer module to the scheduler. */
|
||||
typedef uint32_t (*app_timer_evt_schedule_func_t) (app_timer_timeout_handler_t timeout_handler,
|
||||
void * p_context);
|
||||
|
||||
/**@brief Timer modes. */
|
||||
typedef enum
|
||||
{
|
||||
APP_TIMER_MODE_SINGLE_SHOT, /**< The timer will expire only once. */
|
||||
APP_TIMER_MODE_REPEATED /**< The timer will restart each time it expires. */
|
||||
} app_timer_mode_t;
|
||||
|
||||
/**@brief Initialize the application timer module.
|
||||
*
|
||||
* @details This macro handles dimensioning and allocation of the memory buffer required by the timer,
|
||||
* making sure that the buffer is correctly aligned. It will also connect the timer module
|
||||
* to the scheduler (if specified).
|
||||
*
|
||||
* @note This module assumes that the LFCLK is already running. If it is not, the module will
|
||||
* be non-functional, since the RTC will not run. If you do not use a SoftDevice, you
|
||||
* must start the LFCLK manually. See the rtc_example's lfclk_config() function
|
||||
* for an example of how to do this. If you use a SoftDevice, the LFCLK is started on
|
||||
* SoftDevice init.
|
||||
*
|
||||
*
|
||||
* @param[in] PRESCALER Value of the RTC1 PRESCALER register. This will decide the
|
||||
* timer tick rate. Set to 0 for no prescaling.
|
||||
* @param[in] OP_QUEUES_SIZE Size of queues holding timer operations that are pending execution.
|
||||
* @param[in] SCHEDULER_FUNC Pointer to scheduler event handler
|
||||
*
|
||||
* @note Since this macro allocates a buffer, it must only be called once (it is OK to call it
|
||||
* several times as long as it is from the same location, for example, to do a re-initialization).
|
||||
*/
|
||||
/*lint -emacro(506, APP_TIMER_INIT) */ /* Suppress "Constant value Boolean */
|
||||
#define APP_TIMER_INIT(PRESCALER, OP_QUEUES_SIZE, SCHEDULER_FUNC) \
|
||||
do \
|
||||
{ \
|
||||
static uint32_t APP_TIMER_BUF[CEIL_DIV(APP_TIMER_BUF_SIZE((OP_QUEUES_SIZE) + 1), \
|
||||
sizeof(uint32_t))]; \
|
||||
uint32_t ERR_CODE = app_timer_init((PRESCALER), \
|
||||
(OP_QUEUES_SIZE) + 1, \
|
||||
APP_TIMER_BUF, \
|
||||
SCHEDULER_FUNC); \
|
||||
APP_ERROR_CHECK(ERR_CODE); \
|
||||
} while (0)
|
||||
|
||||
|
||||
|
||||
/**@brief Function for initializing the timer module.
|
||||
*
|
||||
* Normally, initialization should be done using the APP_TIMER_INIT() macro, because that macro will both
|
||||
* allocate the buffers needed by the timer module (including aligning the buffers correctly)
|
||||
* and take care of connecting the timer module to the scheduler (if specified).
|
||||
*
|
||||
* @param[in] prescaler Value of the RTC1 PRESCALER register. Set to 0 for no prescaling.
|
||||
* @param[in] op_queues_size Size of queues holding timer operations that are pending
|
||||
* execution. Note that due to the queue implementation, this size must
|
||||
* be one more than the size that is actually needed.
|
||||
* @param[in] p_buffer Pointer to memory buffer for internal use in the app_timer
|
||||
* module. The size of the buffer can be computed using the
|
||||
* APP_TIMER_BUF_SIZE() macro. The buffer must be aligned to a
|
||||
* 4 byte boundary.
|
||||
* @param[in] evt_schedule_func Function for passing time-out events to the scheduler. Point to
|
||||
* app_timer_evt_schedule() to connect to the scheduler. Set to NULL
|
||||
* to make the timer module call the time-out handler directly from
|
||||
* the timer interrupt handler.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the module was initialized successfully.
|
||||
* @retval NRF_ERROR_INVALID_PARAM If a parameter was invalid (buffer not aligned to a 4 byte
|
||||
* boundary or NULL).
|
||||
*/
|
||||
uint32_t app_timer_init(uint32_t prescaler,
|
||||
uint8_t op_queues_size,
|
||||
void * p_buffer,
|
||||
app_timer_evt_schedule_func_t evt_schedule_func);
|
||||
|
||||
/**@brief Function for creating a timer instance.
|
||||
*
|
||||
* @param[in] p_timer_id Pointer to timer identifier.
|
||||
* @param[in] mode Timer mode.
|
||||
* @param[in] timeout_handler Function to be executed when the timer expires.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the timer was successfully created.
|
||||
* @retval NRF_ERROR_INVALID_PARAM If a parameter was invalid.
|
||||
* @retval NRF_ERROR_INVALID_STATE If the application timer module has not been initialized or
|
||||
* the timer is running.
|
||||
*
|
||||
* @note This function does the timer allocation in the caller's context. It is also not protected
|
||||
* by a critical region. Therefore care must be taken not to call it from several interrupt
|
||||
* levels simultaneously.
|
||||
* @note The function can be called again on the timer instance and will re-initialize the instance if
|
||||
* the timer is not running.
|
||||
* @attention The FreeRTOS and RTX app_timer implementation does not allow app_timer_create to
|
||||
* be called on the previously initialized instance.
|
||||
*/
|
||||
uint32_t app_timer_create(app_timer_id_t const * p_timer_id,
|
||||
app_timer_mode_t mode,
|
||||
app_timer_timeout_handler_t timeout_handler);
|
||||
|
||||
/**@brief Function for starting a timer.
|
||||
*
|
||||
* @param[in] timer_id Timer identifier.
|
||||
* @param[in] timeout_ticks Number of ticks (of RTC1, including prescaling) to time-out event
|
||||
* (minimum 5 ticks).
|
||||
* @param[in] p_context General purpose pointer. Will be passed to the time-out handler when
|
||||
* the timer expires.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the timer was successfully started.
|
||||
* @retval NRF_ERROR_INVALID_PARAM If a parameter was invalid.
|
||||
* @retval NRF_ERROR_INVALID_STATE If the application timer module has not been initialized or the timer
|
||||
* has not been created.
|
||||
* @retval NRF_ERROR_NO_MEM If the timer operations queue was full.
|
||||
*
|
||||
* @note The minimum timeout_ticks value is 5.
|
||||
* @note For multiple active timers, time-outs occurring in close proximity to each other (in the
|
||||
* range of 1 to 3 ticks) will have a positive jitter of maximum 3 ticks.
|
||||
* @note When calling this method on a timer that is already running, the second start operation
|
||||
* is ignored.
|
||||
*/
|
||||
uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context);
|
||||
|
||||
/**@brief Function for stopping the specified timer.
|
||||
*
|
||||
* @param[in] timer_id Timer identifier.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the timer was successfully stopped.
|
||||
* @retval NRF_ERROR_INVALID_PARAM If a parameter was invalid.
|
||||
* @retval NRF_ERROR_INVALID_STATE If the application timer module has not been initialized or the timer
|
||||
* has not been created.
|
||||
* @retval NRF_ERROR_NO_MEM If the timer operations queue was full.
|
||||
*/
|
||||
uint32_t app_timer_stop(app_timer_id_t timer_id);
|
||||
|
||||
/**@brief Function for stopping all running timers.
|
||||
*
|
||||
* @retval NRF_SUCCESS If all timers were successfully stopped.
|
||||
* @retval NRF_ERROR_INVALID_STATE If the application timer module has not been initialized.
|
||||
* @retval NRF_ERROR_NO_MEM If the timer operations queue was full.
|
||||
*/
|
||||
uint32_t app_timer_stop_all(void);
|
||||
|
||||
/**@brief Function for returning the current value of the RTC1 counter.
|
||||
*
|
||||
* @param[out] p_ticks Current value of the RTC1 counter.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the counter was successfully read.
|
||||
*/
|
||||
uint32_t app_timer_cnt_get(uint32_t * p_ticks);
|
||||
|
||||
/**@brief Function for computing the difference between two RTC1 counter values.
|
||||
*
|
||||
* @param[in] ticks_to Value returned by app_timer_cnt_get().
|
||||
* @param[in] ticks_from Value returned by app_timer_cnt_get().
|
||||
* @param[out] p_ticks_diff Number of ticks from ticks_from to ticks_to.
|
||||
*
|
||||
* @retval NRF_SUCCESS If the counter difference was successfully computed.
|
||||
*/
|
||||
uint32_t app_timer_cnt_diff_compute(uint32_t ticks_to,
|
||||
uint32_t ticks_from,
|
||||
uint32_t * p_ticks_diff);
|
||||
|
||||
#ifdef APP_TIMER_WITH_PROFILER
|
||||
/**@brief Function for getting the maximum observed operation queue utilization.
|
||||
*
|
||||
* Function for tuning the module and determining OP_QUEUE_SIZE value and thus module RAM usage.
|
||||
*
|
||||
* @return Maximum number of events in queue observed so far.
|
||||
*/
|
||||
uint16_t app_timer_op_queue_utilization_get(void);
|
||||
#endif
|
||||
|
||||
#endif // APP_TIMER_H__
|
||||
|
||||
/** @} */
|
||||
|
|
@ -1,239 +0,0 @@
|
|||
#include "app_timer.h"
|
||||
#include <stdlib.h>
|
||||
#include "nrf.h"
|
||||
#include "nrf_soc.h"
|
||||
#include "app_error.h"
|
||||
#include "app_util.h"
|
||||
#include "cmsis_os.h"
|
||||
#include "app_util_platform.h"
|
||||
|
||||
#define RTC1_IRQ_PRI APP_IRQ_PRIORITY_LOW /**< Priority of the RTC1 interrupt. */
|
||||
|
||||
#define MAX_RTC_COUNTER_VAL 0x00FFFFFF /**< Maximum value of the RTC counter. */
|
||||
|
||||
/**@brief This structure keeps information about osTimer.*/
|
||||
typedef struct
|
||||
{
|
||||
osTimerDef_t timerDef;
|
||||
uint32_t buffer[5];
|
||||
osTimerId id;
|
||||
}app_timer_info_t;
|
||||
|
||||
/**@brief Store an array of timers with configuration. */
|
||||
typedef struct
|
||||
{
|
||||
uint8_t max_timers; /**< The maximum number of timers*/
|
||||
uint32_t prescaler;
|
||||
app_timer_info_t * app_timers; /**< Pointer to table of timers*/
|
||||
}app_timer_control_t;
|
||||
app_timer_control_t app_timer_control;
|
||||
|
||||
/**@brief This structure is defined by RTX. It keeps information about created osTimers. It is used in app_timer_start(). */
|
||||
typedef struct os_timer_cb_
|
||||
{
|
||||
struct os_timer_cb_ * next;
|
||||
uint8_t state;
|
||||
uint8_t type;
|
||||
uint16_t reserved;
|
||||
uint16_t tcnt;
|
||||
uint16_t icnt;
|
||||
void * arg;
|
||||
const osTimerDef_t * timer;
|
||||
} os_timer_cb;
|
||||
|
||||
/**@brief This functions are defined by RTX.*/
|
||||
//lint --save -e10 -e19 -e526
|
||||
extern osStatus svcTimerStop(osTimerId timer_id); /**< Used in app_timer_stop(). */
|
||||
extern osStatus svcTimerStart(osTimerId timer_id, uint32_t millisec); /**< Used in app_timer_start(). */
|
||||
// lint --restore
|
||||
static void * rt_id2obj(void *id) /**< Used in app_timer_start(). This function gives information if osTimerID is valid */
|
||||
{
|
||||
|
||||
if ((uint32_t)id & 3)
|
||||
return NULL;
|
||||
|
||||
#ifdef OS_SECTIONS_LINK_INFO
|
||||
|
||||
if ((os_section_id$$Base != 0) && (os_section_id$$Limit != 0))
|
||||
{
|
||||
if (id < (void *)os_section_id$$Base)
|
||||
return NULL;
|
||||
|
||||
if (id >= (void *)os_section_id$$Limit)
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
|
||||
uint32_t app_timer_init(uint32_t prescaler,
|
||||
uint8_t op_queues_size,
|
||||
void * p_buffer,
|
||||
app_timer_evt_schedule_func_t evt_schedule_func)
|
||||
{
|
||||
if (p_buffer == NULL)
|
||||
{
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
app_timer_control.prescaler = prescaler;
|
||||
app_timer_control.app_timers = p_buffer;
|
||||
NVIC_SetPriority(RTC1_IRQn, RTC1_IRQ_PRI);
|
||||
|
||||
return NRF_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
uint32_t app_timer_create(app_timer_id_t const * p_timer_id,
|
||||
app_timer_mode_t mode,
|
||||
app_timer_timeout_handler_t timeout_handler)
|
||||
{
|
||||
|
||||
if ((timeout_handler == NULL) || (p_timer_id == NULL))
|
||||
{
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
app_timer_info_t * p_timer_info = (app_timer_info_t *)*p_timer_id;
|
||||
p_timer_info->timerDef.timer = p_timer_info->buffer;
|
||||
p_timer_info->timerDef.ptimer = (os_ptimer)timeout_handler;
|
||||
|
||||
p_timer_info->id = osTimerCreate(&(p_timer_info->timerDef), (os_timer_type)mode, NULL);
|
||||
|
||||
if (p_timer_info->id)
|
||||
return NRF_SUCCESS;
|
||||
else
|
||||
{
|
||||
return NRF_ERROR_INVALID_PARAM; // This error is unspecified by rtx
|
||||
}
|
||||
}
|
||||
|
||||
#define osTimerRunning 2
|
||||
uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context)
|
||||
{
|
||||
if ((timeout_ticks < APP_TIMER_MIN_TIMEOUT_TICKS))
|
||||
{
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
uint32_t timeout_ms =
|
||||
((uint32_t)ROUNDED_DIV(timeout_ticks * 1000 * (app_timer_control.prescaler + 1),
|
||||
(uint32_t)APP_TIMER_CLOCK_FREQ));
|
||||
|
||||
app_timer_info_t * p_timer_info = (app_timer_info_t *)timer_id;
|
||||
if (rt_id2obj((void *)p_timer_info->id) == NULL)
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
|
||||
// Pass p_context to timer_timeout_handler
|
||||
((os_timer_cb *)(p_timer_info->id))->arg = p_context;
|
||||
|
||||
if (((os_timer_cb *)(p_timer_info->id))->state == osTimerRunning)
|
||||
{
|
||||
return NRF_SUCCESS;
|
||||
}
|
||||
// osTimerStart() returns osErrorISR if it is called in interrupt routine.
|
||||
switch (osTimerStart((osTimerId)p_timer_info->id, timeout_ms) )
|
||||
{
|
||||
case osOK:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
case osErrorISR:
|
||||
break;
|
||||
|
||||
case osErrorParameter:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
|
||||
default:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
// Start timer without svcCall
|
||||
switch (svcTimerStart((osTimerId)p_timer_info->id, timeout_ms))
|
||||
{
|
||||
case osOK:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
case osErrorISR:
|
||||
return NRF_ERROR_INVALID_STATE;
|
||||
|
||||
case osErrorParameter:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
|
||||
default:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t app_timer_stop(app_timer_id_t timer_id)
|
||||
{
|
||||
app_timer_info_t * p_timer_info = (app_timer_info_t *)timer_id;
|
||||
switch (osTimerStop((osTimerId)p_timer_info->id) )
|
||||
{
|
||||
case osOK:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
case osErrorISR:
|
||||
break;
|
||||
|
||||
case osErrorParameter:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
|
||||
case osErrorResource:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
default:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
// Stop timer without svcCall
|
||||
switch (svcTimerStop((osTimerId)p_timer_info->id))
|
||||
{
|
||||
case osOK:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
case osErrorISR:
|
||||
return NRF_ERROR_INVALID_STATE;
|
||||
|
||||
case osErrorParameter:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
|
||||
case osErrorResource:
|
||||
return NRF_SUCCESS;
|
||||
|
||||
default:
|
||||
return NRF_ERROR_INVALID_PARAM;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32_t app_timer_stop_all(void)
|
||||
{
|
||||
for (int i = 0; i < app_timer_control.max_timers; i++)
|
||||
{
|
||||
if (app_timer_control.app_timers[i].id)
|
||||
{
|
||||
(void)app_timer_stop((app_timer_id_t)app_timer_control.app_timers[i].id);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
extern uint32_t os_tick_val(void);
|
||||
uint32_t app_timer_cnt_get(uint32_t * p_ticks)
|
||||
{
|
||||
*p_ticks = os_tick_val();
|
||||
return NRF_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
uint32_t app_timer_cnt_diff_compute(uint32_t ticks_to,
|
||||
uint32_t ticks_from,
|
||||
uint32_t * p_ticks_diff)
|
||||
{
|
||||
*p_ticks_diff = ((ticks_to - ticks_from) & MAX_RTC_COUNTER_VAL);
|
||||
return NRF_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue