def __init__(self, period=500):
self.state = self.STATE_BUTTON_START
self.start_time = 0
self.period = period
self.click_state = self.STATE_CLICK_START
self.indicator = Indicator(PinSet(Sonoff.GREEN_LED))
self.relay = PinSet(Sonoff.RELAY)
self.smartconfig = SM(self.indicator)
self.iostate = False
def __init__(self, period=500):
self.state = self.STATE_BUTTON_START
self.start_time = 0
self.period = period
self.click_state = self.STATE_CLICK_START
self.indicator = Indicator(PinSet(Sonoff.GREEN_LED))
self.relay = PinSet(Sonoff.RELAY)
self.smartconfig = SM(self.indicator)
self.iostate = False
def __init__(self, db, adapter=0, encryption=False, random=None):
self.stack = BTStack(adapter=adapter)
self.att = ATT_Protocol(self.stack, GATT_Server(db), encryption)
self.sm = SM()
self.smp = SM_Protocol(self.stack, self.sm)
if random is not None:
self.stack.set_random_address(random)
self.sm.ra = ''.join(
map(lambda x: chr(int(x, 16)), random.split(':')))
self.sm.ra_type = 1
else:
self.sm.ra = self.stack.addr
self.sm.ra_type = 0
def __init__(self, boardName, board, parent = None):
QTcpServer.__init__(self, parent)
self.boardName = boardName
self.connections = []
SM.next = _smDebug(SM.next)
self.sm = SM(board)
self.sm.stateChanged.connect(self.sendStateChange)
self.sm.turnChanged.connect(self.sendTurnChange)
self.sm.territoryUpdated.connect(self.sendTerritoryUpdate)
self.sm.remainingTroopsChanged.connect(self.sendRemainingTroopsChange)
self.sm.attacked.connect(self.sendAttack)
self.sm.cardAwarded.connect(self.sendCardAward)
self.sm.cardsExchanged.connect(self.sendCardsExchanged)
self.sm.mustExchangeCards.connect(self.sendMustExchangeCards)
self.sm.playerEliminated.connect(self.sendPlayerEliminated)
self.chatHistory = []
self.colors = self.predefinedColors
parent = os.path.dirname(__file__)
with open(os.path.join(parent, "words")) as f:
self.words = f.read().split("\n")
timer = QTimer(self)
timer.setInterval(3000)
timer.timeout.connect(self.sendPing)
timer.start()
class ButtonHandler:
STATE_BUTTON_START = 0
STATE_BUTTON_COLLECT = 1
STATE_CLICK_START = 0
STATE_CLICK_CONFIRM_CONFIG = 1
STATE_CLICK_IN_CONFIG = 2
def __init__(self, period=500):
self.state = self.STATE_BUTTON_START
self.start_time = 0
self.period = period
self.click_state = self.STATE_CLICK_START
self.indicator = Indicator(PinSet(Sonoff.GREEN_LED))
self.relay = PinSet(Sonoff.RELAY)
self.smartconfig = SM(self.indicator)
self.iostate = False
def timer_finish(self):
# print("Events", self.click_state)
# for ii in self.events:
# print(ii)
zero_count = len([ii for ii in self.events if ii[0] == 0])
if self.click_state == self.STATE_CLICK_START:
if zero_count == 2:
if self.smartconfig.running:
self.smartconfig.stop()
self.indicator.blink(period=100)
self.click_state = self.STATE_CLICK_CONFIRM_CONFIG
elif self.click_state == self.STATE_CLICK_CONFIRM_CONFIG:
if zero_count == 2:
self.smartconfig.start(self.iostate)
self.click_state = self.STATE_CLICK_IN_CONFIG
self.indicator.blink(period=500)
else:
self.click_state = self.STATE_CLICK_START
self.indicator.blink_cancel()
elif self.click_state == self.STATE_CLICK_IN_CONFIG:
self.click_state = self.STATE_CLICK_START
self.state = self.STATE_BUTTON_START
def handle(self, button_value):
if button_value == 0:
if self.iostate is True:
self.iostate = False
self.relay.off()
else:
self.iostate = True
self.relay.on()
if self.state == self.STATE_BUTTON_START:
self.start_time = pyb.millis()
self.state = self.STATE_BUTTON_COLLECT
self.events = list()
self.timer = esp.os_timer(lambda timer: self.timer_finish(), period=self.period, repeat=False)
elapsed = 0
else:
elapsed = pyb.elapsed_millis(self.start_time)
self.events.append((button_value, elapsed))
import machine
import pyb
import math
import lcd160cr
from pyb import Pin
from pyb import Timer
from sm import SM
from button import Button
from label import Label
lcd = lcd160cr.LCD160CR('X')
lcd.set_orient(lcd160cr.PORTRAIT)
sme = SM("SME", Timer(2), Pin('X3', Pin.OUT), 4000, 1)
timProcess = Timer(11, freq=10)
process = False
encounter = 0
encounterTouch = 0
Touch = False
X = 0
Y = 0
gz = [0]
factor = 10.0
roundPerMinut = [0]
change = False
buttonPlus = Button(lcd, 98, 0, 30, 30, "+")
buttonMinus = Button(lcd, 98, 60, 30, 30, "-")
class ButtonHandler:
STATE_BUTTON_START = 0
STATE_BUTTON_COLLECT = 1
STATE_CLICK_START = 0
STATE_CLICK_CONFIRM_CONFIG = 1
STATE_CLICK_IN_CONFIG = 2
def __init__(self, period=500):
self.state = self.STATE_BUTTON_START
self.start_time = 0
self.period = period
self.click_state = self.STATE_CLICK_START
self.indicator = Indicator(PinSet(Sonoff.GREEN_LED))
self.relay = PinSet(Sonoff.RELAY)
self.smartconfig = SM(self.indicator)
self.iostate = False
def timer_finish(self):
# print("Events", self.click_state)
# for ii in self.events:
# print(ii)
zero_count = len([ii for ii in self.events if ii[0] == 0])
if self.click_state == self.STATE_CLICK_START:
if zero_count == 2:
if self.smartconfig.running:
self.smartconfig.stop()
self.indicator.blink(period=100)
self.click_state = self.STATE_CLICK_CONFIRM_CONFIG
elif self.click_state == self.STATE_CLICK_CONFIRM_CONFIG:
if zero_count == 2:
self.smartconfig.start(self.iostate)
self.click_state = self.STATE_CLICK_IN_CONFIG
self.indicator.blink(period=500)
else:
self.click_state = self.STATE_CLICK_START
self.indicator.blink_cancel()
elif self.click_state == self.STATE_CLICK_IN_CONFIG:
self.click_state = self.STATE_CLICK_START
self.state = self.STATE_BUTTON_START
def handle(self, button_value):
if button_value == 0:
if self.iostate is True:
self.iostate = False
self.relay.off()
else:
self.iostate = True
self.relay.on()
if self.state == self.STATE_BUTTON_START:
self.start_time = pyb.millis()
self.state = self.STATE_BUTTON_COLLECT
self.events = list()
self.timer = esp.os_timer(lambda timer: self.timer_finish(),
period=self.period,
repeat=False)
elapsed = 0
else:
elapsed = pyb.elapsed_millis(self.start_time)
self.events.append((button_value, elapsed))
class Server(QTcpServer):
sendReady = pyqtSignal(int, list)
sendReadySpecific = pyqtSignal(int, list, int)
resetting = pyqtSignal()
predefinedColors = [
[255, 0, 0],
[0, 255, 0],
[0, 0, 255],
[255, 255, 0],
[0, 255, 255],
[255, 0, 255],
]
def __init__(self, boardName, board, parent = None):
QTcpServer.__init__(self, parent)
self.boardName = boardName
self.connections = []
SM.next = _smDebug(SM.next)
self.sm = SM(board)
self.sm.stateChanged.connect(self.sendStateChange)
self.sm.turnChanged.connect(self.sendTurnChange)
self.sm.territoryUpdated.connect(self.sendTerritoryUpdate)
self.sm.remainingTroopsChanged.connect(self.sendRemainingTroopsChange)
self.sm.attacked.connect(self.sendAttack)
self.sm.cardAwarded.connect(self.sendCardAward)
self.sm.cardsExchanged.connect(self.sendCardsExchanged)
self.sm.mustExchangeCards.connect(self.sendMustExchangeCards)
self.sm.playerEliminated.connect(self.sendPlayerEliminated)
self.chatHistory = []
self.colors = self.predefinedColors
parent = os.path.dirname(__file__)
with open(os.path.join(parent, "words")) as f:
self.words = f.read().split("\n")
timer = QTimer(self)
timer.setInterval(3000)
timer.timeout.connect(self.sendPing)
timer.start()
def send(self, msg, args = []):
self.sendReady.emit(msg, args)
def sendTo(self, id, msg, args = []):
self.sendReadySpecific.emit(msg, args, id)
def sendExcept(self, id, msg, args = []):
for c in self.connections:
if c and c.id != id:
self.sendTo(c.id, msg, args)
def incomingConnection(self, socketDescriptor):
c = Connection(socketDescriptor)
c.error.connect(self.handleError)
self.connections.append(c)
c.messageReceived.connect(self.handleMessage)
c.disconnected.connect(self.handleDisconnect)
self.sendReady.connect(c.sendMessage)
self.sendReadySpecific.connect(c.sendMessage)
self.resetting.connect(c.abort)
timer = QTimer(c)
timer.setInterval(10000)
timer.timeout.connect(self.handleTimeout)
c.messageReceived2.connect(timer.start)
timer.start()
def handleTimeout(self):
conn = self.sender().parent()
if conn.player:
log.warning("%s has timed out.", conn.player.name)
conn.abort()
def handleError(self, err):
if err != Connection.RemoteHostClosedError:
if self.sender().player:
name = self.sender().player.name
else:
name = "Anonymous client"
log.warning("%s network error: %s", name, self.sender().errorString())
self.sender().abort()
def handleDisconnect(self):
conn = self.sender()
if conn.player:
log.info("%s has disconnected.", conn.player)
self.sm.next(Action.RemovePlayer, [conn.player.name])
if self.sm.substate == State.Lobby:
self.send(Message.PlayerLeft, [conn.player.name])
else:
self.send(Message.PlayerLeftDuringGame, [conn.player.name])
else:
log.info("Anonymous client disconnected.")
self.connections.remove(conn)
conn.deleteLater()
def handleMessage(self, msg, args):
conn = self.sender()
if not conn.player:
if msg == Message.Join:
log.info("%s connected.", conn.peerAddress().toString())
if self.sm.substate != State.Lobby:
self.sendTo(conn.id, Message.GameInProgress)
else:
self.sendTo(conn.id, Message.JoinSuccess)
elif msg == Message.RequestName:
name = args[0]
log.info("%s requested the name \"%s\".", conn.peerAddress().toString(), name)
if not self.sm.next(Action.AddPlayer, [name]):
log.info("Name taken.")
self.sendTo(conn.id, Message.NameTaken)
else:
password = random.choice(self.words)
conn.player = self.sm.players[-1]
conn.player.password = password
if not self.colors:
conn.player.color = [random.randint(0, 255) for i in range(3)]
else:
conn.player.color = self.colors.pop(random.randint(0, len(self.colors) - 1))
log.info("%s has been granted the name \"%s\" and password: %s.", conn.peerAddress().toString(), name, password)
log.info("%s has been assigned the color %s", name, conn.player.color)
self.sendTo(conn.id, Message.NameAccepted, [name, conn.player.password])
self.sendExcept(conn.id, Message.PlayerJoined, [name] + conn.player.color)
elif msg == Message.Rejoin:
password = args[0]
for i in range(len(self.sm.players)):
if self.sm.players[i].password == password:
conn.player = self.sm.players[i]
break
if conn.player:
log.info("%s has rejoined.", conn.player.name)
self.sendTo(conn.id, Message.RejoinSuccess, [conn.player.name])
self.sendExcept(conn.id, Message.PlayerRejoined, [conn.player.name])
else:
self.sendTo(conn.id, Message.IncorrectPassword)
else:
if msg == Message.SendChat:
text = args[0]
log.info("%s: %s", conn.player.name, text)
timestamp = QDateTime.currentDateTime().toTime_t()
self.chatHistory.append([conn.player, text, timestamp])
self.send(Message.ReceiveChat, [conn.player.name, text, timestamp])
elif msg == Message.SendWhisper:
(target, text) = args
targetPlayer = self.sm.getPlayer(target)
if not targetPlayer:
self.sendTo(conn.id, Message.WhisperError)
else:
timestamp = QDateTime.currentDateTime().toTime_t()
for c in self.connections:
if c.player == targetPlayer:
self.sendTo(c.id, Message.ReceiveWhisper, [conn.player.name, c.player.name, text, timestamp])
self.sendTo(conn.id, Message.ReceiveWhisper, [conn.player.name, c.player.name, text, timestamp])
log.info("%s >> %s: %s", conn.player.name, target, text)
break
elif msg == Message.RequestBoardName:
self.sendTo(conn.id, Message.LoadBoard, [self.boardName])
elif msg == Message.RequestPlayerList:
self.sendTo(conn.id, Message.BeginPlayerList)
for p in self.sm.players:
self.sendTo(conn.id, Message.PlayerInfo, [p.name, len(p.cards)] + list(p.color))
self.sendTo(conn.id, Message.EndPlayerList)
elif msg == Message.RequestChatHistory:
for line in self.chatHistory:
self.sendTo(conn.id, Message.ReceiveChat, [line[0].name, line[1]])
elif msg == Message.RequestState:
self.sendTo(conn.id, Message.CurrentState, [self.sm.substate])
elif msg == Message.RequestOwnershipList:
self.sendTo(conn.id, Message.BeginOwnershipList)
for t in self.sm.board.iterTerritories():
owner = t.owner.name if t.owner else ""
self.sendTo(conn.id, Message.Ownership, [t.name, owner, t.troopCount])
self.sendTo(conn.id, Message.EndOwnershipList)
elif msg == Message.RequestCardList:
self.sendTo(conn.id, Message.BeginCardList)
for c in conn.player.cards:
self.sendTo(conn.id, Message.Card, [c.territoryName, c.unit])
self.sendTo(conn.id, Message.EndCardList)
elif msg == Message.RequestCurrentPlayer:
self.sendTo(conn.id, Message.CurrentPlayer, [self.sm.currentPlayer.name])
elif msg == Message.RequestRemainingTroops:
self.sendTo(conn.id, Message.RemainingTroopsChanged, [self.sm.remainingTroops])
elif msg == Message.ChangeName:
if self.sm.substate != State.Lobby:
return
before = conn.player.name
after = args[0]
if before == after:
return
for player in self.sm.players:
if player == conn.player:
continue
if player.name == after:
self.sendTo(conn.id, Message.NameChangeTaken)
return
conn.player.name = after
log.info("%s changed their name to %s.", before, after)
self.sendTo(conn.id, Message.NameChangeSuccess, [after])
self.send(Message.NameChanged, [before, after])
elif msg == Message.ChangeColor:
if self.sm.substate != State.Lobby:
return
color = args
player = conn.player
player.color = color
log.info("%s changed their color to (%d, %d, %d)", player.name, color[0], color[1], color[2])
self.send(Message.ColorChanged, [player.name] + color)
elif msg == Message.ReadyToPlay:
conn.player.ready = True
if not False in [p.ready for p in self.sm.players] and self.sm.playerCount() > 1:
log.info("Game automatically started.")
self.sm.next(Action.StartGame)
elif conn.player == self.sm.currentPlayer:
if msg == Message.ClaimTerritory:
name = args[0]
self.sm.next(Action.PlaceTroops, [name, 1])
elif msg == Message.Draft:
(name, count) = args
self.sm.next(Action.PlaceTroops, [name, count])
elif msg == Message.ExchangeCards:
self.sm.next(Action.ExchangeCards, args)
elif msg == Message.Attack:
(source, target, count) = args
self.sm.next(Action.Attack, [source, target, count])
elif msg == Message.EndAttack:
self.sm.next(Action.EndAttack)
elif msg == Message.Fortify:
(source, target, count) = args
self.sm.next(Action.Fortify, [source, target, count])
elif msg == Message.EndTurn:
self.sm.next(Action.EndTurn)
def readStdin(self):
line = sys.stdin.readline().strip()
if line.lower() == "quit":
QCoreApplication.quit()
elif line.lower() == "reset":
log.info("Resetting server.")
self.colors = self.predefinedColors
self.sm.reset()
self.resetting.emit()
elif line.lower() == "start":
if not self.sm.next(Action.StartGame):
log.warning("Need more players to start.")
def sendPing(self):
self.send(Message.Ping)
def sendStateChange(self, old, new):
self.send(Message.StateChanged, [old, new])
def sendTurnChange(self, name):
self.send(Message.TurnChanged, [name])
def sendTerritoryUpdate(self, name, owner, troopCount):
name = str(name)
owner = str(owner)
log.info("%s owns %s with %d troops", owner, name, troopCount)
self.send(Message.TerritoryUpdated, [name, owner, troopCount])
def sendRemainingTroopsChange(self, n):
if self.sm.currentPlayer:
log.info("%s has %d troops remaining.", self.sm.currentPlayer.name, n)
self.send(Message.RemainingTroopsChanged, [n])
def sendCardsExchanged(self, name, c1, c2, c3):
self.send(Message.CardsExchanged, [name, c1, c2, c3])
def sendMustExchangeCards(self, name):
for c in self.connections:
if c.player.name == name:
self.sendTo(c.id, Message.MustExchangeCards)
def sendAttack(self, attacker, source, target):
self.send(Message.Attacked, [attacker, source, target])
def sendCardAward(self, player, territory, unit):
for c in self.connections:
if c.player.name == player:
self.sendTo(c.id, Message.ReceiveCard, [territory, unit])
self.send(Message.CardAwarded, [player])
def sendPlayerEliminated(self, player):
self.send(Message.PlayerEliminated, [player])
def build(self):
return SM()
