Welche Möglichkeiten der Fehlersuche hat man beim Arduino?

[fredyxx]

Hallo HaWe,

deine Antwort hat mir in zweierlei Hinsicht mal richtig gut getan. DANKE dafür!

1. Dieser Satz:

es ist nur persönliches Ästhetikempfinden, nicht mehr und nicht weniger

Ich bin auch noch als Arduinoanfänger nach einem halben Jahr Aufwand an dem Hobby-Projekt ziemlich weit davon entfernt das Programm um zu schreiben, denn da würden sicher auch wieder neue Probleme auftreten. Man ist ja häufig auch schon froh, wenn man nicht eine optimale sondern überhaupt eine Lösung findet. Trotzdem werde ich in Zukunft mehr darüber nachdenken, ob ich mehr Case und Funtionen verwenden werde.
Außerdem habe ich zZ eine Spur, wo der Fehler liegen könnte, nämlich im Umgang mit dem Signal des STOP-Tasters, dessen zeitlicher Signalablauf ich wohl nicht vollständig durchschaut und daher auch nicht richtig verarbeitet habe. Bin mir aber noch nicht sicher.
Maßnahme gegen Tasterprelllen hatte ich schon vorgesehen.

Außerdem hat mir bei der Fehlersuche Folgendes geholfen:
ich habe an den Stellen, von denen ich sicher wissen wollte, ob das Programm da durchläuft oder nicht, einen Ausgang mit LED gesetzt, der im Programm mit Sicherheit nicht zurückgesetzt wird. Dadurch brauchte ich mir keine Gedanken über die zeitliche Verarbeitung von Serial.print zu machen und ich habe sofort erkannt, bei welchem Prozesschritt das passiert.

2.
So was wie dein Vorschlag zu "zum Debuggen mit serial" war das, was ich auf meine ursprüngliche Frage als Antwort erhofft hatte.

Ich werde nicht aufgeben und bei Erfolg berichten.

vG

fredyxx

[oberallgeier]

switch/case ist nichts anderes als ein goto .. Die case (irgendwas) sind nichts anderes als Sprungmarken für gotos ..

Wirklich? Ohh! Das ist für mich jetzt total neu.

Ich dachte immer die Anweisung "case expr :" in der switch-Schleife wird abgearbeitet, solange kein break folgt bzw. die switch-Schleife durch eine andere Anweisung verlassen wird wie z.B. return. Deshalb fürchtete ich, dass ohne break oder return eine Anweisung wie das goto beim nächsten return wieder in der switch-Schleife landet. Mit kaum kontrollierbarem weiteren Ablauf. Abgesehen davon, dass meines Wissens nach, das Sprungziel nur innerhalb des Gültigkeitsbereiches der Marke liegen, d.h. nur in der jeweiligen Funktion liegen darf.

Frage: Bedeutet die oben zitierte Aussage, dass durch das "goto label;" innerhalb eines "case expr :" KEIN Rücksprung in die switch-Schleife erfolgt? Nie und Nimmer?
Frage: Wie kriegt der Stack diesen Ablauf gebacken ?

[Mxt]

Frage: Wie kriegt der Stack diesen Ablauf gebacken ?

Also erstmal sind wir hier in der Arduino Rubrik. Es gelten also die goto Regeln von C++, nicht die von C.

Zweitens, von der Implementierung her ist ein switch/case eher eine if else if Kette, kein goto.

Den Stack in Ordnung zu halten ist Sache des C++ Compilers. Was ein bischen ein Problem ist, der g++ für die 8 Bitter ist ein recht abgespeckter Compiler. Keine Ahnung, ob der wirklich alle Regeln befolgt. Auch das ist ein Grund, warum ich solche goto Konstrukte für suspekt halte.

Grundsätzlich gilt: In C++ darf man mit goto nur innerhalb einer Funktion springen und

{
  Ding a;
  Ding b;

  goto weg;
}

bedeutet implizit, dass beim goto die Destruktoren von a und b aufgerufen werden. Und bei

goto da;
{
   Ding a;
   Ding b;

   da:

   // ... mehr Code

bedeutet das goto, dass a und b über ihre Defaultkonstruktoren erzeugt werden. Zumindest findet man das so in Büchern, die meisten Compiler erlauben das nicht.

[fredyxx]

Das ist mir zu hoch und sollte sich m.E. auch auf einen Link beschränken, der auf eine andere Stelle im Forum zeigt, wo solche Spezialthemen behandelt werden.

Wie dem auch sei. Ich habe die Ursache gefunden und die hatte nichts mit goto o.ä. zu tun.

Es handelte sich um zeitliche und logische Abläufe bei der STOP-Tastenauswertung, die ich nicht vollständig durchschaut und richtig umgesetzt hatte.

Danke für eure sehr aktive Hilfe. Ich kenne in dem Programm mindestens noch ein Problem, an dem ich nun beginne zu knabbern.

Befriedigend ist es ja dann, wenn man es doch wieder mal geschafft hat und man hat wieder was dazu gelernt.


vG

fredyxx

[HaWe]

was hinter "case" steht, heißt nicht umsonst "label": es ist eine verkappte Sprungadresse, genau wie bei goto. Dabei wird der Wert der Bedingung mit der Label/Sprungmarke verknüpft/assoziiert.
Von der Logik her ist es natürlich vergleichbar mit if/else-Ketten, mit dem Unterschied, dass hier kein "break" nötig ist nach jeder logischen Bedingung
- was wieder darauf zurückzuführen ist, dass vor der nächsten case-label/Sprungmarke per "break" ans Ende vom "switch"-Block gesprungen werden muss, ebenfalls genau wie bei reinen aneinandergereihten goto Sprungmarken:
täte man das nicht, würde weiter einfach zeilenweise der Code schrittweise weiter abgearbeitet werden, direkt in den nächsten case-"Körper" hinein, ebenfalls genau wie bei kaskadierten goto-Befehlen, auch hier würde einfach über das kommende Label hinweggelesen, in die dann folgenden Anweisungen "hinein".

Man müsste sich wahrscheinlich wirklich mal die Mühe machen, den nackten Maschinencode zu untersuchen, den ein C und auch ein C++ Compiler aus switch/case, goto und if/else-Ketten/Blöcken macht, aber allein schon der Unterschied, dass case (genau wie goto) nur Konstanten als Labels erlaubt (1,2,3,4...), während if/else jedes logische Statement zulässt (<2, >=2 und <3.999, >=4...), zeigt schon die Ähnlichkeiten von goto und switch/case und den Unterschied zu if/else (letzteres ist allerdings genau das, was ich selber bevorzuge, wegen der größeren Möglichkeiten und Mächtigkeit dieses Konstrukts, ohne dabei aber auf goto zu verzichten; switch/case hingegen ist IMO das "allerletzte" wegen der Beschränkung auf Integer-Konstanten und dem nervtötenden "break" zwischen den Sprungmarken).

[Mxt]

- was wieder darauf zurückzuführen ist, dass vor der nächsten case-label/Sprungmarke per "break" ans Ende vom "switch"-Block gesprungen werden muss, ebenfalls genau wie bei reinen aneinandergereihten goto Sprungmarken

Das ist gleich doppelt falsch. Ein switch kann in C und C++ auch so aussehen

switch(wert)
{
case 1:
case 2:
case 3:
  // Code für die ersten drei Fälle
  break;

case 4:
  // speziell für 4
case 5:
case 6:
  // für 4 bis 6 gemeinsam
}

Weil das eine beliebte Fehlerquelle ist, durch ein vergessenes break, haben erst neuere Sprachen wie C# die Regel eingeführt, dass jedes case mit einem break beendet werden muss.


Zweitens ist es natürlich nicht richtig, dass irgendwie ans Ende des switch gesprungen werden muss. In C++ schon weil es Exceptions gibt, die können natürlich ein switch an beliebiger Stelle verlassen. Und gemeinsam mit C gibt es natürlich die Möglichkeit mit return statt break herauszugehen.

[HaWe]

das ist nicht doppelt faslch, du hast meinen Punkt einfach nicht richtig verstanden
- ntl kann man bei case das break weglassen, aber um es mit "else" zu vergleichen, muss eben doch ein break folgen:

du hast schließlich selber den Vergleich zu if/else bemüht, ich wollte nur den Unterschied zum (exklusiven) else hervorheben, gegenüber dem völlig anders - nämlich sprungmarkenartig - funktionierenden case, wo ohne break einfach zeilenweise weiter gearbeitet wird.

[Mxt]

Ein

case 1:

entspricht etwa einem (Pseudocode)

if (noch_kein_passendes_case_gesehen && (x != 1))
  goto hinter_naechstes_break;  // wo wieder ein if steht
else
  noch_kein_passendes_case_gesehen = false;

[HaWe]

du kannst es analogiemäßig erklären und umschreiben wie du willst, wem oder was immer es pseudocodemäßig entsprechen mag, aber es bleibt dabei, dass bei Erfüllung der Bedingung eine dem Integerwert entsprechende gleichnamige Integer-Sprungmarke angesprungen wird, die genau wie bei goto-labels eine Konstante sein muss und auch genau wie bei Lables von einem Doppelpunkt gefolgt wird:

if(x==1) goto 1;
if(x==2) goto 2;
if(x==3) goto 3;
if(x==4) goto 4;
goto default;
1: ...
2: ...
3: ...
4: ...
default: ...

Es entspricht aber keinesfalls eher oder unmittelbarer einem kaskadierten
if/else if /else if/...
wo dann auch nicht der Rest wie bei if/else-Körpern übersprungen wird, sondern ebenfalls wie bei goto Labels einfach schrittweise weitergearbeitet wird und wo in jedem else-Körper auch wieder Variablen-Ausdrücke, floats oder statements erlaubt wären.

Wie auch immer:
alles ist legaler C Code und hat seine gleichwertige Daseins-Berechtigung.