
#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 "nrf_ble_qwr.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_pwr_mgmt.h"

//added to handle fds
#include "fds.h"
#include "app_timer.h"
#include "app_error.h"
#include "nrf_cli.h"
#include "fds_example.h"

//end of added to handle fds
#include <stdbool.h>
#include "nrf_delay.h"
#include "nrf_gpio.h"

#define LED 18
#define LED2 19
#define LED4 20
#define Button 14
//added to handle i/o

//includes for twi

#include <stdio.h>
#include "boards.h"
#include "app_util_platform.h"
#include "app_error.h"
#include "nrf_drv_twi.h"


#include "nrf_log_default_backends.h"

uint8_t* clockTime();


//end includes for twi

#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

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

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

#define DEVICE_NAME                     "Nordic_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 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 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(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. */


BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT);                                   /**< BLE NUS 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. */


#define DoingNothingTooLong  APP_TIMER_TICKS(5000)    
#define ValidConnectionTime  APP_TIMER_TICKS(5000)                               //15 seconds in timer ticks, sleep if this condition is met
#define EraseTimeoutQuantity  APP_TIMER_TICKS(15000)   

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}
};


//global vars
bool validConnectionFlag = false;


//forward declarations
void writeTime(const bool writeBool);
void deleteAll();
uint8_t getStateFlag(void);
void deleteStateFlag(void);
void writeStateFlag(const bool flagBool);
void SendTime(void);



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

/* Array to map FDS events to strings. */
static char const * fds_evt_str[] =
{
    "FDS_EVT_INIT",
    "FDS_EVT_WRITE",
    "FDS_EVT_UPDATE",
    "FDS_EVT_DEL_RECORD",
    "FDS_EVT_DEL_FILE",
    "FDS_EVT_GC",
};

/* Dummy configuration data. */
static configuration_t m_dummy_cfg =
{
    .config1_on  = false,
    .config2_on  = true,
    .boot_count  = 0x0,
    .device_name = "dummy",
};

/* A record containing dummy configuration data. */
static fds_record_t const m_dummy_record =
{
    .file_id           = CONFIG_FILE,
    .key               = CONFIG_REC_KEY,
    .data.p_data       = &m_dummy_cfg,
    /* The length of a record is always expressed in 4-byte units (words). */
    .data.length_words = (sizeof(m_dummy_cfg) + 3) / sizeof(uint32_t),
};

/* Keep track of the progress of a delete_all operation. */
static struct
{
    bool delete_next;   //!< Delete next record.
    bool pending;       //!< Waiting for an fds FDS_EVT_DEL_RECORD event, to delete the next record.
} m_delete_all;

/* Flag to check fds initialization. */
static bool volatile m_fds_initialized;


const char *fds_err_str(ret_code_t ret)
{
    /* Array to map FDS return values to strings. */
    static char const * err_str[] =
    {
        "FDS_ERR_OPERATION_TIMEOUT",
        "FDS_ERR_NOT_INITIALIZED",
        "FDS_ERR_UNALIGNED_ADDR",
        "FDS_ERR_INVALID_ARG",
        "FDS_ERR_NULL_ARG",
        "FDS_ERR_NO_OPEN_RECORDS",
        "FDS_ERR_NO_SPACE_IN_FLASH",
        "FDS_ERR_NO_SPACE_IN_QUEUES",
        "FDS_ERR_RECORD_TOO_LARGE",
        "FDS_ERR_NOT_FOUND",
        "FDS_ERR_NO_PAGES",
        "FDS_ERR_USER_LIMIT_REACHED",
        "FDS_ERR_CRC_CHECK_FAILED",
        "FDS_ERR_BUSY",
        "FDS_ERR_INTERNAL",
    };

    return err_str[ret - NRF_ERROR_FDS_ERR_BASE];
}


static void fds_evt_handler(fds_evt_t const * p_evt)
{
    if (p_evt->result == NRF_SUCCESS)
    {
        NRF_LOG_GREEN("Event: %s received (NRF_SUCCESS)",
                      fds_evt_str[p_evt->id]);
    }
    else
    {
        NRF_LOG_GREEN("Event: %s received (%s)",
                      fds_evt_str[p_evt->id],
                      fds_err_str(p_evt->result));
    }

    switch (p_evt->id)
    {
        case FDS_EVT_INIT:
            if (p_evt->result == NRF_SUCCESS)
            {
                m_fds_initialized = true;
            }
            break;

        case FDS_EVT_WRITE:
        {
            if (p_evt->result == NRF_SUCCESS)
            {
                NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->write.record_id);
                NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->write.file_id);
                NRF_LOG_INFO("Record key:\t0x%04x", p_evt->write.record_key);
            }
        } break;

        case FDS_EVT_DEL_RECORD:
        {
            if (p_evt->result == NRF_SUCCESS)
            {
                NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->del.record_id);
                NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->del.file_id);
                NRF_LOG_INFO("Record key:\t0x%04x", p_evt->del.record_key);
            }
            m_delete_all.pending = false;
        } break;

        default:
            break;
    }
}


/**@brief   Begin deleting all records, one by one. */
void delete_all_begin(void)
{
    m_delete_all.delete_next = true;
}


/**@brief   Process a delete all command.
 *
 * Delete records, one by one, until no records are left.
 */
void delete_all_process(void)
{
    if (   m_delete_all.delete_next
        & !m_delete_all.pending)
    {
        NRF_LOG_INFO("Deleting next record.");

        m_delete_all.delete_next = record_delete_next();
        if (!m_delete_all.delete_next)
        {
            NRF_LOG_CYAN("No records left to delete.");
        }
    }
}



/**@brief   Initialize the timer. */
static void timer_init(void)
{
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
}


/**@brief   Initialize logging. */
static void log_init(void)
{
    ret_code_t rc = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(rc);
}


/**@brief   Sleep until an event is received. */
static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
    (void) sd_app_evt_wait();
#else
    __WFE();
#endif
}


/**@brief   Wait for fds to initialize. */
static void wait_for_fds_ready(void)
{
    while (!m_fds_initialized)
    {
        power_manage();
    }
}




//end of functions added for fds




/**@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 analyse
 *          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] 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);
}

/**@brief Function for the GAP initialization.
 *
 * @details This function will set 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 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 the data from the Nordic UART Service.
 *
 * @details This function will process the data received from the Nordic UART BLE Service and send
 *          it to the UART module.
 *
 * @param[in] p_evt       Nordic UART Service event.
 */
/**@snippet [Handling the data received over BLE] */
static void nus_data_handler(ble_nus_evt_t * p_evt)
{

    if (p_evt->type == BLE_NUS_EVT_RX_DATA)
    {
        uint32_t err_code;

        NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
        NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);

        for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
        {
            do
            {
                err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
                if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
                {
                    NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
                    APP_ERROR_CHECK(err_code);
                }
            } while (err_code == NRF_ERROR_BUSY);
        }
        if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r')
        {
            while (app_uart_put('\n') == NRF_ERROR_BUSY);
        }
    }

}
/**@snippet [Handling the data received over BLE] */


/**@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;
    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 NUS.
    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 an event from the Connection Parameters Module.
 *
 * @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 config 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)
{
    uint32_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 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             = false;
    cp_init.evt_handler                    = on_conn_params_evt;
    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 will 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.
    //this configures button 14 and 13 to wake from sleep off mode with code: bsp_wakeup_button_enable(BTN_ID_WAKEUP);
    //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 putting the chip into sleep mode.
 *
 * @note This function will not return.
 */
static void sleep_mode_enter_wakeup_enabled(void)
{
    uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
    APP_ERROR_CHECK(err_code);

    // Prepare wakeup buttons.
    //this configures button 14 and 13 to wake from sleep off mode with code: bsp_wakeup_button_enable(BTN_ID_WAKEUP);
    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)
{
    uint32_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;
        case BLE_ADV_EVT_IDLE:
            sleep_mode_enter_wakeup_enabled();
            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("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");
            // 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_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;

        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 rc;
    //added functionality from flash fds
    uint32_t   ram_start;

    /* Enable the SoftDevice. */
    rc = nrf_sdh_enable_request();
    APP_ERROR_CHECK(rc);

     rc = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
     APP_ERROR_CHECK(rc);

    //end functionality from flash fds
    

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.

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

    // 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, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
    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_wakeup_enabled();
            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 handling app_uart events.
 *
 * @details This function will receive a single character from the app_uart module and append it to
 *          a string. The string will be be sent over BLE when the last character received was a
 *          'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
 */
/**@snippet [Handling the data received over UART] */
void uart_event_handle(app_uart_evt_t * p_event)
{
    static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
    static uint8_t index = 0;
    uint32_t       err_code;

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            index++;

            if ((data_array[index - 1] == '\n') ||
                (data_array[index - 1] == '\r') ||
                (index >= m_ble_nus_max_data_len))
            {
                if (index > 1)
                {
                    NRF_LOG_DEBUG("Ready to send data over BLE NUS");
                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);

                    do
                    {
                        uint16_t length = (uint16_t)index;
                        err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
                        if ((err_code != NRF_ERROR_INVALID_STATE) &&
                            (err_code != NRF_ERROR_RESOURCES) &&
                            (err_code != NRF_ERROR_NOT_FOUND))
                        {
                            APP_ERROR_CHECK(err_code);
                        }
                    } while (err_code == NRF_ERROR_RESOURCES);
                }

                index = 0;
            }
            break;

        case APP_UART_COMMUNICATION_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_communication);
            break;

        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;

        default:
            break;
    }
}
/**@snippet [Handling the data received over UART] */


/**@brief  Function for initializing the UART module.
 */
/**@snippet [UART Initialization] */
static void uart_init(void)
{
    uint32_t                     err_code;
    app_uart_comm_params_t const comm_params =
    {
        .rx_pin_no    = RX_PIN_NUMBER,
        .tx_pin_no    = TX_PIN_NUMBER,
        .rts_pin_no   = RTS_PIN_NUMBER,
        .cts_pin_no   = CTS_PIN_NUMBER,
        .flow_control = APP_UART_FLOW_CONTROL_DISABLED,
        .use_parity   = false,
#if defined (UART_PRESENT)
        .baud_rate    = NRF_UART_BAUDRATE_115200
#else
        .baud_rate    = NRF_UARTE_BAUDRATE_115200
#endif
    };

    APP_UART_FIFO_INIT(&comm_params,
                       UART_RX_BUF_SIZE,
                       UART_TX_BUF_SIZE,
                       uart_event_handle,
                       APP_IRQ_PRIORITY_LOWEST,
                       err_code);
    APP_ERROR_CHECK(err_code);
}
/**@snippet [UART Initialization] */


/**@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.
 *
 * @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)
{
    bsp_event_t startup_event;

    uint32_t 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 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(void)
{
    uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}


/**@brief Application main function.
 */

 #define TWI_INSTANCE_ID 0

static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);

void twi_init(void) //configure twi connection
{
  ret_code_t err_code; 

  const nrf_drv_twi_config_t twi_config = {
    .scl = 22, //configure pin 22 to scl
    .sda = 23, //configure pin 23 to sda
    .frequency = NRF_DRV_TWI_FREQ_100K, //nrf freq 100k 250k or 400k
    .interrupt_priority = APP_IRQ_PRIORITY_HIGH, //if using a soft device this has to be changed accordingly
    .clear_bus_init = false 

    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, NULL, NULL); //can pass this an interrupt handler
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);

}

uint8_t bcd_decimal(uint8_t x) 
{
  //return (x - 6 * (x >> 4)) - 80;
  return (x - 6 * (x >> 4)) - 256;
  //sometimes needs -80, sometimes -256
}    


//Function to set the clock
void setClock()
{
    uint8_t address = 0x68; //address of DS1339
 //                         skip  sec   min   HR    skip  date  MO    YR
    uint8_t timeBuffer[] = {0x00, 0x00, 0x44, 0x00, 0x00, 0x08, 0x08, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
    nrf_drv_twi_tx(&m_twi, address, &timeBuffer, 17, true);
}



uint8_t* clockTime()
{

    ret_code_t err_code;
    uint8_t address = 0x68; //address of DS1307
    static uint8_t rx_data[17]  = {0}; //buffer for rx twi info. array of 7 uint8_t to hold 7 bytes received over twi
    uint8_t startAddress = 0x00;
  

   err_code = nrf_drv_twi_tx(&m_twi, address, &startAddress, 1, true); //transmit to designate the start address

   if (NRF_SUCCESS == err_code) //if the starting address was successfully transmitted receive the 7 bytes for the clock time
   {
     err_code = nrf_drv_twi_rx(&m_twi, address, &rx_data, sizeof(rx_data));
   }

   rx_data[0] = bcd_decimal(rx_data[0]); //rx[3] holds seconds which is a weird bcd.  must convert then subtract 80 then typecast it to a decimal
   //after 6th entry the clock breaks and needs to be uninit.  on first run bcd_decimal must be run but in subsequent runs it can be removed?
   return (rx_data);
}



//event handler if doing nothing
static void mSleepTimer_timeout_handler(void * p_context)
{
  sleep_mode_enter_wakeup_enabled();
}



//timeout means we have a valid connection
static void mConnectTimer_timeout_handler(void * p_context)
{
  validConnectionFlag = true;
}



//times out if held down for 5 seconds or if nothing is done for 5 seconds, deletes everything if 10 presses after advertising
void potentiallyDeleteAll()
{
  uint8_t resetCount = 10;
  bool wasThereAButtonPress = false;
  APP_TIMER_DEF(mlongConnection);                                      
  app_timer_create(&mlongConnection, APP_TIMER_MODE_SINGLE_SHOT, mSleepTimer_timeout_handler);
  APP_TIMER_DEF(mNoActivity);  
  app_timer_create(&mNoActivity, APP_TIMER_MODE_SINGLE_SHOT, mSleepTimer_timeout_handler);
  

  while(true) 
  {
    app_timer_start(mNoActivity,EraseTimeoutQuantity, NULL); 
        

    while(nrf_gpio_pin_read(Button) == 0) 
    {
      app_timer_stop(mNoActivity); 
      app_timer_start(mlongConnection, EraseTimeoutQuantity, NULL); 
      wasThereAButtonPress = true;
      nrf_delay_ms(100);
    };

        
    if(wasThereAButtonPress == true)
    {
    resetCount++;
    wasThereAButtonPress = false;
    }

    app_timer_stop(mlongConnection); 

    if(resetCount == 20)
    {
      deleteAll();
      bsp_wakeup_button_enable(Button);
      sleep_mode_enter_wakeup_enabled();
    }
        
  }//end while loop

}//end potentially delete fn


//record time on valid press, 10 presses to put into advertising mode/send then 10 more presses to delete everything
void buttonPress()
{

  const bool startTime = 0;
  const bool endTime = 1;

  if(getStateFlag() == 1)
  {
    writeTime(endTime); 
    nrf_delay_ms(150); 
    deleteStateFlag();
    nrf_delay_ms(50);
    writeStateFlag(0);
    nrf_delay_ms(50);
    advertising_start(); 
    nrf_delay_ms(500);
    SendTime(); 
    nrf_delay_ms(500);

    //set button 14 to wake up from any gpio event

    sleep_mode_enter_wakeup_enabled();
  }



  uint8_t resetCount = 0;
  bool wasThereAButtonPress = false;
  nrf_gpio_cfg_output(LED); //configures the led pin as an output pin
  nrf_gpio_cfg_input(Button, NRF_GPIO_PIN_PULLUP); //configures the button pin as an input pin. nrf_gpio_cfg_input takes argument for a pin and an enumerator. 
  APP_TIMER_DEF(mSleepTimer);                                      
  app_timer_create(&mSleepTimer, APP_TIMER_MODE_SINGLE_SHOT, mSleepTimer_timeout_handler); //mSleepTimer handler can be passed by ref like this since the third parameter is already the typedef of an app_timer_timeout_handler_t function
  APP_TIMER_DEF(mConnectTimer);                                      
  app_timer_create(&mConnectTimer, APP_TIMER_MODE_SINGLE_SHOT, mConnectTimer_timeout_handler);
  
   nrf_gpio_pin_set(LED); //turns off the led by setting = to 1, this is now default state
  

   while(true) //enter this loop which will act as an event handler for a button press if a button press is received, or timeout and go into sleep mode if DoingNothingTooLong (15 seconds) time is reached
   {
      app_timer_start(mSleepTimer,DoingNothingTooLong, NULL); //timer to put into sleep mode for case of device woken up but no button press is received
        

        //when button isn't being held button = 1 so this is skipped
     while(nrf_gpio_pin_read(Button) == 0 && validConnectionFlag == false) //while the button is being pressed loop. stay here until button is released
     {
         nrf_gpio_pin_clear(LED); //led on while in loop couting to see if valid connection. this light will turn off if start time written successfully
         app_timer_stop(mSleepTimer); //stop the doing nothing timer
         app_timer_start(mConnectTimer, ValidConnectionTime, NULL); //if button held for 10 seconds then timeout and go to mConnect handler otherwise leave loop which starts process over
         wasThereAButtonPress = true;
         nrf_delay_ms(100); //debouncing for button press less than 5 sec for the reset count
     };

     //while loops increment stuff really fast, we only want to increment if there was a button press that was less than ValidConnectionTime took place
     if(wasThereAButtonPress == true)
     {
        resetCount++;
        wasThereAButtonPress = false;
     }
  
     nrf_gpio_pin_set(LED);
     app_timer_stop(mConnectTimer); //if the hold was less than 10 seconds leave the loop which stops the connect timer, then returns to the doing nothing too long timer

     //if the times have been written leave this loop and go back to main
    

     //if there was a valid connection then write the start time to memory and change the state flag to 1
     if(validConnectionFlag == true)
     {
      //sense mode will sense when the pin goes high (ie disconnect).  can't cfg twice or causes issues
      nrf_gpio_cfg_sense_input(Button, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_HIGH);
  
      writeTime(startTime);
      nrf_delay_ms(150); 

      //change the state flag to pressed
      deleteStateFlag();
      nrf_delay_ms(50);
      writeStateFlag(1);
      nrf_delay_ms(50);

      printf("start time written to memory time written to memory, state flag set to 1");

      nrf_delay_ms(500);

      sleep_mode_enter();
     }
        
     //after the 10th press advertise and send the info. for some reason it resets after advertising?
     if(resetCount == 10) 
     {
        advertising_start(); 
        nrf_delay_ms(10000);
        SendTime(); 
        potentiallyDeleteAll(); //i disabled the leds for this so if it goes to sleep it deleted
     }

   } //end while loop for button event handling
} //end button press fn



void writeTime(const bool writeBool)
{
   #define FILE_ID         0x0005  /* The ID of the file to write the records into. */
   #define RECORD_KEY_1    0x5555  /* A key for the first record. */

   ret_code_t rc = NULL;

   uint8_t* rx_data = clockTime(); //get the pointer to the array that holds the clockTime

   static char intermediate[20] = {0}; //writing to the aligned variable breaks the alignment but memcpy doesn't.  So add data to an intermediate var then memcpy it to the aligned variable and write it to memory.
  __ALIGN(4) static char m_timeStart[20] = {0};


 
  switch(writeBool) 
  { 
     case 0 : 
        snprintf(intermediate, sizeof(intermediate), "S: %x:%x:%d %x/%x/%x", rx_data[2], rx_data[1], rx_data[0], rx_data[5], rx_data[4], rx_data[6]);
        break;

     case 1 : 
        snprintf(intermediate, sizeof(intermediate), "E: %x:%x:%d %x/%x/%x", rx_data[2], rx_data[1], rx_data[0], rx_data[5], rx_data[4], rx_data[6]);
        break;

     default :
        break;
  } 
      
   //copy the correct version (start or end) to m_timeStart
   memcpy(m_timeStart, intermediate, sizeof(intermediate));


   fds_record_t        record;
   fds_record_desc_t   record_desc;


   // Set up record.

   record.file_id           = FILE_ID;
   record.key               = RECORD_KEY_1;
   record.data.p_data       = &m_timeStart;
   /* The following calculation takes into account any eventual remainder of the division. */
   record.data.length_words = (sizeof(m_timeStart) + 3) / 4;
   rc = fds_record_write(&record_desc, &record);

   if (rc != NRF_SUCCESS)
   {
    printf("Ltart time didn't work. rc: %x", rc); 
   }
   else
   {
     printf("Wtart time did work"); 
   }
}

void countEntries(void)
{
  fds_flash_record_t  flash_record = {0};
  fds_record_desc_t   desc1 = {0};
  fds_find_token_t    tok1 = {0};
  ret_code_t rc;
  uint8_t countEntries = 0;

  /* It is required to zero the token before first use. */
  memset(&tok1, 0x00, sizeof(fds_find_token_t));

  //count files in memory 
  while (fds_record_find(FILE_ID, RECORD_KEY_1, &desc1, &tok1) == NRF_SUCCESS) //loop thru all records with this address
  {
    /* Open the record and read its contents. */
    rc = fds_record_open(&desc1, &flash_record);
    APP_ERROR_CHECK(rc);

        
    /* Close the record when done reading. */
    rc = fds_record_close(&desc1);
    APP_ERROR_CHECK(rc);

    countEntries++;

  } //end while loop

  printf("There are %d entires total.", countEntries);
}

void writeStateFlag(const bool flagBool)
{
   #define FILE_ID2         0x0006  /* The ID of the file to write the records into. */
   #define RECORD_KEY_2    0x6666  /* A key for the first record. */

   ret_code_t rc = NULL;
   fds_record_t        record;
   fds_record_desc_t   record_desc;
   record.file_id           = FILE_ID2;
   record.key               = RECORD_KEY_2;
   __ALIGN(4) static const bool m_stateFlagF = false;
   __ALIGN(4) static const bool m_stateFlagT = true;

 switch(flagBool) 
  { 
     case 0 : 
        record.data.p_data       = &m_stateFlagF;
        break;

     case 1 : 
        record.data.p_data       = &m_stateFlagT;
        break;

     default :
        break;
  } 

   


   // Set up record. moved to top with p data defined based on the switch statement

   /* The following calculation takes into account any eventual remainder of the division. */
   record.data.length_words = (sizeof(m_stateFlagF) + 3) / 4;
   rc = fds_record_write(&record_desc, &record);

   nrf_delay_ms(50);

   if (rc != NRF_SUCCESS)
   {
    printf("writing state flag didn't work. rc: %x. end of rc", rc); 
   }
   else
   {
     printf("state flag correctly written to \n"); 
   }
}

uint8_t getStateFlag(void)
{
  
  fds_flash_record_t  flash_record = {0};
  fds_record_desc_t   desc1 = {0};
  fds_find_token_t    tok1 = {0};
  ret_code_t rc;
  uint8_t countEntries = 0;
  uint32_t       err_code;
  uint8_t hold = 0; 

  /* It is required to zero the token before first use. */
  memset(&tok1, 0x00, sizeof(fds_find_token_t));

  if(fds_record_find(FILE_ID2, RECORD_KEY_2, &desc1, &tok1) == NRF_SUCCESS)
  {
    rc = fds_record_open(&desc1, &flash_record);
    APP_ERROR_CHECK(rc);


    //flash_record.p_data is a pointer to the physical memory location
 
    hold = *(volatile uint8_t *)flash_record.p_data;
 

    uint16_t length1 = sizeof(hold);

    //loop to handle soft device buffer full (caused to stop sending after 11 sends).  repeatedly calls ble_nus_data_send until it doesn't return nrf_error_resources
    
    printf("the state flag from memory is: %d \n", hold);


    /* Close the record when done reading. */
    rc = fds_record_close(&desc1);
    APP_ERROR_CHECK(rc);
    nrf_delay_ms(50);

  } //end if cond
  //if there is no file then set the state to not pressed since file hasn't run
  else
  {
    writeStateFlag(0);
    printf("getStateFlag called without a written flag, flag now set to 0 \n");
  }
  return hold; //hold holds the state
}

void deleteStateFlag(void)
{
  fds_flash_record_t  flash_record = {0};
  fds_record_desc_t   desc1 = {0};
  fds_find_token_t    tok1 = {0};
  ret_code_t rc;
  memset(&tok1, 0x00, sizeof(fds_find_token_t));

  while (fds_record_find(FILE_ID2, RECORD_KEY_2, &desc1, &tok1) == NRF_SUCCESS) //loop thru all records with this address
  {
    rc = fds_record_delete(&desc1);
    nrf_delay_ms(50);

    if (rc != NRF_SUCCESS)
    {
      printf("delete failed, rc: %x", rc); 
    }

  } //end while loop

  rc = fds_gc();
  if(rc != NRF_SUCCESS)
  {
    printf("garbage failed, rc: %x", rc);
  }
  else
  {
    //printf("garbage succeeded"); 
  }

  //printf("All records successfully deleted");
}

void SendTime(void)
{
  fds_flash_record_t  flash_record = {0};
  fds_record_desc_t   desc1 = {0};
  fds_find_token_t    tok1 = {0};
  ret_code_t rc;
  uint8_t countEntries = 0;
  uint32_t       err_code;

  /* It is required to zero the token before first use. */
  memset(&tok1, 0x00, sizeof(fds_find_token_t));

  while (fds_record_find(FILE_ID, RECORD_KEY_1, &desc1, &tok1) == NRF_SUCCESS) //loop thru all records with this address
  {
    /* Open the record and read its contents. */
    rc = fds_record_open(&desc1, &flash_record);
    APP_ERROR_CHECK(rc);

    uint8_t hold[20] = {0}; 

    //flash_record.p_data is a pointer to the physical memory location
    for(int i = 0; i < 20; i++) //get the string from flash memory and typecast it to uint8_t to minimize data tx
    {
      hold[i] = *(volatile uint8_t *)flash_record.p_data;
      flash_record.p_data++;
    }

    uint16_t length1 = sizeof(hold);

    //loop to handle soft device buffer full (caused to stop sending after 11 sends).  repeatedly calls ble_nus_data_send until it doesn't return nrf_error_resources
    do
    {
      err_code = ble_nus_data_send(&m_nus, hold, &length1, m_conn_handle);
      if ( (err_code != NRF_ERROR_INVALID_STATE) && (err_code != NRF_ERROR_RESOURCES) &&
          (err_code != NRF_ERROR_NOT_FOUND) )
      {
        APP_ERROR_CHECK(err_code);
      }

    } while (err_code == NRF_ERROR_RESOURCES);

    /* Close the record when done reading. */
    rc = fds_record_close(&desc1);
    APP_ERROR_CHECK(rc);

  } //end while loop
}


void deleteAll()
{
  fds_flash_record_t  flash_record = {0};
  fds_record_desc_t   desc1 = {0};
  fds_find_token_t    tok1 = {0};
  ret_code_t rc;
  memset(&tok1, 0x00, sizeof(fds_find_token_t));

  while (fds_record_find(FILE_ID, RECORD_KEY_1, &desc1, &tok1) == NRF_SUCCESS) //loop thru all records with this address
  {
    rc = fds_record_delete(&desc1);
    NRF_LOG_INFO("file deleted"); 
    nrf_delay_ms(100);

    if (rc != NRF_SUCCESS)
    {
      NRF_LOG_INFO("delete failed, rc: %x", rc); 
    }

  } //end while loop

  rc = fds_gc();
  if(rc != NRF_SUCCESS)
  {
    NRF_LOG_INFO("garbage failed, rc: %x", rc);
  }
  else
  {
    NRF_LOG_INFO("garbage succeeded"); 
  }

  printf("All records successfully deleted");
}

/*
void initStateHandler();
{
    //if the state flag is 1, the button has been pressed and we start the program by changing it to the released state
    if (getStateFlag() == true)
    {
      deleteStateFlag();
      writeStateFlag(0);
    }
    //if the state flag is 0 the button has not been pressed and we start the program by changing it to the pressed state
    //potential issue here is if pressed but not valid connection == only change this if there was a valid connection
    else if (getStateFlag() == false)
    {
      //deleteStateFlag();
      //writeStateFlag(1);
    }
}
*/


int main(void)
{
    bool erase_bonds;
    ret_code_t rc;

    // Initialize.
    twi_init();
    uart_init();
    log_init();
    timers_init();
    buttons_leds_init(&erase_bonds);
    power_management_init();
    ble_stack_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();

    


    //initStateHandler();

    //Comment in setClock() function to set a hardcoded time.  See setClock for details
    //in current form need to run once with commented in, then comment out and run again, otherwise
    //the time will reset after each sleep cycle.  Is there a way to keep variables between sleep cycles
    //without writing to flash?  Could also just write to flash the flag that says if written and pull it > check it
    //between runs.  this will be the same logic to control more efficient powering of read/write

    //setClock();


    /* Register first to receive an event when initialization is complete. */
    (void) fds_register(fds_evt_handler);


    rc = fds_init();
    APP_ERROR_CHECK(rc);

    /* Wait for fds to initialize. */
    wait_for_fds_ready();

    // Start execution.
    printf("\r\nUART started.\r\n");



    //turn on LED3 while on and not in sleep mode. added to make sure device isn't running unnecessarily
    nrf_gpio_cfg_output(LED2);
    nrf_gpio_pin_clear(LED2);

    NRF_LOG_INFO("Debug logging for UART over RTT started.");


    //flow of events: init everyting > begin advertising > write the start time to memory > wait for button release event > on button release event record the end time 
    // >send the entire log of start and end times over ble notification > go to sleep 5 seconds later

    //button press waits for a button press event or times out and goes to sleep mode if no button press is received in 15 seconds
   
    
    buttonPress(); 

    nrf_delay_ms(100);

    //added for debugging
    countEntries();

    //save power by only advertising after the data has been written to memory and is ready to send
    advertising_start(); 

    //advertise for 15 seconds then try to send the data
    nrf_delay_ms(5000);

    //SendTime sends the entire memory, should add a condition to make sure that it's connected to BLE, potentially only send new entries etc.
    SendTime(); 

    //wait 5 seconds after sending the data before entering sleep mode, just here to give time to read in devtools for debugging
    nrf_delay_ms(5000);

    sleep_mode_enter_wakeup_enabled();
    
    





    // Enter main loop.
    for (;;)
    {
        //idle_state_handle();
    }
}


