MESH DFU PROBLEM

[SAIF]

Hello,

Here i are using nRF52832 ,softdevice S132 and mesh sdk v3.0.0

For my Application,i need to go with DFU.so i merged my application into the example code of DFU provided by MESH SDK.

As my Application needs BUTTON related functions.so for this i have added this code

hal_buttons_init(button_event_handler);

static void button_event_handler(uint32_t button_number)
{
       switch (button_number)
       {
  /*When switch 0 is pressed*/
           case 0:
           {
            AF_ButtonState = BUTTON0;
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON0 -----\n");
           }
            break;
  /*When switch 1 is pressed*/
          case 1:
          {
           AF_ButtonState = BUTTON1;
                           __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON1 -----\n");
          }
      
           break;
   /*When switch 2 is pressed*/
          case 2:
          {
           AF_ButtonState = BUTTON2;
                           __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON2 -----\n");
          }
       
            break;
   /*When switch 3 is pressed*/
          case 3:
          {
           AF_ButtonState = BUTTON3;
                           __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON3 -----\n");
          }
             
           break;
   /*When switch 4 is pressed*/                    
          case 4:
          {
           AF_ButtonState = BUTTON4;
                           __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BUTTON4 -----\n");
          }
          break;
                          
          default:
            AF_ButtonState = BUTTON_IDLE;
            break;
      }
}

so when ever BUTTON actions happen,it is not going to the handler and nothing is printing in the LOG as well.

As given in MESH sdk (SERVER code example).

i have enabled RTT also,

rtt_input_enable(app_rtt_input_handler, RTT_INPUT_POLL_PERIOD_MS);

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

As MESH DFU example doesn't have BUTTON related functions,so i have added the above things,but here nothings seems to go quite well with my application.

So i hope could anyone help me in this regards

thank you.

[Bjørn Kvaale]

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?

[SAIF]

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?

[Bjørn Kvaale]

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!

[Bjørn Kvaale]

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.

[SAIF]

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 (;;)
    {
       
    }
}