Forum: Mikrocontroller und Digitale Elektronik Taschenrechner auf ATMega88


von Manuel F. (noobhoch10)


Angehängte Dateien:

Lesenswert?

Hallo zusammen,

ich möchte einen einfachen Taschenrechner auf dem ATMega88 realisieren. 
Der Rechner soll über das LCD Display und die 4 Tasten bedient 
werden.Keine Kommazahlen und nur 4 Rechenorperationen ( + - * / ). 
Leider bin ich auf dem Gebiet der Programmierung ein absoluter Anfänger 
und habe keine Ahnung wie ich mein SChema in C umsetzen soll und ob 
dieses überhaupt korrekt ist.

Vielleicht kann mir jemand weiterhelfen und einen Lösungsweg beschreiben 
oder eine C-Datei schicken.

Vielen Dank!

von Gregor W. (gregor78)


Lesenswert?

Hallo Manuel,
ein Tipp aus eigener Erfahrung:
Fange mal mit einfachen Problemen an: Leuchtdioden schalten(mit 
Warteschleifen, Interrupt, Timer), 7-Segmentanzeigen usw. Dann kannst Du 
an den Taschenrechner gehen. Sonst wirst Du nur frustriert sein.
Ich habe für den Einstieg einen ATmega16 im DIL-Gehäuse genommen. Damit 
sind die Schaltungen schnell auf einem Steckbrett aufgebaut.
Grüße Gregor

von Manuel F. (noobhoch10)


Lesenswert?

Hallo Gregor,

also die LED habe ich bis auf Interrupts schon zum Blinken gebracht, so 
weit bin ich.
Aber das Problem ist jetzt wie ich an die Geschichte herangehe. Ich muss 
das ganze als Hausarbeit für die Uni programmieren.

Da ich Maschinenbau studiere interessiere ich mich nicht wirklich für 
die Mikrokontroller Informatik und möchte hier auch nicht zu viel Zeit 
investieren müssen, da es wichtigere Dinge gibt.

von Gregor W. (gregor78)


Lesenswert?

-Muss es überhaupt ein LCD sein? An dieser Sache bin ich auch noch dran, 
das Thema ist nicht einfach.
-Für jeden Block in deinem Flussdiagramm (müsste so funktionieren) eine 
Funktion schreiben/ergoogeln, mit kleinem Hilfsprogramm testen, die 
Tasten-Funkt. per pin change interrupt ausführen, erspart das polling.
-Entprellung nicht vergessen.
-Mit höheren Semestern gut stellen, erfordert fast keinen Einsatz.

von Karl H. (kbuchegg)


Lesenswert?

Dein 'Flusdiagram' ist erst mal ein Anfang. Aber so richtig wird das 
nichts. Dazu ist es noch viel zu oberflächlich. Das erinnert mich ein 
wenig an: Wir planen eine Reise in die Antarktis nach folgendem Schema

            Europa
              |
              v
     +----------------+
     |  Ins Flugzeug  |
     |  einsteigen    |
     +----------------+
              |
              |
              v
     +----------------+
     |  Aus Flugzeug  |
     |  aussteigen    |
     +----------------+
              |
              |
              v
     +----------------+
     |  warme Hose    |
     |  anziehen      |
     +----------------+
              |
              |
              v
         Antarktis

Klar hat das schon etwas mit der Reise in die Antarktis zu tun. Aber im 
Grunde genommen ist es ziemlich nichtssagend.

Wie funktioniert denn ein Taschenrechner?
Der lauert ständig auf Tastendrücke. Nicht nur auf einen.
Er sitzt also in einer Schleife und wartet darauf, dass eine Taste 
gedrückt wird. Ist sie gedrückt, dann erfolgt die Abfrage welche Taste 
das war (soweit hast du das ja richtig) und eine entsprechende Aktion. 
Dazu hat der Taschenrechner immer noch sowas wie eine aktuelle Zahl oder 
aktuelles Ergebnis, welches er anzeigt. Und diese Zahl wird manipuliert. 
Das kann auch heissen, dass die Zahl sich nur verändert, zb wenn du 
hintereinander die Tasten '2' und '1' drückst. Dann steht in der Anzeige 
21. Drückst du dann die Taste '5', dann rechnet der Rechner: neues 
aktuelles Ergebnis = altes aktuelles Ergebnis * 10 + 
Wert_der_der_Taste_entspricht.
Oder mit Zahlen

    Result = 21 * 10 + 5  -> 215

und erhält 215, welches in der Anzeige erscheint. Drückst du dann zb 
'+', dann merkt sich der Taschenrechner die 215 als ersten Operanden und 
wartet auf die nächste Zahleneingabe (aktuelle Zahl wird auf 0 gesetzt). 
Du drückst zb '8'. Der Taschenrechner rechnet

    Result = 0 * 10 + 8   -> 8
welche er anzeigt.
Du drückst '3'
Der Rechner rechnet
    Result = 8 * 10 + 3   -> 83
an zeigt die 83 an
Du drückst '7'
Der Rechner rechnet
    Result = 83 * 10 + 7   -> 837
und zeigt 837 an

Jetzt drückst du '='

Da erinnert sich der Taschenrechner, dass er ja vorher eine Zahl, 
nämlich die 215 in einer Variablen zur Seite gelegt hat. Dein Begehr ist 
es offensichtlich, 215 + 837 ausrechnen zu lassen. Genau das macht der 
Taschenrechner und gibt das Ergebnis aus - 1052

Jetzt drückst du '-'
Als Folge davon legt der Rechner das aktuelle Ergebnis (die 1052 die er 
bis eben noch angezeigt hat) wieder zur Seite (in eine Variable) und 
fängt wieder bei 0 an um dich eine Zahl eingeben zu lassen (so wie 
oben).
Und so geht es immer weiter.

Dein Flussdiagramm muss in der Lage sein, mit solchen Arbeitsabläufen 
zurechtzukommen. Du kannst das testen, indem du selbst µC spielst un 
dmit dem Finger dein Ablaufdiagram durchgehst. Erfinde für dich eine 
Aufgabenstellung. Du willst zb  23 + 5 - 8 rechnen. Du hast dir dafür 
die Tastendrücke zurechtgelegt und weißt in welcher Reihenfolge sie 
kommen. Jetzt spielst du Computer (mit dem Finger auf dem Diagramm) und 
spielst das Diagramm durch. Du machst nur das, was im Diagramm steht und 
wenn du zur Tastenabfrage kommst, tust du einfach so als ob die nächste 
Taste laut deinem Berechnungsschema gedrückt worden wäre. Wenn dein 
Diagramm richtig ist, dann musst du irgendwann zu einer Ausgabe kommen, 
an der das richtige Ergebnis auf der Ausgabe steht und deine 
Tastenabfrage ständig in der Schleife 'Warte auf Taste' kreist.

> Da ich Maschinenbau studiere interessiere ich mich nicht wirklich
> für die Mikrokontroller Informatik und möchte hier auch nicht zu
> viel Zeit investieren müssen, da es wichtigere Dinge gibt.

Das glaub ich dir schon.
Sieh es mehr als Übung im folgerichtigen Denken und im Aufstellen eines 
Planes, der ein 'Problem lösen kann' wenn man sich nur stur an diesen 
Plan hält.

von Manuel F. (noobhoch10)


Lesenswert?

Vielen Dank für die Antworten.

Mein Problem stellt sich genau bei dem oben beschrieben Problem. Wie 
kann ich meinem ATMega 88 beibringen, dass ich eine Zahl per Taste 1 
durch mehrmaliges Drücken eingebe, diese gespeichert wird, danach der 
Operator gesetzt wird (Taste 2 oder 3) und dann meine zweite Zahl und 
das Ergebnis?

Das mit dem Entprellen der Tasten ist mir auch klar, habe hier eine 
Entprellfunktion von der Uni welche ich einbinden kann. LCD sollte 
eigentlich auch möglich sein, da gibt es andere Aufgaben die man 
umschreiben kann.

Die Aufgabe gibt es leider erst seit diesem Semester, somit ist das mit 
den höheren Semestern nicht möglich.

Gruß

Manuel

von Alejandro P. (ale500)


Lesenswert?

Ich habe ein Taschenrechner (Zwei Prototypen) aber mit ein ATMega32 
realisiert. Rechnungen sind mit BCD gemacht (assembler).


Jetzt auf English:

It is actually a bit more complicated. Before you start to code 
something you should make a couple of these flow diagrams that describe 
the inner workings in a bit more detail.
If you haven't programmed something in C before (how do you know the 
language?), then I'd suggest you start with a simpler approach. A loop 
that reads keys using getc and accordingly works like any other 4 
functions calculators, where +, -, and so on produce the result 
directly.
Going to the ATMega things get more complicated because there is no getc 
unless you use a serial terminal, and I think you want your own 
keyboard.
One way is to use an interrupt driven model. Where every key wakes the 
processor from sleep and then returns it to sleep when done. That step 
alone is just to "emulate" getc. Then comes the calculation or digit 
entry depending on the key and display.
Using the sleep mode saves battery (if you need it).
I wrote mine using this technique but I only used assembly and not C. 
but the logic is more or less the same.

Sorry for the English part, but my German is still quite bad :-(

von Manuel F. (noobhoch10)


Lesenswert?

Hello,

I'm not allowed to use a PC-Keyboard to enter the numbers. Only by 
pressing the 4 switches available on the ATMega88 board it is possible 
to use the calculator options such as numbers and calculation operators.

Greetings

von Karl H. (kbuchegg)


Lesenswert?

Manuel Fisch schrieb:

> Mein Problem stellt sich genau bei dem oben beschrieben Problem. Wie
> kann ich meinem ATMega 88 beibringen, dass ich eine Zahl per Taste 1
> durch mehrmaliges Drücken eingebe, diese gespeichert wird, danach der
> Operator gesetzt wird (Taste 2 oder 3) und dann meine zweite Zahl und
> das Ergebnis?

Fang damit an, dir ein Diagramm zu malen.
Das ist ja ok.

Ich geb dir mal was vor

       akt_Zahl = 0
       Operand  = 0;
             |
             v<---------------+
  +---> Taste gedrückt?  -----+ Nein
  |          |
  |          v            Ja
  |        War es '1'?  ---+
  |          | Nein        v
  |          |          akt_Zahl = 10 * akt_Zahl + 1;
  |          |            |
  |          |            +------------------------------------+
  |          |                                                 |
  |          v           Ja                                    |
  |        War es '2'  ---+                                    |
  |          | Nein       v                                    |
  |          |          akt_Zahl = 10 * akt_Zahl + 2;          |
  |          |            |                                    |
  |          |            +----------------------------------->|
  |          |                                                 |
  ....     ....                                              ....
  |          |                                                 |
  |          v           Ja                                    |
  |        War es '+'  ---+                                    |
  |          | Nein       v                                    |
  |          |          Operand = akt_Zahl                     |
  |          |          akt_Zahl = 0                           |
  |          |          Operation = Plus                       |
  |          |            |                                    |
  |          |            +----------------------------------->|
  |          |                                                 |
  |          |                                                 |
  ....     ....                                             .....
  |          |                                                 |
  |          v           Ja                                    |
  |        War es '='  ---+                                    |
  |          | Nein       |                      Ja            |
  |          |          Ist die Operation Plus? --+            |
  |          |            | Nein                  v            |
  |          |            |                akt_Zahl =          |
  |          |            |                akt_Zahl + Operand  |
  |          |            |                       |            |
  |          |            |                       +----------->|
  |          |            v                      Ja            |
  |          |          Ist die Operation Minus --+            |
  |          |            | Nein                  v            |
  |          |            |                akt_Zahl =          |
  |          |            |                 akt_Zahl - Operand |
  |          |            |                       |            |
  |          |            |                       +----------->|
  |          |            |                                    |
  |          |            v                      Ja            |
  |          |          Ist die Operation Mal  ---+            |
  |          |            | Nein                  v            |
 ....      ....          .....                  .....        ....
  |          |                                                 |
  |          |<------------------------------------------------+
  |          |
  |          v
  |        akt_Zahl ausgeben
  |          |
  +----------+

Fahr mit dem Finger die Linien nach, wenn die Tastendrücke nacheinander 
gewesen wären:

  '1' '2' '+' '2' '1' '='

und überzeuge dich davon, dass das das richtige Ergebnis liefert. 
Beobachte auch, wie das Zusammenspiel von akt_Zahl, Operand und 
Operation funktioniert.

von Karl H. (kbuchegg)


Lesenswert?

Manuel Fisch schrieb:
> Hello,
>
> I'm not allowed to use a PC-Keyboard to enter the numbers. Only by
> pressing the 4 switches available on the ATMega88 board it is possible
> to use the calculator options such as numbers and calculation operators.
>

Dann musst du dir ein Schema überlegen, wie du mit diesen 4 Tasten 
Zahleneingabe, Operationsauswahl und Berechnung anstösst.

Zuerst musst du wissen, wie du die 4 Tasten einsetzen willst (Welche 
Bedeutung jede Taste hat). Danach kannst du dann dein Diagramm zeichnen, 
welches die Funktionalität 'Taschenrechner' realisiert.

von Manuel F. (noobhoch10)


Lesenswert?

So habe jetzt mal probiert das alles hinzubekommen.Läuft so weit auch. 
Nur kann ich eben zum Ergebnis nichts hinzufügen, also z.B die Zahl 
übernehmen und dann weiterrechnen. Was mir noch Probleme bereitet ist, 
dass bei mir die Operatoren und das Gleichzeichen nicht auf dem LCD 
angezeigt werden. Hat jemand eine Lösung? Ich weiß nur dass man die 
ASCII Tabelle braucht aber keine Ahnung wie ich das zuweisen kann.

#include <avr/io.h>
#include <avr/interrupt.h>
#include "display_funktionen.h"



void Initialisierung_Ports2(void);
void Initialisierung_Timer(void);
void Initialisierung_Timer0_CTC(void);

unsigned char Zeile1[16]="Taschenrechner";   //Ausgabe des Textes
unsigned char Zeile2[16]="                ";   //Ausgabe der 
Rechenoperationen
unsigned int taste_s1,taste_s2,timer_cout;
unsigned int status=1;
unsigned int zahl1=0;                           // Zuweisung Zahl 1=0
unsigned int zahl2=0;                           //Zuweisung Zahl 2=0
unsigned int op=1;
long int ergebnis;
long int i=250;


int main(void)
{
 Initialisierung_Ports2();
 Initialisierung_Timer();
 Initialisierung_Timer0_CTC();
 Anzeige_initialisierung();
 while(1)
 {
  if(status==1)
  {
    if(~PINC&0x01 && taste_s1==1)         //Flankenerkennung für Taste 1
 {
    delay(300);               //Entprellung der Tasten über die in die 
Displayfunktion inkludierte Funktion
        if(zahl1==9)              // Zählschleife von 0bis9 falls Zahl 
größer 9 zurück zu 0
    {
      zahl1=0;                // Erste dargestellte Ziffer ist 0
      }
    else
    {
      zahl1++;                //Erhöhen der Zahl um 1
      }
        taste_s1=0;                //Durch Tastendruck S1 wird Zahl 
erhöht
  }
        Zeile2[7] = (unsigned char) 0x30 + zahl1;  //Ausgabe der Zahl 
auf dem Display
        Write_LCD(1, Zeile1);
        Write_LCD(2, Zeile2);
        if(~PINC&0x02 && taste_s2==1)        //Flankenerkennung für 
Taste 2
   {
         delay(300);
        status=2;
      taste_s2=0;                  //Taste S2 gedrückt
   }
  }
  if(status==2)                  // Status 2 dient zuzr Auswahl der 
Operanden
  {
    if(~PINC&0x01 && taste_s1==1)        //Flankenerkennung für Taste 1
  {
    delay(300);
        if(op==4)                //Wenn Operation 4 ausgeführt wird dann 
soll sie op=1 sein
    {
      op=1;
      }
    else
    {
      op++;
      }
    taste_s1=0;
  }
   if(op==1)
   {
    Zeile2[8] = (unsigned char) 0x30 + '+';   // Zuweisung der Operation 
für op=1 mit der Rechenoperation "+"
   }
   if(op==2)
   {
    Zeile2[8] = (unsigned char) 0x30 + '-';   // Zuweisung der Operation 
für op=2 mit der Rechenoperation "-"
   }
   if(op==3)
   {
    Zeile2[8] = (unsigned char) 0x30 + '*';   // Zuweisung der Operation 
für op=3 mit der Rechenoperation "*"
   }
   if(op==4)
   {
    Zeile2[8] = (unsigned char) 0x30 + '/';   // Zuweisung der Operation 
für op=4 mit der Rechenoperation "/"
   }
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
   Write_LCD(1, Zeile1);
   Write_LCD(2, Zeile2);
   if(~PINC&0x02 && taste_s2==1)
   {
     delay(300);
    status=3;
  taste_s2=0;
   }
  }
  if(status==3)                  // Status 3 lässt zu, dass man die 
zweite Zahl eingeben kann
  {
    if(~PINC&0x01 && taste_s1==1)        //Flankenerkennung für Taste 1
  {
    delay(300);                // Entprellung
        if(zahl2==9)              // Zählschleife von 0bis9 falls Zahl 
größer 9 zurück zu 0
    {
      zahl2=0;                                // Setzt den Startwert auf 
dem Display 0
      }
    else
    {
      zahl2++;                                //Zählt die Zahl von Null 
bei Tatsendruck um +1 nach oben
      }
    taste_s1=0;                               //Taste 1 gedrückt also 
soll ++ ausgeführt werden
  }
   if(op==1)
   {
    Zeile2[8] = (unsigned char) 0x30 + '+';
   }
   if(op==2)
   {
    Zeile2[8] = (unsigned char) 0x30 + '-';
   }
   if(op==3)
   {
    Zeile2[8] = (unsigned char) 0x30 + '*';
   }
   if(op==4)
   {
    Zeile2[8] = (unsigned char) 0x30 + '/';
   }
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
   Zeile2[9] = (unsigned char) 0x30 + zahl2;
   Write_LCD(1, Zeile1);
   Write_LCD(2, Zeile2);
   if(~PINC&0x02 && taste_s2==1)
   {
     delay(300);
    status=4;
  taste_s2=0;
   }
  }
  if(status==4)                                 // Status 4 führt die 
Rechenoperation aus
  {
     if(op==1)
    {
     ergebnis=zahl1+zahl2;                     // Ergebnisberechnung von 
Addition
   Zeile2[8] = (unsigned char) 0x30 + '+';   //LCD-Ausgabe
    }
    if(op==2)
    {
     ergebnis=zahl1-zahl2;                     // Ergebnisberechnung von 
Subtraktion
   Zeile2[8] = (unsigned char) 0x30 + '-';
    }
    if(op==3)
    {
     ergebnis=zahl1*zahl2;                   // Ergebnisberechnung von 
Multiplikation
   Zeile2[8] = (unsigned char) 0x30 + '*';
    }
    if(op==4)
    {
     ergebnis=zahl1/zahl2;                  // Ergebnisberechnung von 
Subtraktion
   Zeile2[8] = (unsigned char) 0x30 + '/';
    }
   int ziffer2 = (ergebnis%100)/10;          //Berechnung über Modulo
   int ziffer1 = (ergebnis%10);
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
   Zeile2[9] = (unsigned char) 0x30 + zahl2;
   Zeile2[10] = (unsigned char) 0x30 + '=';
   Zeile2[11] = (unsigned char) 0x30 + ziffer2;
   Zeile2[12] = (unsigned char) 0x30 + ziffer1;
   Write_LCD(1, Zeile1);
   Write_LCD(2, Zeile2);
   if(~PINC&0x01 && taste_s1==1)
   {
     delay(300);
    status=1;
  zahl1=0;
  zahl2=0;
  op=1;
  taste_s1=0;
   }
  }
 }

 return(0);
}

void Initialisierung_Ports2(void)      // Datenregister setzen
{
 DDRC &= ~0x03;
 DDRD |= 0x01<<PD7;
 PORTC |= 0x03;
 PORTD &= ~0x80;
}

void Initialisierung_Timer(void)
{
 TCCR1A = 0;
 TCCR1B |= (1<<WGM12) | (1<<CS10);
 OCR1A = 36864;
 TIMSK1 |= (1<<OCIE1A);
 sei();
}

ISR(TIMER1_COMPA_vect)
{
 timer_cout++;
 if(timer_cout >=i)
 {
  timer_cout = 0;
  taste_s1 = 1;
  taste_s2 = 1;
 }
}

von Vlad T. (vlad_tepesch)


Lesenswert?

das beste wär du postest den code noch mal in c-tags, damit die 
formatierung nicht so durcheinander kommt.  (siehe Hinweise unter 
"Formatierung")

was mir sofort auffällt:
warum addierst du 0x30 auf die character '*' '+' '-' ...
Ist doch klar, dass da was ganz anderes Angezeigt wird.


edit:

und wenn man schreibt
'0' + zahl
wird auch ein wenig klarer, was das bezwecken soll.


Das beste wär wohl aber eine kleine funktion, die das macht
1
static inline char digitToAscii( uint8_t digit)
2
{
3
  return '0' + digit;
4
}

für den Fall, dass sich der Zeichensatz mal ändert (zB, weil du auf ein 
anderes Display musst) reicht es so, eine Funktion anzupassen.

von Manuel (Gast)


Lesenswert?

1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
#include "display_funktionen.h"
4
5
6
7
void Initialisierung_Ports2(void);
8
void Initialisierung_Timer(void);
9
void Initialisierung_Timer0_CTC(void);
10
11
unsigned char Zeile1[16]="Taschenrechner";   //Ausgabe des Textes
12
unsigned char Zeile2[16]="                ";   //Ausgabe der
13
Rechenoperationen
14
unsigned int taste_s1,taste_s2,timer_cout;
15
unsigned int status=1;
16
unsigned int zahl1=0;                           // Zuweisung Zahl 1=0
17
unsigned int zahl2=0;                           //Zuweisung Zahl 2=0
18
unsigned int op=1;
19
long int ergebnis;
20
long int i=250;
21
22
23
int main(void)
24
{
25
 Initialisierung_Ports2();
26
 Initialisierung_Timer();
27
 Initialisierung_Timer0_CTC();
28
 Anzeige_initialisierung();
29
 while(1)
30
 {
31
  if(status==1)
32
  {
33
    if(~PINC&0x01 && taste_s1==1)         //Flankenerkennung für Taste 1
34
 {
35
    delay(300);               //Entprellung der Tasten über die in die
36
Displayfunktion inkludierte Funktion
37
        if(zahl1==9)              // Zählschleife von 0bis9 falls Zahl
38
größer 9 zurück zu 0
39
    {
40
      zahl1=0;                // Erste dargestellte Ziffer ist 0
41
      }
42
    else
43
    {
44
      zahl1++;                //Erhöhen der Zahl um 1
45
      }
46
        taste_s1=0;                //Durch Tastendruck S1 wird Zahl
47
erhöht
48
  }
49
        Zeile2[7] = (unsigned char) 0x30 + zahl1;  //Ausgabe der Zahl
50
auf dem Display
51
        Write_LCD(1, Zeile1);
52
        Write_LCD(2, Zeile2);
53
        if(~PINC&0x02 && taste_s2==1)        //Flankenerkennung für
54
Taste 2
55
   {
56
         delay(300);
57
        status=2;
58
      taste_s2=0;                  //Taste S2 gedrückt
59
   }
60
  }
61
  if(status==2)                  // Status 2 dient zuzr Auswahl der
62
Operanden
63
  {
64
    if(~PINC&0x01 && taste_s1==1)        //Flankenerkennung für Taste 1
65
  {
66
    delay(300);
67
        if(op==4)                //Wenn Operation 4 ausgeführt wird dann
68
soll sie op=1 sein
69
    {
70
      op=1;
71
      }
72
    else
73
    {
74
      op++;
75
      }
76
    taste_s1=0;
77
  }
78
   if(op==1)
79
   {
80
    Zeile2[8] = (unsigned char) 0x30 + '+';   // Zuweisung der Operation
81
für op=1 mit der Rechenoperation "+"
82
   }
83
   if(op==2)
84
   {
85
    Zeile2[8] = (unsigned char) 0x30 + '-';   // Zuweisung der Operation
86
für op=2 mit der Rechenoperation "-"
87
   }
88
   if(op==3)
89
   {
90
    Zeile2[8] = (unsigned char) 0x30 + '*';   // Zuweisung der Operation
91
für op=3 mit der Rechenoperation "*"
92
   }
93
   if(op==4)
94
   {
95
    Zeile2[8] = (unsigned char) 0x30 + '/';   // Zuweisung der Operation
96
für op=4 mit der Rechenoperation "/"
97
   }
98
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
99
   Write_LCD(1, Zeile1);
100
   Write_LCD(2, Zeile2);
101
   if(~PINC&0x02 && taste_s2==1)
102
   {
103
     delay(300);
104
    status=3;
105
  taste_s2=0;
106
   }
107
  }
108
  if(status==3)                  // Status 3 lässt zu, dass man die
109
zweite Zahl eingeben kann
110
  {
111
    if(~PINC&0x01 && taste_s1==1)        //Flankenerkennung für Taste 1
112
  {
113
    delay(300);                // Entprellung
114
        if(zahl2==9)              // Zählschleife von 0bis9 falls Zahl
115
größer 9 zurück zu 0
116
    {
117
      zahl2=0;                                // Setzt den Startwert auf
118
dem Display 0
119
      }
120
    else
121
    {
122
      zahl2++;                                //Zählt die Zahl von Null
123
bei Tatsendruck um +1 nach oben
124
      }
125
    taste_s1=0;                               //Taste 1 gedrückt also
126
soll ++ ausgeführt werden
127
  }
128
   if(op==1)
129
   {
130
    Zeile2[8] = (unsigned char) 0x30 + '+';
131
   }
132
   if(op==2)
133
   {
134
    Zeile2[8] = (unsigned char) 0x30 + '-';
135
   }
136
   if(op==3)
137
   {
138
    Zeile2[8] = (unsigned char) 0x30 + '*';
139
   }
140
   if(op==4)
141
   {
142
    Zeile2[8] = (unsigned char) 0x30 + '/';
143
   }
144
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
145
   Zeile2[9] = (unsigned char) 0x30 + zahl2;
146
   Write_LCD(1, Zeile1);
147
   Write_LCD(2, Zeile2);
148
   if(~PINC&0x02 && taste_s2==1)
149
   {
150
     delay(300);
151
    status=4;
152
  taste_s2=0;
153
   }
154
  }
155
  if(status==4)                                 // Status 4 führt die
156
Rechenoperation aus
157
  {
158
     if(op==1)
159
    {
160
     ergebnis=zahl1+zahl2;                     // Ergebnisberechnung von
161
Addition
162
   Zeile2[8] = (unsigned char) 0x30 + '+';   //LCD-Ausgabe
163
    }
164
    if(op==2)
165
    {
166
     ergebnis=zahl1-zahl2;                     // Ergebnisberechnung von
167
Subtraktion
168
   Zeile2[8] = (unsigned char) 0x30 + '-';
169
    }
170
    if(op==3)
171
    {
172
     ergebnis=zahl1*zahl2;                   // Ergebnisberechnung von
173
Multiplikation
174
   Zeile2[8] = (unsigned char) 0x30 + '*';
175
    }
176
    if(op==4)
177
    {
178
     ergebnis=zahl1/zahl2;                  // Ergebnisberechnung von
179
Subtraktion
180
   Zeile2[8] = (unsigned char) 0x30 + '/';
181
    }
182
   int ziffer2 = (ergebnis%100)/10;          //Berechnung über Modulo
183
   int ziffer1 = (ergebnis%10);
184
   Zeile2[7] = (unsigned char) 0x30 + zahl1;
185
   Zeile2[9] = (unsigned char) 0x30 + zahl2;
186
   Zeile2[10] = (unsigned char) 0x30 + '=';
187
   Zeile2[11] = (unsigned char) 0x30 + ziffer2;
188
   Zeile2[12] = (unsigned char) 0x30 + ziffer1;
189
   Write_LCD(1, Zeile1);
190
   Write_LCD(2, Zeile2);
191
   if(~PINC&0x01 && taste_s1==1)
192
   {
193
     delay(300);
194
    status=1;
195
  zahl1=0;
196
  zahl2=0;
197
  op=1;
198
  taste_s1=0;
199
   }
200
  }
201
 }
202
203
 return(0);
204
}
205
206
void Initialisierung_Ports2(void)      // Datenregister setzen
207
{
208
 DDRC &= ~0x03;
209
 DDRD |= 0x01<<PD7;
210
 PORTC |= 0x03;
211
 PORTD &= ~0x80;
212
}
213
214
void Initialisierung_Timer(void)
215
{
216
 TCCR1A = 0;
217
 TCCR1B |= (1<<WGM12) | (1<<CS10);
218
 OCR1A = 36864;
219
 TIMSK1 |= (1<<OCIE1A);
220
 sei();
221
}
222
223
ISR(TIMER1_COMPA_vect)
224
{
225
 timer_cout++;
226
 if(timer_cout >=i)
227
 {
228
  timer_cout = 0;
229
  taste_s1 = 1;
230
  taste_s2 = 1;
231
 }
232
}

von Vlad T. (vlad_tepesch)


Lesenswert?

so hätte ich das auch selbst tun können. die Formatierung ist jetzt 
schon kaputt.

von Karl H. (kbuchegg)


Lesenswert?

Was mir daran nicht schmeckt, dass ist das du da alles in ein main() 
hineingequetscht hast ohne Rücksicht auf Verluste.

Teil doch die Funktionalität etwas besser in Funktionen auf, dann kann 
man das auch leichter nachvollziehen was du da eigentlich gemacht hast.

Deine Hauptschleife könnte so aussehen
1
 while(1)
2
 {
3
   if( status == 1 )
4
     getZahl1();
5
6
   else if( status == 2 )
7
     getOperation();
8
9
   else if( status == 3 )
10
     getZahl2();
11
12
   else if( status == 4 )
13
     performOperation();
14
 }


Dadurch teilt sich der Code in kleinere Einheiten auf, die leichter zu 
überblicken sind.

von Vlad T. (vlad_tepesch)


Lesenswert?

naja, die antwort auf seine Frage, warum die operatoren nicht zu sehen 
sind, ahbe ich ihm ja schon gegeben.
Reagiert hat er nicht darauf.

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.