TWIM issue

[nikola]

Hello ,
I am working on a project which contains I2C communication,
When I test the twi scanner example on my sensor and it works fine
But when I do the combination with the usbd_ble_uart example to send the data to uart I encountered a problem during an I2C read operation. My code stuck in this infinite loop

bool transmission_finished = false;
        do {
            if (nrf_twim_event_check(p_twim, NRF_TWIM_EVENT_SUSPENDED))
            {
                transmission_finished = true;
            }

            if (nrf_twim_event_check(p_twim, NRF_TWIM_EVENT_STOPPED))
            {
                nrf_twim_event_clear(p_twim, NRF_TWIM_EVENT_STOPPED);
                transmission_finished = true;
            }

            if (nrf_twim_event_check(p_twim, NRF_TWIM_EVENT_ERROR))
            {
                nrf_twim_event_clear(p_twim, NRF_TWIM_EVENT_ERROR);

                bool lasttx_triggered = nrf_twim_event_check(p_twim, NRF_TWIM_EVENT_LASTTX);
                uint32_t shorts_mask = nrf_twim_shorts_get(p_twim);

                if (!(lasttx_triggered && (shorts_mask & NRF_TWIM_SHORT_LASTTX_STOP_MASK)))
                {
                    // Unless LASTTX event arrived and LASTTX_STOP shortcut is active,
                    // triggering of STOP task in case of error has to be done manually.
                    nrf_twim_task_trigger(p_twim, NRF_TWIM_TASK_RESUME);
                    nrf_twim_task_trigger(p_twim, NRF_TWIM_TASK_STOP);

                    // Mark transmission as not finished yet,
                    // as STOPPED event is expected to arrive.
                    // If LASTTX_SUSPENDED shortcut is active,
                    // NACK has been received on last byte sent
                    // and SUSPENDED event happened to be checked before ERROR,
                    // transmission will be marked as finished.
                    // In such case this flag has to be overwritten.
                    transmission_finished = false;
                }

                if (lasttx_triggered && (shorts_mask & NRF_TWIM_SHORT_LASTTX_SUSPEND_MASK))
                {
                    // When STOP task was triggered just before SUSPEND task has taken effect,
                    // SUSPENDED event may not arrive.
                    // However if SUSPENDED arrives it always arrives after ERROR.
                    // Therefore SUSPENDED has to be cleared
                    // so it does not cause premature termination of busy loop
                    // waiting for STOPPED event to arrive.
                    nrf_twim_event_clear(p_twim, NRF_TWIM_EVENT_SUSPENDED);

                    // Mark transmission as not finished yet,
                    // for same reasons as above.
                    transmission_finished = false;
                }
            }
        } while (!transmission_finished);

Although I tried to copy all the configuration performed in the example of twi scanner

Please Help me .

[nikola]

Karl Ylvisaker said:

Please make sure that all returned error codes are passed to an APP_ERROR_CHECK or similar, so that you will know in the case that you will know if the function call failed, for whatever reason.

I have already verified that all returned error codes are passed to APP_ERROR_CHECK

[Karl Ylvisaker]

nikola said:

I have already verified that all returned error codes are passed to APP_ERROR_CHECK

Looking briefly through the code you shared this seems not to be the case in your functions Read, Send and Samplesready, at least.

nikola said:

I have already tried to insert my code and and I cannot

That is unfortunate. If the problem persists, you might try to upload it as a complete file, using the Insert -> File option instead.

Best regards,
Karl 

[nikola]

there is my main code I want to divide it into two parts, this is the first part :

#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "ble_hci.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gatt.h"
#include "app_timer.h"
#include "ble_nus.h"
#include "app_uart.h"
#include "app_util_platform.h"
#include "bsp_btn_ble.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "nrf_drv_usbd.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_drv_power.h"

#include "app_error.h"
#include "app_util.h"
#include "app_usbd_core.h"
#include "app_usbd.h"
#include "app_usbd_string_desc.h"
#include "app_usbd_cdc_acm.h"
#include "app_usbd_serial_num.h"
/*********************PPG Librairies ***********************/

#include <stdint.h>
#include <stdbool.h>
#include "boards.h"
#include "app_util_platform.h"
#include "app_error.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "nrf_drv_rtc.h"
#include "nrf_drv_clock.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
/*****************************End of PPG Librairies *****************/

/**************************TWI initailisation of PPG ********************/
/* TWI instance ID. */
#if TWI0_ENABLED
#define TWI_INSTANCE_ID     0
#elif TWI1_ENABLED
#define TWI_INSTANCE_ID     1
#endif

 /* Number of possible TWI addresses. */
#define TWI_ADDRESSES      127
/************************** End of TWI initailisation of PPG ********************/






#define LED_BLE_NUS_CONN (BSP_BOARD_LED_0)
#define LED_BLE_NUS_RX   (BSP_BOARD_LED_1)
#define LED_CDC_ACM_CONN (BSP_BOARD_LED_2)
#define LED_CDC_ACM_RX   (BSP_BOARD_LED_3)

#define LED_BLINK_INTERVAL 800

APP_TIMER_DEF(m_blink_ble);
APP_TIMER_DEF(m_blink_cdc);

/**
 * @brief App timer handler for blinking the LEDs.
 *
 * @param p_context LED to blink.
 */
void blink_handler(void * p_context)
{
    bsp_board_led_invert((uint32_t) p_context);
}

#define ENDLINE_STRING "\r\n"

// USB DEFINES START
static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
                                    app_usbd_cdc_acm_user_event_t event);

#define CDC_ACM_COMM_INTERFACE  0
#define CDC_ACM_COMM_EPIN       NRF_DRV_USBD_EPIN2

#define CDC_ACM_DATA_INTERFACE  1
#define CDC_ACM_DATA_EPIN       NRF_DRV_USBD_EPIN1
#define CDC_ACM_DATA_EPOUT      NRF_DRV_USBD_EPOUT1

static char m_cdc_data_array[BLE_NUS_MAX_DATA_LEN];

/** @brief CDC_ACM class instance */
APP_USBD_CDC_ACM_GLOBAL_DEF(m_app_cdc_acm,
                            cdc_acm_user_ev_handler,
                            CDC_ACM_COMM_INTERFACE,
                            CDC_ACM_DATA_INTERFACE,
                            CDC_ACM_COMM_EPIN,
                            CDC_ACM_DATA_EPIN,
                            CDC_ACM_DATA_EPOUT,
                            APP_USBD_CDC_COMM_PROTOCOL_AT_V250);

// USB DEFINES END

// BLE DEFINES START
#define APP_BLE_CONN_CFG_TAG            1                                           /**< A tag identifying the SoftDevice BLE configuration. */

#define APP_FEATURE_NOT_SUPPORTED       BLE_GATT_STATUS_ATTERR_APP_BEGIN + 2        /**< Reply when unsupported features are requested. */

#define DEVICE_NAME                     "Nordic_USBD_BLE_UART"                      /**< Name of device. Will be included in the advertising data. */
#define NUS_SERVICE_UUID_TYPE           BLE_UUID_TYPE_VENDOR_BEGIN                  /**< UUID type for the Nordic UART Service (vendor specific). */

#define APP_BLE_OBSERVER_PRIO           3                                           /**< Application's BLE observer priority. You shouldn't need to modify this value. */

#define APP_ADV_INTERVAL                64                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
#define APP_ADV_DURATION                18000                                       /**< The advertising duration (180 seconds) in units of 10 milliseconds. */


#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(20, UNIT_1_25_MS)             /**< Minimum acceptable connection interval (20 ms). Connection interval uses 1.25 ms units. */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(75, UNIT_1_25_MS)             /**< Maximum acceptable connection interval (75 ms). Connection interval uses 1.25 ms units. */
#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds). Supervision Timeout uses 10 ms units. */
#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                       /**< Time from initiating an event (connect or start of notification) to the first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY   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 DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump. Can be used to identify stack location on stack unwind. */

#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */







/*************************Max30105**********************/
/*MX30105*/

//Spo2
#define FreqS 25    //sampling frequency
#define BUFFER_SIZE (FreqS * 4) 
#define MA4_SIZE 4 // DONOT CHANGE
#define MX30105_ADDR 0x57
/*******************************************************/

BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT);                                   /**< BLE NUS service instance. */
NRF_BLE_GATT_DEF(m_gatt);                                                           /**< GATT module instance. */
BLE_ADVERTISING_DEF(m_advertising);                                                 /**< Advertising module instance. */

static uint16_t   m_conn_handle          = BLE_CONN_HANDLE_INVALID;                 /**< Handle of the current connection. */
static uint16_t   m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3;            /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
static ble_uuid_t m_adv_uuids[]          =                                          /**< Universally unique service identifier. */
{
    {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}
};
static char m_nus_data_array[BLE_NUS_MAX_DATA_LEN];

// BLE DEFINES END

/***********************Define the varibles of PPG ************************/
uint32_t example =   0x00;
int32_t BPM = 0x00;
int32_t HZ = 0x00; 
int8_t finger = 0;
int8_t error = 0;
int16_t example1 = 0;
uint32_t examplered;
uint32_t examplegreen;
uint32_t exampleIR;
uint32_t validHeartRate = 0 ;
uint32_t heartRate = 0 ;
uint32_t validSPO2 = 0;
uint32_t spo2 = 0;
/******************************End of definition of varibles PPG *****************/

/* Timer Stuff */

const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE(0);

static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
{
    if (int_type == NRF_DRV_RTC_INT_COMPARE0)
    {
         NRF_LOG_INFO("Compare event  ");
    }
    else if (int_type == NRF_DRV_RTC_INT_TICK)
    {
         NRF_LOG_INFO(" Tick Event ");
    }
}

/** @brief Function starting the internal LFCLK XTAL oscillator.
 */
/*static void lfclk_config(void)
{    ret_code_t err_code = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_clock_lfclk_request(NULL);
    NRF_LOG_INFO(" Low Frequency Configuration done ");
}

*/
/*static void rtc_config(void)
{
    uint32_t err_code;

    //Initialize RTC instance
    nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG;
    config.prescaler = 327;
    err_code = nrf_drv_rtc_init(&rtc, &config, rtc_handler);
    APP_ERROR_CHECK(err_code);
    nrf_drv_rtc_enable(&rtc);
    NRF_LOG_INFO("RTC Configuration done");
}
*/
static  int32_t an_x[ BUFFER_SIZE]; //ir
static  int32_t an_y[ BUFFER_SIZE]; //red
const uint8_t uch_spo2_table[184]={ 95, 95, 95, 96, 96, 96, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 99, 99, 99, 99, 
              99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 
              100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97, 
              97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 
              90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81, 
              80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67, 
              66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 
              49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29, 
              28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5, 
              3, 2, 1 } ;
/* TWI instance. */
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);


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

    const nrf_drv_twi_config_t twi_config = {
       .scl                = ARDUINO_SCL_PIN,
       .sda                = ARDUINO_SDA_PIN,
       .frequency          = NRF_DRV_TWI_FREQ_100K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = true
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}


/**
 * @brief Function for main application entry.
 */


 uint32_t redBuffer[100];
 uint32_t irBuffer[100];
 uint32_t greenBuffer[100];












/**
 * @brief Function for assert macro callback.
 *
 * @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 an 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] p_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 initializing the timer module. */
static void timers_init(void)
{
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
    err_code = app_timer_create(&m_blink_ble, APP_TIMER_MODE_REPEATED, blink_handler);
    APP_ERROR_CHECK(err_code);
    err_code = app_timer_create(&m_blink_cdc, APP_TIMER_MODE_REPEATED, blink_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. It also sets the permissions and appearance.
 */
static void gap_params_init(void)
{
    uint32_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);

    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 handling the data from the Nordic UART Service.
 *
 * @details This function processes the data received from the Nordic UART BLE Service and sends
 *          it to the USBD CDC ACM module.
 *
 * @param[in] p_evt Nordic UART Service event.
 */
static void nus_data_handler(ble_nus_evt_t * p_evt)
{

    if (p_evt->type == BLE_NUS_EVT_RX_DATA)
    {
        bsp_board_led_invert(LED_BLE_NUS_RX);
        NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on CDC ACM.");
        NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
        memcpy(m_nus_data_array, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);

        // Add endline characters
        uint16_t length = p_evt->params.rx_data.length;
        if (length + sizeof(ENDLINE_STRING) < BLE_NUS_MAX_DATA_LEN)
        {
            memcpy(m_nus_data_array + length, ENDLINE_STRING, sizeof(ENDLINE_STRING));
            length += sizeof(ENDLINE_STRING);
        }

        // Send data through CDC ACM
        ret_code_t ret = app_usbd_cdc_acm_write(&m_app_cdc_acm,
                                                m_nus_data_array,
                                                length);
        if(ret != NRF_SUCCESS)
        {
            NRF_LOG_INFO("CDC ACM unavailable, data received: %s", m_nus_data_array);
        }
    }

}


/** @brief Function for initializing services that will be used by the application. */
static void services_init(void)
{
    uint32_t       err_code;
    ble_nus_init_t nus_init;

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

    nus_init.data_handler = nus_data_handler;

    err_code = ble_nus_init(&m_nus, &nus_init);
    APP_ERROR_CHECK(err_code);
}

/**
 * @brief Function for handling errors from the Connection Parameters module.
 *
 * @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 cp_init;

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

    cp_init.p_conn_params                  = NULL;
    cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
    cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
    cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
    cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID;
    cp_init.disconnect_on_fail             = true;
    cp_init.evt_handler                    = NULL;
    cp_init.error_handler                  = conn_params_error_handler;

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


/**
 * @brief Function for putting the chip into sleep mode.
 *
 * @note This function does not return.
 */
static void sleep_mode_enter(void)
{
    uint32_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 starting advertising. */
static void advertising_start(void)
{
    uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}

/**
 * @brief Function for handling advertising events.
 *
 * @details This function is 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)
{
    uint32_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            err_code = app_timer_start(m_blink_ble,
                                       APP_TIMER_TICKS(LED_BLINK_INTERVAL),
                                       (void *) LED_BLE_NUS_CONN);
            APP_ERROR_CHECK(err_code);
            break;
        case BLE_ADV_EVT_IDLE:
            NRF_LOG_INFO("Advertising timeout, restarting.")
            advertising_start();
            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)
{
    uint32_t err_code;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("BLE NUS connected");
            err_code = app_timer_stop(m_blink_ble);
            APP_ERROR_CHECK(err_code);
            bsp_board_led_on(LED_BLE_NUS_CONN);
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("BLE NUS disconnected");
            // LED indication will be changed when advertising starts.
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
            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_GAP_EVT_SEC_PARAMS_REQUEST:
            // Pairing not supported.
            err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST:
        {
            ble_gap_data_length_params_t dl_params;

            // Clearing the struct will effectively set members to @ref BLE_GAP_DATA_LENGTH_AUTO.
            memset(&dl_params, 0, sizeof(ble_gap_data_length_params_t));
            err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, &dl_params, NULL);
            APP_ERROR_CHECK(err_code);
        } break;

        case BLE_GATTS_EVT_SYS_ATTR_MISSING:
            // No system attributes have been stored.
            err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GATTC_EVT_TIMEOUT:
            // Disconnect on GATT Client timeout event.
            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.
            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;

        case BLE_EVT_USER_MEM_REQUEST:
            err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gattc_evt.conn_handle, NULL);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
        {
            ble_gatts_evt_rw_authorize_request_t  req;
            ble_gatts_rw_authorize_reply_params_t auth_reply;

            req = p_ble_evt->evt.gatts_evt.params.authorize_request;

            if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
            {
                if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ)     ||
                    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
                    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
                {
                    if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
                    {
                        auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
                    }
                    else
                    {
                        auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
                    }
                    auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
                    err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
                                                               &auth_reply);
                    APP_ERROR_CHECK(err_code);
                }
            }
        } break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST

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


/**
 * @brief Function for the SoftDevice initialization.
 *
 * @details This function 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 GATT library. */
void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
{
    if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED))
    {
        m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
        NRF_LOG_INFO("Data len is set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
    }
    NRF_LOG_DEBUG("ATT MTU exchange completed. central 0x%x peripheral 0x%x",
                  p_gatt->att_mtu_desired_central,
                  p_gatt->att_mtu_desired_periph);
}


/** @brief Function for initializing the GATT library. */
void gatt_init(void)
{
    ret_code_t err_code;

    err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, 64);
    APP_ERROR_CHECK(err_code);
}


/**
 * @brief Function for handling events from the BSP module.
 *
 * @param[in]   event   Event generated by button press.
 */
void bsp_event_handler(bsp_event_t event)
{
    uint32_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 initializing the Advertising functionality. */
static void advertising_init(void)
{
    uint32_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 = false;
    init.advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;

    init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    init.srdata.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. */
static void buttons_leds_init(void)
{
    uint32_t err_code = bsp_init(BSP_INIT_LEDS, bsp_event_handler);
    APP_ERROR_CHECK(err_code);
}


/** @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 placing the application in low power state while waiting for events. */
static void power_manage(void)
{
    uint32_t err_code = sd_app_evt_wait();
    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)
{
    UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());
    power_manage();
}


// USB CODE START
static bool m_usb_connected = false;


/** @brief User event handler @ref app_usbd_cdc_acm_user_ev_handler_t */
static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
                                    app_usbd_cdc_acm_user_event_t event)
{
    app_usbd_cdc_acm_t const * p_cdc_acm = app_usbd_cdc_acm_class_get(p_inst);

    switch (event)
    {
        case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN:
        {
            /*Set up the first transfer*/
            ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm,
                                                   m_cdc_data_array,
                                                   1);
            UNUSED_VARIABLE(ret);
            ret = app_timer_stop(m_blink_cdc);
            APP_ERROR_CHECK(ret);
            bsp_board_led_on(LED_CDC_ACM_CONN);
            NRF_LOG_INFO("CDC ACM port opened");
            break;
        }

        case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE:
            NRF_LOG_INFO("CDC ACM port closed");
            if (m_usb_connected)
            {
                ret_code_t ret = app_timer_start(m_blink_cdc,
                                                 APP_TIMER_TICKS(LED_BLINK_INTERVAL),
                                                 (void *) LED_CDC_ACM_CONN);
                APP_ERROR_CHECK(ret);
            }
            break;

        case APP_USBD_CDC_ACM_USER_EVT_TX_DONE:
            break;

        case APP_USBD_CDC_ACM_USER_EVT_RX_DONE:
        {
            ret_code_t ret;
            static uint8_t index = 0;
            index++;

            do
            {
                if ((m_cdc_data_array[index - 1] == '\n') ||
                    (m_cdc_data_array[index - 1] == '\r') ||
                    (index >= (m_ble_nus_max_data_len)))
                {
                    if (index > 1)
                    {
                        bsp_board_led_invert(LED_CDC_ACM_RX);
                        NRF_LOG_DEBUG("Ready to send data over BLE NUS");
                        NRF_LOG_HEXDUMP_DEBUG(m_cdc_data_array, index);
                        NRF_LOG_INFO ( "%s" , m_cdc_data_array);
                     //   readuart(m_cdc_data_array,index)

                        
                      //  NRF_LOG_INFO(m_cdc_data_array);

                        do
                        {
                            uint16_t length = (uint16_t)index;
                            if (length + sizeof(ENDLINE_STRING) < BLE_NUS_MAX_DATA_LEN)
                            {
                                memcpy(m_cdc_data_array + length, ENDLINE_STRING, sizeof(ENDLINE_STRING));
                                length += sizeof(ENDLINE_STRING);
                            }
                                    ret_code_t ret = app_usbd_cdc_acm_write(&m_app_cdc_acm,
                                                m_cdc_data_array,
                                                index);
                            ret = ble_nus_data_send(&m_nus, 
                                                    (uint8_t *) m_cdc_data_array,
                                                    &length,
                                                    m_conn_handle);

                            if (ret == NRF_ERROR_NOT_FOUND)
                            {
                                NRF_LOG_INFO("BLE NUS unavailable, data received: %s", m_cdc_data_array);
                                break;
                            }

                            if (ret == NRF_ERROR_RESOURCES)
                            {
                                NRF_LOG_ERROR("BLE NUS Too many notifications queued.");
                                break;
                            }

                            if ((ret != NRF_ERROR_INVALID_STATE) && (ret != NRF_ERROR_BUSY))
                            {
                                APP_ERROR_CHECK(ret);
                            }
                        }
                        while (ret == NRF_ERROR_BUSY);
                    }

                    index = 0;
                }

                /*Get amount of data transferred*/
                size_t size = app_usbd_cdc_acm_rx_size(p_cdc_acm);
                NRF_LOG_DEBUG("RX: size: %lu char: %c", size, m_cdc_data_array[index - 1]);

                /* Fetch data until internal buffer is empty */
                ret = app_usbd_cdc_acm_read(&m_app_cdc_acm,
                                            &m_cdc_data_array[index],
                                            1);
                if (ret == NRF_SUCCESS)
                {
                    index++;
                }
            }
            while (ret == NRF_SUCCESS);

            break;
        }
        default:
            break;
    }
}

static void usbd_user_ev_handler(app_usbd_event_type_t event)
{
    switch (event)
    {
        case APP_USBD_EVT_DRV_SUSPEND:
            break;

        case APP_USBD_EVT_DRV_RESUME:
            break;

        case APP_USBD_EVT_STARTED:
            break;

        case APP_USBD_EVT_STOPPED:
            app_usbd_disable();
            break;

        case APP_USBD_EVT_POWER_DETECTED:
            NRF_LOG_INFO("USB power detected");

            if (!nrf_drv_usbd_is_enabled())
            {
                app_usbd_enable();
            }
            break;

        case APP_USBD_EVT_POWER_REMOVED:
        {
            NRF_LOG_INFO("USB power removed");
            ret_code_t err_code = app_timer_stop(m_blink_cdc);
            APP_ERROR_CHECK(err_code);
            bsp_board_led_off(LED_CDC_ACM_CONN);
            m_usb_connected = false;
            app_usbd_stop();
        }
            break;

        case APP_USBD_EVT_POWER_READY:
        {
            NRF_LOG_INFO("USB ready");
            ret_code_t err_code = app_timer_start(m_blink_cdc,
                                                  APP_TIMER_TICKS(LED_BLINK_INTERVAL),
                                                  (void *) LED_CDC_ACM_CONN);
            APP_ERROR_CHECK(err_code);
            m_usb_connected = true;
            app_usbd_start();
        }
            break;

        default:
            break;
    }
}

// USB CODE END
void sendcom(char  c[]){
         uint8_t length;
         length =strlen(c);
          ret_code_t ret = app_usbd_cdc_acm_write(&m_app_cdc_acm,
                                                c,
                                                length);

 while(true)
        
       {
         
        uint8_t bufferLength = 100;

        for(uint8_t k =0 ; k <  bufferLength ; k++)
        {
    
        
        err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Write_PointerADD, 1, false);
        nrf_delay_ms(5);
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Write_Pointer,1);
        nrf_delay_ms(5);
        if (err_code != NRF_SUCCESS)
        {
            NRF_LOG_INFO(" ERROR IN Write Pointer:  0x%x", FIFO_Write_Pointer);
            NRF_LOG_FLUSH();
            error = 1;
        }
                err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Read_PointerADD, 1, false);
        nrf_delay_ms(5);  
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Read_Pointer,1);
        nrf_delay_ms(5);
        if (err_code != NRF_SUCCESS)
        {
           NRF_LOG_INFO(" ERROR IN Read Pointer 0x%x", FIFO_Read_Pointer);
           NRF_LOG_FLUSH();
           error = 1;
        }
        err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&Over_Flow_CounterADD, 1, false);
        nrf_delay_ms(5);
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &Over_Flow_Counter,1);
        nrf_delay_ms(5);
        if (err_code == NRF_SUCCESS)
        {
           // NRF_LOG_INFO(" Overflowed:  0x%x", Over_Flow_Counter);
          
        }
        
        if (FIFO_Write_Pointer >  FIFO_Read_Pointer){ReadySamples = FIFO_Write_Pointer - FIFO_Read_Pointer;}
        if (FIFO_Write_Pointer <  FIFO_Read_Pointer ){ReadySamples = FIFO_Write_Pointer+32 - FIFO_Read_Pointer;}
        if (FIFO_Write_Pointer ==  FIFO_Read_Pointer)
        {
        ReadySamples = 0;
        k--;
        }
        if (error == 1 )
        {
        ReadySamples = 0;
        k--;
        }
        if ( ReadySamples > 0){
                
                bsp_board_led_invert(3);

                err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Data_RegisterADD, 1, false);
                err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Data_Register,3*ReadySamples*lednumber);
                nrf_delay_ms(4);
                if (err_code == NRF_SUCCESS)
                  { 
                  error = 0;
                  uint8_t i=0;
                  if (lednumber == 1)
                  {
                        for (i=0;i<ReadySamples*3;i=i+3)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             example = (((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2]);
                              redBuffer[k]=Max_ADC;
                              NRF_LOG_INFO("RED : %d,Samples %d %d %d %d", Max_ADC, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                              
                              NRF_LOG_FLUSH();
                              bsp_board_led_invert(3);
                              
                             }
                  }
                  if ( lednumber == 2 )
                  {
                             for (i=0;i<ReadySamples*3*2;i=i+6)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             Max_ADC2 = ((uint32_t)FIFO_Data_Register[i+3] << 16) | ((uint32_t)FIFO_Data_Register[i+4] << 8) | FIFO_Data_Register[i+5];
                            // example = (((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2]); 
                             redBuffer[k]=Max_ADC;
                             irBuffer[k]=Max_ADC2;
                             //NRF_LOG_INFO("RED : %d,Samples %d %d %d %d", Max_ADC, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                             //NRF_LOG_INFO("IR : %d,Samples %d %d %d %d", Max_ADC2, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                             
                             NRF_LOG_FLUSH();
                             bsp_board_led_invert(3);
                             }
                              
                  }
                  if (lednumber == 3 )
                  { 
                   for (i=0;i<ReadySamples*3*3;i=i+9)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             Max_ADC2 = ((uint32_t)FIFO_Data_Register[i+3] << 16) | ((uint32_t)FIFO_Data_Register[i+4] << 8) | FIFO_Data_Register[i+5];
                             Max_ADC3 = ((uint32_t)FIFO_Data_Register[i+6] << 16) | ((uint32_t)FIFO_Data_Register[i+7] << 8) | FIFO_Data_Register[i+8];
                             redBuffer[k]=Max_ADC;
                             irBuffer[k]=Max_ADC2;
                             greenBuffer[k]=Max_ADC3;
                            // example = (((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2]); 
                             //NRF_LOG_INFO("RED : %d,Samples %d %d %d %d", Max_ADC, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                            // NRF_LOG_INFO("IR : %d,Samples %d %d %d %d", Max_ADC2, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                            // NRF_LOG_INFO("GREEN : %d,Samples %d %d %d %d", Max_ADC3, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                            
                            NRF_LOG_FLUSH();
                             bsp_board_led_invert(3);
                             }


                  }
                  

                 
                   
                  }


                              }
        }
  //timer=nrfx_rtc_counter_get(&rtc);
  maxim_heart_rate_and_oxygen_saturation(irBuffer, bufferLength, redBuffer, &spo2, &validSPO2, &heartRate, &validHeartRate);

  //Continuously taking samples from MAX30102.  Heart rate and SpO2 are calculated every 1 second
  while (1)
  {
    //dumping the first 25 sets of samples in the memory and shift the last 75 sets of samples to the top
    for (uint8_t k = 25; k < 100; k++)
    {
      redBuffer[k - 25] = redBuffer[k];
      irBuffer[k - 25] = irBuffer[k];
    }

    //take 25 sets of samples before calculating the heart rate.
    for (uint8_t k = 75; k < 100; k++)
    {
    
    
        
        err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Write_PointerADD, 1, false);
        nrf_delay_ms(5);
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Write_Pointer,1);
        nrf_delay_ms(5);
        if (err_code != NRF_SUCCESS)
        {
            NRF_LOG_INFO(" ERROR IN Write Pointer:  0x%x", FIFO_Write_Pointer);
            NRF_LOG_FLUSH();
            error = 1;
        }
                err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Read_PointerADD, 1, false);
        nrf_delay_ms(5);  
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Read_Pointer,1);
        nrf_delay_ms(5);
        if (err_code != NRF_SUCCESS)
        {
           NRF_LOG_INFO(" ERROR IN Read Pointer 0x%x", FIFO_Read_Pointer);
           NRF_LOG_FLUSH();
           error = 1;
        }
        err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&Over_Flow_CounterADD, 1, false);
        nrf_delay_ms(5);
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &Over_Flow_Counter,1);
        nrf_delay_ms(5);
        if (err_code == NRF_SUCCESS)
        {
           // NRF_LOG_INFO(" Overflowed:  0x%x", Over_Flow_Counter);
          
        }
        if (FIFO_Write_Pointer >  FIFO_Read_Pointer){ReadySamples = FIFO_Write_Pointer - FIFO_Read_Pointer;}
        if (FIFO_Write_Pointer <  FIFO_Read_Pointer ){ReadySamples = FIFO_Write_Pointer+32 - FIFO_Read_Pointer;}
        if (FIFO_Write_Pointer ==  FIFO_Read_Pointer)
        {
        ReadySamples = 0;
        k--;
        }
        if (error == 1 )
        {
        ReadySamples = 0;
        k--;
        }
        if ( ReadySamples > 0){
                
                bsp_board_led_invert(3);

                err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Data_RegisterADD, 1, false);
                err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Data_Register,3*ReadySamples*lednumber);
                nrf_delay_ms(4);
                if (err_code == NRF_SUCCESS)
                  { 
                  error = 0;
                  uint8_t i=0;
                  if (lednumber == 1)
                  {
                        for (i=0;i<ReadySamples*3;i=i+3)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             example = (((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2]);
                              redBuffer[k]=Max_ADC;
                              NRF_LOG_INFO("RED : %d,Samples %d %d %d %d", Max_ADC, ReadySamples, Over_Flow_Counter,FIFO_Read_Pointer,FIFO_Write_Pointer );
                              
                              NRF_LOG_FLUSH();
                              bsp_board_led_invert(3);
                              
                             }
                  }
                  if ( lednumber == 2 )
                  {
                             for (i=0;i<ReadySamples*3*2;i=i+6)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             Max_ADC2 = ((uint32_t)FIFO_Data_Register[i+3] << 16) | ((uint32_t)FIFO_Data_Register[i+4] << 8) | FIFO_Data_Register[i+5];
                             redBuffer[k]=Max_ADC;
                             irBuffer[k]=Max_ADC2;
                            
                             NRF_LOG_FLUSH();
                             bsp_board_led_invert(3);
                             }
                              
                  }
                  if (lednumber == 3 )
                  { 
                   for (i=0;i<ReadySamples*3*3;i=i+9)
                             {
                             Max_ADC = ((uint32_t)FIFO_Data_Register[i] << 16) | ((uint32_t)FIFO_Data_Register[i+1] << 8) | FIFO_Data_Register[i+2];
                             Max_ADC2 = ((uint32_t)FIFO_Data_Register[i+3] << 16) | ((uint32_t)FIFO_Data_Register[i+4] << 8) | FIFO_Data_Register[i+5];
                             Max_ADC3 = ((uint32_t)FIFO_Data_Register[i+6] << 16) | ((uint32_t)FIFO_Data_Register[i+7] << 8) | FIFO_Data_Register[i+8];
                             redBuffer[k]=Max_ADC;
                             irBuffer[k]=Max_ADC2;
                             greenBuffer[k]=Max_ADC3;
                           
                            NRF_LOG_FLUSH();
                             bsp_board_led_invert(3);
                             }


                  }
                  

                 
                   
                  }


                              }
    
   
    maxim_heart_rate_and_oxygen_saturation(irBuffer, bufferLength, redBuffer, &spo2, &validSPO2, &heartRate, &validHeartRate);
    NRF_LOG_INFO(" %d  ", spo2 );

     BPM = (int32_t)60000/(int32_t)heartRate;
      
 }  
 
       
        
        
        
         
       
   
  }}
  
     

        if(ret != NRF_SUCCESS)
        {
            NRF_LOG_INFO("Data not sent,Please Open Com to send data : %s", c);
        }
}

[nikola]

this is the second part :

/** @brief Application main function. */
int main(void)

{
/*******************************For PPG ********************/
    uint32_t Max_ADC;
    uint32_t Max_ADC2;
    uint32_t Max_ADC3;
    uint8_t address;
    ret_code_t err_code;
    uint8_t sample_data;
    uint8_t FIFO_Configuration = 0;
    uint8_t Mode_Configuration = 0;
    uint8_t SpO2_Configuration = 0;
    uint8_t RESERVED;
    uint8_t Multi_LED_Mode_Control1= 0;
    uint8_t Multi_LED_Mode_Control2= 0;
    uint8_t FIFO_Write_Pointer= 0;
    uint8_t Over_Flow_Counter= 0;
    uint8_t FIFO_Read_Pointer=0;
    uint8_t FIFO_Data_Register[288];
    uint8_t FIFO_Configuration1 = 0;
    uint8_t Mode_Configuration1 = 0;
    uint8_t SpO2_Configuration1 = 0;
    uint8_t RESERVED1;
    uint8_t Multi_LED_Mode_Control11= 0;
    uint8_t Multi_LED_Mode_Control21= 0;
    uint8_t FIFO_Write_Pointer1= 0;
    uint8_t Over_Flow_Counter1= 0;
    uint8_t FIFO_Read_Pointer1=0;
    uint8_t FIFO_Data_Register1[288];
    
//configuration : 


   const uint8_t FIFO_Write_PointerADD = 0x04;
   const uint8_t Over_Flow_CounterADD = 0x05;
   const uint8_t FIFO_Read_PointerADD = 0x06;
   const uint8_t FIFO_Data_RegisterADD = 0x07;
   const uint8_t FIFO_ConfigurationADD = 0x08;
   const uint8_t Mode_ConfigurationADD = 0x09;
   const uint8_t SpO2_ConfigurationADD = 0x0A;
   const uint8_t RESERVEDADD = 0x0B;
   const uint8_t LED_PulseAmplitude1ADD = 0x0C;
   const uint8_t LED_PulseAmplitude2ADD = 0x0D;
   const uint8_t LED_PulseAmplitude3ADD = 0x0E;
   const uint8_t LED_PulseAmplitude4ADD = 0x0F;
   const uint8_t Multi_LED_Mode_Control1ADD = 0x11;
   const uint8_t Multi_LED_Mode_Control2ADD = 0x12;
   const uint8_t Temp_Integer = 0x1F;
   const uint8_t Temp_Fraction = 0x20; //only last 4 bits 
   const uint8_t Die_Temperature_Config = 0x21; //only one bit


    //masks//
    const uint8_t SMP_AVE_MASK          =0x1F;
    const uint8_t FIFO_ROLLOVER_EN_MASK =0xEF;
    const uint8_t FIFO_A_FULL_MASK      =0xF0;
    const uint8_t SHDN_MASK             =0x7F;
    const uint8_t RESET_MASK            =0xBF;
    const uint8_t MODE_MASK             =0xF8;
    const uint8_t SPO2_ADC_RGE_MASK     =0x9F;
    const uint8_t SPO2_SR_MASK          =0xE3;
    const uint8_t LED_PW_MASK           =0xFC;
    const uint8_t SLOT1_MASK            =0xF8;
    const uint8_t SLOT2_MASK            =0x8F;
    const uint8_t SLOT3_MASK            =0xF8;
    const uint8_t SLOT4_MASK            =0x8F;


      // test variables 
    uint8_t masked =    0x00; // too
    uint8_t notshifted= 0x01;
    uint8_t shifted =   0x00;
    uint8_t ReadySamples = 0x00;
     //Configuration of MAX30105                         Heart Rate   -------  SPO2 
     uint8_t SMP_AVE          =0x00;   
     uint8_t FIFO_ROLLOVER_EN =0x00;
     uint8_t FIFO_A_FULL      =0x00 ;
     uint8_t SHDN             =0x00 ;
     uint8_t RESET            =0x00 ;
     uint8_t MODE             =0x00 ;
     uint8_t SPO2_ADC_RGE     =0x00 ;
     uint8_t SPO2_SR          =0x00 ;
     uint8_t LED_PulseAmplitude1 = 0x00; 
     uint8_t LED_PulseAmplitude2 = 0x00;  
     uint8_t LED_PulseAmplitude3 = 0x00;  
     uint8_t LED_PulseAmplitude4 = 0x00;  
     uint8_t LED_PW           =0x00;
     uint8_t SLOT1            =0x00 ;
     uint8_t SLOT2            =0x00 ;
     uint8_t SLOT3            =0x00 ;
     uint8_t SLOT4            =0x00 ;
     uint8_t lednumber = 0x00;
    
/***********************************************************/
/***********************************************************/
/************************************************************/

    ret_code_t ret;
    static const app_usbd_config_t usbd_config = {
        .ev_state_proc = usbd_user_ev_handler
    };
    // Initialize.
 bool detected_device = false;
    log_init();
   // APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    //NRF_LOG_DEFAULT_BACKENDS_INIT();
    twi_init();


  
    for (address = 1; address <= TWI_ADDRESSES; address++)
    {       
        err_code = nrf_drv_twi_rx(&m_twi, address, &sample_data, sizeof(sample_data));
        if (err_code == NRF_SUCCESS)
        {
            detected_device = true;
           NRF_LOG_INFO("TWI device detected at address 0x%x.", address);
        }
        NRF_LOG_FLUSH();
        nrf_delay_ms(10);
    }

    if (!detected_device)
    {
        NRF_LOG_INFO("hi there");

                NRF_LOG_INFO("No device was found.");
        NRF_LOG_FLUSH();
    }



   

    
    timers_init();

    buttons_leds_init();

    app_usbd_serial_num_generate();

    ret = nrf_drv_clock_init();
    APP_ERROR_CHECK(ret);

    NRF_LOG_INFO("USBD BLE UART example started.");

    ret = app_usbd_init(&usbd_config);
    APP_ERROR_CHECK(ret);

    app_usbd_class_inst_t const * class_cdc_acm = app_usbd_cdc_acm_class_inst_get(&m_app_cdc_acm);
    ret = app_usbd_class_append(class_cdc_acm);
    APP_ERROR_CHECK(ret);

    ble_stack_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();

    // Start execution.
    
    /*********************************************For PPG**************************************/
    /******************************************************************************************/
    /*******************************************************************************************/
    /*--------------------------------------READING COMMAND-------------------------------*/
/*--------------------------------------READING COMMAND-------------------------------*/
/*--------------------------------------READING COMMAND-------------------------------*/


        uint8_t Read(uint8_t address)
        {
        uint8_t temp;
        bsp_board_led_invert(4);
        err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&address, 1, false);
        nrf_delay_ms(10);
        err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &temp,1);
        nrf_delay_ms(10);
        if (err_code == NRF_SUCCESS)
        {
           // NRF_LOG_RAW_INFO(" 0x%x  at 0x%x                          ", temp ,address );
            //NRF_LOG_INFO(" ");
            NRF_LOG_FLUSH();
            return temp;
            bsp_board_led_invert(4);
        }
        }
/*--------------------------------------SENDING COMMAND-------------------------------*/
/*--------------------------------------SENDING COMMAND-------------------------------*/
/*--------------------------------------SENDING COMMAND-------------------------------*/

        void Send(uint8_t address, uint8_t command)
        {
          uint8_t fifoconfig_Reg[2]={address,command} ;
          bsp_board_led_invert(2);
          err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&fifoconfig_Reg, sizeof(fifoconfig_Reg), false);
          nrf_delay_ms(10);
         if (err_code == NRF_SUCCESS)
        {
           // NRF_LOG_INFO(" Sent : 0x%x to 0x%x", command,address);
            //NRF_LOG_FLUSH();
            bsp_board_led_invert(2);
        }
        }
        
        void Softreset()
        {
      //  NRF_LOG_RAW_INFO("Reading Mode_Configuration for Reset : ");
        Mode_Configuration = Read(Mode_ConfigurationADD); 
        Mode_Configuration =  (Mode_Configuration & RESET_MASK) | (0x01 << 6) ;
        Send(Mode_ConfigurationADD,Mode_Configuration);
        nrf_delay_ms(250);
       // NRF_LOG_INFO("                      Soft Reset Done                    ");
        }
        void Readall(){ 
      
       // NRF_LOG_RAW_INFO("FIFO_Configuration  : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);

        //NRF_LOG_RAW_INFO("Mode_Configuration  : ");
        Mode_Configuration = Read(Mode_ConfigurationADD);
       
        //NRF_LOG_RAW_INFO("SpO2_Configuration  : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);

       // NRF_LOG_RAW_INFO("Multi_LED_Mode_Con1 : ");
        Multi_LED_Mode_Control1 = Read(Multi_LED_Mode_Control1ADD);

        //NRF_LOG_RAW_INFO("Multi_LED_Mode_Con2 : ");
        Multi_LED_Mode_Control2 = Read(Multi_LED_Mode_Control2ADD);

        //NRF_LOG_RAW_INFO("LED_PulseAmplitude1 : ");
        LED_PulseAmplitude1 = Read(LED_PulseAmplitude1ADD);

        //NRF_LOG_RAW_INFO("LED_PulseAmplitude2 : ");
        LED_PulseAmplitude2 = Read(LED_PulseAmplitude2ADD);

        //NRF_LOG_RAW_INFO("LED_PulseAmplitude3 : ");
        LED_PulseAmplitude3 = Read(LED_PulseAmplitude3ADD);

        //NRF_LOG_RAW_INFO("LED_PulseAmplitude4 : ");
        LED_PulseAmplitude4 = Read(LED_PulseAmplitude4ADD);
        }  

        
        

        void ConfigureSampleAverage(uint8_t SampleAverage)
        {
        SampleAverage = SampleAverage << 5; 
        //NRF_LOG_RAW_INFO("Reading FIFO_CONFIGURATION for SampleAverage : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        FIFO_Configuration =  (FIFO_Configuration & SMP_AVE_MASK) | SampleAverage ;
        Send(FIFO_ConfigurationADD,FIFO_Configuration);
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        }

        void Enablefiforollover()
        {
        //NRF_LOG_RAW_INFO("Reading FIFO_CONFIGURATION for Enabling Rollover : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        FIFO_Configuration =  (FIFO_Configuration & FIFO_ROLLOVER_EN_MASK) | ( 0x01 << 4 ) ;
        Send(FIFO_ConfigurationADD,FIFO_Configuration);
       // NRF_LOG_RAW_INFO("comfirm FIFO_CONFIGURATION for Enabling Rollover : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        }

        void Disablefiforollover()
        {
        NRF_LOG_RAW_INFO("Reading FIFO_CONFIGURATION for Enabling Rollover : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        FIFO_Configuration =  (FIFO_Configuration & FIFO_ROLLOVER_EN_MASK) | ( 0x00 << 4 ) ;
        Send(FIFO_ConfigurationADD,FIFO_Configuration);
        NRF_LOG_RAW_INFO("Comfirm FIFO_CONFIGURATION for Enabling Rollover : ");
        FIFO_Configuration = Read(FIFO_ConfigurationADD);
        }

        void Setmode(uint8_t mode)
        {
        if (mode == 0x02){
        lednumber =1;
         }
        if (mode == 0x03){
        lednumber =2;
        }
        if (mode == 0x07){
        lednumber =3;
        }

         // NRF_LOG_RAW_INFO("Reading Mode_CONFIGURATION for Enabling Rollover : ");
        Mode_Configuration = Read(Mode_ConfigurationADD);
        Mode_Configuration =  (Mode_Configuration & MODE_MASK) | mode ;
        Send(Mode_ConfigurationADD,Mode_Configuration);
        //NRF_LOG_RAW_INFO("Comfirm Mode_CONFIGURATION for Enabling Rollover : ");
        Mode_Configuration = Read(Mode_ConfigurationADD);         
        }
        void Ledpulsewidth(uint8_t LED_PW){
        //NRF_LOG_RAW_INFO("Reading Spo2_CONFIGURATION for Led pulse width : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        SpO2_Configuration =  (SpO2_Configuration & LED_PW_MASK) | LED_PW ;
        Send(SpO2_ConfigurationADD,SpO2_Configuration);
        //NRF_LOG_RAW_INFO("comfirm Spo2_CONFIGURATION for Led pulse width : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        }
        void Spo2samplerate(uint8_t SPO2_SR)
        {
        SPO2_SR = SPO2_SR << 2;
        //NRF_LOG_RAW_INFO("Reading Spo2_CONFIGURATION for Spo2samplerate : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        SpO2_Configuration =  (SpO2_Configuration & SPO2_SR_MASK) | SPO2_SR ;
        Send(SpO2_ConfigurationADD,SpO2_Configuration);
        //NRF_LOG_RAW_INFO("comfirm Spo2_CONFIGURATION for Led pulse width : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        }
        void Spo2adcrange(uint8_t SPO2_ADC_RGE ){
        SPO2_ADC_RGE = SPO2_ADC_RGE << 5;
       // NRF_LOG_RAW_INFO("Reading Spo2_CONFIGURATION for Spo2adcrange : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        SpO2_Configuration =  (SpO2_Configuration & SPO2_ADC_RGE_MASK) | SPO2_ADC_RGE ;
        Send(SpO2_ConfigurationADD,SpO2_Configuration);
        //NRF_LOG_RAW_INFO("comfirm Spo2_CONFIGURATION for Spo2adcrange : ");
        SpO2_Configuration = Read(SpO2_ConfigurationADD);
        }

        void Led1pulseamplitude(uint8_t amplitude){
        Send( LED_PulseAmplitude1ADD,amplitude);
       // NRF_LOG_RAW_INFO("Led1 Pulse Amplitude : ");
        amplitude = Read(LED_PulseAmplitude1ADD);
        }
         void Led2pulseamplitude(uint8_t amplitude){
        Send( LED_PulseAmplitude2ADD,amplitude);
        //NRF_LOG_RAW_INFO("Led2 Pulse Amplitude : ");
        amplitude = Read(LED_PulseAmplitude2ADD);
        }
         void Led3pulseamplitude(uint8_t amplitude){
        Send( LED_PulseAmplitude3ADD,amplitude);
        //NRF_LOG_RAW_INFO("Led3 Pulse Amplitude : ");
        amplitude = Read(LED_PulseAmplitude3ADD);
        }
         void Led4pulseamplitude(uint8_t amplitude){
        Send( LED_PulseAmplitude4ADD,amplitude);
        //NRF_LOG_RAW_INFO("Led4 Pulse Amplitude : ");
        amplitude = Read(LED_PulseAmplitude4ADD);

        }
        void  slot1(uint8_t SLOT1) {
       //NRF_LOG_RAW_INFO("Reading Multi_LED_Mode_Control1 for SLOT1 : ");
       Multi_LED_Mode_Control1 = Read(Multi_LED_Mode_Control1ADD) ;
       Multi_LED_Mode_Control1 =  (Multi_LED_Mode_Control1 & SLOT1_MASK) | SLOT1 ;
       
       Send( Multi_LED_Mode_Control1ADD,Multi_LED_Mode_Control1);
        //NRF_LOG_RAW_INFO("Comfirm Multi_LED_Mode_Control1 for SLOT1 : ");
        Multi_LED_Mode_Control1 = Read(Multi_LED_Mode_Control1ADD) ;
       
       }
        void  slot2(uint8_t SLOT2) {
        SLOT2 =SLOT2 << 4;
       //NRF_LOG_RAW_INFO("Reading Multi_LED_Mode_Control1 for SLOT2 : ");
       Multi_LED_Mode_Control1 = Read(Multi_LED_Mode_Control1ADD) ;
       Multi_LED_Mode_Control1 =  (Multi_LED_Mode_Control1 & SLOT2_MASK) | SLOT2 ;
       
       Send( Multi_LED_Mode_Control1ADD,Multi_LED_Mode_Control1);
        //NRF_LOG_RAW_INFO("Comfirm Multi_LED_Mode_Control1 for SLOT2 : ");
        Multi_LED_Mode_Control1 = Read(Multi_LED_Mode_Control1ADD) ;

       
       }
         void  slot3(uint8_t SLOT3) {
       //NRF_LOG_RAW_INFO("Reading Multi_LED_Mode_Control1 for SLOT1 : ");
       Multi_LED_Mode_Control2 = Read(Multi_LED_Mode_Control2ADD) ;
       Multi_LED_Mode_Control2 =  (Multi_LED_Mode_Control2 & SLOT3_MASK) | SLOT3 ;
       
       Send( Multi_LED_Mode_Control2ADD,Multi_LED_Mode_Control2);
        //NRF_LOG_RAW_INFO("Comfirm Multi_LED_Mode_Control1 for SLOT1 : ");
        Multi_LED_Mode_Control2 = Read(Multi_LED_Mode_Control2ADD) ;
       
       }
       void  slot4(uint8_t SLOT4) {
        SLOT4 =SLOT4 << 4;
       //NRF_LOG_RAW_INFO("Reading Multi_LED_Mode_Control2 for SLOT2 : ");
       Multi_LED_Mode_Control2 = Read(Multi_LED_Mode_Control2ADD) ;
       Multi_LED_Mode_Control2 =  (Multi_LED_Mode_Control2 & SLOT4_MASK) | SLOT4 ;
       
       Send( Multi_LED_Mode_Control2ADD,Multi_LED_Mode_Control2);
        //NRF_LOG_RAW_INFO("Comfirm Multi_LED_Mode_Control2 for SLOT2 : ");
        Multi_LED_Mode_Control2 = Read(Multi_LED_Mode_Control2ADD) ;       
       }

 bsp_board_init(BSP_INIT_LEDS);
        Readall();
        Softreset();
        Readall();

        bsp_board_led_invert(0);
        Enablefiforollover();
        ConfigureSampleAverage(0x02); //Sample Average 4 ; FOR SPO2 
        Setmode(0x03); // 2 is red only, 3 is red + IR , 7 is Green + Red + IR ; ledMode = 2;
        Spo2adcrange(0x01); //2048 in arduino.
        Spo2samplerate(0x01);  // 50 in arduino.
        Ledpulsewidth(0x03); // pulse Width is us ms ;
        //if 1 led = > 1 slot and put Red in it, if 2 leds , 2 slots and put IR in second one, if 3 slots , put Red in first, IR in second and green in third.
        //we have red only so: ( RED 0x01, IR 0x02, Green 0x03)
        slot1(0x01);
        slot2(0x02);
        slot3(0x03);
        Led1pulseamplitude(0x1F);
        Led2pulseamplitude(0x1F);
        Led3pulseamplitude(0x1F);
        bsp_board_led_invert(0);
        bsp_board_led_invert(3);
        
        
        NRF_LOG_FLUSH();


        //TESTING BEAT STUFF//
 int16_t IR_AC_Max = 20;
int16_t IR_AC_Min = -20;
//int16_t example1 = 0;
int16_t IR_AC_Signal_Previous;
int16_t IR_AC_Signal_min = 0;
int16_t IR_AC_Signal_max = 0;
int16_t IR_Average_Estimated;

int16_t positiveEdge = 0;
int16_t negativeEdge = 0;
int32_t ir_avg_reg = 0;

int16_t cbuf[32];
uint8_t offset = 0;
static const uint16_t FIRCoeffs[12] = {172, 321, 579, 927, 1360, 1858, 2390, 2916, 3391, 3768, 4012, 4096};

//  Average DC Estimator
int16_t averageDCEstimator(int32_t *p, uint16_t x)
{
  *p += ((((long) x << 15) - *p) >> 4);
  return (*p >> 15);
}

int32_t mul16(int16_t x, int16_t y)
{
  return((long)x * (long)y);
}
//  Low Pass FIR Filter
int16_t lowPassFIRFilter(int16_t din)
{  
  cbuf[offset] = din;

  int32_t z = mul16(FIRCoeffs[11], cbuf[(offset - 11) & 0x1F]);
  
  for (uint8_t i = 0 ; i < 11 ; i++)
  {
    z += mul16(FIRCoeffs[i], cbuf[(offset - i) & 0x1F] + cbuf[(offset - 22 + i) & 0x1F]);
  }

  offset++;
  offset %= 32; //Wrap condition

  return(z >> 15);
}







//  Heart Rate Monitor functions takes a sample value and the sample number
//  Returns true if a beat is detected
//  A running average of four samples is recommended for display on the screen.
bool checkForBeat(int32_t sample)
{
  bool beatDetected = false;

  //  Save current state
  IR_AC_Signal_Previous = example1;
  
  //This is good to view for debugging
  //Serial.print("Signal_Current: ");
  //Serial.println(example);

  //  Process next data sample
  IR_Average_Estimated = averageDCEstimator(&ir_avg_reg, sample);
  example1 = lowPassFIRFilter(sample - IR_Average_Estimated);

  //  Detect positive zero crossing (rising edge)
  if ((IR_AC_Signal_Previous < 0) & (example1 >= 0))
  {
  
    IR_AC_Max = IR_AC_Signal_max; //Adjust our AC max and min
    IR_AC_Min = IR_AC_Signal_min;

    positiveEdge = 1;
    negativeEdge = 0;
    IR_AC_Signal_max = 0;

    //if ((IR_AC_Max - IR_AC_Min) > 100 & (IR_AC_Max - IR_AC_Min) < 1000)
    if ((IR_AC_Max - IR_AC_Min) > 20 & (IR_AC_Max - IR_AC_Min) < 1000)
    {
      //Heart beat!!!
      beatDetected = true;
    }
  }

  //  Detect negative zero crossing (falling edge)
  if ((IR_AC_Signal_Previous > 0) & (example1 <= 0))
  {
    positiveEdge = 0;
    negativeEdge = 1;
    IR_AC_Signal_min = 0;
  }

  //  Find Maximum value in positive cycle
  if (positiveEdge & (example1 > IR_AC_Signal_Previous))
  {
    IR_AC_Signal_max = example1;
  }

  //  Find Minimum value in negative cycle
  if (negativeEdge & (example1 < IR_AC_Signal_Previous))
  {
    IR_AC_Signal_min = example1;
  }
  
  return(beatDetected);
}

//end of Testing beat
//rtc_config();
//lfclk_config();


uint8_t Readysamplesnumber()
{
uint8_t write;
uint8_t read;
uint8_t error;
error = 0;
err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Read_PointerADD, 1, false);
nrf_delay_ms(5);  
err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Read_Pointer,1);
nrf_delay_ms(5);
        if (err_code == NRF_SUCCESS)
        {
        read = FIFO_Read_Pointer;   
        }
        if (err_code !=NRF_SUCCESS)
        {
        error = 1 ;
        }

err_code = nrf_drv_twi_tx(&m_twi, MX30105_ADDR,&FIFO_Write_PointerADD, 1, false);
nrf_delay_ms(5);
err_code = nrf_drv_twi_rx(&m_twi, MX30105_ADDR, &FIFO_Write_Pointer,1);
nrf_delay_ms(5);
if (err_code == NRF_SUCCESS)
        {
        write = FIFO_Write_Pointer;   
        }
if (err_code !=NRF_SUCCESS)
        {
        error = 1 ;
        }
if (error = 0 ){
  if ( write > read )
  {
  return write - read ;
  }
  if ( write < read )
  {
  return write+32 -read;  
  }

error =0;
}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////SPO2//////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void maxim_sort_indices_descend(  int32_t  *pn_x, int32_t *pn_indx, int32_t n_size)
/**
* \brief        Sort indices
* \par          Details
*               Sort indices according to descending order (insertion sort algorithm)
*
* \retval       None
*/ 
{
  int32_t i, j, n_temp;
  for (i = 1; i < n_size; i++) {
    n_temp = pn_indx[i];
    for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j-1]]; j--)
      pn_indx[j] = pn_indx[j-1];
    pn_indx[j] = n_temp;
  }
}

void maxim_sort_ascend(int32_t  *pn_x, int32_t n_size) 
/**
* \brief        Sort array
* \par          Details
*               Sort array in ascending order (insertion sort algorithm)
*
* \retval       None
*/
{
  int32_t i, j, n_temp;
  for (i = 1; i < n_size; i++) {
    n_temp = pn_x[i];
    for (j = i; j > 0 && n_temp < pn_x[j-1]; j--)
        pn_x[j] = pn_x[j-1];
    pn_x[j] = n_temp;
  }
}

void maxim_remove_close_peaks(int32_t *pn_locs, int32_t *pn_npks, int32_t *pn_x, int32_t n_min_distance)
/**
* \brief        Remove peaks
* \par          Details
*               Remove peaks separated by less than MIN_DISTANCE
*
* \retval       None
*/
{
    
  int32_t i, j, n_old_npks, n_dist;
    
  /* Order peaks from large to small */
  maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );

  for ( i = -1; i < *pn_npks; i++ ){
    n_old_npks = *pn_npks;
    *pn_npks = i+1;
    for ( j = i+1; j < n_old_npks; j++ ){
      n_dist =  pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
      if ( n_dist > n_min_distance || n_dist < -n_min_distance )
        pn_locs[(*pn_npks)++] = pn_locs[j];
    }
  }

  // Resort indices int32_to ascending order
  maxim_sort_ascend( pn_locs, *pn_npks );
}

void maxim_peaks_above_min_height( int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height )
/**
* \brief        Find peaks above n_min_height
* \par          Details
*               Find all peaks above MIN_HEIGHT
*
* \retval       None
*/
{
  int32_t i = 1, n_width;
  *n_npks = 0;
  
  while (i < n_size-1){
    if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i-1]){      // find left edge of potential peaks
      n_width = 1;
      while (i+n_width < n_size && pn_x[i] == pn_x[i+n_width])  // find flat peaks
        n_width++;
      if (pn_x[i] > pn_x[i+n_width] && (*n_npks) < 15 ){      // find right edge of peaks
        pn_locs[(*n_npks)++] = i;    
        // for flat peaks, peak location is left edge
        i += n_width+1;
      }
      else
        i += n_width;
    }
    else
      i++;
  }
}
void maxim_find_peaks( int32_t *pn_locs, int32_t *n_npks,  int32_t  *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num )
/**
* \brief        Find peaks
* \par          Details
*               Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
*
* \retval       None
*/
{
  maxim_peaks_above_min_height( pn_locs, n_npks, pn_x, n_size, n_min_height );
  maxim_remove_close_peaks( pn_locs, n_npks, pn_x, n_min_distance );
  //added a min here, because min doesn't exist 
  if (*n_npks > n_max_num){  
   *n_npks = n_max_num;
   }
 // *n_npks = min( *n_npks, n_max_num );
  if (*n_npks < n_max_num){
  *n_npks = *n_npks;
  }
}


void maxim_heart_rate_and_oxygen_saturation(uint32_t *pun_ir_buffer, int32_t n_ir_buffer_length, uint32_t *pun_red_buffer, int32_t *pn_spo2, int8_t *pch_spo2_valid, 
                int32_t *pn_heart_rate, int8_t *pch_hr_valid)
/**
* \brief        Calculate the heart rate and SpO2 level
* \par          Details
*               By detecting  peaks of PPG cycle and corresponding AC/DC of red/infra-red signal, the an_ratio for the SPO2 is computed.
*               Since this algorithm is aiming for Arm M0/M3. formaula for SPO2 did not achieve the accuracy due to register overflow.
*               Thus, accurate SPO2 is precalculated and save longo uch_spo2_table[] per each an_ratio.
*
* \param[in]    *pun_ir_buffer           - IR sensor data buffer
* \param[in]    n_ir_buffer_length      - IR sensor data buffer length
* \param[in]    *pun_red_buffer          - Red sensor data buffer
* \param[out]    *pn_spo2                - Calculated SpO2 value
* \param[out]    *pch_spo2_valid         - 1 if the calculated SpO2 value is valid
* \param[out]    *pn_heart_rate          - Calculated heart rate value
* \param[out]    *pch_hr_valid           - 1 if the calculated heart rate value is valid
*
* \retval       None
*/
{
  uint32_t un_ir_mean;
  int32_t k, n_i_ratio_count;
  int32_t i, n_exact_ir_valley_locs_count, n_middle_idx;
  int32_t n_th1, n_npks;   
  int32_t an_ir_valley_locs[15] ;
  int32_t n_peak_interval_sum;
  
  int32_t n_y_ac, n_x_ac;
  int32_t n_spo2_calc; 
  int32_t n_y_dc_max, n_x_dc_max; 
  int32_t n_y_dc_max_idx = 0;
  int32_t n_x_dc_max_idx = 0; 
  int32_t an_ratio[5], n_ratio_average; 
  int32_t n_nume, n_denom ;

  // calculates DC mean and subtract DC from ir
  un_ir_mean =0; 
  for (k=0 ; k<n_ir_buffer_length ; k++ ) un_ir_mean += pun_ir_buffer[k] ;
  un_ir_mean =un_ir_mean/n_ir_buffer_length ;
    
  // remove DC and invert signal so that we can use peak detector as valley detector
  for (k=0 ; k<n_ir_buffer_length ; k++ )  
    an_x[k] = -1*(pun_ir_buffer[k] - un_ir_mean) ; 
    
  // 4 pt Moving Average
  for(k=0; k< BUFFER_SIZE-MA4_SIZE; k++){
    an_x[k]=( an_x[k]+an_x[k+1]+ an_x[k+2]+ an_x[k+3])/(int)4;        
  }
  // calculate threshold  
  n_th1=0; 
  for ( k=0 ; k<BUFFER_SIZE ;k++){
    n_th1 +=  an_x[k];
  }
  n_th1=  n_th1/ ( BUFFER_SIZE);
  if( n_th1<30) n_th1=30; // min allowed
  if( n_th1>60) n_th1=60; // max allowed

  for ( k=0 ; k<15;k++) an_ir_valley_locs[k]=0;
  // since we flipped signal, we use peak detector as valley detector
  maxim_find_peaks( an_ir_valley_locs, &n_npks, an_x, BUFFER_SIZE, n_th1, 4, 15 );//peak_height, peak_distance, max_num_peaks 
  n_peak_interval_sum =0;
  if (n_npks>=2){
    for (k=1; k<n_npks; k++) n_peak_interval_sum += (an_ir_valley_locs[k] -an_ir_valley_locs[k -1] ) ;
    n_peak_interval_sum =n_peak_interval_sum/(n_npks-1);
    *pn_heart_rate =(int32_t)( (FreqS*60)/ n_peak_interval_sum );
    *pch_hr_valid  = 1;
  }
  else  { 
    *pn_heart_rate = -999; // unable to calculate because # of peaks are too small
    *pch_hr_valid  = 0;
  }

  //  load raw value again for SPO2 calculation : RED(=y) and IR(=X)
  for (k=0 ; k<n_ir_buffer_length ; k++ )  {
      an_x[k] =  pun_ir_buffer[k] ; 
      an_y[k] =  pun_red_buffer[k] ; 
  }

  // find precise min near an_ir_valley_locs
  n_exact_ir_valley_locs_count =n_npks; 
  
  //using exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration an_ratio
  //finding AC/DC maximum of raw

  n_ratio_average =0; 
  n_i_ratio_count = 0; 
  for(k=0; k< 5; k++) an_ratio[k]=0;
  for (k=0; k< n_exact_ir_valley_locs_count; k++){
    if (an_ir_valley_locs[k] > BUFFER_SIZE ){
      *pn_spo2 =  -999 ; // do not use SPO2 since valley loc is out of range
      *pch_spo2_valid  = 0; 
      return;
    }
  }
  // find max between two valley locations 
  // and use an_ratio betwen AC compoent of Ir & Red and DC compoent of Ir & Red for SPO2 
  for (k=0; k< n_exact_ir_valley_locs_count-1; k++){
    n_y_dc_max= -16777216 ; 
    n_x_dc_max= -16777216; 
    if (an_ir_valley_locs[k+1]-an_ir_valley_locs[k] >3){
        for (i=an_ir_valley_locs[k]; i< an_ir_valley_locs[k+1]; i++){
          if (an_x[i]> n_x_dc_max) {n_x_dc_max =an_x[i]; n_x_dc_max_idx=i;}
          if (an_y[i]> n_y_dc_max) {n_y_dc_max =an_y[i]; n_y_dc_max_idx=i;}
      }
      n_y_ac= (an_y[an_ir_valley_locs[k+1]] - an_y[an_ir_valley_locs[k] ] )*(n_y_dc_max_idx -an_ir_valley_locs[k]); //red
      n_y_ac=  an_y[an_ir_valley_locs[k]] + n_y_ac/ (an_ir_valley_locs[k+1] - an_ir_valley_locs[k])  ; 
      n_y_ac=  an_y[n_y_dc_max_idx] - n_y_ac;    // subracting linear DC compoenents from raw 
      n_x_ac= (an_x[an_ir_valley_locs[k+1]] - an_x[an_ir_valley_locs[k] ] )*(n_x_dc_max_idx -an_ir_valley_locs[k]); // ir
      n_x_ac=  an_x[an_ir_valley_locs[k]] + n_x_ac/ (an_ir_valley_locs[k+1] - an_ir_valley_locs[k]); 
      n_x_ac=  an_x[n_y_dc_max_idx] - n_x_ac;      // subracting linear DC compoenents from raw 
      n_nume=( n_y_ac *n_x_dc_max)>>7 ; //prepare X100 to preserve floating value
      n_denom= ( n_x_ac *n_y_dc_max)>>7;
      if (n_denom>0  && n_i_ratio_count <5 &&  n_nume != 0)
      {   
        an_ratio[n_i_ratio_count]= (n_nume*100)/n_denom ; //formular is ( n_y_ac *n_x_dc_max) / ( n_x_ac *n_y_dc_max) ;
        n_i_ratio_count++;
      }
    }
  }
  // choose median value since PPG signal may varies from beat to beat
  maxim_sort_ascend(an_ratio, n_i_ratio_count);
  n_middle_idx= n_i_ratio_count/2;

  if (n_middle_idx >1)
    n_ratio_average =( an_ratio[n_middle_idx-1] +an_ratio[n_middle_idx])/2; // use median
  else
    n_ratio_average = an_ratio[n_middle_idx ];

  if( n_ratio_average>2 && n_ratio_average <184){
    n_spo2_calc= uch_spo2_table[n_ratio_average] ;
    *pn_spo2 = n_spo2_calc ;
    *pch_spo2_valid  = 1;//  float_SPO2 =  -45.060*n_ratio_average* n_ratio_average/10000 + 30.354 *n_ratio_average/100 + 94.845 ;  // for comparison with table
  }
  else{
    *pn_spo2 =  -999 ; // do not use SPO2 since signal an_ratio is out of range
    *pch_spo2_valid  = 0; 
  }
}




///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////SPO2//////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





/*******************************************************************************************/
/*********************************************************************************************/
/********************************************************************************************/
    
    
    
    
    
    
    
    
    
    
    
    
    advertising_start();

    ret = app_usbd_power_events_enable();
    APP_ERROR_CHECK(ret);

   // Enter main loop
    for (;;)
    {
      while (app_usbd_event_queue_process())
        {
         sendcom("hello");
        }}
   
      
        
        idle_state_handle();

        
    
}

[nikola]

Karl Ylvisaker said:

Looking briefly through the code you shared this seems not to be the case in your functions Read, Send and Samplesready, at least.

ok i want to check that