Taschen­rech­ner Grundrechenarten

# include "LiquidCrystal_I2C.h"

// LCD Port festlegen
LiquidCrystal_I2C lcd(0x27, 20, 4);

String Eingabe;
String Rechnung;
float Ergebnis;
bool BuchstabeGefunden = false;
bool DivisionNull = false;

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // LCD einschalten
  lcd.init();
  lcd.backlight();

  // LCD einschalten
  lcd.init();
  lcd.backlight();

  // Erklärung anzeigen Serieller Monitor
  Serial.println("Taschenrechner");
  Serial.println("_______________________");
  Serial.println("+\tAddition");
  Serial.println("-\tSubtraktion");
  Serial.println("*\tMultiplikation");
  Serial.println(":\tDivision");
  Serial.println("_______________________");

  // LCD
  lcd.setCursor(0, 0);
  lcd.print("+ Addition");
  lcd.setCursor(0, 1);
  lcd.print("- Subtraktion");
  lcd.setCursor(0, 2);
  lcd.print("* Multiplikation");
  lcd.setCursor(0, 3);
  lcd.print(": Division");
}

void loop()
{
  String GleichZeichen = " = ";
  lcd.setCursor(0, 0);
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n = return eingegeben wurde
    Eingabe = Serial.readStringUntil('\n');

    lcd.clear();

    // Addition
    // "+" Zeichen suchen
    if (Eingabe.indexOf('+') > 0)
    {
      int PlusZeichen = Eingabe.indexOf('+');

      // erster Summand: von 0 bis zur Position des Pluszeichens
      String SummandEins = Eingabe.substring(0, PlusZeichen);

      // Leerzeichen entfernen
      SummandEins.trim();
      
      // für die Rechnung , durch . ersetzen
      SummandEins.replace(",", ".");

      // zweiter Summand: von der Position hinter dem Pluszeichen
      // bis zum letzten Zeichen
      String SummandZwei = Eingabe.substring(PlusZeichen + 1, Eingabe.length());

      // Leerzeichen entfernen
      SummandZwei.trim();

      // für die Rechnung , durch . ersetzen
      SummandZwei.replace(",", ".");

      // rechnen
      Ergebnis = SummandEins.toFloat() + SummandZwei.toFloat();

      // prüfen, ob Ergebnis eine natürliche Zahl
      String StringPruefen = NullEntfernen(String(Ergebnis));

      // String Rechnung "zusammenbauen"
      Rechnung = SummandEins + " + " + SummandZwei + GleichZeichen + String(StringPruefen);

      Rechnung.replace(".", ",");

      BuchstabeGefunden = BuchstabeSuchen(SummandEins + SummandZwei);
    }

    // Subtraktion
    // "-" Zeichen suchen
    if (Eingabe.indexOf('-') > 0)
    {
      int MinusZeichen = Eingabe.indexOf('-');

      // Minuend: von 0 bis zur Position des Minuszeichens
      String Minuend = Eingabe.substring(0, MinusZeichen);

      // Leerzeichen entfernen
      Minuend.trim();

      // für die Rechnung , durch . ersetzen
      Minuend.replace(",", ".");

      // Subtrahend: von der Position hinter dem Minuszeichen
      // bis zum letzten Zeichen
      String Subtrahend = Eingabe.substring(MinusZeichen + 1, Eingabe.length());

      // Leerzeichen entfernen
      Subtrahend.trim();

      // für die Rechnung , durch . ersetzen
      Subtrahend.replace(",", ".");

      // rechnen
      Ergebnis = Minuend.toFloat() - Subtrahend.toFloat();

      // prüfen, ob Ergebnis eine natürliche Zahl
      String StringPruefen = NullEntfernen(String(Ergebnis));

      // String Rechnung "zusammenbauen"
      Rechnung = Minuend + " - " + Subtrahend + GleichZeichen + String(StringPruefen);
      Rechnung.replace(".", ",");

      // nach Buchstaben suchen
      BuchstabeGefunden = BuchstabeSuchen(Subtrahend + Minuend);
    }

    // Multiplikation
    // "*" Zeichen suchen
    if (Eingabe.indexOf('*') > 0)
    {
      int MalZeichen = Eingabe.indexOf('*');

      // erster Faktor: von 0 bis zur Position des Malzeichens
      String FaktorEins = Eingabe.substring(0, MalZeichen);

      // Leerzeichen entfernen
      FaktorEins.trim();

      // für die Rechnung , durch . ersetzen
      FaktorEins.replace(",", ".");

      // zweiter Faktor: von der Position hinter dem Malzeichen
      // bis zum letzten Zeichen
      String FaktorZwei = Eingabe.substring(MalZeichen + 1, Eingabe.length());

      // Leerzeichen entfernen
      FaktorZwei.trim();

      // für die Rechnung , durch . ersetzen
      FaktorZwei.replace(",", ".");

      // rechnen
      Ergebnis = FaktorEins.toFloat() * FaktorZwei.toFloat();

      // prüfen, ob Ergebnis eine natürliche Zahl
      String StringPruefen = NullEntfernen(String(Ergebnis));

      // String Rechnung "zusammenbauen"
      Rechnung = FaktorEins + " * " + FaktorZwei + GleichZeichen + String(StringPruefen);
      Rechnung.replace(".", ",");
    }

    // Division
    // ":" Zeichen suchen
    if (Eingabe.indexOf(':') > 0)
    {
      int GeteiltZeichen = Eingabe.indexOf(':');
      // Dividend: von 0 bis zur Position des Geteiltzeichens
      String Dividend = Eingabe.substring(0, GeteiltZeichen);

      // Leerzeichen entfernen
      Dividend.trim();

      Dividend.replace(",", ".");

      // Divisor: von der Position hinter dem Geteiltzeichen
      // bis zum letzten Zeichen
      String Divisor = Eingabe.substring(GeteiltZeichen + 1, Eingabe.length());

      // Leerzeichen entfernen
      Divisor.trim();
      Divisor.replace(",", ".");

      /* String Rechnung "zusammenbauen"
         Besonderheit: das Ergebnis einer Division kann eine Kommazahl sein
         -> Datentyp float -> Kommazahlen
         Ergebnis zeigt nur 2 Nachkommastellen
      */

      // Division durch 0 nicht möglich
      if (Divisor == "0")
      {
        DivisionNull = true;

        // String Rechnung ohne Ergebnis "zusammenbauen"
        Rechnung = Dividend + " : " + Divisor + GleichZeichen;
      }

      // Divisor != 0 -> rechnen
      else
      {
        Ergebnis = Dividend.toFloat() / Divisor.toFloat();
        String StringPruefen = NullEntfernen(String(Ergebnis));

        // String Rechnung "zusammenbauen"
        Rechnung = Dividend + " : " + Divisor + GleichZeichen + String(StringPruefen);
        BuchstabeGefunden = BuchstabeSuchen(Dividend + Divisor);

        // . durch , ersetzen
        Rechnung.replace(".", ",");
      }
    }

    // wenn kein Buchstabe gefunden wurde oder Divisor != 0 -> Rechnung ausgeben
    if (!BuchstabeGefunden && !DivisionNull) RechnungAusgeben();

    // Division durch 0 -> Meldung anzeigen
    if (DivisionNull)
    {
      Serial.println(Rechnung);
      Serial.println("Division durch 0 ist verboten ;-)");
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(Rechnung);
      lcd.setCursor(0, 1);
      lcd.print("Divison durch 0");
      lcd.setCursor(0, 2);
      lcd.print("ist verboten ;-)");
    }

    // Buchstabe eingegeben -> Meldung anzeigen
    if (BuchstabeGefunden)
    {
      Rechnung = Rechnung.substring(0, Rechnung.indexOf('='));
      Serial.println(Rechnung);
      Serial.println("Buchstaben sind nicht erlaubt ;-)");
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(Rechnung);
      lcd.setCursor(0, 1);
      lcd.print("Buchstaben sind ");
      lcd.setCursor(0, 2);
      lcd.print("nicht erlaubt ;-)");
    }

    // Eingaben löschen, Fehlervariablen auf false setzen
    Rechnung = "";
    Eingabe = "";
    DivisionNull = false;
    BuchstabeGefunden = false;
  }
}

void RechnungAusgeben()
{
  // Ausgabe Serieller Monitor
  Serial.println(Rechnung);

  // Ausgabe LCD
  lcd.clear();

  // Ergebnis zu String umwandeln, damit die Länge bestimmt werden kann
  String LaengeErgebnis = String(Ergebnis);

  lcd.setCursor(0, 0);
  int laenge = Rechnung.length();

  // wenn die Länge der Rechnung > 20
  if (laenge > 20)
  {
    // Position des =-Zeichen bestimmen
    int GleichZeichen = Rechnung.indexOf('=');

    // Rechnung bis =-Zeichen anzeigen
    lcd.print(Rechnung.substring(0, GleichZeichen + 1 ));

    // Ergebnis anzeigen
    lcd.setCursor(0, 1);
    lcd.print(Rechnung.substring(GleichZeichen + 2, Rechnung.length()));
  }

  // Rechnung passt in eine Zeile
  else lcd.print(Rechnung);
}

bool BuchstabeSuchen(String Pruefen)
{
  bool BuchstabeGefunden = false;

  // wenn das Zeichen im zu prüfenden String ein Buchstabe (isAlpha) ist
  // -> BuchstabeGefunden = true
  for (int i = 0; i < Pruefen.length(); i++)
  {
    if (isAlpha(Pruefen.charAt(i)))
    {
      BuchstabeGefunden = true;

      // nicht weiter suchen Schleife verlassen
      break;
    }
  }

  return BuchstabeGefunden;
}

String NullEntfernen(String PruefString)
{
  String TestString;
  PruefString.replace(" ", "");

  // wenn die letzten Ziffern 00 sind -> Ergebnis ist natürliche Zahl
  if (PruefString.indexOf(".00") > 0)
  {
    TestString = PruefString.substring(0, PruefString.indexOf(".00"));
  }
  else TestString = PruefString;

  return TestString;
}