SPI Kommunikation mit AD7780

Dann ist mir aber der negative Messwert nicht ganz klar.

Ja, dann manche in der Struktur den "long" zu einem "unsigned long"

Das mit den negativen Werten wird offensichtlich anders abgehandelt, als ich das von einem Differenzial ADC erwartet habe.

The AD7780 uses offset binary coding. Thus, a negative fullscale
voltage results in a code of 000...000, a zero differential
input voltage results in a code of 100...000, and a positive fullscale
input voltage results in a code of 111...111.
The output code for any analog input voltage can be represented as
Code = 2N − 1 × [(AIN × Gain /VREF) + 1]

Da wird also noch etwas Fummel nötig sein, um auf korrekte Werte zu kommen

DaDaVee:
So ganz habe ich den Code von dir noch nicht verstanden.
Du schiebst mithilfe von shiftIn 8 bits in storeTo[] und das 3x -> 24bit

Ja, der HX711 hat nur 24 Bit und bekommt am Ende des Auslesens mitgeteilt mit welchen Parametern
die nächste Konversion stattfinden soll, ist also nur für den HX711 sinnvoll.

Du kannst dir ja die ganze Library mal ansehen, habe ich ja oben verlinkt.
Ich denke du könntest die mit minimalem Aufwand auf den AD7780 übertragen.

Abgeschlossene Konversionen werden über den gleichen Mechanismus signalisiert.

Die Library ist nicht blockierend und berechnet nebenbei auch Mittelwerte einstellbarer Mittelungslänge.

DaDaVee:
Habe auch den ganzen Code nicht auf github gefunden um es besser nachzuvollziehen.

Komisch, für mich funktioniert der Link, habe ihn aber erst später hinzugefügt.

Hast du einen Link zu einem günstigen AD7780 Modul?
Auf Aliexpress finde ich nur den nackten Chip.

Hallo,

jetzt weiß ich warum der Pin Name "DIN" auftauchte. DOUT Pin Benennung macht µC seitig keinen Sinn. :wink:
Wenn ich meine Basisvariante zeigen darf. Kompiliert, jedoch ohne dem AD kann ich nicht in echt testen. Die Rohdaten sollten hoffentlich stimmen und stabil sein. Wenn es Whandalls anpassbare Lib nicht gebe wäre der Code doch okay - oder? /PDRST würde ich erstmal fest auf High legen.

/*
  Doc_Arduino - german Arduino Forum
  IDE 1.8.5
  Arduino Mega2560

  29.06.2018
    
*/


const byte SCLK = 2;   // Takteingang vom AD
const byte DIN = 3;    // Datenausgang vom AD

 
struct t_data
{
  bool ready_flag = false;
  int32_t data_measurement = 0;
  uint8_t data_status = 0;
} AD;
 
                    
void setup() {
  
  Serial.begin(9600);
  
  pinMode(SCLK, OUTPUT);
  pinMode(DIN, INPUT_PULLUP);
  digitalWrite(SCLK, HIGH);
}


 void loop () {

  AD.ready_flag = detect_ready();          
 
  if (AD.ready_flag) {                    // Ready erkannt, lese Daten ein ...
    read_data();             
  }

  show_daten();                           // aller 500ms
}  // loop ENDE


void read_data()                          // 32 Bits einlesen
{
  AD.data_measurement = 0;
  AD.data_status = 0;
  
  for (uint8_t i=24;i>0;i--) {            // 24 Durchläufe, MSB first                                         
    digitalWrite(SCLK, LOW);              // Clocktakt erzeugen
    digitalWrite(SCLK, HIGH);             
    if ( digitalRead(DIN) ) {             // wenn Data HIGH ist, dann 
      AD.data_measurement |= (1UL << i);  // Bits ver_ODERN     
    }                                                                             
  } 
   
  for (uint8_t i=8;i>0;i--) {             // 8 Durchläufe                                         
    digitalWrite(SCLK, LOW);                                
    digitalWrite(SCLK, HIGH);                   
    if ( digitalRead(DIN) ) {           
      AD.data_status |= (1UL << i);        
    }                                                                                
  } 
}


bool detect_ready ()
{  
  bool valid = false;
    
  if ( !digitalRead(DIN) ) {              // DOUT/READY auf "LOW" ?
    valid = true;
  }  
    
  return valid;
}


void formatiere_daten (int32_t data)
{
  for (char i=23;i>=16;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('.');
  for (char i=15;i>=8;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('.');
  for (char i=7;i>=0;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('\t');
} 


void show_daten ()
{  
  static uint32_t last_ms = 0;
  
  if (millis() - last_ms < 500)  return;                        // Abbruch
  last_ms = millis();
  formatiere_daten(AD.data_measurement); Serial.print('\t');    // Debug
  formatiere_daten(AD.data_status); Serial.print('\t');         // Debug
  Serial.print(AD.data_measurement); Serial.print('\t');
  Serial.println(AD.data_status);
}

WOW!!!
Danke DOC!

Es Funktioniert :money_mouth_face:

Vielen Danke an alle nochmal für die super Hilfe.
Ich melde mich ganz sicher die Tage in einen nächsten Thread :grinning:

Hallo,

bin positiv überrascht das es auf Anhieb funktioniert. Wollte Whandall nicht vorgreifen. Dessen Lib hat noch Features drin. Aber Danke für die Rückmeldung. Vielleicht dient es dir morgen oder übermorgen als Vorlage die Lib anzupassen. :wink:

@Doc_Arduino

ist ja letztlich die gleiche Technik, ich habe lediglich shiftIn benutzt und alles in eine Library gepackt
(natürlich für den HX711 der sich aber wirklich sehr ähnlich verhält)

Ich würde die I/O Lösung einer SPI Lösung vorziehen,
zumal man ja wegen dem Mega Pins bis zum Abwinken hat.

@DaDaVee

Du hast meine Frage nach einer Bezugsquelle schlichtweg ignoriert,
waren wir nicht besonders lieb zu dir?

Hallo,

was will man beim shiften auch anders machen. :smiley: Das Merkmal ist die Trennung des Messwertes vom Statusbyte direkt beim einlesen. Vereinfacht die spätere Verarbeitung.

Etwas offtopic.
Was ich an der Stelle noch anmerken möchte. Das shiften mittels Index kann zu zeitlichen Problemen führen, wenn man den Takt nicht selbst unter Kontrolle hat. Je größer die Indexnummer umso länger dauert das shiften. Das hatte ich bei meinem Meßschieberprojekt festgestellt. Dort kommt der Takt vom Meßschieber. Trotz direkten Registerzugriff wird das Timing bei den letzten Bits sehr knapp. Bei 32Bits dürften die letzten Bits verloren gehen. Laut meiner Einschätzung der Logicanalyzer Daten. Vorrausgesetzt der Takt bleibt so. Dann kann man das shiften umbauen ohne über den Index zugehen. Atomic musste auch noch rein, sonst haut ein Interrupt dazwischen. Vermutlich der millis Timer 0, weil nichts zusätzlich aktiv ist. Wenn man das debugt sieht es damit wieder symmetrisch aus.

int32_t read_data() {

  int32_t value = 0;
  uint32_t shift = 1;                       // Bit.0 mit "1" vorbelegen
  
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {  
    for (uint8_t i=0;i<24;i++) {            // 24 Durchläufe                                         
      while ( PIN_CLOCK )  { }              // warten bis Clock wieder LOW ist
      if ( PIN_DATA ) {                     // wenn Data HIGH ist, dann schreibe 
        value |= shift;                     // Bits ver_ODERN, shiften separat sonst wird es "hier" immer langsamer     
      }                                    
      while ( !PIN_CLOCK )  { }             // warten bis Clock wieder HIGH ist  
      shift = (shift << 1);                                                           
    }  
  }
  
  return value;   
}

Das wollte ich noch anmerken für Leute die ähnliche zeitlich kritische Dinge programmieren und vielleicht ungeahnte Probleme bekommen.

Ein fertiges Modul habe ich auch nicht gefunden. Bei Mouser kostet der AD7780 einzeln 7,70€ netto. Ab 1000St. 4,40€.

Doc_Arduino:
Das wollte ich noch anmerken für Leute die ähnliche zeitlich kritische Dinge programmieren und vielleicht ungeahnte Probleme bekommen.

Sowohl HX711 als auch der AD7780 bekommen den Takt vorgegeben, das ist nicht zeitkritisch.

Na ja, beim AD7780 muss man die Daten lesen ehe die nächste Konversion fertig ist,
aber bei 4,7 10 oder 16,7 Hz ist das ja nun wirklich nicht schwierig.

Whandall:
Hast du einen Link zu einem günstigen AD7780 Modul?
Auf Aliexpress finde ich nur den nackten Chip.

Sorry habe ich tatsächlich vor lauter Euphorie überlesen.
Ich habe den auch nur den nackten Chip gekauft, daher habe ich leider keine andere Bezugsquelle für nen Modul.

Zeitkritisch kann es bei mir am Ende wohl auch werden.
Ich möchte nämlich einen Schrittmotor ansteuern, einen Encoder für die genaue Winkelstellung auslesen und eben den Druck aufzeichnen (Dafür mein AD Wandler).
Aus Druck und Encoderwert will ich sekündlich den Mittelwert aus 10 Werten Bilden.
Daher ist es super, wenn die einzelnen Blöcke nicht zeitkritisch sind.

Als nackter Chip ist der AD7780 für mich bei seinem Preis eher uninteressant,
es gibt ungefähr gleich teure Alternativen auf Breakout-Boards die dann auch wirklich für SPI geeignet sind.

Hast du dir inzwischen die Library mal angesehen, oder hast du immer noch Probleme mit dem Link?
Du musst nur das eigentliche Lesen vom Chip anpassen.

DaDaVee:
Aus Druck und Encoderwert will ich sekündlich den Mittelwert aus 10 Werten Bilden.

Die Library kann Mittelwerte der letzten x Samples ermitteln, das ist nicht sekündlich,
kann aber locker eine Sekunde abdecken, 17 Messungen reichen da ja.

Ja die habe ich mir angeschaut. und das mit dem Mittelwert werde ich auch übernehmen.
Ich habe nur gedacht, da ich meinen AD Wandler mit 10Hz betreibe, habe ich ja sekündlich 10 Werte.
Nur ich will eben nur jede Sekunde den Mittelwert abspeichern.

Mir ist jedoch jetzt noch etwas aufgefallen. Heute früh so geflasht gewesen, dass es auf anhieb geklappt hat =D
Und zwar bekomme ich als Messwert aus meinem AD Wandler diese Werte.
Vorgegeben habe ich die Eingangsspannung durch meinen Arduino.

Bei Eingangsspannung = 0V:

11111111.11111100.10110010 00000000.00000000.10011010 16776370 154
11111111.11111101.00010000 00000000.00000000.10011010 16776464 154
11111111.11111100.01100010 00000000.00000000.10011010 16776290 154

Bei Eingangsspannung = 1V:

00110110.01011010.10100010 00000000.00000000.10011010 20339362 154
00110110.00101000.01101010 00000000.00000000.10011010 20326506 154
00110110.00111111.11101000 00000000.00000000.10011010 20332520 154

Bei Eingangsspannung = 2,5V:

10000100.10101000.01000110 00000000.00000000.10011010 25471046 154
10000100.10001000.11011110 00000000.00000000.10011010 25463006 154
10000100.11000001.01000010 00000000.00000000.10011010 25477442 154

Bei Eingangsspannung = 4,9V:

11111000.11001100.10100110 00000000.00000000.10011010 33082534 154
11111000.11010001.01101010 00000000.00000000.10011010 33083754 154
11111000.11010000.10110000 00000000.00000000.10011010 33083568 154

Natürlich hatte mein Drucksensor eine Ausgangsspannung von 2,5 V wo das ganze sehr gut übereinstimmt.
Jedoch ist bei abweichender Spannung der Wert falsch.

Den AD Wandler betreibe ich mit 5V mittels Spannungsreferenz IC.
Ich habe schon überlegt an was das liegen kann, bin aber bisher nicht drauf gekommen.

Habt ihr da vll noch einen Tip?
Liegt das an dem Data Output Coding?

Gruß
Dave

DaDaVee:
Ich habe nur gedacht, da ich meinen AD Wandler mit 10Hz betreibe, habe ich ja sekündlich 10 Werte.
Nur ich will eben nur jede Sekunde den Mittelwert abspeichern.

Was hindert dich den Mittelwert nur einmal in der Sekunde zu lesen?

Bei Eingangsspannung = 0V:

11111111.11111100.10110010 00000000.00000000.10011010 16776370 154

zero differential input voltage results in a code of 100...000

Passt für mich nicht zusammen.

Ich verstehe auch die merkwürdigen Zahlen rechts der Rohdaten nicht, die sehen aus wie abgeschnitten.

Nichts hintert mich daran. Ich werde das ja genau so machen =D

Ja richtig, irgendwas passt da nicht.
Daher wunder ich mich ja auch gerade.
War bei 2,5V eben zufällig genau das richtige Ergebnis.

Die rechten Zahlen sind einfach nur die 8 Status-Bit, während die ersten 24 Bit der Messwert ist.
Könnte da auch die Darstellung noch ändern, sodass er mir die Nullen nicht mitschreibt.

Die rechten Zahlen sind einfach nur die 8 Status-Bit,

Das Datenblatt sagt dazu:

Indicates that the serial transfer from the ADC was not performed correctly.

Und solange das nicht "correctly" ist, kannst du Müll gelesen haben.


Bei Eingangsspannung = 4,9V:

Mit 128 facher Verstärkung gemessen...
Was für ein Ergebnis erwartest du?


da ich meinen AD Wandler mit 10Hz betreibe,

Der Status sagt aber 16,7Hz

Das Statusbyte ist keins, weil die ID nicht stimmt.

Ihr lest den Kram nicht richtig ein.

Da ich die ganzen Pins gesetzt habe, gehe ich davon aus, dass es alles um ein Bit verschoben ist.
Denn auch wenn ich die Bit für Filter oder Gain auf Low setzte, macht er das korrekt.

10011010 = 01001101

const byte GAIN = 40;                       
const byte PDRST = 41;                      
const byte FILTER = 42;
const byte SCLK = 52;   // Takteingang vom AD
const byte DIN = 50;    // Datenausgang vom AD

 
struct t_data
{
  bool ready_flag = false;
  int32_t data_measurement = 0;
  uint8_t data_status = 0;
} AD;
 float Spannung = 1.5; // [V]
 float Sp=Spannung*256/5;
 float SpReal=Sp*5/256;
                   
void setup() {
 
  Serial.begin(9600);
  Serial.print("Eingansspannung ");
  Serial.println(SpReal);
  pinMode(SCLK, OUTPUT);
  pinMode(DIN, INPUT_PULLUP);
  digitalWrite(SCLK, HIGH);

  pinMode(GAIN, OUTPUT);
  pinMode(PDRST, OUTPUT);
  pinMode(FILTER, OUTPUT);

  digitalWrite(GAIN, HIGH);          //GAIN (1 = Gain 128; 0 = Gain 1
  digitalWrite(PDRST, HIGH);         // Power-Down / Reset -> PIN muss High sein damit ADC aktiv ist
  digitalWrite(FILTER, HIGH);        // 0 = 16,7 Hz || 1 = 10 Hz

  pinMode(2, OUTPUT);
  analogWrite(2,Sp);

  delay(100);
}


 void loop () {

  AD.ready_flag = detect_ready();         
 
  if (AD.ready_flag) {                    // Ready erkannt, lese Daten ein ...
    read_data();             
  }

  show_daten();                           // aller 500ms
}  // loop ENDE


void read_data()                          // 32 Bits einlesen
{
  AD.data_measurement = 0;
  AD.data_status = 0;
 
  for (uint8_t i=24;i>0;i--) {            // 24 Durchläufe, MSB first                                         
    digitalWrite(SCLK, LOW);              // Clocktakt erzeugen
    digitalWrite(SCLK, HIGH);             
    if ( digitalRead(DIN) ) {             // wenn Data HIGH ist, dann
      AD.data_measurement |= (1UL << i);  // Bits ver_ODERN     
    }                                                                             
  }
   
  for (uint8_t i=8;i>0;i--) {             // 8 Durchläufe                                         
    digitalWrite(SCLK, LOW);                               
    digitalWrite(SCLK, HIGH);                   
    if ( digitalRead(DIN) ) {           
      AD.data_status |= (1UL << i);       
    }                                                                               
  }
}


bool detect_ready ()
{ 
  bool valid = false;
   
  if ( !digitalRead(DIN) ) {              // DOUT/READY auf "LOW" ?
    valid = true;
  } 
   
  return valid;
}


void formatiere_daten (int32_t data)
{
  for (char i=23;i>=16;i--) {
    Serial.print(bitRead(data,i));
  }
  Serial.print('.');
  for (char i=15;i>=8;i--) {
    Serial.print(bitRead(data,i));
  }
  Serial.print('.');
  for (char i=7;i>=0;i--) {
    Serial.print(bitRead(data,i));
  }
  Serial.print('\t');
}


void show_daten ()
{ 
  static uint32_t last_ms = 0;
 
  if (millis() - last_ms < 500)  return;                        // Abbruch
  last_ms = millis();
  formatiere_daten(AD.data_measurement); Serial.print('\t');    // Debug
  formatiere_daten(AD.data_status); Serial.print('\t');         // Debug
  Serial.print(AD.data_measurement); Serial.print('\t');
  Serial.println(AD.data_status);
}

Bist du delay süchtig? Was soll das delay am Ende von Setup?

  delay(100);

DaDaVee:
Da ich die ganzen Pins gesetzt habe, gehe ich davon aus, dass es alles um ein Bit verschoben ist.

Der 24 Bit Wert auch?

Egal wie man es dreht: du liest den Kram nicht richtig ein.

Hallo,

mein offtopic Kommentar mit dem "zeitkritisch" ist hier nicht relevant, hatte ich im Text aber geschrieben.
Die Ausgabe ist wie folgt.
Rohwert Meßwert,
Rohwert Statusbyte,
Dezimalwert vom Rohwert ohne jede Umrechnung,
Dezimalwert vom Statusbyte.

Wenn Gain high ist und wird als low ausgelesen/übertragen, dann wird wohl tatsächlich was nicht stimmen, vielleicht liest der Code auf dem falschen Pegel ein ... mal schauen.

Fragen.
Was liegt am Pin ...
AIN(+)
AIN(-)
REFIN(+)
REFIN(-)
für ein Spannungswert an ?
An welchen Pin liegt dein Meßsignal an?

Was machst du mit Pin 2 vom Arduino? Weil das ist keine exakte Gleichspannung. Da wird ein PWM Signal erzeugt. Das ist getaktet. Der Funktionsname analogWrite ist leider irreführend. Das muss mindestens mit einem RC Glied geglättet werden bevor du das an den AD weiterleitest. Bevor das nicht sicher läuft, sollte man besser immer feste bekannte Gleichspannungswerte anlegen. Zum Bsp. mit einem Spannungsteiler erzeugt. Wegen dem Timingdiagramm. Habe mir noch das Datenblatt vom HX711 rangezogen, da wird das besser dargestellt. Habe die Takterzeugung geändert.

Versuch mal dein Glück mit dem geänderten Code.

/*
  Doc_Arduino - german Arduino Forum
  IDE 1.8.5
  Arduino Mega2560

  30.06.2018

  - Takterzeugung geändert
  - filter settling time hinzugefügt
    
*/


const byte GAIN   = 40;                      
const byte PDRST  = 41;                      
const byte FILTER = 42;
const byte SCLK   = 52;   // Takteingang vom AD
const byte DIN    = 50;   // Datenausgang vom AD

 
struct t_data
{
  bool ready_flag = false;
  int32_t data_measurement = 0;
  uint8_t data_status = 0;
} AD;
 
                    
void setup() {
  
  Serial.begin(9600);
  
  pinMode(SCLK, OUTPUT);
  pinMode(DIN, INPUT_PULLUP);
  pinMode(GAIN, OUTPUT);
  pinMode(PDRST, OUTPUT);
  pinMode(FILTER, OUTPUT);

  digitalWrite(GAIN, HIGH);          // GAIN (0 = Gain 128; 1 = Gain 1
  digitalWrite(PDRST, HIGH);         // Power-Down / Reset -> PIN muss High sein damit ADC aktiv ist
  digitalWrite(FILTER, HIGH);        // 0 = 16,7 Hz || 1 = 10 Hz
  delay(300);                        // filter settling time
}


 void loop () {

  AD.ready_flag = detect_ready();          
 
  if (AD.ready_flag) {                    // Ready erkannt, lese Daten ein ...
    read_data();             
  }

  show_daten();                           // aller 500ms
}  // loop ENDE


void read_data()                          // 32 Bits einlesen
{  
  for (uint8_t i=24;i>0;i--) {            // 24 Durchläufe, MSB first                                         
    digitalWrite(SCLK, HIGH);             // Clocktakt erzeugen   
    digitalWrite(SCLK, LOW);          
    if ( digitalRead(DIN) ) {             // wenn Data HIGH ist, dann 
      AD.data_measurement |= (1UL << i);  // Bits ver_ODERN     
    }                                                                           
  } 
   
  for (uint8_t i=8;i>0;i--) {             // 8 Durchläufe                                         
    digitalWrite(SCLK, HIGH);             // Clocktakt erzeugen 
    digitalWrite(SCLK, LOW);                                                 
    if ( digitalRead(DIN) ) {           
      AD.data_status |= (1 << i);        
    }                                                                               
  } 
}


bool detect_ready ()
{  
  AD.data_measurement = 0;
  AD.data_status = 0;
  bool valid = false;
    
  if ( !digitalRead(DIN) ) {              // DOUT/READY auf "LOW" ?
    valid = true;
  }  
    
  return valid;
}


void formatiere_daten (int32_t data)
{
  for (char i=23;i>=16;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('.');
  for (char i=15;i>=8;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('.');
  for (char i=7;i>=0;i--) {
    Serial.print(bitRead(data,i)); 
  }
  Serial.print('\t');
} 


void show_daten ()
{  
  static uint32_t last_ms = 0;
  
  if (millis() - last_ms < 500)  return;                        // Abbruch
  last_ms = millis();
  formatiere_daten(AD.data_measurement); Serial.print('\t');    // Debug
  formatiere_daten(AD.data_status); Serial.print('\t');         // Debug
  Serial.print(AD.data_measurement); Serial.print('\t');
  Serial.println(AD.data_status);
}

Hallo,

also ich habe jetzt nochmal die PINs überprüft und auch die Statusbytes überprüft.

Nachfolgendes ist noch mit den alten Code getestet.
Wenn ich AIN- und AIN+ kurzschließe erwarte ich eine Spannung von 0V, es kommt aber dieses Ergebnis raus:
11111111.11111100.00100110 00000000.00000000.10011010 16776230 154

Die Überprüfung der Statusbytes hat folgendes ergeben:
Darstellung Statusbits:
RDY | FILTER | ERR | ID1 | ID0 | GAIN | PAT1 | PAT0

PDRST HIGH und FILTER HIGH
GAIN LOW: 10010010
GAIN HIGH: 10011010

PDRST HIGH und GAIN HIGH
FILTER LOW: 00011010
FILTER HIGH: 10011010

PDRST LOW: 00000000

Daraus schließe ich, dass bei meine StatusBits um ein Bit verschoben sind?
So kommt es mir zumindest vor: FILTER | ERR | ID1 | ID0 | GAIN | PAT1 | PAT0 | RDY
Entweder wird das RDY Bit ganz weggelasen oder hinten angehängt?

Doc_Arduino:
Fragen.
Was liegt am Pin ...
AIN(+)
AIN(-)
REFIN(+)
REFIN(-)
für ein Spannungswert an ?
An welchen Pin liegt dein Meßsignal an?

AIN+: Messsignal (2,4V - 2,6V) -> Für den Test habe ich an diesen mal eine Spannung zwischen 0V und 5V angelegt.
AIN-: GND
REFIN+: +5V
REFIN-: GND

PIN2 von Arduino hatte ich als Spannungsvorgabe für den TEST genutzt, habe das aber jetzt durch nen Poti über 5V ersetzt, um eine Testspannung einstellen zu können.

Mit dem geänderten Code zeigt es mir nur noch "Nullen" an.
Und ich lese aus dem Timingdiagramm auf Seite 5 raus, dass der Timer HIGH startet, also so wie in dem alten Code, oder sehe ich das falsch?

Muss ich für das richtige ergebnis evtl. noch das Data output Coding auf Seite 12 beachten?

Viele Grüße
Dave