/* Copyright (c) 2010 - 2020, 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. */ #include #include /* HAL */ #include "boards.h" #include "simple_hal.h" #include "app_timer.h" /* Core */ #include "nrf_mesh_config_core.h" #include "nrf_mesh_gatt.h" #include "nrf_mesh_configure.h" #include "nrf_mesh.h" #include "mesh_stack.h" #include "device_state_manager.h" #include "access_config.h" /* Provisioning and configuration */ #include "mesh_provisionee.h" #include "mesh_app_utils.h" /* Models */ #include "generic_onoff_client.h" /* Logging and RTT */ #include "log.h" #include "rtt_input.h" /* Example specific includes */ #include "app_config.h" #include "nrf_mesh_config_examples.h" #include "light_switch_example_common.h" #include "example_common.h" #include "ble_softdevice_support.h" /* Custom added includes */ #include "mesh_opt_core.h" /***************************************************************************** * Definitions *****************************************************************************/ #define APP_STATE_OFF (0) #define APP_STATE_ON (1) #define APP_FORCE_SEGMENTATION (false) #define APP_MIC_SIZE (NRF_MESH_TRANSMIC_SIZE_SMALL) /***************************************************************************** * Forward declaration of static functions *****************************************************************************/ /***************************************************************************** * Static variables *****************************************************************************/ static bool m_device_provisioned; static access_model_handle_t msg_model_handle; static uint8_t data[] = {0x12}; /***************************************************************************** Model definitions/callbacks *****************************************************************************/ static void msg_client_reply_cb(access_model_handle_t handle, const access_message_rx_t * p_rx_msg, void * p_args) { __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reply recieved [Handle:%04X] \n[Data: %02X, TTL:%02X] \n", handle, p_rx_msg->p_data[0], p_rx_msg->meta_data.ttl); } static void reliable_status_cb(access_model_handle_t model_handle, void * p_args, access_reliable_status_t status) { switch (status) { case ACCESS_RELIABLE_TRANSFER_SUCCESS: __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reliable transfer success.\n"); break; case ACCESS_RELIABLE_TRANSFER_TIMEOUT: __LOG(LOG_SRC_APP, LOG_LEVEL_WARN, "Reliable reply timed out\n"); break; case ACCESS_RELIABLE_TRANSFER_CANCELLED: __LOG(LOG_SRC_APP, LOG_LEVEL_WARN, "Reliable transfer cancelled\n"); break; default: /* Should not be possible. */ NRF_MESH_ASSERT(false); break; } } static const access_opcode_handler_t m_opcode_handlers[] = { {ACCESS_OPCODE_VENDOR(0xC3, 0xF001), msg_client_reply_cb} }; static void models_init_cb(void) { __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n"); access_model_add_params_t init_params = { .model_id = ACCESS_MODEL_VENDOR(0xC001, 0xF001), .element_index = 0, .p_opcode_handlers = &m_opcode_handlers[0], .opcode_count = ARRAY_SIZE(m_opcode_handlers), .p_args = NULL, .publish_timeout_cb = NULL }; ERROR_CHECK(access_model_add(&init_params, &msg_model_handle)); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Model Handle is %04X\n", msg_model_handle); } /***************************************************************************** general application functions *****************************************************************************/ static void send_reliable_message(access_model_handle_t handle, const uint8_t * p_data, uint16_t length) { const access_message_tx_t msg = { .opcode = ACCESS_OPCODE_VENDOR(0xC2, 0xF001), // Build the normal Message, with the Opcode that the Receiver should execute .p_buffer = p_data, .length = length, .force_segmented = false, .transmic_size = NRF_MESH_TRANSMIC_SIZE_SMALL, .access_token = nrf_mesh_unique_token_get() }; access_reliable_t reliable_msg = { .model_handle = handle, .message = msg, .reply_opcode = ACCESS_OPCODE_VENDOR(0xC3, 0xF001), .timeout = SEC_TO_US(5), .status_cb = reliable_status_cb }; if(access_reliable_model_is_free(handle)) { NRF_MESH_ERROR_CHECK(access_model_reliable_publish(&reliable_msg)); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reliable message sent: %02X\n", reliable_msg.message.p_buffer[0]); } } static void send_message(access_model_handle_t handle, const uint8_t * p_data, uint16_t length) { const access_message_tx_t msg = { .opcode = ACCESS_OPCODE_VENDOR(0xC4, 0xF001), // Build the normal Message, with the Opcode that the Receiver should execute .p_buffer = p_data, .length = length, .force_segmented = false, .transmic_size = NRF_MESH_TRANSMIC_SIZE_SMALL, .access_token = nrf_mesh_unique_token_get() }; NRF_MESH_ERROR_CHECK(access_model_publish(handle, &msg)); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Message sent: %02X\n", msg.p_buffer[0]); } static void node_reset(void) { __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Node reset -----\n"); hal_led_blink_ms(HAL_LED_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_RESET); /* This function may return if there are ongoing flash operations. */ mesh_stack_device_reset(); } static void config_server_evt_cb(const config_server_evt_t * p_evt) { if (p_evt->type == CONFIG_SERVER_EVT_NODE_RESET) { node_reset(); } } #if NRF_MESH_LOG_ENABLE static const char m_usage_string[] = "\n" "\t\t------------------------------------------------------------------------------------\n" "\t\t Button/RTT 1) Send a custom reliable message\n" "\t\t Button/RTT 2) Send a custom message\n" "\t\t Button/RTT 3)-\n" "\t\t Button/RTT 4) Reset node\n" "\t\t------------------------------------------------------------------------------------\n"; #endif static void button_event_handler(uint32_t button_number) { /* Increase button number because the buttons on the board is marked with 1 to 4 */ button_number++; __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Button %u pressed\n", button_number); switch (button_number) { case 1: send_reliable_message(msg_model_handle, &data[0], ARRAY_SIZE(data)); break; case 2: send_message(msg_model_handle, &data[0], ARRAY_SIZE(data)); break; case 3: break; case 4: node_reset(); break; default: __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, m_usage_string); break; } } static void rtt_input_handler(int key) { if (key >= '1' && key <= '4') { uint32_t button_number = key - '1'; button_event_handler(button_number); } else { __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, m_usage_string); } } static void device_identification_start_cb(uint8_t attention_duration_s) { hal_led_mask_set(HAL_LED_MASK, false); hal_led_blink_ms(HAL_LED_MASK_HALF, LED_BLINK_ATTENTION_INTERVAL_MS, LED_BLINK_ATTENTION_COUNT(attention_duration_s)); } static void provisioning_aborted_cb(void) { hal_led_blink_stop(); } static void unicast_address_print(void) { dsm_local_unicast_address_t node_address; dsm_local_unicast_addresses_get(&node_address); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Node Address: 0x%04x \n", node_address.address_start); } static void provisioning_complete_cb(void) { __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Successfully provisioned\n"); #if MESH_FEATURE_GATT_ENABLED /* Restores the application parameters after switching from the Provisioning * service to the Proxy */ gap_params_init(); conn_params_init(); #endif unicast_address_print(); hal_led_blink_stop(); hal_led_mask_set(HAL_LED_MASK, LED_MASK_STATE_OFF); hal_led_blink_ms(HAL_LED_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_PROV); } /***************************************************************************** Initialization *****************************************************************************/ static void mesh_init(void) { mesh_stack_init_params_t init_params = { .core.irq_priority = NRF_MESH_IRQ_PRIORITY_LOWEST, .core.lfclksrc = DEV_BOARD_LF_CLK_CFG, .core.p_uuid = NULL, .models.models_init_cb = models_init_cb, .models.config_server_cb = config_server_evt_cb }; uint32_t status = mesh_stack_init(&init_params, &m_device_provisioned); switch (status) { case NRF_ERROR_INVALID_DATA: __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Data in the persistent memory was corrupted. Device starts as unprovisioned.\n"); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reboot device before starting of the provisioning process.\n"); break; case NRF_SUCCESS: break; default: ERROR_CHECK(status); } } static void initialize(void) { __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS | LOG_SRC_BEARER, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BLE Mesh Light Switch Client Demo -----\n"); ERROR_CHECK(app_timer_init()); hal_leds_init(); #if BUTTON_BOARD ERROR_CHECK(hal_buttons_init(button_event_handler)); #endif ble_stack_init(); #if MESH_FEATURE_GATT_ENABLED gap_params_init(); conn_params_init(); #endif mesh_init(); } static void start(void) { rtt_input_enable(rtt_input_handler, RTT_INPUT_POLL_PERIOD_MS); if (!m_device_provisioned) { static const uint8_t static_auth_data[NRF_MESH_KEY_SIZE] = STATIC_AUTH_DATA; mesh_provisionee_start_params_t prov_start_params = { .p_static_data = static_auth_data, .prov_sd_ble_opt_set_cb = NULL, .prov_complete_cb = provisioning_complete_cb, .prov_device_identification_start_cb = device_identification_start_cb, .prov_device_identification_stop_cb = NULL, .prov_abort_cb = provisioning_aborted_cb, .p_device_uri = EX_URI_LS_CLIENT }; ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params)); } else { unicast_address_print(); } mesh_app_uuid_print(nrf_mesh_configure_device_uuid_get()); ERROR_CHECK(mesh_stack_start()); __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, m_usage_string); hal_led_mask_set(HAL_LED_MASK, LED_MASK_STATE_OFF); hal_led_blink_ms(HAL_LED_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_START); } //----------------------------------- Main -------------------------------------------- int main(void) { initialize(); start(); __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS | LOG_SRC_BEARER, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT); for (;;) { (void)sd_app_evt_wait(); } }