Unable to insert breakpoint in timer interrupt handler

Question

Hi, I'm delevoping an appilcation which can generate one sample per 20 us (accomplished with timer0) and transmit one ESB packet when 20 samples are collected. Below is the C code for my applciation (modified from esb_ptx example in nRF5 SDK 16.0):

/**
 * Copyright (c) 2014 - 2019, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "sdk_common.h"
#include "nrf.h"
#include "nrf_error.h"
#include "app_util.h"
#include "app_error.h"

#include "nrf_esb.h"
#include "nrf_esb_error_codes.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "nrf_drv_gpiote.h"
#include "boards.h"

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

//// Pin definitions
#define PIN_CLKS                 11         // Use P0.11 (Arduino D0 on nRF52 DK)
#define PIN_BUT1                 BUTTON_1  
#define PIN_SAMPEN               LED_1  

//// Parameters
#define CLKS_PERIOD              20         // Timer0 interval in microseconds
#define NUM_BYTE_SLAV_PKT_DATA   20
#define NUM_BYTE_SLAV_PKT_ID      2
#define NUM_TX_PKT               10

//// Global Variables
uint8_t   saadc_count = 0; 
uint16_t  pid = 0;
uint16_t  dummy=1;

//// Instance declarations
static nrf_esb_payload_t        slav_tx_payload;
static nrf_esb_payload_t        slav_rx_payload;

static const nrf_drv_timer_t m_timer0 = NRF_DRV_TIMER_INSTANCE(0);

static nrf_ppi_channel_t m_ppi_channel1;
static nrf_ppi_channel_t m_ppi_channel2;
static nrf_ppi_channel_t m_ppi_channel3;
static nrf_ppi_channel_t m_ppi_channel4;

//// Function declarations
void pin_but1_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
    nrf_drv_gpiote_out_toggle(PIN_SAMPEN);
}


static void timer0_event_handler(nrf_timer_event_t event_type, void * p_context)
{
    uint16_t pid_tmp;
    uint32_t idx_pid;

    switch (event_type)
    {
        case NRF_TIMER_EVENT_COMPARE0:            
            slav_tx_payload.data[NUM_BYTE_SLAV_PKT_ID+saadc_count] = dummy++;

            if (saadc_count == NUM_BYTE_SLAV_PKT_DATA-1){                
                pid_tmp = pid; 
                for (idx_pid=0; idx_pid<NUM_BYTE_SLAV_PKT_ID; idx_pid++)
                {
                    slav_tx_payload.data[NUM_BYTE_SLAV_PKT_ID-1-idx_pid] = (uint8_t) pid_tmp&0xFF;
                    pid_tmp = pid_tmp>>8;

                }
                saadc_count = 0;
                pid++;
                
                // Send packet
                slav_tx_payload.noack = false;
                nrf_esb_write_payload(&slav_tx_payload);
                NRF_LOG_HEXDUMP_DEBUG(slav_tx_payload.data, NUM_BYTE_SLAV_PKT_ID+NUM_BYTE_SLAV_PKT_DATA);
            }
            else {
                saadc_count++;
            }
            
            if (pid==NUM_TX_PKT) {   // [Note] Timer0 cleared w/ NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK
                NRF_LOG_INFO("Stop timer0");
                nrf_drv_timer_disable(&m_timer0);
                nrf_drv_gpiote_out_toggle(PIN_SAMPEN); 
                pid = 0;
                dummy = 0;
            }
        default:
            //Do nothing.
            break;
    }
}


void nrf_esb_event_handler(nrf_esb_evt_t const * p_event)
{
    switch (p_event->evt_id)
    {
        // case NRF_ESB_EVENT_TX_SUCCESS:
        //     NRF_LOG_DEBUG("TX SUCCESS EVENT");
        //     break;
        case NRF_ESB_EVENT_TX_FAILED:
            NRF_LOG_DEBUG("TX FAILED EVENT");
            (void) nrf_esb_flush_tx();
            (void) nrf_esb_start_tx();
            break;
        case NRF_ESB_EVENT_RX_RECEIVED:
            // NRF_LOG_DEBUG("RX RECEIVED EVENT");
            while (nrf_esb_read_rx_payload(&slav_rx_payload) == NRF_SUCCESS)
            {
                if (slav_rx_payload.length > 0)
                {
                    NRF_LOG_DEBUG("RX RECEIVED PAYLOAD");
                }
            }
            break;
    }
}


static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


void clocks_start( void )
{
    NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;
    NRF_CLOCK->TASKS_HFCLKSTART = 1;

    while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0);
}


static void gpio_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_gpiote_init();
    APP_ERROR_CHECK(err_code);
    
    // PIN_CLKS setting
    nrf_drv_gpiote_out_config_t pin_clks_config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(false);  // init_high=false

    err_code = nrf_drv_gpiote_out_init(PIN_CLKS, &pin_clks_config);
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_out_task_enable(PIN_CLKS);
    
    // PIN_BUT1 setting
    nrf_drv_gpiote_in_config_t pin_but1_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(false);  // hi_accu=false (no use IN_EVENT)
    pin_but1_config.pull = NRF_GPIO_PIN_PULLUP;

    err_code = nrf_drv_gpiote_in_init(PIN_BUT1, &pin_but1_config, pin_but1_handler);  // IN_EVENT = pin_but1_handler
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_in_event_enable(PIN_BUT1, true);

    // PIN_SAMPEN setting
    nrf_drv_gpiote_out_config_t pin_sampen_config = GPIOTE_CONFIG_OUT_SIMPLE(true);  // configuring PIN_SAMPEN as output, where GPIOTE is not used; init_high=true 
    // nrf_drv_gpiote_out_config_t pin_sampen_config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);  // init_high=true 

    err_code = nrf_drv_gpiote_out_init(PIN_SAMPEN, &pin_sampen_config);
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_out_task_enable(PIN_SAMPEN);

}


static void timer0_init(void)
{
    // Check TIMER0 configuration for details.
    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
    timer_cfg.frequency = NRF_TIMER_FREQ_1MHz;
    timer_cfg.mode      = NRF_TIMER_MODE_TIMER;
    timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;

    ret_code_t err_code = nrf_drv_timer_init(&m_timer0, &timer_cfg, timer0_event_handler);
    APP_ERROR_CHECK(err_code);

    nrf_drv_timer_extended_compare(&m_timer0,
                                   NRF_TIMER_CC_CHANNEL0, 
                                   nrf_drv_timer_us_to_ticks(&m_timer0, CLKS_PERIOD),
                                   NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                   true);  // enable_int = true 

    nrf_drv_timer_compare         (&m_timer0,
                                   NRF_TIMER_CC_CHANNEL1, 
                                   nrf_drv_timer_us_to_ticks(&m_timer0, CLKS_PERIOD>>1),
                                   false); // enable_int = false 
}


static void ppi_init(void)
{
    uint32_t err_code = NRF_SUCCESS;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);


    /* Configure & enable available PPI channel to start TIMER0 on SENSE_HITOLO of PIN_BUT1 */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel1);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel1,
                                          nrf_drv_gpiote_in_event_addr_get(PIN_BUT1),
                                          nrf_drv_timer_task_address_get(&m_timer0, NRF_TIMER_TASK_START) );
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_enable(m_ppi_channel1);
    APP_ERROR_CHECK(err_code);

    /* Configure & enable available PPI channel to set PIN_CLKS to high on TIMER0 COMPARE[1] match */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel2);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel2,
                                          nrf_drv_timer_event_address_get(&m_timer0, NRF_TIMER_EVENT_COMPARE1),
                                          nrf_drv_gpiote_set_task_addr_get(PIN_CLKS) );
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_enable(m_ppi_channel2);
    APP_ERROR_CHECK(err_code);

    /* Configure & enable available PPI channel to set PIN_CLKS to low on TIMER0 COMPARE[0] match */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel3);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel3,
                                          nrf_drv_timer_event_address_get(&m_timer0, NRF_TIMER_EVENT_COMPARE0),
                                          nrf_drv_gpiote_clr_task_addr_get(PIN_CLKS) );
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_enable(m_ppi_channel3);
    APP_ERROR_CHECK(err_code);

    // /* Configure & enable 4th available PPI channel to set PIN_SAMPEN to low on SENSE_HITOLO of PIN_BUT1 */
    // err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel4);
    // APP_ERROR_CHECK(err_code);
    // err_code = nrf_drv_ppi_channel_assign(m_ppi_channel4,
    //                                       nrf_drv_gpiote_in_event_addr_get(PIN_BUT1),
    //                                       nrf_drv_gpiote_clr_task_addr_get(PIN_SAMPEN) );
    // APP_ERROR_CHECK(err_code);
    // err_code = nrf_drv_ppi_channel_enable(m_ppi_channel4);
    // APP_ERROR_CHECK(err_code);

}


uint32_t esb_init( void )
{
    uint32_t err_code;
    uint8_t base_addr_0[4] = {0xE7, 0xE7, 0xE7, 0xE7};
    uint8_t base_addr_1[4] = {0xC2, 0xC2, 0xC2, 0xC2};
    uint8_t addr_prefix[8] = {0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8 };

    nrf_esb_config_t nrf_esb_config         = NRF_ESB_DEFAULT_CONFIG;
    nrf_esb_config.protocol                 = NRF_ESB_PROTOCOL_ESB_DPL;
    nrf_esb_config.retransmit_delay         = 600;
    nrf_esb_config.bitrate                  = NRF_ESB_BITRATE_2MBPS;
    nrf_esb_config.event_handler            = nrf_esb_event_handler;
    nrf_esb_config.mode                     = NRF_ESB_MODE_PTX;
    nrf_esb_config.selective_auto_ack       = false;

    err_code = nrf_esb_init(&nrf_esb_config);

    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_base_address_0(base_addr_0);
    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_base_address_1(base_addr_1);
    VERIFY_SUCCESS(err_code);

    err_code = nrf_esb_set_prefixes(addr_prefix, NRF_ESB_PIPE_COUNT);
    VERIFY_SUCCESS(err_code);

    return err_code;
}


int main(void)
{
    ret_code_t err_code;

    log_init();
    clocks_start();
    gpio_init();
    timer0_init();
    ppi_init();

    err_code = esb_init();
    APP_ERROR_CHECK(err_code);

    // TX payload init
    slav_tx_payload.pipe   = 0;
    slav_tx_payload.length = NUM_BYTE_SLAV_PKT_ID + NUM_BYTE_SLAV_PKT_DATA;

    NRF_LOG_INFO("ANC raw data transmitter started.");

    while (true)
    {
        __WFE();
    }
}

Here're my questions:

1. Why a question mark appears at the breakpoint inserted at the beginning of the following for-loop below?

2. It seems the program didn't perform the loop operation as expected (i.e., only perform 1 tiem loop rather than that specified by NUM_BYTE_SLAV_PKT_ID). Why?

                for (idx_pid=0; idx_pid<NUM_BYTE_SLAV_PKT_ID; idx_pid++)
                {
                    slav_tx_payload.data[NUM_BYTE_SLAV_PKT_ID-1-idx_pid] = (uint8_t) pid_tmp&0xFF;
                    pid_tmp = pid_tmp>>8;

                }

Thank you in advance for your help.

Best regards,

Johnson

Hung Bui · Accepted Answer

Hi Johnson, 
 I suspect that the code has been optimized and that why you can't add breakpoint. You would need to configure the code with no optimization to be able to debug: 
 
 Can you add the breakpoint inside the loop ?

Hung Bui · Answer

Hi Johnson, Could you just right click on the slav_tx_payload.data and select at to watch ?

Unable to insert breakpoint in timer interrupt handler

Top Replies