Conway's Game of Life auf einem ATmega32

[Torrentula]

Sieht cool aus dein Programm!

ok ich habe das jetzt mal versucht umzuschreiben soweit noch keine Probleme mit den Schleifen und allem. Nun aber:

Was stellen die Leerzeichen hier dar:

anz=anz+alt(a-1,b  )+               +alt(a+1,b   )

[BMS]

Die Leerzeichen haben keine Bedeutung, dient nur der Übersichtlichkeit.
Ein logisches AND in C geht mit && (ja, zwei mal!) , das brauchst du hier

Der Vollständigkeit halber:
Bitweises AND geht mit & (nur eins) , das brauchst du hier aber nicht

[Torrentula]

Mein Code sieht jetzt so aus:

#include <stdlib.h>
#include <avr/io.h>
#include "rn-control.h"

#define width 5         // Breite des Spielfelds
#define height 5        // Höhe des Spielfelds

int bit[width][height]; // Bitfeld
int alt[width][height]; // Backup

int main(void){

//#######################Initialisierungen#######################

// Deklarieren der Input/Output-Pins

//###############################################################

int a;
int b;

bit[2][2] == 1;

while(1){
    for (a = 1; a <= (width-1); ++a){
        for (b = 1; b <= (height-1); ++b){
            // in andere Matrix kopieren
            alt[a][b] = bit[a][b];

            // Nachbarn Checken

            int anz = 0;
            anz = anz + alt[a-1][b-1]+alt[a][b-1]+alt[a+1][b-1];
            anz = anz + alt[a-1][b] + alt[a+1][b];
            anz = anz + alt[a-1][b+1] + alt[a][b+1] + alt[a+1][b+1];

            // Stadien bestimmen

            // Wiedergeburt
                   if (anz == 3){
                       if (bit[a][b] == 0){
                        bit[a][b] = 1;
                    }
                }
            // Einsamkeit
                if (anz < 2){
                    if(bit[a][b] == 1) {
                        bit[a][b] = 0;
                    }
                }

            // bleibt am Leben
                if (anz == 2){
                    if (bit[a][b] == 1){
                        bit[a][b] = 1;
                    }
                }

            // bleibt am Leben
                if (anz == 3){
                    if (bit[a][b] == 1){
                        bit[a][b] = 1;
                    }
                }

            // Überbevölkerung
                if (anz > 3){
                    bit[a][b] = 0;
                }


        }
    }

    // Ausgebeben

    for (a = 0; a = width; ++a){
        for (b = 0; b = height; ++b){
            if ( bit[a][b] == 1){

            }
        }
    }

}
    return 0;
}

Da müssen jetzt halt noch die Pindefinitionen rein. Wie kann ich das dann Ausgeben dass er mir auch die LED anschaltet, die im Spielfeld 1 ist?
Am besten wahrscheinlich einfach if-schleifen die abfragen, wann welches Feld an ist und dementsprechend die LEDs einschaltet...

[BMS]

Ein paar if-Abfragen dürften hier das einfachste sein.
Die letzten zwei Schleifen passen nicht wegen a=width, das sollte eher a<=width oder a<width heißen, das wirst du aber bzgl. der Ausgabe sowieso in if umbauen.
Noch etwas: Zu Beginn hast du nur die mittlere LED auf 1 gesetzt, die wird beim ersten Schritt einfach an Einsamkeit ausgehen Da musst du schon ein paar mehr setzen!

Die Variablen a und b kannst du als unsigned char machen, das spart Speicherplatz.
Bei den Bitfeldern könnte eventuell bool[width][height] klappen.

[Torrentula]

Au stimmt

Vielen Dank!

[Torrentula]

So ich habe jetzt die Pindefinitionen drin.

Bin in der zwischenzeit übrigens auf einen ATmega8 umgestiegen.

Der Code sieht im Moment so aus. Irgendwie kann ich keine Veränderung der LED-Stadien sehen. Auch die mittlere LED, die im Seed definiert ist, leuchtet nicht.

#include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>


#define width 5         // Breite des Spielfelds
#define height 5        // Höhe des Spielfelds

int bit[width][height]; // Bitfeld
int alt[width][height]; // Backup

void LED(unsigned char a, unsigned char b){

    if (a == 1 && b == 1){
        PORTB |= (1<<PB3);
    }
    if (a == 1 && b == 2){
        PORTB |= (1<<PB4);
    }
    if (a == 1 && b == 3){
        PORTB |= (1<<PB5);
    }
    if (a == 2 && b == 1){
        PORTC |= (1<<PB0);
    }
    if (a == 2 && b == 2){
        PORTC |= (1<<PB1);
    }
    if (a == 2 && b == 3){
        PORTC |= (1<<PB2);
    }
    if (a == 3 && b == 1){
        PORTC |= (1<<PB3);
    }
    if (a == 3 && b == 2){
        PORTC |= (1<<PB4);
    }
    if (a == 3 && b == 3){
        PORTC |= (1<<PB5);
    }

}

int main(void){

//#######################Initialisierungen#######################

DDRC = 0xFF;
DDRB = 0xFF;

//###############################################################

unsigned char a;
unsigned char b;

bit[2][1] = 1; // Seed 
bit[2][2] = 1;
bit[2][3] = 1;


while(1){
    for (a = 1; a <= (width-1); ++a){
        for (b = 1; b <= (height-1); ++b){
            // in andere Matrix kopieren
            alt[a][b] = bit[a][b];

            // Nachbarn Checken

            int anz = 0;
            anz = anz + alt[a-1][b-1]+alt[a][b-1]+alt[a+1][b-1];
            anz = anz + alt[a-1][b] + alt[a+1][b];
            anz = anz + alt[a-1][b+1] + alt[a][b+1] + alt[a+1][b+1];

            // Stadien bestimmen

            // Wiedergeburt
                   if (anz == 3){
                       if (bit[a][b] == 0){
                        bit[a][b] = 1;
                    }
                }
            // Einsamkeit
                if (anz < 2){
                    if(bit[a][b] == 1) {
                        bit[a][b] = 0;
                    }
                }

            // bleibt am Leben
                if (anz == 2){
                    if (bit[a][b] == 1){
                        bit[a][b] = 1;
                    }
                }

            // bleibt am Leben
                if (anz == 3){
                    if (bit[a][b] == 1){
                        bit[a][b] = 1;
                    }
                }

            // Überbevölkerung
                if (anz > 3){
                    bit[a][b] = 0;
                }


        }
    }

    // Ausgeben

    for (a = 0; a <= width; ++a){
        for (b = 0; b <= height; ++b){
           if (bit[a][b] == 1){
                LED(a, b);            
            }
        }
    }

    _delay_ms(100); 

}
}

Vielleicht ein brutal einfacher Fehler, find ihn aber gerade nicht...

Hoffe ihr könnt mir helfen

[sternst]

Ich sehe zwei grundlegende Fehler.

1)
Der Algorithmus kann so nicht funktionieren. Gleichzeitiges Kopieren und Auswerten geht nicht. Spiel deinen Code doch einfach mal mit alt komplett Null und bit mit der Seed Zeile für Zeile durch.

2)
Ich sehe nur, dass LEDs eingeschaltet werden. Wo werden sie wieder ausgeschaltet, wenn ein Feld Null ist?