mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Taschenrechner auf ATMega88


Autor: Manuel Fisch (noobhoch10)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht 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!

Autor: Gregor Wetzel (gregor78)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Manuel Fisch (noobhoch10)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Gregor Wetzel (gregor78)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Manuel Fisch (noobhoch10)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Alejandro P. s. (ale500)
Datum:

Bewertung
0 lesenswert
nicht 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 :-(

Autor: Manuel Fisch (noobhoch10)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Manuel Fisch (noobhoch10)
Datum:

Bewertung
0 lesenswert
nicht 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;
 }
}

Autor: Vlad Tepesch (vlad_tepesch)
Datum:

Bewertung
0 lesenswert
nicht 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
static inline char digitToAscii( uint8_t digit)
{
  return '0' + digit;
}


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

Autor: Manuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#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;
 }
}

Autor: Vlad Tepesch (vlad_tepesch)
Datum:

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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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
 while(1)
 {
   if( status == 1 )
     getZahl1();

   else if( status == 2 )
     getOperation();

   else if( status == 3 )
     getZahl2();

   else if( status == 4 )
     performOperation();
 }


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

Autor: Vlad Tepesch (vlad_tepesch)
Datum:

Bewertung
0 lesenswert
nicht 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.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.