Eingabe und Berechnung mit Modulo

Die Dezimalzahl d, mit 0 <= d < 1000, ist auch zu schreiben als:

d = a_2 *10^2 + a_1 *10^1 + a_0 *10^0

dabei sind a_n, a_n E{0,..,9} und n E{0,1,2} die einzelnen "Stellen" 
Koeffizienten der Dezimalzahl d.

Nun frage dich bitte, was mit diese Darstellung gemeint ist:

d = b_2 *16^2 + b_1 *16^1 + b_0 *16^0

Vielleicht noch ein wichtiger Zusammenhang.

"+" Addition,
"-" Subtraktion,
"*" Multiplikation und
"/" Division sind bekannt.

"%" Modulo auch, aber wie ist der Modulo über die anderen 
Rechenoperatoren definierbar ?

Hast du denn schon die Eingabe fertig?
Wenn jemand einen Buchstaben tippt, oder ein Komma?

Nur so interessehalber...

Ansonsten gibts auch HAUSARBEITEN-PUNKT-DE. ;-)

Die Eingabe ist fertig. Eigentlich wird wird ein Punkt auf einem TFT 
festgelegt, an dem eine Ausgabe erfolgen soll. Leider sind verschiedene 
Eingaben, Grössen un Zusätze möglich.
Beispiel:
- Das Display hat einen Spalten und Zeilenzahl von 100 x 30
- Damit Eingabe eines Punkte an der Stelle 50 und 15 (Displaymitte)
- Eingabe nach Angabe Hersteller muss mit 48,53,48 , 49,53 erfolgen
- Diese Werte entsprechen den Zahlen als Char nach Tabelle
- Diese Eingabe ist sehr verwirrend
- Bei der Eingabe von Figuren kommen dabei ca. 10 bis 15 Zahlen zustande
- Angabe der Koordinaten erfolgt im Programm dadurch kein Komma oder 
Buchstaben möglich
- Werte der Zahle von 1 - 9 für einstellig
- oder von 10 - 99 für zweistellig
- oder nur 100 für dreistellig, danach Begrenzung
- andere Richtung von 1 - 9 und 10 -30
- Möchte die Zahlen mit Modulo in die einzelnen Zahlen aufteilen z.B. 
Eingabe Zahl 65, aufgeteilt in 0 , 6 , 5 und übergabe in eine Funktion
- damit habe ich für die Angabe eines Quadrate nur 40, 10, 70, 25
- sonst ist 0,4,0,1,0,7,0,2,5 und Zusätze für Farbe mit 3 x 0-FF, 
Hintergrundfarbe, Schriftfarbe, Schriftart, Randfarbe, Randbreite, 
Randmuster usw. nötig.

Bis her bin ich an dieser sache dran:

if (a < 10)
{ ... Modulo einstellig)
if (a >9 und <99)
[ ... Modulo zweistellig)
if (a == 100)
{ ... Modulo dreistellig}

hat jemand eine bessere Idee dazu?

LG

PS: Es ist ein I2C TFT Display in Farbe und 5 Zoll mit ca 100 Befehlen 
mit einem 3 stelligen Buchstabencode, eigenen Prozessor, eigenen 
Bildspeicher, eigenen IOs, USB und 3,3V nicht vergessen. Etwas richtig 
anspruchsvolles Teil und leider nicht billig. Als Programmierung wird 
das Smallprotokoll verwendet

Paul schrieb:
> if (a >9 und <99)
> [ ... Modulo zweistellig)

muss natürlich

if (a >9 und <100)

sein

Jobst M. schrieb:
> Mach eben erst ein Modulo 100 ...

Wie meinst du das?
Habe doch eine Rechnung mit Modulo und 100 drin.

Karl M. schrieb:
> d = a_2 *10^2 + a_1 *10^1 + a_0 *10^0

Sorry da komme ich nicht mit wie du das meinst. Kannst mir mal auf die 
Sprünge helfen

Paul schrieb:
> Karl M. schrieb:
>> d = a_2 *10^2 + a_1 *10^1 + a_0 *10^0
>
> Sorry da komme ich nicht mit wie du das meinst. Kannst mir mal auf die
> Sprünge helfen

123 = 1*10^2 + 2*10^1 + 3*10^0

Hi

Ich habe 'Es' noch nicht verstanden :/

Hast Du eine Eingabe, ziffernweise?
Oder ist die Eingabe bereits 'im Chip' und soll nun ausgegeben werden?

Ziffernweise Eingabe:
Ergebnis=0
nextchar:
Ergebnis=Ergebnis*10
X=Eingabe (als ASCII)
X=X-$30    ;ziehe '0' von der Eingabe ab
Ergebnis=Ergebnis+X
fertig?
N -> goto nextchar
--> in Ergebnis steht die in DEZ eingegebene Zahl

Ausgabe, ziffernweise von Hinten nach Vorne:
nextchar2:
Zeichen=Zahl%10  (Modulo)
Zahl=Zahl/10     (Integer-Division)
Ausgabe Zeichen (als ASCII +$30 ... oder auch "0")
Ist Zahl>0 ? goto nextchar2

MfG

Gut, verstanden, habe in der falschen Ecke gedacht. Wie wird das bei 
meinem Problem angewendet?

Hallo Paul,

ich glaube, dass wir im 4 Schuljahr diese Darstellung von Zahlen zur 
Basis 2 schon durch genommen hatten.
Wenn das bei Dir keine Grundlagen sind, dann würde ich das jetzt 
nachholen.

Hallo
scheinbar habe ich das Problem nicht richtig erklärt.
Das Display möchte als Eingabe 48, 53, 48, 49, 48 haben. das müssten die 
Zahle in Asci für 0, 5, 0 und 1, 5 sein.
Ich möchte zur besseren Eingabe aber die Zahlen 50, 15 nehmen.
Ich muss also von diesen beiden Zahlen die Länge (1 oder 2 oder 3 
Stellig)ermitteln und dann anschliessend auf 48,53,48 umrechnen.
Das ich z.B. mit Modulo machen.

1. Ermittel die länge ob 1 oder 2 oder 3 stellig
2. Emittel die einzelnen Zahlen
3. adiere zu den einzelnen Zahlen jeweils 48 und gebe es zum Display

Beispiel:

50, 15 soll ergeben 48, 53, 48 und 49, 53
Dazu "zerlege" ich die 50 in 5 und 0 und adiere dazu 48. Das ergibt 53 
und 48. Es fehlt noch die führende 0

Das mit der 2 versteh ich ohne Probleme. Ob es in der 4. Klasse war, 
kann ich mich nicht mehr erinnern. Benutze dann aber die schreibweise 
00001101.

Wenn ich 50, 15 schreibe fehlt die führende 0 bei 50 also ist die 
korrekte Eingabe 050. Das kann ich aber nicht schreiben, weil das 
Display nur 48, 53, 48 akzeptiert. Da ich teilweise viele Zahlen angeben 
muss ist das ganze zu lang. Für die Eingabe eines Rechteckes muss ich 
dann eingeben:

48,51,48,49,54,48,55,48,50,55

zusätzlich kommt noch dazu

48,53,48,49,52 für die Angabe der Mitte (Anker)

und noch ca 10 weitere. Das geht doch einfacher z.B.:

30, 14, 60, 25, 40, 23

Das letzte ist viel übersichtlicher und macht nicht soviel Fehler


Die 50 und 48 wird durch das Programm eingegeben:

void Cursor_Position(48,53,48,49,53)

Bis her sieht es so aus:

1

Graphik_C_Cursor_Position(0,9,9,2,9);

das andere

1

void Graphik_C_Cursor_Position(uint8_t x1, uint8_t x2, uint8_t x3, uint8_t y1, uint8_t y2)

2

{

3

  uint8_t x1a, x2a, x3a, y1a, y2a;

4

  x1a = x1 + 48;

5

  x2a = x2 + 48;

6

  x3a = x3 + 48;

7

  y1a = y1 + 48;

8

  y2a = y2 + 48;

9

  uint8_t bcc;

10

  bcc = DC1 + 0x0b + ESC + END + 0x2c + 'Y' + 'C' + 'P' + x1a + x2a + x3a + y1a +y2a;

11

  i2c_start(slave_adresse_1);

12

  i2c_write(DC1);

13

  i2c_write(0x0b);  // len 07

14

  i2c_write(ESC);

15

  i2c_write('Y');    // Y

16

  i2c_write('C');    // C

17

  i2c_write('P');    // P

18

  i2c_write(x1a);

19

  i2c_write(x2a);

20

  i2c_write(x3a);

21

  i2c_write(0x2c);

22

  i2c_write(y1a);

23

  i2c_write(y2a);

24

25

  i2c_write(END);

26

  i2c_write(bcc);

27

  i2c_stop();

28

29

  _delay_us(100);

30

31

  i2c_start(slave_adresse_2);

32

  e = i2c_readAck();

33

  i2c_stop();

34

35

  itoa( e, Buffer, 10 );

36

  lcd_printlc(1,5,Buffer);

37

  _delay_us(100);

38

39

}

Damit geht es, bis auf die führende 0 bzw die Eingabe und die Menge der 
möglichen Zahlen.
Das mit Modulo geht noch nicht

Sorry vergessen anzugeben. Der untere Teil des Codes dient nur zur 
Ausgabe der Prüfsumme auf einem zweiten Display auch über den Bus

Die führende 0 soll weg. Gebe ich 50 statt 050 wird automatisch anders 
gerechnet, 50 ist zweistellige Eingabe und 050 ist dreistellige Eingabe. 
Gebe ich 50 statt 050 ein wird die erste Zahl von der nächsten 
Koordinate genommen und alle Koordinaten sind falsch.

Mein Problem habe ich mehrfach beschrieben. Scheint nicht klar rüber 
zukommen.
Das Display will 48,53,48,49,53 als Eingabe bekommen. Das sind die 
Zahlen
0, 5, 0, 1, 5.
Ich möchte eingeben 50,15 ohne die 0

Es erfolgt keine Eingabe über Tasten. Ich definiere einen Punkt auf dem 
Display wo etwas ausgegeben werden soll. Die Eingabe der Daten soll 
relativ einfach und verständlich ohne umrechnung (per Hand) erfolgen. 
Das Programm soll die Koordinaten von 50,15 auf 48,53,48,49,53 umrechnen 
und gleichzeitig prüfen ob die angebenen Koordinaten korrekt sind. 
Weiterhin möchte ich die mögliche Anzahl der Zahlen zur Eingabe aller 
notwendigen Koordinaten reduzieren. Im Programm (oben) ist ja zu sehen, 
welcher Aufwand jetzt schon ist. Teilweise arbeite ich jetzt schon mit 
10 bis 20 Graphikbefehlen fast gleichzeitig. Im original Programm ist 
eine maximale Verzögerung von 6 us drin. Es kommt noch der Bildaufbau 
und Anzeige aus dem Speicher dazu.
Eigentlich hast du recht. Mach das so wie oben schon angefangen. Brauche 
später das Teil ca. 50 bis 100 im ganzen Code für verschiedene 
Anwendungen.
Danke für die Hilfe und entschuldigung für den Satzaufbau
LG Paul