Multiplikations-Taschenrechner

Lese­zeit: 6 Minu­ten
Navi­ga­ti­on

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.

Bevor du star­ten kannst musst du eine Biblio­thek instal­lie­ren:
Sketch → Biblio­thek ein­bin­den → Biblio­the­ken verwalten

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)

Neben der Biblio­thek und den Varia­blen des ➨Tas­ten­felds musst du die Biblio­thek LiquidCrystal_I2C einbinden:

// Keypad einbinden und Arrays definieren
# include <Keypad.h>

/*
  Größe des Tastenfeldes
  3 Spalten
  da Arrays immer statisch sind, muss SPALTEN/REIHEN als statisch (const) definiert werden
*/
const byte SPALTEN = 3;

// 4 Zeilen
const byte REIHEN = 4;

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

// die Pins für die 4 Reihen 
byte ReihenPins[REIHEN] = {8, 9, 10, 11};

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

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

# include <LiquidCrystal_I2C.h> 
LiquidCrystal_I2C lcd(0x27, 20, 4);

0×27 ist die ID des I2C-Busses, 20 bestimmt die Anzahl der Zei­chen pro Zei­le, 4 nennt die Anzahl der Zeilen.

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

Jetzt kann die eigent­li­che Pro­gram­mie­rung begin­nen.
Lege zusätz­li­che Varia­ble fest:

// setzt die Position der Spalte 
int Position = 0; 

// beinhaltet die vollständige Rechnung 
String Rechnung; 

// temporäre Speicherung der gedrückten Tasten 
String Eingabe; 
char gedrueckteTaste; 
int LAUTSPRECHER = 13; 

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

  // LCD einschalten   
  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);  

  // gedrückte Taste abfragen 
  gedrueckteTaste = TastenFeld.getKey(); 

  // wenn eine Taste gedrückt wurde 
  if (gedrueckteTaste)  
  {  
    tone(LAUTSPRECHER, 1000);  
    delay(50); 
    noTone(LAUTSPRECHER);  

    /* 
      wenn eine Aufgabe gerechnet 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);    
   } 

   // Ausgabe eine Position weiter  
   Position ++;   

   // # soll nicht angezeigt werden  
   if (gedrueckteTaste != '#') lcd.print(gedrueckteTaste);     

   // gedrueckteTaste dem String Eingabe hinzufügen       
   Eingabe = Eingabe + gedrueckteTaste; 
   // oder Kurzform: Eingabe += gedrueckteTaste; 

   // # gedrückt → Rechnung ausführen   
   if (gedrueckteTaste == '#')   
   {    
     // letztes Zeichen ist # → muss entfernt werden        
     Rechnung = Eingabe.substring(0, Eingabe.length() - 1);       
     
     // Position des Malzeichens bestimmen    
     // Zählung beginnt mit 0     
     int MalZeichen = Eingabe.indexOf('*');  

     // erster Faktor: von 0 bis zur Position des Malzeichens         
     String FaktorEins = Eingabe.substring(0, MalZeichen);       
     /* 
       zweiter Faktor: von der Position hinter dem Malzeichen          
       bis zum vorletzten Zeichen  
       das letzte Zeichen ist # → soll entfernt werden
     */     
     String FaktorZwei = Eingabe.substring(MalZeichen + 1, Eingabe.length() - 1);  
     /* 
        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();     
      Eingabe = "";   
    } 
  } 
}

Ergän­ze das Pro­gramm mit der Metho­de Rech­nungAus­ge­ben().

void RechnungAusgeben()
{
  // Ausgabe Serieller Monitor 
  Serial.println(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 < 20 Zeichen ...
  else lcd.print(Rechnung);
}

Ver­wand­te Aufgaben:

Letzte Aktualisierung: 29. Dez 2020 @ 12:43