xobs/simmel-bootloader
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add files from nrf52832 bootloader project

Browse Source
This commit is contained in:
hathach
2018-02-07 23:32:49 +07:00
parent ac1f0e7955
commit 9f1d9f321e
186 changed files with 83021 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_error.c Normal file
View File

@@ -0,0 +1,124 @@
/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @file
*
* @defgroup app_error Common application error handler
* @{
* @ingroup app_common
*
* @brief Common application error handler.
*/
#include "nrf.h"
#include <stdio.h>
#include "app_error.h"
#include "nordic_common.h"
#include "sdk_errors.h"
#include "nrf_log.h"
#ifdef DEBUG
#include "bsp.h"
#endif
/**@brief Function for error handling, which is called when an error has occurred.
*
* @warning This handler is an example only and does not fit a final product. You need to analyze
* how your product is supposed to react in case of error.
*
* @param[in] error_code Error code supplied to the handler.
* @param[in] line_num Line number where the handler is called.
* @param[in] p_file_name Pointer to the file name.
*/
/*lint -save -e14 */
void app_error_handler(ret_code_t error_code, uint32_t line_num, const uint8_t * p_file_name)
{
error_info_t error_info =
{
.line_num = line_num,
.p_file_name = p_file_name,
.err_code = error_code,
};
app_error_fault_handler(NRF_FAULT_ID_SDK_ERROR, 0, (uint32_t)(&error_info));
UNUSED_VARIABLE(error_info);
}
/*lint -save -e14 */
void app_error_handler_bare(ret_code_t error_code)
{
error_info_t error_info =
{
.line_num = 0,
.p_file_name = NULL,
.err_code = error_code,
};
app_error_fault_handler(NRF_FAULT_ID_SDK_ERROR, 0, (uint32_t)(&error_info));
UNUSED_VARIABLE(error_info);
}
void app_error_save_and_stop(uint32_t id, uint32_t pc, uint32_t info)
{
/* static error variables - in order to prevent removal by optimizers */
static volatile struct
{
uint32_t fault_id;
uint32_t pc;
uint32_t error_info;
assert_info_t * p_assert_info;
error_info_t * p_error_info;
ret_code_t err_code;
uint32_t line_num;
const uint8_t * p_file_name;
} m_error_data = {0};
// The following variable helps Keil keep the call stack visible, in addition, it can be set to
// 0 in the debugger to continue executing code after the error check.
volatile bool loop = true;
UNUSED_VARIABLE(loop);
m_error_data.fault_id = id;
m_error_data.pc = pc;
m_error_data.error_info = info;
switch (id)
{
case NRF_FAULT_ID_SDK_ASSERT:
m_error_data.p_assert_info = (assert_info_t *)info;
m_error_data.line_num = m_error_data.p_assert_info->line_num;
m_error_data.p_file_name = m_error_data.p_assert_info->p_file_name;
break;
case NRF_FAULT_ID_SDK_ERROR:
m_error_data.p_error_info = (error_info_t *)info;
m_error_data.err_code = m_error_data.p_error_info->err_code;
m_error_data.line_num = m_error_data.p_error_info->line_num;
m_error_data.p_file_name = m_error_data.p_error_info->p_file_name;
break;
}
UNUSED_VARIABLE(m_error_data);
// If printing is disrupted, remove the irq calls, or set the loop variable to 0 in the debugger.
__disable_irq();
while(loop);
__enable_irq();
}
/*lint -restore */

201
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_error.h Normal file
View File

@@ -0,0 +1,201 @@
/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @file
*
* @defgroup app_error Common application error handler
* @{
* @ingroup app_common
*
* @brief Common application error handler and macros for utilizing a common error handler.
*/
#ifndef APP_ERROR_H__
#define APP_ERROR_H__
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include "nrf.h"
#include "sdk_errors.h"
#include "nordic_common.h"
#include "nrf_log.h"
#include "app_error_weak.h"
#define NRF_FAULT_ID_SDK_RANGE_START 0x00004000 /**< The start of the range of error IDs defined in the SDK. */
/**@defgroup APP_ERROR_FAULT_IDS Fault ID types
* @{ */
#define NRF_FAULT_ID_SDK_ERROR NRF_FAULT_ID_SDK_RANGE_START + 1 /**< An error stemming from a call to @ref APP_ERROR_CHECK or @ref APP_ERROR_CHECK_BOOL. The info parameter is a pointer to an @ref error_info_t variable. */
#define NRF_FAULT_ID_SDK_ASSERT NRF_FAULT_ID_SDK_RANGE_START + 2 /**< An error stemming from a call to ASSERT (nrf_assert.h). The info parameter is a pointer to an @ref assert_info_t variable. */
/**@} */
/**@brief Structure containing info about an error of the type @ref NRF_FAULT_ID_SDK_ERROR.
*/
typedef struct
{
uint16_t line_num; /**< The line number where the error occurred. */
uint8_t const * p_file_name; /**< The file in which the error occurred. */
uint32_t err_code; /**< The error code representing the error that occurred. */
} error_info_t;
/**@brief Structure containing info about an error of the type @ref NRF_FAULT_ID_SDK_ASSERT.
*/
typedef struct
{
uint16_t line_num; /**< The line number where the error occurred. */
uint8_t const * p_file_name; /**< The file in which the error occurred. */
} assert_info_t;
/**@brief Function for error handling, which is called when an error has occurred.
*
* @param[in] error_code Error code supplied to the handler.
* @param[in] line_num Line number where the handler is called.
* @param[in] p_file_name Pointer to the file name.
*/
void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name);
/**@brief Function for error handling, which is called when an error has occurred.
*
* @param[in] error_code Error code supplied to the handler.
*/
void app_error_handler_bare(ret_code_t error_code);
/**@brief Function for saving the parameters and entering an eternal loop, for debug purposes.
*
* @param[in] id Fault identifier. See @ref NRF_FAULT_IDS.
* @param[in] pc The program counter of the instruction that triggered the fault, or 0 if
* unavailable.
* @param[in] info Optional additional information regarding the fault. Refer to each fault
* identifier for details.
*/
void app_error_save_and_stop(uint32_t id, uint32_t pc, uint32_t info);
/**@brief Function for printing all error info (using nrf_log).
*
* @details Nrf_log library must be initialized using NRF_LOG_INIT macro before calling
* this function.
*
* @param[in] id Fault identifier. See @ref NRF_FAULT_IDS.
* @param[in] pc The program counter of the instruction that triggered the fault, or 0 if
* unavailable.
* @param[in] info Optional additional information regarding the fault. Refer to each fault
* identifier for details.
*/
static __INLINE void app_error_log(uint32_t id, uint32_t pc, uint32_t info)
{
switch (id)
{
case NRF_FAULT_ID_SDK_ASSERT:
NRF_LOG(NRF_LOG_COLOR_RED "\n*** ASSERTION FAILED ***\n");
if (((assert_info_t *)(info))->p_file_name)
{
NRF_LOG_PRINTF(NRF_LOG_COLOR_WHITE "Line Number: %u\n", (unsigned int) ((assert_info_t *)(info))->line_num);
NRF_LOG_PRINTF("File Name: %s\n", ((assert_info_t *)(info))->p_file_name);
}
NRF_LOG_PRINTF(NRF_LOG_COLOR_DEFAULT "\n");
break;
case NRF_FAULT_ID_SDK_ERROR:
NRF_LOG(NRF_LOG_COLOR_RED "\n*** APPLICATION ERROR *** \n" NRF_LOG_COLOR_WHITE);
if (((error_info_t *)(info))->p_file_name)
{
NRF_LOG_PRINTF("Line Number: %u\n", (unsigned int) ((error_info_t *)(info))->line_num);
NRF_LOG_PRINTF("File Name: %s\n", ((error_info_t *)(info))->p_file_name);
}
NRF_LOG_PRINTF("Error Code: 0x%X\n" NRF_LOG_COLOR_DEFAULT "\n", (unsigned int) ((error_info_t *)(info))->err_code);
break;
}
}
/**@brief Function for printing all error info (using printf).
*
* @param[in] id Fault identifier. See @ref NRF_FAULT_IDS.
* @param[in] pc The program counter of the instruction that triggered the fault, or 0 if
* unavailable.
* @param[in] info Optional additional information regarding the fault. Refer to each fault
* identifier for details.
*/
//lint -save -e438
static __INLINE void app_error_print(uint32_t id, uint32_t pc, uint32_t info)
{
unsigned int tmp = id;
printf("app_error_print():\r\n");
printf("Fault identifier: 0x%X\r\n", tmp);
printf("Program counter: 0x%X\r\n", tmp = pc);
printf("Fault information: 0x%X\r\n", tmp = info);
switch (id)
{
case NRF_FAULT_ID_SDK_ASSERT:
printf("Line Number: %u\r\n", tmp = ((assert_info_t *)(info))->line_num);
printf("File Name: %s\r\n", ((assert_info_t *)(info))->p_file_name);
break;
case NRF_FAULT_ID_SDK_ERROR:
printf("Line Number: %u\r\n", tmp = ((error_info_t *)(info))->line_num);
printf("File Name: %s\r\n", ((error_info_t *)(info))->p_file_name);
printf("Error Code: 0x%X\r\n", tmp = ((error_info_t *)(info))->err_code);
break;
}
}
//lint -restore
/**@brief Macro for calling error handler function.
*
* @param[in] ERR_CODE Error code supplied to the error handler.
*/
#ifdef DEBUG
#define APP_ERROR_HANDLER(ERR_CODE) \
do \
{ \
app_error_handler((ERR_CODE), __LINE__, (uint8_t*) __FILE__); \
} while (0)
#else
#define APP_ERROR_HANDLER(ERR_CODE) \
do \
{ \
app_error_handler_bare((ERR_CODE)); \
} while (0)
#endif
/**@brief Macro for calling error handler function if supplied error code any other than NRF_SUCCESS.
*
* @param[in] ERR_CODE Error code supplied to the error handler.
*/
#define APP_ERROR_CHECK(ERR_CODE) \
do \
{ \
const uint32_t LOCAL_ERR_CODE = (ERR_CODE); \
if (LOCAL_ERR_CODE != NRF_SUCCESS) \
{ \
APP_ERROR_HANDLER(LOCAL_ERR_CODE); \
} \
} while (0)
/**@brief Macro for calling error handler function if supplied boolean value is false.
*
* @param[in] BOOLEAN_VALUE Boolean value to be evaluated.
*/
#define APP_ERROR_CHECK_BOOL(BOOLEAN_VALUE) \
do \
{ \
const uint32_t LOCAL_BOOLEAN_VALUE = (BOOLEAN_VALUE); \
if (!LOCAL_BOOLEAN_VALUE) \
{ \
APP_ERROR_HANDLER(0); \
} \
} while (0)
#endif // APP_ERROR_H__
/** @} */

53
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_error_weak.c Normal file
View File

@@ -0,0 +1,53 @@
/* Copyright (c) 2016 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#include "app_error.h"
#ifdef DEBUG
#include "bsp.h"
#endif
/*lint -save -e14 */
/**
* Function is implemented as weak so that it can be overwritten by custom application error handler
* when needed.
*/
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
// On assert, the system can only recover with a reset.
#ifndef DEBUG
NVIC_SystemReset();
#else
#ifdef BSP_DEFINES_ONLY
LEDS_ON(LEDS_MASK);
#else
UNUSED_VARIABLE(bsp_indication_set(BSP_INDICATE_FATAL_ERROR));
// This call can be used for debug purposes during application development.
// @note CAUTION: Activating this code will write the stack to flash on an error.
// This function should NOT be used in a final product.
// It is intended STRICTLY for development/debugging purposes.
// The flash write will happen EVEN if the radio is active, thus interrupting
// any communication.
// Use with care. Uncomment the line below to use.
//ble_debug_assert_handler(error_code, line_num, p_file_name);
#endif // BSP_DEFINES_ONLY
app_error_save_and_stop(id, pc, info);
#endif // DEBUG
}
/*lint -restore */

51
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_error_weak.h Normal file
View File

@@ -0,0 +1,51 @@
/* Copyright (c) 2016 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#ifndef APP_ERROR_WEAK_H__
#define APP_ERROR_WEAK_H__
/** @file
*
* @defgroup app_error Common application error handler
* @{
* @ingroup app_common
*
* @brief Common application error handler.
*/
/**@brief Callback function for asserts in the SoftDevice.
*
* @details A pointer to this function will be passed to the SoftDevice. This function will be
* called by the SoftDevice if certain unrecoverable errors occur within the
* application or SoftDevice.
*
* See @ref nrf_fault_handler_t for more details.
*
* @param[in] id Fault identifier. See @ref NRF_FAULT_IDS.
* @param[in] pc The program counter of the instruction that triggered the fault, or 0 if
* unavailable.
* @param[in] info Optional additional information regarding the fault. Refer to each fault
* identifier for details.
*
* @remarks Function is implemented as weak so that it can be overwritten by custom application
* error handler when needed.
*/
#ifdef __CC_ARM
void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info);
#else
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info);
#endif
/** @} */
#endif // APP_ERROR_WEAK_H__

493
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_util.h Normal file
View File

@@ -0,0 +1,493 @@
/* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @file
*
* @defgroup app_util Utility Functions and Definitions
* @{
* @ingroup app_common
*
* @brief Various types and definitions available to all applications.
*/
#ifndef APP_UTIL_H__
#define APP_UTIL_H__
#include <stdint.h>
#include <stdbool.h>
#include "compiler_abstraction.h"
#include "nrf.h"
//lint -save -e27 -e10 -e19
#if defined ( __CC_ARM )
extern char STACK$$Base;
extern char STACK$$Length;
#define STACK_BASE &STACK$$Base
#define STACK_TOP ((void*)((uint32_t)STACK_BASE + (uint32_t)&STACK$$Length))
#elif defined ( __ICCARM__ )
extern char CSTACK$$Base;
extern char CSTACK$$Length;
#define STACK_BASE &CSTACK$$Base
#define STACK_TOP ((void*)((uint32_t)STACK_BASE + (uint32_t)&CSTACK$$Length))
#elif defined ( __GNUC__ )
extern uint32_t __StackTop;
extern uint32_t __StackLimit;
#define STACK_BASE &__StackLimit
#define STACK_TOP &__StackTop
#endif
//lint -restore
enum
{
UNIT_0_625_MS = 625, /**< Number of microseconds in 0.625 milliseconds. */
UNIT_1_25_MS = 1250, /**< Number of microseconds in 1.25 milliseconds. */
UNIT_10_MS = 10000 /**< Number of microseconds in 10 milliseconds. */
};
/**@brief Implementation specific macro for delayed macro expansion used in string concatenation
*
* @param[in] lhs Left hand side in concatenation
* @param[in] rhs Right hand side in concatenation
*/
#define STRING_CONCATENATE_IMPL(lhs, rhs) lhs ## rhs
/**@brief Macro used to concatenate string using delayed macro expansion
*
* @note This macro will delay concatenation until the expressions have been resolved
*
* @param[in] lhs Left hand side in concatenation
* @param[in] rhs Right hand side in concatenation
*/
#define STRING_CONCATENATE(lhs, rhs) STRING_CONCATENATE_IMPL(lhs, rhs)
// Disable lint-warnings/errors for STATIC_ASSERT
//lint --emacro(10,STATIC_ASSERT)
//lint --emacro(18,STATIC_ASSERT)
//lint --emacro(19,STATIC_ASSERT)
//lint --emacro(30,STATIC_ASSERT)
//lint --emacro(37,STATIC_ASSERT)
//lint --emacro(42,STATIC_ASSERT)
//lint --emacro(26,STATIC_ASSERT)
//lint --emacro(102,STATIC_ASSERT)
//lint --emacro(533,STATIC_ASSERT)
//lint --emacro(534,STATIC_ASSERT)
//lint --emacro(132,STATIC_ASSERT)
//lint --emacro(414,STATIC_ASSERT)
//lint --emacro(578,STATIC_ASSERT)
//lint --emacro(628,STATIC_ASSERT)
//lint --emacro(648,STATIC_ASSERT)
//lint --emacro(830,STATIC_ASSERT)
/**@brief Macro for doing static (i.e. compile time) assertion.
*
* @note If the EXPR isn't resolvable, then the error message won't be shown.
*
* @note The output of STATIC_ASSERT will be different across different compilers.
*
* @param[in] EXPR Constant expression to be verified.
*/
#if defined ( __COUNTER__ )
#define STATIC_ASSERT(EXPR) \
;enum { STRING_CONCATENATE(static_assert_, __COUNTER__) = 1/(!!(EXPR)) }
#else
#define STATIC_ASSERT(EXPR) \
;enum { STRING_CONCATENATE(assert_line_, __LINE__) = 1/(!!(EXPR)) }
#endif
/**@brief Implementation details for NUM_VAR_ARGS */
#define NUM_VA_ARGS_IMPL( \
_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
_21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
_31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
_41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \
_51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \
_61, _62, N, ...) N
/**@brief Macro to get the number of arguments in a call variadic macro call
*
* param[in] ... List of arguments
*
* @retval Number of variadic arguments in the argument list
*/
#define NUM_VA_ARGS(...) NUM_VA_ARGS_IMPL(__VA_ARGS__, 63, 62, 61, \
60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
/**@brief type for holding an encoded (i.e. little endian) 16 bit unsigned integer. */
typedef uint8_t uint16_le_t[2];
/**@brief Type for holding an encoded (i.e. little endian) 32 bit unsigned integer. */
typedef uint8_t uint32_le_t[4];
/**@brief Byte array type. */
typedef struct
{
uint16_t size; /**< Number of array entries. */
uint8_t * p_data; /**< Pointer to array entries. */
} uint8_array_t;
/**@brief Macro for performing rounded integer division (as opposed to truncating the result).
*
* @param[in] A Numerator.
* @param[in] B Denominator.
*
* @return Rounded (integer) result of dividing A by B.
*/
#define ROUNDED_DIV(A, B) (((A) + ((B) / 2)) / (B))
/**@brief Macro for checking if an integer is a power of two.
*
* @param[in] A Number to be tested.
*
* @return true if value is power of two.
* @return false if value not power of two.
*/
#define IS_POWER_OF_TWO(A) ( ((A) != 0) && ((((A) - 1) & (A)) == 0) )
/**@brief Macro for converting milliseconds to ticks.
*
* @param[in] TIME Number of milliseconds to convert.
* @param[in] RESOLUTION Unit to be converted to in [us/ticks].
*/
#define MSEC_TO_UNITS(TIME, RESOLUTION) (((TIME) * 1000) / (RESOLUTION))
/**@brief Macro for performing integer division, making sure the result is rounded up.
*
* @details One typical use for this is to compute the number of objects with size B is needed to
* hold A number of bytes.
*
* @param[in] A Numerator.
* @param[in] B Denominator.
*
* @return Integer result of dividing A by B, rounded up.
*/
#define CEIL_DIV(A, B) \
(((A) + (B) - 1) / (B))
/**@brief Macro for creating a buffer aligned to 4 bytes.
*
* @param[in] NAME Name of the buffor.
* @param[in] MIN_SIZE Size of this buffor (it will be rounded up to multiples of 4 bytes).
*/
#define WORD_ALIGNED_MEM_BUFF(NAME, MIN_SIZE) static uint32_t NAME[CEIL_DIV(MIN_SIZE, sizeof(uint32_t))]
/**@brief Macro for calculating the number of words that are needed to hold a number of bytes.
*
* @details Adds 3 and divides by 4.
*
* @param[in] n_bytes The number of bytes.
*
* @return The number of words that @p n_bytes take up (rounded up).
*/
#define BYTES_TO_WORDS(n_bytes) (((n_bytes) + 3) >> 2)
/**@brief The number of bytes in a word.
*/
#define BYTES_PER_WORD (4)
/**@brief Macro for increasing a number to the nearest (larger) multiple of another number.
*
* @param[in] alignment The number to align to.
* @param[in] number The number to align (increase).
*
* @return The aligned (increased) @p number.
*/
#define ALIGN_NUM(alignment, number) ((number - 1) + alignment - ((number - 1) % alignment))
/**@brief Function for changing the value unit.
*
* @param[in] value Value to be rescaled.
* @param[in] old_unit_reversal Reversal of the incoming unit.
* @param[in] new_unit_reversal Reversal of the desired unit.
*
* @return Number of bytes written.
*/
static __INLINE uint64_t value_rescale(uint32_t value, uint32_t old_unit_reversal, uint16_t new_unit_reversal)
{
return (uint64_t)ROUNDED_DIV((uint64_t)value * new_unit_reversal, old_unit_reversal);
}
/**@brief Function for encoding a uint16 value.
*
* @param[in] value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t uint16_encode(uint16_t value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((value & 0x00FF) >> 0);
p_encoded_data[1] = (uint8_t) ((value & 0xFF00) >> 8);
return sizeof(uint16_t);
}
/**@brief Function for encoding a three-byte value.
*
* @param[in] value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t uint24_encode(uint32_t value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((value & 0x000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((value & 0x0000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((value & 0x00FF0000) >> 16);
return 3;
}
/**@brief Function for encoding a uint32 value.
*
* @param[in] value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t uint32_encode(uint32_t value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((value & 0x000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((value & 0x0000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((value & 0x00FF0000) >> 16);
p_encoded_data[3] = (uint8_t) ((value & 0xFF000000) >> 24);
return sizeof(uint32_t);
}
/**@brief Function for encoding a uint48 value.
*
* @param[in] value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t uint48_encode(uint64_t value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((value & 0x0000000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((value & 0x00000000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((value & 0x000000FF0000) >> 16);
p_encoded_data[3] = (uint8_t) ((value & 0x0000FF000000) >> 24);
p_encoded_data[4] = (uint8_t) ((value & 0x00FF00000000) >> 32);
p_encoded_data[5] = (uint8_t) ((value & 0xFF0000000000) >> 40);
return 6;
}
/**@brief Function for decoding a uint16 value.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value.
*/
static __INLINE uint16_t uint16_decode(const uint8_t * p_encoded_data)
{
return ( (((uint16_t)((uint8_t *)p_encoded_data)[0])) |
(((uint16_t)((uint8_t *)p_encoded_data)[1]) << 8 ));
}
/**@brief Function for decoding a uint16 value in big-endian format.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value.
*/
static __INLINE uint16_t uint16_big_decode(const uint8_t * p_encoded_data)
{
return ( (((uint16_t)((uint8_t *)p_encoded_data)[0]) << 8 ) |
(((uint16_t)((uint8_t *)p_encoded_data)[1])) );
}
/**@brief Function for decoding a three-byte value.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value (uint32_t).
*/
static __INLINE uint32_t uint24_decode(const uint8_t * p_encoded_data)
{
return ( (((uint32_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint32_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint32_t)((uint8_t *)p_encoded_data)[2]) << 16));
}
/**@brief Function for decoding a uint32 value.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value.
*/
static __INLINE uint32_t uint32_decode(const uint8_t * p_encoded_data)
{
return ( (((uint32_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint32_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint32_t)((uint8_t *)p_encoded_data)[2]) << 16) |
(((uint32_t)((uint8_t *)p_encoded_data)[3]) << 24 ));
}
/**@brief Function for decoding a uint32 value in big-endian format.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value.
*/
static __INLINE uint32_t uint32_big_decode(const uint8_t * p_encoded_data)
{
return ( (((uint32_t)((uint8_t *)p_encoded_data)[0]) << 24) |
(((uint32_t)((uint8_t *)p_encoded_data)[1]) << 16) |
(((uint32_t)((uint8_t *)p_encoded_data)[2]) << 8) |
(((uint32_t)((uint8_t *)p_encoded_data)[3]) << 0) );
}
/**@brief Function for encoding a uint32 value in big-endian format.
*
* @param[in] value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data will be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t uint32_big_encode(uint32_t value, uint8_t * p_encoded_data)
{
#ifdef NRF51
p_encoded_data[0] = (uint8_t) ((value & 0xFF000000) >> 24);
p_encoded_data[1] = (uint8_t) ((value & 0x00FF0000) >> 16);
p_encoded_data[2] = (uint8_t) ((value & 0x0000FF00) >> 8);
p_encoded_data[3] = (uint8_t) ((value & 0x000000FF) >> 0);
#elif NRF52
*(uint32_t *)p_encoded_data = __REV(value);
#endif
return sizeof(uint32_t);
}
/**@brief Function for decoding a uint48 value.
*
* @param[in] p_encoded_data Buffer where the encoded data is stored.
*
* @return Decoded value. (uint64_t)
*/
static __INLINE uint64_t uint48_decode(const uint8_t * p_encoded_data)
{
return ( (((uint64_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint64_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint64_t)((uint8_t *)p_encoded_data)[2]) << 16) |
(((uint64_t)((uint8_t *)p_encoded_data)[3]) << 24) |
(((uint64_t)((uint8_t *)p_encoded_data)[4]) << 32) |
(((uint64_t)((uint8_t *)p_encoded_data)[5]) << 40 ));
}
/** @brief Function for converting the input voltage (in milli volts) into percentage of 3.0 Volts.
*
* @details The calculation is based on a linearized version of the battery's discharge
* curve. 3.0V returns 100% battery level. The limit for power failure is 2.1V and
* is considered to be the lower boundary.
*
* The discharge curve for CR2032 is non-linear. In this model it is split into
* 4 linear sections:
* - Section 1: 3.0V - 2.9V = 100% - 42% (58% drop on 100 mV)
* - Section 2: 2.9V - 2.74V = 42% - 18% (24% drop on 160 mV)
* - Section 3: 2.74V - 2.44V = 18% - 6% (12% drop on 300 mV)
* - Section 4: 2.44V - 2.1V = 6% - 0% (6% drop on 340 mV)
*
* These numbers are by no means accurate. Temperature and
* load in the actual application is not accounted for!
*
* @param[in] mvolts The voltage in mV
*
* @return Battery level in percent.
*/
static __INLINE uint8_t battery_level_in_percent(const uint16_t mvolts)
{
uint8_t battery_level;
if (mvolts >= 3000)
{
battery_level = 100;
}
else if (mvolts > 2900)
{
battery_level = 100 - ((3000 - mvolts) * 58) / 100;
}
else if (mvolts > 2740)
{
battery_level = 42 - ((2900 - mvolts) * 24) / 160;
}
else if (mvolts > 2440)
{
battery_level = 18 - ((2740 - mvolts) * 12) / 300;
}
else if (mvolts > 2100)
{
battery_level = 6 - ((2440 - mvolts) * 6) / 340;
}
else
{
battery_level = 0;
}
return battery_level;
}
/**@brief Function for checking if a pointer value is aligned to a 4 byte boundary.
*
* @param[in] p Pointer value to be checked.
*
* @return TRUE if pointer is aligned to a 4 byte boundary, FALSE otherwise.
*/
static __INLINE bool is_word_aligned(void const* p)
{
return (((uintptr_t)p & 0x03) == 0);
}
/**
* @brief Function for checking if provided address is located in stack space.
*
* @param[in] ptr Pointer to be checked.
*
* @return true if address is in stack space, false otherwise.
*/
static __INLINE bool is_address_from_stack(void * ptr)
{
if (((uint32_t)ptr >= (uint32_t)STACK_BASE) &&
((uint32_t)ptr < (uint32_t)STACK_TOP) )
{
return true;
}
else
{
return false;
}
}
#endif // APP_UTIL_H__
/** @} */

413
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_util_bds.h Normal file
View File

@@ -0,0 +1,413 @@
/* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @file
*
* @defgroup app_util Utility Functions and Definitions
* @{
* @ingroup app_common
*
* @brief Various types and definitions available to all applications.
*/
#ifndef APP_UTIL_BDS_H__
#define APP_UTIL_BDS_H__
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "compiler_abstraction.h"
#include "app_util.h"
#include "ble_srv_common.h"
#include "nordic_common.h"
typedef uint8_t nibble_t;
typedef uint32_t uint24_t;
typedef uint64_t uint40_t;
/**@brief IEEE 11073-20601 Regulatory Certification Data List Structure */
typedef struct
{
uint8_t * p_list; /**< Pointer the byte array containing the encoded opaque structure based on IEEE 11073-20601 specification. */
uint8_t list_len; /**< Length of the byte array. */
} regcertdatalist_t;
/**@brief SFLOAT format (IEEE-11073 16-bit FLOAT, meaning 4 bits for exponent (base 10) and 12 bits mantissa) */
typedef struct
{
int8_t exponent; /**< Base 10 exponent, should be using only 4 bits */
int16_t mantissa; /**< Mantissa, should be using only 12 bits */
} sfloat_t;
/**@brief Date and Time structure. */
typedef struct
{
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hours;
uint8_t minutes;
uint8_t seconds;
} ble_date_time_t;
/**@brief Function for encoding a uint16 value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t bds_uint16_encode(const uint16_t * p_value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((*p_value & 0x00FF) >> 0);
p_encoded_data[1] = (uint8_t) ((*p_value & 0xFF00) >> 8);
return sizeof(uint16_t);
}
static __INLINE uint8_t bds_int16_encode(const int16_t * p_value, uint8_t * p_encoded_data)
{
uint16_t tmp = *p_value;
return bds_uint16_encode(&tmp, p_encoded_data);
}
/**@brief Function for encoding a uint24 value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t bds_uint24_encode(const uint32_t * p_value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((*p_value & 0x000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((*p_value & 0x0000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((*p_value & 0x00FF0000) >> 16);
return (3);
}
/**@brief Function for encoding a uint32 value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t bds_uint32_encode(const uint32_t * p_value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((*p_value & 0x000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((*p_value & 0x0000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((*p_value & 0x00FF0000) >> 16);
p_encoded_data[3] = (uint8_t) ((*p_value & 0xFF000000) >> 24);
return sizeof(uint32_t);
}
/**@brief Function for encoding a uint40 value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t bds_uint40_encode(const uint64_t * p_value, uint8_t * p_encoded_data)
{
p_encoded_data[0] = (uint8_t) ((*p_value & 0x00000000000000FF) >> 0);
p_encoded_data[1] = (uint8_t) ((*p_value & 0x000000000000FF00) >> 8);
p_encoded_data[2] = (uint8_t) ((*p_value & 0x0000000000FF0000) >> 16);
p_encoded_data[3] = (uint8_t) ((*p_value & 0x00000000FF000000) >> 24);
p_encoded_data[4] = (uint8_t) ((*p_value & 0x000000FF00000000) >> 32);
return 5;
}
/**@brief Function for encoding a sfloat value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*
* @return Number of bytes written.
*/
static __INLINE uint8_t bds_sfloat_encode(const sfloat_t * p_value, uint8_t * p_encoded_data)
{
uint16_t encoded_val;
encoded_val = ((p_value->exponent << 12) & 0xF000) |
((p_value->mantissa << 0) & 0x0FFF);
return(bds_uint16_encode(&encoded_val, p_encoded_data));
}
/**@brief Function for encoding a uint8_array value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*/
static __INLINE uint8_t bds_uint8_array_encode(const uint8_array_t * p_value,
uint8_t * p_encoded_data)
{
memcpy(p_encoded_data, p_value->p_data, p_value->size);
return p_value->size;
}
/**@brief Function for encoding a utf8_str value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*/
static __INLINE uint8_t bds_ble_srv_utf8_str_encode(const ble_srv_utf8_str_t * p_value,
uint8_t * p_encoded_data)
{
memcpy(p_encoded_data, p_value->p_str, p_value->length);
return p_value->length;
}
/**@brief Function for encoding a regcertdatalist value.
*
* @param[in] p_value Value to be encoded.
* @param[out] p_encoded_data Buffer where the encoded data is to be written.
*/
static __INLINE uint8_t bds_regcertdatalist_encode(const regcertdatalist_t * p_value,
uint8_t * p_encoded_data)
{
memcpy(p_encoded_data, p_value->p_list, p_value->list_len);
return p_value->list_len;
}
/**@brief Function for decoding a date_time value.
*
* @param[in] p_date_time pointer to the date_time structure to encode.
* @param[in] p_encoded_data pointer to the encoded data
* @return length of the encoded field.
*/
static __INLINE uint8_t bds_ble_date_time_encode(const ble_date_time_t * p_date_time,
uint8_t * p_encoded_data)
{
uint8_t len = bds_uint16_encode(&p_date_time->year, &p_encoded_data[0]);
p_encoded_data[len++] = p_date_time->month;
p_encoded_data[len++] = p_date_time->day;
p_encoded_data[len++] = p_date_time->hours;
p_encoded_data[len++] = p_date_time->minutes;
p_encoded_data[len++] = p_date_time->seconds;
return len;
}
/**@brief Function for decoding a uint16 value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_uint16_decode(const uint8_t len,
const uint8_t * p_encoded_data,
uint16_t * p_decoded_val)
{
UNUSED_VARIABLE(len);
*p_decoded_val = (((uint16_t)((uint8_t *)p_encoded_data)[0])) |
(((uint16_t)((uint8_t *)p_encoded_data)[1]) << 8 );
return (sizeof(uint16_t));
}
/**@brief Function for decoding a int16 value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_int16_decode(const uint8_t len,
const uint8_t * p_encoded_data,
int16_t * p_decoded_val)
{
UNUSED_VARIABLE(len);
uint16_t tmp = 0;
uint8_t retval = bds_uint16_decode(len, p_encoded_data, &tmp);
*p_decoded_val = (int16_t)tmp;
return retval;
}
/**@brief Function for decoding a uint24 value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_uint24_decode(const uint8_t len,
const uint8_t * p_encoded_data,
uint32_t * p_decoded_val)
{
UNUSED_VARIABLE(len);
*p_decoded_val = (((uint32_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint32_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint32_t)((uint8_t *)p_encoded_data)[2]) << 16);
return (3);
}
/**@brief Function for decoding a uint32 value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_uint32_decode(const uint8_t len,
const uint8_t * p_encoded_data,
uint32_t * p_decoded_val)
{
UNUSED_VARIABLE(len);
*p_decoded_val = (((uint32_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint32_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint32_t)((uint8_t *)p_encoded_data)[2]) << 16) |
(((uint32_t)((uint8_t *)p_encoded_data)[3]) << 24 );
return (sizeof(uint32_t));
}
/**@brief Function for decoding a uint40 value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_uint40_decode(const uint8_t len,
const uint8_t * p_encoded_data,
uint64_t * p_decoded_val)
{
UNUSED_VARIABLE(len);
*p_decoded_val = (((uint64_t)((uint8_t *)p_encoded_data)[0]) << 0) |
(((uint64_t)((uint8_t *)p_encoded_data)[1]) << 8) |
(((uint64_t)((uint8_t *)p_encoded_data)[2]) << 16) |
(((uint64_t)((uint8_t *)p_encoded_data)[3]) << 24 )|
(((uint64_t)((uint8_t *)p_encoded_data)[4]) << 32 );
return (40);
}
/**@brief Function for decoding a sfloat value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_sfloat_decode(const uint8_t len,
const uint8_t * p_encoded_data,
sfloat_t * p_decoded_val)
{
p_decoded_val->exponent = 0;
bds_uint16_decode(len, p_encoded_data, (uint16_t*)&p_decoded_val->mantissa);
p_decoded_val->exponent = (uint8_t)((p_decoded_val->mantissa & 0xF000) >> 12);
p_decoded_val->mantissa &= 0x0FFF;
return len;
}
/**@brief Function for decoding a uint8_array value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_uint8_array_decode(const uint8_t len,
const uint8_t * p_encoded_data,
uint8_array_t * p_decoded_val)
{
memcpy(p_decoded_val->p_data, p_encoded_data, len);
p_decoded_val->size = len;
return p_decoded_val->size;
}
/**@brief Function for decoding a utf8_str value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_ble_srv_utf8_str_decode(const uint8_t len,
const uint8_t * p_encoded_data,
ble_srv_utf8_str_t * p_decoded_val)
{
p_decoded_val->p_str = (uint8_t*)p_encoded_data;
p_decoded_val->length = len;
return p_decoded_val->length;
}
/**@brief Function for decoding a regcertdatalist value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_decoded_val pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_regcertdatalist_decode(const uint8_t len,
const uint8_t * p_encoded_data,
regcertdatalist_t * p_decoded_val)
{
memcpy(p_decoded_val->p_list, p_encoded_data, len);
p_decoded_val->list_len = len;
return p_decoded_val->list_len;
}
/**@brief Function for decoding a date_time value.
*
* @param[in] len length of the field to be decoded.
* @param[in] p_encoded_data Buffer where the encoded data is stored.
* @param[in] p_date_time pointer to the decoded value
*
* @return length of the decoded field.
*/
static __INLINE uint8_t bds_ble_date_time_decode(const uint8_t len,
const uint8_t * p_encoded_data,
ble_date_time_t * p_date_time)
{
UNUSED_VARIABLE(len);
uint8_t pos = bds_uint16_decode(len, &p_encoded_data[0], &p_date_time->year);
p_date_time->month = p_encoded_data[pos++];
p_date_time->day = p_encoded_data[pos++];
p_date_time->hours = p_encoded_data[pos++];
p_date_time->minutes = p_encoded_data[pos++];
p_date_time->seconds = p_encoded_data[pos++];
return pos;
}
#endif // APP_UTIL_BDS_H__
/** @} */

60
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_util_platform.c Normal file
View File

@@ -0,0 +1,60 @@
/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#include "app_util_platform.h"
static uint32_t m_in_critical_region = 0;
void app_util_disable_irq(void)
{
__disable_irq();
m_in_critical_region++;
}
void app_util_enable_irq(void)
{
m_in_critical_region--;
if (m_in_critical_region == 0)
{
__enable_irq();
}
}
void app_util_critical_region_enter(uint8_t *p_nested)
{
#ifdef NRF52
ASSERT(APP_LEVEL_PRIVILEGED == privilege_level_get())
#endif
#if defined(SOFTDEVICE_PRESENT)
/* return value can be safely ignored */
(void) sd_nvic_critical_region_enter(p_nested);
#else
app_util_disable_irq();
#endif
}
void app_util_critical_region_exit(uint8_t nested)
{
#ifdef NRF52
ASSERT(APP_LEVEL_PRIVILEGED == privilege_level_get())
#endif
#if defined(SOFTDEVICE_PRESENT)
/* return value can be safely ignored */
(void) sd_nvic_critical_region_exit(nested);
#else
app_util_enable_irq();
#endif
}

211
nRF5_SDK_11.0.0_89a8197/components/libraries/util/app_util_platform.h Normal file
View File

@@ -0,0 +1,211 @@
/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/**@file
*
* @defgroup app_util_platform Utility Functions and Definitions (Platform)
* @{
* @ingroup app_common
*
* @brief Various types and definitions available to all applications when using SoftDevice.
*/
#ifndef APP_UTIL_PLATFORM_H__
#define APP_UTIL_PLATFORM_H__
#include <stdint.h>
#include "compiler_abstraction.h"
#include "nrf.h"
#ifdef SOFTDEVICE_PRESENT
#include "nrf_soc.h"
#include "nrf_nvic.h"
#endif
#include "nrf_assert.h"
#include "app_error.h"
#if defined(NRF51)
#define _PRIO_SD_HIGH 0
#define _PRIO_APP_HIGH 1
#define _PRIO_APP_MID 1
#define _PRIO_SD_LOW 2
#define _PRIO_APP_LOW 3
#define _PRIO_APP_LOWEST 3
#define _PRIO_THREAD 4
#elif defined(NRF52)
#define _PRIO_SD_HIGH 0
#define _PRIO_SD_MID 1
#define _PRIO_APP_HIGH 2
#define _PRIO_APP_MID 3
#define _PRIO_SD_LOW 4
#define _PRIO_SD_LOWEST 5
#define _PRIO_APP_LOW 6
#define _PRIO_APP_LOWEST 7
#define _PRIO_THREAD 15
#else
#error "No platform defined"
#endif
/**@brief The interrupt priorities available to the application while the SoftDevice is active. */
typedef enum
{
#ifdef SOFTDEVICE_PRESENT
APP_IRQ_PRIORITY_HIGHEST = _PRIO_SD_HIGH,
#else
APP_IRQ_PRIORITY_HIGHEST = _PRIO_APP_HIGH,
#endif
APP_IRQ_PRIORITY_HIGH = _PRIO_APP_HIGH,
#ifndef SOFTDEVICE_PRESENT
APP_IRQ_PRIORITY_MID = _PRIO_SD_LOW,
#else
APP_IRQ_PRIORITY_MID = _PRIO_APP_MID,
#endif
APP_IRQ_PRIORITY_LOW = _PRIO_APP_LOW,
APP_IRQ_PRIORITY_LOWEST = _PRIO_APP_LOWEST,
APP_IRQ_PRIORITY_THREAD = _PRIO_THREAD /**< "Interrupt level" when running in Thread Mode. */
} app_irq_priority_t;
/*@brief The privilege levels available to applications in Thread Mode */
typedef enum
{
APP_LEVEL_UNPRIVILEGED,
APP_LEVEL_PRIVILEGED
} app_level_t;
/**@cond NO_DOXYGEN */
#define EXTERNAL_INT_VECTOR_OFFSET 16
/**@endcond */
#define PACKED(TYPE) __packed TYPE
void app_util_critical_region_enter (uint8_t *p_nested);
void app_util_critical_region_exit (uint8_t nested);
/**@brief Macro for entering a critical region.
*
* @note Due to implementation details, there must exist one and only one call to
* CRITICAL_REGION_EXIT() for each call to CRITICAL_REGION_ENTER(), and they must be located
* in the same scope.
*/
#ifdef SOFTDEVICE_PRESENT
#define CRITICAL_REGION_ENTER() \
{ \
uint8_t __CR_NESTED = 0; \
app_util_critical_region_enter(&__CR_NESTED);
#else
#define CRITICAL_REGION_ENTER() app_util_critical_region_enter(NULL)
#endif
/**@brief Macro for leaving a critical region.
*
* @note Due to implementation details, there must exist one and only one call to
* CRITICAL_REGION_EXIT() for each call to CRITICAL_REGION_ENTER(), and they must be located
* in the same scope.
*/
#ifdef SOFTDEVICE_PRESENT
#define CRITICAL_REGION_EXIT() \
app_util_critical_region_exit(__CR_NESTED); \
}
#else
#define CRITICAL_REGION_EXIT() app_util_critical_region_exit(0)
#endif
/* Workaround for Keil 4 */
#ifndef IPSR_ISR_Msk
#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */
#endif
/**@brief Macro to enable anonymous unions from a certain point in the code.
*/
#if defined(__CC_ARM)
#define ANON_UNIONS_ENABLE _Pragma("push") \
_Pragma("anon_unions")
#elif defined(__ICCARM__)
#define ANON_UNIONS_ENABLE _Pragma("language=extended")
#else
#define ANON_UNIONS_ENABLE
// No action will be taken.
// For GCC anonymous unions are enabled by default.
#endif
/**@brief Macro to disable anonymous unions from a certain point in the code.
* @note Call only after first calling @ref ANON_UNIONS_ENABLE.
*/
#if defined(__CC_ARM)
#define ANON_UNIONS_DISABLE _Pragma("pop")
#elif defined(__ICCARM__)
#define ANON_UNIONS_DISABLE
// for IAR leave anonymous unions enabled
#else
#define ANON_UNIONS_DISABLE
// No action will be taken.
// For GCC anonymous unions are enabled by default.
#endif
/* Workaround for Keil 4 */
#ifndef CONTROL_nPRIV_Msk
#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */
#endif
/**@brief Function for finding the current interrupt level.
*
* @return Current interrupt level.
* @retval APP_IRQ_PRIORITY_HIGH We are running in Application High interrupt level.
* @retval APP_IRQ_PRIORITY_LOW We are running in Application Low interrupt level.
* @retval APP_IRQ_PRIORITY_THREAD We are running in Thread Mode.
*/
static __INLINE uint8_t current_int_priority_get(void)
{
uint32_t isr_vector_num = __get_IPSR() & IPSR_ISR_Msk ;
if (isr_vector_num > 0)
{
int32_t irq_type = ((int32_t)isr_vector_num - EXTERNAL_INT_VECTOR_OFFSET);
return (NVIC_GetPriority((IRQn_Type)irq_type) & 0xFF);
}
else
{
return APP_IRQ_PRIORITY_THREAD;
}
}
/**@brief Function for finding out the current privilege level.
*
* @return Current privilege level.
* @retval APP_LEVEL_UNPRIVILEGED We are running in unprivileged level.
* @retval APP_LEVEL_PRIVILEGED We are running in privileged level.
*/
static __INLINE uint8_t privilege_level_get(void)
{
#if defined(NRF51)
/* the Cortex-M0 has no concept of privilege */
return APP_LEVEL_PRIVILEGED;
#elif defined(NRF52)
uint32_t isr_vector_num = __get_IPSR() & IPSR_ISR_Msk ;
if (0 == isr_vector_num)
{
/* Thread Mode, check nPRIV */
int32_t control = __get_CONTROL();
return control & CONTROL_nPRIV_Msk ? APP_LEVEL_UNPRIVILEGED : APP_LEVEL_PRIVILEGED;
}
else
{
/* Handler Mode, always privileged */
return APP_LEVEL_PRIVILEGED;
}
#endif
}
#endif // APP_UTIL_PLATFORM_H__
/** @} */

38
nRF5_SDK_11.0.0_89a8197/components/libraries/util/common.h Normal file
View File

@@ -0,0 +1,38 @@
/* Copyright (c) 2009 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#ifndef COMMON_H
#define COMMON_H
/*lint ++flb "Enter library region" */
#include <stdbool.h>
#include <stdint.h>
/* @file
* @brief Common header file for generic macros and definitions
*
*/
/*
* GPIO glue macros, this can be used to define a pin number in source/header file and use that macro for pin
* configuration using this expansion.
* example:
* #define RESET_PIN 8
* NRF_GPIO->PINCNF(RESET_PIN) = XXX ; // Expanded NRF_GPIO->PIN_CNF[8] = XXX
*/
#define PINX_GLUE(x, y, z) x##y##_##z /*!< first level glue for pin macros */
#define PINCNF(p) PINX_GLUE(PIN,p,CNF) /*!< gpio configure pin number 'p' */
#define PINOUT(p) PINX_GLUE(PIN,p,OUT) /*!< gpio out pin number 'p' */
/*lint --flb "Leave library region" */
#endif

108
nRF5_SDK_11.0.0_89a8197/components/libraries/util/nordic_common.h Normal file
View File

@@ -0,0 +1,108 @@
/* Copyright (c) 2008 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*/
/** @file
* @brief Common defines and macros for firmware developed by Nordic Semiconductor.
*/
#ifndef NORDIC_COMMON_H__
#define NORDIC_COMMON_H__
/** The upper 8 bits of a 32 bit value */
//lint -emacro(572,MSB) // Suppress warning 572 "Excessive shift value"
#define MSB_32(a) (((a) & 0xFF000000) >> 24)
/** The lower 8 bits (of a 32 bit value) */
#define LSB_32(a) ((a) & 0x000000FF)
/** The upper 8 bits of a 16 bit value */
//lint -emacro(572,MSB_16) // Suppress warning 572 "Excessive shift value"
#define MSB_16(a) (((a) & 0xFF00) >> 8)
/** The lower 8 bits (of a 16 bit value) */
#define LSB_16(a) ((a) & 0x00FF)
/** Leaves the minimum of the two 32-bit arguments */
/*lint -emacro(506, MIN) */ /* Suppress "Constant value Boolean */
#define MIN(a, b) ((a) < (b) ? (a) : (b))
/** Leaves the maximum of the two 32-bit arguments */
/*lint -emacro(506, MAX) */ /* Suppress "Constant value Boolean */
#define MAX(a, b) ((a) < (b) ? (b) : (a))
/** Concatenates two parameters. Useful as a second level of indirection,
* when a parameter can be macro itself. */
#define CONCAT_2(p1, p2) p1##p2
/** Concatenates three parameters. Useful as a second level of indirection,
* when a parameter can be macro itself. */
#define CONCAT_3(p1, p2, p3) p1##p2##p3
/**@brief Set a bit in the uint32 word.
*
* @param[in] W Word whose bit is being set.
* @param[in] B Bit number in the word to be set.
*/
#define SET_BIT(W,B) ((W) |= (uint32_t)(1U << (B)))
/**@brief Clears a bit in the uint32 word.
*
* @param[in] W Word whose bit is to be cleared.
* @param[in] B Bit number in the word to be cleared.
*/
#define CLR_BIT(W, B) ((W) &= (~((uint32_t)1 << (B))))
/**@brief Checks if a bit is set.
*
* @param[in] W Word whose bit is to be checked.
* @param[in] B Bit number in the word to be checked.
*
* @retval 1 if bit is set.
* @retval 0 if bit is not set.
*/
#define IS_SET(W,B) (((W) >> (B)) & 1)
#define BIT_0 0x01 /**< The value of bit 0 */
#define BIT_1 0x02 /**< The value of bit 1 */
#define BIT_2 0x04 /**< The value of bit 2 */
#define BIT_3 0x08 /**< The value of bit 3 */
#define BIT_4 0x10 /**< The value of bit 4 */
#define BIT_5 0x20 /**< The value of bit 5 */
#define BIT_6 0x40 /**< The value of bit 6 */
#define BIT_7 0x80 /**< The value of bit 7 */
#define BIT_8 0x0100 /**< The value of bit 8 */
#define BIT_9 0x0200 /**< The value of bit 9 */
#define BIT_10 0x0400 /**< The value of bit 10 */
#define BIT_11 0x0800 /**< The value of bit 11 */
#define BIT_12 0x1000 /**< The value of bit 12 */
#define BIT_13 0x2000 /**< The value of bit 13 */
#define BIT_14 0x4000 /**< The value of bit 14 */
#define BIT_15 0x8000 /**< The value of bit 15 */
#define BIT_16 0x00010000 /**< The value of bit 16 */
#define BIT_17 0x00020000 /**< The value of bit 17 */
#define BIT_18 0x00040000 /**< The value of bit 18 */
#define BIT_19 0x00080000 /**< The value of bit 19 */
#define BIT_20 0x00100000 /**< The value of bit 20 */
#define BIT_21 0x00200000 /**< The value of bit 21 */
#define BIT_22 0x00400000 /**< The value of bit 22 */
#define BIT_23 0x00800000 /**< The value of bit 23 */
#define BIT_24 0x01000000 /**< The value of bit 24 */
#define BIT_25 0x02000000 /**< The value of bit 25 */
#define BIT_26 0x04000000 /**< The value of bit 26 */
#define BIT_27 0x08000000 /**< The value of bit 27 */
#define BIT_28 0x10000000 /**< The value of bit 28 */
#define BIT_29 0x20000000 /**< The value of bit 29 */
#define BIT_30 0x40000000 /**< The value of bit 30 */
#define BIT_31 0x80000000 /**< The value of bit 31 */
#define UNUSED_VARIABLE(X) ((void)(X))
#define UNUSED_PARAMETER(X) UNUSED_VARIABLE(X)
#define UNUSED_RETURN_VALUE(X) UNUSED_VARIABLE(X)
#endif // NORDIC_COMMON_H__

28
nRF5_SDK_11.0.0_89a8197/components/libraries/util/nrf_assert.c Normal file
View File

@@ -0,0 +1,28 @@
/* Copyright (c) 2006 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#include "nrf_assert.h"
#include "app_error.h"
#include "nordic_common.h"
#if defined(DEBUG_NRF)
void assert_nrf_callback(uint16_t line_num, const uint8_t * file_name)
{
assert_info_t assert_info =
{
.line_num = line_num,
.p_file_name = file_name,
};
app_error_fault_handler(NRF_FAULT_ID_SDK_ASSERT, 0, (uint32_t)(&assert_info));
UNUSED_VARIABLE(assert_info);
}
#endif /* DEBUG_NRF */

60
nRF5_SDK_11.0.0_89a8197/components/libraries/util/nrf_assert.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright (c) 2006 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is confidential property of Nordic Semiconductor. The use,
* copying, transfer or disclosure of such information is prohibited except by express written
* agreement with Nordic Semiconductor.
*
*/
/** @file
* @brief Utilities for verifying program logic
*/
#ifndef NRF_ASSERT_H_
#define NRF_ASSERT_H_
#include <stdint.h>
#include "nrf.h"
#include "app_error.h"
#if defined(DEBUG_NRF) || defined(DEBUG_NRF_USER)
/** @brief Function for handling assertions.
*
*
* @note
* This function is called when an assertion has triggered.
*
*
* @post
* All hardware is put into an idle non-emitting state (in particular the radio is highly
* important to switch off since the radio might be in a state that makes it send
* packets continiously while a typical final infinit ASSERT loop is executing).
*
*
* @param line_num The line number where the assertion is called
* @param file_name Pointer to the file name
*/
void assert_nrf_callback(uint16_t line_num, const uint8_t *file_name);
/*lint -emacro(506, ASSERT) */ /* Suppress "Constant value Boolean */
/*lint -emacro(774, ASSERT) */ /* Suppress "Boolean within 'if' always evaluates to True" */ \
/** @brief Function for checking intended for production code.
*
* Check passes if "expr" evaluates to true. */
#define ASSERT(expr) \
if (expr) \
{ \
} \
else \
{ \
assert_nrf_callback((uint16_t)__LINE__, (uint8_t *)__FILE__); \
}
#else
#define ASSERT(expr) //!< Assert empty when disabled
__WEAK void assert_nrf_callback(uint16_t line_num, const uint8_t *file_name);
#endif /* defined(DEBUG_NRF) || defined(DEBUG_NRF_USER) */
#endif /* NRF_ASSERT_H_ */

425
nRF5_SDK_11.0.0_89a8197/components/libraries/util/nrf_log.c Normal file
View File

@@ -0,0 +1,425 @@
#include "nrf.h"
#include "nrf_log.h"
#include "nrf_error.h"
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#if defined(NRF_LOG_USES_RTT) && NRF_LOG_USES_RTT == 1
#include <SEGGER_RTT_Conf.h>
#include <SEGGER_RTT.h>
static char buf_normal_up[BUFFER_SIZE_UP];
static char buf_down[BUFFER_SIZE_DOWN];
uint32_t log_rtt_init(void)
{
static bool initialized = false;
if (initialized)
{
return NRF_SUCCESS;
}
if (SEGGER_RTT_ConfigUpBuffer(LOG_TERMINAL_NORMAL,
"Normal",
buf_normal_up,
BUFFER_SIZE_UP,
SEGGER_RTT_MODE_NO_BLOCK_TRIM
)
!= 0)
{
return NRF_ERROR_INVALID_STATE;
}
if (SEGGER_RTT_ConfigDownBuffer(LOG_TERMINAL_INPUT,
"Input",
buf_down,
BUFFER_SIZE_DOWN,
SEGGER_RTT_MODE_NO_BLOCK_SKIP
)
!= 0)
{
return NRF_ERROR_INVALID_STATE;
}
initialized = true;
return NRF_SUCCESS;
}
// Forward declaration of SEGGER RTT vprintf function
int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
void log_rtt_printf(int terminal_index, char * format_msg, ...)
{
//lint -save -e526 -e628 -e530
va_list p_args;
va_start(p_args, format_msg);
(void)SEGGER_RTT_vprintf(terminal_index, format_msg, &p_args);
va_end(p_args);
//lint -restore
}
__INLINE void log_rtt_write_string(int terminal_index, int num_args, ...)
{
const char* msg;
//lint -save -e516 -e530
va_list p_args;
va_start(p_args, num_args);
//lint -restore
for (int i = 0; i < num_args; i++)
{
//lint -save -e26 -e10 -e64 -e526 -e628 -e530
msg = va_arg(p_args, const char*);
//lint -restore
(void)SEGGER_RTT_WriteString(terminal_index, msg);
}
va_end(p_args);
}
void log_rtt_write_hex(int terminal_index, uint32_t value)
{
char temp[11];
temp[0] = '0';
temp[1] = 'x';
temp[10] = 0; // Null termination
uint8_t nibble;
uint8_t i = 8;
while(i-- != 0)
{
nibble = (value >> (4 * i)) & 0x0F;
temp[9-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
}
(void)SEGGER_RTT_WriteString(terminal_index, temp);
}
void log_rtt_write_hex_char(int terminal_index, uint8_t value)
{
char temp[3];
temp[2] = 0; // Null termination
uint8_t nibble;
uint8_t i = 2;
while(i-- != 0)
{
nibble = (value >> (4 * i)) & 0x0F;
temp[1-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
}
(void)SEGGER_RTT_WriteString(terminal_index, temp);
}
__INLINE int log_rtt_has_input()
{
return SEGGER_RTT_HasKey();
}
uint32_t log_rtt_read_input(char * c)
{
int r;
r = SEGGER_RTT_Read(LOG_TERMINAL_INPUT, c, 1);
if (r == 1)
return NRF_SUCCESS;
else
return NRF_ERROR_NULL;
}
#elif defined(NRF_LOG_USES_UART) && NRF_LOG_USES_UART == 1
#include "app_uart.h"
#include "app_error.h"
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "bsp.h"
#define MAX_TEST_DATA_BYTES (15U) /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 512 /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 1 /**< UART RX buffer size. */
static uint8_t m_uart_data;
static bool m_uart_has_input;
void uart_error_cb(app_uart_evt_t * p_event)
{
if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
{
APP_ERROR_HANDLER(p_event->data.error_communication);
}
else if (p_event->evt_type == APP_UART_FIFO_ERROR)
{
APP_ERROR_HANDLER(p_event->data.error_code);
}
}
uint32_t log_uart_init()
{
static bool initialized = false;
if (initialized)
{
return NRF_SUCCESS;
}
uint32_t err_code;
const app_uart_comm_params_t comm_params =
{
RX_PIN_NUMBER,
TX_PIN_NUMBER,
RTS_PIN_NUMBER,
CTS_PIN_NUMBER,
APP_UART_FLOW_CONTROL_ENABLED,
false,
UART_BAUDRATE_BAUDRATE_Baud115200
};
APP_UART_FIFO_INIT(&comm_params,
UART_RX_BUF_SIZE,
UART_TX_BUF_SIZE,
uart_error_cb,
APP_IRQ_PRIORITY_LOW,
err_code);
initialized = true;
return err_code;
}
//lint -save -e530 -e64
void log_uart_printf(const char * format_msg, ...)
{
va_list p_args;
va_start(p_args, format_msg);
(void)vprintf(format_msg, p_args);
va_end(p_args);
}
__INLINE void log_uart_write_string_many(int num_args, ...)
{
const char* msg;
va_list p_args;
va_start(p_args, num_args);
for (int i = 0; i < num_args; i++)
{
msg = va_arg(p_args, const char*);
log_uart_write_string(msg);
}
va_end(p_args);
}
__INLINE void log_uart_write_string(const char* msg)
{
while( *msg )
{
(void)app_uart_put(*msg++);
}
}
//lint -restore
void log_uart_write_hex(uint32_t value)
{
uint8_t nibble;
uint8_t i = 8;
(void)app_uart_put('0');
(void)app_uart_put('x');
while( i-- != 0 )
{
nibble = (value >> (4 * i)) & 0x0F;
(void)app_uart_put( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
}
}
void log_uart_write_hex_char(uint8_t c)
{
uint8_t nibble;
uint8_t i = 2;
while( i-- != 0 )
{
nibble = (c >> (4 * i)) & 0x0F;
(void)app_uart_put( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
}
}
__INLINE int log_uart_has_input()
{
if (m_uart_has_input) return 1;
if (app_uart_get(&m_uart_data) == NRF_SUCCESS)
{
m_uart_has_input = true;
return 1;
}
return 0;
}
uint32_t log_uart_read_input(char * c)
{
if (m_uart_has_input)
{
*c = (char)m_uart_data;
m_uart_has_input = false;
return NRF_SUCCESS;
}
if (app_uart_get((uint8_t *)c) == NRF_SUCCESS)
{
return NRF_SUCCESS;
}
return NRF_ERROR_NULL;
}
#elif defined(NRF_LOG_USES_RAW_UART) && NRF_LOG_USES_RAW_UART == 1
#include "app_uart.h"
#include <stdio.h>
#include <string.h>
#include "bsp.h"
uint32_t log_raw_uart_init()
{
// Disable UART
NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Disabled;
// Configure RX/TX pins
nrf_gpio_cfg_output( TX_PIN_NUMBER );
nrf_gpio_cfg_input(RX_PIN_NUMBER, NRF_GPIO_PIN_NOPULL);
// Set a default baud rate of UART0_CONFIG_BAUDRATE
NRF_UART0->PSELTXD = TX_PIN_NUMBER;
NRF_UART0->BAUDRATE = UART0_CONFIG_BAUDRATE;
NRF_UART0->PSELRTS = 0xFFFFFFFF;
NRF_UART0->PSELCTS = 0xFFFFFFFF;
// Disable parity and interrupt
NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Excluded << UART_CONFIG_PARITY_Pos );
NRF_UART0->CONFIG |= (UART_CONFIG_HWFC_Disabled << UART_CONFIG_HWFC_Pos );
// Re-enable the UART
NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Enabled;
NRF_UART0->INTENSET = 0;
NRF_UART0->TASKS_STARTTX = 1;
NRF_UART0->TASKS_STARTRX = 1;
return NRF_SUCCESS;
}
void log_raw_uart_printf(const char * format_msg, ...)
{
static char buffer[256];
va_list p_args;
va_start(p_args, format_msg);
sprintf(buffer, format_msg, p_args);
va_end(p_args);
log_raw_uart_write_string(buffer);
}
__INLINE void log_raw_uart_write_char(const char c)
{
NRF_UART0->TXD = c;
while( NRF_UART0->EVENTS_TXDRDY != 1 );
NRF_UART0->EVENTS_TXDRDY = 0;
}
__INLINE void log_raw_uart_write_string_many(int num_args, ...)
{
const char* msg;
va_list p_args;
va_start(p_args, num_args);
for (int i = 0; i < num_args; i++)
{
msg = va_arg(p_args, const char*);
log_raw_uart_write_string(msg);
}
va_end(p_args);
}
__INLINE void log_raw_uart_write_string(const char* msg)
{
while( *msg )
{
NRF_UART0->TXD = *msg++;
while( NRF_UART0->EVENTS_TXDRDY != 1 );
NRF_UART0->EVENTS_TXDRDY = 0;
}
}
void log_raw_uart_write_hex(uint32_t value)
{
uint8_t nibble;
uint8_t i = 8;
log_raw_uart_write_string( "0x" );
while( i-- != 0 )
{
nibble = (value >> (4 * i)) & 0x0F;
log_raw_uart_write_char( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
}
}
void log_raw_uart_write_hex_char(uint8_t c)
{
uint8_t nibble;
uint8_t i = 2;
while( i-- != 0 )
{
nibble = (c >> (4 * i)) & 0x0F;
log_raw_uart_write_hex( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
}
}
__INLINE int log_raw_uart_has_input()
{
return 0;
}
uint32_t log_raw_uart_read_input(char * c)
{
return NRF_ERROR_NULL;
}
#endif // NRF_LOG_USES_RAW_UART == 1
const char* log_hex_char(const char c)
{
static volatile char hex_string[3];
hex_string[2] = 0; // Null termination
uint8_t nibble;
uint8_t i = 2;
while(i-- != 0)
{
nibble = (c >> (4 * i)) & 0x0F;
hex_string[1-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
}
return (const char*) hex_string;
}
const char* log_hex(uint32_t value)
{
static volatile char hex_string[11];
hex_string[0] = '0';
hex_string[1] = 'x';
hex_string[10] = 0;
uint8_t nibble;
uint8_t i = 8;
while(i-- != 0)
{
nibble = (value >> (4 * i)) & 0x0F;
hex_string[9-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
}
return (const char*)hex_string;
}

699
nRF5_SDK_11.0.0_89a8197/components/libraries/util/nrf_log.h Normal file
View File

@@ -0,0 +1,699 @@
#ifndef NRF_LOG_H_
#define NRF_LOG_H_
#ifndef DOXYGEN
#include <stdint.h>
#include <stdarg.h>
#include <app_util.h>
#ifndef NRF_LOG_USES_RTT
#define NRF_LOG_USES_RTT 0
#endif
#ifndef NRF_LOG_USES_UART
#define NRF_LOG_USES_UART 0
#endif
#ifndef NRF_LOG_USES_RAW_UART
#define NRF_LOG_USES_RAW_UART 0
#endif
#ifndef NRF_LOG_USES_COLORS
#define NRF_LOG_USES_COLORS 1
#endif
#if NRF_LOG_USES_COLORS == 1
#define NRF_LOG_COLOR_DEFAULT "\x1B[0m"
#define NRF_LOG_COLOR_BLACK "\x1B[1;30m"
#define NRF_LOG_COLOR_RED "\x1B[1;31m"
#define NRF_LOG_COLOR_GREEN "\x1B[1;32m"
#define NRF_LOG_COLOR_YELLOW "\x1B[1;33m"
#define NRF_LOG_COLOR_BLUE "\x1B[1;34m"
#define NRF_LOG_COLOR_MAGENTA "\x1B[1;35m"
#define NRF_LOG_COLOR_CYAN "\x1B[1;36m"
#define NRF_LOG_COLOR_WHITE "\x1B[1;37m"
#else
#define NRF_LOG_COLOR_DEFAULT
#define NRF_LOG_COLOR_BLACK
#define NRF_LOG_COLOR_RED
#define NRF_LOG_COLOR_GREEN
#define NRF_LOG_COLOR_YELLOW
#define NRF_LOG_COLOR_BLUE
#define NRF_LOG_COLOR_MAGENTA
#define NRF_LOG_COLOR_CYAN
#define NRF_LOG_COLOR_WHITE
#endif
#if defined(NRF_LOG_USES_RTT) && NRF_LOG_USES_RTT == 1
#define LOG_TERMINAL_NORMAL (0)
#define LOG_TERMINAL_ERROR (1)
#define LOG_TERMINAL_INPUT (0)
/**@brief Function for initializing the SEGGER RTT logger.
*
* @details See <a href="https://www.segger.com/jlink-rtt.html" target="_blank">segger.com</a>
* for information about SEGGER Real Time Transfer (RTT).
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use the macro @ref NRF_LOG_INIT instead.
*
* @retval NRF_SUCCESS If initialization was successful.
* @retval NRF_ERROR Otherwise.
*/
uint32_t log_rtt_init(void);
/**@brief Function for writing a printf string using RTT.
*
* @details The printf implementation in SEGGER's RTT is more efficient than
* the standard implementation. However, printf requires more processor time
* than other logging functions. Therefore, applications that require logging
* but need it to interfere as little as possible with the execution, should
* avoid using printf.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_PRINTF
* - @ref NRF_LOG_PRINTF_DEBUG
* - @ref NRF_LOG_PRINTF_ERROR
*
* @param terminal_index Segger RTT terminal index to use as output.
* @param format_msg Printf format string.
*/
void log_rtt_printf(int terminal_index, char * format_msg, ...);
/**@brief Function for writing a string using RTT.
*
* @details The string to write must be null-terminated, but the null termination will not be stored
* in the ring buffer.
* The impact of running this function should be very low compared to writing to UART.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG
* - @ref NRF_LOG_DEBUG
* - @ref NRF_LOG_ERROR
*
* @param terminal_index Segger RTT terminal index to use as output.
* @param num_args Number of arguments.
*/
void log_rtt_write_string(int terminal_index, int num_args, ...);
/**@brief Function for writing an integer as HEX using RTT.
*
* The output data is formatted as, for example, 0x89ABCDEF.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX
* - @ref NRF_LOG_HEX_DEBUG
* - @ref NRF_LOG_HEX_ERROR
*
* @param terminal_index Segger RTT terminal index to use as output.
* @param value Integer value to be printed as HEX.
*/
void log_rtt_write_hex(int terminal_index, uint32_t value);
/**@brief Function for writing a single character as HEX using RTT.
*
* The output string is formatted as, for example, AA.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX_CHAR
* - @ref NRF_LOG_HEX_CHAR_DEBUG
* - @ref NRF_LOG_HEX_CHAR_ERROR
*
* @param terminal_index Segger RTT terminal index to use as output.
* @param value Character to print as HEX.
*/
void log_rtt_write_hex_char(int terminal_index, uint8_t value);
/**@brief Function for checking if data is available in the input buffer.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use @ref NRF_LOG_HAS_INPUT instead.
*
* @retval 1 If characters are available to read.
* @retval 0 If no characters are available.
*/
int log_rtt_has_input(void);
/**@brief Function for reading one character from the input buffer.
*
* @param[out] p_char Pointer where to store the character.
*
* This function is available only when NRF_LOG_USES_RTT is defined as 1.
*
* @note Do not call this function directly. Use @ref NRF_LOG_READ_INPUT instead.
*
* @retval NRF_SUCCESS If the character was read out.
* @retval NRF_ERROR_INVALID_DATA If no character could be read.
*/
uint32_t log_rtt_read_input(char* p_char);
#define NRF_LOG_INIT() log_rtt_init() /*!< Initialize the module. */
#define NRF_LOG_PRINTF(...) log_rtt_printf(LOG_TERMINAL_NORMAL, ##__VA_ARGS__) /*!< Print a log message using printf. */
#define NRF_LOG_PRINTF_DEBUG(...) log_rtt_printf(LOG_TERMINAL_NORMAL, ##__VA_ARGS__) /*!< If DEBUG is set, print a log message using printf. */
#define NRF_LOG_PRINTF_ERROR(...) log_rtt_printf(LOG_TERMINAL_ERROR, ##__VA_ARGS__) /*!< Print a log message using printf to the error stream. */
#define NRF_LOG(...) log_rtt_write_string(LOG_TERMINAL_NORMAL, NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message. The input string must be null-terminated. */
#define NRF_LOG_DEBUG(...) log_rtt_write_string(LOG_TERMINAL_NORMAL, NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< If DEBUG is set, print a log message. The input string must be null-terminated. */
#define NRF_LOG_ERROR(...) log_rtt_write_string(LOG_TERMINAL_ERROR, NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message to the error stream. The input string must be null-terminated. */
#define NRF_LOG_HEX(val) log_rtt_write_hex(LOG_TERMINAL_NORMAL, val) /*!< Log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_DEBUG(val) log_rtt_write_hex(LOG_TERMINAL_NORMAL, val) /*!< If DEBUG is set, log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_ERROR(val) log_rtt_write_hex(LOG_TERMINAL_ERROR, val) /*!< Log an integer as HEX value to the error stream (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_CHAR(val) log_rtt_write_hex_char(LOG_TERMINAL_NORMAL, val) /*!< Log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_DEBUG(val) log_rtt_write_hex_char(LOG_TERMINAL_NORMAL, val) /*!< If DEBUG is set, log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_ERROR(val) log_rtt_write_hex_char(LOG_TERMINAL_ERROR, val) /*!< Log a character as HEX value to the error stream (example output: AA). */
#define NRF_LOG_HAS_INPUT() log_rtt_has_input() /*!< Check if the input buffer has unconsumed characters. */
#define NRF_LOG_READ_INPUT(p_char) log_rtt_read_input(p_char) /*!< Consume a character from the input buffer. */
#if !defined(DEBUG) && !defined(DOXYGEN)
#undef NRF_LOG_DEBUG
#define NRF_LOG_DEBUG(...)
#undef NRF_LOG_STR_DEBUG
#define NRF_LOG_STR_DEBUG(...)
#undef NRF_LOG_HEX_DEBUG
#define NRF_LOG_HEX_DEBUG(...)
#undef NRF_LOG_HEX_CHAR_DEBUG
#define NRF_LOG_HEX_CHAR_DEBUG(...)
#endif // !defined(DEBUG) && !defined(DOXYGEN)
#elif defined(NRF_LOG_USES_UART) && NRF_LOG_USES_UART == 1
/**@brief Function for initializing the UART logger.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note Do not call this function directly. Use the macro @ref NRF_LOG_INIT instead.
*
* @retval NRF_SUCCESS If initialization was successful.
* @retval NRF_ERROR Otherwise.
*/
uint32_t log_uart_init(void);
/**@brief Function for logging a printf string to UART.
*
* @details Printf requires more processor time
* than other logging functions. Therefore, applications that require logging
* but need it to interfere as little as possible with the execution, should
* avoid using printf.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_PRINTF
* - @ref NRF_LOG_PRINTF_DEBUG
* - @ref NRF_LOG_PRINTF_ERROR
*
* @param format_msg Printf format string.
*/
void log_uart_printf(const char * format_msg, ...);
/**@brief Function for logging a single character to UART.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @param c Character.
*/
void log_uart_write_char(const char c);
/**@brief Function for logging null-terminated strings to UART.
*
* @details This function is more efficient than using printf.
* The null termination will not be logged.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG
* - @ref NRF_LOG_DEBUG
* - @ref NRF_LOG_ERROR
*
* @param num_args Number of arguments.
*/
void log_uart_write_string_many(int num_args, ...);
/**@brief Function for logging a null-terminated string to UART.
*
* @details This function is more efficient than using printf.
* The null termination will not be logged.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG
* - @ref NRF_LOG_DEBUG
* - @ref NRF_LOG_ERROR
*
* @param msg Null-terminated string.
*/
void log_uart_write_string(const char* msg);
/**@brief Function for logging an integer value as HEX to UART.
*
* @details The output data is formatted as, for example, 0x89ABCDEF.
* This function is more efficient than printf.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX
* - @ref NRF_LOG_HEX_DEBUG
* - @ref NRF_LOG_HEX_ERROR
*
* @param value Integer value to be printed as HEX.
*/
void log_uart_write_hex(uint32_t value);
/**@brief Function for logging a single character as HEX to UART.
*
* @details The output string is formatted as, for example, AA.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX_CHAR
* - @ref NRF_LOG_HEX_CHAR_DEBUG
* - @ref NRF_LOG_HEX_CHAR_ERROR
*
* @param c Character.
*/
void log_uart_write_hex_char(uint8_t c);
/**@brief Function for checking if data is available in the input buffer.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note Do not call this function directly. Use @ref NRF_LOG_HAS_INPUT instead.
*
* @retval 1 If characters are available to read.
* @retval 0 If no characters are available.
*/
int log_uart_has_input(void);
/**@brief Function for reading one character from the input buffer.
*
* @param[out] p_char Pointer where to store the character.
*
* This function is available only when NRF_LOG_USES_UART is defined as 1.
*
* @note Do not call this function directly. Use NRF_LOG_READ_INPUT instead.
*
* @retval NRF_SUCCESS If the character was read out.
* @retval NRF_ERROR_INVALID_DATA If no character could be read.
*/
uint32_t log_uart_read_input(char* p_char);
#define NRF_LOG_INIT() log_uart_init() /*!< Initialize the module. */
#define NRF_LOG_PRINTF(...) log_uart_printf(__VA_ARGS__) /*!< Print a log message using printf. */
#define NRF_LOG_PRINTF_DEBUG(...) log_uart_printf(__VA_ARGS__) /*!< If DEBUG is set, print a log message using printf. */
#define NRF_LOG_PRINTF_ERROR(...) log_uart_printf(__VA_ARGS__) /*!< Print a log message using printf to the error stream. */
#define NRF_LOG(...) log_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message. The input string must be null-terminated. */
#define NRF_LOG_DEBUG(...) log_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< If DEBUG is set, print a log message. The input string must be null-terminated. */
#define NRF_LOG_ERROR(...) log_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message to the error stream. The input string must be null-terminated. */
#define NRF_LOG_HEX(val) log_uart_write_hex(val) /*!< Log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_DEBUG(val) log_uart_write_hex(val) /*!< If DEBUG is set, log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_ERROR(val) log_uart_write_hex(val) /*!< Log an integer as HEX value to the error stream (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_CHAR(val) log_uart_write_hex_char(val) /*!< Log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_DEBUG(val) log_uart_write_hex_char(val) /*!< If DEBUG is set, log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_ERROR(val) log_uart_write_hex_char(val) /*!< Log a character as HEX value to the error stream (example output: AA). */
#define NRF_LOG_HAS_INPUT() log_uart_has_input() /*!< Check if the input buffer has unconsumed characters. */
#define NRF_LOG_READ_INPUT(p_char) log_uart_read_input(p_char) /*!< Consume a character from the input buffer. */
#if !defined(DEBUG) && !defined(DOXYGEN)
#undef NRF_LOG_DEBUG
#define NRF_LOG_DEBUG(...)
#undef NRF_LOG_PRINTF_DEBUG
#define NRF_LOG_PRINTF_DEBUG(...)
#undef NRF_LOG_STR_DEBUG
#define NRF_LOG_STR_DEBUG(...)
#undef NRF_LOG_HEX_DEBUG
#define NRF_LOG_HEX_DEBUG(...)
#undef NRF_LOG_HEX_CHAR_DEBUG
#define NRF_LOG_HEX_CHAR_DEBUG(...)
#endif // !defined(DEBUG) && !defined(DOXYGEN)
#elif defined(NRF_LOG_USES_RAW_UART) && NRF_LOG_USES_RAW_UART == 1
/**@brief Function for initializing the raw UART logger.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note Do not call this function directly. Use the macro @ref NRF_LOG_INIT instead.
*
* @retval NRF_SUCCESS If initialization was successful.
* @retval NRF_ERROR Otherwise.
*/
uint32_t log_raw_uart_init(void);
/**@brief Function for logging a printf string to raw UART.
*
* @details Printf requires more processor time
* than other logging functions. Therefore, applications that require logging
* but need it to interfere as little as possible with the execution, should
* avoid using printf.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_PRINTF
* - @ref NRF_LOG_PRINTF_DEBUG
* - @ref NRF_LOG_PRINTF_ERROR
*
* @param format_msg Printf format string.
*/
void log_raw_uart_printf(const char * format_msg, ...);
/**@brief Function for logging a single character to raw UART.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @param c Character.
*/
void log_raw_uart_write_char(const char c);
/**@brief Function for logging null-terminated strings to raw UART.
*
* @details This function is more efficient than using printf.
* The null termination will not be logged.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG
* - @ref NRF_LOG_DEBUG
* - @ref NRF_LOG_ERROR
*
* @param num_args Number of arguments.
*/
void log_raw_uart_write_string_many(int num_args, ...);
/**@brief Function for logging a null-terminated string to raw UART.
*
* @details This function is more efficient than using printf.
* The null termination will not be logged.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG
* - @ref NRF_LOG_DEBUG
* - @ref NRF_LOG_ERROR
*
* @param str Null-terminated string.
*/
void log_raw_uart_write_string(const char * str);
/**@brief Function for logging an integer value as HEX to raw UART.
*
* @details The output data is formatted as, for example, 0x89ABCDEF.
* This function is more efficient than printf.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX
* - @ref NRF_LOG_HEX_DEBUG
* - @ref NRF_LOG_HEX_ERROR
*
* @param value Integer value to be printed as HEX.
*/
void log_raw_uart_write_hex(uint32_t value);
/**@brief Function for logging a single character as HEX to raw UART.
*
* @details The output string is formatted as, for example, AA.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note This function is non-blocking. If too much data is sent to the UART,
* some characters might be skipped.
*
* @note Do not call this function directly. Use one of the following macros instead:
* - @ref NRF_LOG_HEX_CHAR
* - @ref NRF_LOG_HEX_CHAR_DEBUG
* - @ref NRF_LOG_HEX_CHAR_ERROR
*
* @param c Character.
*/
void log_raw_uart_write_hex_char(uint8_t c);
/**@brief Function for checking if data is available in the input buffer.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note Do not call this function directly. Use @ref NRF_LOG_HAS_INPUT instead.
*
* @retval 1 If characters are available to read.
* @retval 0 If no characters are available.
*/
int log_raw_uart_has_input(void);
/**@brief Function for reading one character from the input buffer.
*
* @param[out] p_char Pointer where to store the character.
*
* This function is available only when NRF_LOG_USES_RAW_UART is defined as 1.
*
* @note Do not call this function directly. Use NRF_LOG_READ_INPUT instead.
*
* @retval NRF_SUCCESS If the character was read out.
* @retval NRF_ERROR_INVALID_DATA If no character could be read.
*/
uint32_t log_raw_uart_read_input(char* p_char);
#define NRF_LOG_INIT() log_raw_uart_init() /*!< nitialize the module. */
#define NRF_LOG_PRINTF(...) log_raw_uart_printf(__VA_ARGS__) /*!< Print a log message using printf. */
#define NRF_LOG_PRINTF_DEBUG(...) log_raw_uart_printf(__VA_ARGS__) /*!< If DEBUG is set, print a log message using printf. */
#define NRF_LOG_PRINTF_ERROR(...) log_raw_uart_printf(__VA_ARGS__) /*!< Print a log message using printf to the error stream. */
#define NRF_LOG(...) log_raw_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message. The input string must be null-terminated. */
#define NRF_LOG_DEBUG(...) log_raw_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< If DEBUG is set, print a log message. The input string must be null-terminated. */
#define NRF_LOG_ERROR(...) log_raw_uart_write_string_many(NUM_VA_ARGS(__VA_ARGS__), ##__VA_ARGS__) /*!< Print a log message to the error stream. The input string must be null-terminated. */
#define NRF_LOG_HEX(val) log_raw_uart_write_hex(val) /*!< Log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_DEBUG(val) log_raw_uart_write_hex(val) /*!< If DEBUG is set, log an integer as HEX value (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_ERROR(val) log_raw_uart_write_hex(val) /*!< Log an integer as HEX value to the error stream (example output: 0x89ABCDEF). */
#define NRF_LOG_HEX_CHAR(val) log_raw_uart_write_hex_char(val) /*!< Log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_DEBUG(val) log_raw_uart_write_hex_char(val) /*!< If DEBUG is set, log a character as HEX value (example output: AA). */
#define NRF_LOG_HEX_CHAR_ERROR(val) log_raw_uart_write_hex_char(val) /*!< Log a character as HEX value to the error stream (example output: AA). */
#define NRF_LOG_HAS_INPUT() log_raw_uart_has_input() /*!< Check if the input buffer has unconsumed characters. */
#define NRF_LOG_READ_INPUT(p_char) log_raw_uart_read_input(p_char) /*!< Consume a character from the input buffer. */
#if !defined(DEBUG) && !defined(DOXYGEN)
#undef NRF_LOG_DEBUG
#define NRF_LOG_DEBUG(...)
#undef NRF_LOG_PRINTF_DEBUG
#define NRF_LOG_PRINTF_DEBUG(...)
#undef NRF_LOG_STR_DEBUG
#define NRF_LOG_STR_DEBUG(...)
#undef NRF_LOG_HEX_DEBUG
#define NRF_LOG_HEX_DEBUG(...)
#undef NRF_LOG_HEX_CHAR_DEBUG
#define NRF_LOG_HEX_CHAR_DEBUG(...)
#endif // !defined(DEBUG) && !defined(DOXYGEN)
#else
#include "nrf_error.h"
#include "nordic_common.h"
// Empty definitions
#define NRF_LOG_INIT() NRF_SUCCESS
#define NRF_LOG(...)
#define NRF_LOG_DEBUG(...)
#define NRF_LOG_ERROR(...)
#define NRF_LOG_PRINTF(...)
#define NRF_LOG_PRINTF_DEBUG(...)
#define NRF_LOG_PRINTF_ERROR(...)
#define NRF_LOG_HEX(val)
#define NRF_LOG_HEX_DEBUG(val)
#define NRF_LOG_HEX_ERROR(val)
#define NRF_LOG_HEX_CHAR(val)
#define NRF_LOG_HEX_CHAR_DEBUG(val)
#define NRF_LOG_HEX_CHAR_ERROR(val)
#define NRF_LOG_HAS_INPUT() 0
#define NRF_LOG_READ_INPUT(ignore) NRF_SUCCESS
#endif
/**@brief Function for writing HEX values.
*
* @note This function not thread-safe. It is written for convenience.
* If you log from different application contexts, you might get different results.
*
* @retval NULL By default.
*/
const char* log_hex(uint32_t value);
/**@brief Function for writing HEX characters.
*
* @note This function not thread-safe. It is written for convenience.
* If you log from different application contexts, you might get different results.
*
* @retval NULL By default.
*/
const char* log_hex_char(const char value);
#else // DOXYGEN
/** @defgroup nrf_log UART/RTT logging
* @{
* @ingroup app_common
*
* @brief Library to output logging information over SEGGER's Real Time Transfer
* (RTT), UART, or raw UART.
*
* This library provides macros that call the respective functions depending on
* which protocol is used. Define LOG_USES_RTT=1 to enable logging over RTT,
* NRF_LOG_USES_UART=1 to enable logging over UART, or NRF_LOG_USES_RAW_UART=1
* to enable logging over raw UART. One of these defines must be set for any of
* the macros to have effect. If you choose to not output information, all
* logging macros can be left in the code without any cost; they will just be
* ignored.
*/
/**@brief Macro for initializing the logger.
*
* @retval NRF_SUCCESS If initialization was successful.
* @retval NRF_ERROR Otherwise.
*/
uint32_t NRF_LOG_INIT(void);
/**@brief Macro for logging null-terminated strings.
*
* @details This function is more efficient than using printf.
* The null termination will not be logged.
*
* @param msg Null-terminated string.
*/
void NRF_LOG(const char* msg);
/**@brief Macro for logging a printf string.
*
* @details Printf requires more processor time
* than other logging functions. Therefore, applications that require logging
* but need it to interfere as little as possible with the execution, should
* avoid using printf.
*
* @note When NRF_LOG_USES_UART is set to 1, this macro is non-blocking.
* If too much data is sent, some characters might be skipped.
*
* @param format_msg Printf format string.
* @param ... Additional arguments replacing format specifiers in format_msg.
*/
void NRF_LOG_PRINTF(const char * format_msg, ...);
/**@brief Macro for logging an integer value as HEX.
*
* @details The output data is formatted as, for example, 0x89ABCDEF.
* This function is more efficient than printf.
*
* @note When NRF_LOG_USES_UART is set to 1, this macro is non-blocking.
* If too much data is sent, some characters might be skipped.
*
* @param value Integer value to be printed as HEX.
*/
void NRF_LOG_HEX(uint32_t value);
/**@brief Macro for logging a single character as HEX.
*
* @details The output string is formatted as, for example, AA.
*
* @note When NRF_LOG_USES_UART is set to 1, this macro is non-blocking.
* If too much data is sent, some characters might be skipped.
*
* @param c Character.
*/
void NRF_LOG_HEX_CHAR(uint8_t c);
/**@brief Macro for checking if data is available in the input buffer.
*
* @note When NRF_LOG_USES_UART is set to 1, this macro is non-blocking.
* If too much data is sent, some characters might be skipped.
*
* @retval 1 If characters are available to read.
* @retval 0 If no characters are available.
*/
int NRF_LOG_HAS_INPUT(void);
/**@brief Macro for reading one character from the input buffer.
*
* @param[out] p_char Pointer where to store the character.
*
* @retval NRF_SUCCESS If the character was read out.
* @retval NRF_ERROR_INVALID_DATA If no character could be read.
*/
uint32_t NRF_LOG_READ_INPUT(char* p_char);
/** @} */
#endif // DOXYGEN
#endif // NRF_LOG_H_

174
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_common.h Normal file
View File

@@ -0,0 +1,174 @@
/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @cond */
/**@file
*
* @ingroup experimental_api
* @defgroup sdk_common SDK Common Header
* @breif All common headers needed for SDK examples will be included here so that application
* developer does not have to include headers on him/herself.
* @{
*/
#ifndef SDK_COMMON_H__
#define SDK_COMMON_H__
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "nordic_common.h"
#include "compiler_abstraction.h"
#include "sdk_os.h"
#include "sdk_errors.h"
#include "app_util.h"
/**@brief Macro for verifying that the module is initialized. It will cause the function to return
* if not.
*
* @param[in] param The variable to check if is NULL.
*/
#ifndef DISABLE_PARAM_CHECK
#define VERIFY_PARAM_NOT_NULL(param) \
do \
{ \
if (param == NULL) \
{ \
return NRF_ERROR_NULL; \
} \
} while(0)
#else
#define VERIFY_PARAM_NOT_NULL()
#endif /* DISABLE_PARAM_CHECK */
/**@brief Macro for verifying that the module is initialized. It will cause the function to return
* if not.
*
* @param[in] param The variable to check if is NULL.
*/
#ifndef DISABLE_PARAM_CHECK
#define VERIFY_PARAM_NOT_NULL_VOID(param) \
do \
{ \
if (param == NULL) \
{ \
return; \
} \
} while(0)
#else
#define VERIFY_PARAM_NOT_NULL_VOID()
#endif /* DISABLE_PARAM_CHECK */
/**@brief Macro for verifying that a function returned NRF_SUCCESS. Will return the err code
* if not.
*
* @param[in] err_code The error code to check.
*/
#ifndef DISABLE_PARAM_CHECK
#define VERIFY_SUCCESS(err_code) \
do \
{ \
if (err_code != NRF_SUCCESS) \
{ \
return err_code; \
} \
} while(0)
#else
#define VERIFY_SUCCESS()
#endif /* DISABLE_PARAM_CHECK */
/**@brief Macro for verifying that a function returned NRF_SUCCESS. Will return if not.
*
* @param[in] err_code The error code to check.
*/
#ifndef DISABLE_PARAM_CHECK
#define VERIFY_SUCCESS_VOID(err_code) \
do \
{ \
if (err_code != NRF_SUCCESS) \
{ \
return; \
} \
} while(0)
#else
#define VERIFY_SUCCESS_VOID()
#endif /* DISABLE_PARAM_CHECK */
/**@brief Macro for verifying statement to be true. Will return err_code if not.
*
* @param[in] statement Statement to test.
* @param[in] err_code Error value to return if test was invalid.
*
* @retval err_code if test fails.
*/
#define VERIFY_TRUE(statement, err_code) \
do \
{ \
if (!(statement)) \
{ \
return err_code; \
} \
} while(0)
/**@brief Macro for verifying statement to be true. Will return if not.
*
* @param[in] statement Statement to test.
*/
#define VERIFY_TRUE_VOID(statement) \
do \
{ \
if (!(statement)) \
{ \
return; \
} \
} while(0)
/**@brief Macro for verifying statement to be false. Will return err_code if not.
*
* @param[in] statement Statement to test.
* @param[in] err_code Error value to return if test was invalid.
*
* @retval err_code if test fails.
*/
#define VERIFY_FALSE(statement, err_code) \
do \
{ \
if ((statement)) \
{ \
return err_code; \
} \
} while(0)
/**@brief Macro for verifying statement to be false. Will return if not.
*
* @param[in] statement Statement to test.
*/
#define VERIFY_FALSE_VOID(statement) \
do \
{ \
if ((statement)) \
{ \
return; \
} \
} while(0)
/** @} */
/** @endcond */
#endif // SDK_COMMON_H__

115
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_errors.h Normal file
View File

@@ -0,0 +1,115 @@
/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/**@file
*
* @defgroup sdk_error SDK Error codes
* @{
* @ingroup app_common
* @{
* @details Error codes are 32-bit unsigned integers with the most significant 16-bit reserved for
* identifying the module where the error occurred while the least least significant LSB
* are used to provide the cause or nature of error. Each module is assigned a 16-bit
* unsigned integer. Which it will use to identify all errors that occurred in it. 16-bit
* LSB range is with module id as the MSB in the 32-bit error code is reserved for the
* module. As an example, if 0x8800 identifies a certain SDK module, all values from
* 0x88000000 - 0x8800FFFF are reserved for this module.
* It should be noted that common error reasons have been assigned values to make it
* possible to decode error reason easily. As an example, lets module uninitialized has
* been assigned an error code 0x000A0. Then, if application encounters an error code
* 0xZZZZ00A0, it knows that it accessing a certain module without initializing it.
* Apart from this, each module is allowed to define error codes that are not covered by
* the common ones, however, these values are defined in a range that does not conflict
* with common error values. For module, specific error however, it is possible that the
* same error value is used by two different modules to indicated errors of very different
* nature. If error is already defined by the NRF common error codes, these are reused.
* A range is reserved for application as well, it can use this range for defining
* application specific errors.
*
* @note Success code, NRF_SUCCESS, does not include any module identifier.
*/
#ifndef SDK_ERRORS_H__
#define SDK_ERRORS_H__
#include <stdint.h>
#include "nrf_error.h"
/**
* @defgroup sdk_err_base Base defined for SDK Modules
* @{
*/
#define SDK_ERROR_BASE (NRF_ERROR_BASE_NUM + 0x8000) /**< Base value defined for SDK module identifiers. */
#define SDK_COMMON_ERROR_BASE (NRF_ERROR_BASE_NUM + 0x0080) /**< Base error value to be used for SDK error values. */
/* @} */
/**
* @defgroup sdk_module_codes Codes reserved as identification for module where the error occurred.
* @{
*/
#define DEVICE_MANAGER_ERR_BASE (0x8000)
#define MEMORY_MANAGER_ERR_BASE (0x8100)
/* @} */
/**
* @defgroup sdk_iot_errors Codes reserved as identification for IoT errors.
* @{
*/
#define IOT_ERR_BASE_START (0xA000)
#define IOT_ERR_BASE_STOP (0xAFFF)
/* @} */
/**
* @defgroup sdk_common_errors Codes reserved as identification for common errors.
* @{
*/
#define MODULE_NOT_INITIALZED (SDK_COMMON_ERROR_BASE + 0x0000)
#define MUTEX_INIT_FAILED (SDK_COMMON_ERROR_BASE + 0x0001)
#define MUTEX_LOCK_FAILED (SDK_COMMON_ERROR_BASE + 0x0002)
#define MUTEX_UNLOCK_FAILED (SDK_COMMON_ERROR_BASE + 0x0003)
#define MUTEX_COND_INIT_FAILED (SDK_COMMON_ERROR_BASE + 0x0004)
#define MODULE_ALREADY_INITIALIZED (SDK_COMMON_ERROR_BASE + 0x0005)
#define API_NOT_IMPLEMENTED (SDK_COMMON_ERROR_BASE + 0x0010)
#define FEATURE_NOT_ENABLED (SDK_COMMON_ERROR_BASE + 0x0011)
/* @} */
/**
* @defgroup dm_specific_errors Error / status codes specific to device manager.
* @{
*/
#define DM_NO_APP_CONTEXT (DEVICE_MANAGER_ERR_BASE + 0x0040)
#define DM_SERVICE_CONTEXT_NOT_APPLIED (DEVICE_MANAGER_ERR_BASE + 0x0041)
#define DM_CONTEXT_INFO_LOST (DEVICE_MANAGER_ERR_BASE + 0x0042)
#define DM_DEVICE_CONTEXT_FULL (DEVICE_MANAGER_ERR_BASE + 0x0043)
/* @} */
/**
* @brief API Result.
*
* @details Indicates success or failure of an API procedure. In case of failure, a comprehensive
* error code indicating cause or reason for failure is provided.
*
* Though called an API result, it could used in Asynchronous notifications callback along
* with asynchronous callback as event result. This mechanism is employed when an event
* marks the end of procedure initiated using API. API result, in this case, will only be
* an indicative of whether the procedure has been requested successfully.
*/
typedef uint32_t ret_code_t;
/** @} */
/** @} */
#endif // SDK_ERRORS_H__

72
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_macros.h Normal file
View File

@@ -0,0 +1,72 @@
/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @cond */
/**@file
*
* @ingroup sdk_util
* @defgroup sdk_common_macros SDK Common Header
* @breif Macros for parameter checking and similar tasks
* @{
*/
#ifndef SDK_MACROS_H__
#define SDK_MACROS_H__
/**@brief Macro for verifying that the module is initialized. It will cause the function to return
* @ref NRF_ERROR_INVALID_STATE if not.
*/
#ifdef DISABLE_PARAM_CHECK
#define VERIFY_MODULE_INITIALIZED()
#else
#ifdef MODULE_INITIALIZED
#define VERIFY_MODULE_INITIALIZED() \
do \
{ \
if (!MODULE_INITIALIZED) \
{ \
return NRF_ERROR_INVALID_STATE; \
} \
} while(0)
#else
#define VERIFY_MODULE_INITIALIZED()
#endif /* MODULE_INITIALIZED */
#endif /* DISABLE_PARAM_CHECK */
/**@brief Macro for verifying that the module is initialized. It will cause the function to return
* if not.
*/
#ifdef DISABLE_PARAM_CHECK
#define VERIFY_MODULE_INITIALIZED_VOID()
#else
#ifdef MODULE_INITIALIZED
#define VERIFY_MODULE_INITIALIZED_VOID() \
do \
{ \
if (!MODULE_INITIALIZED) \
{ \
return; \
} \
} while(0)
#else
#define VERIFY_MODULE_INITIALIZED_VOID()
#endif /* MODULE_INITIALIZED */
#endif /* DISABLE_PARAM_CHECK */
/** @} */
/** @endcond */
#endif // SDK_MACROS_H__

161
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_mapped_flags.c Normal file
View File

@@ -0,0 +1,161 @@
/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#include "sdk_mapped_flags.h"
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "compiler_abstraction.h"
/**@brief Function for setting the state of a flag to true.
*
* @note This function does not check whether the index is valid.
*
* @param[in] p_flags The collection of flags to modify.
* @param[in] index The index of the flag to modify.
*/
static __INLINE void sdk_mapped_flags_set_by_index(sdk_mapped_flags_t * p_flags, uint16_t index)
{
*p_flags |= (1U << index);
}
/**@brief Function for setting the state of a flag to false.
*
* @note This function does not check whether the index is valid.
*
* @param[in] p_flags The collection of flags to modify.
* @param[in] index The index of the flag to modify.
*/
static __INLINE void sdk_mapped_flags_clear_by_index(sdk_mapped_flags_t * p_flags, uint16_t index)
{
*p_flags &= ~(1U << index);
}
/**@brief Function for getting the state of a flag.
*
* @note This function does not check whether the index is valid.
*
* @param[in] p_flags The collection of flags to read.
* @param[in] index The index of the flag to get.
*/
static __INLINE bool sdk_mapped_flags_get_by_index(sdk_mapped_flags_t flags, uint16_t index)
{
return ((flags & (1 << index)) != 0);
}
uint16_t sdk_mapped_flags_first_key_index_get(sdk_mapped_flags_t flags)
{
for (uint16_t i = 0; i < SDK_MAPPED_FLAGS_N_KEYS; i++)
{
if (sdk_mapped_flags_get_by_index(flags, i))
{
return i;
}
}
return SDK_MAPPED_FLAGS_INVALID_INDEX;
}
void sdk_mapped_flags_update_by_key(uint16_t * p_keys,
sdk_mapped_flags_t * p_flags,
uint16_t key,
bool value)
{
sdk_mapped_flags_bulk_update_by_key(p_keys, p_flags, 1, key, value);
}
void sdk_mapped_flags_bulk_update_by_key(uint16_t * p_keys,
sdk_mapped_flags_t * p_flags,
uint32_t n_flag_collections,
uint16_t key,
bool value)
{
if ((p_keys != NULL) && (p_flags != NULL) && (n_flag_collections > 0))
{
for (uint32_t i = 0; i < SDK_MAPPED_FLAGS_N_KEYS; i++)
{
if (p_keys[i] == key)
{
for (uint32_t j = 0; j < n_flag_collections; j++)
{
if (value)
{
sdk_mapped_flags_set_by_index(&p_flags[j], i);
}
else
{
sdk_mapped_flags_clear_by_index(&p_flags[j], i);
}
}
return;
}
}
}
}
bool sdk_mapped_flags_get_by_key(uint16_t * p_keys, sdk_mapped_flags_t flags, uint16_t key)
{
if (p_keys != NULL)
{
for (uint32_t i = 0; i < SDK_MAPPED_FLAGS_N_KEYS; i++)
{
if (p_keys[i] == key)
{
return sdk_mapped_flags_get_by_index(flags, i);
}
}
}
return false;
}
sdk_mapped_flags_key_list_t sdk_mapped_flags_key_list_get(uint16_t * p_keys,
sdk_mapped_flags_t flags)
{
sdk_mapped_flags_key_list_t key_list;
key_list.len = 0;
if (p_keys != NULL)
{
for (uint32_t i = 0; i < SDK_MAPPED_FLAGS_N_KEYS; i++)
{
if (sdk_mapped_flags_get_by_index(flags, i))
{
key_list.flag_keys[key_list.len++] = p_keys[i];
}
}
}
return key_list;
}
uint32_t sdk_mapped_flags_n_flags_set(sdk_mapped_flags_t flags)
{
uint32_t n_flags_set = 0;
for (uint32_t i = 0; i < SDK_MAPPED_FLAGS_N_KEYS; i++)
{
if (sdk_mapped_flags_get_by_index(flags, i))
{
n_flags_set += 1;
}
}
return n_flags_set;
}

153
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_mapped_flags.h Normal file
View File

@@ -0,0 +1,153 @@
/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#ifndef SDK_MAPPED_FLAGS_H__
#define SDK_MAPPED_FLAGS_H__
#include <stdint.h>
#include <stdbool.h>
#include "app_util.h"
#include "compiler_abstraction.h"
/**
* @file
* @defgroup sdk_mapped_flags Mapped flags
* @ingroup app_common
* @{
* @brief Module for writing and reading flags that are associated
* with keys.
*
* @details The flags are represented as bits in a bitmap called a <i>flag collection</i>. The keys
* are uint16_t. Each flag collection contains all flags of the same type, one flag for
* each key.
*
* The mapped flags module does not keep the flag states, nor the list of keys. These are
* provided in the API calls. A key's index in the key list determines which bit in the
* flag collection is associated with it. This module does not ever edit the key list, and
* does not edit flags except in function calls that take the flag collection as a pointer.
*
*/
#define SDK_MAPPED_FLAGS_N_KEYS 8 /**< The number of keys to keep flags for. This is also the number of flags in a flag collection. If changing this value, you might also need change the width of the sdk_mapped_flags_t type. */
#define SDK_MAPPED_FLAGS_N_KEYS_PER_BYTE 8 /**< The number of flags that fit in one byte. */
#define SDK_MAPPED_FLAGS_INVALID_INDEX 0xFFFF /**< A flag index guaranteed to be invalid. */
typedef uint8_t sdk_mapped_flags_t; /**< The bitmap to hold flags. Each flag is one bit, and each bit represents the flag state associated with one key. */
// Test whether the flag collection type is large enough to hold all the flags. If this fails,
// reduce SDK_MAPPED_FLAGS_N_KEYS or increase the size of sdk_mapped_flags_t.
STATIC_ASSERT((
sizeof(sdk_mapped_flags_t)*SDK_MAPPED_FLAGS_N_KEYS_PER_BYTE) >= SDK_MAPPED_FLAGS_N_KEYS);
/**@brief Type used to present a subset of the registered keys.
*/
typedef struct
{
uint32_t len; /**< The length of the list. */
uint16_t flag_keys[SDK_MAPPED_FLAGS_N_KEYS]; /**< The list of keys. */
} sdk_mapped_flags_key_list_t;
/**@brief Function for getting the first index at which the flag is true in the provided
* collection.
*
* @param[in] flags The flag collection to search for a flag set to true.
*
* @return The first index that has its flag set to true. If none were found, the
* function returns @ref SDK_MAPPED_FLAGS_INVALID_INDEX.
*/
uint16_t sdk_mapped_flags_first_key_index_get(sdk_mapped_flags_t flags);
/**@brief Function for updating the state of a flag.
*
* @param[in] p_keys The list of associated keys (assumed to have a length of
* @ref SDK_MAPPED_FLAGS_N_KEYS).
* @param[out] p_flags The flag collection to modify.
* @param[in] key The key to modify the flag of.
* @param[in] value The state to set the flag to.
*/
void sdk_mapped_flags_update_by_key(uint16_t * p_keys,
sdk_mapped_flags_t * p_flags,
uint16_t key,
bool value);
/**@brief Function for updating the state of the same flag in multiple flag collections.
*
* @details The key and value are the same for all flag collections in the p_flags array.
*
* @param[in] p_keys The list of associated keys (assumed to have a length of
* @ref SDK_MAPPED_FLAGS_N_KEYS).
* @param[out] p_flags The flag collections to modify.
* @param[out] n_flag_collections The number of flag collections in p_flags.
* @param[in] key The key to modify the flag of.
* @param[in] value The state to set the flag to.
*/
void sdk_mapped_flags_bulk_update_by_key(uint16_t * p_keys,
sdk_mapped_flags_t * p_flags,
uint32_t n_flag_collections,
uint16_t key,
bool value);
/**@brief Function for getting the state of a specific flag.
*
* @param[in] p_keys The list of associated keys (assumed to have a length of
* @ref SDK_MAPPED_FLAGS_N_KEYS).
* @param[in] flags The flag collection to read from.
* @param[in] key The key to get the flag for.
*
* @return The state of the flag.
*/
bool sdk_mapped_flags_get_by_key(uint16_t * p_keys, sdk_mapped_flags_t flags, uint16_t key);
/**@brief Function for getting a list of all keys that have a specific flag set to true.
*
* @param[in] p_keys The list of associated keys (assumed to have a length of
* @ref SDK_MAPPED_FLAGS_N_KEYS).
* @param[in] flags The flag collection to search.
*
* @return The list of keys.
*/
sdk_mapped_flags_key_list_t sdk_mapped_flags_key_list_get(uint16_t * p_keys,
sdk_mapped_flags_t flags);
/**@brief Function for getting the number of keys that have a specific flag set to true.
*
* @param[in] flags The flag collection to search.
*
* @return The number of keys.
*/
uint32_t sdk_mapped_flags_n_flags_set(sdk_mapped_flags_t flags);
/**@brief Function for querying whether any flags in the collection are set.
*
* @param[in] flags The flag collection to query.
*
* @retval true If one or more flags are set to true.
* @retval false Otherwise.
*/
static __INLINE bool sdk_mapped_flags_any_set(sdk_mapped_flags_t flags)
{
return (flags != 0);
}
/** @} */
#endif /* SDK_MAPPED_FLAGS_H__ */

40
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_os.h Normal file
View File

@@ -0,0 +1,40 @@
/* Copyright (c) 2013 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/** @cond */
/**@file
*
* @defgroup sdk_os SDK OS Abstraction
* @ingroup experimental_api
* @details In order to made SDK modules independent of use of an embedded OS, and permit
* application with varied task architecture, SDK abstracts the OS specific
* elements here in order to make all other modules agnostic to the OS or task
* architecture.
* @{
*/
#ifndef SDK_OS_H__
#define SDK_OS_H__
#define SDK_MUTEX_DEFINE(X)
#define SDK_MUTEX_INIT(X)
#define SDK_MUTEX_LOCK(X)
#define SDK_MUTEX_UNLOCK(X)
/**
* @defgroup os_data_type Data types.
*/
/** @} */
/** @endcond */
#endif // SDK_OS_H__

50
nRF5_SDK_11.0.0_89a8197/components/libraries/util/sdk_resources.h Normal file
View File

@@ -0,0 +1,50 @@
/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*/
/** @file
* @brief Definition file for resource usage by SoftDevice, ESB and Gazell.
*/
#ifndef APP_RESOURCES_H__
#define APP_RESOURCES_H__
#ifdef SOFTDEVICE_PRESENT
#include "nrf_sd_def.h"
#else
#define SD_PPI_RESTRICTED 0uL /**< 1 if PPI peripheral is restricted, 0 otherwise. */
#define SD_PPI_CHANNELS_USED 0uL /**< PPI channels utilized by SotfDevice (not available to th spplication). */
#define SD_PPI_GROUPS_USED 0uL /**< PPI groups utilized by SotfDevice (not available to th spplication). */
#define SD_TIMERS_USED 0uL /**< Timers used by SoftDevice. */
#define SD_SWI_USED 0uL /**< Software interrupts used by SoftDevice. */
#endif
#ifdef GAZELL_PRESENT
#include "nrf_gzll_resources.h"
#else
#define GZLL_PPI_CHANNELS_USED 0uL /**< PPI channels utilized by Gazell (not available to th spplication). */
#define GZLL_TIMERS_USED 0uL /**< Timers used by Gazell. */
#define GZLL_SWI_USED 0uL /**< Software interrupts used by Gazell */
#endif
#ifdef ESB_PRESENT
#include "nrf_esb_resources.h"
#else
#define ESB_PPI_CHANNELS_USED 0uL /**< PPI channels utilized by ESB (not available to th spplication). */
#define ESB_TIMERS_USED 0uL /**< Timers used by ESB. */
#define ESB_SWI_USED 0uL /**< Software interrupts used by ESB */
#endif
#define NRF_PPI_CHANNELS_USED (SD_PPI_CHANNELS_USED | GZLL_PPI_CHANNELS_USED | ESB_PPI_CHANNELS_USED)
#define NRF_PPI_GROUPS_USED (SD_PPI_GROUPS_USED)
#define NRF_SWI_USED (SD_SWI_USED | GZLL_SWI_USED | ESB_SWI_USED)
#define NRF_TIMERS_USED (SD_TIMERS_USED | GZLL_TIMERS_USED | ESB_TIMERS_USED)
#endif // APP_RESOURCES_H__