自学教程：C++ APPL_LOG函数代码示例

/**@brief ICMP6 module event handler. * * @details Callback registered with the ICMP6 module to receive asynchronous events from *          the module, if the ICMP6_ENABLE_ALL_MESSAGES_TO_APPLICATION constant is not zero *          or the ICMP6_ENABLE_ND6_MESSAGES_TO_APPLICATION constant is not zero. */uint32_t icmp6_handler(iot_interface_t * p_interface,                       ipv6_header_t   * p_ip_header,                       icmp6_header_t  * p_icmp_header,                       uint32_t          process_result,                       iot_pbuffer_t   * p_rx_packet){    APPL_LOG("[APPL]: Got ICMP6 Application Handler Event on interface 0x%p/r/n", p_interface);    APPL_LOG("[APPL]: Source IPv6 Address: ");    APPL_ADDR(p_ip_header->srcaddr);    APPL_LOG("[APPL]: Destination IPv6 Address: ");    APPL_ADDR(p_ip_header->destaddr);    APPL_LOG("[APPL]: Process result = 0x%08lx/r/n", process_result);    switch (p_icmp_header->type)    {        case ICMP6_TYPE_ECHO_REPLY:            APPL_LOG("[APPL]: ICMP6 Message Type = Echo Reply/r/n");            if (m_app_state != APP_STATE_IDLE)            {                // Invert LED_FOUR.                LEDS_INVERT(LED_FOUR);            }            // Reset echo request retransmission number.            m_echo_req_retry_count = 0;            break;        default:            break;    }    return NRF_SUCCESS;}

/**@brief Function for application main entry. */int main(void){    // Initialize    app_trace_init();    leds_init();    timers_init();    buttons_init();    ipv6_transport_init();    ip_stack_init();    uint32_t err_code = coap_init(17);    APP_ERROR_CHECK(err_code);    coap_endpoints_init();    iot_timer_init();    APPL_LOG("/r/n");    APPL_LOG("[APPL]: Init complete./r/n");    // Start execution    advertising_start();    // Enter main loop    for (;;)    {        power_manage();    }}

/** * @brief Function for application main entry. */int main(void){    uint32_t err_code;    // Initialize.    app_trace_init();    leds_init();    timers_init();    gpiote_init();    err_code = ipv6_transport_init();    APP_ERROR_CHECK(err_code);    // Initialize IP Stack.    ip_stack_init();    APPL_LOG("/r/n");    APPL_LOG("[APPL]: Init complete./r/n");    // Start execution.    advertising_start();    // Enter main loop.    for (;;)    {        /* Sleep waiting for an application event. */        err_code = sd_app_evt_wait();        APP_ERROR_CHECK(err_code);    }}

/**@brief Function for application main entry. */int main(void){    uint32_t err_code;    bool erase_bonds;#ifdef ENABLE_DEBUG_LOG_SUPPORT    app_trace_init();#endif    APPL_LOG("START/r/n");    // Initialize.    timers_init();    buttons_leds_init(&erase_bonds);    adc_config();    ble_stack_init();    device_manager_init(erase_bonds);    gap_params_init();    advertising_init();    services_init();    conn_params_init();    // Start execution.    err_code = ble_advertising_start(BLE_ADV_MODE_FAST);    APP_ERROR_CHECK(err_code);    APPL_LOG("start advertising : %u/n", err_code);    // Enter main loop.    for (;;)    {        power_manage();    }}

/**@brief Function for handling the Application's BLE Stack events. * * @param[in] p_ble_evt  Bluetooth stack event. */static void on_ble_evt(ble_evt_t * p_ble_evt){    uint32_t err_code;    switch (p_ble_evt->header.evt_id)            {        case BLE_GAP_EVT_CONNECTED:            APPL_LOG("BLE_GAP_EVT_CONNECTED : %u/n", p_ble_evt->header.evt_id);            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 = app_timer_start(m_app_timer_id, APP_TIMER_ADC_INTERVAL, NULL);            //APP_ERROR_CHECK(err_code);            err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);            APP_ERROR_CHECK(err_code);            break;        case BLE_GAP_EVT_DISCONNECTED:            APPL_LOG("BLE_GAP_EVT_DISCONNECTED : %u/n", p_ble_evt->header.evt_id);            m_conn_handle = BLE_CONN_HANDLE_INVALID;            //nrf_adc_stop();            //app_timer_stop(m_app_timer_id);            break;        default:            // No implementation needed.            break;    }}

void app_mqtt_evt_handler(const mqtt_client_t * p_client, const mqtt_evt_t * p_evt){    uint32_t err_code;    switch(p_evt->id)    {        case MQTT_EVT_CONNECTED:        {            APPL_LOG ("[APPL]: >> MQTT_EVT_CONNECTED/r/n");            if(p_evt->result == MQTT_SUCCESS)            {                m_connection_state = true;                m_display_state = LEDS_CONNECTED_TO_BROKER;                err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL);                APP_ERROR_CHECK(err_code);            }            break;        }        case MQTT_EVT_DISCONNECTED:        {            APPL_LOG ("[APPL]: >> MQTT_EVT_DISCONNECTED/r/n");            m_connection_state = false;            m_display_state = LEDS_IPV6_IF_UP;            err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL);            APP_ERROR_CHECK(err_code);            break;        }        default:            break;    }}

static void ip_app_handler(iot_interface_t * p_interface, ipv6_event_t * p_event){    uint32_t    err_code;    ipv6_addr_t src_addr;    APPL_LOG("[APPL]: Got IP Application Handler Event on interface 0x%p/r/n", p_interface);    switch (p_event->event_id)    {        case IPV6_EVT_INTERFACE_ADD:#ifdef COMMISSIONING_ENABLED            commissioning_joining_mode_timer_ctrl(JOINING_MODE_TIMER_STOP_RESET);#endif // COMMISSIONING_ENABLED            APPL_LOG("[APPL]: New interface added!/r/n");            mp_interface = p_interface;            m_display_state = LEDS_IPV6_IF_UP;            APPL_LOG("[APPL]: Sending Router Solicitation to all routers!/r/n");            // Create Link Local addresses            IPV6_CREATE_LINK_LOCAL_FROM_EUI64(&src_addr, p_interface->local_addr.identifier);            // Delay first solicitation due to possible restriction on other side.            nrf_delay_ms(APP_RTR_SOLICITATION_DELAY);            // Send Router Solicitation to all routers.            err_code = icmp6_rs_send(p_interface,                                     &src_addr,                                     &m_local_routers_multicast_addr);            APP_ERROR_CHECK(err_code);        break;        case IPV6_EVT_INTERFACE_DELETE:#ifdef COMMISSIONING_ENABLED            commissioning_joining_mode_timer_ctrl(JOINING_MODE_TIMER_START);#endif // COMMISSIONING_ENABLED            APPL_LOG("[APPL]: Interface removed!/r/n");            mp_interface = NULL;            m_display_state = LEDS_IPV6_IF_DOWN;            // Stop application state machine timer.            m_app_state = APP_STATE_IDLE;            err_code = app_timer_stop(m_app_timer);            APP_ERROR_CHECK(err_code);            break;        case IPV6_EVT_INTERFACE_RX_DATA:            APPL_LOG("[APPL]: Got unsupported protocol data!/r/n");            break;        default:            // Unknown event. Should not happen.            break;    }}

/**@brief Function for handling button events. * * @param[in]   pin_no         The pin number of the button pressed. * @param[in]   button_action  The action performed on button. */static void button_event_handler(uint8_t pin_no, uint8_t button_action){    uint32_t err_code;#ifdef COMMISSIONING_ENABLED    if ((button_action == APP_BUTTON_PUSH) && (pin_no == ERASE_BUTTON_PIN_NO))    {        APPL_LOG("[APPL]: Erasing all commissioning settings from persistent storage... /r/n");        commissioning_settings_clear();        return;    }#endif // COMMISSIONING_ENABLED    // Check if interface is UP.    if(mp_interface == NULL)    {        return;    }    if (button_action == APP_BUTTON_PUSH)    {        switch (pin_no)        {            case START_BUTTON_PIN_NO:            {                APPL_LOG("[APPL]: Start button has been pushed./r/n");                // Change application state in case being in IDLE state.                if(m_app_state == APP_STATE_IDLE)                {                    m_app_state = APP_STATE_QUERYING;                    // Start application state machine timer.                    err_code = app_timer_start(m_app_timer, APP_STATE_INTERVAL, NULL);                    APP_ERROR_CHECK(err_code);                }                break;            }            case STOP_BUTTON_PIN_NO:            {                APPL_LOG("[APPL]: Stop button has been pushed./r/n");                LEDS_OFF((LED_THREE | LED_FOUR));                // Back to IDLE state.                m_app_state = APP_STATE_IDLE;                // Stop application state machine timer.                err_code = app_timer_stop(m_app_timer);                APP_ERROR_CHECK(err_code);                break;            }            default:              break;        }    }}

/**@brief Function for application main entry. */int main(void){    uint32_t err_code;    // Initialize    app_trace_init();    leds_init();#ifdef COMMISSIONING_ENABLED    err_code = pstorage_init();    APP_ERROR_CHECK(err_code);#endif // COMMISSIONING_ENABLED    timers_init();    buttons_init();    static ipv6_medium_init_params_t ipv6_medium_init_params;    memset(&ipv6_medium_init_params, 0x00, sizeof(ipv6_medium_init_params));    ipv6_medium_init_params.ipv6_medium_evt_handler    = on_ipv6_medium_evt;    ipv6_medium_init_params.ipv6_medium_error_handler  = on_ipv6_medium_error;    ipv6_medium_init_params.use_scheduler              = false;#ifdef COMMISSIONING_ENABLED    ipv6_medium_init_params.commissioning_id_mode_cb   = commissioning_id_mode_cb;    ipv6_medium_init_params.commissioning_power_off_cb = commissioning_power_off_cb;#endif // COMMISSIONING_ENABLED    err_code = ipv6_medium_init(&ipv6_medium_init_params, /                                IPV6_MEDIUM_ID_BLE,       /                                &m_ipv6_medium);    APP_ERROR_CHECK(err_code);    eui48_t ipv6_medium_eui48;    err_code = ipv6_medium_eui48_get(m_ipv6_medium.ipv6_medium_instance_id, /                                     &ipv6_medium_eui48);    ipv6_medium_eui48.identifier[EUI_48_SIZE - 1] = 0x00;    err_code = ipv6_medium_eui48_set(m_ipv6_medium.ipv6_medium_instance_id, /                                     &ipv6_medium_eui48);    APP_ERROR_CHECK(err_code);    ip_stack_init();    ip_stack_timer_init();    dns_client_init();    APPL_LOG("/r/n");    APPL_LOG("[APPL]: Init complete./r/n");    // Start execution    connectable_mode_enter();    // Enter main loop    for (;;)    {        power_manage();    }}

/**@brief IP stack event handler. * * @details Callback registered with the ICMP6 to receive asynchronous events from the module. */void ip_app_handler(iot_interface_t * p_interface, ipv6_event_t * p_event){    uint32_t err_code;    APPL_LOG("[APPL]: Got IP Application Handler Event on interface 0x%p/r/n", p_interface);    switch(p_event->event_id)    {        case IPV6_EVT_INTERFACE_ADD:            APPL_LOG("[APPL]: New interface added!/r/n");            err_code = udp6_socket_allocate(&m_udp_socket);            APP_ERROR_CHECK(err_code);            err_code = udp6_socket_bind(&m_udp_socket, IPV6_ADDR_ANY, HTONS(UDP_PORT));            APP_ERROR_CHECK(err_code);            err_code = udp6_socket_recv(&m_udp_socket, rx_udp_port_app_handler);            APP_ERROR_CHECK(err_code);            memset(&m_packet_buffer[0][0], 0x00, sizeof(m_packet_buffer));            m_node_state    = APP_STATE_IPV6_IF_UP;            m_display_state = LEDS_TX_ECHO_REQUEST;            // IPv6 interface is up, start sending Echo Requests to peer.            err_code = app_timer_start(m_tx_node_timer, APP_PING_INTERVAL, NULL);            APP_ERROR_CHECK(err_code);            break;        case IPV6_EVT_INTERFACE_DELETE:            err_code = app_timer_stop(m_tx_node_timer);            APP_ERROR_CHECK(err_code);            APPL_LOG("[APPL]: Interface removed!/r/n");            err_code = udp6_socket_free(&m_udp_socket);            APP_ERROR_CHECK(err_code);            memset(&m_packet_buffer[0][0], 0x00, sizeof(m_packet_buffer));            m_node_state    = APP_STATE_IPV6_IF_DOWN;            m_display_state = LEDS_IPV6_IF_DOWN;            break;        case IPV6_EVT_INTERFACE_RX_DATA:            APPL_LOG("[APPL]: Got unsupported protocol data!/r/n");            break;        default:            //Unknown event. Should not happen.            break;    }}

/**@brief Battery level Collector Handler. **************************************** */static void bas_c_evt_handler(ble_bas_c_t * p_bas_c, ble_bas_c_evt_t * p_bas_c_evt){    uint32_t err_code;    switch (p_bas_c_evt->evt_type)    {        case BLE_BAS_C_EVT_DISCOVERY_COMPLETE:            // Battery service discovered. Enable notification of Battery Level.            APPL_LOG("[APPL]: Battery Service discovered. /r/n");            APPL_LOG("[APPL]: Reading battery level. /r/n");            err_code = ble_bas_c_bl_read(p_bas_c);            APP_ERROR_CHECK(err_code);            APPL_LOG("[APPL]: Enabling Battery Level Notification. /r/n");            err_code = ble_bas_c_bl_notif_enable(p_bas_c);            APP_ERROR_CHECK(err_code);            printf("Battery service discovered /r/n");            break;        case BLE_BAS_C_EVT_BATT_NOTIFICATION:        {            APPL_LOG("[APPL]: Battery Level received %d %%/r/n", p_bas_c_evt->params.battery_level);	    	    uint8_t batteryLevel = p_bas_c_evt->params.battery_level;	    // Normalize the battery level	    //if(batteryLevel > 100) batteryLevel = 100;	    batteryLevel = batteryLevel < 100 ? batteryLevel : 100;            printf("batteryLevel = %d %%/r/n", batteryLevel);	    while(app_pwm_channel_duty_set(&PWM1, 0, batteryLevel) == NRF_ERROR_BUSY)            printf("Battery = %d %%/r/n", batteryLevel);            break;        }        case BLE_BAS_C_EVT_BATT_READ_RESP:        {            APPL_LOG("[APPL]: Battery Level Read as %d %%/r/n", p_bas_c_evt->params.battery_level);            //printf("Battery Read As = %d %%/r/n", p_bas_c_evt->params.battery_level);            break;        }        default:            break;    }}

/**@brief Function for handling the Application's BLE Stack events. * * @param[in]   p_ble_evt   Bluetooth stack event. */static void on_ble_evt(ble_evt_t * p_ble_evt){    switch (p_ble_evt->header.evt_id)    {        case BLE_GAP_EVT_CONNECTED:            APPL_LOG ("[APPL]: Connected./r/n");            break;        case BLE_GAP_EVT_DISCONNECTED:            APPL_LOG ("[APPL]: Disconnected./r/n");            advertising_start();            break;        default:            break;    }}

/**@brief Publishes LED state to MQTT broker. * * @param[in]   led_state   LED state being published. */static void app_mqtt_publish(bool led_state){    mqtt_topic_t topic;    mqtt_data_t  data;    char topic_desc[] = "led/state";    topic.p_topic = (uint8_t *)topic_desc;    topic.topic_len = strlen(topic_desc);    data.data_len = 1;    data.p_data = (uint8_t *)&led_state;    uint32_t err_code = mqtt_publish(&m_app_mqtt_id,&topic, &data);    APPL_LOG("[APPL]: mqtt_publish result 0x%08lx/r/n", err_code);    if (err_code == MQTT_SUCCESS)    {        LEDS_INVERT(LED_FOUR);        m_led_state = !m_led_state;    }    else    {        // Flash LED_THREE if error occurs.        LEDS_ON(LED_THREE);        err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL);        APP_ERROR_CHECK(err_code);    }}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. */static void ble_stack_init(void){    uint32_t err_code;    // Initialize the SoftDevice handler module.    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC, NULL);#if defined(S110) || defined(S130)    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));#ifdef S130    //ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_MIN;    //これだと自分のATTが出てこなかった    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_MIN;    //これだと自分のATTが出てこなかった    ble_enable_params.gap_enable_params.periph_conn_count = 1;#endif    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;#ifdef S130    uint32_t app_ram_base = (uint32_t)m_ble_buf;    err_code = sd_ble_enable(&ble_enable_params, &app_ram_base);    APPL_LOG("app_ram_base : %x/n", app_ram_base);#else    err_code = sd_ble_enable(&ble_enable_params);#endif    APP_ERROR_CHECK(err_code);#endif    // Register with the SoftDevice handler module for BLE events.    err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);    APP_ERROR_CHECK(err_code);    // Register with the SoftDevice handler module for BLE events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

/**@brief Function for sending the configuration. */uint32_t ble_agsensor_configuration_send(ble_agsensor_t * p_agsensor, ble_agsensor_configuration_t * p_configuration){    uint32_t err_code = NRF_SUCCESS;    if (p_agsensor->conn_handle != BLE_CONN_HANDLE_INVALID)    {        ble_gatts_hvx_params_t hvx_params;        uint8_t encoded_value[MAX_CONFIGURATION_LEN];        uint16_t hvx_len;        // Initialize value struct.        memset(&hvx_params, 0, sizeof(hvx_params));        hvx_len           = configuration_encode(p_configuration, encoded_value);        hvx_params.handle = p_agsensor->configuration_handles.value_handle;        hvx_params.type   = BLE_GATT_HVX_INDICATION;        hvx_params.p_len  = &hvx_len;        hvx_params.offset = 0;        hvx_params.p_data = encoded_value;        err_code = sd_ble_gatts_hvx(p_agsensor->conn_handle, &hvx_params);		APPL_LOG("ble_agsensor_configuration_send %d %d/r/n", (int)err_code, p_agsensor->conn_handle);//		APPL_LOG("ble_agsensor_configuration_send %d %d %d %d/r/n", hvx_params.handle, hvx_params.type, (int)*hvx_params.p_len, hvx_params.offset);    }    else    {        err_code = NRF_ERROR_INVALID_STATE;    }    return err_code;}

/**@brief Function for application main entry. */int main(void){    uint32_t err_code;    bool erase_bonds;    app_trace_init();    // Initialize.    timers_init();    buttons_leds_init(&erase_bonds);    ble_stack_init();    device_manager_init(erase_bonds);    gap_params_init();    advertising_init();    services_init();    conn_params_init();    // Start execution.    application_timers_start();    APPL_LOG("Start Advertising /r/n");    printf("Dhavaltest/r/n");    SEGGER_RTT_WriteString(0, "SEGGER Real-Time-Terminal Sample/r/n");    err_code = ble_advertising_start(BLE_ADV_MODE_FAST);    APP_ERROR_CHECK(err_code);    // Enter main loop.    for (;;)    {        power_manage();    }}

uint32_t ser_sd_transport_cmd_write(const uint8_t *                p_buffer,                                    uint16_t                       length,                                    ser_sd_transport_rsp_handler_t cmd_rsp_decode_callback){    uint32_t err_code = NRF_SUCCESS;    m_rsp_wait        = true;    m_rsp_dec_handler = cmd_rsp_decode_callback;    err_code          = ser_hal_transport_tx_pkt_send(p_buffer, length);    APP_ERROR_CHECK(err_code);    /* Execute callback for response decoding only if one was provided.*/    if ((err_code == NRF_SUCCESS) && cmd_rsp_decode_callback)    {        if (m_ot_rsp_wait_handler)        {            m_ot_rsp_wait_handler();            m_ot_rsp_wait_handler = NULL;        }        m_os_rsp_wait_handler();        err_code = m_return_value;    }    else    {        m_rsp_wait = false;    }    APPL_LOG("/r/n[SD_CALL_ID]: 0x%X, err_code= 0x%X/r/n", p_buffer[1], err_code);    return err_code;}

static void coap_response_handler(uint32_t status, void * arg, coap_message_t * p_response){    if (status == NRF_SUCCESS)    {        if (coap_message_opt_present(p_response, COAP_OPT_OBSERVE) == NRF_SUCCESS)        {            // It is an notification or result of a GET response            LEDS_ON(LED_FOUR);        }        else        {            LEDS_OFF(LED_FOUR);        }        APPL_LOG("[APPL]: Response Code : %d/r/n", p_response->header.code);        if (p_response->header.code == COAP_CODE_205_CONTENT)        {            switch (p_response->p_payload[0])            {                case STATUS_ON:                    LEDS_ON(LED_THREE);                    break;                case STATUS_OFF:                    LEDS_OFF(LED_THREE);                    break;                default:                    break;            }        }    }}

static uint32_t ble_agsensor_update_config (ble_agsensor_t * p_agsensor) {    uint32_t err_code = NRF_SUCCESS;	static ble_gatts_hvx_params_t hvx_params;	if (isConfigSendWaiting) {//		APPL_LOG("isConfigSendWaiting %d/r/n", (int)err_code, p_agsensor->conn_handle);	    hvx_params.handle = p_agsensor->configuration_handles.value_handle;	    hvx_params.type   = BLE_GATT_HVX_INDICATION;	    hvx_params.p_len  = &hvx_p_config_len;	    hvx_params.offset = 0;	    hvx_params.p_data = hvx_encoded_buffer;		err_code = sd_ble_gatts_hvx(p_agsensor->conn_handle, &hvx_params);		isConfigSendWaiting = (!(err_code == NRF_SUCCESS));		// TODO: this part does not work as it does not confirm that msg been sent		if (err_code == NRF_ERROR_BUSY) {			if (*(hvx_params.p_len) == hvx_p_config_len) {				isConfigSendWaiting = false;			}		}		APPL_LOG("ble_agsensor_update_config %d %d/r/n", (int)err_code, p_agsensor->conn_handle);//		APPL_LOG("ble_agsensor_update_config %d %d %d %d/r/n", hvx_params.handle, hvx_params.type, (int)*hvx_params.p_len, hvx_params.offset);//		APPL_LOG("ble_agsensor_update_config %d /r/n", (int)(*hvx_params.p_len));	}	return err_code;}

/**@brief Send test data on the port. *  * @details Sends TCP data in Request of size 8 in format described in description above. * * @param[in]   p_pcb     PCB identifier of the port. */static void tcp_send_data(struct tcp_pcb * p_pcb, uint32_t sequence_number){    err_t  err = ERR_OK;    if (m_tcp_state != TCP_STATE_DATA_TX_IN_PROGRESS)    {        //Register callback to get notification of data reception is complete.        tcp_sent(p_pcb, tcp_write_complete);        uint8_t tcp_data[TCP_DATA_SIZE];        tcp_data[0] = (uint8_t )((sequence_number >> 24) & 0x000000FF);        tcp_data[1] = (uint8_t )((sequence_number >> 16) & 0x000000FF);        tcp_data[2] = (uint8_t )((sequence_number >> 8)  & 0x000000FF);        tcp_data[3] = (uint8_t )(sequence_number         & 0x000000FF);        tcp_data[4] = 'P';        tcp_data[5] = 'o';        tcp_data[6] = 'n';        tcp_data[7] = 'g';        //Enqueue data for transmission.        err = tcp_write(p_pcb, tcp_data, TCP_DATA_SIZE, 1);        if (err != ERR_OK)        {            APPL_LOG ("[APPL]: Failed to send TCP packet, reason %d/r/n", err);        }        else        {            m_tcp_state = TCP_STATE_DATA_TX_IN_PROGRESS;        }    }

void commissioning_power_off_cb(bool power_off_on_failure){    m_power_off_on_failure = power_off_on_failure;    APPL_LOG("[APPL]: Commissioning: do power_off on failure: %s./r/n", /             m_power_off_on_failure ? "true" : "false");}

/**@brief Heart Rate Collector Handler. */static void hrs_c_evt_handler(ble_hrs_c_t * p_hrs_c, ble_hrs_c_evt_t * p_hrs_c_evt){    uint32_t err_code;    switch (p_hrs_c_evt->evt_type)    {        case BLE_HRS_C_EVT_DISCOVERY_COMPLETE:            // Initiate bonding.            err_code = dm_security_setup_req(&m_dm_device_handle);            APP_ERROR_CHECK(err_code);            // Heart rate service discovered. Enable notification of Heart Rate Measurement.            err_code = ble_hrs_c_hrm_notif_enable(p_hrs_c);            APP_ERROR_CHECK(err_code);            printf("Heart rate service discovered /r/n");            break;        case BLE_HRS_C_EVT_HRM_NOTIFICATION:        {            APPL_LOG("[APPL]: HR Measurement received %d /r/n", p_hrs_c_evt->params.hrm.hr_value);            printf("Heart Rate = %d/r/n", p_hrs_c_evt->params.hrm.hr_value);            break;        }        default:            break;    }}

/**@brief Function for error handling, which is called when an error has occurred. * * @warning This handler is an example only and does not fit a final product. You need to analyze *          how your product is supposed to react in case of error. * * @param[in] error_code  Error code supplied to the handler. * @param[in] line_num    Line number where the handler is called. * @param[in] p_file_name Pointer to the file name. */void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name){    LEDS_ON((LED_ONE | LED_TWO | LED_THREE | LED_FOUR));    APPL_LOG("[** ASSERT **]: Error 0x%08lX, Line %ld, File %s/r/n", error_code, line_num, p_file_name);    // Variables used to retain function parameter values when debugging.    static volatile uint8_t  s_file_name[MAX_LENGTH_FILENAME];    static volatile uint16_t s_line_num;    static volatile uint32_t s_error_code;    strncpy((char *)s_file_name, (const char *)p_file_name, MAX_LENGTH_FILENAME - 1);    s_file_name[MAX_LENGTH_FILENAME - 1] = '/0';    s_line_num                           = line_num;    s_error_code                         = error_code;    UNUSED_VARIABLE(s_file_name);    UNUSED_VARIABLE(s_line_num);    UNUSED_VARIABLE(s_error_code);    // This call can be used for debug purposes during application development.    // @note CAUTION: Activating this code will write the stack to flash on an error.    //                This function should NOT be used in a final product.    //                It is intended STRICTLY for development/debugging purposes.    //                The flash write will happen EVEN if the radio is active, thus interrupting    //                any communication.    //                Use with care. Un-comment the line below to use.    // ble_debug_assert_handler(error_code, line_num, p_file_name);    // On assert, the system can only recover on reset.    //NVIC_SystemReset();    for(;;)    {        // Infinite loop.    }}

/**@brief Function for handling the advertising report BLE event. * * @param[in] p_ble_evt  Bluetooth stack event. */static void on_adv_report(const ble_evt_t * const p_ble_evt){    uint32_t      err_code;    uint8_array_t adv_data;    uint8_array_t dev_name;    bool          do_connect = false;    // For readibility.    const ble_gap_evt_t * const p_gap_evt    = &p_ble_evt->evt.gap_evt;    const ble_gap_addr_t  * const peer_addr  = &p_gap_evt->params.adv_report.peer_addr;    // Initialize advertisement report for parsing    adv_data.p_data = (uint8_t *)p_gap_evt->params.adv_report.data;    adv_data.size   = p_gap_evt->params.adv_report.dlen;    //search for advertising names    bool found_name = false;    err_code = adv_report_parse(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME,                                &adv_data,                                &dev_name);    if (err_code != NRF_SUCCESS)    {        // Look for the short local name if it was not found as complete        err_code = adv_report_parse(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME, &adv_data, &dev_name);        if (err_code != NRF_SUCCESS)        {            // If we can't parse the data, then exit            return;        }        else        {            found_name = true;        }    }    else    {        found_name = true;    }    if (found_name)    {        if (strlen(m_target_periph_name) != 0)        {            if(memcmp(m_target_periph_name, dev_name.p_data, dev_name.size) == 0)            {                do_connect = true;            }        }    }    if (do_connect)    {        // Initiate connection.        err_code = sd_ble_gap_connect(peer_addr, &m_scan_param, &m_connection_param);        if (err_code != NRF_SUCCESS)        {            APPL_LOG("[APPL]: Connection Request Failed, reason %d/r/n", err_code);        }    }}

/**@brief Function for starting connectable mode. */static void connectable_mode_enter(void){    uint32_t err_code = ipv6_medium_connectable_mode_enter(m_ipv6_medium.ipv6_medium_instance_id);    APP_ERROR_CHECK(err_code);    APPL_LOG("[APPL]: Physical layer in connectable mode./r/n");    m_display_state = LEDS_CONNECTABLE_MODE;}

/**@brief Function to handle interface up event. */void nrf51_driver_interface_up(void){    APPL_LOG ("[APPL]: IPv6 interface up./r/n");    sys_check_timeouts();    m_display_state = LEDS_IPV6_IF_UP;}

/**@brief Function for starting connectable mode. */static void connectable_mode_enter(void){    uint32_t err_code = ipv6_medium_connectable_mode_enter(m_ipv6_medium.ipv6_medium_instance_id);    APP_ERROR_CHECK(err_code);    APPL_LOG("[APPL]: Physical layer in connectable mode./r/n");    LEDS_OFF(LED_TWO);    LEDS_ON(LED_ONE);}

/**@brief Function to handle interface down event. */void nrf_driver_interface_down(void){       APPL_LOG ("[APPL]: IPv6 interface down./r/n");#ifdef COMMISSIONING_ENABLED    commissioning_joining_mode_timer_ctrl(JOINING_MODE_TIMER_START);#endif // COMMISSIONING_ENABLED        m_display_state = LEDS_IPV6_IF_DOWN;}

/**@brief Function to handle interface up event. */void nrf51_driver_interface_up(void){    APPL_LOG ("[APPL]: IPv6 Interface Up./r/n");    sys_check_timeouts();    // Set flag indicating interface state.    m_interface_state = true;    m_display_state = LEDS_IPV6_IF_UP;}

/**@brief Function for handling the Application's BLE Stack events. * * @param[in]   p_ble_evt   Bluetooth stack event. */static void on_ble_evt(ble_evt_t * p_ble_evt){    switch (p_ble_evt->header.evt_id)    {        case BLE_GAP_EVT_CONNECTED:            APPL_LOG ("[APPL]: Connected./r/n");            m_display_state = LEDS_IPV6_IF_DOWN;            break;        case BLE_GAP_EVT_DISCONNECTED:            APPL_LOG ("[APPL]: Disconnected./r/n");            m_display_state = LEDS_INACTIVE;            advertising_start();            break;        default:            break;    }}