How to combine nrf5 SDK code with mesh sdk?

[Aduka_27]

Hi guys,

I have already created some code in a peripheral folder inside nrf5 SDK documentation related to temperature readings and the way how to save the data in the flash memory and read it after that in order for example to calculate the average of ten temperature values. Now, I am interested in how to properly move that code in the mesh SDK folder because I would like to send the final value using mesh features. Is that possible, and if it is can you please send me an example or give me advice on how to properly do that.

Thanks in advance! 

Adnan

[tesc]

Hi,

From what I understand you have a project based on the nRF5 SDK, where you store temperature readings to flash, before you read them out and do some calculation. Now you want to use Bluetooth mesh for communicating the result of the calculation to other devices.

If you are only going to use Bluetooth mesh in your project, and not "normal" BLE, then I think it is best to start with an example from the nRF5 SDK for Mesh, and add your code to that project. Otherwise you can have a look at Integrating Bluetooth mesh into nRF5 SDK examples.

Please note that depending on your use case, writing the temperature readings to flash in order to store them is not necessarily a good idea. If the time span that you need to temporarily store the values is short, then keeping them in RAM (until you have enough values to do the calculation) may be a better idea. The flash of the nRF52 series is typically guaranteeing only 10k write/erase cycles before you may start seeing bit errors, while RAM does not have such a constraint.

Regards,
Terje

[Aduka_27]

Hi,

Yes, my current code is completely based on nRF5 SDK for which I used the existing code in the peripherals folder. Now, I want to use that code in order to send the average temp value to let's say server, but using the BLE mesh. I tried to copy and paste my code, together with all needed drivers and libraries to the existing BLE mesh example but without success. In the attachment, I send you my current code if you want just to check if we understand each other correctly. Thanks in advance!

Best regards, 

Adnan.

 

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "nrf.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "nrf_delay.h"
#include "nrf_temp.h"
#include "app_error.h"
#include "bsp.h"
#include "app_util_platform.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_nvmc.h"
#include "nordic_common.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "app_timer.h"
#include "nrf_drv_clock.h"

#include "nrf_cli.h"
#include "nrf_cli_uart.h"

void saadc_callback_handler (nrf_drv_saadc_evt_t const * p_event){

  // Empty handler function
}

void saadc_init(void){

  ret_code_t err_code;

  // Create a config struct and assign it default values along with the pin number for ADC input
  // Configure the input as Single Ended (One Pin Reading)

  nrf_saadc_channel_config_t channel_config = NRFX_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_VDD);

  // Initilize the saadc
  err_code = nrf_drv_saadc_init(NULL, saadc_callback_handler);
  APP_ERROR_CHECK(err_code);

  // Initilize the channel which will be connected to that specific pin
  err_code = nrfx_saadc_channel_init(0, &channel_config);
  APP_ERROR_CHECK(err_code);

}

float f_temp(){


    float temp; 

    NRF_TEMP->TASKS_START = 1;

    while (NRF_TEMP->EVENTS_DATARDY == 0)
    {
        // Do nothing.
    }
    
    NRF_TEMP->EVENTS_DATARDY = 0;

    temp = (nrf_temp_read() / 4);

    NRF_TEMP->TASKS_STOP = 1;

    return temp;

}

float f_store(float temp, uint32_t *i, int temp_size){


    uint32_t tmp_temp = temp;

    uint32_t f_addr = 0x0007f000;

    uint32_t * p_addr = (uint32_t *)f_addr;

    uint32_t tmp_temp_array[*i+1];

    for (int k = 0; k<=*i; k++) {
      
      tmp_temp_array[k] = *(p_addr+k);
      
    }

    tmp_temp_array[*i] = tmp_temp;

    nrf_nvmc_page_erase(f_addr);
    nrf_nvmc_write_words(f_addr, tmp_temp_array, *i+1);
    
   
    for (int j = 0; j<=*i; j++){
      NRF_LOG_INFO("i memory is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i));
      NRF_LOG_INFO("j is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(j));
      NRF_LOG_INFO("In memory data is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*(p_addr+j)));
    }

    NRF_LOG_INFO("i at end of f_store is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i));

}

float f_compute(int temp_size){

  uint32_t f_addr = 0x0007f000;

  uint32_t * p_addr = (uint32_t *)f_addr;

  uint32_t avg_addr = 0x0007d000;

  uint32_t * avg_pointer = (uint32_t *)avg_addr;

  float temp_sum = 0;

  for (int k = 0; k<temp_size; k++){
 
    temp_sum = temp_sum + (*(p_addr+k));
  }

  float average_temp = temp_sum / temp_size;

  NRF_LOG_INFO("Average temperature is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(average_temp));

  nrf_nvmc_page_erase(avg_addr);
  nrf_nvmc_write_word(avg_addr, average_temp);

  nrf_nvmc_page_erase(f_addr);
}

int main(void)
{
    saadc_init();

    nrf_saadc_value_t adc_val;


    nrf_temp_init();
    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();
    
    int temp_size = 10;

    uint32_t i_addr = 0x0007e000;
    uint32_t * i_pointer = (uint32_t *)i_addr;

    NRF_LOG_INFO("Test is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i_pointer));

    if (*i_pointer == -1){
      nrf_nvmc_write_word(i_addr, 0);
    }
    
    NRF_LOG_INFO("agfter Test is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i_pointer));

    while (true)
    {
        

        nrfx_saadc_sample_convert(0, &adc_val);

        float voltage = adc_val * 3.6 / 1024;

        NRF_LOG_INFO("Volts: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(voltage));

        //NRF_LOG_INFO("Hello!\n");

        if (voltage > 2.5){
          
          NRF_LOG_INFO("i: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i_pointer));

          if (*i_pointer < temp_size){
            NRF_LOG_INFO("uso u if\n");
            
            f_store(f_temp(), i_pointer, temp_size);
            const uint32_t new_i = *(i_pointer) + 1;
            NRF_LOG_INFO("i after f-store() is: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(new_i));
            nrf_nvmc_page_erase(i_addr);
            nrf_nvmc_write_word(i_addr, new_i);
            NRF_LOG_INFO("after new i: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i_pointer));
            //nrf_nvmc_write_word(i_addr, 2);
            //NRF_LOG_INFO("after second new i: " NRF_LOG_FLOAT_MARKER " \n", NRF_LOG_FLOAT(*i_pointer));
          } else {
            NRF_LOG_INFO("uso u else\n");
            f_compute(temp_size); //in this function, erase from memory
            //i = 0;
            nrf_nvmc_page_erase(i_addr);
            nrf_nvmc_write_word(i_addr, 0);
          }


        }
        else{
        
          NRF_LOG_INFO("Not possible!\n");
        }

        nrf_delay_ms(5000);

        NRF_LOG_FLUSH();
    }
}

[tesc]

Hi,

With Bluetooth mesh (as with BLE) you are using the SoftDevice (our BLE stack), which takes control of many of the peripherals on the SoC, including control of the non-volatile memory controller (nvmc). Therefore you need to use the SoftDevice API for accessing certain peripherals (including nvmc).

That means that the code that you provided will not work with the SoftDevice (and therefore not with any BLE or Bluetooth mesh applications either.)

A couple of our flash examples come in both "blank" versions and "s132" versions (for the S132 SoftDevice). Those are the Flash Storage Example and the Flash Data Storage Example. They both use higher abstractions for storing to flash.

For more information on what peripherals are needed by the SoftDevice, have a look at the Hardware peripherals section of the SoftDevice Specification.

Regards,
Terje

[Aduka_27]

Hi Terje,

First of all, thanks a lot for this very detailed explanation of my problem. I have already moved to SoftDevice APIs and for now, I created the same application as I sent you before. But also, in this example, I have some problems as I am not able to read the temperature properly, and also if you can check if everything is correct. I have already flashed my board and run the code, and everything works as I expected, but it's always better if somebody else with more experience checks the code again. Also, I have a problem with printing the float values, I tried to use NRF_LOG but without success (because in the previous example I used NRF_LOG_FLOAT_MARKER)? 

Best regards,

Adnan.

Here is the 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_gatt.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"

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

/* Models */
#include "generic_onoff_server.h"

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

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

#include "nrf_delay.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h "

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

static void initilize(void)
{

    __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT);

}

static int32_t f_temp()
{

    int32_t temp;

    (void)sd_temp_get(&temp);

    int32_t temperature = (int8_t)(temp);

    __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"temp_read = %d \n",temperature);	

    return temperature;

}

static int32_t f_store(int32_t temperature, uint32_t *i, int temp_size)
{

    int32_t tempa = temperature;

    uint32_t pg_size = NRF_FICR->CODEPAGESIZE;
    uint32_t pg_num = NRF_FICR->CODESIZE-2; 

    uint32_t *addr_store = (uint32_t *)(pg_size * pg_num);

    int32_t tempa_array[*i+1];

    for (int k=0; k<=*i; k++){
        
        tempa_array[k] = *(addr_store+k);  
    }

    tempa_array[*i] = tempa;

    sd_flash_page_erase(pg_num);

    sd_flash_write((uint32_t*)addr_store, (int32_t*)tempa_array, *i+1);

    for (int j=0; j<=*i; j++){
    
        __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Temperature value is: %d \n", *(uint32_t*)(addr_store+j));	   
    }    
}

static int32_t f_compute(int temp_size){

    uint32_t pg_size = NRF_FICR->CODEPAGESIZE;
    uint32_t pg_num = NRF_FICR->CODESIZE-2; 

    uint32_t *addr_store = (uint32_t *)(pg_size * pg_num);

    uint32_t pg_size_compute = NRF_FICR->CODEPAGESIZE;
    uint32_t pg_num_compute = NRF_FICR->CODESIZE-3;

    uint32_t *addr_compute = (uint32_t *)(pg_size_compute * pg_num_compute);

    int temp_sum = 0;

    for (int k = 0; k<temp_size; k++){
 
        temp_sum = temp_sum + (*(addr_store+k));
    }

    int average_temp[1] = {temp_sum / temp_size};

    sd_flash_page_erase(pg_num_compute);
    sd_flash_write((uint32_t*)addr_compute, (uint32_t*)average_temp, 1);

    __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Average temperature is: %d \n", *(uint32_t*)(addr_compute));

    sd_flash_page_erase(pg_num);

}

int main(void)
{

    initilize();

    int temp_size = 3;

    uint32_t pg_size_pointer = NRF_FICR->CODEPAGESIZE;
    uint32_t pg_num_pointer = NRF_FICR->CODESIZE-4; // use last page in flash 

    uint32_t *addr_pointer = (uint32_t *)(pg_size_pointer * pg_num_pointer);

    __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Pointer value is = %d \n", *(uint32_t*)(addr_pointer));

    if (*(uint32_t*)(addr_pointer) == -1){

        __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Pointer je -1!\n");

        uint32_t pointer_array[1] = {0};
    
        sd_flash_write((uint32_t*)addr_pointer, (uint32_t*)pointer_array, 1);

        __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Pointer value is = %d \n", *(uint32_t*)(addr_pointer));

    }

    while(true) {


        if (*(uint32_t*)(addr_pointer) < temp_size){
        
            __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Usao sam u if funkciju!\n");
            f_temp();
            f_store(f_temp(), addr_pointer, temp_size);
            uint32_t new_i[1] = {*(addr_pointer) + 1};
            sd_flash_page_erase(pg_num_pointer);
            sd_flash_write((uint32_t*)addr_pointer, (uint32_t*)new_i, 1);
            __LOG(LOG_SRC_APP,LOG_LEVEL_INFO,"Pointer value is = %d \n", *(uint32_t*)(addr_pointer)); 
        }

        else{
        
             f_compute(temp_size);
             sd_flash_page_erase(pg_num_pointer);
             uint32_t new_i[1] = {0};
             sd_flash_write((uint32_t*)addr_pointer, (uint32_t*)new_i, 1);
        }

        nrf_delay_ms(10000);

        }

}

[tesc]

Hi,

Regarding the issues with temperature reading and printing floats, it looks like you already did get help and good suggestions in other threads before the holidays.

As a general remark, I see in your code that you do quite some writing and erasing of flash, instead of simply holding things in RAM. If you get one read/erase cycle on the flash page every 5 seconds, then you may risk the flash starting to fail after 10000 * 5 = 50000 seconds, or after around fourteen hours of operation, ref. the absolute maximum ratings table of the nRF52832 Product Specification. (It may of course last longer, but 10000 is the minimum rating that we guarantee.)

Regards,
Terje