// sketch_prog1a_2k

/*

Für einmalige (aperiodische) Ein- und Ausschaltvorgänge, 2-kanalig, in 300 Messwerte komprimiert (Triggerung b3):

Gemessen wird der Spulen-Strom durch den Spannungsabfall

U0 an einem zur Spule in Reihe geschalteten Widerstand R1. Diese nichtnegative Spannung wird über Kanal A1 gemessen,

die Induktionsspannung über den Pegelwandler IN0, letztlich über Kanal A0.

Liest Daten mit Werten im Bereich von 0 bis 1023 vom ANALOG INPUT
Kanal A1 und A0 ein und speichert sie schnell im SRAM des Prozessors ab
(max. 1999 Bytes verfügbar). Da ca. 400 Bytes für Programm-Variablen
benötigt werden, so dass ca. 1600 Bytes tatsächlich zur Verfügung
stehen, lassen sich pro Kanal maximal ca. 400 Messwerte à 2 Bytes speichern.

Dazu wird durch eine spezielle Triggerung dafür gesorgt, dass der
Vorgang mit dem Anstieg der Mess-Spannung U0 nach dem "Einschalten"
beginnt, dass der Prozessor nach Erreichen des stationären Werts
ohne Speicherung wartet, bis die Mess-Spannung vom stationären Wert
wieder abfällt, bis also der Ausschaltvorgang beginnt. Dann wird die
Speicherung fortgesetzt.

Die Daten werden als Paket von 150 Werten auf 5000 mV (bzw. an die
an PIN18 des ARDUINO liegende Vergleichsspannung) skaliert und dann
seriell an den Serial Monitor ausgegeben.

Die Mess-Schaltung enthält eine 1,5 V Monozelle, einen mechanischen
Taster, eine Spule (typ. L = 0,1 H), einen Messwiderstand R1 zur Messung
des Spulenstroms und einen Widerstand R2, der den Spulenstrom nach
dem "Abschalten" ermöglicht (beide typ. 100 Ohm). Der Spannungsabfall
an R1 ist die Messgröße als Maß für I.

Basis der Programmierung war ein Beispielprogramm:           http://www.arduino.cc/en/Tutorial/AnalogInOutSerial
*/

// Festlegung von Typ und Wert von Konstanten und Variablen

int utrigval = 4 ;   // untere Triggerschwelle
int otrigval ;  // obere Triggerschwelle
int mesw = 0 ;  // laufende Messwerte x in Warteschleifen; 0 <= x < 1024
int mesw1 = 0 ; // erster gültiger Messwert
int idx1 = 0 ;   // allmählich entstehender Maximalwert für den Laufindex idx

const int analogInPin1 = A1;  // Festlegung des Analogeingangs, über den die U0-Messungen vorgenommen werden
const int analogInPin0 = A0; // zusätzlich bei optionaler 2-kanaliger Wechselstrommessung der Induktionsspannung

int null = 490 ;   // Nullspannung bei Pegelanhebung durch Pegelwandler; sonst null = 0
// int mess[300] ;   // Array für 300 INTEGER-Werten (jeweils 2 Bytes) bei einkanaliger Messung

// Bei zweikanaliger Messung:

int mess1[150] ;    // Array für 150 INTEGER-Werten (2 Bytes); pro Datensatz doppelter Speicherplatz benötigt (4 Bytes)
int mess0[150] ;   // Array für weitere 150 INTEGER-Werten (2 Bytes)
int mesw = 0 ;      // laufender Messwert x in Triggerschleifen; 0 <= x < 1024

int outputValue1 ;
int outputValue0 ; // bei 2-kanaliger Messung

int nullValue ;

int nullValue0 ;

char eingabe ;  // ASCII-Wert der Tastatureingabe vom PC




int loop1 = 150 ; // Zahl der Datensätze, bei 2-kanaliger Messung;  sonst: int loop1 = 300 ;

long idx1 = 0 ;  // Maximalwert des Laufindexes idx


bool count = true ;
bool bereit = false;  // 0

void setup()

{ Serial.begin(57600);

  // Initialisierung der seriellen Kommunikation mit 57600 bps
  // initialize control over the keyboard:
  //  Keyboard.begin(); Offenbar nicht nötig
}

char eingabe ;  // ASCII-Wert der Tastatureingabe vom PC
long zeit1 ;   // Dauer der Registrierung für den Einschaltvorgang in mikrosec
long zeit ;     // Gesamtdauer der Registrierung in mikrosec
long zwi ;     // Zwischenergebnis Zeitmessung
long time ;    // laufende Zeit je nach Datensatz-Nummer

long av ;      // durchschnittlicher Messwert, für Nulllinie

int loop1 = 80 ; // 80 Messungen in ca. 8 ms; ca 0,11 ms pro Messung; Teilmessung für Einschaltvorgang
int loop2 =300 ; // Gesamtzahl der Datensätze

bool count = true ;
bool bereit = false;  // 0
 

void loop() { // Hauptschleife
 



// Triggerschleife 1: Stellt fest, ob Eingabetaste am PC gedrückt. Könnte auch wegfallen.

bereit = true ;

while ( bereit == true or eingabe == !'0' )    // Drehe Schleife bis bereit = false  (bzw. 0): keine Taste gedrückt
{ eingabe = Serial.read();          
   bereit = Serial.available();  Serial.println(bereit); }
 
 bereit = false;
 
while ( bereit == false )  // Drehe Schleife bis bereit = true (bzw. 1): Taste gedrückt
 { bereit = Serial.available();   } // jetzt Taste gedrückt


// Triggerung für Einschaltvorgang:

 mesw=100 ;

 

// Triggerschleife 2: Dreht Schleife ohne Registrierung bis Messwert an A1 auf  0 abgefallen, damit Einschaltvorgang aus Messwert = 0 startet;

while  (mesw > 0)   
 { mesw = analogRead(analogInPin1); }

// Triggerschleife 3  // Dreht Schleife ohne Registrierung bis Messwert an A1 > untere Triggerschwelle;

 while  (mesw <= utrigval)   
   { mesw = analogRead(analogInPin1); }

// jetzt Messwert auf Wert über untere Triggerschwelle gestiegen: Registrierung des Datenpakets für Einschaltvorgang kann beginnen

// Justierung der Nulllinie für Kanal A0 (im Leerlauf): fehlt noch

mesw = 0 ;
mesw1 = mesw ;
bereit = false;
zeit1 = micros();


// Mess-Schleife1 für Einschaltvorgang

  for (int idx = 1; idx < loop1; idx++)
  {mess1[idx] = analogRead(analogInPin1);    // Messung über Analogeingang, der durch die Konstante analogInPin0 bestimmt ist
   mess0[idx] = analogRead(analogInPin0);  // bei 2-kanaliger Messung
   } // erster Teil-Datensatz - Einschaltvorgang - verarbeitet

zeit1 = micros() -zeit1;   // Zeitdauer für Messung und Speicherung von  loop1 Messdaten


// Triggerschleife 4: wartet bis Ausschaltvorgang beginnt

otrigval =analogRead(analogInPin1);   // obere Triggerschwelle
mesw = otrigval ;

while  (mesw >= otrigval-4)    // Drehe Schleife bis Messwert < obere  Triggerschwelle-4 :

{ mesw = analogRead(analogInPin1); }

// jetzt Messwert auf Wert unter der oberen Triggerschwelle abgesunken: Messung des
// Datenpakets für Ausschaltsvorgang kann beginnen

// Mess-Schleife2 für Ausschaltvorgang:

zeit =  micros() ;

for (int idx = loop1; idx < loop2; idx++)

{mess1[idx] = analogRead(analogInPin1);   // Messung über Analogeingang, der durch die Konstante analogInPin1 bestimmt ist

mess0[idx] = analogRead(analogInPin0);  // bei 2-kanaliger Messung

}

// ganzer Datensatz verarbeitet

zeit = micros() - zeit;   // Ermittlung der Restzeit bis Ende des Datensatzes (Ausschaltvorgang)

zeit = zeit1 + zeit ;      // Gesamtdauer der Messungen mit Speicherung

mess0[0] = mesw1 ;     // erster relevanter Messwert vor Mess-Schleife 1 für Einschalten ergänzt

mess0[0] = null ;  // erster relevanter Messwert vor Mess-Schleife 1 für Einschalten ergänzt   ???
mess1[0] = null ; 

  // Ausgabeschleife

  for (int idx = 0; idx < loop2; idx++)

  {
  idx1 = idx ;
  time = (zeit/loop2)*idx;   //  laufende Zeit zu Messwert mit Nummer idx

outputValue1 = map(mess1[idx], 0, 1023, 0, 5000);  // Umwandlung in mV (Skalierung)

outputValue0 = map(mess0[idx], 0, 1023, 0, 5000); // bei 2-kanaliger Messung


Serial.print(idx); Serial.print(",");  Serial.print(time); Serial.print(","); Serial.print(outputValue1);  Serial.print(",");       Serial.println(outputValue0);  Serial.print(","); Serial.print(nullValue); Serial.println(""); 

   // Serial.print(nullValue);  // dient zum Zeichnen der Nulllinie

?????
Serial.print("Zeitintervall in microsec = "); Serial.println(zeit/loop2); Serial.println("") ;

delay(1000); bereit = true ;

Serial.println("") ; Serial.print("Nächste Runde, wenn PC-Taste gedrückt !") ; Serial.println("") ;

  // nächste Runde
}