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!
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
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.
-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.
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.
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
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 :-(
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
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.
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.
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; } }
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.
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 | }
|
so hätte ich das auch selbst tun können. die Formatierung ist jetzt schon kaputt.
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.
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
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.