PDM code implementation and testing

RE: PDM code implementation and testing

sara — Wed, 07 Aug 2019 07:29:11 GMT

Thanks a lot, Overbekk and Haakonsh for your support!

RE: PDM code implementation and testing

ovrebekk — Wed, 07 Aug 2019 07:15:46 GMT

That's great news, the best of luck with your project 🙂

RE: PDM code implementation and testing

sara — Tue, 06 Aug 2019 12:39:33 GMT

Hello,

Now able to get data by storing a burst of data in a buffer.

Thank you so much for your support Overbekk.

RE: PDM code implementation and testing

ovrebekk — Tue, 06 Aug 2019 08:06:38 GMT

The problem of printing the data live is that we are talking about a raw data stream of 256kbps.

This is technically possible to output on the UART if you use a high baudrate (460800 or more is probably needed), but you will have to display the data as raw data, not as hex. Some terminal programs might be able to show you the data in decimal or hex form, but not all will do this.

Have you considered storing a burst of data in a buffer that you can analyze afterwards?

Either you can use the debugger to inspect the data in the buffer, or you can output the buffer to UART once you have filled it up (then you don't have to worry about how much time it takes to empty the buffer, since you are not writing to the UART live).

Best regards
Torbjørn

RE: PDM code implementation and testing

sara — Mon, 05 Aug 2019 11:29:32 GMT

hello, Ovrebekk.

I need data because I want to validate the MIC data. Is there any other way to validate PDM MIC data?

RE: PDM code implementation and testing

sara — Mon, 05 Aug 2019 07:29:12 GMT

Thank you soo much Ovrebekk, the code which you gave is working for me now. But now just working on data as I need all the data and printing all the data does not work. So if you have any alternative for it do help.

RE: PDM code implementation and testing

sara — Sat, 03 Aug 2019 11:05:43 GMT

Hi,

Thank you, initially I had tried with the SDK PDM but in that I was not able to get the clock so I switched with this code. And now out due to weekend so will try out your code on Monday. And if I want all the data then what should I do?? And wich MIC have you interfaced with the nrf52? I have to use the INvensense MIC ICS -41352

RE: PDM code implementation and testing

ovrebekk — Fri, 02 Aug 2019 15:20:16 GMT

Hi Sara

Any particular reason you are not using the PDM driver provided with the SDK?

I tried to add the PDM driver to the ble_app_uart example, and was able to get it running very quickly. I can print out parts of the PDM data without any issues (I didn't try to print out all the data, as this might be too much for the UART to handle).

You can download my project here if you want to have a look:
ble_app_uart_pdmtest.zip

Best regards
Torbjørn

RE: PDM code implementation and testing

sara — Thu, 01 Aug 2019 11:09:13 GMT

Hi, i had made the interrupt priorities changes as below , but still my device resets and goes into Fatal error.

#ifndef NRFX_UART_DEFAULT_CONFIG_IRQ_PRIORITY
#define NRFX_UART_DEFAULT_CONFIG_IRQ_PRIORITY 5
#endif

#ifndef PDM_CONFIG_IRQ_PRIORITY
#define PDM_CONFIG_IRQ_PRIORITY 7
#endif

RE: PDM code implementation and testing

ovrebekk — Wed, 31 Jul 2019 14:32:43 GMT

Hi Sara

I don't think the UART driver is very happy if you try to access the driver from a high priority interrupt.

Could you try to reduce the interrupt priority of the PDM interrupt handler and see if it works better?

A higher IRQ priority number corresponds to lower interrupt priority, with 7 being the lowest and 0 the highest.

Best regards
Torbjørn

RE: PDM code implementation and testing

sara — Tue, 30 Jul 2019 12:21:48 GMT

For me, only the data matters that is how to read the PDM data either on a terminal or from RAM anything will do.You can guide me on either way but need the PDM data.

RE: PDM code implementation and testing

sara — Tue, 30 Jul 2019 12:04:05 GMT

Thanks, Torbjorn

Yes, I want to echo the data which i receive from the PDM which will be PCM data(I guess).

I was using ble_app_template example code but since I was not getting PDM clock I had removed everything from it and had only kept the PDM related functions.

For the Uarte code when I had used the code given to me the board was rebooting. But then while I was debugging when I ad only initialised uarte, I got to know it hangs in the while condition of the below code :

static void serial_tx(void const * p_context, char const * p_buffer, size_t len)
{
uint8_t len8 = (uint8_t)(len & 0x000000FF);
m_xfer_done = false;
ret_code_t err_code = nrf_drv_uart_tx(&m_uart, (uint8_t *)p_buffer, len8);
APP_ERROR_CHECK(err_code);
/* wait for completion since buffer is reused*/
while (m_async_mode && (m_xfer_done == false))
{

}

And I am attaching the code when system enters fatal error when I try transmitting data on terminal in PDM handler..

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "fds.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "sensorsim.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "boards.h"
#include "nrf_gpio.h"
#include "app_scheduler.h"


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

#include "nrf_drv_pdm.h"
#include "nrf_fstorage.h"
#include "nrf_fstorage_sd.h"
#include "drv_audio.h"
#include "app_uart.h"
#include "nrfx_uarte.h"



#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

#define DEVICE_NAME                     "Nordic_Template"                       /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME               "NordicSemiconductor"                   /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_ADV_INTERVAL                 1600//300                                     /**< The advertising interval (in units of 0.625 ms. This value corresponds to 187.5 ms). */

#define APP_ADV_DURATION                500//18000                                   /**< The advertising duration (180 seconds) in units of 10 milliseconds. */
#define APP_BLE_OBSERVER_PRIO           3                                       /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG            1                                       /**< A tag identifying the SoftDevice BLE configuration. */

#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(100, UNIT_1_25_MS)        /**< Minimum acceptable connection interval (0.1 seconds). */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(200, UNIT_1_25_MS)        /**< Maximum acceptable connection interval (0.2 second). */
#define SLAVE_LATENCY                   0                                       /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)         /**< Connection supervisory timeout (4 seconds). */

#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                   /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000)                  /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                       /**< Number of attempts before giving up the connection parameter negotiation. */

#define SEC_PARAM_BOND                  1                                       /**< Perform bonding. */
#define SEC_PARAM_MITM                  0                                       /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC                  0                                       /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS              0                                       /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES       BLE_GAP_IO_CAPS_NONE                    /**< No I/O capabilities. */
#define SEC_PARAM_OOB                   0                                       /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE          7                                       /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE          16                                      /**< Maximum encryption key size. */

#define DEAD_BEEF                       0xDEADBEEF                              /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */


#define CONFIG_PDM_BUFFER_SIZE_SAMPLES 64//320

// <o> PDM Decimation Filter Gain <0x00-0x50>
// <i> For details on the PDM decimation filter, see the 'Decimation filter' section in the nRF52 Product Specification document.
//#define CONFIG_PDM_GAIN 0x28
//
//
//// <o> PDM CLK Pin
//#define CONFIG_IO_PDM_CLK  29
//
//// <o> PDM DATA Pin
//#define CONFIG_IO_PDM_DATA   5 //0x05

// <o> PDM Microphone Power Control Pin
#define CONFIG_IO_PDM_MIC_PWR_CTRL 0x1A


//
//typedef struct
//{
//    uint8_t buffer[CONFIG_AUDIO_FRAME_SIZE_BYTES];
//    int     buffer_size;
//    bool    buffer_free_flag;
//} drv_audio_frame_t;

unsigned char enabled = 0;
/**@brief Audio buffer handler. */
typedef void (*drv_audio_buffer_handler_t)(int16_t *p_buffer, uint16_t samples);

static int16_t                      input_pdm_buff[2][CONFIG_PDM_BUFFER_SIZE_SAMPLES];
//volatile drv_audio_frame_t       m_audio_frame[CONFIG_AUDIO_FRAME_BUFFERS];

static int32_t                      *output_pdm_buff;
static drv_audio_buffer_handler_t   m_buffer_handler;
//uint16_t			m_frame_index = 0;
//uint16_t                        m_next_frame_index = 0;
static app_sched_event_handler_t        m_audio_frame_handler = NULL;


const uint8_t leds_list[LEDS_NUMBER] = LEDS_LIST;
void startDMA();


/**@brief  Function for initializing the UART module.
 */
/**@snippet [UART Initialization] */
//nrfx_uarte uarte0 = NRFX_UARTE_INSTANCE(0);

nrfx_uarte_t uarte0 = NRFX_UARTE_INSTANCE(0);
void uarte_handler(nrfx_uarte_event_t const * p_event, void *p)
{
    //Handle uarte events if needed
}

void uarte_init(void)
{
    nrfx_err_t err_code = NRFX_SUCCESS;
    nrfx_uarte_config_t uarte_cfg = NRFX_UARTE_DEFAULT_CONFIG; //Set config in sd_config.h
    
//    err_code = nrfx_uarte_init(&uarte0, &uarte_cfg, uarte_handler);
//    APP_ERROR_CHECK(err_code);
  
//    uint8_t txBuffer[20];
//    uint8_t rxBuffer[20];
//    
//    memset(txBuffer,'A',sizeof(txBuffer));
//
    NRF_UARTE0->BAUDRATE = NRF_UARTE_BAUDRATE_115200;
    NRF_UARTE0->PSEL.TXD = TX_PIN_NUMBER;
    NRF_UARTE0->PSEL.RXD = RX_PIN_NUMBER;
    NRF_UARTE0->CONFIG = NRF_UARTE_HWFC_DISABLED;
    NRF_UARTE0->ENABLE = (UARTE_ENABLE_ENABLE_Enabled << UARTE_ENABLE_ENABLE_Pos);

//    NRF_UARTE0->TXD.PTR = (uint32_t)((uint8_t *) txBuffer);
//    NRF_UARTE0->TXD.MAXCNT = sizeof(txBuffer);
//    NRF_UARTE0->TASKS_STARTTX = 0;
//
//    NRF_UARTE0->RXD.PTR = (uint32_t)((uint8_t *) rxBuffer);
//    NRF_UARTE0->RXD.MAXCNT = sizeof(rxBuffer);
//    NRF_UARTE0->TASKS_STARTRX = 1;
//    NRF_UARTE0->TASKS_STARTTX = 1;


    NRF_UARTE0->INTENCLR = 0xFFFFFFFF;
    NRF_UARTE0->INTENSET = NRF_UARTE_INT_ENDRX_MASK;

    NVIC_ClearPendingIRQ(UARTE0_UART0_IRQn);
    NVIC_SetPriority(UARTE0_UART0_IRQn, 1);
    NVIC_EnableIRQ(UARTE0_UART0_IRQn);
//
//
//    LEDS_CONFIGURE(LEDS_MASK);
//    LEDS_OFF(LEDS_MASK);
//    if(NRF_UARTE0->EVENTS_RXSTARTED){
//        LEDS_INVERT(1 << leds_list[1]);
//    }



}


/**@brief Function for initializing the nrf log module.
 */
static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}




//static void nrf52_pdm_irq(void)
//{
//    // Simply pass on to the driver component handler.
////    if (nrf52_pdm_driver)
////        nrf52_pdm_driver->irq();
//      irq();
//}

/**
 * Constructor for an instance of a PDM input (typically microphone),
 *
 * @param sd The pin the PDM data input is connected to.
 * @param sck The pin the PDM clock is conected to.
 * @param sampleRate the rate at which samples are generated in the output buffer (in Hz)
 * @param id The id to use for the message bus when transmitting events.
 */
//                


#define BUFFER_SIZE  64

void startDMA()
{

//   NRF_LOG_INFO("startDMA   \n");   
   NRF_PDM->SAMPLE.PTR = (uint32_t)&input_pdm_buff[0];
}

void pdm_enable()
{
    if (!enabled)
    {
        enabled = true;

        NRF_PDM->ENABLE = 1;

        startDMA();

        NRF_PDM->TASKS_START = 1;
//        NRF_PDM->EVENTS_STARTED = 1;
    }
}

/**
 * Disable this component
 */
void pdm_disable()
{
    // Schedule all DMA transfers to stop after the next DMA transaction completes.
    enabled = false;
    NRF_PDM->ENABLE = 0;
//    NRF_PDM->TASKS_START = 1;
//    NRF_PDM->EVENTS_STOPPED = 0;
//    NRF_PDM_TASK_STOP = 0;
}



void PDM_IRQHandler()
{

//    NRF_LOG_INFO(" INTERRUPT HANDLER \n"); 
    if (NRF_PDM->EVENTS_STARTED) 
    {
//         NRF_LOG_INFO(" EVENTS_STARTED \n"); 
        // We've just started receiving data the inputBuffer.
        // So we don't miss any data, line up the next buffer.
        // (unless we've been asked to stop).
        if (enabled)
        {
          uint16_t *finished_buffer;
          finished_buffer = input_pdm_buff[0];
          nrfx_uarte_tx(&uarte0, &input_pdm_buff, CONFIG_AUDIO_FRAME_SIZE_BYTES);
          startDMA();

          NRF_PDM->EVENTS_STARTED = 0;
        }
    }

    if (NRF_PDM->EVENTS_END)
    {
//      NRF_LOG_INFO(" EVENTS_END \n"); 
//        if (outputBuffer.length() > 0)
//            output.pullRequest();

        NRF_PDM->EVENTS_END = 0;
    }

    if (NRF_PDM->EVENTS_STOPPED)
    NRF_LOG_INFO(" EVENTS_STOPPED \n"); 
        NRF_PDM->EVENTS_STOPPED = 0;

    // Erratum.
    // JF: Not sure what this is working around? Seems harmless, so leaving it in for now...
    (void) NRF_PDM->EVENTS_STOPPED;
    
}

void pdm_init()
{
   
    // Define our output stream as non-bocking.
//    output.setBlocking(false);

   
    pdm_disable();
  
    nrf_gpio_cfg_output(CONFIG_IO_PDM_CLK);
    nrf_gpio_cfg_input(CONFIG_IO_PDM_DATA,NRF_GPIO_PIN_NOPULL);

    // Map the PDM peripheral onto the given pins...
    NRF_PDM->PSEL.CLK = CONFIG_IO_PDM_CLK;
//    pdm_cfg.edge = NRF_PDM_EDGE_LEFTRISING;
//   nrf_pdm_mode_set(nrf_pdm_mode_t pdm_mode, nrf_pdm_edge_t pdm_edge)

     NRF_PDM->MODE = ((PDM_CONFIG_MODE << PDM_MODE_OPERATION_Pos) & PDM_MODE_OPERATION_Msk)
                    | ((NRF_PDM_EDGE_LEFTRISING << PDM_MODE_EDGE_Pos) & PDM_MODE_EDGE_Msk);


    NRF_PDM->PSEL.DIN = CONFIG_IO_PDM_DATA;

    // Configure for DMA enabled, single channel PDM input.
//  NVIC_SetVector(PDM_IRQn, (uint32_t )nrf52_pdm_irq);

    /* Set up interrupts */
    NRF_PDM->INTENSET = (PDM_INTENSET_STARTED_Enabled << PDM_INTENSET_STARTED_Pos) |
        (PDM_INTENSET_END_Enabled << PDM_INTENSET_END_Pos ) |
        (PDM_INTENSET_STOPPED_Enabled << PDM_INTENSET_STOPPED_Pos);

    NVIC_SetPriority( PDM_IRQn, 1);
    NVIC_ClearPendingIRQ( PDM_IRQn );
    NVIC_EnableIRQ( PDM_IRQn );


    // Configure for a 1.032MHz PDM clock.
    NRF_PDM->PDMCLKCTRL = (PDM_PDMCLKCTRL_FREQ_Default << PDM_PDMCLKCTRL_FREQ_Pos );

    // Mono operation.
    NRF_PDM->MODE = ( PDM_MODE_EDGE_LeftRising  << PDM_MODE_EDGE_Pos ) |
        (PDM_MODE_OPERATION_Mono << PDM_MODE_OPERATION_Pos);

    // Set default gain of 0dbm.
    NRF_PDM->GAINL = CONFIG_AUDIO_PDM_GAIN;
    NRF_PDM->GAINR = CONFIG_AUDIO_PDM_GAIN;


    // Configure buffer size.
   
    NRF_PDM->SAMPLE.PTR = (uint32_t)&input_pdm_buff[0];
    NRF_PDM->SAMPLE.MAXCNT = CONFIG_PDM_BUFFER_SIZE_SAMPLES;
    pdm_enable();

    // Record our sample rate for future computation.
    // This is a constant of the PDM samplerate / 64 (as defined in nrf52 specification, seciton 44).
    // For the configuration above, this translates to approx 16kHz.
//    this->sampleRate = 1032000 / 64;
}



   




/**
 * Initiate a DMA transfer into the raw data buffer.
 */

static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for application main entry.
 */
int main(void)
{
   // Start execution.

 
    log_init();
//

    uarte_init();
//      uart_init();

    NRF_LOG_INFO("Template example started.");
    pdm_init();
    

for (;;)
    {
        idle_state_handle();
    }
  
}




/**
 * Update our reference to a downstream component.
 * Pass through any connect requests to our output buffer component.
 *
 * @param component The new downstream component for this PDM audio source.
 */


//static NRF52PDM *nrf52_pdm_driver = NULL;

RE: PDM code implementation and testing

ovrebekk — Tue, 30 Jul 2019 11:46:40 GMT

Håkon is currently out in vacation, and I will help out with your case in the meantime.

If I understand correctly you simply want to echo all the data you receive over the PWM onto the UART interface?

If so I agree with Håkon's suggestion above to use the nrfx_uarte driver, except that the uarte_handler function is implemented incorrectly in his code snippet. It should look like this:

void uarte_handler(nrfx_uarte_event_t const * p_event, void *p)
{
    //Handle uarte events if needed
}

Can you send me the code snippet that makes the system reset?

Are you using the template project in the SDK as the starting point, or something else?

Best regards
Torbjørn

RE: PDM code implementation and testing

sara — Mon, 29 Jul 2019 09:24:50 GMT

For your reference,

static int16_t                      input_pdm_buff[2][CONFIG_PDM_BUFFER_SIZE_SAMPLES];
//volatile drv_audio_frame_t       m_audio_frame[CONFIG_AUDIO_FRAME_BUFFERS];

static int32_t                      *output_pdm_buff;
static drv_audio_buffer_handler_t   m_buffer_handler;
//uint16_t			m_frame_index = 0;
//uint16_t                        m_next_frame_index = 0;
static app_sched_event_handler_t        m_audio_frame_handler = NULL;


const uint8_t leds_list[LEDS_NUMBER] = LEDS_LIST;


//void UARTE0_UART0_IRQHandler(){
//
//    if(NRF_UARTE0->EVENTS_ENDRX){
//        LEDS_INVERT(1 << leds_list[3]);
//    }
//
//}




/**@brief   Function for handling app_uart events.
 *
 * @details This function will receive a single character from the app_uart module and append it to
 *          a string. The string will be be sent over BLE when the last character received was a
 *          'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
 */
/**@snippet [Handling the data received over UART] */
void uart_event_handle(app_uart_evt_t * p_event)
{
    static uint8_t data_array[CONFIG_PDM_BUFFER_SIZE_SAMPLES];
    static uint8_t index = 0;
    uint32_t       err_code;

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            index++;

            if ((data_array[index - 1] == '\n') ||
                (data_array[index - 1] == '\r') ||
                (index >= CONFIG_PDM_BUFFER_SIZE_SAMPLES))
            {
                if (index > 1)
                {
                    NRF_LOG_DEBUG("Ready to send data over BLE NUS");
                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);

//                    do
//                    {
//                        uint16_t length = (uint16_t)index;
//                        err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
//                        if ((err_code != NRF_ERROR_INVALID_STATE) &&
//                            (err_code != NRF_ERROR_RESOURCES) &&
//                            (err_code != NRF_ERROR_NOT_FOUND))
//                        {
//                            APP_ERROR_CHECK(err_code);
//                        }
//                    } while (err_code == NRF_ERROR_RESOURCES);
                }

                index = 0;
            }
            break;

        case APP_UART_COMMUNICATION_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_communication);
            break;

        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;

        default:
            break;
    }
}
/**@snippet [Handling the data received over UART] */



/**@brief  Function for initializing the UART module.
 */
/**@snippet [UART Initialization] */
//nrfx_uarte uarte0 = NRFX_UARTE_INSTANCE(0);

nrfx_uarte_t uarte0 = NRFX_UARTE_INSTANCE(0);
void uarte_handler(nrfx_uarte_evt_type_t evt)
{
    //Handle uarte events if needed
}

void uarte_init(void)
{
    nrfx_err_t err_code = NRFX_SUCCESS;
    nrfx_uarte_config_t uarte_cfg = NRFX_UARTE_DEFAULT_CONFIG; //Set config in sd_config.h
    
//    err_code = nrfx_uarte_init(&uarte0, &uarte_cfg, uarte_handler);
//    APP_ERROR_CHECK(err_code);
  
//    uint8_t txBuffer[20];
//    uint8_t rxBuffer[20];
//    
//    memset(txBuffer,'A',sizeof(txBuffer));
//
    NRF_UARTE0->BAUDRATE = NRF_UARTE_BAUDRATE_115200;
    NRF_UARTE0->PSEL.TXD = TX_PIN_NUMBER;
    NRF_UARTE0->PSEL.RXD = RX_PIN_NUMBER;
    NRF_UARTE0->CONFIG = NRF_UARTE_HWFC_DISABLED;
    NRF_UARTE0->ENABLE = (UARTE_ENABLE_ENABLE_Enabled << UARTE_ENABLE_ENABLE_Pos);

//    NRF_UARTE0->TXD.PTR = (uint32_t)((uint8_t *) txBuffer);
//    NRF_UARTE0->TXD.MAXCNT = sizeof(txBuffer);
//    NRF_UARTE0->TASKS_STARTTX = 0;
//
//    NRF_UARTE0->RXD.PTR = (uint32_t)((uint8_t *) rxBuffer);
//    NRF_UARTE0->RXD.MAXCNT = sizeof(rxBuffer);
//    NRF_UARTE0->TASKS_STARTRX = 1;
//    NRF_UARTE0->TASKS_STARTTX = 1;


    NRF_UARTE0->INTENCLR = 0xFFFFFFFF;
    NRF_UARTE0->INTENSET = NRF_UARTE_INT_ENDRX_MASK;

    NVIC_ClearPendingIRQ(UARTE0_UART0_IRQn);
    NVIC_SetPriority(UARTE0_UART0_IRQn, 1);
    NVIC_EnableIRQ(UARTE0_UART0_IRQn);
//
//
//    LEDS_CONFIGURE(LEDS_MASK);
//    LEDS_OFF(LEDS_MASK);
//    if(NRF_UARTE0->EVENTS_RXSTARTED){
//        LEDS_INVERT(1 << leds_list[1]);
//    }



}


/**@brief Function for initializing the nrf log module.
 */
static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}




//static void nrf52_pdm_irq(void)
//{
//    // Simply pass on to the driver component handler.
////    if (nrf52_pdm_driver)
////        nrf52_pdm_driver->irq();
//      irq();
//}

/**
 * Constructor for an instance of a PDM input (typically microphone),
 *
 * @param sd The pin the PDM data input is connected to.
 * @param sck The pin the PDM clock is conected to.
 * @param sampleRate the rate at which samples are generated in the output buffer (in Hz)
 * @param id The id to use for the message bus when transmitting events.
 */
//                


#define BUFFER_SIZE  64

  typedef struct ArrayList
  {
    uint8_t buffer[BUFFER_SIZE];
  } ArrayList_type;

 


void startDMA()
{

//    ArrayList_type ReaderList[63];
//      uint32_t i;
////    PDMREADER.MAXCNT = BUFFER_SIZE;
////    READER.PTR = &ReaderList;
////    PDM_SAMPLE_PTR_SAMPLEPTR_Pos 
//    NRF_PDM->SAMPLE.MAXCNT = BUFFER_SIZE;
//    NRF_PDM->SAMPLE.PTR = &ReaderList;
//    for(i=0;i<BUFFER_SIZE;i++)
//   {
//      NRF_LOG_INFO("ReaderList[%d] = %d ",i,ReaderList->buffer[i]);
//
//   }

//    uint32_t err_code;
//    err_code = drv_audio_init(m_audio_handler);
//    APP_ERROR_CHECK(err_code);


//    output_pdm_buff = &input_pdm_buff[0];
    uint32_t i;
    NRF_LOG_INFO("startDMA   \n");
//
//   
   NRF_PDM->SAMPLE.PTR = (uint32_t)&input_pdm_buff[0];
//   NRF_LOG_INFO("NRF_PDM->SAMPLE.PTR   =  %x ",NRF_PDM->SAMPLE.PTR );
   memcpy(output_pdm_buff, &input_pdm_buff[0],CONFIG_PDM_BUFFER_SIZE_SAMPLES);
   
//     for(i=0;i<CONFIG_PDM_BUFFER_SIZE_SAMPLES;i++)
//     {
//      NRF_LOG_INFO("m_audio_frame->buffer[%d] = %d ",i,output_pdm_buff[i]);
//
//
//     }



//     drv_audio_frame_t *p_frame;
//     app_sched_event_put(&p_frame, sizeof(drv_audio_frame_t *), m_audio_frame_handler);
//    NRF_PDM->SAMPLE.PTR = (uint32_t)&m_audio_frame[0];
//     memcpy(&(m_audio_frame->buffer), p_frame,CONFIG_AUDIO_FRAME_SIZE_BYTES);
//     uint32_t i;
//     for(i=0;i<CONFIG_AUDIO_FRAME_SIZE_BYTES;i++)
//     {
//      NRF_LOG_INFO("m_audio_frame->buffer[%d] = %d ",i,m_audio_frame->buffer[i]);
//
//
//     }


}
//
//
///**
// * Enable this component
// */
void pdm_enable()
{
    if (!enabled)
    {
        enabled = true;

        NRF_PDM->ENABLE = 1;

//        pdm_start();
//        startDMA();

        NRF_PDM->TASKS_START = 1;
    }
}

/**
 * Disable this component
 */
void pdm_disable()
{
    // Schedule all DMA transfers to stop after the next DMA transaction completes.
    enabled = false;
    NRF_PDM->ENABLE = 0;
}


void PDM_IRQHandler()
{
   
    if (NRF_PDM->EVENTS_STARTED) 
    {
        // We've just started receiving data the inputBuffer.
        // So we don't miss any data, line up the next buffer.
        // (unless we've been asked to stop).
//        m_xfer_done = true;
        nrfx_uarte_tx(&uarte0, &input_pdm_buff, CONFIG_AUDIO_FRAME_SIZE_BYTES);
        
          
        if (enabled)

        startDMA();

        NRF_PDM->EVENTS_STARTED = 0;
    }

    if (NRF_PDM->EVENTS_END)
    {
//        if (outputBuffer.length() > 0)
//            output.pullRequest();

        NRF_PDM->EVENTS_END = 0;
    }

    if (NRF_PDM->EVENTS_STOPPED)
        NRF_PDM->EVENTS_STOPPED = 0;

    // Erratum.
    // JF: Not sure what this is working around? Seems harmless, so leaving it in for now...
    (void) NRF_PDM->EVENTS_STOPPED;




    
}




void pdm_init()
{
   
    // Define our output stream as non-bocking.
//    output.setBlocking(false);

   
    pdm_disable();
  
    nrf_gpio_cfg_output(CONFIG_IO_PDM_CLK);
    nrf_gpio_cfg_input(CONFIG_IO_PDM_DATA,NRF_GPIO_PIN_NOPULL);

    // Map the PDM peripheral onto the given pins...
    NRF_PDM->PSEL.CLK = CONFIG_IO_PDM_CLK;
//    pdm_cfg.edge = NRF_PDM_EDGE_LEFTRISING;
//   nrf_pdm_mode_set(nrf_pdm_mode_t pdm_mode, nrf_pdm_edge_t pdm_edge)

     NRF_PDM->MODE = ((PDM_CONFIG_MODE << PDM_MODE_OPERATION_Pos) & PDM_MODE_OPERATION_Msk)
                    | ((NRF_PDM_EDGE_LEFTRISING << PDM_MODE_EDGE_Pos) & PDM_MODE_EDGE_Msk);


    NRF_PDM->PSEL.DIN = CONFIG_IO_PDM_DATA;

    // Configure for DMA enabled, single channel PDM input.
//  NVIC_SetVector(PDM_IRQn, (uint32_t )nrf52_pdm_irq);

    /* Set up interrupts */
    NRF_PDM->INTENSET = (PDM_INTENSET_STARTED_Enabled << PDM_INTENSET_STARTED_Pos) |
        (PDM_INTENSET_END_Enabled << PDM_INTENSET_END_Pos ) |
        (PDM_INTENSET_STOPPED_Enabled << PDM_INTENSET_STOPPED_Pos);

    NVIC_SetPriority( PDM_IRQn, 1);
    NVIC_ClearPendingIRQ( PDM_IRQn );
    NVIC_EnableIRQ( PDM_IRQn );


    // Configure for a 1.032MHz PDM clock.
    NRF_PDM->PDMCLKCTRL = (PDM_PDMCLKCTRL_FREQ_Default << PDM_PDMCLKCTRL_FREQ_Pos );

    // Mono operation.
    NRF_PDM->MODE = ( PDM_MODE_EDGE_LeftRising  << PDM_MODE_EDGE_Pos ) |
        (PDM_MODE_OPERATION_Mono << PDM_MODE_OPERATION_Pos);

    // Set default gain of 0dbm.
    NRF_PDM->GAINL = CONFIG_AUDIO_PDM_GAIN;
    NRF_PDM->GAINR = CONFIG_AUDIO_PDM_GAIN;


    // Configure buffer size.
   
    NRF_PDM->SAMPLE.PTR = &input_pdm_buff[0];
    NRF_PDM->SAMPLE.MAXCNT = CONFIG_PDM_BUFFER_SIZE_SAMPLES;
    pdm_enable();

    // Record our sample rate for future computation.
    // This is a constant of the PDM samplerate / 64 (as defined in nrf52 specification, seciton 44).
    // For the configuration above, this translates to approx 16kHz.
//    this->sampleRate = 1032000 / 64;
}



   




/**
 * Initiate a DMA transfer into the raw data buffer.
 */

static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for application main entry.
 */
int main(void)
{
   // Start execution.

 
    log_init();
//

    uarte_init();
//      uart_init();

    NRF_LOG_INFO("Template example started.");
    pdm_init();
    

for (;;)
    {
        idle_state_handle();
    }
  
}

devzone.nordicsemi.com/.../0456.sdk_5F00_config.h I am attaching my code and sdk_config.h file.

RE: PDM code implementation and testing

sara — Sat, 27 Jul 2019 04:34:10 GMT

Is there any other way how can I get the EasyDMA data or PDM data ?

RE: PDM code implementation and testing

sara — Fri, 26 Jul 2019 11:54:27 GMT

Thanks, But when I call uarte_init(); in main the system resets

RE: PDM code implementation and testing

haakonsh — Fri, 26 Jul 2019 10:29:40 GMT

Once a set of samples are taken they have already been transferred to RAM via EasyDMA. If you want to send this over UART to a terminal you need to start a UARTE transfer where the TX buffer pointer points to the PDM buffer.

See UARTE driver API docs:

nrfx_uarte uarte0 = NRFX_UARTE_INSTANCE(0);

void uarte_handler(nrfx_uarte_evt_type_t evt)
{
    //Handle uarte events if needed
}

void uarte_init(void)
{
    nrfx_err_t err_code = NRFX_SUCCESS;
    nrfx_uarte_config_t uarte_cfg = NRFX_UARTE_DEFAULT_CONFIG; //Set config in sd_config.h
    
    err_code = nrfx_uarte_init(&uarte0, &uarte_cfg, uarte_handler);
    APP_ERROR_CHECK(err_code);
}

// In PDM handler, call: nrfx_uarte_tx(&uarte0, &YourPDMbuffer, LenghtOfPDMbuffer)

RE: PDM code implementation and testing

sara — Fri, 26 Jul 2019 06:36:09 GMT

Hello Haakonsh, I got the pdm clock but now how should I print the PDM data on terminal using easyDMA?

RE: PDM code implementation and testing

haakonsh — Tue, 23 Jul 2019 13:56:53 GMT

Call nrfx_clock_init, then nrfx_clock_hfclk_start, then wait for the EVENTS_HFCLKSTARTED event:
while(!NRF_CLOCK->EVENTS_HFCLKSTARTED)();

RE: PDM code implementation and testing

sara — Tue, 23 Jul 2019 13:21:36 GMT

Ok n if no softdevice is enabled then sd_clock_hflck_request should not be enabled for PDM init . Am I ryt?

RE: PDM code implementation and testing

haakonsh — Tue, 23 Jul 2019 12:50:27 GMT

See sd_clock_hfclk_request.
No you do not need to init another peripheral.
You need to call nrfx_pdm_start after nrfx_pdm_init i guess.

RE: PDM code implementation and testing

sara — Tue, 23 Jul 2019 06:18:46 GMT

1) And what does this mean given in the datasheet of nrf52832 " 43.1 Master clock generator
The FREQ field in the master clock's PDMCLKCTRL register allows adjusting the PDM clock's frequency.
The master clock generator does not add any jitter to the HFCLK source chosen. It is recommended (but not
mandatory) to use the Xtal as HFCLK source " Do I need to set HFCLK ? and if yes then how?

2) And do I need to init any other interface ? I2C ?or any peripherals?

3) After pdm_init is called will I get the clock pulse?(If yes, then I am not getting clock pulse even after nrf_drv_pdm_init() )

RE: PDM code implementation and testing

sara — Tue, 23 Jul 2019 05:28:17 GMT

yes, I am sure I am measuring on the pin p0.29. And its toggling. I have attached the screenshot for it.

And one more thing what is the use of CONFIG_IO_PDM_MIC_PWR_CTRL pin ?

RE: PDM code implementation and testing

haakonsh — Mon, 22 Jul 2019 12:50:21 GMT

Are you sure you're measuring for the clock signal on p0.29 of the PCA10040 DK?

Are you able to toggle the pin state of p0.29 with a call to nrf_gpio_cfg_output and nrf_gpio_pin_toggle?

RE: PDM code implementation and testing

sara — Mon, 22 Jul 2019 09:28:41 GMT

Hello Haakonsh, Please suggest me what next should I do to make my pdm driver work. As still I am not able to get the clock on CRO, which means pdm is not configured properly (I guess).