Klausuraufgabe verstehen

Hallo Zusammen,

Ich schreibe bald Klausur und habe ne Frage zu einer Aufgabe aus einer Altklausur.

Der Code sieht wie folgt aus:

void setup()
{
  Serial.begin(115200)
}

void loop();
{
  unsigned int a = analogRead(A0);
  if (a == 0) Serial.println("X");
  if (a == 1) Serial.println("-X");
  if (a == 2) Serial.println("--X");
  if (a == 3) Serial.println("---X");
  // [...]
  if (a == 1023)Serial.println("-------- [...] --X");
}

Vorgabe ist, dass der eingelesene Analogwert zwischen 0 und 1023 betragen kann. Und im Code zur Ausgabe 1024 if-Anweisungen eingesetzt wurden.
Ich soll das Programm verkürzen und neu aufschreiben, kann mir da aber nichts drunter vorstellen.
Kann mir vielleicht jemand Helfen.

Hallo,

Du könntst Dir eine Zeichenkette zusammensetzten die erst mal in einer Schleife a-1 "-" in die Zeuchenkette schreibt und dann noch ein x anhängt.

Dazu schaust Du Dir die C-Char Zeichenkette an .

Leselink

Heinz

Hallo,

weiß zwar nicht was das mit der unendlich langen Ausgabe werden soll, aber du sollst die 1024 if Abfragen eleminieren. Schau dir die for Schleife an.

Jede Ausgabe wird mit einem 'X' angeschlossen, und die Anzahl der '-' Zeichen davor stellen den wert dar, richtig?

Also z.B. sowas:

void loop() {
  unsigned int a = analogRead(A0);
  while (a > 0) {
     Serial.print("-");
     a--;
  }  
  Serial.println("X");
  delay (1000); // Damit man mitlesen kann
}

1024 Zeichen ergeben allerdings ziemlich lange Zeilen...

michael_x:
Jede Ausgabe wird mit einem 'X' angeschlossen, und die Anzahl der '-' Zeichen davor stellen den wert dar, richtig?

Also z.B. sowas:

void loop() {

unsigned int a = analogRead(A0);
  while (a > 0) {
    Serial.print("-");
    a--;
  } 
  Serial.println("X");
  delay (1000); // Damit man mitlesen kann
}




1024 Zeichen ergeben allerdings ziemlich lange Zeilen...

Ich glaube es geht hier eher weniger um den Sinn des Programmes an sich, sondern, dass ich ein Programm verkürzen kann und es die selbe Ausgabe hat.
Und ja genau die "-" Stellen den Wert dar.

(deleted)

Doc_Arduino:
weiß zwar nicht was das mit der unendlich langen Ausgabe werden soll

Als theoretische Aufgabe zu Schleifen ist das schon ganz nützlich

okay :slight_smile:

Danke an euch alle für eure Antworten,

Ich werde jetzt mal ein bisschen mit den Sachen die ihr mir geschickt habt herumprobieren. :slight_smile:

Rentner:
Hallo,

Du könntst Dir eine Zeichenkette zusammensetzten die erst mal in einer Schleife a-1 "-" in die Zeuchenkette schreibt und dann noch ein x anhängt.

Dazu schaust Du Dir die C-Char Zeichenkette an .

Leselink

Heinz

und beim 2. Durchgang gleich der Arduino abschmiert?
Bei einer möglichen Länge von 1024 Zeichen ist das RAM schnell voll.
Solche sachen sollte man gleich ausgeben und nicht zwischenspeichern.

Grüße Uwe

Hallo,

@Uwe da hast du vollkommen Recht ich hatte die Länge 1024 vergessen. Bei meiner Variante hätte der T0 noch was zu C-Zeichenketten lernen können. Nutzt aber nix wenn das Ding dann abschmiert.

Gruß Heinz

Bei meiner Variante hätte der TO noch was zu C-Zeichenketten lernen können

OK, da hast du auch wieder Recht. :wink:

Statt dessen könnte er jetzt noch lernen, dass
Serial.write('-'); einen Tick optimaler als
Serial.print("-"); ist. (Bzw. wann man auch gut ohne C-Zeichenketten auskommt) :stuck_out_tongue:

Peter-CAD-HST:
for (int n = 0; n < analogRead(A0); n++) Serial.print("-"); Serial.println(“X”);

Viel Erfolg bei der Klausur!

Dem Erfolgswunsch schließe ich mich gerne an! (Es gibt tatsächlich noch jemand, der sich vor einer Klausur mit alten Aufgaben beschäftigt - das finde ich Klasse!)

@Peter:
Veränderst Du da nicht heimlich die Schleifen-Ende-Bedingung?

Wenn also der Anfangswert 1000 ist und man dann den Eingang A0 z.B. so ungefähr beim 200ten ‘-’ auf GND legt, werden wir 32768 Minuszeichen sehen.

Wenn also der Anfangswert 1000 ist und man dann den Eingang A0 z.B. so ungefähr beim 200ten '-' auf GND legt, werden wir 32768 Minuszeichen sehen.

Nein.
Sobald mindestens so viele '-' geschrieben sind wie der Wert ergibt, hört die Schleife auf. In deinem Beispiel eben nach 200 '-' statt erst nach 1000. Natürlich ist das formal ein anderes Verhalten als die Aufgabenstellung. Außerdem ist die Schleifengeschwindigkeit nicht nur von der Seriellen Geschwindigkeit bei vollem Puffer, sondern eventuell auch von der Dauer eines analogRead abhängig.

Deine Befürchtung mit den 32768 '-' sehe ich aber nicht.

Wir haben übrigens früher nur hauptsächlich nach alten Klausuren gelernt. Der ganze theoretische Hintergrund war viel zu kompliziert. Hauptsache, man konnte es irgendwie anwenden. ( nur Ingenieure eben ).

michael_x:
Sobald mindestens so viele '-' geschrieben sind wie der Wert ergibt, hört die Schleife auf.

Jetzt wo Du es sagst - stimmt.
War auf dem falschen Dampfer mit überlaufenden Countern die dann einmal rumzählen (kommt mir berufsbedingt gelegentlich unter).

Wir haben übrigens früher nur hauptsächlich nach alten Klausuren gelernt. Der ganze theoretische Hintergrund war viel zu kompliziert. Hauptsache, man konnte es irgendwie anwenden. ( nur Ingenieure eben ).

Stimmt auch - und nicht nur für Ingenieure :slight_smile:

for (int n = 0; n < analogRead(A0); n++) Serial.print("-"); Serial.println("X");

Wird hier nicht immer wieder der analogpin bei jedem Schleifendurchgang neu eingelesen?
Wenn sich dieser Wert ändert ist auch die länge der Ausgabe di dann weder Anfangswert noch Endwert ist.

Ich würde den Analogwert vor dem for in eine Variable abspeichern und im for mit dieser Variablen arbeiten.

int max = analogRead(A0)
for (int n = 0; n < max; n++) Serial.print("-"); Serial.println("X");

Grüße Uwe

Ich will auch mal:

int minuse = analogRead(A0);
while(minuse--) Serial.write('-');
Serial.println("X");

(deleted)

Guten Morgen,

ich hatte das mit while in der Nacht auch schon mal, weil ich die Geschwindigkeit der einzelnen Varianten gegenüberstellen wollte.

Ich habe folgenden Code:

int a;
void setup()
  {
  Serial.begin(115200);
  delay(5);
  a=1;
  a--;
  Serial.println(a);
  a=1023;
  Serial.println("Start while");
  Serial.println(micros());
  while (a--)
    {
    }
  Serial.println(micros());
  Serial.println(a);
  a = 1023;
  Serial.println("Start for");
  Serial.println(micros());
  for (a; a > 0; a--) {}
  Serial.println(micros());
  Serial.println(a);
  a = 1023;
  Serial.println("Start do");
  Serial.println(micros());
  do
    {
    a--;
    }
  while (a > 0);
  Serial.println(micros());
  Serial.println(a);
  a = 1023;
  Serial.println("Start do2");
  Serial.println(micros());
  do
    {
    }
  while (a--);
  Serial.println(micros());
  Serial.println(a);
  }

void loop()
  {
  }

und bekomme folgende Ausgaben: (In Klammern die manuell errechnete Zeit in micros)

09:11:31.607 -> 0
09:11:31.607 -> Start while
09:11:31.607 -> 5204
09:11:31.607 -> 5436 (232)
09:11:31.607 -> 65535
09:11:31.607 -> Start for
09:11:31.607 -> 6048
09:11:31.607 -> 6292 (244)
09:11:31.607 -> 0
09:11:31.607 -> Start do
09:11:31.607 -> 6700
09:11:31.641 -> 6924 (224)
09:11:31.641 -> 0
09:11:31.641 -> Start do2
09:11:31.641 -> 7796
09:11:31.641 -> 8304 (508)
09:11:31.641 -> 65535

Die Werte sind reproduzierbar.

Was mich stutzig macht, ist die letzte Laufzeit.
Führt man die Schleife einzeln aus sinds keine 508 micros, bzw. tauscht die beiden Varianten do/while ist immer die letztere Zeit mehr als doppelt so langsam.

Zum anderen frage ich mich, warum es beim ersten while(a--) zum Überlauf kommt. Dieses Verhalten hätte ich nur bei do/while() erwartet.

Kann mir jemand die schlechte Laufzeit und ggfls. das mit dem Ergebnis != 0 erläutern?
(Umgebung: MEGA und 1.8.10 / Linux)

(deleted)