Exemplo n.º 1
0
def main():
    global running, core, core_lock
    match_id = int(sys.argv[1])
    listen_addr = sys.argv[2]
    listen_port = int(sys.argv[3])

    core = SubottoCore(match_id)
    with core_lock:
        core.update()

    # Initialize ConnectionServer
    server = ThreadedTCPServer((listen_addr, listen_port), Connection)
    server_thread = threading.Thread(target=server.serve_forever)
    server_thread.start()

    # Do things
    try:
        while True:
            with core_lock:
                core.update()
            time.sleep(1.0)
    except KeyboardInterrupt:
        running = False

    running = False
    server.shutdown()
    server.server_close()
    server_thread.join()
Exemplo n.º 2
0
def main():
    match_id = int(sys.argv[1])
    serial_port = sys.argv[2]
    ss = SubottoSerial(serial_port, 115200)
    # Here we wait for the SUB_READY command, otherwise we risk to
    # send commands before the unit is ready
    print ss.wait_for_ready()
    core = SubottoCore(match_id)
	
    # Run a test match
    ss.set_slave_mode()
    score = [0, 0]
    cached_score = [None, None]
    try:
        while True:
            events = ss.receive_events()
            for ev in events:
                team, var, desc, source = SubottoSerial.ASYNC_DESC[ev]
                score[team] += var
                print "%s; result is %d -- %d" % (desc, score[0], score[1])
                if var > 0:
                	core.act_goal(core.order[team], source)
                elif var < 0:
                	core.act_goal_undo(core.order[team], source)
            core.update()
            for i in [0, 1]:
                this_score = core.score[core.detect_team(core.order[i])]
                if this_score != cached_score[i]:
                    ss.set_score(this_score, i)
                    cached_score[i] = this_score
            time.sleep(0.2)
    except KeyboardInterrupt:
        pass
Exemplo n.º 3
0
def main():
    global running, core, core_lock, allowed_IPs, dry_run

    parser = argparse.ArgumentParser(description='Arduino interface')
    parser.add_argument('match_id', type=int, help='The id of the match to connect to')
    parser.add_argument('--listen_addr', default='0.0.0.0', help='The address the listener server listens to')
    parser.add_argument('--listen_port', default=2204, type=int, help='The address the listener server listens to')
    parser.add_argument('arduino_ip', help='The ip of the allowed Arduino')
    parser.add_argument('--dry-run', action='store_true', help='Test run')

    args = parser.parse_args()

    allowed_IPs.append(args.arduino_ip)
    dry_run = args.dry_run

    core = SubottoCore(args.match_id)
    with core_lock:
        core.update()

    # Initialize ConnectionServer
    server = ThreadedTCPServer((args.listen_addr, args.listen_port), Connection)
    server_thread = threading.Thread(target=server.serve_forever)
    server_thread.start()

    print >> sys.stdout, "Started server on {}:{}".format(args.listen_addr, args.listen_port)

    # Do things
    try:
        while True:
            with core_lock:
                core.update()
            time.sleep(1.0)
    except KeyboardInterrupt:
        running = False

    running = False
    server.shutdown()
    server.server_close()
    server_thread.join()
Exemplo n.º 4
0
                    self.order[i].box.reparent(self.team_slot[i])
            
    def on_window_destroy (self, widget):
        self.core.close()
        Gtk.main_quit()

    def on_btn_switch_clicked (self, widget):
        debug("Cambio!", 2)
        self.switch_teams()

    def regenerate(self):
        debug("Updating!",20)
        self.update_teams()

    def new_player_match(self, player_match):
        pass

    def new_event(self, event):
        pass

if __name__ == "__main__":

    match_id = int(sys.argv[1])
    core = SubottoCore(match_id)
    main_window = Subotto24GTK(core)

    core.update()
    gi.repository.GObject.timeout_add(1000, core.update)

    Gtk.main()
Exemplo n.º 5
0
class Interface:

    _numDebugebugLines = 0

    DEVICE = ["arduino","core"]
    MAX_NUM_CONSOLE_ROWS = 100

    connected = False
    toDisconnect = False
    score = {dev:[0,0] for dev in DEVICE}
    lastToScore = {dev:None for dev in DEVICE}


    # === init function ===

    def __init__(self):
        filename = "main.glade"
        self.builder = Gtk.Builder()
        self.builder.add_from_file(filename)
        self.builder.connect_signals(self)

        self.mainWindow = self.builder.get_object("mainWindow")
        self.connectionWindow = self.builder.get_object("connectionWindow")
        self.debugConsole = Gtk.ListStore(str)
        self.consoleView = self.builder.get_object("console")
        self.consoleView.set_model(self.debugConsole)
        self.consoleView.insert_column(Gtk.TreeViewColumn("Debug Log", Gtk.CellRendererText(), text=0),0)

        self.scoreTextView = {
            "arduino":{"RED":self.builder.get_object("redArduinoScore"),
                       "BLUE":self.builder.get_object("blueArduinoScore")},
            "core":{"RED":self.builder.get_object("redCoreScore"),
                    "BLUE":self.builder.get_object("blueCoreScore")}
        }
        self.lastToScoreBar = {
            "arduino":{"RED":self.builder.get_object("redArduinoLastToScore"),
                       "BLUE":self.builder.get_object("blueArduinoLastToScore")},
            "core":{"RED":self.builder.get_object("redCoreLastToScore"),
                    "BLUE":self.builder.get_object("blueCoreLastToScore")},
        }
        self.sensorSwitch = {
            "RED":{
                "VOID":None,
                "GOAL":self.builder.get_object("redGoalSwitch"),
                "SUPERGOAL":self.builder.get_object("redSupergoalSwitch"),
                "PLUS_ONE":self.builder.get_object("redAddButtonSwitch"),
                "MINUS_ONE":self.builder.get_object("redUndoButtonSwitch")
            },
            "BLUE":{
                "VOID":None,
                "GOAL":self.builder.get_object("blueGoalSwitch"),
                "SUPERGOAL":self.builder.get_object("blueSupergoalSwitch"),
                "PLUS_ONE":self.builder.get_object("blueAddButtonSwitch"),
                "MINUS_ONE":self.builder.get_object("blueUndoButtonSwitch")
            }
        }

        self.core = SubottoCore(int(sys.argv[1]))
        for i in [0,1]:
            self.score["core"][i] = self.getCoreScore(i)
       
        GObject.timeout_add(300, self.loopFunction)
        self.core = SubottoCore(int(sys.argv[1]))


    # === control functions ===

    # write on the console
    def debugLog(self,string):
        self._numDebugebugLines += 1
        self.debugConsole.append([string])
        #if len(self.debugConsole) > self.MAX_NUM_CONSOLE_ROWS:
        #    self.debugConsole.remove(self.debugConsole.get_iter_first())


    # === main loop ===

    def loopFunction(self,*args):
        if self.connected:
            self.updateScore()
        elif self.toDisconnect:
            self.disconnect()
        else:
            self.debugLog("Not connected")
        self.core.update()
        return True


    # === connection/disconnection functions ===

    # connect to socket
    def connect(self):
        if not self.connected:    
            try:
                self.debugLog("Getting data..")
                TCP_IP = self.builder.get_object("tcpipText").get_text()
                TCP_PORT = int(self.builder.get_object("tcpportText").get_text())
                PWD = self.builder.get_object("pwdText").get_text()
                self.debugLog("Connecting to socket...")
                self.debugLog("TCP_IP: " + TCP_IP)
                self.debugLog("TCP_PORT: " + str(TCP_PORT))
                self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                self.s.connect((TCP_IP, TCP_PORT))
                self.debugLog("Connected!")
                self.s.send(PWD)
                self.connected = True
                self.debugLog("Creating arduino controller object...")
                self.ac = ArdCon(self.s,self.debugLog)
                self.debugLog("Arduino controller object Created!")
                self.debugLog("Asking Arduino data...")
                for i in [0,1]:
                    self.getArduinoScore(i)
                self.connectionWindow.hide()
            except:
                traceback.print_exc()
                self.debugLog("Connection failed\n")
            else:
                self.connected = True
                self.debugLog("Connection successful\n")

    # disconnect from socket
    def disconnect(self):
        self.toDisconnect = False
        #if not self.connected:
        try:
            self.s.close()
        except:
            pass
        self.connectionWindow.show()
        self.connected = False
        self.debugLog("Disconnected\n")


    def readEvents(self):
        try:
            rcv = self.ac.receiveData()
            while rcv is not None:
                self.debugLog(str(rcv))
                self.sendEventToCore(rcv)
                rcv = self.ac.receiveData()
        except:
            traceback.print_exc()
            self.connected = False
            self.toDisconnect = True
            self.debugLog("Disconnected")


    # === update functions ===

    # asks the score to arduino and the core; updates arduino score
    def updateScore(self):
        self.readEvents()
        for i in [0,1]:
            self.score["core"][i] = self.getCoreScore(i)
            if self.score["arduino"][i] == None:
                self.debugLog("Arduino score unknown")
                self.lastToScore["arduino"] = None
            else:
                if self.score["core"][i] != self.score["arduino"][i]:
                    # server takes priority over arduino
                    self.setArduinoScore(i,self.score["core"][i])
                    self.lastToScore["arduino"] = None
            self.updateView(i)

    # update scores on the main window
    def updateView(self,team):
        for dev in self.DEVICE:
            score = self.score[dev][team]
            if score == None:
                self.scoreTextView[dev][self.ac.ARD_TEAM[team]].set_text("Unknown")
            else:
                self.scoreTextView[dev][self.ac.ARD_TEAM[team]].set_text(str(score))
            if self.lastToScore[dev] == team:
                self.lastToScoreBar[dev][self.ac.ARD_TEAM[team]].set_fraction(1)
            else:
                self.lastToScoreBar[dev][self.ac.ARD_TEAM[team]].set_fraction(0)


    # === core communication ===

    # get score from the core
    def getCoreScore(self,i):
        return self.core.score[self.core.detect_team(self.core.order[i])]

    # send an event received from arduino
    def sendEventToCore(self,data):
        team = self.ac.ARD_TEAM.index(data["team"])
        self.score["arduino"][team] = data["score"]
        event = self.ac.CORE_EVENT[data["team"]][data["event"]]
        if event is None:
            pass
        elif event in self.ac.UNDO_EVENT:
            self.core.act_goal_undo(self.core.order[team], event)
        else:
            self.core.act_goal(self.core.order[team], event)
            self.lastToScore["core"] = team
            self.lastToScore["arduino"] = team


    # === arduino communication ===

    # get arduino score
    def getArduinoScore(self,i):
        self.ac.askData(self.ac.ARD_TEAM[i])

    # set arduino score
    def setArduinoScore(self,team,score):
        scoreChange = score - self.score["arduino"][team]
        self.ac.sendScoreCommand(self.ac.ARD_TEAM[team],scoreChange)
        self.getArduinoScore(team)

    
    # === event handlers ===

    # called when the console shows
    def onConsoleShow(self,*args):
        adj = self.consoleView.get_vadjustment()
        adj.set_value( adj.get_page_size() )

    # called when a new line is added to the console
    def onSizeAllocate(self,*args):
        numDebugLines = self._numDebugebugLines
        self._numDebugebugLines = 0
        adj = self.consoleView.get_vadjustment()
        if adj.get_value() >= adj.get_upper() - adj.get_page_size() - numDebugLines * adj.get_step_increment():
            adj.set_value( adj.get_upper() - adj.get_page_size() )

    # called when a switch is switched
    def onSwitchNotify(self,*args):
        if self.connected:
            for team in self.ac.ARD_TEAM:
                for event in self.ac.EVENT:
                    if args[0] == self.sensorSwitch[team][event]:
                        toActivate = self.sensorSwitch[team][event].get_active()
                        self.ac.sendSensorCommand(team,event,toActivate)
                        self.debugLog("switch " + str(team) + " " + str(event) + " was turned " + str(toActivate))

    # called when the connection button is hit
    def onConnection(self,*args):
        self.debugLog("Connecting...")
        self.connect()

    # called when the main window is closed
    def onDestroyWindow(self,*args):
        try:
            del(self.ac)
            self.disconnect()
        except:
            traceback.print_exc()
            pass
        sys.exit(0)