Micropython PiPico constant sampling ADC

[Christoph M. (mchris)]

Ich will wissen, wie schnell man den ADC eines PiPico 2 mit konstanter 
Abtastrate betreiben kann.

from machine import ADC
import time

# Initialisierung des ADC0 (GPIO26)
adc = ADC(0)

values=[]
laenge=1000
start=time.ticks_us()
for n in range(0,laenge):
  val = adc.read_u16()
  values.append(val)
stop=time.ticks_us()

dt=(stop-start)/laenge
print("sampling time [us] :"+str(dt))
print("sampling frequency [Hz] : "+str(1/dt*1000000))

Das Ergebnis:
sampling time [us] :16.332
sampling frequency [Hz] : 61229.48

Die Abtastrate schwankt leicht. Welche besseren Methoden gibt es?

[Dergute W. (derguteweka)]

Moin,

Christoph M. schrieb:
> Welche besseren Methoden gibt es?

Programmiersprache verwenden, in der man das Gewurschtel mit dem ADC in 
einer Tickerinterruptroutine machen kann.

Gruss
WK

[Norbert (der_norbert)]

Christoph M. schrieb:
> Welche besseren Methoden gibt es?

In aufsteigender Geschwindigkeit:
* Function mit native decorator
* Function mit viper decorator
* Asm-Function mit asm_thumb decorator
* DMA in einen Buffer
* DMA in einen Ring-Buffer
* DMA in zwei wechselnde Buffer

Höchste erzielte Geschwindigkeit: 3Msps.
Weit außerhalb der Spezifikation und mit zunehmend schlechterer 
Linearität.

PS. Nicht auf Leute hören, welche offensichtlich keinerlei Erfahrung mit 
einer Programmiersprache haben.

[Norbert (der_norbert)]

Nur mal als kleine Richtungsangabe.
(_ADC_BASE auf Prozessortyp anpassen)

#!/python
# -*- coding: UTF-8 -*-
# vim: fileencoding=utf-8: ts=4: sw=4: expandtab:
from machine import ADC
from array import array
from time import ticks_us, ticks_diff

@micropython.native
def test_n(values, laenge):
    method = adc.read_u16
    start = ticks_us()
    for index in range(laenge):
      val = method()
      values[index] = val
    stop = ticks_us()
    return ticks_diff(stop, start) / laenge

@micropython.viper
def test_v(values: ptr16, laenge: int):
    method = adc.read_u16
    start: int = ticks_us()
    index: int = 0
    while index < laenge:
      values[index] = int(method())
      index += 1
    stop: int = ticks_us()
    return float(ticks_diff(stop, start)) / float(laenge)


# _ADC_BASE = const(0x4004c000)   # rp2040
_ADC_BASE = const(0x400a0000)   # rp2350
_ADC_CS   = const(0x00 >> 2)
_ADC_FCS  = const(0x08 >> 2)
_ADC_FIFO = const(0x0c >> 2)

@micropython.viper
def adc_on():
    ADC: ptr32      = ptr32(_ADC_BASE)
    ADC[_ADC_FCS]   =   (1<<0)      # EN write result to the FIFO after each conversion.
    ADC[_ADC_CS]    = ( (1<<3)      # START_MANY Continuously perform conversions.
                    |   (1<<0) )    # EN Power on ADC and enable its clock.

@micropython.viper
def adc_off():
    ADC: ptr32      = ptr32(_ADC_BASE)
    ADC[_ADC_FCS]   = 0
    ADC[_ADC_CS]    = 0

@micropython.viper
def test_v_regs(values: ptr16, laenge: int):
    FIFOEMPTY: int  = (1<<8)        # prepare mask
    ADC: ptr32      = ptr32(_ADC_BASE)

    adc_on()
    index: int = 0
    start: int = ticks_us()
    while (ADC[_ADC_FCS] & FIFOEMPTY) == 0:
        ADC[_ADC_FIFO]
    while index < laenge:
        while ADC[_ADC_FCS] & FIFOEMPTY: pass
        values[index] = ADC[_ADC_FIFO]
        index += 1
    stop: int = ticks_us()
    adc_off()
    return float(ticks_diff(stop, start)) / float(laenge)

def show_results(dt):
    print(f'sampling time:      {dt:10} µs')
    print(f'sampling frequency: {1e6/dt:10} Hz')

adc = ADC(0)
laenge = 1000
values = array('H', (0 for _ in range(laenge)))
show_results(test_n(values, laenge))
show_results(test_v(values, laenge))
show_results(test_v_regs(values, laenge))

# sampling time:           7.887 µs
# sampling frequency:     126791 Hz
# sampling time:            4.68 µs
# sampling frequency:     213675 Hz
# sampling time:               2 µs
# sampling frequency:     500000 Hz

[Christoph M. (mchris)]

Norbert (der_norbert)
>Nur mal als kleine Richtungsangabe.

Das ist ein super Richtungsangabe, danke :-)
Ich habe mal versucht, das Ganze in eine Klasse zu packen, damit man es 
als externes Modul benutzen kann.
Als Klasse scheint es aber etwas langsamer zu werden:

sampling time:           2.004 µs  
sampling frequency:     499002 Hz  
sampling time:           2.006 µs  
sampling frequency:     498504 Hz  
sampling time:           2.006 µs  
sampling frequency:     498504 Hz  
sampling time:           2.005 µs

Am einfachsten wäre meiner Meinung nach folgende Form:

import fastAdc  
laenge=1000  
fs=500000  
adc=fastAdc.FastAdc()  
print(adc.get_samples(laenge,fs))

Ich habe es aber nicht geschafft, die Array-Initialisierung in die 
Klasseninitialisierung zu verschieben, weil Viper scheinbar ein Problem 
mit dem Array als Klassenvariable hat.

[Norbert (der_norbert)]

Christoph M. schrieb:
> Als Klasse scheint es aber etwas langsamer zu werden:

Die paar Nanosekunden sind lediglich eine Meßunschärfe. Sieht man sobald 
größere Mengen (50_000) gesammelt werden.

Christoph M. schrieb:
> Ich habe es aber nicht geschafft, die Array-Initialisierung in die
> Klasseninitialisierung zu verschieben, weil Viper scheinbar ein Problem
> mit dem Array als Klassenvariable hat.

Array in __init_() errichten und dann mit self referenzieren.
Viper kann das problemlos.
Hab mal ein wenig modifiziert.

[Christoph M. (mchris)]

>Hab mal ein wenig modifiziert.

Super, danke. Muss ich später noch ausprobieren.
Gerade habe ich noch so was für variable Sampling-Raten probiert:

from machine import Timer
from machine import ADC

global adc
adc = ADC(0)

def tick(timer):
    global adc
    adc0 = adc.read_u16()
    print(adc0)
        
Timer().init(freq=10, mode=Timer.PERIODIC, callback=tick)

print("hello")

Was ist vom Timer-Interrupt zu halten?

[Norbert (der_norbert)]

Christoph M. schrieb:
> Was ist vom Timer-Interrupt zu halten?

Viel zu lahmarschig, meiner Meinung nach.
Da kannst du besser den ADC Pacing Timer im Register setzen. Ist um 
Größenordnungen präziser und einfacher.

Register DIV (0x10 >> 2) unterhalb der _ADC_BASE.

[Christoph M. (mchris)]

> fastadc.py (2,03 KB)
>Hab mal ein wenig modifiziert

Das Array scheint problematisch. es gibt nur einen Rückgabewert (ich 
nehme an der Pointer auf das Array? ):

# Usage example:
if __name__ == "__main__":
    fast_adc = FastADC(0, 100)
    values,dt = fast_adc.get_samples()
    print(values)

Ergebnis:
536958224

[Norbert (der_norbert)]

Christoph M. schrieb:
> print(values)

Stimmt. Geschrieben ohne zu testen.
Muss
return self.values, samplingTime_us
heißen.

[Christoph M. (mchris)]

Danke für die Antwort.
Jetzt ist das Problem, dass ich das array in ein json array umwandeln 
will:

json.dumps(signal)

Das klappt aber nicht mit dem u16 Format, welches "get_samples" zurück 
liefert.

Eine Möglichkeit, die mir einfällt aber recht unelegant erscheint ist, 
eine Funktion zu in der FastADC Klasse zu implementieren, mit der ich 
Einzelwerte abholen kann:

    @micropython.viper
    def get_sample(self,idx):
        values: ptr16 = ptr16(self.values)
        value: int = self.values[idx]
        return value

und dann sie dann mühsellig mit hohem Speicherverbrauch umzuwandeln:

vs=[]
for n in range(0,10):
    vs.append(adc.get_sample(n))

Gibt es eine einfachere Lösung?

[Norbert (der_norbert)]

Du musst keine Klimmzüge veranstalten um auf die Daten des Arrays 
zuzugreifen.

Einfach nur mit values[index].
Dein JSON String besteht einfach nur aus einer Auflistung der Werte, 
Komma-getrennt.
Du brauchst also bis zu fünf mal soviel Speicherplatz wie du Werte im 
Array hast (0…4095 + ,).

Oder noch einfacher:

#!/python
val_array = array('H', (1000,2000,3000,4000))
result = json.dumps([x for x in val_array])
print(result, len(result))
# [1000, 2000, 3000, 4000] 24

Oder noch einfacher:

#!/python
result = json.dumps(list(val_array))
print(result, len(result))
# [1000, 2000, 3000, 4000] 24

[Christoph M. (mchris)]

>Du musst keine Klimmzüge veranstalten um auf die Daten des Arrays
>zuzugreifen.

Vielen Dank. Irgendwie geht es ja meistens einfach mit Python. Die Kunst 
ist nur, die richtige Funktion zu finden.

Im Anhang mal den Screenshot des Signals mit einem PiPico W gesampelt.

[Christoph M. (mchris)]

Hier mal die vollständigen Sourcen für eine Art "PiPico Oszi".
Eine PiPico W wird als Access-Point konfiguriert auf den man dann autark 
zugreifen kann.

[Ada J. Quiroz (inschnier)]

Christoph M. schrieb:
> Welche besseren Methoden gibt es?

C/C++ benutzen.

[Norbert (der_norbert)]

Ada J. Quiroz schrieb:
> C/C++ benutzen.

Werd' erwachsen. Der Profi macht's in Maschinensprache!

[Pferd O. (pferdo)]

Ich habe nur mitgelesen, aber: Was für ein Qualitätbeitrag, Norbert. Wow 
:-)

[Christoph M. (mchris)]

>Ich habe nur mitgelesen, aber: Was für ein Qualitätbeitrag, Norbert.
Ich finde die sarkastische Antwort von Norbert durchaus passend, denn 
immerhin hat er gezeigt, wie sich das Problem in Micropython auf 
elegante Art lösen lässt. Außer dümmliche Kommentare, die an der 
Eingangsfrage vorbei gehen, hat ja ansonsten niemand zur Lösung 
beigetragen

[Christoph M. (mchris)]

Vielleicht hat jemand Erfahrung damit: Kann man mit Micropython 
kontinuierliche Signalverarbeitung machen?
z.B:
Via DMA ein Microphon samplen und dann mit Blocksignalverarbeitung einen 
Goertzel Algorithmus oder einen Bandpassfilter laufen lassen.

ADC DMA:
https://iosoft.blog/2021/10/26/pico-adc-dma/

[Norbert (der_norbert)]

Christoph M. schrieb:
> Goertzel Algorithmus

Goertzel geht prima, hatte ich vor geraumer Zeit schon gemacht.
Habe aber im Moment keine Meßwerte zum Zeitverhalten.
Es war aber, selbst ohne Optimierung, schon recht flugs.
Wenn man dann noch den zweiten Kern bemüht…

[Norbert (der_norbert)]

Christoph M. schrieb:
> ADC DMA:
> https://iosoft.blog/2021/10/26/pico-adc-dma/

Eines noch, der Artikel ist völlig veraltet.
So haben wir's vor Jahren noch gemacht.

Selbstverfreilich bietet µPy (mittlerweile) ein fertiges DMA System an.

[Christoph M. (mchris)]

Heute bin ich zufällig auf einen Vortrag des Micropython-Gründers 
gestoßen:
https://www.youtube.com/watch?v=iEQQWpjgFd8
Laut ihm gibt es eine Kooperation mit der ESA, die Micropthon in 
Satelliten einsetzen will.

[Christoph M. (mchris)]

>Selbstverfreilich bietet µPy (mittlerweile) ein fertiges DMA System an.
Danke für den Hinweis.
Leider gibt es in den Micropython-Docs kein Beispiel für die Verwendung 
der DMA-Klasse, objwohl das eine der wichtigsten Anwendungen der DMA 
sein dürfte:

https://docs.micropython.org/en/latest/library/rp2.DMA.html

Die Beispiele für DMA-ADC sind wohl alle Register-bassiert:
https://wokwi.com/projects/320232834674459219

[Norbert (der_norbert)]

Nun, die Beispiele im Zwischennetz sind vermutlich alle veraltet.

Wie der ADC in den Ecstasy-Mode versetzt wird, hatten wir ja schon.
Als Data-Request Quelle (treq_sel) muss je nach µC DREQ_ADC:48 oder 
DREQ_ADC:36 gesetzt werden.
Im ADC: FCS Register einmal DREQ_EN einschalten.

Soweit aus der Erinnerung…

Datenblatt studieren hilft bei jeder Programmiersprache. ;-)