The Giant Chessclock

#!/usr/bin/python
# License: GNU GPL Version 3 (https://www.gnu.org/licenses/gpl-3.0.html)
# The Giant Chess Clock - g-c-c (please don't confuse with the GNU C compiler gcc!)
# Author: Thomas Klaube (thomas@klaube.net)
# 
# Used libraries:
# Raspberry Pi PWM library fro WS281X from Jeremy Garff https://github.com/jgarff/rpi_ws281x
# pigpio from http://abyz.me.uk/rpi/pigpio/ - best gpio library for RasPi on this planet! 
# twisted from https://twistedmatrix.com/trac/
# plus some "standard" python libraries/modules (time, os, datetime)
# test on a RPI 2B running with raspbian. Don't forget to install and setup pigpiod!
#
import time
import pigpio
import os

from datetime import datetime
from neopixel import *
from twisted.internet import task
from twisted.internet import reactor

#GPIO Pins used for the adjustment/start/reset Buttons
INCREMENT=23
MINUTES=24
START=25
RESET=21

#GPIO Pins used for the big Push-Buttons - we call them "Green" and "Red" Button
BUTTONGREEN=17
BUTTONRED=27

#accordingly we have a "Red" Display and a "Green" Display. Display and Button of the same color are on the same side of the clock!
DisplayRed=1           # The "RED" Display has Index 1   (left side)
DisplayGreen=0         # The "GREEN" Display has Index 0 (right side)

#this is implemented as a deterministic finite state machine (more or less)
StartState = 1 # loop Minutes
CurrentState = 0 # no current State
FormerState = 0 # no former State

# States:
# 1: loop Minute/Time modes
# 2: loop Increment modes
# 3: Prestart (Start is pressed, but time is not running on any clock)
# 4: Run Red (Green Button was pressed, Green clock is paused, Red clock is running)
# 5: Run Green (Red Button was pressed, Red clock is paused, Green clock is running)
# 6: Pause Red (Start/Pause was pressed, while Red Clock was running)
# 7: Pause Green (Start/Pause was pressed, while Green Clock was running)
# 8: reboot
# 9: Shutdown

# Actions:
ActionMinutes=1             # Minutes is pressed
ActionIncrement=2           # Increment is pressed
ActionReset=3               # Reset is pressed (short < 3 sec)
ActionStartPause=4          # Start/Pause is pressed
ActionGreenButtonPressed=5  # Green Button is pressed
ActionRedButtonPressed=6    # Red Button is pressed
ActionLongReset=7           # Reset is pressed long > 5 sec, this will always reboot, no matter which state
ActionVeryLongReset=8       # Reset is pressed very long > 10 sec, this will always shutdown no matter which state

# State Transistions are handled through this "Matrix". The Lines represent the States, the
# Colums represent the Actions. E.g.: assume we are in state "3" (Prestart) and Action 5 is
# triggered (Green Button pressed) => State will switch to 4 (Stop Green, Run Red). Does this
# make sense?

StateTable = [[1,2,1,3,1,1,8,9],
              [1,2,1,3,2,2,8,9],
              [3,3,1,3,4,5,8,9],
              [4,4,1,6,4,5,8,9],
              [5,5,1,7,4,5,8,9],
              [6,6,1,4,6,6,8,9],
              [7,7,1,5,7,7,8,9],
              [8,8,8,8,8,8,8,8],
              [9,9,9,9,9,9,9,9]]


MinuteModes = [1,3,5,10,15,20,25,30,45,60]  # numbers are in minutes
IncrementModes = [0,1,2,3,4,5,10,15,30,60]    # numbers are in seconds

MinuteIndex = 0
IncrementIndex = 0             
MinuteMode=MinuteModes[MinuteIndex]          # 1 minute Game is setup on Program startup. This will be "pushed" to 3 Min when DFA is initialized. So 3 Min game is the default
IncrementMode=IncrementModes[IncrementIndex] # 0 seconds increment is the default

Game_Running = False           # Will be set to True as soon as the Red or Green Button was pressed while in "Prestart" state -> One Clock starts "Count-Down"
Start_Time = 0

Ignore_Button_Events = True    # It takes some ms until all gpio pins are initialized. All "ghost"-events must be ignored for this time

# next few fuctions will define what to do, when one of the buttons is pressed (minutes, increment, start, reset, red, green)
# For all Buttons: level == 0 => falling edge (press button), level == 1 => rising edge (release button)
def call_reset(gpio, level, tick):
   global resetTicks 
   global CurrentState
   if not(Ignore_Button_Events):
     if level == 0:
		#button press - we will only act on reset release as we must keep short, long and verylong press apart
                resetTicks = tick
     elif level == 1:
		#button release
                diff = pigpio.tickDiff(resetTicks, tick)
                if diff < 5000000:
			#Switch pressed under 5 seconds
                        doAction(CurrentState,ActionReset)   # doAction will put the DFA into a new state
                elif diff >= 5000000 and diff < 10000000:
                        #Switch pressed over 5 but under 10 second -> Action 9 == LongReset
                        doAction(CurrentState,ActionLongReset)
                elif diff >= 10000000 :
                        #Switch pressed over 10 second -> Action 10 == VeryLongReset
                        doAction(CurrentState,ActionVeryLongReset)

def call_start(gpio, level, tick):
     if not(Ignore_Button_Events):
       if level == 0:    # for all other buttons we will only act on "press" not "release"
         print ("Start was pressed")
         doAction(CurrentState,ActionStartPause)

def call_minutes(gpio, level, tick):
     if not(Ignore_Button_Events):
       if level == 0:
         print ("Minutes was pressed")
         doAction(CurrentState,ActionMinutes)

def call_increment(gpio, level, tick):
     if not(Ignore_Button_Events):
       if level == 0:
         print ("Increment was pressed")
         doAction(CurrentState,ActionIncrement)

def call_button_green(gpio, level, tick):
     if not(Ignore_Button_Events):
       if level == 0:
         print ("The green Button was pressed")
         doAction(CurrentState,ActionGreenButtonPressed)

def call_button_red(gpio, level, tick):
     if not(Ignore_Button_Events):
      if level == 0:
         print ("The red Button was pressed")
         doAction(CurrentState,ActionRedButtonPressed)
 
pi = pigpio.pi() # Connect to local Pi.

resetTicks = pi.get_current_tick() #initializing var

for i in [INCREMENT,MINUTES,START,RESET,BUTTONGREEN,BUTTONRED]:
   pi.set_pull_up_down(i, pigpio.PUD_UP)    # We use the RasPI built-in Pull-Up/Down resistors...
   pi.set_mode(i, pigpio.INPUT)             # all buttons are inputs...
   pi.set_glitch_filter(i, 100000)          # glitch filter of 0.1 sec. This will ignore every input level change (low-high-low or high-low-high) that is
                                            # happening faster than within 0.1 sec. This way of "debouncing" is so much more powerful than RPi.GPIOs "bouncetime" !
                                            # If you ever had problems detecting the state of your push buttons in your RasPI Projects, try using pigpio!!!

pi.callback(INCREMENT, pigpio.EITHER_EDGE, call_increment)       # now we define the callback functions for the various button events
pi.callback(MINUTES, pigpio.EITHER_EDGE, call_minutes)
pi.callback(START, pigpio.EITHER_EDGE, call_start)
pi.callback(RESET, pigpio.EITHER_EDGE, call_reset)
pi.callback(BUTTONGREEN, pigpio.EITHER_EDGE, call_button_green)
pi.callback(BUTTONRED, pigpio.EITHER_EDGE, call_button_red)

# now comes the LED strip configuration:
LED_COUNT      = 172      # Number of LED pixels.
LED_PIN        = 18      # GPIO pin connected to the pixels (must support PWM!).
LED_FREQ_HZ    = 800000  # LED signal frequency in hertz (usually 800khz)
LED_DMA        = 10      # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 255     # Set to 0 for darkest and 255 for brightest
LED_INVERT     = False   # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL    = 0
LED_STRIP      = ws.SK6812_STRIP_RGBW

DotsOn = [False,False]     # Dots are off in both clocks
DotsToggle = [False,False] # Dots will not start blinking with Toggle == False

ShowSymbols = [False,False]    # If Symbols insted of the Time must be displayed, these Symbols must be placed into this var

TimeRed = 0   # Time to be shown on the "RED" Display
TimeGreen = 0 # Time to be shown on the "GREEN" Display

DisplayColor = [[0,0,0,255],[0,0,0,255]] # color to be used in Green and Red Display

# Every 7-Segment display is housing 21 SK6812 "pixels" (3 per segment). The "Digits" matrix
# defines which pixels must be lit up to show the digits 0-9
Digits = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1],        # digit "0"
          [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],        # digit "1"
          [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],        # ...
          [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
          [1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1],
          [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1],
          [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1],
          [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
          [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
          [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]        # digit "9"

# And there are a number of Symbols.... 
Symbols = {"-": [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
           "C": [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
           "E": [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1],
           "G": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1],
           "H": [1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1],
           "S": [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1]}

NumberBases = [0,21,44,65,86,107,130,151]  # defines at which Pixel the 7-Segments Displays "start" - e.g. 4th Display starts at Pixel 65...
DotsBases = [42,128] # Theses are the startpixel for the Dots that separate Minutes from Seconds

def ShowDots():
    global DotsOn
    global DotsToggle
    global DotsBases
    for i in range(0,2):
       strip.setPixelColor(DotsBases[i], Color(DisplayColor[i][0]*int(DotsOn[i]), DisplayColor[i][1]*int(DotsOn[i]), DisplayColor[i][2]*int(DotsOn[i]), DisplayColor[i][3]*int(DotsOn[i])))
       strip.setPixelColor(DotsBases[i]+1, Color(DisplayColor[i][0]*int(DotsOn[i]), DisplayColor[i][1]*int(DotsOn[i]), DisplayColor[i][2]*int(DotsOn[i]), DisplayColor[i][3]*int(DotsOn[i])))
       if DotsToggle[i]:
          DotsOn[i] = not(DotsOn[i])
    strip.show()

def displayDigit(On, Number):
     for i in range(len(Digits[Number])):
         strip.setPixelColor(NumberBases[On]+i, Color(DisplayColor[On//4][0]*Digits[Number][i], DisplayColor[On//4][1]*Digits[Number][i], DisplayColor[On//4][2]*Digits[Number][i], DisplayColor[On//4][3]*Digits[Number][i]))
     strip.show()

def displayChar(On, Sym):
     for i in range(len(Symbols[Sym])):
         strip.setPixelColor(NumberBases[On]+i, Color(DisplayColor[On//4][0]*Symbols[Sym][i], DisplayColor[On//4][1]*Symbols[Sym][i], DisplayColor[On//4][2]*Symbols[Sym][i], DisplayColor[On//4][3]*Symbols[Sym][i]))
     strip.show()

def displaySymbol(Display,String):
     d3 = list(String)[3]
     d2 = list(String)[2]
     d1 = list(String)[1]
     d0 = list(String)[0]

     displayChar(Display*4+3,d3)
     displayChar(Display*4+2,d2)
     displayChar(Display*4+1,d1)
     displayChar(Display*4+0,d0)

def displayNumber(Display,Time):
     Number = int(Time)
     d3 = Number//600
     d2 = Number//60 - 10*d3
     d1 = (Number - (10*d3+d2)*60)//10
     d0 = Number%10
     
     displayDigit(Display*4+3,d3)
     displayDigit(Display*4+2,d2)
     displayDigit(Display*4+1,d1)
     displayDigit(Display*4+0,d0)

def ShowClocks():
    if ShowSymbols[DisplayRed]:
       displaySymbol(DisplayRed,ShowSymbols[DisplayRed])
    else: 
       displayNumber(DisplayRed,TimeRed)
    if ShowSymbols[DisplayGreen]:
       displaySymbol(DisplayGreen,ShowSymbols[DisplayGreen])
    else: 
       displayNumber(DisplayGreen,TimeGreen)
    # print ("R G N", TimeRed, TimeGreen, datetime.now())

def DecrementClocks(): # This function is called once every 100ms and will dec the Red or the Green Clock by 100 ms
    global TimeRed
    global TimeGreen
    global DisplayColor
    global DotsOn
    global DotsToggle
    global ShowSymbols
    if Game_Running:
       print ("Game Running")
       if CurrentState == 4:                                           # Stop Green, Run Red
          TimeRed -= 0.1                                               # decrement by 100ms
          if TimeRed < 0.1*(MinuteMode * 60 + 40 * IncrementMode):     # less then 10% of time is left on the clock
             DisplayColor[DisplayRed] = [0,255,0,0]                    # Clock will turn red
          else:
             DisplayColor[DisplayRed] = [0,0,0,255]                    # default color is white
          if TimeRed <= 0:                                              # Time is up for red...
             ShowSymbols[DisplayRed] = '----'                          # show the hyphen
             DotsOn[DisplayRed] = True
             DotsToggle[DisplayRed] = True
       elif CurrentState == 5:                                         # Stop Red, Run Green
          TimeGreen -= 0.1                                             # decrement by 100ms
          if TimeGreen < 0.1*(MinuteMode * 60 + 40 * IncrementMode):   # less then 10% of time is left on the clock
             DisplayColor[DisplayGreen] = [0,255,0,0]                  # Clock will turn red
          else:
             DisplayColor[DisplayGreen] = [0,0,0,255]                  # default color is white
          if TimeGreen <= 0:                                            # Time is up for green...
             ShowSymbols[DisplayGreen] = '----'                        # show the hyphen
             DotsOn[DisplayGreen] = True
             DotsToggle[DisplayGreen] = True 

def ActionLoopMinutes(): # State 1
    global ShowSymbols
    global MinuteIndex
    global MinuteMode
    global DotsOn
    global DotsToggle
    global TimeRed
    global TimeGreen
    global DisplayColor
    print ("Old: ", MinuteMode)
    ShowSymbols=[False,False]           # Show no Symbols but Numbers - back to default
    DisplayColor = [[0,0,0,255],[0,0,0,255]]  # reset DisplayColors to default values
    if FormerState == CurrentState:     # show current mode if State is entered
      MinuteIndex += 1                  # start looping on repetitive Button press
    MinuteIndex = MinuteIndex % len(MinuteModes)
    MinuteMode = MinuteModes[MinuteIndex]
    print ("F C I M: ", FormerState, CurrentState, MinuteIndex, MinuteMode)
    TimeRed = MinuteMode * 60
    TimeGreen = IncrementMode
    DotsOn[DisplayGreen]=False
    DotsToggle[DisplayGreen]=False
    DotsOn[DisplayRed]=True
    DotsToggle[DisplayRed]=True   # Turn on Display Red and start blinking

def ActionLoopIncrement(): # State 2
    global IncrementIndex
    global IncrementMode
    global DotsOn
    global DotsToggle
    global TimeRed
    global TimeGreen
    print ("Old: ", IncrementMode)
    if FormerState == CurrentState:  # show current mode if State is entered
       IncrementIndex += 1           # start looping on repetitive Button press
    IncrementIndex = IncrementIndex % len(IncrementModes)
    IncrementMode = IncrementModes[IncrementIndex]
    print ("F C I I: ", FormerState, CurrentState, IncrementIndex, IncrementMode)
    TimeGreen = IncrementMode
    TimeRed = MinuteMode * 60
    DotsOn[DisplayGreen]=True
    DotsToggle[DisplayGreen]=True
    DotsOn[DisplayRed]=False
    DotsToggle[DisplayRed]=False

def ActionPrestart(): # State 3
    global TimeRed
    global TimeGreen
    global DotsOn
    global DotsToggle
    if FormerState == CurrentState: # just exit on same state
       return
    print ("F C M: ", FormerState, CurrentState, MinuteMode)
    TimeRed = MinuteMode * 60
    TimeGreen = MinuteMode * 60
    DotsOn[DisplayGreen]=True
    DotsToggle[DisplayGreen]=True
    DotsOn[DisplayRed]=True
    DotsToggle[DisplayRed]=True

def ActionStopGreenRunRed(): # State 4
    global TimeRed
    global DotsOn
    global DotsToggle
    global Start_Time
    global Game_Running
    print ("F C R", FormerState, CurrentState, Game_Running)
    if FormerState == 3: 
       # The game is started (we would not be here or in this state if not...)
       Game_Running = True
       Start_Time = time.time()
    if ( (FormerState != CurrentState) and (TimeRed > 0) ) :
       TimeRed += IncrementMode                                   # Red Player gets the increment for this move, but not if timeout occured before...
    if FormerState == 6:
       TimeRed -= IncrementMode  # No Increment after Pause
       Game_Running = True
    if TimeRed >= 0.1*(MinuteMode * 60 + 40 * IncrementMode):     # more than 10% of the time left 
       DisplayColor[DisplayRed] = [0,0,0,255]                     # Switch Color to White again
    DotsOn[DisplayGreen]=False
    DotsToggle[DisplayGreen]=False
    DotsOn[DisplayRed]=True
    DotsToggle[DisplayRed]=True
    print ("Stop Green, Run Red")

def ActionStopRedRunGreen(): # State 5
    global TimeGreen
    global DotsOn
    global DotsToggle
    global Start_Time
    global Game_Running
    if FormerState == 3:
       # The game is started (we would not be in here / this state if not...)
       Game_Running = True
       Start_Time = time.time()
    if ( (FormerState != CurrentState) and (TimeGreen > 0) ) :
       TimeGreen += IncrementMode                                   # Green Player gets the increment for this move, but not if timeout occured before...
    if FormerState == 7:
       TimeGreen -= IncrementMode  # No Increment after Pause
       Game_Running = True
    if TimeGreen >= 0.1*(MinuteMode * 60 + 40 * IncrementMode):     # more than 10% of the time left
       DisplayColor[DisplayGreen] = [0,0,0,255]                     # Switch Color to White again
    DotsOn[DisplayGreen]=True
    DotsToggle[DisplayGreen]=True
    DotsOn[DisplayRed]=False
    DotsToggle[DisplayRed]=False

    print ("Stop Red Run Green")

def ActionPauseGreen(): # State 6
    global Game_Running
    Game_Running = False

def ActionPauseRed(): # State 7
    global Game_Running
    Game_Running = False

def ActionReboot():   # State 8
    print("rebooting")
    os.system('sudo shutdown -r now')

def ActionShutdown(): # State 9 
    print("shutting down")
    os.system('sudo shutdown -h now')

FunctionSwitcher = {
        1: ActionLoopMinutes,
        2: ActionLoopIncrement,
        3: ActionPrestart,
        4: ActionStopGreenRunRed,
        5: ActionStopRedRunGreen,
        6: ActionPauseGreen,
        7: ActionPauseRed,
        8: ActionReboot,
        9: ActionShutdown,
}

def doAction(Current,Action):
    global StateTable
    global FormerState
    global CurrentState
    global FunctionSwitcher
    print ("Action " , Action, " Current State ", Current, "New State ", StateTable[Current-1][Action-1])
    if Action == 0: 
        return
    NewState = StateTable[Current-1][Action-1]
    func = FunctionSwitcher.get(NewState, lambda: "Invalid State")
    FormerState = CurrentState
    CurrentState = NewState
    func()
    return

# Main program logic follows:
if __name__ == '__main__':
        time.sleep(1)   # warten bis alle Taster inititalisiert sind
        print ("after sleep")
        Ignore_Button_Events = False  # ab jetzt sind die Taster funktionsfaehig
        # Create NeoPixel object with appropriate configuration.
        strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_STRIP)
        # Intialize the library (must be called once before other functions).
        strip.begin()

        CurrentState = StartState # Now we start with the first State
        doAction(CurrentState,ActionMinutes)   # Fakes a "Minutes" Button press

        dots = task.LoopingCall(ShowDots)
        dots.start(0.5) # call every 0.5 second
        # dots.stop() will stop the looping calls

        clock = task.LoopingCall(ShowClocks)
        clock.start(0.1) # call every  100ms

        decrement = task.LoopingCall(DecrementClocks)
        decrement.start(0.1) # call every  100ms
        
        reactor.run()