MESH DFU PROBLEM

RE: MESH DFU PROBLEM

SAIF — Tue, 14 May 2019 04:04:58 GMT

Hi,

Thanks for ur reply.

Yeah,Above mentioned DFU process is working fine.i.e,by uploading Softdevice,Bootloader and dfu_package file related to my application of LIGHT_SWITCH_SERVER code,it is entering into DFU_TARGET mode and i can able to upload my DFU_PACKAGE file as many time as i want and for one to one device only.

Yes,i have tried flashing the example before the mesh dfu process and in that case the buttons doesn't work.

But,as of now my application with DFU seems to work with LIGHT_SWITCH_SERVER code only.

So,i have not gone with MESH DFU code provided in the MESH SDK.

RE: MESH DFU PROBLEM

Bjørn Kvaale — Fri, 10 May 2019 11:31:47 GMT

Are you sure that the mesh DFU updated successfully? Do you have any logging information you could provide for the mesh dfu? It seems that you initialize the button_event_handler correctly. Have you tried running flashing the example before you try the mesh DFU process? Do the buttons then work as intended?

RE: MESH DFU PROBLEM

SAIF — Mon, 06 May 2019 07:21:43 GMT

Thanks for your reply.!!

Right now i am not going with mesh dfu process and it takes nearly about 1 hour and it is also one to many devices dfu process.

As i want only one to one device dfu process in MESH . So what i have done is i have implemented the dfu process related to BLE stack in the normal LIGHT SWITCH SERVER code and done with one to one device dfu process and it is working fine.

i.e., by uploading softdevice ,bootloader hex files and application dfu package file.

By this i solved my button handler issue,but still i am sending you the main code so that i can know what is the reason for button handler not working in MESH DFU code.

#include <stdint.h>
#include <string.h>

/* HAL */
#include "boards.h"
#include "simple_hal.h"
#include "app_timer.h"

/* Core */
#include "nrf_mesh_config_core.h"
#include "nrf_mesh_configure.h"
#include "nrf_mesh.h"
#include "mesh_stack.h"
#include "device_state_manager.h"
#include "access_config.h"
#include "proxy.h"
#include "nrf_mesh_events.h"
#include "nrf_mesh_dfu.h"

/* Provisioning and configuration */
#include "mesh_provisionee.h"
#include "mesh_app_utils.h"
#include "mesh_adv.h"

/* Logging and RTT */
#include "log.h"
#include "rtt_input.h"

/* Example specific includes */
#include "app_config.h"
#include "example_common.h"
#include "light_switch_example_common.h"
#include "nrf_mesh_config_examples.h"
#include "ble_softdevice_support.h"
#include "nrf_drv_gpiote.h"

#ifndef NRF_MESH_SERIAL_ENABLE
#define NRF_MESH_SERIAL_ENABLE 1
#endif

#if NRF_MESH_SERIAL_ENABLE
#include "nrf_mesh_serial.h"
#endif


#if defined(NRF51) && defined(NRF_MESH_STACK_DEPTH)
#include "stack_depth.h"
#endif


#define STATIC_AUTH_DATA {0x6E, 0x6F, 0x72, 0x64, 0x69, 0x63, 0x5F, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x5F, 0x31}

#if defined(NRF51)
    #define FLASH_PAGE_SIZE                 ( 0x400)
    #define FLASH_PAGE_MASK             (0xFFFFFC00)
#elif defined(NRF52_SERIES)
    #define FLASH_PAGE_SIZE                 (0x1000)
    #define FLASH_PAGE_MASK             (0xFFFFF000)
#endif

#if defined(_lint)
    const volatile uint32_t * rom_base   = NULL;
    const volatile uint32_t * rom_length = NULL;
    uint32_t rom_end;
    uint32_t bank_addr;
#elif defined ( __CC_ARM )
    extern uint32_t Image$$ER_IROM1$$Base;
    extern uint32_t Image$$ER_IROM1$$Length;
    const volatile uint32_t * rom_base   = &Image$$ER_IROM1$$Base;
    const volatile uint32_t * rom_length = &Image$$ER_IROM1$$Length;
    uint32_t rom_end;
    uint32_t bank_addr;
#elif defined   ( __GNUC__ )
    extern uint32_t _start;
    extern uint32_t __exidx_end;
    const volatile uint32_t rom_base   = (uint32_t) &_start;
    const volatile uint32_t rom_end    = (uint32_t) &__exidx_end;
    uint32_t rom_length;
    uint32_t bank_addr;
#endif

static nrf_mesh_evt_handler_t m_evt_handler;
static bool m_device_provisioned;


static bool fw_updated_event_is_for_me(const nrf_mesh_evt_dfu_t * p_evt)
{
    switch (p_evt->fw_outdated.transfer.dfu_type)
    {
        case NRF_MESH_DFU_TYPE_APPLICATION:
            return (p_evt->fw_outdated.current.application.app_id == p_evt->fw_outdated.transfer.id.application.app_id &&
                    p_evt->fw_outdated.current.application.company_id == p_evt->fw_outdated.transfer.id.application.company_id &&
                    p_evt->fw_outdated.current.application.app_version < p_evt->fw_outdated.transfer.id.application.app_version);

        case NRF_MESH_DFU_TYPE_BOOTLOADER:
            return (p_evt->fw_outdated.current.bootloader.bl_id == p_evt->fw_outdated.transfer.id.bootloader.bl_id &&
                    p_evt->fw_outdated.current.bootloader.bl_version < p_evt->fw_outdated.transfer.id.bootloader.bl_version);

        case NRF_MESH_DFU_TYPE_SOFTDEVICE:
            return false;

        default:
            return false;
    }
}

static void mesh_evt_handler(const nrf_mesh_evt_t* p_evt)
{
    switch (p_evt->type)
    {
        case NRF_MESH_EVT_DFU_FIRMWARE_OUTDATED:
        case NRF_MESH_EVT_DFU_FIRMWARE_OUTDATED_NO_AUTH:
            if (fw_updated_event_is_for_me(&p_evt->params.dfu))
            {
                ERROR_CHECK(nrf_mesh_dfu_request(p_evt->params.dfu.fw_outdated.transfer.dfu_type,
                                                 &p_evt->params.dfu.fw_outdated.transfer.id,
                                                 (uint32_t*) bank_addr));
                hal_led_mask_set(LEDS_MASK, false); /* Turn off all LEDs */
            }
            else
            {
                ERROR_CHECK(nrf_mesh_dfu_relay(p_evt->params.dfu.fw_outdated.transfer.dfu_type,
                                               &p_evt->params.dfu.fw_outdated.transfer.id));
            }
            break;

        case NRF_MESH_EVT_DFU_START:
            hal_led_mask_set(BSP_LED_0_MASK | BSP_LED_2_MASK, true);
            break;

        case NRF_MESH_EVT_DFU_END:
            hal_led_mask_set(LEDS_MASK, false); /* Turn off all LEDs */
            hal_led_mask_set(BSP_LED_0_MASK | BSP_LED_1_MASK, true); /* Yellow */
            break;

        case NRF_MESH_EVT_DFU_BANK_AVAILABLE:
            hal_led_mask_set(LEDS_MASK, false); /* Turn off all LEDs */
            ERROR_CHECK(nrf_mesh_dfu_bank_flash(p_evt->params.dfu.bank.transfer.dfu_type));
            break;

        default:
            break;

    }
}

static void node_reset(void)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Node reset  -----\n");
    hal_led_blink_ms(LEDS_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();
    }
}

static void button_event_handler(uint32_t button_number)
{
    switch (button_number)
       {
  /*When switch 0 is pressed*/
           case 0:
           {
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON 0 -----\n");

           }
            break;
  /*When switch 1 is pressed*/
          case 1:
          {
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON 1 -----\n");
          }
      
           break;
   /*When switch 2 is pressed*/
          case 2:
          {
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON 2 -----\n");
        
          }
       
            break;
   /*When switch 3 is pressed*/
          case 3:
          {
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON 3 -----\n");
          }
             
           break;
   /*When switch 4 is pressed*/					
          case 4:
          { 
            __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON 4 -----\n");
          }
          break;
                          
          default:
            break;
      }

}


static void app_rtt_input_handler(int key)
{
    if (key >= '0' && key <= '4')
    {
        uint32_t button_number = key - '0';
        button_event_handler(button_number);
    }
}


static void mesh_init(void)
{
    uint8_t dev_uuid[NRF_MESH_UUID_SIZE];
    uint8_t node_uuid_prefix[NODE_UUID_PREFIX_LEN] = SERVER_NODE_UUID_PREFIX;
    
    ERROR_CHECK(mesh_app_uuid_gen(dev_uuid, node_uuid_prefix, NODE_UUID_PREFIX_LEN));
    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             = dev_uuid,
        .models.models_init_cb   = NULL,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));

#if NRF_MESH_SERIAL_ENABLE
    ERROR_CHECK(nrf_mesh_serial_init(NULL));
#endif

    m_evt_handler.evt_cb = mesh_evt_handler;
    nrf_mesh_evt_handler_add(&m_evt_handler);
}

static void initialize(void)
{
uint32_t err_code;
#if defined(NRF51) && defined(NRF_MESH_STACK_DEPTH)
    stack_depth_paint_stack();
#endif

    ERROR_CHECK(app_timer_init());
    hal_leds_init();

    __LOG_INIT(LOG_MSK_DEFAULT | LOG_SRC_DFU | LOG_SRC_APP | LOG_SRC_SERIAL, LOG_LEVEL_INFO, log_callback_rtt);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Bluetooth Mesh DFU Example -----\n");

#if defined ( __CC_ARM )
    rom_end    = (uint32_t) rom_base + (uint32_t) rom_length;
#elif defined   ( __GNUC__ )
    rom_length = (uint32_t) rom_end - rom_base;
#endif
    /* Take the next available page address */
    bank_addr  = (uint32_t) (rom_end & FLASH_PAGE_MASK) + FLASH_PAGE_SIZE;
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG2, "rom_base   %X\n", rom_base);
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG2, "rom_end    %X\n", rom_end);
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG2, "rom_length %X\n", rom_length);
    __LOG(LOG_SRC_APP, LOG_LEVEL_DBG2, "bank_addr   %X\n", bank_addr);


    err_code =hal_buttons_init(button_event_handler);
    if (err_code == NRF_SUCCESS)
    {
      __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- successful -----\n");
    }
    else
    {
      __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- unsuccessful -----\n");
    }
    ble_stack_init();

#if MESH_FEATURE_GATT_ENABLED
    gap_params_init();
    conn_params_init();
#endif

    mesh_init();

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initialization complete!\n");
}

static void start(void)
{
    rtt_input_enable(app_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_complete_cb = NULL,
            .prov_device_identification_start_cb = NULL,
            .prov_device_identification_stop_cb = NULL,
            .prov_abort_cb = NULL,
            .p_device_uri = NULL
        };
        ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params));
    }

#if NRF_MESH_SERIAL_ENABLE
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Enabling serial interface...\n");
    ERROR_CHECK(nrf_mesh_serial_enable());
#endif

    ERROR_CHECK(mesh_stack_start());

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "DFU example started!\n");
}



int main(void)
{
    initialize();
    start();
    for (;;)
    {
       
    }
}

RE: MESH DFU PROBLEM

Bjørn Kvaale — Fri, 03 May 2019 13:46:28 GMT

You could also add some logging to the beginning of the button_event_handler to see if the function is being called at all:

__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Button %u pressed\n", button_number);

Are you sure the button_pin_config is set correctly, like done in the light switch example?

    for (uint32_t i = 0; i < BUTTONS_NUMBER ; ++i)
    {
        NRF_GPIO->PIN_CNF[m_buttons_list[i]] = BUTTON_PIN_CONFIG;
    }

Could you post the complete main code using the Insert -> Code option in DevZone? That may make it easier to debug.

RE: MESH DFU PROBLEM

Bjørn Kvaale — Wed, 01 May 2019 06:49:35 GMT

Due to other support activity, I have been kept busy the last few days. You can expect a response latest on the 3rd of May. Sorry for any inconvenience caused!

RE: MESH DFU PROBLEM

SAIF — Thu, 25 Apr 2019 12:55:08 GMT

Hello,

Thanks for your reply!!!

Yes,i have used ERROR_CHECK(hal_buttons_init(button_event_handler)) and it returned NRF_SUCCESS.

No,I am not using regular 52832 DK board,i am using my own developed board with customized gpio's configured according to my schematics for buttons.

Actually my entire application works fine with my gpio's configured with my board ,for this application i have used LIGHT_SWITCH_SERVER_CODE...There is not problem with my application when going with this SERVER code ,but as i need my application to run with DFU.

so ,i have merged my complete developed application in DFU code provided in MESH_EXAMPLES,but BUTTON related operations where NOT working in DFU code.

Yes,i have added RTT logging at the beginning of main..i.e.,in the initialize() function.

Do i need to go with RTT logging at the beginning of main ? As i am using this call ERROR_CHECK(hal_buttons_init(button_event_handler)) for my button handler.And i think this call will take to button_event_handler when ever button action happens?

RE: MESH DFU PROBLEM

Bjørn Kvaale — Thu, 25 Apr 2019 12:16:29 GMT

It's always a good idea to run ERROR_CHECK(hal_buttons_init(button_event_handler)) to see if the initialization function has initialized correctly. Are you using a regular 52832 DK when testing this functionality?

Have you added any RTT logging at the beginning of your main function just to see if you have setup RTT correctly (for example how it is done in the initialize() function of the light switch client example? Do you receive any RTT logging at all?