Hi there,
Currently we are developing our own system to drive WS2812B LED's using the NRFX pwm library. And the coloring and signaling works fine when it is in a bare metal mode, however once the I wish to loop over the nrfx_pwm_simple_playback(); function and update the sequence values in time, either within the main function and a separate thread, it fails with p_cb->state = NRFX_DRV_STATE_UNINITIALIZED, or an error code, indicating the initialisation is broken even though i have already initialised it in teh beginning. I have tried initialising the PWM on each loop however my assert(status == NRFX_SUCCESS) ends up failing.
I have used the code from the nrfx_pwm_common_example, I believe it is an issue to do with the nrfx driver mechanism or how I am integrating it into zephyr, but I cannot seem to find the issue, looking for some guidance please.
/* * 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 <zephyr/drivers/pwm.h> #include <zephyr/kernel.h> #include <zephyr/sys/printk.h> #include "drivers/nrfx_errors.h" #include <nrfx_glue.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 /** * @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 /** @brief Array with duty cycle values. */ // 6 is high , 13 is low -> logic is inverted for this PWM 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 }; 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 }; nrf_pwm_values_common_t reset_seq [55] = {0}; nrf_pwm_values_common_t pwm_array_val [192] = {0}; 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; } 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--){ if((red&(0x80>>i))){ val[i + 8] = 6; } else { val[i + 8] = 14; } if((blue&(0x80>>i))){ val[i + 16] = 6; } else { val[i + 16] = 14; } //val[i + 15] |= 1<<15; if((green&(0x80>>i))){ val[i] = 6; } else { val[i] = 14; } } return; } void thread0(void) { nrfx_pwm_t pwm_instance1 = NRFX_PWM_INSTANCE(PWM_INST_IDX); nrf_pwm_sequence_t seq_set1 = { .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); colour_sequence(pwm_val, 0x00, 0x0F, 0x00); ledarraybuild(pwm_array_val, 2, pwm_val); colour_sequence(pwm_val, 0x00, 0x0F, 0x00); ledarraybuild(pwm_array_val, 4, pwm_val); //LOG_HEXDUMP_INF(pwm_array_val, sizeof(pwm_array_val),"Thread0 Data"); k_mutex_unlock(&key); } } void thread1(void) { nrfx_pwm_t pwm_instance2 = NRFX_PWM_INSTANCE(PWM_INST_IDX); nrf_pwm_sequence_t seq_set2 = { .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); colour_sequence(pwm_val, 0x00, 0x00, 0x0F); ledarraybuild(pwm_array_val, 3, pwm_val); k_mutex_unlock(&key); } } /** * @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. */ static void pwm_handler(nrfx_pwm_evt_type_t event_type, void * p_context) { nrfx_pwm_t * inst = p_context; 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++; } /** * @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_t pwm_instance = NRFX_PWM_INSTANCE(PWM_INST_IDX); //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); k_mutex_lock(&key, K_FOREVER); for(int i = 0; i <8; i++){ nrfx_pwm_simple_playback(&pwm_instance, &seq_set, PLAYBACK_COUNT, NRFX_PWM_FLAG_LOOP); } k_mutex_unlock(&key); k_msleep(2000); } } /** @} */