Increase ADC sample rate with Teensy4.1 (and Samd51 Thing Plus as well)

[LeandroFernandes88]

I'm having some difficulties when reading analog signals with the internal ADC of the Teensy4.1 and Samd51 Thing Plus microcontrollers.

Below is some data obtained when using Micropython on the following microcontrollers:

• Raspberry Pi Peak: 46 kHz (real_fs as output)

• Samd51 Thing Plus - 5.7 kHz (real_fs as output) with default firmware

• Samd51 Thing Plus - 22 kHz, if you recompile the code as follows:
  micropython\ports\samd "machine_adc.c"
  #define DEFAULT_ADC_AVG 1

• Teensy4.1 = 6.4 kHz (real_fs as output)

I tried to keep the code very simple and only perform the acquisition in the array.array module as it is faster than the acquisition with numpy array.

What caught my attention was the performance much below what I was expecting for the Teensy4.1.

Is there anything that could be done to improve this ADC data acquisition speed? As an example, the Raspberry Pi Pico library - Analogbufio, in which higher acquisition speeds are achieved.

Maybe with @ native and @ viper? (the problem is that I don't understand this coding well and I didn't find much information either)
Would it also be possible to perform acquisitions at audio processing frequencies? 22050Hz or 44100Hz?
Or is there a specific library for this purpose?

I saw some reports in posts saying it was possible to reach the ADC's maximum acquisition rate, but I'm really new to coding in Micropython and I can't find code that could be useful to me.

Could anyone suggest the necessary changes in the code to reach these frequencies of interest with @Native or @viper?

Here is my code:

length = 1024
data = array.array('H', [0] * length)  # int16 unsigned short
adc = machine.ADC(A0)
acq_start = utime.ticks_us()
for i in range(length):
    data[i] = adc.read_u16()
    utime.sleep_us(xx) # commented for higher sample rate

Any help would be greatly appreciated. Thanks

[robert-hh]

• With SAMD51 there is no need to recompile to change the AVG. It is an option of the constructor.
• Since you compile your code yourself yourself, you can have a look at the PR samd/adc_dac: Implememt adc.read_timed() and dac.write_timed(). #9624, which adds adc_timed() ADC & DAC to the SAMD port, allowing up to 1 million samples/s. adc_timed is not (yet) prepared for the Teensy port.

[LeandroFernandes88]

robert-hh

I greatly appreciate the help and especially for all the effort and hard work to rewrite the Micropython acquisition code, I believe it is a great advance in sampling rate control.

I ended up making edits to the files manually,
I was able to compile the micropython firmware with ulab,
And micropython.machine.ADC has the read_timed() class

I'm trying to run the code, but I think my lack of experience is probably making it a little difficult, sorry.
I haven't used Micropython for a while either.

If you could take a look at the code, in the ADC construction part
I think I probably made a mistake when building it.

Thank you very much.

length = 1024
vref = 3.3
fs = 22050

data = array.array('H', [0] * length)
adc = ADC(Pin.board.A0, average=1, bits=12, vref=3, callback=None)
start_time = time.time_ns()
adc.read_timed(data, fs)
end_time = time.time_ns()
data = np.array(data)
data = data*(vref/65535) # voltage conversion
acquire_time_ms = (end_time - start_time) / 1000000 # miliseconds
real_fs = len(data)*1000 / acquire_time_ms # Hz
adc.deinit()

print('Sample Rate:', real_fs, 'Hz')

For any mistake I can't understand, the sample rate ins't sensible to fs,
The function performs the acquisition of 1024 samples at an interval of almost 0.1ms, producing 10Msps
I'll try again to do what you say or try to look for any mistakes I made when copying the codes manually to the files

[robert-hh]

adc.read_timed() is asynchronous. It returns immediately after setting up the measurement. You have to wait until the data acquisition is finished. You can use adc.busy() or a callback.

Note: Code in a post has to be enclose in three backticks ```, not forward ticks. For convenience, you can as well highlight the code block and push Ctrl-E.

[robert-hh]

Just a note: At SAMD ticks_ns() returns ticks_us() * 1000. At MIMXRT it returns time.time * 10**9. So better use ticks_us() and ticks_diff().

[LeandroFernandes88]

Thank you robert-hh
Due to this update to the Samd port code of Micropython, I was able to read data at the desired speed and hope to do some tests with the signal generator and audio processing and report back as soon as possible.

If you are planning this update for Teensy4.1, it would be very interesting.

Thank you very much.

[robert-hh]

If you are planning this update for Teensy4.1, it would be very interesting.

It's on my to-do list for the MIMXRT port. But I wait until there is a common approach for adc_timed.

[bixb922]

This is a way to do this with viper:

import time
import array
import machine

#@micropython.viper
def read_signal(data:ptr16, length:int):
    adc = machine.ADC(machine.Pin(10)) # The pin depends on the board used
    acq_start = time.ticks_us()
    i = 0
    readadc = adc.read_u16
    while i < length:
        data[i] = int(readadc())
        # time.sleep_us(delay) # commented for higher sample rate
        i += 1
    duration = (time.ticks_diff( time.ticks_us(), acq_start))
    return duration
                
# a generator will use less memory than a list: [0]*length
length = const(1024)
data = array.array('H', (0 for i in range(length)))
duration = read_signal( data, length )
print("rate", length/duration*1_000_000 )

Unfortunately, I don't have a Teensy. On my ESP32-S3 with PSRAM this samples at 38 kHz.

If your application can tolerate a small bit of jitter, this goes up to 300kHz:

@micropython.viper
def read_signal2(data:ptr16, length:int):
    adc = machine.ADC(machine.Pin(10)) # The pin depends on the board used
    acq_start = time.ticks_us()
    i = 0
    readadc = adc.read_u16
    length8 = length//8
    while i < length8:
        data[i+0] = int(readadc())
        data[i+1] = int(readadc())
        data[i+2] = int(readadc())
        data[i+3] = int(readadc())
        data[i+4] = int(readadc())
        data[i+5] = int(readadc())
        data[i+6] = int(readadc())
        data[i+7] = int(readadc())
        i += 8
    duration = (time.ticks_diff( time.ticks_us(), acq_start))
    return duration

[LeandroFernandes88]

Hello bixb922
Thank you very much for your help,
With this coding sent, I was possible to read signals up to approximately 170kHz.
As my intention would be to make the most precise and accurate acquisition at frequencies of 22050 or 44100Hz, I inserted some time.sleep_us() to try to be as close to the frequency of interest, reaching values of 22.5kHz and 43.5kHz respectively.
I should do some tests soon with the signal generator and audio processing and report back as soon as possible.