C Code ich verstehe den Fehler nicht

[Peter M. (allforone)]

Hallo,
Ich versuche einen BCD-Schalter einzulesen und ihn vorher zu entprellen. 
Das soll alles mit einem Timerinterrupt geschehen.

#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "MCUInit.h"     //Interrupts, IO-Ausgänge, SPI
#include "IOVerarbeitung.h"   //BCD-Schalter, DIL-Schalter, LEDS, SPI

#define uint8 unsigned char

uint8 key_state;  // debounced and inverted key state:
          
uint8 key_press;  // bit = 1: key pressed

volatile bool status_bcd;
volatile uint8 ISR_counter;

void main(void)
{
  PeriphInit();
  for(;;) {
  __RESET_WATCHDOG();
    
    if(status_bcd == true) {
     status_bcd = 0;
     //Sende_SPI(framerate);
    } else{
     //Der BCD-Schalter wurde nicht verändert 
    }
  }
 }
 
 interrupt VectorNumber_Vtpm2ovf void Timer_ISR() {

   static uint8 ct0, ct1;
   uint8 i;
 
   SRTISC_RTIACK= 1;
   
   ISR_counter++;
    if(ISR_counter == 4) {
       ISR_counter = 0;

      i = key_state ^ ~KEY_PIN;                       // key changed ?
      ct0 = ~( ct0 & i );                             // reset or count ct0
      ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
      i &= ct0 & ct1;                                 // count until roll over ?
      key_state ^= i;                                 // then toggle debounced state
      key_press |= key_state & i; 

      status_bcd = BCD_Verarbeiten(BCD_Auslesen());
      //Jetzt kann ich den Status des Schalters abfragen
   }  
 }

//IOVerarbeitung.h

//Wert von BCD-Schalter auslesen und in eine Dezimalzahl konvertieren 
uint8 BCD_Auslesen(void) {
  buffer = PTGD;
  buffer = (buffer & 0xf); 
  return ((((buffer & 0xF0) >> 4) * 10) + (buffer & 0x0F));   //Rückgabewert: BCD-Schalterzahl in dezimaler Form
}


//Wert von BCD-Schalter weiterverarbeiten => entsprechende Framerate setzen
bool BCD_Verarbeiten(uint8 i) {

  if(lastresult_bcd == i) {
   return false;
  } 
  else{
        if(i == 0)
          framerate = 23.97;
   }
//Hier sthet normal noch mehr
      return true;
}

Fehler kommt im True Time Simulator immer der hier:

Error: At location FFCC -
Error: Attempt to use invalid or uninitialized memory

Error: Interrupt processing failed.

Ich könnte mir vorstellen, dass etwas mit der Speicherbehandlung nicht 
stimmt. Es könnte auch damit zusammenhängen, dass ich eventuell die 
"PeDa"-Lösung falsch eingebunden habe.

Prozessor :MC9S08AW60 von freescale
http://www.freescale.com/files/microcontrollers/doc/data_sheet/MC9S08AW60.pdf

[Daniel V. (danvet)]

Jan R. schrieb:
>

> //IOVerarbeitung.h
> 
> //Wert von BCD-Schalter auslesen und in eine Dezimalzahl konvertieren
> uint8 BCD_Auslesen(void) {
>   buffer = PTGD;
>   buffer = (buffer & 0xf);
>   return ((((buffer & 0xF0) >> 4) * 10) + (buffer & 0x0F)); 
> //Rückgabewert: BCD-Schalterzahl in dezimaler Form
> }
>

Wo ist denn "buffer" definiert?

[Peter M. (allforone)]

byte buffer; //Temporäre Veriable für Überprüfung der Schalter

Die Variable ist auch in "IOVerarbeitung" definiert.

Der Compiler beanstandet auch nichts, erst wenn ich es in einem 
Simulator loslaufen lasse, entsthet der oben genannte Fehler.

[Rufus Τ. F. (rufus)]

Jan R. schrieb:
> //IOVerarbeitung.h

Was machen die Funktionen in der Headerdatei?!

[Peter M. (allforone)]

Ja das mag schlecht oder unsystematisch programmiert sein, aber der 
Compiler meckert nicht.
Die Headerdatei wird doch einfach in die main.c kopiert, demnach spielt 
es ja keine Rolle.

Oder hast du eher auf die Funktionsweise angespielt?

[Karl H. (kbuchegg)]

Jan R. schrieb:

> Fehler kommt im True Time Simulator immer der hier:
>
> Error: At location FFCC -
> Error: Attempt to use invalid or uninitialized memory
>
> Error: Interrupt processing failed.


Hört sich erst mal nach einem Problem in der ISR an.

Geh halt mal so vor:
kommentiere alles aus der ISR aus, so dass nichts drinnen ist.
Fehler noch da?

Wenn nicht dann fang einzelne Teile wieder einzubinden. Als erstes

interrupt VectorNumber_Vtpm2ovf void Timer_ISR() {

   static uint8 ct0, ct1;
   uint8 i;
 
   SRTISC_RTIACK= 1;

/*   
   ISR_counter++;
    if(ISR_counter == 4) {
       ISR_counter = 0;

      i = key_state ^ ~KEY_PIN;                       // key changed ?
      ct0 = ~( ct0 & i );                             // reset or count ct0
      ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
      i &= ct0 & ct1;                                 // count until roll over ?
      key_state ^= i;                                 // then toggle debounced state
      key_press |= key_state & i; 

      status_bcd = BCD_Verarbeiten(BCD_Auslesen());
      //Jetzt kann ich den Status des Schalters abfragen
   }
*/  
 }

Fehler da?

Wenn nicht, dann wieder einen Teil mit dazu.

interrupt VectorNumber_Vtpm2ovf void Timer_ISR() {

   static uint8 ct0, ct1;
   uint8 i;
 
   SRTISC_RTIACK= 1;
   
   ISR_counter++;
    if(ISR_counter == 4) {
       ISR_counter = 0;

/*
      i = key_state ^ ~KEY_PIN;                       // key changed ?
      ct0 = ~( ct0 & i );                             // reset or count ct0
      ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
      i &= ct0 & ct1;                                 // count until roll over ?
      key_state ^= i;                                 // then toggle debounced state
      key_press |= key_state & i; 

      status_bcd = BCD_Verarbeiten(BCD_Auslesen());
      //Jetzt kann ich den Status des Schalters abfragen
*/
   }  
 }

Wenn immer noch kein Fehler, dann nimmst du den Teil vor der BCD 
Auswertung mit dazu.

Solange bis dass du einen Anhaltspunkt hast, in welchem Bereich sich das 
Problem abspielt.

[Karl H. (kbuchegg)]

Jan R. schrieb:
> Ja das mag schlecht oder unsystematisch programmiert sein, aber der
> Compiler meckert nicht.

Schlechtes Argument.
Der Duden hat gegen
 "Das Flugzeug taucht die Gabel mit der Fahne."
auch nichts einzuwenden. Alle Wörter, alle Wortstellungen sind korrekt, 
alle Grammatikregeln wurden eingehalten.
Und trotzdem ist der Satz Unsinn.


Wenn der Compiler nichts beanstandet, dann heißt das erst mal nur, dass 
die Grammatik stimmt. Mehr nicht.

[Peter M. (allforone)]

So habe alles auskommentiert in der ISR und der Fehler kam immer noch.

void PeriphInit(void) {

//Global Interrupts aktivieren
EnableInterrupts;

//PORT G für BCP und DIL Schalter auf Eingang stellen
PTGDD = 0x00;
//PORT D für LEDS auf Ausgang stellen
PTADD = 0xff;

//Timer initialisieren
SRTISC_RTIACK= 1;          //Alte Interrupts clearen
SRTISC_RTIE = 1;           //Timer-Interrupt enable
SRTISC_RTIS = 0x001b;      //Interrupt alle 8 ms
SRTISC_RTICLKS = 0;        //Interner 1Khz Takt wird für Timer Interrupt benutzt

}

Dann kann der Fehler fast nur noch in der Initialisierung liegen.

Ich habe auch versucht einen Breakpoint auf die ISR zu setzen, 
allerdings wurde dieser nie erreicht...

[Daniel V. (danvet)]

Jan R. schrieb:
> Error: At location FFCC -
> Error: Attempt to use invalid or uninitialized memory
>
> Error: Interrupt processing failed.
>

Kompletter Code bitte.
Listing anschauen und an Adresse FFCC schauen was da steht. Welche 
Codezeile?

[Karl H. (kbuchegg)]

Jan R. schrieb:
> So habe alles auskommentiert in der ISR und der Fehler kam immer noch.

Dann heißt es eben weiterschauen.
Die Technik dazu kennst du ja jetzt.


Nur der Vollständigkeit halber

> void PeriphInit(void) {
>
> //Global Interrupts aktivieren
> EnableInterrupts;
>
> ....
> }

Die Reihenfolge ist:
ERST konfiguriert man alle Bauteile und Komponenten und DANN gibt man 
die Interrupts generell frei. Nicht umgekehrt. Sonst kann es dir 
theoretisch bei mehreren Interrupt Quellen passieren, dass der erste 
Interrupt schon kommt, während das Programm die weiteren Komponenten 
noch gar nicht fertig konfiguriert hat.

[Peter M. (allforone)]

Hier der komplette Code:

main.c

#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "MCUInit.h"     //Interrupts, IO-Ausgänge, SPI
#include "IOVerarbeitung.h"   //BCD-Schalter, DIL-Schalter, LEDS, SPI

#define uint8 unsigned char

uint8 key_state;  // debounced and inverted key state:
          
uint8 key_press;  // bit = 1: key pressed

volatile bool status_bcd;
volatile bool status_dil;
volatile uint8 ISR_counter;

void main(void)
{
  PeriphInit();
  for(;;) {
  __RESET_WATCHDOG();
    
    if(status_bcd == true) {
     status_bcd = 0;
     //Sende_SPI(framerate);
    } else{
     //Der BCD-Schalter wurde nicht verändert 
    }
  }
 }
 
 __interrupt VectorNumber_Vtpm2ovf void Timer_ISR() {

   static uint8 ct0, ct1;
   uint8 i;
 
   SRTISC_RTIACK= 1;   
   
    /*
    
   ISR_counter++;
    if(ISR_counter == 4) {
       ISR_counter = 0;
     

      i = key_state ^ ~KEY_PIN;                       // key changed ?
      ct0 = ~( ct0 & i );                             // reset or count ct0
      ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
      i &= ct0 & ct1;                                 // count until roll over ?
      key_state ^= i;                                 // then toggle debounced state
      key_press |= key_state & i; 
   
      status_bcd = BCD_Verarbeiten(BCD_Auslesen());
      //Jetzt kann ich den Status des Schalters abfragen

   } 
   */
 }

MCUInit.h

void PeriphInit(void) {

//Global Interrupts aktivieren
EnableInterrupts;

//PORT G für BCP und DIL Schalter auf Eingang stellen
PTGDD = 0x00;
//PORT D für LEDS auf Ausgang stellen
PTADD = 0xff;

//Timer initialisieren
SRTISC_RTIACK= 1;          //Alte Interrupts clearen
SRTISC_RTIE = 1;           //Timer-Interrupt enable
SRTISC_RTIS = 0x001b;      //Interrupt alle 8 ms
SRTISC_RTICLKS = 0;        //Interner 1Khz Takt wird für Timer Interrupt benutzt
}

IOVerarbeitung.h

typedef int bool;
  /*!< Definition for boolean type. */
#ifdef __MISRA__ /* MISRA rule #18 */
  #define true  1u
    /*!< Definitioni for TRUE. */
  #define false 0u
    /*!< Definition for FALSE. */
#else
  #define true  1
    /*!< Definitioni for TRUE. */
  #define false 0
    /*!< Definition for FALSE. */
#endif

#define uint8 unsigned char
#define KEY_PIN    PTGD_PTGD;


byte buffer; //Temporäre Veriable für Überprüfung der Schalter


uint8 lastresult_bcd;      //Letzter Wert des BCD-Schalters
uint8 lastresult_dil;      //Letzter Wert des DIL-Schalters
float framerate;           //Aktuelle Framerate


bool BCD_Verarbeiten(uint8);
uint8 BCD_Auslesen(void);
void DIL_Verarbeiten(uint8);
uint8 DIL_Auslesen(void);

 
//Wert von BCD-Schalter auslesen und in eine Dezimalzahl konvertieren 
uint8 BCD_Auslesen(void) {
  buffer = PTGD;
  buffer = (buffer & 0xf); 
  return ((((buffer & 0xF0) >> 4) * 10) + (buffer & 0x0F));   //Rückgabewert: BCD-Schalterzahl in dezimaler Form
}

//Wert von BCD-Schalter weiterverarbeiten => entsprechende Framerate setzen
bool BCD_Verarbeiten(uint8 i) {

  if(lastresult_bcd == i) {
   return false;
  } 
  else{
        if(i == 0) {
          framerate = 23.97;
        } 
      }  
      lastresult_bcd = i;
      return true;
}

Dann gibt es noch vorgefertigte Includes:
derivative.h
MC9S08AW60.h

[Peter M. (allforone)]

> Die Reihenfolge ist:
> ERST konfiguriert man alle Bauteile und Komponenten und DANN gibt man
> die Interrupts generell frei. Nicht umgekehrt. Sonst kann es dir
> theoretisch bei mehreren Interrupt Quellen passieren, dass der erste
> Interrupt schon kommt, während das Programm die weiteren Komponenten
> noch gar nicht fertig konfiguriert hat.

Ok, gut vielen Dank!

Ist denn ein genereller logischer fehler zu sehen.
Ist z.B. die PeDa-Lösung richtig eingebunden, auch wenn der Fehler 
auskommentiert kommt.

Es wird dann am Timer liegen, ich werde es jetzt mal schrittweise 
durchgehen.

[Peter II (Gast)]

Jan R. schrieb:
> buffer = PTGD;
>   buffer = (buffer & 0xf);
>   return ((((buffer & 0xF0) >> 4) * 10) + (buffer & 0x0F));
> //Rückgabewert: BCD-Schalterzahl in dezimaler Form

funktioniert das denn?

wenn du ein

buffer = (buffer & 0xf);

machst, dann macht es für mich wenig sinn dann später ein

(buffer & 0xF0)

zu machen.

(wenn ich mich irre, dann wegen der wärme ...)

[Peter M. (allforone)]

Fehler erstmal gefunden... falsche Vectornumber benutzt KopfAnWand

Jetzt muss ich logische Fehler finden.
Den Entprellcode habe ich nur eingebaut ohne mich damit näher zu 
beschäftigen. Da schaue ich jetzt mal als erstes.

Aber allen vielen Dank für die fleiíge Unterstützung hat sich gelohnt.

[Rufus Τ. F. (rufus)]

Den üblen Pfusch mit Code und Variablendefinitionen in Headerdateien 
solltest Du Dir allerdings so schnell wie irgend möglich abgewöhnen -- 
und zwar noch bevor Du irgendwas anderes machst.

[Der kernige Ridschie (Gast)]

Rufus Τ. Firefly schrieb:
> Den üblen Pfusch mit Code und Variablendefinitionen in Headerdateien
> solltest Du Dir allerdings so schnell wie irgend möglich abgewöhnen --
> und zwar noch bevor Du irgendwas anderes machst.

Dem kann ich nur beipflichten.
In eine Headerdatei gehört nichts, was Speicher braucht.
Deklarationen, aber niemals Definitionen.

[Peter M. (allforone)]

Kennt ihr dazu eine gute Seite, die erklärt was wohin gehört?
Ich habe es einfach nur für mich zur besseren ordnung gemacht.
Gibt es eine Begründung, wieso hier keine Sachen reindürfen, die 
Speicher benötigen?

[Cyblord -. (cyblord)]

Schreibst du schon länger für die Reihe "Quellcode aus der Hölle", oder 
ist das dein erster Beitrag für die? :-p

[Peter M. (allforone)]

Ich bin Ehrenvorsitzender dieses Vereins auf Lebenszeiten. Wir haben uns 
das Ziel gesetzt nie schönen Quellcode zu schreiben. Doch jetzt haben 
wir einen Abtrünnigen, der doch mal schönen Code schreiben wollte, habt 
ihr für ihn Tipps?
Ich schaue erstmal in der Sammlung, ob ich etwas finde....

[Peter M. (allforone)]

Es würde sich jetzt also anbieten, eine MCUInit.c und eine 
IOVerarbeitung.c zu erstellen?

[Cyblord -. (cyblord)]

http://de.wikipedia.org/wiki/Modul_(Software)

Grundsätzlich:

Ein .c Datei und eine. h Datei bilden ein sog. MODUL. In der der Header 
Datei wird das Interface definiert. Auch die Datenstrukturen. In der .c 
Datei wird dieses Interface implementiert.
Um das Modul zu nutzen wird nur die .h Datei inkludiert.

Ein Modul sollte eine wohldefinierte Aufgabe haben. Klar abgegrenzt zum 
Rest.

Es bietet sich z.B. an, bestimmte Peripherie Bausteine in eigene Module 
auszulagern. Ein Modul kapselt dann die gesamte Funktionalität des 
Bausteins.

Oder bestimmte Algorithmen, wie Sortierung oder Datenstrukturen mit 
Operationen drauf (Bäume, Listen usw.).

Ob man nun IOs und Init in eigene module machen sollte, würde ich 
bezweifeln.

Module sollten über Sachverhalte und Komplexität abstrahieren, und die 
Komplexität darunter, für den nutzenden Code, verdecken.

gruß cyblord

[amateur (Gast)]

0 - byte buffer;
1 - buffer = PTGD;
2 - buffer = (buffer & 0xf);
3 - return ((((buffer & 0xF0) >> 4) * 10) + (buffer & 0x0F));

1) buffer = ????????;
2) buffer = ???????? & 00001111 = 0000????;
3) buffer = 0000???? & 11110000 = 0 so war es zumindest früher einmal.

[Peter M. (allforone)]

1 - buffer = PTGD;
2 - buffer = (buffer & 0xf);

Hier wird der Wert von PTGD eingelesen.
Egal was vorher dort drinstand, ich brauche nur die vier unteren Bits.
Egal was in den oberen drinstand, die sind dann 0. Und die unteren 
behalten ihren normalen Wert.
Ja ok du hast aber Recht.

(((buffer & 0xF0) >> 4) * 10)

Ergibt dann eigentlich keinen Sinn, es funktioniert aber wie es soll.
Ich könnte dies quasi löschen. Scheinbar kann der Compiler automatisch 
von byte in uint8 konvertieren.


@cyblord
Wenn ich diese Sachen nicht auslagern würde, dann wäre die main.c aber 
so voll.

[Cyblord -. (cyblord)]

Jan R. schrieb:

> @cyblord
> Wenn ich diese Sachen nicht auslagern würde, dann wäre die main.c aber
> so voll.

Du kannst sie schon auslagern, aber sinnvoll gegliedert und nicht 
einfach wahllos über verschiedene Dateien hinweg irgendwelche Funktionen 
aufrufen.


gruß cyblord

[Peter M. (allforone)]

Kannst du mir mal eine kurze sinnvolle Gliederung hierfür erstellen?
Wäre super nett.
Habe es einfach noch nie gemacht.

[Cyblord -. (cyblord)]

Jan R. schrieb:
> Kannst du mir mal eine kurze sinnvolle Gliederung hierfür erstellen?
> Wäre super nett.
> Habe es einfach noch nie gemacht.

Programmieren musst du schon selber, Übung macht den Meister.

Deine IO-Verarbeitung ist ja eigentlich das Einlesen deiner 
BCD-Schalter. Die kannst du schon kapseln, mit Header Datei (dort denkst 
du dir ein praktisches Interface aus) und .c Datei wo du das 
ausprogrammierst.

Und das Verarbeiten der BCD-Daten, gehört da nicht rein. Das Modul hat 
die Aufgabe, die BCD-Stellung aus den Portpins abzufragen und ordentlich 
als Zahl wiederzugeben. Nicht mehr und nicht weniger.

Trotzdem ist deine main jetzt nicht so lang dass man das nicht auch 
einfach direkt als eine Funktion in die main.c schreiben könnte. Aber 
wenn du es auslagern willst, dann eben so.

gruß cyblord

[Pete K. (pete77)]

Normalerweise hast Du zu jeder Header-Datei (.h) eine Codedatei (.c). 
Diese beiden Dateien bilden ein Modul und sollten auch als gekapselt 
programmiert werden.

Du greifst von der main.c direkt auf Variablen in einem Modul zu. So 
etwas ist schlechter Stil und fehleranfällig (Seiteneffekte).

Ein gutes Buch (wenn nicht das C-Buch ist von Kernighan-Ritchie):
http://www.amazon.de/Programmieren-C-Reference-Manual-deutscher-Sprache/dp/3446154973/ref=sr_1_1/276-8358910-2845704?s=books&ie=UTF8&qid=1374741104&sr=1-1&keywords=3446154973

Dort steht alles drin.

[Cyblord -. (cyblord)]

Pete K. schrieb:
> Normalerweise hast Du zu jeder Header-Datei (.h) eine Codedatei (.c).
> Diese beiden Dateien bilden ein Modul und sollten auch als gekapselt
> programmiert werden.

Es wurde schon alles gesagt, nur noch nicht von jedem?

> Ein .c Datei und eine. h Datei bilden ein sog. MODUL. In der der Header
> Datei wird das Interface definiert. Auch die Datenstrukturen. In der .c
> Datei wird dieses Interface implementiert.

> Seiteneffekte
Ohoh damit rufst du die Sprach-Nazis auf den Plan. side effects = 
Nebeneffekte. Aber sag ich auch nicht ;-)

[Peter M. (allforone)]

Ok ich gönn mir dann gleich mal dein vorgeschlagenes Buch. Allerdings 
werde ich es in englisch bestellen, auf solche komischen Übersetzungen 
wie sie bei Amazon beschrieben sind habe ich keien Lust, die werden mich 
nur mehr verwirren.

[Cyblord -. (cyblord)]

Ich kann noch ein sehr gutes Buch empfehlen: "Clean Code" von Robert C. 
Martin. Beispiele sind zwar in Java, aber es geht nicht um die Sprache, 
sondern um die Konzepte von gutem Code.

gruß cyblord

[Peter M. (allforone)]

Ja, wobei ein Buch in der richtigen Sprache schon ganz schön wäre...

[Dirk (Gast)]

Ich erinnere mich noch gut daran:

mein erstes C-Programmierbuch (>25 Jahre her)
Keine Erfahrung mit Programmieren mit Bibliotheken.
Und dann kam der Satz:
"Benutzen Sie diese Funktion aus der Bücherei"

Super!
Dann doch lieber in Englisch....

[Cyblord -. (cyblord)]

Jan R. schrieb:
> Ja, wobei ein Buch in der richtigen Sprache schon ganz schön wäre...

Sprache und Konzept sollte man trennen können. Sonst wird man nie gut.

[Peter II (Gast)]

cyblord ---- schrieb:
>> Ja, wobei ein Buch in der richtigen Sprache schon ganz schön wäre...
>
> Sprache und Konzept sollte man trennen können. Sonst wird man nie gut.

dumm nur das Java OOP ist und C nicht. C hat dafür auch noch 
Headerdateien. Man kann halt nicht alles vergleichen. Es gibt konzepte 
die man in C anders umsetzt als bei java.

[Peter M. (allforone)]

"Benutzen Sie diese Funktion aus der Bücherei"
ja das sind die Klassiker....
Da wird man mehr verwirrt, als das einem diese Übersetzung hilft.
Ja nur ist das C Buch in Englisch noch zeitgemäß, ist ja schon fast 20 
Jahre alt. Nicht, dass der dann noch ältere englische Wörter benutzt...

[Cyblord -. (cyblord)]

Peter II schrieb:
> cyblord ---- schrieb:
>>> Ja, wobei ein Buch in der richtigen Sprache schon ganz schön wäre...
>>
>> Sprache und Konzept sollte man trennen können. Sonst wird man nie gut.
>
> dumm nur das Java OOP ist und C nicht. C hat dafür auch noch
> Headerdateien. Man kann halt nicht alles vergleichen. Es gibt konzepte
> die man in C anders umsetzt als bei java.

Ja sicher gibt es da Unterschiede. Das Buch ist auch keine Anleitung für 
gutes OOP, sondern für guten Code.
Es gibt leider nichts vergleichbares für C, darum muss man halt über das 
Java hinwegsehen. Es ist auch kein Anfängerbuch, welches einem die 
Sprachen näher bringen soll.
Hast du es mal gelesen? Danach diskutiere ich mit dir gerne weiter 
darüber.
Also back to Topic!