Timer working only once

RE: Timer working only once

Dzolo2k1 — Tue, 27 Feb 2024 17:20:05 GMT

Ok I got it, i had do initialise every channel separately so my channel_count macro works, and ofc im an idiot who didnt understand properly my code. I had to change a bit my buff req loop so it looks for samples count not channel count.

RE: Timer working only once

Dzolo2k1 — Tue, 27 Feb 2024 13:36:05 GMT

Sadly, it doesnt work. I was trying to add this line of config before.

And still it does block itself from working again on evt_finished. I can do try to do it differently, but right now im just super curious what have i done wrong.

RE: Timer working only once

Jørgen Holmefjord — Tue, 27 Feb 2024 11:29:32 GMT

Can you add this line before nrfx_saadc_advanced_mode_set()?

adv_config.start_on_end = true;

You then need to use NRF_SAADC_TASK_SAMPLE as the endpoint.

Alternatively you need to use two separate PPI channels, one between TIMER->COMPARE0 and SAADC->SAMPLE and one between SAADC->END and SAADC->START.

RE: Timer working only once

Dzolo2k1 — Mon, 26 Feb 2024 23:41:04 GMT

Oh yeah and ive change in endpoints setup NRF_SAADC_TASK_SAMPLE to NRF_SAADC_TASK_START

RE: Timer working only once

Dzolo2k1 — Mon, 26 Feb 2024 23:40:28 GMT

I've done some debugging and it is not entering nrfx_saadc_evt_done

RE: Timer working only once

Dzolo2k1 — Mon, 26 Feb 2024 22:37:57 GMT

Hello, I still have a problem. Sadly it is not working in loop or actually it is, cuz if i trigger Timer callback i can see its workin in loop, but somehow my SAADC starts only once. Im completely stuck.

#include <zephyr/kernel.h>
#include "nrfx_saadc.h"
#include <nrfx_timer.h>
#include <nrfx_gpiote.h>
#include <nrfx_log.h>
#include <helpers/nrfx_gppi.h>
#include <nrfx_ppi.h>
#define ANALOG_INPUT_TO_SAADC_AIN(x) ((x) + 1)


#define TIMER_INST_IDX 0
#define TIME_TO_WAIT_MS 3300UL

#define CH0_AIN ANALOG_INPUT_TO_SAADC_AIN(1)
#define CH1_AIN ANALOG_INPUT_TO_SAADC_AIN(2)
#define CH2_AIN ANALOG_INPUT_TO_SAADC_AIN(3)

#define CHANNEL_COUNT NRFX_ARRAY_SIZE(m_multiple_channels)


#define BUFFER_SIZE 3UL
#define BUFFER_COUNT 3UL

static const nrfx_saadc_channel_t m_multiple_channels[] =
{
    NRFX_SAADC_DEFAULT_CHANNEL_SE(CH0_AIN, 0),
    NRFX_SAADC_DEFAULT_CHANNEL_SE(CH1_AIN, 1),
    NRFX_SAADC_DEFAULT_CHANNEL_SE(CH2_AIN, 2)
};

static uint8_t m_gppi_channels[3];
static nrf_saadc_value_t value_buffer[CHANNEL_COUNT];

static void timer_handler(nrf_timer_event_t event_type, void * p_context){
      
}

nrfx_timer_t timer_inst = NRFX_TIMER_INSTANCE(TIMER_INST_IDX);


static void saadc_handler(nrfx_saadc_evt_t const * p_event){
    nrfx_err_t status;
    (void)status;

    static uint16_t buffer_index = 1;
    static uint16_t buf_req_evt_counter;
    uint16_t samples_number;
switch(p_event->type)
    {
        case NRFX_SAADC_EVT_CALIBRATEDONE:

            status = nrfx_saadc_mode_trigger();
            NRFX_ASSERT(status == NRFX_SUCCESS);
            break;

        case NRFX_SAADC_EVT_READY:

            break;

        case NRFX_SAADC_EVT_BUF_REQ:
            NRFX_LOG_INFO("SAADC event: BUF_REQ");

            if (++buf_req_evt_counter < 3)
            {
                status = nrfx_saadc_buffer_set(value_buffer[buffer_index++], BUFFER_SIZE);
                buffer_index = buffer_index % BUFFER_COUNT;
                if(status != NRFX_SUCCESS)
			    {
				LOG_ERR("Error! Could not set buffer: %d\n", status);
			    }
            }
            
            break;
        case NRFX_SAADC_EVT_DONE:

            samples_number = p_event->data.done.size;
            for (uint16_t i = 0; i < samples_number; i++)
            {
                printf("[Sample %u] value == %d\n", i, p_event->data.done.p_buffer[i]);
            }
            break;

        

        default:
            break;
    }
}

static void Timer_init(void){

    nrfx_err_t err; 

    (void)err;


    uint32_t base_frequency = NRF_TIMER_BASE_FREQUENCY_GET(timer_inst.p_reg);

    nrfx_timer_config_t config = NRFX_TIMER_DEFAULT_CONFIG(base_frequency);

    config.bit_width = NRF_TIMER_BIT_WIDTH_32;

    err = nrfx_timer_init(&timer_inst, &config, timer_handler);

    nrfx_timer_clear(&timer_inst);

    uint32_t desired_ticks = nrfx_timer_ms_to_ticks(&timer_inst, TIME_TO_WAIT_MS);


    nrfx_timer_extended_compare(&timer_inst, NRF_TIMER_CC_CHANNEL0, desired_ticks,
                                NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, false);                           

     
    
    
}
void saadc_init(void){

    nrfx_err_t err; 

    (void)err;

    err = nrfx_saadc_init(NRFX_SAADC_DEFAULT_CONFIG_IRQ_PRIORITY);

    err = nrfx_saadc_channels_config(m_multiple_channels, CHANNEL_COUNT);

    uint32_t channel_mask = nrfx_saadc_channels_configured_get();

    nrfx_saadc_adv_config_t adv_config = NRFX_SAADC_DEFAULT_ADV_CONFIG;

    err = nrfx_saadc_advanced_mode_set(channel_mask,
                                          NRF_SAADC_RESOLUTION_8BIT,
                                          &adv_config,
                                          saadc_handler);
  
    err = nrfx_saadc_buffer_set(&value_buffer, CHANNEL_COUNT);

    err = nrfx_saadc_offset_calibrate(saadc_handler);

    }

int main(void)
{
    nrfx_err_t err; 

    saadc_init(); 

    Timer_init();

    uint8_t channel;
	err = nrfx_gppi_channel_alloc(&channel);
    
    nrfx_gppi_channel_endpoints_setup(
        channel,
		nrfx_timer_event_address_get(&timer_inst, NRF_TIMER_EVENT_COMPARE0),
		nrf_saadc_task_address_get(NRF_SAADC, NRF_SAADC_TASK_SAMPLE));

    nrfx_gppi_channels_enable(BIT(channel));                         

    #if defined(__ZEPHYR__)
    IRQ_DIRECT_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_SAADC), IRQ_PRIO_LOWEST, nrfx_saadc_irq_handler, 0);
    #endif
    #if defined(__ZEPHYR__)
    IRQ_DIRECT_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_TIMER_INST_GET(TIMER_INST_IDX)), IRQ_PRIO_LOWEST,
                       NRFX_TIMER_INST_HANDLER_GET(TIMER_INST_IDX), 0);
    IRQ_DIRECT_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_GPIOTE), IRQ_PRIO_LOWEST, nrfx_gpiote_irq_handler,
                       0);
    #endif      
    nrfx_timer_enable(&timer_inst);

        while(1){}

        return 0;
}

RE: Timer working only once

Jørgen Holmefjord — Mon, 26 Feb 2024 12:17:59 GMT

Some of the drivers are described in nRF5 documentation, but the APIs does not match 100% to the nrfx driver APIs, see Migration guide for nrfx drivers. The HAL APIs are only documented in the nrfx API documentation.

For nRF Connect SDK, it is recommended to use the Zephyr driver APIs whenever possible.

RE: Timer working only once

Dzolo2k1 — Mon, 26 Feb 2024 12:09:54 GMT

Oh god, thank you. But im wondering is there any doc. explains the functions in HAL/drivers? I know there are samples and some basic explanations about functions in .h file, but im asking about some more knowledge. Cuz right now im just reading HW documents from nrf52840 and trying to figure out what to use from .h files

RE: Timer working only once

Jørgen Holmefjord — Mon, 26 Feb 2024 11:48:01 GMT

Hi,

If you want a recurring timer, you need to change the parameter passed to nrfx_timer_extended_compare() from NRF_TIMER_SHORT_COMPARE0_STOP_MASK to NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK. The STOP mask will stop the timer once the COMPARE0 is generated, while the CLEAR mask will clear the counter in the timer, practically restarting it.

Note that you have set the enable_int parameter to false, which means that there will be no interrupt generated from the event, and the timer handler will not be run. This is useful if you are using the event for triggering SAADC sampling using PPI.

Best regards,
Jørgen