ADC NRFX interrupt connect Build Error Multiple IRQ Connect

Hi there, I am trying to do a blocking simple ADC measurement in using NRFX drivers in a threaded context, however when I build I get the following error:

gen_isr_tables.py: error: multiple registrations at table_index 14 for irq 14 (0xe)
Existing handler 0xd34d, new handler 0x5bfd
Has IRQ_CONNECT or IRQ_DIRECT_CONNECT accidentally been invoked on the same irq multiple times?

ninja: build stopped: subcommand failed.

But as you can see in my code that I define my IRQ_CONNECT for two separate interrupt functions, if I comment out the interrupt connect the code builds however the ADC does not sample. If i step through in debug mode the ADC does sample, could I please have some assistance with this issue?

/*
 * Copyright (c) 2022 - 2023, Nordic Semiconductor ASA
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * 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 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 the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 "hal/nrf_pwm.h"
#include <nrfx_example.h>
#include <nrfx_pwm.h>
#include <stdbool.h>
#include <stdint.h>
//#include <zephyr/drivers/adc.h>
#include <zephyr/drivers/pwm.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include "drivers/nrfx_errors.h"
#include <nrfx_glue.h>
#include <nrfx_saadc.h>
//#include "saadc_examples_common.h"

#define NRFX_LOG_MODULE                 EXAMPLE
#define NRFX_EXAMPLE_CONFIG_LOG_ENABLED 1
#define NRFX_EXAMPLE_CONFIG_LOG_LEVEL   3
#include <nrfx_log.h>

/**
 * @defgroup nrfx_pwm_common_example Common mode PWM example
 * @{
 * @ingroup nrfx_pwm_examples
 *
 * @brief Example showing basic functionality of nrfx_pwm driver for sequence loaded in common mode.
 *
 * @details Application initializes nrfx_pmw driver. It plays a simple sequence on LEDs ("breath"
 *          effect) and replays this sequence @ref NUM_OF_LOOPS times. The @ref pwm_handler() is
 *          executed with relevant log message after every loop.
 */

/** @brief Symbol specifying PWM instance to be used. */
#define STACKSIZE 1024
#define THREAD0_PRIORITY 7
#define THREAD1_PRIORITY 7
#define PWM_INST_IDX 0
#define ARRAYSIZE 192
//#define CH0_AIN ANALOG_INPUT_TO_SAADC_AIN(ANALOG_INPUT_A0)

/**
 * @brief Symbol specifying number of times that each duty cycle is to be repeated (after being
 *        played once) and is strictly correlated with the "breath" effect speed.
 */
#define VALUE_REPEATS 0UL

/** @brief Symbol specifying number of loops (breaths) to be performed. */
#define NUM_OF_LOOPS 1UL

/**
 * @brief Symbol specifying number of playbacks to be performed. In this example couple of
 *        playbacks might be considered as one loop.
 */
#define PLAYBACK_COUNT 1UL



//create a global PWM instance
nrfx_pwm_t pwm_instance1 = NRFX_PWM_INSTANCE(PWM_INST_IDX);

// Global PWM configuration setup
// 1 PWM period is 1.25us, clcok period is 62.5ns
// automatic stepping
nrfx_pwm_config_t config1 = {    
    .output_pins = {LED1_PIN, LED2_PIN, LED3_PIN, LED4_PIN},
    .pin_inverted = {0, 0, 0, 0},
    .irq_priority = 7,
    .base_clock = NRF_PWM_CLK_16MHz,
    .count_mode = NRF_PWM_MODE_UP,
    .top_value = 20,
    .load_mode = NRF_PWM_LOAD_COMMON,
    .step_mode = NRF_PWM_STEP_AUTO,
    .skip_gpio_cfg = 0
};

// Mutex definition of variable synchronisation/ control over critical code section timing
K_MUTEX_DEFINE(key);
nrf_pwm_values_common_t pwm_val []=
{
    0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 13, 6, 13, 6, 13, 6, 6, 13, 13, 13, 13, 6, 13
};
static nrf_pwm_values_common_t reset_seq [55] = {0};
nrf_pwm_values_common_t pwm_array_val [192] = {0};
nrf_pwm_values_common_t pwm_array_val2 [192] = {0};

// Led Array Build Function:
/*
Inputs:
    nrf_pwm__values_common_t *array: Pointer to array[0] to store signal PWM duty cycles as one big block to send as a continouse signal
    int lednumber: number where it sits in the LED strip 0-7 to place the colour sequnce in teh correct order
    nrf_pwm__values_common_t *coloursignal: pointer to coloursignal[0] which is the 24 element array that holds the colour value for 1 LED
Outputs:
    none
Description:
    concatenates each LED colour setup array as one big block of a pwm duty cycle sequence to be sent as a continous signal due to the WS2812 signalling
*/
void ledarraybuild(nrf_pwm_values_common_t *array,int lednumber,nrf_pwm_values_common_t *coloursignal){
    int base;
    base = 24*lednumber;
    for(int i = 0; i < 24; i++){
        array[base + i] = coloursignal[i];
    }
    return;
}

// Colour Sequence Function:
/*
Inputs:
    nrf_pwm__values_common_t *val: Pointer to val[0], which is a 24 element array of uint16_t values to store individual duty cycles in
    uint8_t red: Red component of a colour RGB hex code for ease of use
    uint8_t green: Green component of a colour RGB hex code for ease of use
    uint8_t blue: Blue component of a colour RGB hex code for ease of use
    
Outputs:
    none
Description:
    Adds appropriate duty cycle values in an array to represent a colour for one LED from a hex code
    to match the WS2812 signalling protocol. This is inverted as it appears the PWM signal has an 
    an inversion at some point. High should be VH for ~800ns, Low should be VH for ~400ns, this is designated
    from the hex code with the correct ordering as well.
*/
void colour_sequence(nrf_pwm_values_common_t *val, uint8_t red, uint8_t green, uint8_t blue){

    for(int i = 7; i >= 0; i--){
        //redblock
        if((red&(0x80>>i))){
            val[i + 8] = 6;
        } else {
            val[i + 8] = 14;
        }
    
        // blue block
        if((blue&(0x80>>i))){
            val[i + 16] = 6;
        } else {
            val[i + 16] = 14; 
        }
        // green block
        if((green&(0x80>>i))){
            val[i] = 6;
        } else {
            val[i] = 14;
        }
    }
    return;
}

//once PWM has a loop event this is triggered to setup a looped PWM.-> we need to change this to not be looping
//currently set to only loop once
static void pwm_handler(nrfx_pwm_evt_type_t event_type, void * p_context)
{
    nrfx_pwm_t * inst = p_context;
    /*switch(event_type){
        case NRFX_PWM_EVT_STOPPED:
            break;

    }*/
    static uint32_t curr_loop = 1;
   
    NRFX_LOG_INFO("Loops: %u / %lu", curr_loop, NUM_OF_LOOPS);

    if (curr_loop == NUM_OF_LOOPS)
    {
        NRFX_LOG_INFO("PWM finished");
        nrfx_pwm_uninit(inst);
    }
    curr_loop++;
}


static void ledupdate(uint16_t highcolour, uint16_t lowcolour, int level){
    static nrf_pwm_values_common_t pwm_array_val [192] = {0};
    nrf_pwm_sequence_t const seq_set =
    {
        .values = {pwm_array_val},
        .length = NRFX_ARRAY_SIZE(pwm_array_val),
        .repeats = VALUE_REPEATS,
        .end_delay = 0
    };
    for(int i = 0; i < 8; i++){
        colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
        ledarraybuild(pwm_array_val, i, pwm_val);
    }
    for(int i = 0; i < level; i++){
        colour_sequence(pwm_val, 0x00, 0x00, 0x0F);
        ledarraybuild(pwm_array_val, i, pwm_val);
    }  
    //NRF_PWM0->SEQ = &pwm_array_val;
    nrfx_pwm_simple_playback(&pwm_instance1, &seq_set, PLAYBACK_COUNT, NRFX_PWM_FLAG_LOOP);
    //nrfx_pwm_stop(&pwm_instance, true);
    //nrfx_pwm_sequence_update(&pwm_instance, 0,&seq_set);
    return;
}


//Thread to change the colour based on the ADC value/ Temperature
void thread0(void)
{
    #if defined(__ZEPHYR__)
    IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_PWM_INST_GET(PWM_INST_IDX)), IRQ_PRIO_LOWEST,
                NRFX_PWM_INST_HANDLER_GET(PWM_INST_IDX), 0, 0);
    #endif
    nrfx_err_t status;
    (void) status;




    //NRFX_EXAMPLE_LOG_INIT();

    //NRFX_LOG_INFO("Starting nrfx_pwm example for sequence loaded in common mode.");
    NRFX_EXAMPLE_LOG_PROCESS();
    //colour_sequence(pwm_val, 0x00, 0x00, 0xFF);
    
    //nrfx_pwm_config_t config = NRFX_PWM_DEFAULT_CONFIG(LED1_PIN, LED2_PIN, LED3_PIN, LED4_PIN);
    status = nrfx_pwm_init(&pwm_instance1, &config1, pwm_handler, &pwm_instance1);
    NRFX_ASSERT(status == NRFX_SUCCESS);
    k_mutex_lock(&key, K_FOREVER);
    //LOG_HEXDUMP_INF(pwm_array_val, sizeof(pwm_array_val),"Thread0 Data");
    /* nrfx_pwm_simple_playback(&pwm_instance, &seq_set1, PLAYBACK_COUNT, NRFX_PWM_FLAG_LOOP);
    k_busy_wait(20000);*/
    int i = 0;
    ledupdate(0xFF, 0X00, (i%8));
    k_mutex_unlock(&key);
   // k_busy_wait(20000);
    i++;
    // at the moment set not to change as the LEDS can't update -> focus on getting ADC to work.
	while (1) {
    k_busy_wait(20000);

	}
}


static int16_t sample;
static nrfx_saadc_channel_t channel = NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN0, 0);
//Thread to configure ADC and to filter + convert the sensor value to a temperature.
void thread1(void)
{   
    uint16_t measured;
    //status value for errors
            /* STEP 5.1 - Connect ADC interrupt to nrfx interrupt handler */
      IRQ_CONNECT(DT_IRQN(DT_NODELABEL(adc)),
		    DT_IRQ(DT_NODELABEL(adc), priority),
		    nrfx_isr, nrfx_saadc_irq_handler, 0);
    
        /* STEP 5.2 - Connect ADC interrupt to nrfx interrupt handler */
        nrfx_err_t err = nrfx_saadc_init(DT_IRQ(DT_NODELABEL(adc), priority));
        if (err != NRFX_SUCCESS) 
        {
                printk("nrfx_saadc_mode_trigger error: %08x", err);
                return;
        }

        /* STEP 5.3 - Configure the SAADC channel */
        channel.channel_config.gain = NRF_SAADC_GAIN1_6;
        err = nrfx_saadc_channels_config(&channel, 1);
        if (err != NRFX_SUCCESS) 
        {
		    printk("nrfx_saadc_channels_config error: %08x", err);
	        return;
	    }

        /* STEP 5.4 - Configure nrfx_SAADC driver in simple and blocking mode */
        err = nrfx_saadc_simple_mode_set(BIT(0),
                                         NRF_SAADC_RESOLUTION_12BIT,
                                         NRF_SAADC_OVERSAMPLE_DISABLED,
                                         NULL);
        if (err != NRFX_SUCCESS) {
                printk("nrfx_saadc_simple_mode_set error: %08x", err);
                return;
        }
        
        /* STEP 5.5 - Set buffer where sample will be stored */
        err = nrfx_saadc_buffer_set(&sample, 1);
        if (err != NRFX_SUCCESS) {
                printk("nrfx_saadc_buffer_set error: %08x", err);
                return;
        }
        while(1){
            nrfx_err_t err = nrfx_saadc_mode_trigger();
            if (err != NRFX_SUCCESS) {
                    printk("nrfx_saadc_mode_trigger error: %08x", err);
                    return;
            }
            k_mutex_lock(&key,K_FOREVER);
            /* STEP 7.3 - Calculate and print voltage */
            int voltage = ((600*6) * sample) / ((1<<12));
            int temp = (voltage - 500)/19.5;
            printk("SAADC sample: %d\n", sample);
            printk("Voltage: %d mV\n", voltage);
            k_mutex_unlock(&key);
            k_msleep(500);
        }

    }

	






/**
 * @brief Function for handling PWM driver events.
 *
 * @param[in] event_type PWM event.
 * @param[in] p_context  General purpose parameter set during initialization of
 *                       the timer. This parameter can be used to pass
 *                       additional information to the handler function.
 */


/**
 * @brief Function for application main entry.
 *
 * @return Nothing.
 */

   K_THREAD_DEFINE(thread0_id, STACKSIZE, thread0, NULL, NULL, NULL,
		THREAD0_PRIORITY, 0, 0);
    K_THREAD_DEFINE(thread1_id, STACKSIZE, thread1, NULL, NULL, NULL,
		THREAD1_PRIORITY, 0, 0);
/*int main(void)
{
    nrfx_err_t status;
    (void) status;


#if defined(__ZEPHYR__)
    IRQ_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_PWM_INST_GET(PWM_INST_IDX)), IRQ_PRIO_LOWEST,
                NRFX_PWM_INST_HANDLER_GET(PWM_INST_IDX), 0, 0);
#endif

    //NRFX_EXAMPLE_LOG_INIT();

    //NRFX_LOG_INFO("Starting nrfx_pwm example for sequence loaded in common mode.");
    NRFX_EXAMPLE_LOG_PROCESS();
    //colour_sequence(pwm_val, 0x00, 0x00, 0xFF);
    
    //nrfx_pwm_config_t config = NRFX_PWM_DEFAULT_CONFIG(LED1_PIN, LED2_PIN, LED3_PIN, LED4_PIN);
    status = nrfx_pwm_init(&pwm_instance, &config1, pwm_handler, &pwm_instance);
    NRFX_ASSERT(status == NRFX_SUCCESS);
    

    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 0, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 1, pwm_val);
    colour_sequence(pwm_val, 0x00, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 2, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 3, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 4, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 5, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 6, pwm_val);
    colour_sequence(pwm_val, 0x0F, 0x00, 0x00);
    ledarraybuild(pwm_array_val, 7, pwm_val);
    nrf_pwm_sequence_t seq_set =
    {
        .values = {pwm_array_val},
        .length = NRFX_ARRAY_SIZE(pwm_array_val),
        .repeats = VALUE_REPEATS,
        .end_delay = 0
    };


    while (1){

        k_mutex_lock(&key, K_FOREVER);
        nrfx_pwm_sequence_update(&pwm_instance,0, &seq_set);
        nrfx_pwm_simple_playback(&pwm_instance, &seq_set, PLAYBACK_COUNT, NRFX_PWM_FLAG_LOOP);
        k_mutex_unlock(&key);
        k_msleep(2000);
        }


    }*/



/** @} */

Related