Welche Möglichkeiten der Fehlersuche hat man beim Arduino?

[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.

[Mxt]

Wie es genau aussieht hängt sowohl vom Compiler als auch von der Verteilung der Werte der case ab. Hier hat einer das für einen Compiler mal angeschaut
http://www.codeproject.com/Articles/...-Switch-Statem
Da verwendet der Compiler gleich drei verschiedene Implementierungen, je nach Struktur der cases.

[HaWe]

auch in deinem Link wird mehrfach die Compilierung zu jmp lables erwähnt.
mag jedoch alles im Detail sein wie es will, switch/case ist trotzdem prinzipiell ein goto und kein if/else if, sonst wären nicht nur Integer-Konstanten sondern auch Variablen-Ausdrücke, floats oder statements als Fallunterscheidungen erlaubt.

und wie bereits erwähnt,

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

[Mxt]

Erstmal, ja

alles ist legaler C Code und hat seine gleichwertige Daseins-Berechtigung.

Aber, nein

switch/case ist trotzdem prinzipiell ein goto und kein if/else if

es ist eine Tabelle, wenn das kürzer ist, sonst sind es auch if.

Ganz unschuldiges Beispiel

switch(i)
{
  case 1:
    // ...
    break;
  case 2:
    // ...
    break;
  case 3:
    // ...
    break;
}

gibt eine Tabelle.

Aber

switch(i)
{
  case 10:
    // ...
    break;
  case 100:
    // ...
    break;
  case 1000:
    // ...
    break;
}

ups, was machen wir mit den Zwischenwerten ? Eine Tabelle mit 1001 Einträgen in den Speicher vom armen Arduino ?

Nein, da passiert was ganz anderes. Und deshalb überlegt der Compiler so lange ...