Mul­ti­pli­ka­ti­ons-Taschen­rech­ner

Das Tas­ten­feld soll dazu ver­wen­det wer­den um Mul­ti­pli­ka­tio­nen durch­zu­füh­ren und das Ergeb­nis soll im Seri­el­len Moni­tor und auf einem LCD ange­zeigt werden.

So sieht es aus:

Schlie­ße das LCD an:

➨LCD

Nor­ma­ler­wei­se wäre eine kom­ple­xe Ver­ka­be­lung zum Betrieb eines LCDs nötig. Der ➨I2C-Bus regelt über einen eige­nen Mikro­pro­zes­sor die Kom­mu­ni­ka­ti­on der Daten­lei­tun­gen unter­ein­an­der. Es wer­den des­halb nur vier Anschlüs­se benötigt.

Auf der Rück­sei­te befin­det sich ein Dreh­po­ten­tio­me­ter, mit dem die Hel­lig­keit des LCDs ein­ge­stellt wird.

Benö­tig­te Bibliotheken:

Benö­tig­te Bauteile:

• LCD 1602
• Laut­spre­cher
• Tas­ten­pad 3×4
• Lei­tungs­dräh­te

Baue die Schal­tung auf.
(Fah­re mit der Maus über das Bild, um die Bezeich­nun­gen der Bau­tei­le zu sehen)

Das Tas­ten­feld besteht aus Rei­hen und Spal­ten, die von unten nach oben in einem ➨zwei­di­men­sio­na­len Array ange­ord­net werden:

# include <Adafruit_Keypad.h>
# include <LiquidCrystal_I2C.h>

int LAUTSPRECHER = 13;

// Größe des Tastenfeldes
// 3 Spalten
const byte SPALTEN = 3;

// 4 Zeilen
const byte REIHEN = 4;

// die Ziffern/Zeichen:
// Array 3 x 4
char Tasten[REIHEN][SPALTEN] =
{
  { '#', '0', '*' },
  { '9', '8', '7' },
  { '6', '5', '4' },
  { '3', '2', '1' }
};

// die Pins für die 3 Spalten
byte SpaltenPins[SPALTEN] = { 3, 4, 5 };

// die Pins für die 4 Zeilen
byte ReihenPins[REIHEN] = { 6, 7, 8, 9 };

// TastenFeld → Name des Keypads
// -> Zuordnung der Pins zu den REIHEN und SPALTEN des Arrays
Adafruit_Keypad Tastenfeld = Adafruit_Keypad(makeKeymap(Tasten), ReihenPins, SpaltenPins, REIHEN, SPALTEN);

/*
  LCD initialisieren
  0x27 -> I2C-ID
  20 -> Anzahl der Zeichen pro Zeile
  4 -> Anzahl der Zeilen
*/
LiquidCrystal_I2C lcd(0x27, 20, 4);

// setzt die Position der Spalte auf dem LCD
int PositionSpalte = 0;

// char-Array für die eingegebenen Zeichen
char Zeichen[50];

// Position des eingegebenen Zeichens im char-Array
int Position = 0;

// beinhaltet die vollständige Rechnung
String Rechnung;

Wenn dir die ID des ver­wen­de­ten Dis­plays nicht bekannt ist, kannst du sie mit fol­gen­dem ➨Pro­gramm herausfinden.

Der set­up-Teil. Beach­te die Kommentare.

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

  // Tastenfeld starten
  Tastenfeld.begin();

  // LCD einschalten, Startbildschirm zeigen
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Mal-Rechner");
  lcd.setCursor(0, 1);
  lcd.print("--------------------");
  lcd.setCursor(0, 2);
}

Der loop-Teil: Beach­te die Kommentare

void loop()
{
  String GleichZeichen = " = ";
  lcd.setCursor(Position, 2);

  // Tastenfeld abfragen
  Tastenfeld.tick();

  while (Tastenfeld.available())
  {
    /*
      wenn eine Aufgabe ausgegeben wurde
      LCD löschen, Anzeige neu aufbauen
    */
    if (Rechnung != "")
    {
      Rechnung = "";
      lcd.clear();
      Position = 0;
      lcd.setCursor(0, 0);
      lcd.print("Mal-Rechner");
      lcd.setCursor(0, 1);
      lcd.print("--------------------");
      lcd.setCursor(0, 2);

      // char-Array Zeichen leeren
      for (int i = 0; i < sizeof(Zeichen); i ++)
      {
        Zeichen[i] = NULL;
      }

      Position = 0;
      PositionSpalte = 0;
    }

    // gedrückte Taste lesen
    keypadEvent Taste = Tastenfeld.read();

    // wenn die Taste losgelassen wurde
    // Wert abgefragter Taste zu char umwandeln
    if (Taste.bit.EVENT == KEY_JUST_RELEASED)
    {
      // eingegebenes Zeichen an der aktuellen Position speichern
      Zeichen[Position] = (char)Taste.bit.KEY;

      // Ton ausgeben
      tone(LAUTSPRECHER, 1000);
      delay(50);
      noTone(LAUTSPRECHER);

      // Zeichen anzeigen
      // # soll nicht angezeigt werden
      if (Taste.bit.KEY != 35)
      {
        Serial.print(Zeichen[Position]);
        lcd.print(Zeichen[Position]);
      }

      // nächstes Zeichen -> Position erhöhen
      Position ++;

      // Ausgabe LCD eine Position weiter
      PositionSpalte ++;

      // # (ASCII-Code = 35) gedrückt → Rechnung ausführen
      if (Taste.bit.KEY == 35)
      {
        // char-Array in String umwandeln
        Rechnung = String(Zeichen);

        // letztes Zeichen ist # → muss entfernt werden
        Rechnung = Rechnung.substring(0, Position - 1);

        // Position des Malzeichens bestimmen
        // Zählung beginnt mit 0
        int MalZeichen = Rechnung.indexOf('*');

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

        /*
          zweiter Faktor: von der Position hinter dem Malzeichen
          bis zum vorletzten Zeichen
          das letzte Zeichen ist # → soll entfernt werden
        */
        String FaktorZwei = Rechnung.substring(MalZeichen + 1, Rechnung.length());

        /*
           Produkt berechnen
           damit dürfen die beiden Faktoren nicht größer als
           32768 sein
           long Produkt = FaktorEins.toInt() * FaktorZwei.toInt();
           Zahlen nach long umwandeln
        */
        long ErsterFaktor = FaktorEins.toInt();
        long ZweiterFaktor = FaktorZwei.toInt();
        long Produkt =  ErsterFaktor * ZweiterFaktor;

        // String Rechnung "zusammenbauen"
        Rechnung = FaktorEins + " * " + FaktorZwei + GleichZeichen + String(Produkt);

        // Rechnung anzeigen
        RechnungAusgeben();
      }
    }
  }
}

Ergän­ze das Pro­gramm mit der Funk­ti­on Rech­nung­Aus­ge­ben().

void RechnungAusgeben()
{
  // Ausgabe Serieller Monitor
  Serial.println("\n" + Rechnung);

  // Ausgabe LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.noCursor();
  lcd.print("Mal-Rechner");
  lcd.setCursor(0, 1);

  lcd.print("--------------------");
  lcd.setCursor(0, 2);

  /* Länge der Rechnung bestimmen
     das LCD hat nur 20 Zeichen
     wenn es mehr als 20 sind → Zeilenumbruch beim =-Zeichen
  */
  int Laenge = Rechnung.length();

  if (Laenge > 20)
  {
    // Position des =-Zeichen bestimmen
    int GleichZeichen = Rechnung.indexOf('=');

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

    // Zeilenumbruch
    lcd.setCursor(0, 3);
    lcd.print(Rechnung.substring(GleichZeichen + 2, Rechnung.length()));
  }

  // wenn Laenge < 20 Zeichen
  else lcd.print(Rechnung);
}

Ver­wand­te Aufgaben:

• Auto­ma­ti­sche Tür mit Hall-Sensoren
• Count­down mit einer ein­stel­li­gen 7-Segment-Anzeige
• Count­down mit einem OLED-Display
• Far­ben­spie­le mit einer RGB-Matrix
• Glücks­rad mit NeoPixel-Ring
• Laby­­rinth-Spiel mit TFT und Fernbedienung
• Laby­rinth­spiel mit Joy­stick und TFT
• Län­­der-Info
• LED-Matrix - Countdown
• LED-Matrix - Joystick-Spiel
• LED-Matrix - Lauflicht
• LED-Matrix Wür­feln
• Lot­to­zah­len - Anzei­ge auf einem LCD
• Lot­to­zah­len - Anzei­ge auf einem OLED-Display
• Spiel mit einer RGB-Matrix
• Taschen­rech­ner Grundrechenarten
• Wür­feln ein­stel­li­ge 7-Seg­­ment-Anzei­­ge und Fernbedienung
• Wür­feln - Anzei­ge auf einem OLED-Display
• Wür­fel­spiel mit einer vier­stel­li­gen Anzeige
• Wür­feln mit einer ein­stel­li­gen Anzeige

Letzte Aktualisierung: 13. Mrz 2023 @ 12:37