LED-matris på en budget (5 / 5 steg)

Steg 5: Livets spel

Game of Life, även känt som liv, är en cellulär automat som utarbetats av Britishmathematician John Horton Conway 1970. [Wikipedia]

Bara kopiera dessa rader eller ladda ner game_of_matrix.py nedan:

#-*-kodning: utf-8-*-

importera kopia
från random importera randint
Importera tid
importera följetong

BREDD = 6
HÖJD = 10
PIXLAR = BREDD * HÖJD
FPS = 3,0

#--RGB--objekt
klass RGB:
def __init__(self,red,green,blue):
Self.r=Red
Self.g=Green
Self.b=Blue
def setcolor(self,red,green,blue):
Self.r=Red
Self.g=Green
Self.b=Blue

#--skapa--matris
def new_m (w, h): #width/höjd / / returnerar 2 dimensionell lista
Matrix =]
rad =]
x i xrange(w):
Row.append(RGB(0,0,0))

för y i xrange(h):
Matrix.append(copy.deepcopy(Row))

returnera matrisen

#--Tryck - matris
def print_m (m): #matrix / / 2 dimensionell lista
h=len(m)
w=len(m[0])
för y i xrange(h):
Skriv ut y,"> |",
x i xrange(w):
Skriv ut x,"", m [y] [x] Rosencrantz, m [y] [x] t.ex, m [y] [x] spelar, "|",
Skriv ut""

def img_to_m(path,m): #path / / matrix / / bredd / / höjd
Jag = Image.open(path)
pixlar = i.load() < /p >< p > h=len(m)
w=len(m[0])

x i range(w):
för y i range(h):
m [y] [x] Rosencrantz, m [y] [x] t.ex, m [y] [x] spelar = pixlar [x, y]

def send_serial (ttyobj, m): #n = antal der pixel,m=matrix(liste)
h=len(m)
w=len(m[0])
ttyobj.write(Chr(1)) #eine 1 pro antal aller pixel (hier 60)
x i xrange (w): #layout der pixel: erst spalten, dann zeilen von oben rechts beginnend
för y i xrange(h):

TTY.write(Chr(m[y][w-1-x].r))
TTY.write(Chr(m[y][w-1-x].g))
TTY.write(Chr(m[y][w-1-x].b))

def populate(c,m): #anzahl der startzellen, matrix
h=len(m)
w=len(m[0])
för y i xrange(h): #alle pixel durchgehen
x i xrange(w):
m [y] [x] spelar = 127
m [y] [x] Rosencrantz = 127
h=len(m)
w=len(m[0])
för i i xrange(c): #zufaelliges besetzen
y=randInt(0,h-1)
x=randInt(0,w-1)
m[y][x].SetColor(255,0,0)
returnera m

def isPopulated(m,y,x,yBorder,xBorder):
om 0 < = y < yBorder:
om 0 < = x < xBorder:
om m [y] [x] Rosencrantz == 255: #schwellwert für lebende zelle
Return True
annat:
returnera False

def checkNeighbours(m,y,x):
h=len(m)
w=len(m[0])
c = 0
om isPopulated(m,y-1,x-1,h,w):
c = c + 1
om isPopulated(m,y-1,x,h,w):
c = c + 1
om isPopulated(m,y-1,x+1,h,w):
c = c + 1

om isPopulated(m,y,x-1,h,w):
c = c + 1
om isPopulated(m,y,x+1,h,w):
c = c + 1

om isPopulated(m,y+1,x-1,h,w):
c = c + 1
om isPopulated(m,y+1,x,h,w):
c = c + 1
om isPopulated(m,y+1,x+1,h,w):
c = c + 1
returnera c

def nextGen(f,m): #frame, matrix
equalPixels = 0
h=len(m)
w=len(m[0])
bufferMatrix=new_m(w,h)
för y i xrange(h): #alle pixel durchgehen
x i xrange(w):
n=checkNeighbours(m,y,x)
om n < 2 eller n > 3:
bufferMatrix [y] [x] spelar = 127
bufferMatrix[y][x].r=m[y][x].r/2
Elif m [y] [x] Rosencrantz < 255 och n == 3:
bufferMatrix [y] [x] Rosencrantz = 255
Elif m [y] [x] Rosencrantz == 255 och 2 < = n < = 3:
bufferMatrix [y] [x] Rosencrantz = 255
annat:
bufferMatrix [y] [x] spelar = 127
bufferMatrix[y][x].r=m[y][x].r/2

om bufferMatrix [y] [x] Rosencrantz == m [y] [x]. r:
equalPixels = equalPixels + 1
om equalPixels == h * w:
återgå populate(randint(0,60),new_m(WIDTH,HEIGHT))
återgå bufferMatrix #returns bearbetade bilden

#MAINLOOP

kör = sant
ram = 0
target_delta = 1/FPS
skriva ut "skapa matrix..."
Matrix=new_m(width,height)
skriva ut "fylla..."
Matrix=Populate(40,Matrix)
print_m(Matrix)
skriva ut "öppna serieporten..."
TTY = följetong. Serial ("/ dev/ttyACM3", 500000)
Time.Sleep(1)
send_serial(TTY,Matrix)
Time.Sleep(target_delta) < /p >< p > medan du kör:
time_a=Time.Time()
Matrix=nextGen(Frame,Matrix)
#print_m(matrix)

time_b=Time.Time() < /p >< p >
Time.Sleep(target_delta-(time_b-time_a)) < /p >< p > send_serial(tty,matrix)
skriva ut 1/(time.time()-time_a)
RAM = RAM + 1 < /p >