#include <stdio.h>
#include <EEPROM.h>

#define GAIN_128 25
#define GAIN_64 27
#define NUMBER_OF_HX711 11
#define M 20 // Anzahl Messwerte pro Messstelle

// Pinbelegungen für CLK und DAT der Sensoren
const int HX711_dout[NUMBER_OF_HX711] = {22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42};
const int HX711_sck[NUMBER_OF_HX711] = {23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43};


// Globale Variable für die Messdaten
unsigned long tab_Messdaten_raw[M][NUMBER_OF_HX711];
float tab_Messdaten_newton[M][NUMBER_OF_HX711];

// Globale Variablen für die Mittelwerte der HX711-Sensoren
float mittelwerte[NUMBER_OF_HX711];

// Globale Variablen für die Nullkalibrierung
float cal_zero_mass[NUMBER_OF_HX711]; //Kalibrierungswert ohne aufgebrachtes Gewicht
float known_mass[NUMBER_OF_HX711]; //Bekanntes Gewicht zum Kalibrieren in kg
float cal_known_mass[NUMBER_OF_HX711]; //Kalibrierungswert mit aufgebrachtem Gewicht
float cal_factor[NUMBER_OF_HX711]; //Kalibrierungsfaktor in Newton

// Funktionsprototypen
inline unsigned long readHX711(int j);
inline void print_Messdaten(unsigned long tab[][NUMBER_OF_HX711]);
inline void print_Messdaten(float tab[][NUMBER_OF_HX711]);
float berechneMittelwert(int sensorPosition);
void kalibrieren();

void setup() {
  Serial.begin(57600); //Baudrate ggf. an den Arduino anpassen
    for (int a = 0; a < NUMBER_OF_HX711; a++) {
      pinMode(HX711_dout[a], INPUT);
      pinMode(HX711_sck[a], OUTPUT);
    }
  
    // Daten aus dem EEPROM lesen und in globalen Variablen speichern
  for (int i = 0; i < NUMBER_OF_HX711; i++) {
    EEPROM.get(i * sizeof(float), cal_zero_mass[i]);
    EEPROM.get(i * sizeof(float) + sizeof(float), cal_known_mass[i]);
    EEPROM.get(i * sizeof(float) + sizeof(float) + sizeof(float), known_mass[i]);
    EEPROM.get(i * sizeof(float) + sizeof(float) + sizeof(float)+ sizeof(float), cal_factor[i]);
  }

  Serial.println("Eingabe drücken zum starten");
}

void loop() {
  int choice;

  while (!Serial.available()) {
    // Warten, bis eine Eingabe über die serielle Schnittstelle erfolgt
  }
  choice = Serial.parseInt();

  switch (choice) {
    case 0:
      Serial.println("Bitte wählen Sie eine Option (1-5):");
      Serial.println("Option 1: Messen");
      Serial.println("Option 2: Messdaten anzeigen");
      Serial.println("Option 3: Mittelwert für eine Messstelle berechnen");
      Serial.println("Option 4: Kalibrieren");
      Serial.println("Option 5: EEPROM anzeigen");
      break;
    case 1:
      Serial.println("Option 1 ausgewählt: Messung wird durchgeführt...");
      for (int i = 0; i < M; i++) {
        
        Serial.print("Messung ");
        Serial.println(i + 1);
        for (int j = 0; j < NUMBER_OF_HX711; j++) {
          unsigned long raw = readHX711(j);
          tab_Messdaten_raw[i][j] = raw;
          tab_Messdaten_newton[i][j] = (raw - cal_zero_mass[j]) * cal_factor[j];
          
        }
        delay(500); // Abtastrate von 0,5 Hz
      }
      Serial.println();
      Serial.println("Messung beendet");
      break;
    case 2:
      Serial.println("Option 2 ausgewählt: Messdaten werden angezeigt...");
      print_Messdaten(tab_Messdaten_raw);
      print_Messdaten(tab_Messdaten_newton);
      Serial.println();
      break;
    case 3:
      Serial.println("Option 3 ausgewählt: Mittelwert für eine Messstelle wird berechnet...");
      int sensorPosition;
      Serial.println("Bitte wählen Sie einen HX711-Sensor (1-11):");
      while (!Serial.available()) {
        // Warten, bis eine Eingabe über die serielle Schnittstelle erfolgt
      }
      sensorPosition = Serial.parseInt();
      if (sensorPosition >= 1 && sensorPosition <= NUMBER_OF_HX711) {
        mittelwerte[sensorPosition - 1] = berechneMittelwert(sensorPosition - 1);
        Serial.print("Mittelwert für Sensor ");
        Serial.print(sensorPosition);
        Serial.print(": ");
        Serial.println(mittelwerte[sensorPosition - 1]);
      } else {
        Serial.println("Ungültige Sensorposition!");
      }
      break;
    case 4:
      Serial.println("Option 4 ausgewählt: Kalibrieren...");
      kalibrieren();
      break;
    case 5:
      Serial.println("Option 5 ausgewählt: EEPROM anzeigen...");
      Serial.print("Messstelle  | ");
      Serial.print("Nullwert    | ");
      Serial.print("Mit Gewicht | ");
      Serial.print("Gewicht     | ");
      Serial.println("Cal-Faktor  | ");
      Serial.println("----------------------------------------------------------------------");
        for(int j = 0; j < NUMBER_OF_HX711; j++){
          Serial.print("Messstelle ");
          Serial.print(j + 1); // Zeilenüberschriften
          Serial.print("| ");
              
              Serial.print(cal_zero_mass[j]);
              Serial.print("  |");
              Serial.print(cal_known_mass[j]);
              Serial.print("  |");
              Serial.print(known_mass[j]);
              Serial.print("       |");
              Serial.print(cal_factor[j], 8);
              Serial.println(" |");
        }
      break;
    default:
      Serial.println("Ungültige Eingabe!");
      break;
  }

  // Warten, bis alle seriellen Daten gesendet wurden
  Serial.flush();
}

inline unsigned long readHX711(int j) {
  unsigned long data = 0;

  // Warten, bis das Datenbit verfügbar ist
  while (digitalRead(HX711_dout[j])) {}

  // Datenbit lesen
  for (uint8_t i = 0; i < 24; i++) {
    digitalWrite(HX711_sck[j], HIGH);
    delayMicroseconds(1); // Mindestens 0.2 µs warten
    data = (data << 1) | digitalRead(HX711_dout[j]);
    digitalWrite(HX711_sck[j], LOW);
    delayMicroseconds(1); // Mindestens 0.2 µs warten
  }

  data = data ^ 0x800000; // Bit 23 umkehren

  return data;
}

inline void print_Messdaten(unsigned long tab[][NUMBER_OF_HX711]) {
  Serial.println("Messstelle;Messstelle 1;Messstelle 2;Messstelle 3;Messstelle 4;Messstelle 5;Messstelle 6;Messstelle 7;Messstelle 8;Messstelle 9;Messstelle 10;Messstelle 11");
  for (int i = 0; i < M; i++) {
    
    Serial.print("Messung ");
    Serial.print(i + 1);
    for (int j = 0; j < NUMBER_OF_HX711; j++) {
      Serial.print(";");
      Serial.print(tab_Messdaten_raw[i][j]);
    }
  }
  Serial.println();
}

inline void print_Messdaten(float tab[][NUMBER_OF_HX711]) {
  Serial.println("Messstelle;Messstelle 1;Messstelle 2;Messstelle 3;Messstelle 4;Messstelle 5;Messstelle 6;Messstelle 7;Messstelle 8;Messstelle 9;Messstelle 10;Messstelle 11");
  for (int i = 0; i < M; i++) {
    
    Serial.print("Messung ");
    Serial.print(i + 1);
    for (int j = 0; j < NUMBER_OF_HX711; j++) {
      Serial.print(";");
      Serial.print(tab_Messdaten_newton[i][j]);
    }
  }
  Serial.println();
}

float berechneMittelwert(int sensorPosition) {
  unsigned long summe = 0;
  for (int i = 0; i < M; i++) {
    summe += tab_Messdaten_raw[i][sensorPosition];
  }
  return summe / (float)M;
}

void kalibrieren() {
  
  int sensorPosition;
  char zeichen;
 
 Serial.println("Bitte wählen Sie eine Messstelle (1-11) für die Kalibrierung:");
 
int trash = Serial.parseInt();//reading int from Serial to clear serial 
  
    while (Serial.available()==0){
       }
       sensorPosition = Serial.parseInt(); //reading long int from Serial
       Serial.print("Ausgewählte Messstelle: ");
       Serial.println(sensorPosition); // checking it works corectly 
  
  Serial.println();

  Serial.println("Bitte sicherstellen, dass keine Gewichtskraft aufgebracht ist. Für Bestätigung bitte 'Eingabe' drücken");
  
  trash = Serial.parseInt();//reading long int from Serial to clear serial  
  
    while (Serial.available()==0){
       }
        
          Serial.println();
          Serial.println("Messung ohne Gewichtskraft wird durchgeführt...");

cal_zero_mass[sensorPosition - 1] = 0.0; // Initialisieren des Wertes

for (int i = 0; i < M; i++) {
    unsigned long raw1 = readHX711(sensorPosition - 1);
    cal_zero_mass[sensorPosition - 1] += raw1;
    Serial.print("Messung ");
    Serial.print(i);
    Serial.print(": ");
    Serial.println(raw1); // Überprüfen, ob die Rohdaten korrekt gelesen werden
    delay(100); // Abtastrate von 0,5 Hz
} 

cal_zero_mass[sensorPosition - 1] /= M;

  
  
  Serial.print("Mittelwert ohne Gewichtskraft: ");
  Serial.println(cal_zero_mass[sensorPosition - 1]);

  Serial.println("Diesen Wert auf dem EEPROM speichern? Ja: 1; Nein: 0 :");
  trash = Serial.parseInt();//reading int from Serial to clear serial  
  int save_answ; //Var for upcoming yes/no answer

    while (Serial.available()==0){
       }
       save_answ = Serial.parseInt();
        if (save_answ == 1) {
          EEPROM.put(sensorPosition * sizeof(float), cal_zero_mass[sensorPosition - 1]);
          Serial.println("Wert erfolgreich auf dem EEPROM gespeichert.");
        }
        else {
          Serial.println("Wert nicht auf dem EEPROM gespeichert.");
        }

  // Weiter zur Kalibrierung mit Gewichtskraft
  Serial.println("Bitte ein bekanntes Gewicht aufbringen. Für Bestätigung bitte 'Eingabe' drücken");
  
  trash = Serial.parseInt();//reading int from Serial to clear serial

  while (!Serial.available()) {
    // Warten, bis eine Eingabe über die serielle Schnittstelle erfolgt
  }
  
  Serial.println("Bitte den Betrag des aufgebrachten Gewichts in kg als Dezimalzahl mit 2 Dezimalstellen eingeben:");
  
  trash = Serial.parseInt();//reading long int from Serial to clear serial

  while (!Serial.available()) {
    // Warten, bis eine Eingabe über die serielle Schnittstelle erfolgt
  }
  known_mass[sensorPosition - 1] = 0.0;
  cal_known_mass[sensorPosition - 1] = 0.0; // Initialisieren des Wertes

    known_mass[sensorPosition -1] = Serial.parseFloat();
    Serial.print("Aufgebrachtes Gewicht: ");
    Serial.print(known_mass[sensorPosition -1 ]);
    Serial.println("kg");
    Serial.println();

          Serial.println("Messung mit bekanntem Gewicht wird durchgeführt...");
          for (int i = 0; i < M; i++) {
            unsigned long raw2 = readHX711(sensorPosition - 1);
            cal_known_mass[sensorPosition - 1] += raw2;
            Serial.print("Messung ");
            Serial.print(i);
            Serial.print(": ");
            Serial.println(raw2); // Überprüfen, ob die Rohdaten korrekt gelesen werden
            delay(100); // Abtastrate von 0,1 Hz
          } 
    cal_known_mass[sensorPosition - 1] /= M;

  Serial.print("Mittelwert der Messwerte mit bekanntem Gewicht: ");
  Serial.println(cal_known_mass[sensorPosition - 1]);

//Kalibrierungsfaktor für jede Messstelle in Newton berechnen
  float g = 9.81; //Erdbeschleunigung in m/s^2
  cal_factor[sensorPosition -1] = 0.0;
  cal_factor[sensorPosition -1] = (known_mass[sensorPosition - 1] * g) / (cal_known_mass[sensorPosition - 1] - cal_zero_mass[sensorPosition - 1]);

  Serial.print("Kalibrierungsfaktor: ");
  Serial.println(cal_factor[sensorPosition - 1], 10);

  Serial.println("Diesen Wert auf dem EEPROM speichern? Ja: 1; Nein: 0 :");
  trash = Serial.parseInt();//reading long int from Serial to clear serial  
  int save_answ2; //Var for upcoming yes/no answer

    while (Serial.available()==0){
       }
       save_answ2 = Serial.parseInt();
        if (save_answ2 == 1) {
          EEPROM.put(sensorPosition * sizeof(float) + sizeof(float), cal_known_mass[sensorPosition - 1]);
          EEPROM.put(sensorPosition * sizeof(float) + sizeof(float) + sizeof(float), known_mass[sensorPosition -1]);
          EEPROM.put(sensorPosition * sizeof(float) + sizeof(float) + sizeof(float)+ sizeof(float), cal_factor[sensorPosition -1]);
          Serial.println("Werte erfolgreich auf dem EEPROM gespeichert.");
        }
        else {
          Serial.println("Wert nicht auf dem EEPROM gespeichert.");
        }

}