[ATmega32] Verlassen der Schleife verlässt alle Schleifen

[Gast (Gast)]

Ich versteh nicht warum, aber sobald er die innerste while Schleife 
durchlaufen hat, verlässt er automatisch alle anderen Schleifen auch. 
Als wäre irgendwo ein riesen break; versteckt. Die vorherige wird aber 
noch bis zum Ende durchlaufen. Also in der for () wird PORTC noch auf 0 
geschalten, und die 1. while Schleife noch 1x X erhöht. Aber er 
durchläuft while kein weiteres mal. Ich versteh nicht, warum nicht 
wieder normal die vorherigen Schleifen weiterlaufen, sondern beendet 
werden. gcc meldet keine Fehler und übertragen kann ich es normal.

Der Code dient jetzt nur zum Testen einiger 7-Segmentanzeigen. Im code[] 
Array sind die verschiedenen Segmentcodes gespeichert.
Es soll:
- eine Zahl anzeigen (while1)
- die innereste while 20x durchlaufen lassen
- in der 1. while die nächste Zahl anzeigen
- wieder innerste while, usw.
- das ganze 2x; dafür die for()

i, x und y sind deklariert als int.

for (i=0; i<2;i++) {


char code[] = {0xF9, 0x88, 0xB5, 0x9D, 0xCC, 0x5D, 0x7D, 0x89, 0xFD, 0xDD, 0x00, 0x3D, 0x23, 0x37, 0x6B, 0x79, 0x63, 0x69, 0x7D};
while (x < strlen(code)) {
PORTC = code[x];
while (y < 20) { // läuft korrekt durch
PORTD = 0x20;
_delay_ms(5);
PORTD = 0x40;
_delay_ms(5);
PORTD = 0x10;
_delay_ms(5);
PORTD = 0x80;
_delay_ms(5);
PORTD = 0x08;
_delay_ms(5);
y++;
  }
x++; // wird beim verlassen der 2. while() 1x ausgeführt und verlässt dann while()
 }
PORTC = 0x00; // wird genauso 1x ausgeführt und verlässt die for()
}

[Skua (Gast)]

x = 0;
y = 0;

[Gast (Gast)]

Alle 3 Zählvariablen sind am Anfang als 0 deklariert.

int i = 0;
int x = 0;
int y = 0;

Und solange sie kleiner als die Schleifenprüfung sind, müsste es ja 
immer laufen.

[Skua (Gast)]

Am Anfang reicht nicht du must vor jedem Durchlauf der x Schleife x auf 
0 setzen dito fuer y.

[Matthias L. (Gast)]

Wie wäre es denn erstmal mit einer ordentlichen Formatierung des Codes?
Einrückungen

for (i=0; i<2;i++)
{
  char code[] = { 0xF9, 0x88, 0xB5, 0x9D, 0xCC, 0x5D, 0x7D, 0x89,
                  0xFD, 0xDD, 0x00, 0x3D, 0x23, 0x37, 0x6B, 0x79,
                  0x63, 0x69, 0x7D };
  while ( x < strlen(code) )
  {
    PORTC = code[x];
    while (y < 20)
    { // läuft korrekt durch
      PORTD = 0x20;
      _delay_ms(5);
      PORTD = 0x40;
      _delay_ms(5);
      PORTD = 0x10;
      _delay_ms(5);
      PORTD = 0x80;
      _delay_ms(5);
      PORTD = 0x08;
      _delay_ms(5);
      y++;
    }
    x++; // wird beim verlassen der 2. while() 
         // 1x ausgeführt und verlässt dann while()
  }
  PORTC = 0x00; // wird genauso 1x ausgeführt und verlässt die for()
}

[Einer (Gast)]

hattu schön macht.

[Martin (Gast)]

Das Problem ist dass, wie Skua gesagt hat, die Variablen der inneren 
Schleifen einmal hochlaufen und dann auf ihrem Wert der Größe als die 
Bedingung der While Schleife ist Hängenbleiben. Die for Schleife läuft 
zwar Ordnungsgemäß durch aber nach dem ersten Durchlauf werden ja die 
beiden while Schleifen nicht mehr ausgeführt. du musst es also so 
machen:

for()
{
  while(x)
  {
   while(y)
     {
     }
  y=0;
  }
x=0;
}

[JensM (Gast)]

Zusätzlich ist nicht definiert was die Funktion strlen(code) 
zurückliefert.

strlen sucht nach einem 0x00 als Endekennung eines Strings.
Dies ist im char[] nicht definiert und was nach dem Array kommt kann 
niemand sagen.

In diesem Fall wäre es besser mit sizeof() zu arbeiten, da dies der 
Compiler schon zur Compilierung auflösen kann und nicht zur Laufzeit
bei jedem Schleifendurchlauf berechnet werden muss.

Ich mache sowas gerne in folgender Form:

while (x < (sizeof(code) / sizeof(char))) {

Das kann der Compiler komplett auflösen und wenn sich z.B.
Datentypen ändern (nicht in diesem Fall, aber wenn statt char Strukturen 
vorhanden sind) muss keine Anpassung gemacht werden.

[Bernhard M. (boregard)]

JensM wrote:
> Zusätzlich ist nicht definiert was die Funktion strlen(code)
> zurückliefert.
>
> strlen sucht nach einem 0x00 als Endekennung eines Strings.
> Dies ist im char[] nicht definiert und was nach dem Array kommt kann
> niemand sagen.
>
ist doch definiert:

  char code[] = { 0xF9, 0x88, 0xB5, 0x9D, 0xCC, 0x5D, 0x7D, 0x89,
                  0xFD, 0xDD, 0x00, <-----!!!

> In diesem Fall wäre es besser mit sizeof() zu arbeiten, da dies der
> Compiler schon zur Compilierung auflösen kann und nicht zur Laufzeit
> bei jedem Schleifendurchlauf berechnet werden muss.
>
> Ich mache sowas gerne in folgender Form:
>
> while (x < (sizeof(code) / sizeof(char))) {
>
> Das kann der Compiler komplett auflösen und wenn sich z.B.
> Datentypen ändern (nicht in diesem Fall, aber wenn statt char Strukturen
> vorhanden sind) muss keine Anpassung gemacht werden.

aber ansonsten hast Du vollkommen recht, zumal bei der 0x00 mitten im 
String dieser nicht vollständig abgearbeitet wird...

[Gast (Gast)]

Jetzt funktionierts :-D Ich bin wohl noch zuviel PHP verwöhnt.

Aber das mit dem 0x00 im Array ist/war mir neu. Lerne ich wieder was 
dazu.

Thx an alle.