Probleme mit der Endlosschleife

Könntest du das bei Gelegenheit etwas lesbarer formatieren? Dann kann
man die Programmstruktur viel leichter erkennen. Schau dir mal ein paar
Beispiele an, und achte drauf entweder nur Tabs oder nur Leerzeichen zu
verwenden, aber nicht beides.

Und das Goto scheint mir so überflüssig wie ein Kropf; das kann man
doch alles ins case-Statement packen.

Was soll denn das hier:

switch (phase) {
         case 1: goto label_1; break;
         case 2: goto label_2; break;
     case 3: goto label_3; break;
     case 4: goto label_4; break;
     case 5: goto label_5; break;
     case 6: goto label_6; break;
          }


Man kann das ganze sicherlich noch unübersichtlicher programmieren,
aber was bitte hat goto in einem switch-Statement verloren?

Okay an der Formatierung kann sicherlich noch was ändern. Aber was mit
der While-Schleife im main-Program ? Wieso lässt sie kein
Timer-Interrupt zu ?

Mal nichts überstürzen. Für eine Ampelsteuerung ist ganz bestimmt kein
Assembler notwendig.

Tom, setz erst mal die Vorschläge um, dann löst sich das Problem
vielleicht von ganz alleine, und vorher wird sich auch niemand das
Programm genauer anschauen wollen.

Ich weiß nicht,ob  ihr mein Problem richtig verstanden habt!
Wenn ich in der main-Funktion goto - Schleife einbaue, läuft alles
einwandfrei !

void main(void)  //Hauptprogramm
{
  init();
  loop:
  PORTB = temp;
  PORTD = temp2;
    if bit_is_clear(PINB,7) // ( !(PINB & (1<<PINB7)) )
    {
      temp2 &= ~ (1<< PD1) ; // PD1 wird auf Low
      Taster_gedrueckt = 1; // Taster wurde betätigt
    }
  goto loop;   // Endlosschleife
 }




Verwende ich jedoch ich einen While oder-for Schleife wird die
Interruptroutine nicht aufgerufen!

Ein Fehler bei einem so simplen Stück Code ist so unwahrscheinlich dass
man von einem Fehler beim Anwender ausgehen kann, und nach einem Blick
auf dem Code wird der auch schnell klar: Variablen die in
Interruptroutinen und Hauptprogramm verwendet werden müssen als
volatile deklariert werden.

Vermutlich wird goto bei der Optimierung etwas anders behandelt als
eine Schleife, deshalb funktioniert es in dem einen Fall und in dem
anderen nicht.

Das ist die längste ISR, die ich jemals gesehen habe.

Erinnern tut mich das Programm an eins, das ein Freund vor Jahren
(damals war der 286er richtig gut und teuer...) geschrieben hat. Ihm
war wohl auch die Existenz von Feldern bekannt.

So würde ich es machen:

Ein Feld (aus Konstanten) mit den sechs Phasen erzeugen.
Mit der Timer-ISR einfach den Phaseindex hochzählen, wenn er zu groß
ist zurück auf 0 setzen.
Scheinbar (dank der fehlenden Dokumentation noch schwieriger
herauszufinden) handelt es sich um eine Bedarfsampel, die auf
Tastendruck erst startet.

In der Main wird also einfach die Ampel initialisiert (rot für
Fußgänger, grün für Kfz).
In einer Schleife wird solange abgefragt, ob die Taste gedrückt wurde,
bis sie gedrückt wurde.
Jetzt wird der Timer gestartet. In einer weiteren Schleife wird
geprüft, ob sich der Phasenindex dank eines Timer-Überlaufs geändert
hat Entsprechend wird die Konstante an den Port geschrieben.
Die Schleife wird abgebrochen, sobald der Phasenindex bei der letzten
Phase angekommen ist. Dann landet das Programm wieder in der
"aufdieTastendrück"-Warteschleife.
In der ISR wird der Phasenindex inkrementiert und der Timer-Reload-Wert
neu gesetzt.

Viel Code ist das nicht. Man braucht definitiv kein goto.

Eigentlich sollte man die Benutzung dieses Wortes unter Strafe stellen.
Zuletzt habe ich es gebraucht, als auf dem Apple][ noch ein
Basic-Interpreter arbeitete. Der Rechner verstand auch noch keine
Funktionsaufrufe...

Danke Andreas !

Wenn man die Variablen mit volatile deklariert dann läufts auch mit For
und While-Schleifen !

Tschüss
Tom

weil der Compiler sie sonst wegoptimiert.

Variablen, die "von aussen" sichtbar sein sollen, müssen global
vereinbart werden.
Volatile weist den Compiler nur an, die Variable zu übersetzen, auch
wenn er dafür in diesem Moment keine Verwendung sieht. Ist sie nicht
als volatile vereinbart, und der Compiler sieht keine Verwendung, dann
optimiert er sie weg. (Suchfunktion des Forums zum Thema
"volatile").

volatile gehört ja auch nicht zu Standard-C, oder?