#include <avr/io.h>

//////////Pin Variablen//////////

#define sinpin 5    //Ausgang für das pulsmodulierte Sinussignal
#define finalpin 4  //Ausgang für das Referenz-Rechtecksignal
#define input 0     //Eingang für das Messsignal


//////////Rechtecksignal//////////

float phase=25; //Phasenangabe für das Rechtecksignal. Durch den Wert 25 wird das Rechtecksignal auf den Startpunkt des Messsignals verschoben
float tphase=0;       //Variable zum Speichern des Zeitinhaltes zum Umwandeln der Variablenphase
float fase=0;         //Variable zum Speichern des letztendlichen Phaseninhaltes, der gebaraucht wird, um Rechtecksignal zu erzeugen
int squar=0;          //Variabele zur Angabe des Zustandes (HIGH oder LOW) des Rechtecksignals zum Multiplizieren mit der Spannungswelle
float valuesquare=0;  //Temporäre Variable zum Generieren des Rechtecksignals aus dem Sinussignal


//////////Variabeln zum Erzeugen des sinusförmigen Signals//////////


unsigned long time=0; //Variable zum Speichern des momentanen Zeitinhaltes
#define w 313.5       //w = Frequenz* 2 * Pi; 
float wt=0;           //wt = w * Zeit


//////////Eingangsvariablen//////////

double value=0;     //Temporäre Variable zum Erzeugen des Sinussignals, welches als PWM ausgegeben wird
#define maxim 126      //Amplitude des Sinussignals
float messsig=0;    //eingelesenes Signal über den Eingang 0
float messsigmV=0;  //Variable zum Speichern des Wertes messsig, umkonvertiert in mV
float messMW;       //Variable zum Speichern der addierten Abtastpunkte
float rechteck;     //Gibt den Zustand des Rechtecksignals an. Notwendig für die Synchrongleichrichtung


//////////Externe Variablen zum Löschen des Zählers von der Funktion millis() und micros()//////////


extern volatile unsigned long timer0_overflow_count; //Variable für den Overflowcounter
extern volatile unsigned long timer0_millis;         //Variable mit des Inhalt des Timers0, umkonvertiert in Millisekunden    


//////////Zählervariable//////////

int messcounter; //Anzahl der addierten Werte zum errechnen des Mittelwertes
int n;
int x;
int y;

//////////Merkervariable//////////

int merk; //Merkervariable zum Errechnen des Mittelwertes

/////////Ausgabe Variable/////////

float MW; // Ausgabe des zeitlichen Mittelwertes proportional zur Kraft

//////////Interne Konfigurationen//////////

void setup()
{

  Serial.begin(9600); //Beginnen mit der seriellen Übertragung bei 9600 Baud


  pinMode(finalpin, OUTPUT);

  //Initialisierung des Inhaltes des Timers 2
  timer0_overflow_count=30000; 
  TCCR2A = 0; //Normal port operation; Normal Waveform Generation
  TCCR2B = 1<<CS22 | 0<<CS21 | 0<<CS20; //Timer2 16Mhz/64 -- Herunterteilen der Quarzfrequenz mit Prescaler(Vorteiler)
  TIMSK2 = 1<<TOIE2; //Timer2 Overflow Interrupt Enable  

}

////////// Einbinden der Interrupt Service Routine//////////

ISR(TIMER2_OVF_vect)  //Interrupt Service Routine für Overflow Interrupt des Timers 2
{    
  if(micros()>100000000)   //Bedingung für das Zurücksetzen des Counters micros
    timer0_overflow_count=30000;

  time = micros();          //time wird gesetzt: Micros ist die Zeit in Microsekunden seit dem der Arduino gestartet worden ist
  wt=w*time;                //wt wird mit vorgegebenen Werten berechnet
  tphase= (phase*392)/360;  //Umwandlung der Phase in eine Zeitdomäne für das Rechtecksignal

  fase=w*tphase;            //letztendlich Phase, die dem Rechtecksignal eingegeben wird
  value= maxim*sin(wt);     //Sinusfunktion, die zum Generieren des PWM notwendig ist, wird erzeugt
  value = value+127;        //Es wird ein Offset auf die Sinusfunktion gegeben

  analogWrite(sinpin, value);       //Schreiben des Sinussignals in den sinuspin
  valuesquare= 1000*sin(wt + fase); //Sinusförmige Welle wird benutzt, um Rechtecksignal zu erzeugen

  if (valuesquare >= 0)
  {
    digitalWrite(finalpin,HIGH); // Schreiben des HIGH-Zustandes in den Finalpin
  }
  else
  {
    digitalWrite(finalpin,LOW); //Schreiben des LOW-Zustandes in den Finalpin
  }

  ///////////Einlesen des Messsignals//////////

  messsig = analogRead (input);     //Messsignal wird über den Eingang 0 eingelesen
  messsigmV = messsig * 5000/1027;  //digitaler Inhalt wird in Millivolt umgerechnet
  messsigmV=messsigmV-1367;         //Über den Instrumentenverstärker eingegebener Offset wird vom Messsignal subtrahiert

  //////////Einlesen des Rechtecksignals///////
  rechteck=digitalRead(finalpin);   //Einlesen des Zustandes des Rechtecksignals
 if (rechteck == 0)                 //Da das Rechteck einen Offset hat, nimmt es bei 0 den Wert -1 an, bei 1 den Wert 1
    {squar=-1;}
 else
    {squar=1;}

  //////////Gleichrichtung//////////

  messsigmV=messsigmV*squar;        //Gleichrichtung des Signals durch die Variable squar

    //////////Integration//////////

 messMW=messMW+messsigmV;          //Addieren der einzelnen Messwerte zueinander
  messcounter++;                    //Messcounter wird erhöht -- Festlegung durch welchen Wert die Addition geteilt wird

  if(squar==1 && merk==0)            //Bedingung: Wenn die Variable squar positiv ist und der Merker null--Auswertung negative Welle
  {    
    merk=1;                          //setze den Merker auf 1
  }
  if(squar==-1 && merk==1)           //Bedingung: Wenn die Variable squar negativ ist und der Merker eins ist--Auswertung positve Welle
  {
    merk=2;
  }
  if(squar==1 && merk==2)
  {
    x=messcounter;
    y=messMW;
    MW=messMW/messcounter;
    messcounter=0;
    messMW=0;
    merk=0;
  }
}


void loop()
{
  Serial.print(x     );   //Der errechnete Wert wird in Newton
  Serial.println(y);
  delay(1000);
  Serial.print('\r');  //Wert wird gelöscht und aktualisiert
 
}