Conway's Game of Life auf einem ATmega32

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

[Torrentula]

Spiel deinen Code doch einfach mal mit alt komplett Null und bit mit der Seed Zeile für Zeile durch.

Wie meinst du das genau? Den seed in bit einfügen und durchlaufen lassen und dann alt auf 0 setzen und laufen lassen und am Ende kopieren?

[sternst]

Wie meinst du das genau?

Ich meine damit, dass du selber mal den Prozessor spielen sollst, um zu merken, woran dein Algorithmus krankt. Du malst dir zwei Felder auf (alt und bit), alt enthält zu Anfang nur Nullen und bit den Seed. Und jetzt gehst du deinen Sourcecode Zeile für Zeile durch und vollziehst die Schritte auf deinem Blatt nach.

[Calis007]

Ich seh das genauso wie sternst. Der Algorithmus hat einen groben Bug
Aber irgendwie kommt mir vor, hier laesst jemand seine Hausaufgaben machen, daher auch von mir nur der Tipp, es mal per Hand nachzuvollziehen.(edit: sehe gerade, dass hier ein alter Thread wiederbelebt wird, daher unwahrscheinlich
Falls ich mich irre, dann bitte ernsthaft wenigstens ueber 6x6 (+Rand) nachdenken. Auf 3x3 gibts nicht viel Spannendes zu sehen ausser dem ewig lebenden 2x2-Block und der oszillierenden 3x1-Linie.