EasyDMA in Arduino nano BLE 33 Part-2

EasyDMA enabled SAADC example for Arduino nano BLE 33

IntermediateFull instructions provided1 hour595

Things used in this project

Hardware components

Arduino Nano 33 BLE

Software apps and online services

Arduino IDE

Story

Flow of the Code:

The DMA (Direct Memory Access) process is initiated by a timer in this setup. The timer records the number of ticks, which is stored in a register. This value, representing the number of ticks, is then compared to the value in the CC (Compare Count) register. When the number of ticks matches the CC register value, an interrupt or trigger is generated. The tick duration can be adjusted by changing prescalers or modifying the clock source.
The PPI (Peripheral Peripheral Interface) module can be thought of as a configurable connection between two peripherals. In this system, the timer's interrupt is fed as the input event to the PPI, which serves as the starting point for the PPI to execute a specific task and, if necessary, fork the process. A development board provides a range of supported events to which the PPI can be connected, with one of these being the timer event. The task and fork operations must be supported by the board. In this particular case, the task was to initiate the SAADC (Successive Approximation Analog-to-Digital Converter) task, and the fork was to trigger the SAADC to commence the conversion process.
Once the SAADC receives a trigger from the PPI, it converts the analog signal from that particular moment into a corresponding digital value. This digital value is then stored in a memory buffer of the specified size. The DMA (EasyDMA) takes care of transferring these values into memory without the need for CPU intervention. Once all the data transfer is complete, the CPU is notified.
Storing values in a buffer, especially when sampling at a high rate, can potentially lead to data loss when the buffer is full and needs to be processed. To mitigate this issue, a ping pong buffer strategy is employed. One buffer is filled with sampled values and being processed while incoming high data rate samples are stored in the other buffer. Once the second buffer is full and in the process of being handled, new data samples are stored in the first buffer. This process alternates, ensuring continuous data capture.
Comparing the system's performance with and without DMA on the Arduino Nano BLE 33, it was observed that the setup without DMA drew approximately 4.73 uA of current, while with DMA, it consumed about 4.6 uA of current. This demonstrates that DMA indeed consumes less current. However, it's noteworthy that the readings of current for different examples were relatively similar for both setups, likely because the DMA controller, like many external modules, draws a somewhat higher current. The key advantage of DMA is its ability to transfer data to memory more efficiently and swiftly while using less overall power.

Code

EasyDMA code

#include "mbed.h"

#define SAMPLES_PER_SECOND  180000
#define PPI_CHANNEL         (7)
#define ADC_BUFFER_SIZE     1

volatile nrf_saadc_value_t adcBuffer[ADC_BUFFER_SIZE];

volatile bool adcFlag = false;
volatile uint32_t sampleCounter = 0;
void setup()
{
  Serial.begin( 9600 );
  while ( !Serial );
  Serial.println( "Arduino Nano 33 BLE (mbedOS) example: Timer -> PPI -> SAADC" );
  delay(10000);
  initADC();
  initTimer4();
  initPPI();
}

void loop()
{
  __WFI();
  __SEV();
  __WFE();

  static uint32_t previousMillis = 0;
  if ( adcFlag )

  {
    
    delay(1000);

    adcFlag = false;

    if ( sampleCounter >= SAMPLES_PER_SECOND )

    {

      uint32_t sampleCount = sampleCounter;
      uint32_t currentMillis = millis();
      uint32_t runTime = currentMillis - previousMillis;
      Serial.print( "Samples: " );
      Serial.print( sampleCount );
      Serial.print( " run time: " );
      Serial.print( runTime );
      Serial.print( " ms A0: " );
      Serial.println( adcBuffer[0] );
      previousMillis = currentMillis;
      sampleCounter = 0;
    }

  }

}

extern "C" void SAADC_IRQHandler_v( void )
{
  if ( NRF_SAADC->EVENTS_END != 0 )
  {
    NRF_SAADC->EVENTS_END = 0;
    adcFlag = true;
    sampleCounter++;
  }

}

void initADC()
{
  nrf_saadc_disable();
  NRF_SAADC->RESOLUTION = NRF_SAADC_RESOLUTION_12BIT;
  NRF_SAADC->CH[2].CONFIG = ( SAADC_CH_CONFIG_GAIN_Gain1_4    << SAADC_CH_CONFIG_GAIN_Pos ) |

                            ( SAADC_CH_CONFIG_MODE_SE         << SAADC_CH_CONFIG_MODE_Pos ) |

                            ( SAADC_CH_CONFIG_REFSEL_VDD1_4   << SAADC_CH_CONFIG_REFSEL_Pos ) |

                            ( SAADC_CH_CONFIG_RESN_Bypass     << SAADC_CH_CONFIG_RESN_Pos ) |

                            ( SAADC_CH_CONFIG_RESP_Bypass     << SAADC_CH_CONFIG_RESP_Pos ) |

                            ( SAADC_CH_CONFIG_TACQ_3us        << SAADC_CH_CONFIG_TACQ_Pos );

 

  NRF_SAADC->CH[2].PSELP = SAADC_CH_PSELP_PSELP_AnalogInput2 << SAADC_CH_PSELP_PSELP_Pos;
  NRF_SAADC->CH[2].PSELN = SAADC_CH_PSELN_PSELN_NC << SAADC_CH_PSELN_PSELN_Pos;
  NRF_SAADC->RESULT.MAXCNT = ADC_BUFFER_SIZE;
  NRF_SAADC->RESULT.PTR = ( uint32_t )&adcBuffer;
  NRF_SAADC->EVENTS_END = 0; //prev interrupt events are cleared
  nrf_saadc_int_enable( NRF_SAADC_INT_END ); // enables the saadc interrupt after adc conversion
  NVIC_SetPriority( SAADC_IRQn, 1UL );
  NVIC_EnableIRQ( SAADC_IRQn );
  nrf_saadc_enable();
  NRF_SAADC->TASKS_CALIBRATEOFFSET = 1;

  while ( NRF_SAADC->EVENTS_CALIBRATEDONE == 0 );

  NRF_SAADC->EVENTS_CALIBRATEDONE = 0;

  while ( NRF_SAADC->STATUS == ( SAADC_STATUS_STATUS_Busy << SAADC_STATUS_STATUS_Pos ) );
}

void initTimer4()
{
  NRF_TIMER4->MODE = TIMER_MODE_MODE_Timer;
  NRF_TIMER4->BITMODE = TIMER_BITMODE_BITMODE_16Bit;
  NRF_TIMER4->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Enabled << TIMER_SHORTS_COMPARE0_CLEAR_Pos; //when timer reaches cc[0], clear the timer
  NRF_TIMER4->PRESCALER = 0;
  NRF_TIMER4->CC[0] = 16000000 / SAMPLES_PER_SECOND; // Needs prescaler set to 0 (1:1) 16MHz clock
  NRF_TIMER4->TASKS_START = 1;
}

void initPPI()
{

  NRF_PPI->CH[PPI_CHANNEL].EEP = ( uint32_t )&NRF_TIMER4->EVENTS_COMPARE[0];
  NRF_PPI->CH[PPI_CHANNEL].TEP = ( uint32_t )&NRF_SAADC->TASKS_START; //starts adc task, helps synchronizing the ADC conversion with Timer 4's events.
  NRF_PPI->FORK[PPI_CHANNEL].TEP = ( uint32_t )&NRF_SAADC->TASKS_SAMPLE;
  NRF_PPI->CHENSET = ( 1UL << PPI_CHANNEL );
}