Unbuffer python...

.rsync-filter

@@ -0,0 +1 @@
+- custom

README.md

@@ -0,0 +1,11 @@
+Building and deployment
+=======================
+
+    $ cd arduino && pio run && cd ..
+    $ cd raspi/mgmt && ansible-playbook playbook.yml && ansible-playbook
+        arduino.yml
+
+Customization
+=============
+
+`raspi/mgmt/custom/{{ IP }}` is overlaid over default raspi/ code

arduino/src/main.ino

@@ -331,8 +331,8 @@ void pin_mazeISR() {
 void openDrawer(){
 	log("The drawer is open.");
 	digitalWrite(pin_drawer_relay, HIGH);
-	delay(DRAWER_OPEN_DELAY);
+	// delay(DRAWER_OPEN_DELAY);
-	digitalWrite(pin_drawer_relay, LOW);
+	// digitalWrite(pin_drawer_relay, LOW);
 }
 
 void checkPassword(){

raspi/gameplayconfig.py

@@ -0,0 +1,11 @@
+#gameplay
+#wynik w snake, ktory wygrywa
+SNAKE_SCORE = 2
+#predkosc gry w snake - w zakresie od 1 do 10 
+TICK_SNAKE = 10
+#ilosc segmentow dodanych do snake po zlapaniu jablka
+SNAKE_ADDSIZE = 10
+
+#hasla klawiatury ekranowej dla obu zagadek
+PASSWORD1 = 'one'
+PASSWORD2 = 'two'

raspi/mgmt/arduino.yml

@@ -0,0 +1,8 @@
+- hosts: raspi
+  become: True
+  become_user: root
+  tasks:
+    - copy: src=../../arduino/.pioenvs/megaatmega2560/firmware.hex dest=/tmp
+    - systemd: state=stopped name=lightdm
+    - shell: avrdude -p m2560 -c wiring -P /dev/serial/by-id/* -b 115200 -D -F -U flash:w:/tmp/firmware.hex
+    - systemd: state=started name=lightdm

raspi/mgmt/hosts

@@ -1,5 +1,11 @@
-[raspi]
+[raspi-wifi]
 192.168.43.12
-#192.168.43.44
+192.168.43.44
 192.168.43.219
 192.168.43.231
+
+[raspi]
+10.21.37.150
+10.21.37.180
+10.21.37.185
+10.21.37.226

raspi/mgmt/playbook.yml

@@ -2,6 +2,13 @@
   become: True
   become_user: root
   tasks:
+    - synchronize: src=../.. dest=/home/pi/sejf
+    - synchronize: src="custom/{{ inventory_hostname }}" dest=/home/pi/sejf/raspi
+      ignore_errors: yes
+    - copy: src=sejf.service dest=/etc/systemd/system/sejf.service
+    - systemd: name=sejf state=restarted enabled=yes
     - copy: src=autostart dest=/home/pi/.config/lxsession/LXDE-pi/autostart
-    - copy: src=sejf.desktop dest=/etc/xdg/autostart
     - apt: name=python-flask state=present
+    - apt: name=avrdude state=present
+    - file: path=/etc/xdg/autostart/pprompt.desktop state=absent
+    - file: path=/etc/xdg/autostart/sejf.desktop state=absent

raspi/mgmt/sejf.desktop

@@ -1,7 +0,0 @@
-[Desktop Entry]
-Type=Application
-Name=sejf
-NoDisplay=true
-Exec=python /home/pi/sejf/raspi/pySejf.py
-Terminal=true
-NotShowIn=GNOME;KDE;XFCE;

raspi/mgmt/sejf.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=sejf
+After=lightdm.service
+
+[Service]
+ExecStart=/usr/bin/python -u /home/pi/sejf/raspi/pySejf.py
+Restart=always
+Environment=DISPLAY=:0
+User=pi
+KillSignal=SIGKILL
+
+[Install]
+WantedBy=default.target

raspi/pySejf.py

@@ -1,34 +1,162 @@
 #!/usr/bin/python
 import os
 os.chdir(os.path.dirname(os.path.realpath(__file__)))
+os.environ['SDL_VIDEO_CENTERED'] = '1'
 
 import serial
 import webapp
+import threading
+import logging
+import socket
+import json
+import string
 
-webapp.init(serial.Serial('/dev/ttyUSB0', 115200))
+logging.basicConfig(level=logging.INFO)
-
+import random, pygame
-import random, math, pygame
 from pygame.locals import *
-from virtualKeyboard import VirtualKeyboard
 
 import threading
-from math import cos
 import time
 import RPi.GPIO as GPIO
 
+class Slide(object):
+    def __init__(self):
+        pass
+
+    def render(self, screen):
+        pass
+
+    def handle(self, ev):
+        pass
+
+    def enter(self, prev_slide):
+        return True
+
+    def exit(self, next_slide):
+        return True
+
+
+class ImageSlide(Slide):
+    def __init__(self, image):
+        self.image = image
+
+    def render(self, screen):
+        screen.fill(WHITE)
+        screen.blit(self.image, (0, 0))
+
+class FinalSlide(ImageSlide):
+    def exit(self, next_slide):
+        # Allow change to exit slide
+        return isinstance(next_slide, FinalSlide)
+
+class FinalEverythingSlide(FinalSlide):
+    def enter(self, prev_slide):
+        global wall_a
+        if(wall_a):
+            win()
+            pygame.mixer.music.load("media/win.mp3")
+            pygame.mixer.music.play(MP3_LOOPS)
+            pygame.mixer.music.set_volume(1.0)
+
+        return True
+
+class SnakeSlide(Slide):
+    def enter(self, prev_slide=None):
+        self.xs = [290, 290, 290, 290, 290];
+        self.ys = [290, 270, 250, 230, 210];
+        self.dirs = 0
+        self.score = 0
+        self.applepos = (random.randint(0, WINSIZEX), random.randint(0, WINSIZEY))
+        #s=pygame.display.set_mode((600, 600))
+        self.appleimage = IMG_APPLE
+        self.img = IMG_SNAKEBODY#pygame.Surface((20, 20))
+        #img.fill((255, 0, 0))
+        self.f = FONT_SNAKE
+        self.clock = pygame.time.Clock()
+        self.finished = False
+
+        return True
+
+    def finish(self):
+        self.finished = True
+        self.finish_time = time.time()
+
+    def handle(self, e):
+        print(e)
+        if e.type == KEYDOWN:
+            if e.key == K_UP and self.dirs != 0: self.dirs = 2
+            elif e.key == K_DOWN and self.dirs != 2: self.dirs = 0
+            elif e.key == K_LEFT and self.dirs != 1: self.dirs = 3
+            elif e.key == K_RIGHT and self.dirs != 3: self.dirs = 1
+
+            if self.finished and time.time() - self.finish_time > 3:
+                self.enter()
+
+            print(self.dirs)
+
+    def render(self, screen):
+        self.clock.tick(TICK_SNAKE)
+
+        if not self.finished:
+            self.interact()
+
+        #rysuj tlo
+        screen.fill(WHITE)
+        screen.blit(IMG_SNAKE, (0, 0))
+
+        for i in range(0, len(self.xs)):
+            screen.blit(self.img, (self.xs[i], self.ys[i]))
+
+        screen.blit(self.appleimage, self.applepos);
+        t=self.f.render(str(self.score), True, (0, 0, 0));
+        screen.blit(t, (10, 10));
+
+        if self.finished:
+            f=FONT_SNAKE
+            t=f.render(MSG_SNAKE+str(self.score), True, (0, 0, 0))
+            screen.blit(t, (10, 270))
+            return
+
+    def interact(self):
+        # snek collision
+        i = len(self.xs)-1
+        while i >= 2:
+            if collide(self.xs[0], self.xs[i], self.ys[0], self.ys[i], 20, 20, 20, 20):
+                self.finish()
+                return
+
+            i-= 1
+
+        # Apple collision
+        if collide(self.xs[0], self.applepos[0], self.ys[0], self.applepos[1], 20, 10, 20, 10):
+            self.score+=1
+            for i in range(0, SNAKE_ADDSIZE):
+                self.xs.append(700)
+                self.ys.append(700)
+            self.applepos=(random.randint(0,WINSIZEX),random.randint(0,WINSIZEY))
+
+        if self.xs[0] < 0 or self.xs[0] > WINSIZEX or self.ys[0] < 0 or self.ys[0] > WINSIZEY: 
+            self.finish()
+            return
+
+        self.xs[1:] = self.xs[:-1]
+        self.ys[1:] = self.ys[:-1]
+
+        if self.dirs==0:self.ys[0] += 20
+        elif self.dirs==1:self.xs[0] += 20
+        elif self.dirs==2:self.ys[0] -= 20
+        elif self.dirs==3:self.xs[0] -= 20
+
+        print("drawing snake...")
+        if(self.score > SNAKE_SCORE):
+            signalWin(4)
+            self.finish()
+            return
+
 pygame.init()
+pygame.mixer.init()
 
-#gameplay
+from gameplayconfig import *
-#wynik w snake, ktory wygrywa
-SNAKE_SCORE = 2
-#predkosc gry w snake - w zakresie od 1 do 10 
-TICK_SNAKE = 10
-#ilosc segmentow dodanych do snake po zlapaniu jablka
-SNAKE_ADDSIZE = 10
-
-#hasla klawiatury ekranowej dla obu zagadek
-password1 = 'one'
-password2 = 'two'
 
 #ilosc powtorzen mp3
 MP3_LOOPS = 4
@@ -118,18 +246,16 @@ GPIO.setup(PIN_SUC10, GPIO.OUT)
 GPIO.setup(PIN_RELAY, GPIO.OUT)
 GPIO.output(PIN_SUC9, 1)
 GPIO.output(PIN_SUC10, 1)
-GPIO.output(PIN_RELAY, 1)    
+
+# Well, we flipped it...
+GPIO.output(PIN_RELAY, 0)
 
 WINSIZEX, WINSIZEY = 900, 680
-counter = 0
 timeSec = 0
 UP = 1
 DOWN = 3
 RIGHT = 2
 LEFT = 4
-lastJoyState = RIGHT
-score = 0
-dynamoValSPI = [0,0,0]
 
 #numery slajdow
 SLIDE_START = 0
@@ -141,21 +267,131 @@ SLIDE_DYNAMO = 5
 SLIDE_KEYPAD = 6
 SLIDE_MAZE = 7
 SLIDE_MP3 = 8
-SLIDE_KEYBOARD = 9
+SLIDE_KEYBOARD = 11
-SLIDE_CONGRATS = 11
+SLIDE_CONGRATS = 9
+SLIDE_CONGRATS_EVERYTHING = 12
 
 SLIDE_SNAKE_DEAD = 10 #to nie slajd, tylko wartosc potrzebna do resetowania snake po przegranej
 
 global slide
 #slajd poczatkowy
 slide = SLIDE_START
-slides = [SLIDE_START,SLIDE_KEY,SLIDE_POT,SLIDE_FOAMBTN,SLIDE_SNAKE,SLIDE_KEYPAD,SLIDE_MAZE,SLIDE_MP3,SLIDE_KEYBOARD,SLIDE_CONGRATS]
+slides = {
+    SLIDE_START: ImageSlide(IMG_HELLO),
+    SLIDE_KEY: ImageSlide(IMG_KEY),
+    SLIDE_POT: ImageSlide(IMG_POT),
+    SLIDE_FOAMBTN: ImageSlide(IMG_FOAMBTN),
+    SLIDE_DYNAMO: ImageSlide(IMG_DYNAMO),
+    SLIDE_KEYPAD: ImageSlide(IMG_KEYPAD),
+    SLIDE_MAZE: ImageSlide(IMG_MAZE),
+    SLIDE_MP3: ImageSlide(IMG_MP3),
+    SLIDE_CONGRATS: FinalSlide(IMG_WIN),
+    SLIDE_CONGRATS_EVERYTHING: FinalEverythingSlide(IMG_WIN),
+    SLIDE_SNAKE: SnakeSlide(),
+    }
+
+def go_to_slide(new_slide):
+    global slide
+
+    if new_slide == slide:
+        logging.warning('Same slide...')
+        return False
+
+    if slides.get(slide) and not slides[slide].exit(slides.get(new_slide)):
+        logging.warning('exit rejected')
+        return False
+
+    if slides.get(new_slide) and not slides[new_slide].enter(slides.get(slide)):
+        logging.warning('enter rejected')
+        return False
+
+    slide = new_slide
+    return True
+
+class SerialThread(threading.Thread):
+    def run(self):
+        self.logger = logging.getLogger(self.__class__.__name__)
+
+        for line in self.serial:
+            try:
+                self.handle(line)
+            except:
+                self.logger.exception('Oops...')
+
+    def handle(self, line):
+        print('Arduino said:', line)
+
+        command, _, args = line.partition(':')
+
+        if command == 'SLIDE':
+            global slide
+            go_to_slide(int(args))
+            print('Setting slide to: ', slide)
+
+class BroadcastThread(threading.Thread):
+    def run(self):
+        cs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        cs.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        cs.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        while True:
+            global slide
+
+            print('sending')
+            cs.sendto(json.dumps({
+                'slide': slide,
+                'name': socket.gethostname(),
+                }), ('255.255.255.255', 54545))
+            time.sleep(1)
+
+class ReceiveThread(threading.Thread):
+    states = None
+
+    def run(self):
+        self.states = {}
+
+        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.bind(('',54545))
+        while True:
+            try:
+                msg, (host, port) = s.recvfrom(1024)
+                self.states[host] = json.loads(msg)
+
+                if all(s['slide'] in [SLIDE_CONGRATS, SLIDE_CONGRATS_EVERYTHING]
+                       for s in self.states.values()):
+                    go_to_slide(SLIDE_CONGRATS_EVERYTHING)
+            except:
+                logging.exception('Receiver failed')
+                time.sleep(0.5)
+
+ser = None
+
+for c in ['/dev/ttyUSB0', '/dev/ttyACM0']:
+    try:
+        ser = serial.Serial(c, 115200)
+    except:
+        continue
+
+    print('Using ', c)
+    webapp.init(ser)
+    th = SerialThread()
+    th.serial = ser
+    th.daemon = True
+    th.start()
+
+    bth = BroadcastThread()
+    bth.daemon = True
+    bth.start()
+
+    rth = ReceiveThread()
+    rth.daemon = True
+    rth.start()
+
+    webapp.app.rth = rth
 
 
 def win():
     print "GAME OVER - YOU WIN"
-    GPIO.output(PIN_RELAY, 0)    
+    GPIO.output(PIN_RELAY, 1)
-    
 
 def signalWin(success):
     pin = 0
@@ -177,108 +413,38 @@ def signalWin(success):
 def waitForEvents():
     global slide
     print("waiting for events")
-    while 1:
+    while checkEvents():
-        time.sleep(0.01)
+        clock.tick(30)
-        if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
+
-                print "Ardu said go to key slide"
+def checkEvents(handler=None):
-                slide = SLIDE_KEY
+    global slide
-                return
+
-        if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-                print "Ardu said go to pot slide"
-                slide = SLIDE_POT
-                return
-        if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-                print "Ardu said go to foam button slide"
-                slide = SLIDE_FOAMBTN
-                return
-        if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-                print "Ardu said go to dynamo slide"
-                slide = SLIDE_DYNAMO
-                return
-        if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-                print "Ardu said go to keypad slide"
-                slide = SLIDE_KEYPAD
-                return
-        if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-                print "Ardu said win"
-                slide = SLIDE_CONGRATS
-                return
     if GPIO.input(PIN_BTNY) == 0 and slide != SLIDE_MAZE:
         print "yellow button pressed - go to maze slide"
-            slide = SLIDE_MAZE
+        go_to_slide(SLIDE_MAZE)
         return
+
     if GPIO.input(PIN_BTNG) == 0 and slide != SLIDE_MP3:
         print "green button pressed - go to mp3 slide"
-            slide = SLIDE_MP3
+        go_to_slide(SLIDE_MP3)
         return
+
     for event in pygame.event.get():
         if event.type == pygame.MOUSEBUTTONDOWN:
-                slide = SLIDE_KEYBOARD
+            go_to_slide(SLIDE_KEYBOARD)
             print("mouse event")
             return
 
         elif event.type == pygame.KEYDOWN:
             if slide != SLIDE_SNAKE:
-                    slide = SLIDE_SNAKE
+                go_to_slide(SLIDE_SNAKE)
-                else:
-                    slide = SLIDE_SNAKE_DEAD
                 print("keydown event")
                 return
 
+        if handler:
+            handler(event)
 
-def checkEvents():
+    return True
-    global slide
-    if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
-            print "Ardu said go to key slide"
-            slide = SLIDE_KEY
-            return
-    if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-            print "Ardu said go to pot slide"
-            slide = SLIDE_POT
-            return
-    if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-            print "Ardu said go to foam button slide"
-            slide = SLIDE_FOAMBTN
-            return
-    if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-            print "Ardu said go to dynamo slide"
-            slide = SLIDE_DYNAMO
-            return
-    if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-            print "Ardu said go to keypad slide"
-            slide = SLIDE_KEYPAD
-            return
-    if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-            print "Ardu said win"
-            slide = SLIDE_KEYPAD
-            return
-    if GPIO.input(PIN_BTNY) == 0 and slide != SLIDE_MAZE:
-        print "yellow button pressed - go to maze slide"
-        slide = SLIDE_MAZE
-        return
-    if GPIO.input(PIN_BTNG) == 0 and slide != SLIDE_MP3: 
-        print "green button pressed - go to mp3 slide"
-        slide = SLIDE_MP3
-        return
-    for event in pygame.event.get():
-            if event.type == pygame.MOUSEBUTTONDOWN and slide != SLIDE_KEYBOARD:
-                slide = SLIDE_KEYBOARD
-                print("mouse event")
-                return 1
-            
-            elif event.type == pygame.KEYDOWN:
-                slide = SLIDE_SNAKE
-                print("keydown event")
-                return
-            else: return 0
-
-def drawSlide(n):
-    print("drawing slide:")
-    print(n)
-    screen.fill(WHITE)
-    screen.blit(slides[n], (0, 0))
-    pygame.display.flip()
-    waitForEvents()
 
 def collide(x1, x2, y1, y2, w1, w2, h1, h2):
     if x1+w1>x2 and x1<x2+w2 and y1+h1>y2 and y1<y2+h2:return True
@@ -292,16 +458,8 @@ def die(screen, score):
     screen.blit(t, (10, 270))
     pygame.display.update()
     pygame.time.wait(2000)
-    waitForEvents()
 
-def main():
+############# old main
-    global slide
-    
-    startonce = 0
-    showstartscreen = 0
-    
-    while startonce == 0:
-        startonce = 0
 ######## CONSTANTS
 WINSIZE = [WINSIZEX,WINSIZEY]
 BLOCKSIZE = [18,18]
@@ -317,206 +475,35 @@ def main():
 MAXY = WINSIZEY - MINY
 
 
-        SNAKESTEP = 20
-        TRUE = 1
-        FALSE = 0
-        
-
 ######## VARIABLES
-        direction = RIGHT # 1=up,2=right,3=down50,4=left
-        snakexy = [300,400]
-        snakelist = [[300,400],[280,400],[260,400]]
-        counter = 0
-        score = 0
-        appleonscreen = 0
-        applexy = [0,0]
-        newdirection = RIGHT
-        snakedead = FALSE
-        gameregulator = 6
-        gamepaused = 0
-        growsnake = 0  # added to grow tail by two each time 
-        snakegrowunit = 2 # added to grow tail by two each time
 clock = pygame.time.Clock()
-        screen = pygame.display.set_mode(WINSIZE)#FULLSCREEN)
+screen = pygame.display.set_mode(WINSIZE, pygame.NOFRAME)
-        #screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
 pygame.display.set_caption('PozySejf')
-        pygame.FULLSCREEN
-        #screen = display.set_mode([1024,768], FULLSCREEN)
-        #screen.fill(BLACK)
-        dynamoValSPI = [0,0,0]
-        dynamoRectY = [50, 50, 50]
-        dynamoRectX = 50
-        dynamoXpos = [-100, 0, 100]
-        distanceDynamoRect = 300
-        textInputDotNumber = 0
-        pushButtonNumber = 100
 
-        valueSound = 100
+############# old main
+
+
+def main():
+    global slide
     
     passwordLetter = ''
+
+    startonce = 0
+    
+    while startonce == 0:
+        startonce = 0
         #### show initial start screen
         ### every while loop for each slide
-        while slide == SLIDE_START:
+
-            print("showing slide 0")
+        if slide in slides:
-            screen.fill(WHITE)
+            slides[slide].render(screen)
-            screen.blit(IMG_HELLO, (0, 0))
+            checkEvents(slides[slide].handle)
             pygame.display.flip()
-            pygame.time.wait(5000)
+            clock.tick(15)
-            waitForEvents()
-            break
-            
-        while slide == SLIDE_KEY:
-            print("showing slide 1 - key")
-            screen.fill(WHITE)
-            screen.blit(IMG_KEY, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-           
-        while slide == SLIDE_POT:
-            print("showing slide 2 - pot")
-            screen.fill(WHITE)
-            screen.blit(IMG_POT, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_FOAMBTN:
-            print("showing slide 3 - foam button")
-            screen.fill(WHITE)
-            screen.blit(IMG_FOAMBTN, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_SNAKE: ## snake
-            print("snake is starting...")
-            
-            xs = [290, 290, 290, 290, 290];
-            ys = [290, 270, 250, 230, 210];
-            dirs = 0
-            score = 0
-            applepos = (random.randint(0, WINSIZEX), random.randint(0, WINSIZEY))
-            pygame.init()
-            #s=pygame.display.set_mode((600, 600))
-            appleimage = IMG_APPLE
-            img = IMG_SNAKEBODY#pygame.Surface((20, 20))
-            #img.fill((255, 0, 0))
-            f = FONT_SNAKE
-            clock = pygame.time.Clock()
-            while slide == SLIDE_SNAKE:
-                    clock.tick(TICK_SNAKE)
-                    if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
-                            print "Ardu said go to key slide"
-                            slide = SLIDE_KEY
-                            break
-                    if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-                            print "Ardu said go to pot slide"
-                            slide = SLIDE_POT
-                            break
-                    if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-                            print "Ardu said go to foam button slide"
-                            slide = SLIDE_FOAMBTN
-                            break
-                    if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-                            print "Ardu said go to dynamo slide"
-                            slide = SLIDE_DYNAMO
-                            break
-                    if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-                            print "Ardu said go to keypad slide"
-                            slide = SLIDE_KEYPAD
-                            break
-                    if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-                            print "Ardu said win"
-                            slide = SLIDE_KEYPAD
-                            break
-                    if GPIO.input(PIN_BTNY) == 0:
-                        print "yellow button pressed - go to maze slide"
-                        slide = SLIDE_MAZE
-                        break
-                    if GPIO.input(PIN_BTNG) == 0: 
-                        print "green button pressed - go to mp3 slide"
-                        slide = SLIDE_MP3
-                        break
-                    for e in pygame.event.get():
-                            #if e.type == QUIT:
-                            #   sys.exit(0) #quit - nie chcemy miec mozliwosci wyjscia z aplikacji
-                            if e.type == KEYDOWN:
-                                    if e.key == K_UP and dirs != 0:dirs = 2
-                                    elif e.key == K_DOWN and dirs != 2:dirs = 0
-                                    elif e.key == K_LEFT and dirs != 1:dirs = 3
-                                    elif e.key == K_RIGHT and dirs != 3:dirs = 1
-                            elif e.type == pygame.MOUSEBUTTONDOWN:
-                                slide = SLIDE_KEYBOARD
-                                print("mouse event")
-                                break
-                    i = len(xs)-1
-                    while i >= 2:
-                            if collide(xs[0], xs[i], ys[0], ys[i], 20, 20, 20, 20):
-                                die(screen, score)
-                                score = 0
-                                break
-                            i-= 1
-                    if collide(xs[0], applepos[0], ys[0], applepos[1], 20, 10, 20, 10):
-                        score+=1
-                        for i in range(0, SNAKE_ADDSIZE):
-                            xs.append(700)
-                            ys.append(700)
-                        applepos=(random.randint(0,WINSIZEX),random.randint(0,WINSIZEY))
-                    if xs[0] < 0 or xs[0] > WINSIZEX or ys[0] < 0 or ys[0] > WINSIZEY: 
-                        die(screen, score)
-                        score = 0
-                        break 
-                    i = len(xs)-1
-                    while i >= 1:
-                            xs[i] = xs[i-1];ys[i] = ys[i-1];i -= 1
-                    if dirs==0:ys[0] += 20
-                    elif dirs==1:xs[0] += 20
-                    elif dirs==2:ys[0] -= 20
-                    elif dirs==3:xs[0] -= 20    
-                    #rysuj tlo
-                    screen.fill(WHITE)
-                    screen.blit(IMG_SNAKE, (0, 0))  
-                    print("drawing snake...")
-                    if(score > SNAKE_SCORE):
-                        die(screen, score)
-                        break
-                    for i in range(0, len(xs)):
-                            screen.blit(img, (xs[i], ys[i]))
-                    screen.blit(appleimage, applepos);t=f.render(str(score), True, (0, 0, 0));screen.blit(t, (10, 10));pygame.display.update()
 
         while slide == SLIDE_SNAKE_DEAD:
             print("resetting snake.")
             slide = SLIDE_SNAKE
-        while slide == SLIDE_DYNAMO:
-            print("showing slide 5 - dynamo")
-            screen.fill(WHITE)
-            screen.blit(IMG_DYNAMO, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break            
-        while slide == SLIDE_KEYPAD:
-            print("showing slide 6 - drawer keypad")
-            screen.fill(WHITE)
-            screen.blit(IMG_KEYPAD, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        while slide == SLIDE_MAZE:
-            print("showing slide 7 - maze")
-            screen.fill(WHITE)
-            screen.blit(IMG_MAZE, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_MP3:
-            print("showing slide 8 - mp3 player")
-            screen.fill(WHITE)
-            screen.blit(IMG_MP3, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break   
 
         while slide == SLIDE_KEYBOARD: ## keyboard
             #print("checking events")
@@ -568,11 +555,11 @@ def main():
                     # Set the x, y postions of the mouse click
                     x, y = event.pos
                     if enterButton.collidepoint(x, y):
-                        if passwordLetter == password1:
+                        if passwordLetter == PASSWORD1:
                             print 'password correct for task 9.'
                             signalWin(9)
 
-                        if passwordLetter == password2:
+                        if passwordLetter == PASSWORD2:
                             print 'password correct for task 10.'
                             signalWin(10)
 
@@ -587,23 +574,6 @@ def main():
 
             pygame.display.flip()
 
-        while slide == SLIDE_CONGRATS: ## congratulation
-            print("showing slide 10 - win")
-            screen.fill(WHITE)
-            screen.blit(IMG_WIN, (0, 0))          
-            pygame.display.flip()
-            if(wall_a):
-                win()
-                pygame.mixer.init()
-                pygame.mixer.music.load("media/win.mp3")
-                pygame.mixer.music.play(MP3_LOOPS)
-                pygame.mixer.music.set_volume(1.0)
-                while pygame.mixer.music.get_busy() == True:
-                    continue
-                while 1:
-                    print "you win."
-            waitForEvents()
-            
 if __name__ == '__main__':
     main()
 

raspi/templates/index.html

@@ -2,18 +2,33 @@
 <body>
 
 <table>
+<ul>
+{% for k, v in states %}
+    <li>
+        {% if v['name'] == hostname %}<b>{% endif %}
+        <a href="http://{{ k }}:5000">{{ v['name'] }}</a> ({{ v['slide'] }})
+        {% if v['name'] == hostname %}</b>{% endif %}
+    </li>
+{% endfor %}
+</ul>
+
 <tr>
 <th>Włącz</th>
 {% for n in range(10) %}
 <td><a href="/set/{{ n }}">{{ n + 1 }}</a></td>
 {% endfor %}
+
+<td><a href="/set/all">Wszystko</a></td>
 </tr>
 <tr>
 <th>Wyłącz</th>
 {% for n in range(10) %}
 <td><a href="/clear/{{ n }}">{{ n + 1 }}</a></td>
 {% endfor %}
+<td><a href="/clear/all">Wszystko</a></td>
 </tr>
 </table>
+
+<a href="/restart" style="color: red">RESTART</a>
 </body>
 </html>

raspi/webapp.py

@@ -1,6 +1,8 @@
 import flask
 import string
+import time
 import threading
+import socket
 
 app = flask.Flask(__name__)
 
@@ -14,9 +16,41 @@ def clear_task(task):
     app.port.write(string.lowercase[task])
     return flask.redirect('/')
 
+@app.route('/set/all')
+def set_all():
+    app.port.write(string.uppercase)
+    return flask.redirect('/')
+
+@app.route('/clear/all')
+def clear_all():
+    app.port.write(string.lowercase)
+    return flask.redirect('/')
+
+@app.route('/restart')
+def restart():
+    import thread
+    thread.interrupt_main()
+    return flask.redirect('/') # xD
+
 @app.route('/')
 def index():
-    return flask.render_template('index.html')
+    states = app.rth.states.items()
+    states.sort(key=lambda (k, v): v['name'])
+
+    return flask.render_template(
+        'index.html', hostname=socket.gethostname(), states=states)
+
+@app.route('/arduino/reset')
+def reset():
+    app.port.dtr = False
+    time.sleep(0.5)
+    app.port.dtr = True
+    time.sleep(0.5)
+    app.port.dtr = False
+    time.sleep(0.5)
+    app.port.dtr = True
+    return flask.redirect('/')
+
 
 def init(ser):
     app.port = ser