Übersicht

Der AD7606 ist ein leistungsfähiger, preiswerter AD-Wandler. Entwicklungsboards sind ab etwa 20 € erhältlich. Er besitzt acht Kanäle mit einer Auflösung von 16 Bit. Es können Spannungen im Bereich von ±5 V oder ±10 V mit einer Rate 200 kSpS (kilo samples per second) gemessen werden. Dies entspricht einer Messdauer von 5 μs. Bereits im Chip kann der Mittelwert aus bis zu 64 Messungen ermittelt werden. Das erhöht den Rauschabstand, verringert allerdings die Durchsatzrate.

Die Messungen werden extern angestoßen. Die Messrate kann also einfach an die Belange des Projekts angepasst werden. Die acht Kanäle sind zu zwei Blöcken von je vier Kanälen zusammengefasst, die getrennt gestartet werden können (max. zeitl. Abstand: 0,5 ms, Signale CVA und CVB). Wenn die Eingänge der Blöcke parallel geschaltet werden, können somit Messungen mit einer Auflösung von 2,5 μs realisiert werden, wenn der zweite Block entsprechend verzögert gestartet wird.

Es stehen drei Schnittstellenversionen zur Übermittlung der Messwerte zur Verfügung:

• 16-Bit parallel: Die einzelnen Kanäle werden nacheinander mit jeweils 16 Bit übertragen.
• 8-Bit parallel: Die einzelnen Kanäle werden nacheinander mit jeweils 2 x 8 Bit (MSB und LSB nacheinander) übertragen.
• Seriell: Die einzelnen Bits der einzelnen Kanäle werden nacheinander übertragen. Es stehen zwei Datenleitungen zu Verfügung, auf denen die Kanäle in unterschiedlicher Reihenfolge übertragen werden.

Die Spannungsversorgungen für den Analog- und den Digitalteil sind getrennt. Der Analogteil wird mit 5 V versorgt. Ein gute Siebung der analogen Versorgungsspannung garantiert gute Messergebnisse. Der Digitalteil kann mit einer Spannung zwischen 2,3 V und 5 V betrieben werden, so dass keine separate Pegelanpassung beim Anschluss an einen μC notwendig ist.

Wenn man mit der maximal möglichen Sample-Rate fahren möchte, werden hohe Anforderungen an den steuernden μC gestellt. Es muss gut geprüft werden, ob der verwendete μC ausreicht.

Projektziele

Der AD7606 soll für zwei Projekte verwendet werden:

• Realisierung eines Phased-Array.
  Acht Ultraschall-Wandler nehmen die Reflexionen eines Ultraschall-Pulses auf. Aus der Phasenlage des empfangenen Signals lassen sich die Positionen der Reflektoren bestimmen (Interferenz). Bei einem US-Signal von 40 kHz (Periodendauer 25μs) und einer Samplerate von 200kSpS kommen fünf Messpunkte auf eine Periode. Das Abtasttheorem verlangt mindestens die doppelte Abtastfrequenz. Mit der etwa fünffachen Frequenz sollte man auf der sicheren Seite sein.
  Die Schallgeschwindigkeit beträgt knapp 350 m/s. Um ein Schallfeld mit einer Tiefe von 1 m zu speichern, benötigt man
  
  
• Prozessüberwachung.
  Mit einer Rate von etwa 10 kSpS sollen acht Kanäle aufgezeichnet werden und zur weiteren Verarbeitung an einen PC gesandt werden. Die Datenübertragung zum PC soll leitungsgebunden erfolgen und mit leicht erhältlichen Bauteilen erfolgen. Hier bietet sich die Übertragung per RS232 an. Die Datenübertragung muss mindestens betragen:
  
  (1) Datenbits + Start- und Stopp-Bit.

Rahmenbedingungen

Die Projekte sollen im Wesentlichen in der Arduino-Bibliothek entwickelt werden. Hier stehen bereits viele, einfach benutzbare Module zur Verfügung. Außerdem gibt es eine große Community, die bei Fragen weiter hilft. Von Nachteil ist, dass die Arduino-Klassen nicht auf Geschwindigkeit optimiert sind.

Die Verarbeitung einer Messrate von 200kSpS erfordert einen leistungsfähigen Microcontroller. Bei der Auswahl der μC spielt neben der Leistungsfähigkeit eine große Rolle, in wie weit man sich selbst mit diesen auskennt, wie gut sie dokumentiert sind und ob es eine große Community gibt, die bei Problemen weiter helfen kann. Es ist zu erwarten, dass einige der Standardfunktionen zu langsam sind und prozessorspezifisch ersetzt werden müssen.

Für das Auslesen des AD7606 gibt es drei Möglichkeiten. Wenn mit max. Sample-Rate gefahren werden soll, muss das Auslesen erfolgen, während bei die nächste Umwandlung läuft. Dafür stehen knapp 4μs zur Verfügung.

• Parallel: Die 16 Bit eines Kanals werden gleichzeitig (parallel) abgriffen, die Kanäle werden nacheinander Übertragen. Die Übertragung startet mit der negativen Flanke des CS-Signals und wird über das RD-Signal synchronisiert (Clock). Der Einlesevorgang für einen Kanal sollte nicht mehr als 0,4μs (gesamt 3,2μs) dauern, dann bleibt noch noch Zeit für das setzen der weiteren notwendigen Signale.
• Byte-parallel: Ähnlich dem Parallel-Modus. Die beiden Bytes eines Kanals werden nacheinander übertragen. Es sind also nur acht Datenleitungen notwendig. Dafür halbiert sich die Zeit, die zum Auslesen eines einzelnen Zugriffs zur Verfügung steht auf etwa 0,2μs.
• Seriell: Die acht Kanäle werden bit-weise mit bis zu 20 MHz über ein oder zwei Leitungen übertragen. Insgesamt müssen 128 Bits übertragen werden. 20 MHz lassen sich i.d.R. nur über eine Hardware-SPI schaffen. Die gesamte Übertragung dauert bei 20 MHz ca. 1/20*128μs = 6,4μs. Wenn mit max. Sample-Rate gefahren werden soll, ist dies zu langsam, es müssen beide Leitungen genutzt werden.

Zusätzlich zu den Datenleitungen werden mindestens 3 Signalleitungen weitere benötigt: CVA/CVB (gemeinsam), CS, RD (clock). Sinnvoll ist auch RST (reset). Der μC muss eine entsprechende Anzahl von Pins zur Verfügung stellen.

AD7606 Board

Pin-Belegung

Auf dem Board sind 27 Steuer- und Datenleitungen herausgeführt. Hinzu kommen Masse, die analoge und die digitale Stromversorgung. 

Mittelwertbildung (Oversampling)

Über die Pins OS0..OS2 kann eine Mittelwertbildung über mehrere Messwerte eingestellt werden. Dadurch sinkt natürlich die Konvertierungsrate (SPS = Samples per Second).

Anschluss/Timing

Auf dem Board sind 27 Steuer- und Datenleitungen herausgeführt. Will man den vollen Funktionsumfang des AD7606 nutzen, müssen alle Leitungen bedient werden. Dies überfordert die meisten Microcontroller. Einige der Leitungen können, je nach Projekt, fest belegt werden. Die Anzahl der notwendigen Datenleitungen lässt such durch die Wahl der Schnittstelle festlegen.

PAR / SER / BYTE SEL wird über die Lötbrücke eingestellt. OS0, OS1, OS2, RAGE können fest eingestellt werden. Die Auswertung von FRST ist optional. CVA und CVB können gemeinsam angesteuert werden.

Steuerung des Messvorgangs

Zur Steuerung des Messvorgangs müssen die Signale RESET, CONVST A, CONVST B (ggf. gemeinsam) und BUSY bedient werden. CS leitet die Datenübertragung ein.

Auslesen nach der Messung

Auslesen während der Messung

Daten auslesen 16-Bit-Parallel

PAR / SER / BYTE SEL (Lötbrücke) in Position 8080.

RST, CVA, CVB, BUSY, CS, RD, DB0..DB15 müssen an den μC angeschlossen werden. CVA und CVB ggf. gemeinsam an einen Output-Pin.

Daten auslesen 8-Bit-Parallel

PAR / SER / BYTE SEL (Lötbrücke) in Position SPI. DB14 (HBEN) steuert Byte-Reihenfolge, DB15 (BYTE SEL) = HIGH.

RST, CVA, CVB, BUSY, CS, RD, DB0..DB7 müssen an den μC angeschlossen werden. CVA und CVB ggf. gemeinsam an einen Output-Pin.

Daten auslesen seriell (SPI)

PAR / SER / BYTE SEL (Lötbrücke) in Position SPI. DB14 = LOW, DB15 (BYTE SEL) = LOW

RST, CVA, CVB, BUSY, CS, RD (SCLK), DB7 oder DB8 (D_OUT, SDO) müssen an den μC angeschlossen werden. CVA und CVB ggf. gemeinsam an einen Output-Pin. DB15 (BYTE SEL) muss auf LOW liegen. DB14 (HBEN) sollte auf LOW gelegt werden

.

STM32F1 (Bluepill)

Der AD7606 schafft 200kSPS, eine Wandlung dauert demzufolge nominal etwa 5μs. Die Signal-Analyse mit einem Logic-Analyzer hat ergeben, dass die eigentliche Wandlung, d.h. die Zeit, in das BUSY-Signal auf HIGH-Level liegt, sogar knapp unter 4μs liegt.

Um die volle Umwandlungsrate zu nutzen, müssen die Messwerte ausgelesen werden, während die nächste Messung läuft (s. Grafik Auslesen während der Messung). Dies muss also innerhalb von 4μs geschehen.

8-Bit-parallel oder Byte-serielle Übertragung

Timing

Um den AD7606 mit der höchst möglichen Sample-Rate zu betreiben, müssen die Daten ausgelesen werden, während die nächste Konvertierung läuft. Hierzu stehen knapp 4μs zur Verfügung. Es gilt also zunächst zu untersuchen, ob es der Bluepill schafft, die Daten in dieser Zeit auszulesen.

Beim Bluepill sind u.a. die Signale PA0..PA7 heraus geführt, bieten also die Möglichkeit ein Byte einzulesen. Mit einem einfachen Programm wurde das Zeitverhalten aufgenommen. Dabei wurden die Funktion zum generieren der Chip-Select- und Clock-Signale und auch das Einlesen der Pins PA0..PA7 zur Zeit-Optimierung über direkten Zugriff auf die Register realisiert. Die Kompileroptimierung war auf O3 (fastest) eingestellt.

static inline void readData(uint8_t* dest) {
   GPIOB->regs->BSRR = (1U << (ssPin - 16)) << 16;; // Beginn der Übertragung [digitalWrite(ssPin, LOW)]

   for (auto i = 0; i < 16; i++) {
      GPIOB->regs->BSRR = (1U << (clockPin - 16)) << 16; // Bit im High-Word des BSRR-Registers setzen [digitalWrite(clockPin, LOW);]
      *dest++ = (uint8_t)(GPIOA->regs->IDR); // Byte einlesen
      GPIOB->regs->BSRR = (1U << (clockPin - 16)); // Bit im Low-Word des BSRR-Registers setzen [digitalWrite(clockPin, HIGH);]
   }
   GPIOB->regs->BSRR = (1U << (ssPin - 16)); // Ende der Übertragung [digitalWrite(ssPin, HIGH)]
}

Der Aufruf der Routine wurde von einem Trigger-Signal eigeschlossen, so dass auch der Aufruf-Overhead sichtbar wurde. Die Interrupts wurden ebenfalls abgeschaltet, damit sie keine Störungen verursachen.

noInterrupts();
uint8_t buffer[16];
UrsAD7606bs.setTrigger();     // Trigger-Signal für den Logic-Analyser
UrsAD7606bs.readData(buffer); // Zeitaufnahme für diese Funktion
UrsAD7606bs.resetTrigger();   // Trigger-Signal für den Logic-Analyser
interrupts();

Das erfreuliche Ergebnis:

Der eigentliche Übertragungsvorgang dauert 1,90μs - 0,60μs = 1,84μs. Der Gesamte Vorgang (Trigger-Signal) dauert 1,95μs. Zum Einlesen stehen knapp 4μs zur Verfügung. Die benötigte Zeit liegt also deutlich darunter.

Das Taktsignal ist dabei nicht symmetrisch. Die High-Zeit beträgt 30ns (≙16,6 MHz, wenn dies Teil eines symmetrischen Pulses wäre), die Low-Zeit etwa 80ns (≙6,3 MHz). Die Gesamt-Taktzeit beträgt 110ns (≙9,1 MHz)

Konkrete Umsetzung

Im Beispielprojekt STM32F1-AD7606-bytepar wird eine Klasse für die Steuerung eines AD7606 durch einen STM32F1-Prozessor (Bluepill) beschrieben. Das Projekt zeigt, wie man eine Messreihe mit einer definierten Samplerate aufnehmen kann.

Das Ergebnis: Das Beispielprogramm zeigt, dass mit dem Bluepill eine Messwertaufnahme mit einer Dauer von minimal 6μs (entsprechenden 167kSpS) erfolgen kann. Dies ist etwas langsamer als die möglichen 200kSpS.

Serielle Übertragung (SPI)

Das Auslesen des AD7606 über das Byte-Serielle-Interface ist ein guter Kompromiss zwischen Geschwindigkeit und Anzahl benötigter Signalleitungen. Benötigt man für andere Funktionen möglichst viele freie Pins bietet die Datenübertragung per SPI eine Alternative. Hier werden nur drei Pins benötigt CS, SCLK und MISO. MOSI wird nicht benötigt, da keine Daten zum Slave übertragen werden.

Versuche mit der SPI des Bluepill haben ergeben:

• Der AD7606 unterstützt laut Datenblatt eine SPI-Frequenz von 20MHz. Mein AD7606-Board funktioniert perfekt mit einer Übertagungsfrequenz von 36MHz. Dies ist die höchst mögliche Frequenz für diese CPU. Die nächst kleinere wäre 18MHz. Zwischenstufen gibt es nicht. Diese hohe Frequenz steht aber nur auf der SPI1 zur Verfügung. SPI2 und ggf. weitere arbeiten mit der halben Frequenz.
  
  
• Bei so hohen Übertragungsraten muss das Einlesen der Daten per DMA geschehen. Das Bedienen der SPI-Register per Software ist zu langsam und führt zu langen Pausen während der Übertragung.
  
  
• Die Arduino-SPI-Bibliothek ist nicht auf Geschwindigkeit sondern auf Flexibilität ausgelegt. Sie kann erwartungsgemäß nicht benutzt werden.
  
  
• Die SPI-Hardware soll es können, das CS-Signal per Hardware zu erzeugen. Das hat leider trotz intensiver Recherche und vieler Versuche nicht funktioniert. Das CS-Signal muss per Software erzeugt werden.
  
  
• Die SPI unterstützt einen Read-Only-Modus, d.h. die Sende-Funktionalitäten der SPI können abgeschaltet werden. Leider schaltet die SPI in diesem Modus nach Ende der Übertragung nicht selbständig ab, sondern erzeugt weiterhin Takt-Signale, bis die SPI per Software abgeschaltet wird. Man schafft die Abschaltung nicht zeitgerecht. Die zusätzlichen Takte bringen den AD7606 durcheinander. Folgende Übertagungen ergeben verschobene Daten. Man muss also sowohl den Empfangs- als auch den Sendeteil beschicken.
  
  
• Es ist nicht notwendig den MOSI-Pin auf die alternative Funktion zu schalten. Man kann ihn somit als normalen GPIO-Pin betreiben.

Timing

 Die folgende Grafik zeigt einen optimierten Auslesevorgang. Die meisten der Registerzugriffe wurden unter Umgehung der Arduino-Funktionen direkt kodiert.

Das eigentliche Auslesen des AD7606 dauert gut 3,5μs (grüner Pfeil), würde also in die zur Verfügung stehende Zeit von knapp 4μs passen. Allerdings sind die Rüstzeiten, d.h. sie notwendig jedes mal durchzuführenden Konfigurationen des SPI- und des DMA-Interfaces recht lang (rote Pfeile, ca. 1,2μs). Insgesamt dauert das Auslesen (von einer fallenden CS-Flanke bis zur nächsten) knapp 5,5μs.

void readingTest() {
   AD7606DataSet t;
   ursAD7606Spi.readData(&t);
   ursAD7606Spi.readData(&t);
}

void readData(AD7606DataSet* dest) {
   beginTransfer(dest); // SPI und DMA vorbereiten

   startReading(); // Übertragung starten.

   // Warten bis die Übertragung abgeschlossen ist. Das TICF-Flag auf dem TX-DMA-Kanal gesetzt wird.
   while ((ad7606DmaDev->regs->ISR & ad7606DmaTICFMask) == 0) {}

   // Warten bis TXE=1 und dann bis BSY=0 bevor die SPI deaktiviert wird.
   while (spi_is_tx_empty(ad7606SpiDev) == 0); // Warten bis TXE=1 (spi_is_tx_empty() ist als inline deklariert).
   while (spi_is_busy(ad7606SpiDev) != 0);     // Warten bis BSY=0 (spi_is_busy() ist als inline deklariert).

   endTransfer(); // SPI und DMA abschalten.
}

void beginTransfer(AD7606DataSet* dest) {
   *pinCsBSRR = (1U << (pinCS)) << 16;; // CS auf LOW.

   // DMA konfigurieren
   ad7606RxDmaChannel->CMAR = (uint32_t)dest; // Ziel-Adresse
   ad7606RxDmaChannel->CNDTR = ad7606ChannelsToRead; // Anzahl Kanäle, die eingelesen werden sollen.
   ad7606TxDmaChannel->CNDTR = ad7606ChannelsToRead;
   ad7606RxDmaChannel->CCR |= DMA_CCR_EN; // DMA anschalten.
   ad7606TxDmaChannel->CCR |= DMA_CCR_EN;
}

void startReading() {
   // DMA im SPI-Device anschalten
   ad7606SpiDev->regs->CR2 |= SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN; // Erzeugt ersten DMA-Request.
}

void endTransfer() {
   // DMA muss abgeschaltet werden, ansonsten können die notwendigen Register nicht beschrieben werden.

   ad7606SpiDev->regs->CR2 &= ~(SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN); // DMA im SPI-Device abschalten.

   ad7606RxDmaChannel->CCR &= ~DMA_CCR_EN; // DMA abschalten.
   ad7606TxDmaChannel->CCR &= ~DMA_CCR_EN;

   dma_clear_isr_bits(ad7606DmaDev, ad7606TxDmaChannelNo); // Interrupt-Flags löschen
   dma_clear_isr_bits(ad7606DmaDev, ad7606RxDmaChannelNo); // Interrupt-Flags löschen

   *pinCsBSRR = (1U << (pinCS)); // CS auf HIGH.
}

Es besteht natürlich die Möglichkeit, dass sich Messung und Auslesen teilweise überschneiden. Man kann mit dem Auslesen beginnen, nachdem das BUSY-Signal wieder auf LOW geht. Das Auslesen muss abgeschlossen sein bevor BUSY das nächste Mal auf LOW. Mit der fallenden Flanke von BUSY werden die neuen Messdaten in den Ausgabe-Puffer geschrieben. Weiterhin kann das Vor- und Nachbereiten des Auslesens, also die SPI- und DMA-Konfiguration ebenfalls während des Messvorgangs geschehen. Das Beispiel STM32F1-AD7606-SPI zeigt, wie man interruptgesteuert eine Sample-Rate von 125kSpS erreichen kann (Taktzeit 8μs). Eine kürzere Taktzeit wäre theoretisch möglich, jedoch lässt die Arduino-Umgebung das nicht zu. Diese fordert zwischendurch Rechenzeit an (z.B. zur Fortschreibung von millis). Bei kürzeren Taktzeiten als 8μs steht nicht mehr genügend freie Rechenzeit zur Verfügung und der Auslesevorgang wird gestört. Das folgende Bild zeigt die Folgen einer solchen Störung bei einer Taktzeit von 7μs.

Im markierten Bereich findet solch eine Störung statt. Das CS-Signal wird verspätet gesetzt und ist außerdem verlängert. Das führt dazu, dass das Auslesen einer Messung ausgelassen wird (gelb: der tatsächlich Signalverlauf, orange: erwarteter Verlauf).

Konkrete Umsetzung

Im Beispielprojekt STM32F1-AD7606-SPI wird eine Klasse für die Steuerung eines AD7606 durch einen STM32F1-Prozessor (Bluepill) beschrieben. Das Projekt zeigt, wie man eine Messreihe mit einer definierten Samplerate über das SPI-Interface aufnehmen kann.

Das Ergebnis: Das Beispielprogramm zeigt, dass mit dem Bluepill eine Messwertaufnahme mit einer Dauer von minimal 8μs (entsprechenden 125kSpS) erfolgen kann. Dies ist etwa halb so schnell wie die möglichen 200kSpS.

ESP32 (WROOM-32D)

Wenn die Daten über ein WLAN übertragen werden sollen, bietet sich an, einen ESP32 zu benutzen. Die Boards gibt es in unterschiedlichen Bauformen.

Real-Time-Probleme

Der ESP32 mit der Arduino-Bibliothek ist für Real-Time-Aufgaben nicht gut geeignet:

• Der bei den ESP32-Systemen verwendete Flash-Speicher ist nicht für die direkte Ausführung geeignet (serieller Zugriff). Der Code, der ausgeführt werden soll, wird deshalb vor der Ausführung in das IRAM geladen. Das IRAM ist klein, so dass Code häufig überschrieben wird und deshalb später nachgeladen werden muss. Dies verursacht unvorhersehbare Verzögerungen.
• Es gibt die Möglichkeit, Code fest im IRAM zu platzieren. Beim ESP32 muss sich der Code von ISRs aber nicht unbedingt im IRAM stehen. Die Interrupt-Handler in der Arduino-Bibliothek sind leider nicht fest im IRAM abgelegt, so dass auch diese beim ersten Aufruf aus dem Flash geladen werden müssen. Eventuell erfolgt ein Nachladen auch dann, wenn der Code der ISR wegen Speicherknappheit überschrieben wurde. Das macht sich besonders bei timer-gesteuerten Anwendungen bemerkbar. Die Timer-Interrupts erscheinen nicht in präzisen Zeitabständen.
• Es ist nicht klar welche Priorität die einzelnen Interrupt-Typen haben, d.h. es ist nicht klar, welche Interrupts andere unterbrechen. Z.T. wird die Prioritätsvergabe dem Betriebssystem (FreeRTOS) überlassen. Leider ist FreeRTOS nicht komplett implementiert, so dass man hierauf wenig Einfluss nehmen kann.
• Interrupt-Getriebene Arduino- oder FreeRTOS-Funktionen verzögern die Ausführung von Applikations-ISRs.
• Die Arduino-Implementierungen der ISRs, sollen sehr flexibel sein und die Interna vor dem Anwender verbergen. Das wird mit einem großen Overhead erkauft.

Einige der o.g. Punkte lassen sich abstellen, indem man die Arduino-Implementierungen ersetzt. Leider funktionieren dann andere Funktionalitäten nicht mehr einwandfrei und man ist vom Update der Bibliotheken ausgeschlossen.

Board-Auswahl / Übertragungsart

Das Setzen und Lesen der GPIO ist beim ESP32 relativ langsam. Um dennoch hohe Sample-Raten zu erzielen, würde es sich anbieten, alle 16 Bit parallel einzulesen. Leider sind bei keinem der Boards 16 aufeinanderfolgende GPIOs vorhanden. Man müsste also die Messwerte aus einzelnen Bits zusammen bauen. Das zehrt den Geschwindigkeitsvorteil wieder auf.

Für die byte-parallel Übertragung muss man darauf achten, dass acht zusammenhänge (fortlaufende Nummern) GPIOs zur Verfügung stehen. Ansonsten müssen auch hier die einzelnen Bits 'zusammengefummelt' werden. Damit lassen sich dann aber die hohen Sampleraten nicht mehr erreichen. Das oben abgebildete Board besitzt acht fortlaufende GPIOs (12..19).

Serielle Übertragung (SPI) ist auf allen Boards möglich.

Es gibt ESP32-Systeme mit einem oder zwei Cores. Bei Ein-Core-Systemen werden die Real-Time-Probleme noch größer werden, da die Rechenzeit nun auch noch mit den Funktionalitäten geteilt werden müssen, die bei Zwei-Core-System auf den zweiten Core ausgelagert werden. Wer hohe Sample-Raten erreichen will, sollte unbedingt ein Zwei-Core-System wählen.

8-Bit-parallel oder Byte-serielle Übertragung

Timing

Um den AD7606 mit der höchst möglichen Sample-Rate zu betreiben, müssen die Daten ausgelesen werden, während die nächste Konvertierung läuft. Hierzu stehen knapp 4μs zur Verfügung. Es gilt also wieder zunächst zu untersuchen, ob es der ESP32 schafft, die Daten in dieser Zeit auszulesen.

Beim ESP32 die einzige fortlaufende GPIO-Serie die Folge GPIO12..GPIO19. Sie werden an die Datenleitungen DB0..DB7 angeschlossen. Mit der folgenden Methode lassen sich so alle acht Kanäle in knapp 3,1μs auslesen, also deutlich unter 4μs.

inline void UrsAD7606bp<pinRST, pinCVA, pinBUSY, pinRD, pinCS, pinDB0, range>::readData(AD7606DataSet* dest) {
   uint8_t* destByte = (uint8_t*)dest; // Es wird byteweise eingelesen

   GPIO.out_w1tc = ((uint32_t)1 << pinCS);    // fallende Flanke des CS-Signals

   for (uint8_t i = 0; i < 16; i++) {
      GPIO.out_w1tc = ((uint32_t)1 << pinRD); // fallende Flanke des Takt-Signals
      GPIO.out_w1ts = ((uint32_t)1 << pinRD); // steigende Flanke des Takt-Signals
      uint32_t temp = GPIO.in;                         // Übernahme nach steigender Flanke
      destByte[i] = (uint8_t) ((temp >> pinDB0) & 0xFF); // Input verarbeiten
   }

   GPIO.out_w1ts = ((uint32_t)1 << pinCS);       // steigende Flanke des CS-Signals
}

Konkrete Umsetzung

Im Beispielprojekt ESP32-AD7606-bytepar wird eine Klasse für die Steuerung eines AD7606 durch einen ESP32-Prozessor beschrieben. Das Projekt zeigt, wie man eine Messreihe mit einer definierten Samplerate aufnehmen kann.

Das Ergebnis: Das Beispielprogramm zeigt, dass mit dem ESP32 eine Messwertaufnahme mit 200kSpS möglich ist. Allerdings ist Taktdauer nicht präzise. Abweichungen von 1μs müssen in Kauf genommen werden. Ab einer Taktdauer von 6μs (entsprechend 167kSpS) funktioniert das Timing tadellos.

Serielle Übertragung (SPI)

Die ESP32-SPI-Hardware ist sehr leistungsfähig. Sie erlaubt Übertragungsraten von bis zu 40 MHz, kann per DMA betrieben werden und besitzt eine Reihe von unterschiedlichen Transfer-Formaten mit diversen individuellen Konfigurationsmöglichkeiten. Die Arduino-Umgebung unterstützt nur das einfache Standard-Format. Mit wenigen kleinen Anpassungen an die SPI-Steuerung schafft man eine sichere Erfassungsrate von 100 kSpS, also eine Taktdauer von 10μs.

Timing

Theoretisch wären bessere Werte möglich, jedoch macht hier die Arduino-Umgebung einen Strich durch die Rechnung. Die folgende Abbildung zeigt eine Messreihe mit einer Taktdauer von 10μs. Für das Auslesen der Daten steht die Zeit zwischen zwei fallenden Flanken des BUSY-Signals zu Verfügung. Bei diesen Flanken werden die internen Ergebnisregister des AD7606 mit neuen Werten überschrieben. Diese Zeit wird bei fast allen Messungen eingehalten. Jedoch bei der Messung, die beim Zeitstempel 30μs startet, mischt sich irgendein (Hintergrund-) Prozess ein und führt zu erheblichen Verzögerung. Bei einem Takt von 10μs führten diese Verzögerungen noch nicht zu Problemen. Das Auslesen konnte knapp vor der nächsten fallenden Flanke beendet werden. Bei kürzeren Taktzeiten ist das jedoch nicht mehr immer möglich.

Da man, wie oben beschrieben, keinen Einfluss auf die Prozess- und Interrupt-Prioritäten hat, lässt dieses Problem auch nicht beheben, ohne die Arduino-Umgebung im großen Stil zu überarbeiten.

Theoretisch besteht beim ESP32 die Möglichkeit, die Daten über zwei Leitungen einzulesen (DUAL-SPI). Man könnte also beide Datenleitungen des AD7606 (D_OUTA und D_OUTB) nutzen und so die Transferzeit von knapp 7μs bei einer SPI-Frequenz von 26 MHz auf etwa 3,5μs halbieren. Dieser Versuch, die Daten während der Messzeit einzulesen, scheitert leider an den Rüstzeiten für die Schnittstelle.

Außerdem würden bei diesem Modus die Bits der beiden Kanäle in einem Byte gemischt werden. Also ABABABAB und im zweiten Eingelesen Byte wieder ABABABAB. Man müsste die Bits wieder trennen in AAAAAAAA und BBBBBBBB. Der dazu notwenige Rechenaufwand macht den Zeitvorteil wieder wett, könnte aber ggf. auf dem zweiten Core ausgeführt werden. Bei der Benutzung von zwei Cores muss aber der Synchronisationsaufwand hinzu gerechnet werden.

Konkrete Umsetzung

Im Beispielprojekt ESP32-AD7606-SPI wird eine Klasse für die Steuerung eines AD7606 durch einen ESP32-Prozessor beschrieben. Das Projekt zeigt, wie man eine Messreihe mit einer definierten Samplerate aufnehmen kann. Das Beispiel ESP32-AD7606-SPI-Interrupt benutzt zusätzliche Interrupts zur Erkennung des Endes der Wandlung (fallende Flanke des BUSY-Signals) und zur Erkennung des Endes des Datentransfers (SPI-Transfer-Complete).