PWM_LED sample code compile error

cptel

nRF9151 Feather v1

Getting following compile error:
21 | #error “No LED PWM device found”
| ~~
In file included from /Users/summer/zephyr/include/zephyr/device.h:12,
from /Users/summer/nrf9160-feather-examples-and-drivers-3.0.x/samples/led_pwm/src/main.c:9:
/Users/summer/nrf9160-feather-examples-and-drivers-3.0.x/samples/led_pwm/src/main.c:27:26: warning: implicit declaration of function ‘LED_PWM_NODE_ID_FOREACH_CHILD’ [-Wimplicit-function-declaration]
27 | DT_FOREACH_CHILD(LED_PWM_NODE_ID, LED_PWM_LABEL)};
| ^~~~~~~~~~~~_~~

Build Configuration:

jaredwolff

@cptel The LED is configured via the PMIC. Check out the blinky sample for controlling the RGB LED.

cptel

good on blinky LEDs.

Do you have a sample code that configures P0.26 (D2 on header pin) as Input?

jaredwolff

cptel ~~a GPIO logic input or ADC input?~~ Let me see what I can find for GPIO input. You may be able to look at the button sample. P0.26 is not an ADC input. Stay tuned

jaredwolff

In Zephyr/Nordic NCS, you can set a GPIO as input using the GPIO_DT_SPEC_GET macro combined with gpio_pin_configure_dt(). Here’s how to do it:

Step 1: Define GPIO in Device Tree

First, define your GPIO in the device tree overlay (boards/circuitdojo_feather_nrf9151_ns.overlay file):

/ {
    gpio_input {
        compatible = "gpio-keys";
        input_pin: input_pin {
            gpios = <&gpio0 26 GPIO_ACTIVE_HIGH>;
            label = "Input Pin";
        };
    };
};

Full sample path for example: nfed/samples/usb_detect/boards/circuitdojo_feather_nrf9151_ns.overlay

Step 2: Get GPIO Specification and Configure as Input

In your C code:

#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>

// Get the GPIO specification from device tree
static const struct gpio_dt_spec input_gpio = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin), gpios);

int main(void)
{
    int ret;

    // Check if the GPIO device is ready
    if (!gpio_is_ready_dt(&input_gpio)) {
        printk("Error: GPIO device %s is not ready\n", input_gpio.port->name);
        return -1;
    }

    // Configure GPIO as input
    ret = gpio_pin_configure_dt(&input_gpio, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure GPIO pin\n", ret);
        return ret;
    }

    printk("GPIO configured as input successfully\n");
    
    // Now you can read the GPIO state
    while (1) {
        int pin_state = gpio_pin_get_dt(&input_gpio);
        printk("Pin state: %d\n", pin_state);
        k_sleep(K_MSEC(1000));
    }

    return 0;
}

Key Points:

GPIO_DT_SPEC_GET(node_id, prop) - Gets the GPIO specification from the device tree node
gpio_is_ready_dt() - Checks if the GPIO device is ready before use
gpio_pin_configure_dt() - Configures the pin with the specified flags
GPIO_INPUT - Flag to configure the pin as input
gpio_pin_get_dt() - Reads the current state of the input pin

cptel

Received the pin state & pin # - cool stuff…
[00:00:08.264,099] <inf> PWL: GPIO: 0×0000001A, Pin state: 0×00000000

Question:
1) I do not see a VCC or GND available on the IO Pinouts. Thoughts on how to pull the pin high/low to test interrupt?
1.a) One thought: I can use one of the other pins - ex: set P0.30 to Output and set the value (High/Low) accordingly, jumper the two and check the value on P0.26.

2) If you agree, it would be great if you can provide a similar sample of ‘STEP 1’ to configure P0.30 as output and corresponding STEP 2 (as you did above).

3) Can you provide modification to STEP #1 on how I can configure additional pins as INPUT? I would like to configure pins P0.27, P0.28 and P0.29 as INPUT

jaredwolff

Give this a go. I also added P0.26 as an interrupt instead of polling.

Updated Device Tree (same as before)

/ {
    gpio_test {
        compatible = "gpio-keys";
        
        // Input pin with interrupt capability
        input_pin_26: input_pin_26 {
            gpios = <&gpio0 26 GPIO_ACTIVE_HIGH>;
            label = "Input Pin 26";
        };
        
        // Other input pins (polling)
        input_pin_27: input_pin_27 {
            gpios = <&gpio0 27 GPIO_ACTIVE_HIGH>;
            label = "Input Pin 27";
        };
        
        input_pin_28: input_pin_28 {
            gpios = <&gpio0 28 GPIO_ACTIVE_HIGH>;
            label = "Input Pin 28";
        };
        
        input_pin_29: input_pin_29 {
            gpios = <&gpio0 29 GPIO_ACTIVE_HIGH>;
            label = "Input Pin 29";
        };
        
        // Output pin for testing
        output_pin_30: output_pin_30 {
            gpios = <&gpio0 30 GPIO_ACTIVE_HIGH>;
            label = "Output Pin 30";
        };
    };
};

Updated C Code with Interrupt Support

#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>

// GPIO specifications
static const struct gpio_dt_spec input_gpio_26 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_26), gpios);
static const struct gpio_dt_spec input_gpio_27 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_27), gpios);
static const struct gpio_dt_spec input_gpio_28 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_28), gpios);
static const struct gpio_dt_spec input_gpio_29 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_29), gpios);
static const struct gpio_dt_spec output_gpio_30 = GPIO_DT_SPEC_GET(DT_NODELABEL(output_pin_30), gpios);

// Interrupt callback data structure
static struct gpio_callback button_cb_data;

// Counter for interrupt events
static volatile uint32_t interrupt_count = 0;
static volatile int last_pin_state = -1;

// Interrupt callback function
void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
    // Read the current state of the pin
    int current_state = gpio_pin_get_dt(&input_gpio_26);
    
    interrupt_count++;
    last_pin_state = current_state;
    
    printk("[INTERRUPT %d] P0.26 changed to: %d (Pin mask: 0x%08X)\n", 
           interrupt_count, current_state, pins);
}

int main(void)
{
    int ret;

    // Check if all GPIO devices are ready
    if (!gpio_is_ready_dt(&input_gpio_26) || 
        !gpio_is_ready_dt(&input_gpio_27) ||
        !gpio_is_ready_dt(&input_gpio_28) ||
        !gpio_is_ready_dt(&input_gpio_29) ||
        !gpio_is_ready_dt(&output_gpio_30)) {
        printk("Error: One or more GPIO devices are not ready\n");
        return -1;
    }

    // Configure P0.26 as input with interrupt capability
    ret = gpio_pin_configure_dt(&input_gpio_26, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.26 as input\n", ret);
        return ret;
    }

    // Configure interrupt on P0.26 for both rising and falling edges
    ret = gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_BOTH);
    if (ret < 0) {
        printk("Error %d: failed to configure interrupt on P0.26\n", ret);
        return ret;
    }

    // Initialize and add the callback
    gpio_init_callback(&button_cb_data, button_pressed, BIT(input_gpio_26.pin));
    ret = gpio_add_callback(input_gpio_26.port, &button_cb_data);
    if (ret < 0) {
        printk("Error %d: failed to add callback\n", ret);
        return ret;
    }

    // Configure other input pins (polling mode)
    ret = gpio_pin_configure_dt(&input_gpio_27, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.27 as input\n", ret);
        return ret;
    }

    ret = gpio_pin_configure_dt(&input_gpio_28, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.28 as input\n", ret);
        return ret;
    }

    ret = gpio_pin_configure_dt(&input_gpio_29, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.29 as input\n", ret);
        return ret;
    }

    // Configure output pin
    ret = gpio_pin_configure_dt(&output_gpio_30, GPIO_OUTPUT_INACTIVE);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.30 as output\n", ret);
        return ret;
    }

    printk("GPIO configuration complete!\n");
    printk("P0.26: Input with interrupt (both edges)\n");
    printk("P0.27-29: Input with polling\n");
    printk("P0.30: Output for testing\n");
    printk("Connect P0.30 to P0.26 to test interrupts\n");
    printk("========================================\n");
    
    bool output_state = false;
    uint32_t loop_count = 0;
    
    while (1) {
        // Toggle output pin
        gpio_pin_set_dt(&output_gpio_30, output_state);

        // Read polling inputs (P0.27-29)
        int pin_27_state = gpio_pin_get_dt(&input_gpio_27);
        int pin_28_state = gpio_pin_get_dt(&input_gpio_28);
        int pin_29_state = gpio_pin_get_dt(&input_gpio_29);

        // Read interrupt pin for comparison
        int pin_26_current = gpio_pin_get_dt(&input_gpio_26);

        loop_count++;
        printk("[POLL %d] P0.30: %d | P0.26: %d | P0.27: %d | P0.28: %d | P0.29: %d | IRQ Count: %d\n", 
               loop_count, output_state, pin_26_current, pin_27_state, pin_28_state, pin_29_state, interrupt_count);

        // Toggle for next iteration
        output_state = !output_state;
        k_sleep(K_MSEC(2000));
    }

    return 0;
}

Key Changes for Interrupt Support:

1. Interrupt Configuration

// Configure interrupt on both rising and falling edges
ret = gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_BOTH);

2. Callback Setup

// Initialize callback structure
gpio_init_callback(&button_cb_data, button_pressed, BIT(input_gpio_26.pin));

// Add callback to GPIO port
gpio_add_callback(input_gpio_26.port, &button_cb_data);

3. Interrupt Handler

void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
    // This function executes in interrupt context
    int current_state = gpio_pin_get_dt(&input_gpio_26);
    interrupt_count++;
    printk("[INTERRUPT] P0.26 changed to: %d\n", current_state);
}

Interrupt Configuration Options:

You can configure different interrupt triggers:

// Rising edge only
gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_RISING);

// Falling edge only  
gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_FALLING);

// Both edges (as used above)
gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_BOTH);

// Level triggered (high)
gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_LEVEL_HIGH);

// Level triggered (low)
gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_LEVEL_LOW);

Expected Output:

When you connect P0.30 to P0.26, you should see:

[POLL 1] P0.30: 0 | P0.26: 0 | P0.27: 0 | P0.28: 0 | P0.29: 0 | IRQ Count: 0
[INTERRUPT 1] P0.26 changed to: 1 (Pin mask: 0x04000000)
[POLL 2] P0.30: 1 | P0.26: 1 | P0.27: 0 | P0.28: 0 | P0.29: 0 | IRQ Count: 1
[INTERRUPT 2] P0.26 changed to: 0 (Pin mask: 0x04000000)
[POLL 3] P0.30: 0 | P0.26: 0 | P0.27: 0 | P0.28: 0 | P0.29: 0 | IRQ Count: 2

Important Notes:

Interrupt Context: The callback runs in interrupt context, so keep it short and avoid blocking operations. If you need to do further operations use something like a semaphore or kick of a worker task to complete
Thread Safety: Use volatile for variables accessed in both interrupt and main contexts

jaredwolff

Also if you flip the board on the backside. It has all the labels for the pins. Including the 3.3V pin and GND.

cptel

jaredwolff this helps - thx!

cptel

All of this works and now I have better understanding of setting IO/Peripherals (fingers crossed) as part of zephyr. Thanks again!

Interesting note: turning LED ON/OFF during IO ISR callback routine freezes (assuming some internal hangup). I am using LEDs in ISR callback for debug purpose only, but interested in your feedback why it freezes up the firmware. When below LEDs are called from non-ISR routine, they work as expected.

Step 1

static const struct device *m_led = DEVICE_DT_GET(DT_NODELABEL(npm1300_leds));

Step 2

// Blue ON led_off(m_led, 0U); led_off(m_led, 1U); led_off(m_led, 2U); led_on(m_led, 2U);
l

jaredwolff

cptel you can’t call the I2C peripheral from an interrupt context. You’ll need to call it from a worker or main thread.

#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>

// GPIO specifications
static const struct gpio_dt_spec input_gpio_26 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_26), gpios);
static const struct gpio_dt_spec input_gpio_27 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_27), gpios);
static const struct gpio_dt_spec input_gpio_28 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_28), gpios);
static const struct gpio_dt_spec input_gpio_29 = GPIO_DT_SPEC_GET(DT_NODELABEL(input_pin_29), gpios);
static const struct gpio_dt_spec output_gpio_30 = GPIO_DT_SPEC_GET(DT_NODELABEL(output_pin_30), gpios);

// Interrupt callback data structure
static struct gpio_callback button_cb_data;

// Work structure and data
struct gpio_work_data {
    struct k_work work;
    uint32_t pin_mask;
    int pin_state;
    uint64_t timestamp;
};

// Counter for interrupt events
static volatile uint32_t interrupt_count = 0;

// Work item instance with initialization using macro
static struct gpio_work_data gpio_work;

// Work handler function - runs in system work queue thread context
static void gpio_work_handler(struct k_work *work)
{
    struct gpio_work_data *work_data = CONTAINER_OF(work, struct gpio_work_data, work);
    
    printk("=== WORK THREAD PROCESSING ===\n");
    printk("Timestamp: %llu ms\n", work_data->timestamp);
    printk("Pin mask: 0x%08X\n", work_data->pin_mask);
    printk("Pin state: %d\n", work_data->pin_state);
    printk("Interrupt count: %u\n", interrupt_count);
    
    // Simulate some work that takes time
    printk("Processing... (simulating 500ms work)\n");
    k_sleep(K_MSEC(500));
    
    // Re-read the pin to see if it changed during processing
    int current_state = gpio_pin_get_dt(&input_gpio_26);
    printk("Pin state after processing: %d\n", current_state);
    
    printk("Work complete!\n");
    printk("==============================\n");
}

// Interrupt callback function - runs in interrupt context (keep minimal!)
void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
    // Increment counter (atomic operation)
    interrupt_count++;
    
    // Read pin state quickly
    int current_state = gpio_pin_get_dt(&input_gpio_26);
    
    // Prepare work data
    gpio_work.pin_mask = pins;
    gpio_work.pin_state = current_state;
    gpio_work.timestamp = k_uptime_get();
    
    // Submit work to system work queue (non-blocking)
    k_work_submit(&gpio_work.work);
    
    // Quick interrupt acknowledgment print (minimal processing)
    printk("[IRQ %u] P0.26 -> %d (queued work)\n", interrupt_count, current_state);
}

int main(void)
{
    int ret;

    printk("Initializing GPIO with Work Queue Example\n");

    // Initialize work item using the init macro
    k_work_init(&gpio_work.work, gpio_work_handler);

    // Check if all GPIO devices are ready
    if (!gpio_is_ready_dt(&input_gpio_26) || 
        !gpio_is_ready_dt(&input_gpio_27) ||
        !gpio_is_ready_dt(&input_gpio_28) ||
        !gpio_is_ready_dt(&input_gpio_29) ||
        !gpio_is_ready_dt(&output_gpio_30)) {
        printk("Error: One or more GPIO devices are not ready\n");
        return -1;
    }

    // Configure P0.26 as input with interrupt capability
    ret = gpio_pin_configure_dt(&input_gpio_26, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.26 as input\n", ret);
        return ret;
    }

    // Configure interrupt on P0.26 for both rising and falling edges
    ret = gpio_pin_interrupt_configure_dt(&input_gpio_26, GPIO_INT_EDGE_BOTH);
    if (ret < 0) {
        printk("Error %d: failed to configure interrupt on P0.26\n", ret);
        return ret;
    }

    // Initialize and add the callback
    gpio_init_callback(&button_cb_data, button_pressed, BIT(input_gpio_26.pin));
    ret = gpio_add_callback(input_gpio_26.port, &button_cb_data);
    if (ret < 0) {
        printk("Error %d: failed to add callback\n", ret);
        return ret;
    }

    // Configure other input pins (polling mode)
    ret = gpio_pin_configure_dt(&input_gpio_27, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.27 as input\n", ret);
        return ret;
    }

    ret = gpio_pin_configure_dt(&input_gpio_28, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.28 as input\n", ret);
        return ret;
    }

    ret = gpio_pin_configure_dt(&input_gpio_29, GPIO_INPUT);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.29 as input\n", ret);
        return ret;
    }

    // Configure output pin
    ret = gpio_pin_configure_dt(&output_gpio_30, GPIO_OUTPUT_INACTIVE);
    if (ret < 0) {
        printk("Error %d: failed to configure P0.30 as output\n", ret);
        return ret;
    }

    printk("GPIO configuration complete!\n");
    printk("P0.26: Input with interrupt -> work queue processing\n");
    printk("P0.27-29: Input with polling\n");
    printk("P0.30: Output for testing\n");
    printk("Connect P0.30 to P0.26 to test interrupt + work queue\n");
    printk("=========================================================\n");
    
    bool output_state = false;
    uint32_t loop_count = 0;
    
    while (1) {
        // Toggle output pin
        gpio_pin_set_dt(&output_gpio_30, output_state);

        // Read polling inputs (P0.27-29)
        int pin_27_state = gpio_pin_get_dt(&input_gpio_27);
        int pin_28_state = gpio_pin_get_dt(&input_gpio_28);
        int pin_29_state = gpio_pin_get_dt(&input_gpio_29);

        // Read interrupt pin for comparison
        int pin_26_current = gpio_pin_get_dt(&input_gpio_26);

        loop_count++;
        printk("[MAIN %u] P0.30: %d | P0.26: %d | P0.27: %d | P0.28: %d | P0.29: %d | IRQ: %u\n", 
               loop_count, output_state, pin_26_current, pin_27_state, pin_28_state, pin_29_state, interrupt_count);

        // Toggle for next iteration
        output_state = !output_state;
        k_sleep(K_MSEC(3000)); // Longer delay to see work processing
    }

    return 0;
}

Make sure that you pick the same thread for all your I2C writes/reads or else you’ll get more runtime faults.

cptel

jaredwolff that makes sense. I should’ve looked at it more carefully to realize its an I2C communication between PMIC & 9151 that’s driving the LED

jaredwolff

cptel yup it’s misleading. Zephyr is good at abstracting all the layers of complexity 😆