Subsampling von 50kHz Signal mit ADC (76.9kSPS)

[Claas H. (black_jacky)]

Hi,

ich bin grade dabei eine Schaltung + Software zur Impedanzmessung 
aufzubauen.
In diesem Thread habe ich meine Grundidee vorgestellt:
Titel Beitrag "Phasenerkennung 50kHz Sinus Signal"
Jetzt sitze ich an der Umsetzung der Software um mein periodisches 
Signal zu erfassen mit Hilfe von Subsampling.
Verwendet wird der uC ATmega328p mit einer Taktrate von 16Mhz un der 
intern ADC mit einem Takt von 1Mhz (entspricht 76,9kSPS bei 8Bit 
Auflösung).
Für den Anfang erzeuge ich mir ein Rechtecksignal, welches ich später 
durch einen TP in einen Sinus umwandle. Vorerst messe ich bei meinem 
aktuellen Aufbau aber das Rechtecksignal direkt.
Das Signal wir mit Hilfe des Timer2 erzeugt (Ohne Prescale) und toggelt 
den Pin PB8 mit Hilfe des Compar2A (Vergleichswert 159 -> alle 100kHz). 
Somit erhalte ich am PB3 ein 50kHz Rechteck Signal.

Nun meine Idee zum Subsampling:
Ich verwende den Compare2B um zu einem definierten Zeitpunkt bezogen auf 
das Rechtecksignal die AD-Wandlung zu starten. Den Wert vom Compare2B 
verändere ich Schrittweise von 4-156 in 8er Schritten.
Beim Timer2_CompareB_Interrupt starte ich die AD-Wandlung.
Dies mache ich einmal für den Teil wo das Rechteck-Signal am Ausgang 0 
ist und einmal wo es 1 ist.
Somit erhalte ich jeweils 20 Werte pro Zustand vom Rechtecksignal.
Das ganze wiederhole ich 10-mal und bilde so den Mittelwert der 
Messwerte und schreibe diese in ein Array, welches ich mir am Ende 
anzeigen lasse.

Nun zu meinem Problem: Ich bekomme die Werte wiederholbar gemessen, nur 
haben die gemessenen Werte nur mit sehr viel Fantasy etwas mit einem 
Sinus zu tun... Im Anhang die geplotteten Werte.
Hier noch mein Programm-Code:

volatile uint16_t convert = 0;
volatile uint8_t adc_aktiv = 0, sin_pin_value = 0, signal_half = 0;
volatile uint16_t adc_messwerte[40][2];

void sin_sig_init( void )
{
  TCCR2A = (1<<COM2A0)|(1<<WGM21);        //OC2A auf toggle bei Compar Match setzen, Modus 2 wählen (CTC)
  OCR2A = F_CPU/(2*F_SIN)-1;            //Zähler einstellen, bis zu dem gezählt werden soll
  DDRB |= 1<<PB3;                  //Pin PB3 als Ausgang definieren (OCRA mapped on PB3)
}

void sin_sig_start( void )
{
  TCCR2B = 1<<CS20;                //Prescale auf "No Prescaling"
}

void sin_sig_stop( void )
{
  TCCR2B = 0;                    //Prescale auf 0 -> Timer deaktivieren
}

void adc_init(void)
{
  ADMUX = (1<<REFS0);                //Analog Refferenz auf extern VCC
  ADMUX |= (1<<ADLAR);              //linksbündig ausgerichtet um einfacher die obersten 8Bit auszulesen
  ADCSRA = (1<<ADEN);                //ADC einschalten
  ADCSRA |= (1<<ADPS2);              //Prescale der Systemclock auf 16 setzen (16MHz/16=1MHz)
  
}

void adc_set_pin (uint8_t pin)
{
  ADMUX &= (1<<REFS1)|(1<<REFS0)|(1<<ADLAR);    //MUX3..0 auf 0 setzen
  ADMUX |= pin;                  //MUX3..0 auf den jeweiligen Eingangspin setzten
}

void adc_stop(void)
{
  if(adc_aktiv) adc_aktiv = 0;          //falls noch nicht gestoppt wurde, auf stoppen setzen
  ADCSRA &= ~(1<<ADSC);            //stoppen der Analog-Digital Umwandlung
}

void adc_start(void)
{
  adc_aktiv = 1;              //auf starten setzten
  signal_half = 0;            //auf die erste Singalhälfte setzen
  for (int i = 0; i<40; i++)
  {
    adc_messwerte[i][0] = 0;
    adc_messwerte[i][1] = 0;
  }
  ADCSRA |= (1<<ADIE);          //Interrupt einschalten
  OCR2B = 4;                //Compare Wert für Timer2CompareB setzen
  TIMSK2 |= (1<<OCIE2B);          //Compare Interrupt aktivieren
}

void adc_dummy_read(void)
{
  adc_aktiv = 0;
  ADCSRA |= (1<<ADIE);          //Interrupt einschalten
  ADCSRA |= 1<<ADSC;            //Starten der Analog-Digital Umwandlung
  _delay_ms(2);              //Warten bis die Werte ausgelesen wurden
}

uint16_t adc_read (uint8_t zeile, uint8_t spalte)
{
  return adc_messwerte[zeile][spalte];
}

ISR(TIMER2_COMPB_vect)
{
  sin_pin_value = (PINB & (1<<PB3))>>PB3;    //Speichern des aktuellen Zustands von Pin PB3
  if(sin_pin_value==signal_half)
  {
    ADCSRA |= 1<<ADSC;            //Starten der Analog-Digital Umwandlung
    TIMSK2 &= ~(1<<OCIE2B);          //Compare Interrupt deaktivieren
  }
}

ISR(ADC_vect)
{
  TIMSK2 &= ~(1<<OCIE2B);            //Compare Interrupt deaktivieren
  uint8_t temp = ((OCR2B+4)/8);
  if(adc_aktiv && signal_half)
  {
    adc_messwerte[temp+19][0] = (adc_messwerte[temp+19][0]+(ADCH))/2;    //Speichern des Wertes der AD Wandlung
    adc_messwerte[temp+19][1] = OCR2B +160;  //Startzeitpunkt der Wandlung speichern
    if(OCR2B >= 156) 
    {
      //adc_aktiv=0;      //Wenn die zweite Signalhälfte auch abgetastet ist die Messung deaktivieren
      signal_half = 0;
      OCR2B = 4;
      adc_aktiv += 1;
      if(adc_aktiv==10) adc_aktiv = 0;
    }
    else OCR2B += 8;            //Falls noch nicht vollständig abgetastet Compare2B auf den nächst höheren setzen
  }
  else if(adc_aktiv)
  {
    adc_messwerte[temp-1][0] = (adc_messwerte[temp-1][0]+(ADCH))/2;    //Speichern des Wertes der AD Wandlung
    adc_messwerte[temp-1][1] = OCR2B;    //Startzeitpunkt der Wandlung speichern
    if(OCR2B >= 156)
    {                    //wenn 144 erreicht ist (5 Abtastungen der ersten Hälfte)
      signal_half = 1;          //Auf die zweite Hälfte des Signals stelle
      OCR2B = 4;              //Compare2B Werte zurücksetzen auf 16
    }else OCR2B += 8;            //Falls noch nicht vollständig abgetastet Compare2B auf den nächst höheren setzen
    
  }
  else convert = (ADCL)|(ADCH<<8);      //Werte aus dem ADC speichern
  //if(start) ADCSRA |= 1<<ADSC;        //erneut starten der Analog-Digital Umwandlung
  //else ADCSRA &= ~(1<<ADIE);        //Interrupt ausschalten
  if(adc_aktiv)  TIMSK2 |= (1<<OCIE2B);      //Compare Interrupt einschalten
}

Und hier mein Aufruf in der Main:

int main(void)
{
  adc_init();
  adc_set_pin(PHASE_PIN);
  adc_dummy_read();
  lcd_init();
  key_init();
  sin_sig_init();
  sin_sig_start();
  _delay_ms(5);
  adc_start();
  do
  {
    if(get_key_short(1<<KEY0) && !get_key_short(1<<KEY1)) ebene++;
    else if (get_key_short(1<<KEY1) && !get_key_short(1<<KEY0)) ebene--;

    sprintf(zeile1, "E:%02d ", ebene);
    sprintf(zeile2, "S:%04d ", adc_read(ebene,0));
    sprintf(zeile2+7, "T:%04d ", adc_read(ebene,1));
    display_update();
  }while(1);
}

[Joe F. (easylife)]

Irgendwie habe ich gerade das Gefühl du bringst da einige Dinge 
durcheinander.
Weisst du wie Subsampling funktioniert? Du benötigst eine sehr genaue 
Zeitbasis und eine Sample&Hold Stufe, die in der Lage ist dein 50 KHz 
Signal abzutasten.
Ausserdem ist ein sehr steilbandiger Bandpassfilter nötig, um 
Aliasfrequenzen auszufiltern.
Einfach das Signal an deinen ADC ranzuhängen und mit 76.9 KHz abzutasten 
funktioniert bei 50 KHz natürlich nicht mehr.
Du kannst max. Frequenzen der halben Samplingfrequenz auflösen, und 
solltest alles darüber auch mit einem externen Tiefpass möglichst steil 
herausfiltern.
Je näher du an FS/2 kommst, desto schlechter wird natürlich die 
Signalform, im Grunde wird es ein Rechteck, und du hast lediglich noch 
die Amplitude als Information.

Eine Phasenmessung zweier 50 KHz Signale mit einem 76.9 KHz ADC ist so 
ziemlich unmöglich.
Ausserdem müssten auch beide ADCs (bzw. die Sample&Hold-Stufen) sehr 
präzise synchronisiert sein.

Warum machst du die Phasenmessung nicht analog?
Dazu beide Signal auf annähernd gleichen Pegel bringen, dann über 
Komparatoren in Rechtecke wandeln, auf ein XOR geben und danach 
Tiefpassfiltern.

Diesen Analogwert kannst du dann mit einem beliebig langsamen ADC mit 
hoher Auflösung messen.

[Possetitjel (Gast)]

Joe F. schrieb:

> Irgendwie habe ich gerade das Gefühl du bringst da
> einige Dinge durcheinander.

Ähh... ebenso :)

> Ausserdem müssten auch beide ADCs (bzw. die Sample&Hold-
> Stufen) sehr präzise synchronisiert sein.

Nö.
Es genügt, wenn Sender und Empfänger, d.h. Generator und
ADC synchronisiert sind. Das ist hier deshalb der Fall,
weil sich beide innerhalb desselben Mikrocontrollers
befinden.

Wenn ein Timer-Kanal die 50 kHz erzeugt und DERSELBE
Timer-Kanal per Capture/Compare die AD-Wandlung startet,
dann wüsste ich nicht, warum das nicht funktionieren
sollte.

> Warum machst du die Phasenmessung nicht analog?

Weil das ein Haufen analoges Gefrickel ist.
Ich weiss, dass das möglich ist, denn eins unserer Messgeräte
hat das so ähnlich gemacht. Aber ganau deshalb weiss ich auch,
dass das analoges Gefrickel ist.

[Joe F. (easylife)]

So, hat ein wenig gedauert, bis ich mir deinen anderen Thread 
durchgelesen habe, und glaube verstanden zu haben was zu da vor hast.

Mal ein paar grundsätzliche Überlegungen:

Dein Signal hat 50KHz, das entspricht einer Periodendauer von 20us.
Wenn es dir gelänge, den Samplezeitpunkt deines ADC auf einen 
Prozessortakt genau in Relation zum erzeugten Signal zu starten, ist das 
eine zeitliche Auflösung für dein Subsampling von 1/16 MHz = 62,5ns.
Das entspricht 1,125° deines 50 KHz Signals.
Bei dem von dir zu untersuchenden Bereiches von 0°-25° hast du also eine 
maximal mögliche Auflösung von ca. 23 Phasen-Stufen (1,125° 
Genauigkeit). Ich gehe davon aus, dass du das berücksichtigt hast, und 
du keine höhere Genauigkeit erreichen möchtest.

Um dein Signal mit 16 MHz abzutasten, benötigst du eine Sample&Hold time 
von max. 62,5ns.
Dein ADC wird mit 1 MHz getaktet, und die interne Sample&Hold Stufe 
braucht mind. 1 ADC-Taktzyklus (ich glaube irgendwo gelesen zu haben, 
dass es sogar 2 Zyklen sind).
D.h. die Sample&Hold Stufe deines ADC ist momentan für mindestens 1/1MHz 
= 1us "offen".
Bezogen auf dein 50 KHz Signal entspräche dies 18° des Signals, die von 
der Sample&Hold Stufe bereits gemittelt werden.
Wenn es 2 ADC Zyklen sein sollten, wären es 36°.
Ich glaube dies allein macht deine Messung schon sehr unbrauchbar.

Ob dein Code korrekt arbeitet, kann ich nicht beurteilen, ich finde ihn 
ziemlich schwer zu lesen.
So wie ich es verstehe, samplest du einen Wert, und mittelst ihn mit den 
vorherigen Werten (wobei wohl irgendwie noch der nachträglich ermittelte 
genaue Samplezeitpunkt die Array-Adresse bestimmt...?).
Deine "Mittelung"

adc_messwerte[temp+19][0] = (adc_messwerte[temp+9][0]+(ADCH))/2;

reduziert allerdings sofort schon mal die Auflösung auf 1/2, und 
ausserdem wird nicht linear gemittelt, sondern frühere Messwerte 
verlieren mit jedem neuen Messwert zunehmend mehr an Bedeutung (uns zwar 
nicht linear)?
Ich verstehe auch nicht, warum einmal temp+19 und einmal temp+9 genommen 
wird...

Ich würde mal versuchen, die Mittelung wegzulassen, und die Daten 
hintereinander weg in ein Array zu schreiben solange es der Speicher her 
gibt, und dies dann hinterher extern auszuwerten.
Dann kannst du besser beurteilen, ob die Werte Sinn machen.

Zusätzlich wäre es vielleicht mal einen Versuch wert, das Timing der ADC 
Startpunkte zu überprüfen.
Anstatt den ADC zu starten, könntest du mal einen weiteren Output 
high/low togglen lassen, und guckst dir am Oszi an, ob die Startpunkte 
einigermaßen gleichmäßig im 62,5ns Abstand über dein zu messendes Signal 
verteilt sind.

Mit diesem Start-Signal könnte man dann auch eine geeignet schnelle, 
externe Sample&Hold Stufe triggern.

Nachtrag:
Klar ist eine analoge Auswertung etwas "einstellbedürftig", allerdings 
hätte sie in deinem Fall wirklich Vorteile.
Da du ja weisst, dass sich dein zu messendes Signal nicht mehr als 180° 
verschiebt, kannst du auf die XOR Auswertung komplett verzichten.
Alles was du tun müsstest ist das Eingangssignal und das zu 
vergleichende Signal auf eine möglichst gleiche Amplitude zu verstärken, 
und das zu messende Signal zu invertieren.
Durch Mischen, aktives Gleichrichten und Tiefpassfiltern erhältst du 
direkt eine analoge Spannung, die der Phasenlage entspricht.
Mit einem 8-bit ADC könntest du damit theoretisch eine Auflösung von ca. 
0,7° erreichen, da du aber nicht mehr so schnell samplen musst, könntest 
du auch auf 10-bit gehen, und hättest eine Auflösung von ca. 0,18° - 
oder noch genauer, indem du den Messbereich auf <180° einschränkst.