/**
 * Copyright (c) 2014 - 2019, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
/** @file
 *
 * @defgroup ble_sdk_uart_over_ble_main main.c
 * @{
 * @ingroup  ble_sdk_app_nus_eval
 * @brief    UART over BLE application main file.
 *
 * This file contains the source code for a sample application that uses the Nordic UART service.
 * This application uses the @ref srvlib_conn_params module.
 */


#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"

#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"
#include "measure.h"
#include "protect.h"
#include "Modbus.h"
#include "Modbus_Monitor.h"

#include "nrf_fstorage.h"
#include "nrf_fstorage_sd.h"

#include "nrf_drv_timer.h"

#include "nrf_drv_ppi.h"
#include "nrf_drv_saadc.h"
#include "SEGGER_RTT.h"
#include "SEGGER_RTT_Conf.h"

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

#define DEVICE_NAME                     "BLE_CC"                               /**< 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                320                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */

#define APP_ADV_DURATION                0                                       /**< 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. */


extern const nrf_drv_timer_t m_timer;
extern nrf_ppi_channel_t     m_ppi_channel;

/*****     自定义全局变量区----START      ******/

//实例化区

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);      
///<声明一个定时任务ID
APP_TIMER_DEF(Timer_Task_Trip);
#define  App_Timer_TripCheck_Interval   APP_TIMER_TICKS(1)

uint32_t          mark_time=0;
uint32_t          make_time_1s=0;
//static uint32_t   sample_num=0;
               


float val[8];

uint32_t     StallCount=0;                //堵转计数20ms/次
uint32_t	 AutoResetCount=0;            //自动复位计数
uint32_t	 FaultLEDFlashCount=0;        //灯闪烁时间计数
uint32_t	 RelayOnBitCount=0;
uint16_t	 RelayOnBitFlag=0;

volatile	 uint32_t ADC_done=0;

uint32_t	 Keycount=0;//计数
uint32_t	 Tripbit=0;//脱扣标志位,0未脱扣，1已脱扣，需要复位。

uint8_t		 CheckON=0;//互感器校准时置位0
uint8_t		 RunFlag=1;//运行状态，默认为1
uint8_t		 KeycountRESET=0;//复位及停止计数
uint8_t		 FaultLEDFlash=0;//灯闪烁标志，全亮(5)：过载，闪一次：不平衡，闪两次：堵转，闪三次：阻塞，闪四次：接地

//实际值与整定值比例
uint32_t	 temp_currFactA=0;
uint32_t	 temp_currFactB=0;
uint32_t	 temp_currFactC=0;

//互感器系数
float			 CoeffA=1;
float			 CoeffB=1;
float			 CoeffC=1;	

//互感器系数*100
uint16_t		 Coeffa;
uint16_t		 Coeffb;
uint16_t		 Coeffc;

uint8_t			 ResetBit;
uint8_t			 StopBit;

//要写入到STM32 FLASH的字符串数组

uint16_t			 ReBuffer[3];

uint8_t       ModbusFlag=0;
uint8_t       ModbusWriteFlag=0;

UART_DATA_TPDF  Modbus_ReceiveBuffer;
UART_DATA_TPDF  Modbus_SendBuffer;

/*****     自定义全局变量区----END      ******/

//页号
#define PAGE_NUM         62
//页起始地址
#define FLASH_START_ADDR 4*1024*PAGE_NUM

//BLE参数存储页  61
#define BLE_PAGE_NUM      61
//页起始地址
#define FLASH_BLE_ADDR  0x0003d000



//声明FS操作结构体
typedef struct
{
    uint16_t write_data[256];//FS写缓存数组
    uint8_t read_data[256]; //FS读缓存数组
	  uint32_t write_len;     //写入的数据长度
    bool need_write;        //写标志
	  bool need_read;         //读标志
    bool busy;              //FS忙标志
}my_fs_info_t;
//定义FS操作结构体变量
static my_fs_info_t my_fs_info;

static uint32_t nrf5_flash_end_addr_get()
{
    uint32_t const bootloader_addr = BOOTLOADER_ADDRESS;
    uint32_t const page_sz         = NRF_FICR->CODEPAGESIZE;
    uint32_t const code_sz         = NRF_FICR->CODESIZE;

    return (bootloader_addr != 0xFFFFFFFF ?
            bootloader_addr : (code_sz * page_sz));
}

static void fstorage_evt_handler(nrf_fstorage_evt_t * p_evt);
//定义名称为my_fs的FS实例：定义回调函数和FS空间
NRF_FSTORAGE_DEF(nrf_fstorage_t my_fs) =
{
    //FS事件回调函数
    .evt_handler = fstorage_evt_handler,

	  //定义FS的空间（起始地址和结束地址），我们必须自己设置起始地址和结束地址
	  //在调用nrf_fstorage_init()函数初始化之前，我们也可以使用nrf5_flash_end_addr_get()
	  //函数获取可用于写入数据的Flash的最后一页上的结束地址
    .start_addr = 0x3e000,
    .end_addr   = 0x3ffff,
};

NRF_FSTORAGE_DEF(nrf_fstorage_t my_fs_ble) =
{
    //FS事件回调函数
    .evt_handler = fstorage_evt_handler,

	  //定义FS的空间（起始地址和结束地址），我们必须自己设置起始地址和结束地址
	  //在调用nrf_fstorage_init()函数初始化之前，我们也可以使用nrf5_flash_end_addr_get()
	  //函数获取可用于写入数据的Flash的最后一页上的结束地址
    .start_addr = 0x3d000,
    .end_addr   = 0x3dfff,
};


                                           /**< Advertising module instance. */

APP_TIMER_DEF(SendTimer);
static uint32_t time_ticket = 0;

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


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

}


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

static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
    (void) sd_app_evt_wait();
#else
    __WFE();
#endif
}
//FS事件处理函数
static void fstorage_evt_handler(nrf_fstorage_evt_t * p_evt)
{
    //FS操作错误
	if (p_evt->result != NRF_SUCCESS)
    {
        NRF_LOG_INFO("--> Event received: ERROR while executing an fstorage operation.");
        return;
    }
    //判断事件类型，执行相应处理，这里只是打印出事件信息
    switch (p_evt->id)
    {
        //FS写完成事件
			  case NRF_FSTORAGE_EVT_WRITE_RESULT:
        {
          my_fs_info.busy = false;  
        } break;
        //擦除完成事件
        case NRF_FSTORAGE_EVT_ERASE_RESULT:
        {
					  my_fs_info.busy = false; 
        } break;

        default:
            break;
    }
}



/**@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)
    {
		ModbusFlag = 1;

		memset(&Modbus_ReceiveBuffer,0,sizeof(Modbus_ReceiveBuffer));
	
		Modbus_ReceiveBuffer.Length = p_evt->params.rx_data.length;
		memcpy(Modbus_ReceiveBuffer.Buff, p_evt->params.rx_data.p_data, Modbus_ReceiveBuffer.Length);
//		for(uint8_t i=0;i<Modbus_ReceiveBuffer.Length;i++)
//		{
//			SEGGER_RTT_printf(0,"Receive  %d \n",Modbus_ReceiveBuffer.Buff[i]);
//		
//		}

//        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.
    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();
            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 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);
	
	err_code = sd_power_mode_set(NRF_POWER_MODE_LOWPWR);
    APP_ERROR_CHECK(err_code);

/**************problem***************/
//    err_code = sd_power_dcdc_mode_set(NRF_POWER_DCDC_ENABLE);     **************problem***************
//    APP_ERROR_CHECK(err_code);
//		FaultLed1On;
}


/**@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();
            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] */
static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];

static uint8_t index = 0;
void uart_event_handle(app_uart_evt_t * p_event)
{
    
    
    uint32_t       err_code;

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
			 UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            index++;
            //接收串口数据，当接收的数据长度达到m_ble_uarts_max_data_len或者接收到换行符后认为一包数据接收完成
            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);
                    //串口接收的数据使用notify发送给BLE主机
                    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;
            }
		
//            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
//						app_uart_put(data_array[index]);						
//						NRF_LOG_INFO("data%d",data_array[index]);
//						index++;
//						time_ticket =1;
//            if ((data_array[index - 1] == '\n') ||
//                (data_array[index - 1] == '\r') ||
//                (index >= m_ble_nus_max_data_len))
//            {
//                if (index > 1)
//                {
//                    NRF_LOG_INFO("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:
            NRF_LOG_INFO("%d",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_9600
#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_GENERAL_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);
//}
uint32_t get_rtc_counter(void)
{
  return NRF_RTC1->COUNTER;
}

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

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


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


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


/**@brief Function for starting advertising.
 */
static void advertising_start(void)
{
    uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}



/**@brief Application main function.
 */
#include "nrf_gpio.h"
#include "nrf_drv_gpiote.h"

static void gpiote_event_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{	
		if (pin==RX_PIN_NUMBER)
		{
				uart_init();
				nrf_drv_gpiote_in_event_enable(RX_PIN_NUMBER, false);
				nrf_drv_gpiote_in_uninit(RX_PIN_NUMBER);	
				NRF_LOG_INFO("uart_init");				
				time_ticket=1;
				app_timer_start(SendTimer,APP_TIMER_TICKS(1),NULL); 
		}
}

void uart_wakeup_init(void)
{
		uint32_t err_code;	
		if (!nrf_drv_gpiote_is_init())
    {
        err_code = nrf_drv_gpiote_init();
        APP_ERROR_CHECK(err_code);
    }	
		nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true);
		config.pull =  NRF_GPIO_PIN_PULLUP;
    err_code = nrf_drv_gpiote_in_init(RX_PIN_NUMBER, &config, gpiote_event_handler);
    APP_ERROR_CHECK(err_code);
		nrf_drv_gpiote_in_event_enable(RX_PIN_NUMBER, true);
}

static void gpio_init(void)
{
		nrf_gpio_cfg_output(RUN_LED);
	    nrf_gpio_cfg_output(FALUT_LED);
		nrf_gpio_cfg_output(Relay);
		RunLedOff;
		FaultLed1Off;
	
 		nrf_gpio_cfg_input(M_RESET, NRF_GPIO_PIN_PULLUP);	  
		nrf_gpio_cfg_input(T1_LEVEL, NRF_GPIO_PIN_PULLUP);	
		nrf_gpio_cfg_input(T2_LEVEL, NRF_GPIO_PIN_PULLUP);	
 		nrf_gpio_cfg_input(STALL, NRF_GPIO_PIN_PULLUP);	 
		nrf_gpio_cfg_input(IMBA, NRF_GPIO_PIN_PULLUP);	
 		nrf_gpio_cfg_input(CORRECT, NRF_GPIO_PIN_PULLUP);	
		nrf_gpio_cfg_input(STOP, NRF_GPIO_PIN_PULLUP);
		nrf_gpio_cfg_input(BLE_KEY, NRF_GPIO_PIN_PULLUP);

		ResetBit = nrf_gpio_pin_read(M_RESET);
		StopBit = nrf_gpio_pin_read(STOP);	
}

void app_timer_tripcheck_handler()
{
	if(Tripbit == 1)
		{		
			RelayOnBitCount++;	
			if(RelayOnBitCount > 100)//100ms
			{
				RelayOnBitCount = 0;
				RelayOnBitFlag = 1;
			}
			
			if(RelayOnBitFlag == 1)
			{
				if(RelayOnBitCount <= VotageKeep)  //PWM控制继电器吸合
				{
					RelayOn;	
				}
				else
				{
					RelayOff;
				}
				
				if(RelayOnBitCount >= 5)
				{
					RelayOnBitCount = 0;
				}	
			}	
		}


}

//初始化APP定时器模块
static void timers_init(void)
{

    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
	
		err_code = app_timer_create(&Timer_Task_Trip, 
	                               APP_TIMER_MODE_REPEATED,
	                               app_timer_tripcheck_handler);
    APP_ERROR_CHECK(err_code);
	
    //加入创建用户定时任务的代码，创建用户定时任务。 

}

static void flash_init(void)
{
	ret_code_t rc;
	nrf_fstorage_api_t * p_fs_api;
	p_fs_api = &nrf_fstorage_sd;
//	rc = nrf_fstorage_init(&my_fs, p_fs_api, NULL);
	rc = nrf_fstorage_init(&my_fs_ble, p_fs_api, NULL);
  APP_ERROR_CHECK(rc);
	
	nrf5_flash_end_addr_get();
}

uint16_t			 Buffer[4]={10,100,100,0};
uint16_t			 Buffer1[3];
ret_code_t rc2;
static void flash_parameterread()
{

//	nrf_fstorage_read(&my_fs, FLASH_START_ADDR, &my_fs_info.read_data,6);	
	for(uint8_t i=0; i<3; i++)
	{
		Buffer1[i]= (my_fs_info.read_data[2*i+1]<<8) | my_fs_info.read_data[2*i];
	}
	if( (Buffer1[0]>700) || (Buffer1[1]>700) || (Buffer1[2]>700) )//Flash数据过大，则强制置数
	{
		Buffer1[0]=100;
		Buffer1[1]=100;
		Buffer1[2]=100;
	}
	
	CoeffA=(float)Buffer1[0]/100;
	CoeffB=(float)Buffer1[1]/100;
	CoeffC=(float)Buffer1[2]/100;
}




MODBUS_WRITE_DATA_TPDF modbus_write_buffer;
ret_code_t rc11;
extern void saadc_callback(nrfx_saadc_evt_t const * p_event); 

void wait_for_flash_ready(nrf_fstorage_t const * p_fstorage)
{
    /* While fstorage is busy, sleep and wait for an event. */
    while (nrf_fstorage_is_busy(p_fstorage))
    {
        power_manage();
    }
}
static uint16_t len =0;
int main(void)
{
	
	static uint16_t sendbufferlength;
	gpio_init();
//    bool erase_bonds;    
	log_init();
	timers_init();
    power_management_init();	
    ble_stack_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();
    NRF_LOG_INFO("Debug logging for UART over RTT started.");
    advertising_start();
	
	
	
	app_timer_start(Timer_Task_Trip, App_Timer_TripCheck_Interval, NULL);
	flash_init();
	flash_parameterread();
    // Enter main loop.

	
	
	
	memcpy(&modbus_write_buffer, (char*)FLASH_BLE_ADDR,sizeof(modbus_write_buffer));
	A_LEVEL_BLE = modbus_write_buffer.TripLevel;
	B_LEVEL_BLE = modbus_write_buffer.RatedCurrentLevel;
	T1_LEVEL_BLE = modbus_write_buffer.PhaseProtectOn_Off;
	T2_LEVEL_BLE = modbus_write_buffer.JamProtectOn_Off;
	STALL_BLE = modbus_write_buffer.StallProtectOn_Off;
	IMBA_BLE = modbus_write_buffer.ResetOn_Off;
	Grand_BLE = modbus_write_buffer.GrandProtectOn_Off;
		


			extern void test_adc(void);
	test_adc();

		while(1)
		{
		measureTask();
		
		if(ModbusFlag == 1)
		{
			ModbusFlag = 0;
			MODBUS_RTU_TaskFunction(NULL);	
			sendbufferlength=Modbus_SendBuffer.Length;
			ble_nus_data_send(&m_nus, Modbus_SendBuffer.Buff, &sendbufferlength, m_conn_handle);

//			
			if(ModbusWriteFlag == 1)
			{
				
				NRF_LOG_INFO("ModbusWriteFlag started.");
				
				ModbusWriteFlag = 0;
				
				memset(&modbus_write_buffer,0,sizeof(modbus_write_buffer));
				
				modbus_write_buffer.TripLevel = A_LEVEL_BLE;
				modbus_write_buffer.RatedCurrentLevel = B_LEVEL_BLE;
				modbus_write_buffer.PhaseProtectOn_Off = T1_LEVEL_BLE;
				modbus_write_buffer.JamProtectOn_Off = T2_LEVEL_BLE;
				modbus_write_buffer.StallProtectOn_Off = STALL_BLE;
				modbus_write_buffer.ResetOn_Off = IMBA_BLE;
				modbus_write_buffer.GrandProtectOn_Off = Grand_BLE;
				
				memcpy(&my_fs_info.write_data, &modbus_write_buffer, sizeof(modbus_write_buffer));
				my_fs_info.write_len = sizeof(modbus_write_buffer)*2;

											rc11=nrf_fstorage_erase(&my_fs_ble, FLASH_BLE_ADDR, 1, NULL);
						APP_ERROR_CHECK(rc11);
						wait_for_flash_ready(&my_fs_ble);

				rc11 = nrf_fstorage_write(&my_fs_ble, FLASH_BLE_ADDR + len, &my_fs_info.write_data, my_fs_info.write_len, NULL);
				APP_ERROR_CHECK(rc11);
				wait_for_flash_ready(&my_fs_ble);
				len += my_fs_info.write_len;
				


			}
		}
		
		

		idle_state_handle();
			
		}
	
}


/**
 * @}
 */
