RE: Creating application timer with context pointer

Vidar Berg — Tue, 19 Jun 2018 08:14:56 GMT

I think it's good practice to use 'static' for global variables for the reason you mentioned, but it's not required. A local static variable is also accessible during the complete execution.

RE: Creating application timer with context pointer

KevinL — Tue, 19 Jun 2018 07:19:04 GMT

I understand that applying to local variables. But globals are accessible during the complete execution anyway. Should they still be made static so another file cannot declare a global variable with the same name?

RE: Creating application timer with context pointer

Vidar Berg — Tue, 19 Jun 2018 06:46:02 GMT

Glad to hear that you got it to work. As for the remaining question, it's unsafe to use an auto variable because it will be pushed to the call stack thus only valid in the scope of which the variable was defined (will likely be overwritten at some point).

RE: Creating application timer with context pointer

KevinL — Mon, 18 Jun 2018 15:31:49 GMT

Thank you for the fast reply. My implementation of the timer was correct all along, the extraction of the rValue in the timeout handler was erroneous.

One question remains: Why should the context pointer be in static memory? I have tried automatic memory allocation, which works just fine.

Below my work progress for future visitors with the same problem.

------------------

What I want to achieve is to do a periodical check and change a variable accordingly, the incrementation is for testing of the timeout handler call only. I want to avoid globals for good coding practice.

I have changed my context variable to be static. I noticed that I forgot to include my implementation starting the timer where I had been passing the context pointer already.

Changes made:

making the counter a static uint32_t
casting to uint32_t *
%d to %u
implementation of valueIncrementer()

APP_TIMER_DEF(valueIncrementer_timer_id);       //Had  not included this before
static uint32_t counter = 0;

void valueIncrementer(void *countValue)
{
  uint32_t *pCountValue = countValue;
  uint32_t newValue = *pCountValue;
  newValue++;
  counter = (int)newValue;
  NRF_LOG_INFO("counter = %u, %d", newValue, counter);
}
void (*valueIncrementerFPtr)(void *);

static void timers_init(void)
{
    // Initialize timer module.

       err_code = app_timer_create(&valueIncrementer_timer_id, 
                                   APP_TIMER_MODE_REPEATED,
                                   //valueIncrementer);
                                   *valueIncrementerFPtr);
       APP_ERROR_CHECK(err_code);
       /*^MY_JOB^*/
}

static void application_timers_start(void)
{
       ret_code_t err_code;
       int* pointer = &counter;
       err_code = app_timer_start(valueIncrementer_timer_id, TIMER_VALUE_INCREMENTER, &counter);    //Breakpoint: &context is correct
       APP_ERROR_CHECK(err_code); 
}

int main(void)
{
    valueIncrementerFPtr = &valueIncrementer;
    ...
    }

The context pointer passed to app_timer_start is correct, as well as the address received in the timeout handler (I've checked this with *pointer = &counter). Knowing that the received pointer address is correct, it had to be something about retrieving the rValue.

At first I did not succeed in easily retrieving the value and incrementing the global counter (implementation of valueIncrementer()). I tried incrementing and casting in the same statement. To solve it, I extracted every step into the simplest possible form.

I am going to reduce this to proper code tomorrow, and calling it a day for now.

------

Edit:

So I have not managed to reduce valueIncrementer() any while keeping the functionality. Underneeth I have only removed the redundant code/checks.

void valueIncrementer(void *countValue)
{
  uint32_t *pCountValue = countValue;
  uint32_t value = *pCountValue;
  value++;
  counter = value;
  NRF_LOG_INFO("counter = %u", counter);
}

static void application_timers_start(void)
{
       ret_code_t err_code;
       err_code = app_timer_start(valueIncrementer_timer_id, TIMER_VALUE_INCREMENTER, &counter);
       APP_ERROR_CHECK(err_code); 
}

RE: Creating application timer with context pointer

Vidar Berg — Mon, 18 Jun 2018 12:38:24 GMT

Hi,

The context pointer should be stored in static memory. Eg.,

static uint32_t context; // Can be defined globally

// Start application timers.
err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, &context);
APP_ERROR_CHECK(err_code);

I'm not completely sure I understand what you want to achieve, but in your case, would it make sense to just increment the "context" variable from the timeout handler?