Serial + BLE + I2C + Timer + GPIO -> serial not works

[Gianmarco Scarpelli]

We are developing an application on the nRF52840 kit with SDK 15.2. We are using Keil as compiler. I have started developmet my application with the example ble_app_cscs. In this example I added the libraries for use the serial, I2C, timer and GPIO.
After that, when I start the application and I connecting the nRF52840 device with app and I receiveng data from UART, after a random time the serial stops to work, while the I2C, GPIO and timer works correctly.
The firmare is running and it communicate with the App but the function that receive from the Uart return always no data. The data continue to come from Uart, I can see them with oscylloscope, but the receive function say always no data. This happen after a random time, it can be immediatly or after some minutes.
When te uart stops to receive data, the error that it return is the numer 13 : timeout.
If I use the BLE or the UART separatly they work fine. I attached all project.
Do you have any idea about this problem?

ble_app_cscs.zip

[Jørgen Holmefjord]

Hi,

Which function is returning timeout error? What device are you receiving UART data from?

Best regards,
Jørgen

[Jørgen Holmefjord]

It seems that you do not check the error code returned from nrf_serial_read function calls. Are you sure there is no other error codes returned earlier in application execution that can explain the timeout error? You should always check errors returned from functions and perform appropriate actions if the error code is not success.

[Jørgen Holmefjord]

How can you check the error code from every call using the debugger? The error code is not static, it can change from call to call, depending on the state of library/driver/peripheral/etc. Normal procedure is to assign the return code to a variable, err_code, and pass this err_code to APP_ERROR_CHECK() macro. When an error occurs, the application will jump to error handler, app_error_handler. You can then set a breakpoint in the error handler and you will catch every error code.

[Gianmarco Scarpelli]

Hi,

I have inserted the function APP_ERROR_CHECK() after the function nrf_serial_read :

ret_loop = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 5 ) ;

APP_ERROR_CHECK ( ret_loop ) ;

When RFID reader read the badge, the application, with debugger active, stopped automatically in the function app_error_handler :

Why the application stopped automatically ?

[Jørgen Holmefjord]

NRF_BREAKPOINT_COND will insert a assembly operation forcing a breakpoint. Most likely one of the conditions above was true, but not the one you set a breakpoint in.

[Gianmarco Scarpelli]

Hi, 

I have does many test, these are the results :

Test 1 : 

ret_loop = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 5 ) ; 

After that the RFID reader read the badge many time, the serial stopped and not work. 

Test 2 :

ret_loop = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 5 ) ; 

APP_ERROR_CHECK ( ret_loop ) ;

The application enter in function app_error_handler with error code 0x0D, because really not receive data because the RFID reader not read the badge.

Test 3 :

ret_loop = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 5 ) ;

if ( ( ret_loop != NRF_SUCCESS ) && ( ret_loop != NRF_ERROR_TIMEOUT ) )
APP_ERROR_CHECK ( ret_loop ) ;

In this way i have filtered error code 0x0D. After that the RFID reader read the badge many time, the application not entry never in the function APP_ERROR_CHECK , and the serial not work. I understand that the serial not work also when in case RFID reader read the badge because i have inserted in a break point in case the function nrf_serial_read have received data.

[Jørgen Holmefjord]

Can you post the state of the UARTE registers (when it is not working) for the UARTE instance that stops working?

Have you tried passing a variable to the parameter p_read of nrf_serial_read, and see if it actually is able to read any bytes?

I suppose you have checked the UART line with a logic analyzer to see if there is any incoming data?

Are you able to transmitt data to the device when the UART is in error state?

[Gianmarco Scarpelli]

Hi,

These are the UARTE registers, when it is not working:

I have tried passing a variable to the parameter p_read of nrf_serial_read, but also in thiscase the UART stops working:

uint8_t p_read ;

ret_loop = nrf_serial_read ( &serial_uart , &p_read , 1 , NULL , 5 ) ;

I have verify that RFID reader sends the data to nrf-52840 kit with the oscilloscope.

If the UART is stops working, the application continue works.

[Jørgen Holmefjord]

I see you are using IRQ mode with the timeout parameter set. Did you notice the warning in the library documentation?

Warning

Do not use synchronous API (timeout_ms parameter > 0) in IRQ context. It may lead to a deadlock because the timeout interrupt cannot preempt the current IRQ context.

[Gianmarco Scarpelli]

Hi,

I have tried setting timeout_ms = 0 in all function that concern the serial. But the UART is alway stops working. I have attacched the file main.c .

Fullscreen 3568.main.c Download

/**
 * Copyright (c) 2014 - 2018, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
/** @file
 *
 * @defgroup ble_sdk_app_csc_main main.c
 * @{
 * @ingroup ble_sdk_app_csc
 * @brief Cycling Speed and Cadence Service Sample Application main file.
 *
 * This file contains the source code for a sample application using the Cycling Speed and Cadence
 * Service.
 * It also includes the sample code for Battery and Device Information services.
 * This application uses the @ref srvlib_conn_params module.
 *
 * This application implements supports for both Wheel revolution Data and Crank Revolution Data.
 * In addition, this application also has support for all 'Speed and Cadence Control Point'.
 */
#include <stdint.h>
#include <string.h>
#include <stdbool.h> // add
#include <stddef.h>	// add

#include "nrf_drv_clock.h"	// add
#include "nrf_gpio.h"	// add
#include "nrf_delay.h"	// add
#include "nrf_drv_power.h"	// add
#include "nrf_serial.h"	// add
#include "app_error.h"	// add
#include "app_util.h"	// add
#include "boards.h"	// add

#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_err.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_bas.h"
#include "ble_cscs.h"
#include "ble_dis.h"
#include "ble_conn_params.h"
#include "sensorsim.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "fds.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_gpio.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "BNO055.h"
#include "nrf_drv_twi.h"
#include "nrf_drv_timer.h"

#include "shared_data.h"

#define DEVICE_NAME                     "U-Tech NRF-BLE"                            /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME               "NordicSemiconductor"                       /**< Manufacturer. Will be passed to Device Information Service. */

#define APP_BLE_OBSERVER_PRIO           3                                           /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG            1                                           /**< A tag identifying the SoftDevice BLE configuration. */

#define APP_ADV_INTERVAL                40                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 25 ms). */

#define APP_ADV_DURATION                18000                                       /**< The advertising duration (180 seconds) in units of 10 milliseconds. */

#define BATTERY_LEVEL_MEAS_INTERVAL     APP_TIMER_TICKS(10) //APP_TIMER_TICKS(2000)/**< Battery level measurement interval (ticks). */
#define MIN_BATTERY_LEVEL               81                                          /**< Minimum battery level as returned by the simulated measurement function. */
#define MAX_BATTERY_LEVEL               100                                         /**< Maximum battery level as returned by the simulated measurement function. */
#define BATTERY_LEVEL_INCREMENT         1                                           /**< Value by which the battery level is incremented/decremented for each call to the simulated measurement function. */

#define SPEED_AND_CADENCE_MEAS_INTERVAL 80	                               						/**< Speed and cadence measurement interval (milliseconds). */

#define WHEEL_CIRCUMFERENCE_MM          2100                                        /**< Simulated wheel circumference in millimeters. */
#define KPH_TO_MM_PER_SEC               278                                         /**< Constant to convert kilometers per hour into millimeters per second. */

#define MIN_SPEED_KPH                   10                                          /**< Minimum speed in kilometers per hour for use in the simulated measurement function. */
#define MAX_SPEED_KPH                   40                                          /**< Maximum speed in kilometers per hour for use in the simulated measurement function. */
#define SPEED_KPH_INCREMENT             1                                           /**< Value by which speed is incremented/decremented for each call to the simulated measurement function. */

#define DEGREES_PER_REVOLUTION          360                                         /**< Constant used in simulation for calculating crank speed. */
#define RPM_TO_DEGREES_PER_SEC          6                                           /**< Constant to convert revolutions per minute into degrees per second. */

#define MIN_CRANK_RPM                   20                                          /**< Minimum cadence in RPM for use in the simulated measurement function. */
#define MAX_CRANK_RPM                   110                                         /**< Maximum cadence in RPM for use in the simulated measurement function. */
#define CRANK_RPM_INCREMENT             3                                           /**< Value by which cadence is incremented/decremented in the simulated measurement function. */

#define MIN_CONN_INTERVAL               MSEC_TO_UNITS ( 10 , UNIT_1_25_MS )         /**< Minimum acceptable connection interval (10 milliseconds). */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS ( 100 , UNIT_1_25_MS )        /**< Maximum acceptable connection interval (100 milliseconds). */
#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS ( 30000 , UNIT_10_MS )        /**< Connection supervisory timeout (30 seconds). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS ( 100 ) // APP_TIMER_TICKS(5000)                    /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS ( 100 ) // APP_TIMER_TICKS(30000)                  	/**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */

#define SEC_PARAM_BOND                  1                                           /**< Perform bonding. */
#define SEC_PARAM_MITM                  0                                           /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC                  0                                           /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS              0                                           /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES       BLE_GAP_IO_CAPS_NONE                        /**< No I/O capabilities. */
#define SEC_PARAM_OOB                   0                                           /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE          7                                           /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE          16                                          /**< Maximum encryption key size. */

#define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */

/******************* SERIAL DECLARATION. ****************** 
*/
static void 	sleep_handler ( void )
{
    __WFE ( ) ;
    __SEV ( ) ;
    __WFE ( ) ;
	
}

NRF_SERIAL_DRV_UART_CONFIG_DEF ( m_uart0_drv_config ,
                      RX_PIN_UART_BADGE , TX_PIN_UART_BADGE ,
                      RTS_PIN_NUMBER , CTS_PIN_NUMBER ,
                      NRF_UART_HWFC_DISABLED , NRF_UART_PARITY_EXCLUDED ,
                      NRF_UART_BAUDRATE_115200 ,
                      UART_DEFAULT_CONFIG_IRQ_PRIORITY ) ;


#define SERIAL_FIFO_TX_SIZE 	1024
#define SERIAL_FIFO_RX_SIZE 	1024

NRF_SERIAL_QUEUES_DEF ( serial_queues , SERIAL_FIFO_TX_SIZE , SERIAL_FIFO_RX_SIZE ) ;


#define SERIAL_BUFF_TX_SIZE 	1
#define SERIAL_BUFF_RX_SIZE 	1

NRF_SERIAL_BUFFERS_DEF ( serial_buffs , SERIAL_BUFF_TX_SIZE , SERIAL_BUFF_RX_SIZE ) ;

NRF_SERIAL_CONFIG_DEF (serial_config , NRF_SERIAL_MODE_IRQ ,	// NRF_SERIAL_MODE_DMA 
                      &serial_queues , &serial_buffs , NULL , sleep_handler ) ;


NRF_SERIAL_UART_DEF ( serial_uart , 1 ) ;
/********************************************************** 
*/

// ID LED
#define ID_LED_1	0
#define ID_LED_2	1
#define ID_LED_3	2
#define ID_LED_4	3

// Macro
#define OK	1 	
#define KO	0

#define BUFF_EQUAL		0

#define MAX_TRY_AGAIN_AUTOLISTCARD_COMMAND	3

// 5 millisecondi
#define TIME_MS_5		5

// Timeout
#define TIMEOUT_READING_BADGE			2000	// 2 sec

// MaxSonar
#define TIMEOUT_PULSE_MAXSONAR		10000	// us -> 5ms

#define RANGE_MINIMUM		300	// 30 mm

// State pulse
#define HIGH_PULSE_MAXSONAR				1
#define LOW_PULSE_MAXSONAR				0

#define ACTIVE_READING_TIME_PULSE_MAXSONAR		1

// Timer
#define TIMER_CONFIG_BIT_WIDTH_32bit	3
#define TIMER_CONFIG_FREQUENCY				4
#define TIMER_CONFIG_MODE							0

// TWI instance ID.
#if TWI0_ENABLED
#define TWI_INSTANCE_ID     0
#elif TWI1_ENABLED
#define TWI_INSTANCE_ID     1
#endif

BLE_BAS_DEF ( m_bas ) ;                                                             /**< Battery service instance. */
BLE_CSCS_DEF ( m_cscs ) ;                                                           /**< Cycling speed and cadence service instance. */
NRF_BLE_GATT_DEF ( m_gatt ) ;                                                       /**< GATT module instance. */
NRF_BLE_QWR_DEF ( m_qwr ) ;                                                         /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF ( m_advertising ) ;                                             /**< Advertising module instance. */
APP_TIMER_DEF ( m_battery_timer_id ) ;                                              /**< Battery timer. */
APP_TIMER_DEF ( m_csc_meas_timer_id ) ;                                             /**< CSC measurement timer. */

static uint16_t          m_conn_handle = BLE_CONN_HANDLE_INVALID ;                  /**< Handle of the current connection. */
static sensorsim_cfg_t   m_battery_sim_cfg ;                                        /**< Battery Level sensor simulator configuration. */
static sensorsim_state_t m_battery_sim_state ;                                      /**< Battery Level sensor simulator state. */

static sensorsim_cfg_t   m_speed_kph_sim_cfg ;                                      /**< Speed simulator configuration. */
static sensorsim_state_t m_speed_kph_sim_state ;                                    /**< Speed simulator state. */
static sensorsim_cfg_t   m_crank_rpm_sim_cfg ;                                      /**< Crank simulator configuration. */
static sensorsim_state_t m_crank_rpm_sim_state ;                                    /**< Crank simulator state. */

static uint32_t m_cumulative_wheel_revs ;                                           /**< Cumulative wheel revolutions. */
static bool     m_auto_calibration_in_progress ;                                    /**< Set when an autocalibration is in progress. */

// Variable 
char  				ACK [ ] = { 0x50 , 0x00 , 0x00 , 0x23 , 0x73 } ;
char					buff_received_uart_badge [ 30 ] = "" ;
char					UID_badge [ MAX_BUFF_BADGE ] = "" ;
char					char_UID_badge [ 10 ] = "" ;
uint8_t				buffer [ 512 ] = "" ;
int						index = 0 ;
uint8_t				error_system = false ;
bool					new_badge = false ;
uint16_t	  	pulse_width_MaxSonar = 0 ;
char					reading_pulse_active = OFF ;
uint32_t	  	tmp_pulse_width_MaxSonar = 0 ;
uint32_t	  	counter_reading_badge = 0 ;
bool					badge_update = false ;

// TWI instance
const 	nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE ( TWI_INSTANCE_ID ) ;

/**< Supported location for the sensor location. */
static ble_sensor_location_t supported_locations [ ] =                              
{
    BLE_SENSOR_LOCATION_FRONT_WHEEL,
    BLE_SENSOR_LOCATION_LEFT_CRANK,
    BLE_SENSOR_LOCATION_RIGHT_CRANK,
    BLE_SENSOR_LOCATION_LEFT_PEDAL,
    BLE_SENSOR_LOCATION_RIGHT_PEDAL,
    BLE_SENSOR_LOCATION_FRONT_HUB,
    BLE_SENSOR_LOCATION_REAR_DROPOUT,
    BLE_SENSOR_LOCATION_CHAINSTAY,
    BLE_SENSOR_LOCATION_REAR_WHEEL,
    BLE_SENSOR_LOCATION_REAR_HUB
};

static ble_uuid_t m_adv_uuids [ ] =                                                   /**< Universally unique service identifiers. */
{
    {BLE_UUID_CYCLING_SPEED_AND_CADENCE,  BLE_UUID_TYPE_BLE},
    {BLE_UUID_BATTERY_SERVICE,            BLE_UUID_TYPE_BLE},
    {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE}
};

// EXTERN
extern bno055_data 	data_BNO055 ;
extern bool					update_data_BNO055 ;
extern char					tmp_UID_badge [ MAX_BUFF_BADGE ] ;
extern uint8_t			package_send ;

// FUNCTION
static void 	advertising_start ( bool erase_bonds ) ;
char					init_autolistcard ( void ) ; 
bool 					twi_init ( void ) ;
uint16_t			read_pulse_MaxSonar ( void ) ;


/**@brief Callback function for asserts in the SoftDevice.
 *
 * @details This function will be called in case of an assert in the SoftDevice.
 *
 * @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 Assert.
 * @warning On assert from the SoftDevice, the system can only recover on reset.
 *
 * @param[in] line_num   Line number of the failing ASSERT call.
 * @param[in] file_name  File name of the failing ASSERT call.
 */
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
    app_error_handler(DEAD_BEEF, line_num, p_file_name);
}



/**@brief Function for handling Peer Manager events.
 *
 * @param[in] p_evt  Peer Manager event.
 */
static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    pm_handler_flash_clean(p_evt);

    switch (p_evt->evt_id)
    {
        case PM_EVT_PEERS_DELETE_SUCCEEDED:
            advertising_start(false);
            break;

        default:
            break;
    }
}



/**@brief Function for performing battery measurement and updating the Battery Level characteristic
 *        in Battery Service.
 */
static void battery_level_update(void)
{
    ret_code_t err_code;
    uint8_t  battery_level;

    // battery_level = (uint8_t)sensorsim_measure(&m_battery_sim_state, &m_battery_sim_cfg);

    err_code = ble_bas_battery_level_update(&m_bas, battery_level, BLE_CONN_HANDLE_ALL);
    if ((err_code != NRF_SUCCESS) &&
        (err_code != NRF_ERROR_INVALID_STATE) &&
        (err_code != NRF_ERROR_RESOURCES) &&
        (err_code != NRF_ERROR_BUSY) &&
        (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
       )
    {
        APP_ERROR_HANDLER(err_code);
    }
}



/**@brief Function for handling the Battery measurement timer timeout.
 *
 * @details This function will be called each time the battery level measurement timer expires.
 *
 * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
 *                       app_start_timer() call to the timeout handler.
 */
static void battery_level_meas_timeout_handler(void * p_context)
{
    UNUSED_PARAMETER(p_context);
    //battery_level_update();
}



/**@brief Function for populating simulated cycling speed and cadence measurements.
 */
static void csc_sim_measurement(ble_cscs_meas_t * p_measurement)
{
    static uint16_t cumulative_crank_revs = 0;
    static uint16_t event_time            = 0;
    static uint16_t wheel_revolution_mm   = 0;
    static uint16_t crank_rev_degrees     = 0;

    uint16_t mm_per_sec;
    uint16_t degrees_per_sec;
    uint16_t event_time_inc;

    // Per specification event time is in 1/1024th's of a second.
    event_time_inc = (1024 * SPEED_AND_CADENCE_MEAS_INTERVAL) / 1000;

    // Calculate simulated wheel revolution values.
    p_measurement->is_wheel_rev_data_present = true;

    mm_per_sec = KPH_TO_MM_PER_SEC * sensorsim_measure(&m_speed_kph_sim_state,
                                                       &m_speed_kph_sim_cfg);

    wheel_revolution_mm     += mm_per_sec * SPEED_AND_CADENCE_MEAS_INTERVAL / 1000;
    m_cumulative_wheel_revs += wheel_revolution_mm / WHEEL_CIRCUMFERENCE_MM;
    wheel_revolution_mm     %= WHEEL_CIRCUMFERENCE_MM;

    p_measurement->cumulative_wheel_revs = m_cumulative_wheel_revs;
    p_measurement->last_wheel_event_time =
        event_time + (event_time_inc * (mm_per_sec - wheel_revolution_mm) / mm_per_sec);

    // Calculate simulated cadence values.
    p_measurement->is_crank_rev_data_present = true;

    degrees_per_sec = RPM_TO_DEGREES_PER_SEC * sensorsim_measure(&m_crank_rpm_sim_state,
                                                                 &m_crank_rpm_sim_cfg);

    crank_rev_degrees     += degrees_per_sec * SPEED_AND_CADENCE_MEAS_INTERVAL / 1000;
    cumulative_crank_revs += crank_rev_degrees / DEGREES_PER_REVOLUTION;
    crank_rev_degrees     %= DEGREES_PER_REVOLUTION;

    p_measurement->cumulative_crank_revs = cumulative_crank_revs;
    p_measurement->last_crank_event_time =
        event_time + (event_time_inc * (degrees_per_sec - crank_rev_degrees) / degrees_per_sec);

    event_time += event_time_inc;
		
}



/**@brief Function for handling the Cycling Speed and Cadence measurement timer timeouts.
 *
 * @details This function will be called each time the cycling speed and cadence
 *          measurement timer expires.
 *
 * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
 *                       app_start_timer() call to the timeout handler.
 */
static void csc_meas_timeout_handler ( void * p_context )
{
    uint32_t        err_code;
    ble_cscs_meas_t cscs_measurement ;

    UNUSED_PARAMETER ( p_context ) ;
	
		/* VERIFICO SE DEVO INVIARE UN PACCHETTO ALL'APP */
		// Se il codice del badge non � valorizzato invio il pacchetto successivo
		if ( badge_update == true )
		{
			if ( strncmp ( UID_badge , tmp_UID_badge , 16 ) != STR_EQUAL ) 
				package_send = PACKAGE_1_SEND_BLE ;
			else
				package_send = PACKAGE_1_SEND_RESET_BLE ;
			
		}
		
		else if ( update_data_BNO055 == true )
			package_send = PACKAGE_2_SEND_BLE ;
		
		else
				package_send = DATA_NOT_AVAILABLE ;
		
		/* SE CI SONO DATI DISPONIBILI LI INVIO ALL'APP */
		if ( package_send != DATA_NOT_AVAILABLE )
		{							
			err_code = ble_cscs_measurement_send ( &m_cscs , &cscs_measurement ) ;	
			
			if ( err_code == NRF_SUCCESS )		
			{
				// Dati inviati correttamente aggiorno le variabili che
				// gestiscono l'invio dei dati ( attesa nuovo badge e
				// nuovi dati disponibili dal sensore BNO055 )
				if ( package_send == PACKAGE_1_SEND_BLE )
				{
					// Dati inviati correttamente, resetto la variabile
					badge_update = false ;
					
					strncpy ( tmp_UID_badge , UID_badge , 16 ) ;
					
					// Se invio il badge il led blinka una volta
					bsp_board_led_invert ( ID_LED_3 ) ;		
					nrf_delay_ms ( 10 ) ;		
					bsp_board_led_invert ( ID_LED_3 ) ;
					
				}
				
				
				else if ( package_send == PACKAGE_1_SEND_RESET_BLE )
				{					
					// Nota : non aggiorno l'array tmp_UID_badge perch� il codice badge passato � sempre lo stesso
					
					// Dati inviati correttamente, resetto la variabile
					badge_update = false ;
					
					// Badge eliminato resetto i buffer per poter inserire nuovamente quello cancellato
					memset ( tmp_UID_badge , 0 , sizeof ( tmp_UID_badge ) ) ;
					memset ( UID_badge , 0 , sizeof ( UID_badge ) ) ;
					
					// Se passo lo stesso badge il led blinka due volta
					bsp_board_led_invert ( ID_LED_3 ) ;		
					nrf_delay_ms ( 10 ) ;		
					bsp_board_led_invert ( ID_LED_3 ) ;
					nrf_delay_ms ( 200 ) ;	
					bsp_board_led_invert ( ID_LED_3 ) ;		
					nrf_delay_ms ( 10 ) ;		
					bsp_board_led_invert ( ID_LED_3 ) ;
					
				}
				
				
				else if ( package_send == PACKAGE_2_SEND_BLE )				
					update_data_BNO055 = false ;	
									
			}

		}

}



/**@brief Function for the Timer initialization.
 *
 * @details Initializes the timer module. This creates and starts application timers.
 */
static void timers_init(void)
{
    ret_code_t err_code;

    // Initialize timer module.
    err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);

    // Create timers.
//    err_code = app_timer_create(&m_battery_timer_id,
//                                APP_TIMER_MODE_SINGLE_SHOT,
//                                battery_level_meas_timeout_handler);
//    APP_ERROR_CHECK(err_code);

    // Create battery timer.
    err_code = app_timer_create(&m_csc_meas_timer_id,
                                APP_TIMER_MODE_REPEATED,
                                csc_meas_timeout_handler);
    APP_ERROR_CHECK(err_code);
}



/**@brief Function for the GAP initialization.
 *
 * @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the
 *          device including the device name, appearance, and the preferred connection parameters.
 */
static void gap_params_init(void)
{
    ret_code_t              err_code;
    ble_gap_conn_params_t   gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_CYCLING_SPEED_CADENCE_SENSOR);
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
    gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
    gap_conn_params.slave_latency     = SLAVE_LATENCY;
    gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}



/**@brief Function for initializing the GATT module.
 */
static void gatt_init(void)
{											  
    ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
    APP_ERROR_CHECK(err_code);

}


/**@brief Function for handling Queued Write Module errors.
 *
 * @details A pointer to this function will be passed to each service which may need to inform the
 *          application about an error.
 *
 * @param[in]   nrf_error   Error code containing information about what went wrong.
 */
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}



/**@brief Function for handling Speed and Cadence Control point events
 *
 * @details Function for handling Speed and Cadence Control point events.
 *          This function parses the event and in case the "set cumulative value" event is received,
 *          sets the wheel cumulative value to the received value.
 */
ble_scpt_response_t sc_ctrlpt_event_handler(ble_sc_ctrlpt_t     * p_sc_ctrlpt,
                                            ble_sc_ctrlpt_evt_t * p_evt)
{
    switch (p_evt->evt_type)
    {
        case BLE_SC_CTRLPT_EVT_SET_CUMUL_VALUE:
            m_cumulative_wheel_revs = p_evt->params.cumulative_value;
            break;

        case BLE_SC_CTRLPT_EVT_START_CALIBRATION:
            m_auto_calibration_in_progress = true;
            break;

        default:
            // No implementation needed.
            break;
    }
    return (BLE_SCPT_SUCCESS);
}



/**@brief Function for initializing services that will be used by the application.
 *
 * @details Initialize the Cycling Speed and Cadence, Battery and Device Information services.
 */
static void services_init(void)
{
    uint32_t              err_code;
    ble_cscs_init_t       cscs_init;
    ble_bas_init_t        bas_init;
    ble_dis_init_t        dis_init;
    ble_sensor_location_t sensor_location;
    nrf_ble_qwr_init_t    qwr_init = {0};

    // Initialize Queued Write Module.
    qwr_init.error_handler = nrf_qwr_error_handler;

    err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
    APP_ERROR_CHECK(err_code);

    // Initialize Cycling Speed and Cadence Service.
    memset(&cscs_init, 0, sizeof(cscs_init));

    cscs_init.evt_handler = NULL;
    cscs_init.feature     = BLE_CSCS_FEATURE_WHEEL_REV_BIT | BLE_CSCS_FEATURE_CRANK_REV_BIT |
                            BLE_CSCS_FEATURE_MULTIPLE_SENSORS_BIT;

    // Here the sec level for the Cycling Speed and Cadence Service can be changed/increased.
    cscs_init.csc_meas_cccd_wr_sec  = SEC_OPEN;
    cscs_init.csc_feature_rd_sec    = SEC_OPEN;
    cscs_init.csc_location_rd_sec   = SEC_OPEN;
    cscs_init.sc_ctrlpt_cccd_wr_sec = SEC_OPEN;
    cscs_init.sc_ctrlpt_wr_sec      = SEC_OPEN;

    cscs_init.ctrplt_supported_functions = BLE_SRV_SC_CTRLPT_CUM_VAL_OP_SUPPORTED
                                           | BLE_SRV_SC_CTRLPT_SENSOR_LOCATIONS_OP_SUPPORTED
                                           | BLE_SRV_SC_CTRLPT_START_CALIB_OP_SUPPORTED;
    cscs_init.ctrlpt_evt_handler            = sc_ctrlpt_event_handler;
    cscs_init.list_supported_locations      = supported_locations;
    cscs_init.size_list_supported_locations = sizeof(supported_locations) /
                                              sizeof(ble_sensor_location_t);

		// initializes the sensor location to add the sensor location characteristic.
    sensor_location           = BLE_SENSOR_LOCATION_FRONT_WHEEL;	
    cscs_init.sensor_location = &sensor_location;

    err_code = ble_cscs_init(&m_cscs, &cscs_init);
    APP_ERROR_CHECK(err_code);

    // Initialize Battery Service.
    memset(&bas_init, 0, sizeof(bas_init));

    // Here the sec level for the Battery Service can be changed/increased.
    bas_init.bl_rd_sec        = SEC_OPEN;
    bas_init.bl_cccd_wr_sec   = SEC_OPEN;
    bas_init.bl_report_rd_sec = SEC_OPEN;

    bas_init.evt_handler          = NULL;
    bas_init.support_notification = true;
    bas_init.p_report_ref         = NULL;
    bas_init.initial_batt_level   = 100;

    err_code = ble_bas_init(&m_bas, &bas_init);
    APP_ERROR_CHECK(err_code);

    // Initialize Device Information Service.
    memset(&dis_init, 0, sizeof(dis_init));

    ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, MANUFACTURER_NAME);

    dis_init.dis_char_rd_sec = SEC_OPEN;

    err_code = ble_dis_init(&dis_init);
    APP_ERROR_CHECK(err_code);
}



/**@brief Function for initializing the sensor simulators.
 */
static void sensor_simulator_init(void)
{
    m_battery_sim_cfg.min          = MIN_BATTERY_LEVEL;
    m_battery_sim_cfg.max          = MAX_BATTERY_LEVEL;
    m_battery_sim_cfg.incr         = BATTERY_LEVEL_INCREMENT;
    m_battery_sim_cfg.start_at_max = true;

    sensorsim_init(&m_battery_sim_state, &m_battery_sim_cfg);

    m_speed_kph_sim_cfg.min          = MIN_SPEED_KPH;
    m_speed_kph_sim_cfg.max          = MAX_SPEED_KPH;
    m_speed_kph_sim_cfg.incr         = SPEED_KPH_INCREMENT;
    m_speed_kph_sim_cfg.start_at_max = false;

    sensorsim_init(&m_speed_kph_sim_state, &m_speed_kph_sim_cfg);

    m_crank_rpm_sim_cfg.min          = MIN_CRANK_RPM;
    m_crank_rpm_sim_cfg.max          = MAX_CRANK_RPM;
    m_crank_rpm_sim_cfg.incr         = CRANK_RPM_INCREMENT;
    m_crank_rpm_sim_cfg.start_at_max = false;

    sensorsim_init(&m_crank_rpm_sim_state, &m_crank_rpm_sim_cfg);

    m_cumulative_wheel_revs        = 0;
    m_auto_calibration_in_progress = false;
		
}




/**@brief Function for starting application timers.
 */
static void application_timers_start(void)
{
    ret_code_t err_code;
    uint32_t csc_meas_timer_ticks;

    // Start application timers.
//    err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL);
//    APP_ERROR_CHECK(err_code);

    csc_meas_timer_ticks = APP_TIMER_TICKS(SPEED_AND_CADENCE_MEAS_INTERVAL);

    err_code = app_timer_start(m_csc_meas_timer_id, csc_meas_timer_ticks, NULL);
    APP_ERROR_CHECK(err_code);
}




/**@brief Function for handling the Connection Parameter events.
 *
 * @details This function will be called for all events in the Connection Parameters Module which
 *          are passed to the application.
 *          @note All this function does is to disconnect. This could have been done by simply
 *                setting the disconnect_on_fail configuration parameter, but instead we use the
 *                event handler mechanism to demonstrate its use.
 *
 * @param[in] p_evt  Event received from the Connection Parameters Module.
 */
static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
    ret_code_t err_code;

    if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
    {
        err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
        APP_ERROR_CHECK(err_code);
			
    }
		
}



/**@brief Function for handling a Connection Parameters error.
 *
 * @param[in] nrf_error  Error code containing information about what went wrong.
 */
static void conn_params_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for initializing the Connection Parameters module.
 */
static void conn_params_init(void)
{
    uint32_t               err_code;
    ble_conn_params_init_t connection_params_init;

    memset(&connection_params_init, 0, sizeof(connection_params_init));

    connection_params_init.p_conn_params                  = NULL;
    connection_params_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
    connection_params_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
    connection_params_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
    connection_params_init.start_on_notify_cccd_handle    = m_cscs.meas_handles.cccd_handle;
    connection_params_init.disconnect_on_fail             = false;
    connection_params_init.evt_handler                    = on_conn_params_evt;
    connection_params_init.error_handler                  = conn_params_error_handler;

    err_code = ble_conn_params_init(&connection_params_init);
    APP_ERROR_CHECK(err_code);
}




/**@brief Function for putting the chip into sleep mode.
 *
 * @note This function will not return.
 */
static void sleep_mode_enter(void)
{
    ret_code_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
    APP_ERROR_CHECK(err_code);

    // Prepare wakeup buttons.
    err_code = bsp_btn_ble_sleep_mode_prepare();
    APP_ERROR_CHECK(err_code);

    // Go to system-off mode (this function will not return; wakeup will cause a reset).
    err_code = sd_power_system_off();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling advertising events.
 *
 * @details This function will be called for advertising events which are passed to the application.
 *
 * @param[in] ble_adv_evt  Advertising event.
 */
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
    ret_code_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            NRF_LOG_INFO("Fast advertising");
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_ADV_EVT_IDLE:
            sleep_mode_enter();
            break;

        default:
            break;
    }
}



/**@brief Function for handling BLE events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 * @param[in]   p_context   Unused.
 */
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    ret_code_t err_code = NRF_SUCCESS;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected");
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
            APP_ERROR_CHECK(err_code);
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected");
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
				
						// Se si disconnette il BLE invio qualsiasi badge viene letto, 
						// anche se uguale al precedente
						memset ( tmp_UID_badge , 0 , sizeof ( tmp_UID_badge ) ) ;
						memset ( UID_badge , 0 , sizeof ( UID_badge ) ) ;
				
            break ;

        case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
        {
            NRF_LOG_DEBUG("PHY update request.");
            ble_gap_phys_t const phys =
            {
                .rx_phys = BLE_GAP_PHY_AUTO,
                .tx_phys = BLE_GAP_PHY_AUTO,
            };
            err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
            APP_ERROR_CHECK(err_code);
        } break;
				
        case BLE_GATTC_EVT_TIMEOUT:
            // Disconnect on GATT Client timeout event.
            NRF_LOG_DEBUG("GATT Client Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
				
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GATTS_EVT_TIMEOUT:
					
            // Disconnect on GATT Server timeout event.
            NRF_LOG_DEBUG("GATT Server Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
				
            APP_ERROR_CHECK(err_code);
            break;

        default:
            // No implementation needed.
            break;
    }
}





/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupt.
 */
static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}





/**@brief Function for handling events from the BSP module.
 *
 * @param[in]   event   Event generated by button press.
 */
static void bsp_event_handler(bsp_event_t event)
{
    ret_code_t err_code;

    switch (event)
    {
        case BSP_EVENT_SLEEP:
            sleep_mode_enter();
            break;

        case BSP_EVENT_DISCONNECT:
					
            err_code = sd_ble_gap_disconnect(m_conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            if (err_code != NRF_ERROR_INVALID_STATE)
            {
                APP_ERROR_CHECK(err_code);
            }
						
            break;

        case BSP_EVENT_WHITELIST_OFF:
					
            if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
            {
                err_code = ble_advertising_restart_without_whitelist(&m_advertising);
                if (err_code != NRF_ERROR_INVALID_STATE)
                {
                    APP_ERROR_CHECK(err_code);
                }
            }
						
            break;

        default:
            break;
    }
}








/**@brief Function for the Peer Manager initialization.
 */
static void peer_manager_init(void)
{
    ble_gap_sec_params_t sec_param;
    ret_code_t           err_code;

    err_code = pm_init();
    APP_ERROR_CHECK(err_code);

    memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));

    // Security parameters to be used for all security procedures.
    sec_param.bond           = SEC_PARAM_BOND;
    sec_param.mitm           = SEC_PARAM_MITM;
    sec_param.lesc           = SEC_PARAM_LESC;
    sec_param.keypress       = SEC_PARAM_KEYPRESS;
    sec_param.io_caps        = SEC_PARAM_IO_CAPABILITIES;
    sec_param.oob            = SEC_PARAM_OOB;
    sec_param.min_key_size   = SEC_PARAM_MIN_KEY_SIZE;
    sec_param.max_key_size   = SEC_PARAM_MAX_KEY_SIZE;
    sec_param.kdist_own.enc  = 1;
    sec_param.kdist_own.id   = 1;
    sec_param.kdist_peer.enc = 1;
    sec_param.kdist_peer.id  = 1;

    err_code = pm_sec_params_set(&sec_param);
    APP_ERROR_CHECK(err_code);

    err_code = pm_register(pm_evt_handler);
    APP_ERROR_CHECK(err_code);
		
}





/**@brief Clear bond information from persistent storage.
 */
static void delete_bonds(void)
{
    ret_code_t err_code;

    NRF_LOG_INFO("Erase bonds!");

    err_code = pm_peers_delete();
    APP_ERROR_CHECK(err_code);
}





/**@brief Function for initializing the Advertising functionality.
 */
static void advertising_init(void)
{
    ret_code_t             err_code;
    ble_advertising_init_t init;

    memset(&init, 0, sizeof(init));

    init.advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    init.advdata.include_appearance      = true;
    init.advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    init.advdata.uuids_complete.p_uuids  = m_adv_uuids;

    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;

    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}





/**@brief Function for initializing buttons and leds.
 *
 * @param[out] p_erase_bonds  Will be true if the clear bonding button was pressed to wake the application up.
 */
static void buttons_leds_init(bool * p_erase_bonds)
{
    ret_code_t err_code;
    bsp_event_t startup_event;

    err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler);
    APP_ERROR_CHECK(err_code);

    err_code = bsp_btn_ble_init(NULL, &startup_event);
    APP_ERROR_CHECK(err_code);

    *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}





/**@brief Function for initializing the nrf log module.
 */
static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}




/**@brief Function for initializing power management.
 */
static void power_management_init(void)
{
    ret_code_t err_code;
    err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
	
}




/**@brief Function for handling the idle state (main loop).
 *
 * @details If there is no pending log operation, then sleep until next the next event occurs.
 */
static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for starting advertising.
 */
static void advertising_start(bool erase_bonds)
{
    ret_code_t err_code;

    if (erase_bonds == true)
    {
        delete_bonds ( ) ;
        // Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
    }
    else
    {
        err_code = ble_advertising_start ( &m_advertising , BLE_ADV_MODE_FAST ) ;
        APP_ERROR_CHECK ( err_code ) ;
			
    }
		
}


/**
*		@brief 		function name  :  init_autolistcard ( void ) 
*		@details 	return			OK :	comando impostato correttamente						
*		
*/
char	init_autolistcard ( void ) 
{
	//		SEND ->  50 00 05 23 04 64 03 01 00 14
	//              |  |  |  |  |  |  |  |  |  |
	//              a  b  c  d  e  f  g  h  i  l

	// a = ACK 
	// b = Data lenght 1 to be transmitted exluding header and XOR
	// c = Data lenght 2 to be transmitted exluding header and XOR
	// d = Command
	// e = Card Type -> TYPE is 0x04: ISO15693 Only ( bit 2 )
	// f = Period -> The time interval between the antenna scanning. Generally set to 100ms, that is 0x64
	// g = ANT -> Which ant use to list the card ( 8 bit ) -> 0x00 will list card cooperatively of all antenna in one time. (Default setting)
	// h = NOTICE -> 0x01 = NOTICE when a tag enters the field
	// i = RFU -> Reserved
	// l = Checksum XOR
	
	// To more info read, pag.20 "OEM-DES devices Communication Protocol_4.4_EN.pdf"

	char					tmp_buff_send [ 10 ] = { 0x50 , 0x00 , 0x05 , 0x23 , 0x04 , 0x64 , 0x03 , 0x01 , 0x00 , 0x14 } ;
	unsigned int	try_again_index = 0 ;	
	
	#ifdef DEBUG_ON
	ret_code_t 		ret_error ;
	#endif
	
	// Se ci sono errori ritento MAX_TRY...
	for ( try_again_index = 0 ; try_again_index < MAX_TRY_AGAIN_AUTOLISTCARD_COMMAND ; try_again_index ++ )
	{	
		// Resetto il buffer
		memset ( buff_received_uart_badge , 0 , sizeof ( buff_received_uart_badge ) ) ;		
		
		( void ) nrf_serial_flush ( &serial_uart , 0 ) ;
		
		// Attivo la funzione autolistcard
		nrf_serial_write ( &serial_uart , &tmp_buff_send , 10 , NULL , 0 ) ;
						
		ret_code_t ret ;
		
		ret = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 5 , NULL , 0 ) ;
								
		// Verifico se ho ricevuto l'ACK
		if ( strncmp ( buff_received_uart_badge , ACK , 5 ) == BUFF_EQUAL )
		{
			// ACK ricevuto ...
			
			( void ) nrf_serial_flush ( &serial_uart , 0 ) ;	
			
			#ifdef DEBUG_ON
			// Debug
			print_Debug ( "ACK autolistcard ricevuto\r\n" ) ;
			#endif
			
			// Spengo il led
			bsp_board_led_invert ( ID_LED_3 ) ;	
			
			return OK ;
			
		}	
		
		#ifdef DEBUG_ON
		// Salvo l'errore da visualizzare
		// Nota: non posso inizializzare la variabile ret = 0 perch� NRF_SUCCESS � uguale a 0
		ret_error = ret ;
		#endif
		
		nrf_delay_ms ( 100 ) ;
		
	}
		
	#ifdef DEBUG_ON
	// DEBUG //
	// Stampo il codice letto 
	memset ( tmp_buff_debug , 0 , sizeof ( tmp_buff_debug ) ) ;
	
	sprintf ( tmp_buff_debug , "Comando autolistcard non eseguito correttamente per %i tentativi, codice:%i\r\n" , MAX_TRY_AGAIN_AUTOLISTCARD_COMMAND , ret_error ) ;
	
	print_Debug ( tmp_buff_debug ) ;
	
	///////////
	#endif
	
	// Spengo il led
	bsp_board_led_invert ( ID_LED_3 ) ;		
		
	// Rimango bloccato qui e segnalo l'errore facendo blinkare il LED 2
	while ( true )
	{
		bsp_board_led_invert ( ID_LED_4 ) ;		
		nrf_delay_ms ( 500 ) ;		
		bsp_board_led_invert ( ID_LED_4 ) ;	
		nrf_delay_ms ( 500 ) ;
		
	}
	
}


/**
 * @brief TWI initialization.
 */
bool 	twi_init ( void )
{
    ret_code_t err_code ;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = PIN_SCL_BNO055 ,	// SCL 26
       .sda                = PIN_SDA_BNO055 ,	// SDA 27	
       .frequency          = NRF_DRV_TWI_FREQ_100K ,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH ,
       .clear_bus_init     = false
    } ;

    err_code = nrf_drv_twi_init ( &m_twi , &twi_config , NULL , NULL ) ;
		
		if ( err_code != NRF_SUCCESS )
			return false ;
		
    // APP_ERROR_CHECK ( err_code ) ;
 
    nrf_drv_twi_enable ( &m_twi ) ;
		
		return true ;

}


/** @brief Function for reading pulse MaxSonar sensor.
 */
uint16_t 	read_pulse_MaxSonar ( void )
{		
	uint32_t counter_pulse = 0 ;
	uint32_t counter_time = 0 ;
		
	// 1 - Inizio a leggere l'onda quando il segnale � basso
	if ( nrf_gpio_pin_read ( RX_PIN_NUMBER ) == LOW_PULSE_MAXSONAR )
	{
		// Attivo il sengale 
		NRF_TIMER2->TASKS_CLEAR = ON ;
		NRF_TIMER2->TASKS_START = ON ;
		
		// Time-put 10 ms 
		while ( counter_time <= TIMEOUT_PULSE_MAXSONAR )
		{
			// 2 - Attendo di vederlo alto
			if ( nrf_gpio_pin_read ( RX_PIN_NUMBER ) == HIGH_PULSE_MAXSONAR )
			{
				// Fermo il time-out che attendeva di vedere il segnale alto
				NRF_TIMER2->TASKS_STOP = ON ;	
				
				// Cancello il timer e lo riattivo per conteggiare l'ampiezza del segnale
				NRF_TIMER2->TASKS_CLEAR = ON ;
				NRF_TIMER2->TASKS_START = ON ;
				
				// Ho trovato il segnale alto, continuo a leggerlo
				reading_pulse_active = ON ;

				break ;

			}			
			
			// Rchiamando TASKS_CAPTURE [ 0 ] aggiorno il valore del registro CC[0] 
			NRF_TIMER2->TASKS_CAPTURE [ 0 ] = ACTIVE_READING_TIME_PULSE_MAXSONAR ;				

			// Leggo il timer
			counter_time = NRF_TIMER2->CC [ 0 ] ;	
			
		}	
		
		// Resetto la variabile
		counter_time = 0 ;

		// Continuo la lettura del segnale alto per verificare l'ampiezza dell'onda e di 
		// conseguenza il valore del altezza restituito dal sensore
		if ( reading_pulse_active == ON )
		{
			// Time-put 10 ms 
			while ( counter_time <= TIMEOUT_PULSE_MAXSONAR )
			{
				if ( nrf_gpio_pin_read ( RX_PIN_NUMBER ) == HIGH_PULSE_MAXSONAR )
					;	// 3 - Leggo l'ampiezza dell'onda	
				else	
				{
					// 4 - Il segnale � tornato a 0, onda terminata
					NRF_TIMER2->TASKS_STOP = ON ;	
					
					// Salvo il valore
					counter_pulse = counter_time ;
													
					break ;
					
				}
				
				// Rchiamando TASKS_CAPTURE [ 0 ] aggiorno il valore del registro CC[0] 				
				NRF_TIMER2->TASKS_CAPTURE [ 0 ] = ACTIVE_READING_TIME_PULSE_MAXSONAR ;					
				
				// Leggo il timer
				counter_time = NRF_TIMER2->CC [ 0 ] ;	
							
			}				
			
			// Resetto la variabile
			reading_pulse_active = OFF ;

		}				
	
	}				
	
	return counter_pulse ;
	
}



/**@brief Function for application main entry.
 */
int 	main ( void )
{
    bool 				erase_bonds ;
		ret_code_t 	ret ;
	
    // Initialize.
		//log_init ( ) ;
    timers_init ( ) ;
    buttons_leds_init ( &erase_bonds ) ;
    power_management_init ( ) ;
    ble_stack_init ( ) ;
    gap_params_init ( ) ;
    gatt_init ( ) ;
    advertising_init ( ) ;
    services_init ( ) ;
    sensor_simulator_init ( ) ;
    conn_params_init ( ) ;
    peer_manager_init ( ) ;	
		 
		// GPIO
		// param1 - pin_number Specifies the pin number.
		// param2 - pull_config State of the pin range pull resistor (no pull, pulled down, or pulled high).
		nrf_gpio_cfg_input ( RX_PIN_NUMBER , NRF_GPIO_PIN_NOPULL ) ; 
		
		// Inizializzazione necessaria per comunicare con la UART
    nrf_drv_clock_lfclk_request ( NULL ) ;
    ret = app_timer_init ( ) ;
    APP_ERROR_CHECK ( ret ) ;
		
		// Inizializzo il Timer	
		// Frequenza 1 MHz
		// Bit width 32 bit
		// Config mode timer
		NRF_TIMER2->BITMODE = TIMER_CONFIG_BIT_WIDTH_32bit ;
		NRF_TIMER2->PRESCALER = TIMER_CONFIG_FREQUENCY ; 
		NRF_TIMER2->MODE = TIMER_CONFIG_MODE ;
		
		// Inizializzol la comuncazione I2C 
		error_system = twi_init ( ) ;
				
		// Controllo se inizializzato correttamente
		if ( error_system == false )
		{
			while ( true )
			{
				bsp_board_led_invert ( ID_LED_4 ) ;		
				nrf_delay_ms ( 500 ) ;		
				bsp_board_led_invert ( ID_LED_4 ) ;	
				nrf_delay_ms ( 500 ) ;
				
			}	
			
		}	
		
		// Inizializzo il sensore
		error_system = BNO055_init ( ) ;
		
		// Controllo se inizializzato correttamente
		if ( error_system == false )
		{
			while ( true )
			{
				bsp_board_led_invert ( ID_LED_4 ) ;		
				nrf_delay_ms ( 500 ) ;		
				bsp_board_led_invert ( ID_LED_4 ) ;	
				nrf_delay_ms ( 500 ) ;
				
			}	
			
		}			
		
		
		// Se ricevo dati blinka il LED 3 
		bsp_board_led_invert ( ID_LED_3 ) ;	
	
		// Inizializzo la UART
		ret = nrf_serial_init ( &serial_uart , &m_uart0_drv_config , &serial_config ) ;
	
    APP_ERROR_CHECK ( ret ) ;

		nrf_delay_ms ( 3000 ) ;	
		
		// Inizializzo la lettura continua 
		init_autolistcard ( ) ;

    // Start execution.
    NRF_LOG_INFO ( " Cycling Speed and Cadence example started." ) ;
    application_timers_start ( ) ;
    advertising_start ( erase_bonds ) ;
		
		ret_code_t ret_loop ;
				
    // Enter main loop.
    for (;;)
    {			
				/******************* I2C. ***************************** 
				*/			
				readLIADataYBNO055 ( &data_BNO055 ) ;
				readQUADataXBNO055 ( &data_BNO055 ) ;
			
				/******************* BLE IDLE STATE. ****************** 
				*/
        // idle_state_handle ( ) ;
			
				/******************* PULSE WIDTH MAX SONAR. *********** 
				*/
				tmp_pulse_width_MaxSonar = read_pulse_MaxSonar ( ) ;
			
				if ( ( tmp_pulse_width_MaxSonar != 0 ) && ( pulse_width_MaxSonar != tmp_pulse_width_MaxSonar ) )							
					pulse_width_MaxSonar = tmp_pulse_width_MaxSonar ;	 				
			
				/******************* SERIAL COMUNICATION. ************* 
				*/				
				if ( ( ( pulse_width_MaxSonar > 0 ) && ( pulse_width_MaxSonar	<= ( RANGE_MINIMUM + 5 ) ) ) && ( counter_reading_badge < TIMEOUT_READING_BADGE ) )
				{
					// Resetto il buffer
					memset ( buff_received_uart_badge , 0 , sizeof ( buff_received_uart_badge ) ) ;
					
					uint8_t p_read ;
					
					// Attendo che viene passato il badge
					// ret_loop = nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 5 ) ;	
					ret_loop = nrf_serial_read ( &serial_uart , &p_read , 1 , NULL , 0 ) ;	
					
					if ( ( ret_loop != NRF_SUCCESS ) && ( ret_loop != NRF_ERROR_TIMEOUT ) )
						APP_ERROR_CHECK ( ret_loop ) ;
					
					// Utilizzo per temporizzare il ciclo il timeout di attesa del messaggio contenente il badge 
					counter_reading_badge += TIME_MS_5 ;
					
					if ( ret_loop != NRF_SUCCESS )  					
						continue ;		
					
					// Se ricevo dati blinka il LED 1 
					bsp_board_led_invert ( ID_LED_4 ) ;		
					nrf_delay_ms ( 100 ) ;		
					bsp_board_led_invert ( ID_LED_4 ) ;	
							
					( void ) nrf_serial_flush ( &serial_uart , 0 ) ;
					
					// Resetto il counter
					counter_reading_badge = 0 ;
					
					// Passato il badge, aggiorno il codice tramite sull'app
					badge_update = true ;

					/******************* SAVING BADGE CODE. *************** 
					*/			
					
					// Salvo il codice UID del badge		
					memcpy ( char_UID_badge , buff_received_uart_badge + 9 , 8 ) ;
									
					sprintf ( UID_badge , "%02X%02X%02X%02X%02X%02X%02X%02X" , char_UID_badge [ 0 ] , char_UID_badge [ 1 ] , char_UID_badge [ 2 ] , 
																																		 char_UID_badge [ 3 ] , char_UID_badge [ 4 ] , char_UID_badge [ 5 ] , 
																																		 char_UID_badge [ 6 ] , char_UID_badge [ 7 ] ) ;					
					
					// nrf_delay_ms ( 100 ) ;	
					
					// Elimino due letture del badge ravvicinate di fila					
					nrf_serial_read ( &serial_uart , &buff_received_uart_badge , 18 , NULL , 0 ) ;		

					( void ) nrf_serial_flush ( &serial_uart , 0 ) ;
		
				}						
				
				else if ( pulse_width_MaxSonar >= ( RANGE_MINIMUM + 5 ) ) 				
					// Resetto il timer
					counter_reading_badge = 0 ;				
					
			
    }
		
}


/**
 * @}
 */

[Jørgen Holmefjord]

Are you still getting timeout error code? Some other error code? It still looks like you do not check error code from every call to nrf_serial_*.

[Gianmarco Scarpelli]

Hi,

When the RFID reader read badge no particular error occurs after the UART is stops working. I have checked with the function APP_ERROR_CHECK.

uint8_t p_read ;

ret_loop = nrf_serial_read ( &serial_uart , &p_read , 1 , NULL , 0 ) ;

if ( ( ret_loop != NRF_SUCCESS ) && ( ret_loop != NRF_ERROR_TIMEOUT ) )
      APP_ERROR_CHECK ( ret_loop ) ;

if ( ret_loop != NRF_SUCCESS )
        continue ;