ADC Sampling Synchronization using Timer and PPI

RE: ADC Sampling Synchronization using Timer and PPI

hmolesworth — Fri, 28 Nov 2025 22:00:02 GMT

Chipping in late so not sure if all the problems were resolved. Sometimes AHB Bus Masters collide and create unexpected results and it is worth isolating the SAADC destination buffers into separate RAM AHB Slaves which have no other memory access (such as stack or variables). The following discussion explains this in more detail: adc-infuriating-behaviour

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Tue, 25 Nov 2025 06:25:21 GMT

[quote user="snoopy20"]It's ok if the timer tick starts before START is called, however if you have a PPI free you can wire START to call both SAMPLE and TIMER_START for perfect sync (see PPI Fork). The only reason I don't is I have no PPI's free (I've took nrf52810 to the max!).[/quote]

A very good idea, I at least did not think of that.

Thanks for chipping in!

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 21:10:37 GMT

For some reason my reply didn't go in-line before, I'll try again.

I do a lot with the ADC, it runs like tasks where the interupt is an end-of-task. I use 810 and RAM is short in supply so I loop the loop sort of speak, that is the easydma runs 256 times instead of 4,000. I did do that in the past but the values I get are multiplied and then required 64 bit maths which hogged the CPU. By doing 256 times and introducing a little jitter I lower CPU usage. It depends what else you need the CPU for and whether at the end you're flip-flopping buffers to keep sampling.

It's ok if the timer tick starts before START is called, however if you have a PPI free you can wire START to call both SAMPLE and TIMER_START for perfect sync (see PPI Fork). The only reason I don't is I have no PPI's free (I've took nrf52810 to the max!).

Yes RESULTSDONE to SAMPLE will cause the issue eventually even with the reset code. Sometimes it would take 30 minutes before it became an issue. As my nrf52810 controls hardware based on the reads they had to be 100% or hardware would be destroyed.

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 20:57:56 GMT

No idea, I assume it's controlling mosfets supplying power to the various aspects of the ADC hardware but who knows. Glad it worked, knew it would though, I had a personal war with the nrf52 ADC a few year back. 🙂

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 20:56:04 GMT

Yes, it was the only way I could get easydma not to occasionally have this issue. The full reset also needs to be done after ADC calibration as that could also trigger it (I'm not 100% whether the reset then wipes the calibration value though!).

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Mon, 24 Nov 2025 20:16:45 GMT

Interesting, the workaround is this errata:
https://docs.nordicsemi.com/bundle/errata_nRF52840_Rev3/page/ERR/nRF52840/Rev3/latest/anomaly_840_241.html

But that one should (at least according to the description) affect the power consumption only, seems it also cleanup something more in this case.

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Mon, 24 Nov 2025 17:39:39 GMT

Thank you for the above. Thank undocumented reset routine seems to do the trick. I'd sure like to know what those undocumented registers are, though.

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Mon, 24 Nov 2025 16:12:35 GMT

Very good, quite a lot of information here. Let me ask questions in the order of the information presented:

Are those "magic addresses" in your reset() routine documented somewhere? Clearly they're part of the SAADC block, but not documented in the regular user manual, which stops at 0x638.

In the code block using documented addresses, you appear to be enabling the SAADC interrupt in line 7. What's that for, since you and I both are using EasyDMA to actually capture the values?

A ways back up this chain you'll see that I explored the possibility that the timer tick was happening before the ADC is ready. In that case I would expect the random flip to happen in the middle of a capture, not just at the start. And in any case I'm running the SAADC precisely per the datasheet, 3µSec settling, 200 KSPS (2 channels at 100KSPS each; I've also tried 8 channels at 25KSPS, with alternating channels sampling the same pins).

Using RESULTSDONE to trigger SAMPLE (via the PPI, for lack of a SHORTS register on SAADC) seemed to work just fine, and didn't change the random misalignment.

I already know about OVERSAMPLE vs. multiple channels. Not using it.

I'll have a go at your reset() routine with the kinky undocumented addresses, and revisit my setup routine referencing your setup routine, and will post here with how it goes. Thank you for the detailed responses.

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 15:52:22 GMT

One more thing, oversample will work on one pass of many channels. I believe (iirc) it won't work on many passes. Quite a few things can cause the random 'flip'!

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 15:46:22 GMT

PS) you can't use RESULTSDONE to trigger SAMPLE it won't work. I can't recall why but iirc the event occurs before EASYDMA may have finished so another point where the wrong buffer position can be used and reads 'flip'. Only use a timer. I personally use TIMER_TICK from an RTC.

RE: ADC Sampling Synchronization using Timer and PPI

snoopy20 — Mon, 24 Nov 2025 15:42:46 GMT

The randomness is a known issue and is sort of described but not fully in the errata. I basically do what you're doing with the nrf52 but everytime you wish to restart a easydma run fully reset the ADC first using the following code and then set everything back up.

/*
 * Performs a full reset, required due to known NRF52 errata.
 */
static void reset (void) {

  NRF_PPI->CHENCLR = 1 << CFG_PPI_ADC_SAMPLEMETHOD;

  volatile uint32_t temp1;
  volatile uint32_t temp2;
  volatile uint32_t temp3;
  temp1 = *(volatile uint32_t *)0x40007640ul;
  temp2 = *(volatile uint32_t *)0x40007644ul;
  temp3 = *(volatile uint32_t *)0x40007648ul;
  *(volatile uint32_t *)0x40007FFCul = 0ul; 
  *(volatile uint32_t *)0x40007FFCul; 
  *(volatile uint32_t *)0x40007FFCul = 1ul;
  *(volatile uint32_t *)0x40007640ul = temp1;
  *(volatile uint32_t *)0x40007644ul = temp2;
  *(volatile uint32_t *)0x40007648ul = temp3;
}

And for reference here's the code which sets up my timed run...

  NRF_SAADC->CH[0].PSELP = CFG_ADC_MPPT_VOLTAGE_PSEL;
  NRF_SAADC->CH[1].PSELP = CFG_ADC_MPPT_CURRENT_PSEL;
  NRF_SAADC->CH[0].CONFIG = SAADC_CH_CONFIG_GAIN_Gain1_6 << SAADC_CH_CONFIG_GAIN_Pos | ADC_SAMPLETIME_CFG_MPPTVOLTAGE << SAADC_CH_CONFIG_TACQ_Pos;
  NRF_SAADC->CH[1].CONFIG = mpptCurrentAttenuation << SAADC_CH_CONFIG_GAIN_Pos | ADC_SAMPLETIME_CFG_CURRENT << SAADC_CH_CONFIG_TACQ_Pos;
  NRF_SAADC->RESULT.MAXCNT = ADC_MPPT_SAMPLES * 2;
  NRF_SAADC->RESULT.PTR = (uint32_t) &buffer;
  NRF_SAADC->INTENSET = SAADC_INTENSET_END_Enabled << SAADC_INTENSET_END_Pos;
  NRF_SAADC->RESOLUTION = ADC_RESOLUTION << SAADC_RESOLUTION_VAL_Pos;
  NRF_SAADC->ENABLE = SAADC_ENABLE_ENABLE_Enabled << SAADC_ENABLE_ENABLE_Pos;
  NRF_SAADC->TASKS_START = SAADC_TASKS_START_TASKS_START_Msk;

Ensure your timer source isn't ticking faster than the ADC required per run. For 2 channels with 20us and 5us TACQ...

// ADC takes 2us per channel, 4us + 20us + 5us = 29us
// 32768Hz = 30us
// 8192Hz = 122us

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Mon, 24 Nov 2025 09:49:44 GMT

Hi,

Sorry, but not sure I have anything more to suggest here. I guess an option might be to consider the nRF54L-series instead, since we support a bare metal option there:
https://www.nordicsemi.com/Products/Development-software/nRF-Connect-SDK/Bare-Metal-option-for-nRF54L-Series?lang=en#infotabs

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Sun, 23 Nov 2025 02:32:52 GMT

Standing by for any guidance you can offer......

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Wed, 19 Nov 2025 23:25:41 GMT

Update: Using RESULTSDONE to trigger SAMPLE, it samples ever so slightly faster than 100 KSPS. And the problem behavior doesn't change. At random, about one buffer in a few tens of buffers is misaligned by one int16.

I tried another thought: Slow the timer by a factor of 4, and set up all 8 channels so they alternate between the two real sets of pins. That is, Ch 0, 2, 4, and 6 all see the same set of pins (the original Ch 0), and Ch 1, 3, 5, and 7 sample the original Ch 1. It appears I understand the SAADC because this gives exactly the same result - except that now the misaligned buffers appear to happen more frequently, maybe one in half a dozen. Any ideas as to why that would be, and what it points to as the underlying cause?

Can you point me to a simple example of just the code that sets up the SAADC to capture a buffer of N results (4096 in my case) on two channels that alternate, at the max 200 KSPS (100 KSPS per channel) rate? I don't need a whole application, just want to see the approved sequence to set things up.

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Wed, 19 Nov 2025 23:05:27 GMT

That sounds reasonable, so much so that I explored it some time ago (and again just now). By changing the sample rate to 50 KSPS I guarantee that the ADC is ready when the timer calls for the next sample. Same result. And anyway, with your explanation, the mismatch would usually happen in the middle of a buffer. I never see that - it's always a full buffer off by one int16, if it's off at all (one in a few tens of buffers).

I don't see any SHORTS register for the SAADC, so I'll next try using the PPI to connect the EVENTS_RESULTDONE to TASKS_SAMPLE. In theory that will run the ADC at the fastest possible rate, which should be 100 KSPS with two channels enabled. Will be interesting to compare and see how accurate that is, and also whether it solves the problem.

I'm not hopeful, though. Right now, after the first two passes, most of the ADC setup is skipped on each future pass. Only the EasyDMA registers are set up on each pass after the 2nd, along with the timer and PPI.

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Wed, 19 Nov 2025 21:40:08 GMT

My best suggestion is that the timer is like triggering continuous timer compare events asynchronous to the state and configuration of the SAADC at any given time, so likely the CPU is updating buffer pointer, triggering start task or something related at a "bad" time compared to the timer triggering. Do you see the same if you simply disable the timer compare ppi channel to the saadc sample task when you do this "job"?

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Wed, 19 Nov 2025 11:03:43 GMT

Almost the same, certainly the same random (perhaps < 10% of the time) swapping of channels. A very clear effect is that with 5uSec acquisition time + 2uSec conversion time, x 2 channels = 14uSec, it's not ready at the 10uSec point when the timer tries to trigger the next sample, so it waits for the next tick and gets a 50 KSPS sampling rate instead of the advertised 100 KSPS.

I also tried going out to 10uSec acquisition time, and got the expected 33.3KSPS sampling rate, no visible change in the rate of channel swapping.

Then I went back to the original 3uSec acquisition time, but changed the timer to trigger at 90KSPS. Yep, the sampling slows down - and the channel swapping stays at the same rate.

Getting desperate here...hmmm, maybe it's some noisy node in this particular processor. Swapped another processor (different board) and the result was.....exactly the same.

Clearly my code is doing something that causes a race condition, doesn't quite meet setup or hold times, something like that. But what??

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Wed, 19 Nov 2025 08:41:12 GMT

Strange indeed.

If you try 5us acquisition time instead, do you see the same then?

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Wed, 19 Nov 2025 00:40:17 GMT

I now have it more stable, still not quite there. I see from ten to several tens of good captures, then one capture with the channels swapped (or equivalently, misaligned in memory by 2 bytes). I have tried moving a lot of code around, and in particular made sure that nothing can get triggered while I'm setting things up. I also set up most of the SAADC registers only on the first two passes, or if something is changed by a user command (the user can change the gain settings etc.) I've now trimmed down the code to the basics, without a lot of the redundant stops and starts that I tried to no effect. Here's the code I'm currently running - results are close but not quite good enough.

void StartAdcFor2Ch (PingPongT Which, RangeT Range1, RangeT Range2)
{
#define AdcPpiChan 12
#define AdcTimer NRF_TIMER4

// Make sure we don't get any premature triggers
NRF_SAADC -> TASKS_STOP = 1;
for (int i = 10000000; i; --i) if (NRF_SAADC -> EVENTS_STOPPED) break;
NRF_PPI -> CHENCLR = 1 << AdcPpiChan;
AdcTimer -> TASKS_STOP = 1;
AdcTimer -> TASKS_CLEAR = 1;
AdcTimer -> EVENTS_COMPARE [0] = 0;

// Set up EasyDMA
NRF_SAADC -> ENABLE = 1;
NRF_SAADC -> RESULT.MAXCNT = sizeof Wave [Which] / sizeof (uint16_t);
NRF_SAADC -> RESULT.PTR = (uint32_t) &(Wave [Which]);

if (AlreadyConfigured < 2)
{
// Build the parts of WaveInfo that only we know about
WaveInfo.uSecPerPoint = 10;
WaveInfo.uVPerCount [0] = 1000;
WaveInfo.uVPerCount [1] = 1000;

// Set ADC inputs back to reset defaults
NRF_SAADC -> ENABLE = 0;
NRF_GPIO -> DIRCLR = 0b10100000000000000000000000010100; // All ADC pins to inputs
//Note that P0.04 must be jumpered to P0.09 via a C28 pad
for (int i = 0; i < 8; ++i)
{
NRF_SAADC -> CH [i].PSELP = adcNoConnect;
NRF_SAADC -> CH [i].PSELN = adcNoConnect;
}
NRF_SAADC -> ENABLE = 1;

// Set up 2 channels to capture samples at 100 KSPS
NRF_SAADC -> ENABLE = 0;
NRF_SAADC -> CH [1].PSELP = adcCh1P;
NRF_SAADC -> CH [1].PSELN = adcCh1M;
NRF_SAADC -> CH [1].CONFIG = (Range1 << 8) | (1 << 20); // nonburst mode, diffierential, 3 uSec, internal 600 mV ref, specified gain, no pullups
NRF_SAADC -> CH [5].PSELP = adcCh2P;
NRF_SAADC -> CH [5].PSELN = adcCh2M;
NRF_SAADC -> CH [5].CONFIG = (Range2 << 8) | (1 << 20); // nonburst mode, diffierential, 3 uSec, internal 600 mV ref, specified gain, no pullups

// Set up SAADC for 12 bits, 2 channels, rate determined by AdcTimer
NRF_SAADC -> OVERSAMPLE = 0;
NRF_SAADC -> RESOLUTION = 2; // 12 bits
NRF_SAADC -> SAMPLERATE = 0; // Cannot use internal timer for multiple channels
NRF_SAADC -> EVENTS_DONE = 0;
NRF_SAADC -> EVENTS_STARTED = 0;
NRF_SAADC -> EVENTS_END = 0;
NRF_SAADC -> EVENTS_STOPPED = 0;
NRF_SAADC -> EVENTS_RESULTDONE = 0;
NRF_SAADC -> ENABLE = 1;

// Set up AdcTimer to trigger sampling (multiple channel sampling cannot use internal timer)
AdcTimer -> SHORTS = 1; // auto restart on CC[0]
AdcTimer -> TASKS_CLEAR;
AdcTimer -> MODE = 0; // Timer
AdcTimer -> BITMODE = 3; // 32 bit timer
AdcTimer -> PRESCALER = 4; // /16 prescale
AdcTimer -> CC [0] = 16000000 / 100000 / (1 << AdcTimer -> PRESCALER);

++AlreadyConfigured;
}

AdcTimer -> EVENTS_COMPARE [0] = 0;
NRF_SAADC -> TASKS_START = 1;
for (int i = 10000000; i; --i) if (NRF_SAADC -> EVENTS_STARTED) break;

// Connect timer output to ADC sampler via PPI
NRF_PPI -> CH [AdcPpiChan].EEP = (uint32_t) &(AdcTimer -> EVENTS_COMPARE [0]);
NRF_PPI -> CH [AdcPpiChan].TEP = (uint32_t) &(NRF_SAADC -> TASKS_SAMPLE);
NRF_PPI -> CHENSET = 1 << AdcPpiChan;

// Ready to run, turn it loose!
AdcTimer -> TASKS_CLEAR;
AdcTimer -> TASKS_START = 1;
}

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Tue, 18 Nov 2025 23:00:37 GMT

I'm not sure I understand what you're suggesting. I looked at the text around that figure and I did see that the preferred way is to set MAXCNT first and then PTR. At first that looked like a solution, because I got lucky and the first half-dozen or so captures worked correctly. But then it went back to randomly swapping the two channels.

I don't see where I would put the PPI link you suggest. My code fully sets up one buffer, waits for that capture to complete, then sets up the other buffer (Wave [0 or 1]) and starts that running while transmitting the previous capture. I have confirmed that the corruption is happening in the ADC capture and not in the transmission, by inserting flag values in the buffer after the capture and before transmitting.

I have now confirmed that the RESULT.AMOUNT register shows 8192 values (4K samples, two channels) every time, whether the channels are swapped or not.

I'm nearly certain there's some kind of race condition that I'm setting up, that the documentation doesn't specify, but I can't figure out where it would be. I configure all the ADC, Timer, and PPI registers with all of them stopped, then enable and start the ADC, then the PPi, and finally the timer. Is that not the correct sequence?

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Tue, 18 Nov 2025 21:01:06 GMT

Do you also have a PPI channel between SAADC END->START event to ensure it will start with next buffer when the first is full? Looking at figure 4 it may indicate this is needed.

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Tue, 18 Nov 2025 20:26:02 GMT

I agree that it *should*. I've re-read that section with close attention to detail, at least a hundred times (I'm not exaggerating!) over the past couple of weeks, finding no help. Is there a simple example code somewhere that shows the correct sequence for setting up the registers?

RE: ADC Sampling Synchronization using Timer and PPI

Kenneth — Tue, 18 Nov 2025 09:36:01 GMT

Hello again,

I don't remember all the small details at hand, but the peripheral chapter covering SAADC should cover what is needed to know (e.g. including double buffering of buffer and figures showing tasks and events):
https://docs.nordicsemi.com/bundle/ps_nrf52840/page/saadc.html

Kenneth

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Mon, 17 Nov 2025 23:28:30 GMT

Another finding that may or may not point the way: While the SAADC is running, I watch for NRF_SAADC -> EVENTS_END to determine when the buffer is ready for use. If I do NRF_SAADC -> TASKS_STOP = 1; at that time, the buffer is truncated. ??? Doesn't EVENTS_END indicate that the buffer is complete?

RE: ADC Sampling Synchronization using Timer and PPI

SteveHx — Mon, 17 Nov 2025 20:46:18 GMT

I have tried a number of things, including moving the sequence around, enuring sections are clearly stopped during programming, etc. It appears that RESULT.AMOUNT is only updated during a runtime (TASKS_START) and the value can only be read after a TASKS_STOP, so I have added routine ReadResAmt() to handle the housekeeping. I find that most of the readings are 0, occasionally the first reading [0] is 1, but that does not coincide with the captures that are misaligned. Before I tried doing a TASKS_STOP and TASKS_START I was reliably seeing 8192 for all reads, which would be correct for the previous complete capture (4096 sets of two channels).

I find that reducing the sample rate to 10 KSPS cuts down the occurrence of the misaligned data to about 1 in 50 times. Setting it to 25 KSPS gives misaligned data around one in a couple dozen, and 100 KSPS gives misaligned data about 1 in 4 times. This seems to point to some kind of race condition, but I can't find it.

I also tried moving more of the clock divider into the Timer prescaler, which had no measurable effect.

My code is below. I'm at my wit's end as to why this doesn't reliably start EasyDMA capture into the designated buffer, without an extra 16-bit value causing a misalignment.

uint32_t ReadResAmt (void)
{
uint32_t Result;
NRF_SAADC -> ENABLE = 1;
NRF_SAADC -> TASKS_START = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STARTED) break;
NRF_SAADC -> TASKS_STOP = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STOPPED) break;
Result = NRF_SAADC -> RESULT.AMOUNT;
NRF_SAADC -> ENABLE = 0;
return Result;
}

void StartAdcFor2Ch (PingPongT Which, RangeT Range1, RangeT Range2)
{
#define AdcPpiChan 11
#define AdcTimer NRF_TIMER3

// Make sure we don't get any premature triggers
NRF_SAADC -> TASKS_STOP = 1;
NRF_PPI -> CHENCLR = 1 << AdcPpiChan;
AdcTimer -> TASKS_STOP = 1;
AdcTimer -> TASKS_CLEAR = 1;
AdcTimer -> EVENTS_COMPARE [0] = 0;

// Build the parts of WaveInfo that only we know about
WaveInfo.uSecPerPoint = 10;
WaveInfo.uVPerCount [0] = 1000;
WaveInfo.uVPerCount [1] = 1000;

// Set ADC inputs back to reset defaults
NRF_SAADC -> TASKS_STOP = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STOPPED) break;
NRF_SAADC -> ENABLE = 0;
WaveInfo.ResAmt [0] = ReadResAmt ();
NRF_GPIO -> DIRCLR = 0b10100000000000000000000000010100; // All ADC pins to inputs
//Note that P0.04 must be jumpered to P0.09 via a C28 pad
for (int i = 0; i < 8; ++i)
{
NRF_SAADC -> CH [i].PSELP = adcNoConnect;
NRF_SAADC -> CH [i].PSELN = adcNoConnect;
}

// Set up 2 channels to capture samples at 100 KSPS
NRF_SAADC -> CH [0].PSELP = adcCh1P;
NRF_SAADC -> CH [0].PSELN = adcCh1M;
NRF_SAADC -> CH [0].CONFIG = (Range1 << 8) | (1 << 20); // nonburst mode, diffierential, 3 uSec, internal 600 mV ref, specified gain, no pullups
NRF_SAADC -> CH [1].PSELP = adcCh2P;
NRF_SAADC -> CH [1].PSELN = adcCh2M;
NRF_SAADC -> CH [1].CONFIG = (Range2 << 8) | (1 << 20); // nonburst mode, diffierential, 3 uSec, internal 600 mV ref, specified gain, no pullups

// Set up SAADC for 12 bits, 2 channels, rate determined by AdcTimer
NRF_SAADC -> OVERSAMPLE = 0;
NRF_SAADC -> RESOLUTION = 2; // 12 bits
NRF_SAADC -> SAMPLERATE = 0; // Cannot use internal timer for multiple channels
NRF_SAADC -> EVENTS_DONE = 0;
NRF_SAADC -> EVENTS_STARTED = 0;
NRF_SAADC -> EVENTS_END = 0;
NRF_SAADC -> EVENTS_STOPPED = 0;
NRF_SAADC -> EVENTS_RESULTDONE = 0;
WaveInfo .ResAmt [1] = ReadResAmt ();

// Set up AdcTimer to trigger sampling (multiple channel sampling cannot use internal timer)
AdcTimer -> SHORTS = 1; // auto restart on CC[0]
AdcTimer -> TASKS_CLEAR;
AdcTimer -> MODE = 0; // Timer
AdcTimer -> BITMODE = 3; // 32 bit timer
AdcTimer -> PRESCALER = 4; // /16 prescale
AdcTimer -> CC [0] = 16000000 / 100000 / (1 << AdcTimer -> PRESCALER);
WaveInfo .ResAmt [2] = ReadResAmt ();

// Connect timer output to ADC sampler via PPI
NRF_PPI -> CH [AdcPpiChan].EEP = (uint32_t) &(AdcTimer -> EVENTS_COMPARE [0]);
NRF_PPI -> CH [AdcPpiChan].TEP = (uint32_t) &(NRF_SAADC -> TASKS_SAMPLE);
NRF_PPI -> CHENSET = 1 << AdcPpiChan;
WaveInfo .ResAmt [3] = ReadResAmt ();

// Set up EasyDMA, twice to ensure double-buffering isn't a problem
NRF_SAADC -> RESULT.PTR = (uint32_t) &(Wave [Which]);
NRF_SAADC -> RESULT.MAXCNT = sizeof Wave [Which] / sizeof (uint16_t);
NRF_SAADC -> ENABLE = 1;
NRF_SAADC -> TASKS_START = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STARTED) break;
NRF_SAADC -> TASKS_STOP = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STOPPED) break;

NRF_SAADC -> RESULT.PTR = (uint32_t) &(Wave [Which]);
NRF_SAADC -> RESULT.MAXCNT = sizeof Wave [Which] / sizeof (uint16_t);

// Ready to run, turn it loose!
NRF_SAADC -> ENABLE = 1;
NRF_SAADC -> TASKS_START = 1;
for (int i = 1000000; i; --i) if (NRF_SAADC -> EVENTS_STARTED) break;
AdcTimer -> TASKS_CLEAR;
AdcTimer -> TASKS_START = 1;
}