lausTracker.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
# notwendige Module einbinden
from time import sleep
import packedCom
 
 
class lausTrackerSelf(packedCom.packedCom):
    def __init__(self):
        """ Initialisieren der Klasse. """
 
        
        self.orientation = 2 # east
        # 0 = south
        # 1 = north
        # 2 = east
        # 3 = west
        self.x = 0
        # 0..7
        self.y = 0
        # 0..7
 
        
        packedCom.packedCom.__init__(self, 0xa1, "BBB")
        # packed descriptor is 0xa1
        # orientation is of type uint8_t
        # x           is of type uint8_t
        # y           is of type uint8_t
 
    def getAsString(self):
        """ Konvertiert die aktuellen Daten in einen String """
 
        # schreibe alle Daten in eine Liste
        # (Reihenfolge wie bei der Initialisierung)
        data = [ self.orientation, self.x, self.y ]
        # rufe die getAsString-Funktion der Basisklasse
        return super(lausTrackerSelf, self).getAsString(data)
 
class lausTrackerRival(packedCom.packedCom):
    def __init__(self):
        """ Initialisieren der Klasse. """
 
        
        self.x = 0
        # 0..7
        self.y = 0
        # 0..7
 
        
        packedCom.packedCom.__init__(self, 0xa2, "BB")
        # packed descriptor is 0xa2
        # x           is of type uint8_t
        # y           is of type uint8_t
 
    def getAsString(self):
        """ Konvertiert die aktuellen Daten in einen String """
 
        # schreibe alle Daten in eine Liste
        # (Reihenfolge wie bei der Initialisierung)
        data = [ self.x, self.y ]
        # rufe die getAsString-Funktion der Basisklasse
        return super(lausTrackerRival, self).getAsString(data)
 
"""
Programm zum Testen der Laustracker-Funktionen.
 
Zugehöriges Mikrocontroller Programm ist examples/lausTracker.c
Wird dieses Programm auf dem Roboter ausgeführt, kann über das Python
Skript eine Kommunikation etabliert werden.
 
Dieses Python Skript benötigt das vereinfachte packedCom-Modul unter
  tools/python/packedCom.py
 
Das Programm kann mit Strg-C abgebrochen werden.
"""
 
# Comport öffnen
#   Standarddevice ist Kabelgebundene USB Verbindung zum Roboter
#   (/dev/tucbot/all_usb)
#
#   Zum öffnen der XBee-Verbindung muss dieses Skript mit dem entsprechenden
#   Parameter geöffnet werden, für den Roboter Andi wäre dies zum Beispiel:
#     $ python customData.py -r andi
comport = packedCom.comPort()
 
# Kurz warten, um das Comport zu initialisieren
sleep(0.2)
 
# Endlosschleife, simuliert, dass der eigene Roboter (S) eine große Runde
# fährt und der Gegner (R) eine kleine
#
#     x0  x1  x2  x3  x4  x5  x6  x7
#    +---+---+---+---+---+---+---+---+
# y0 I S<--S<--S<--S<--S<--S<--S<--S I
#    + v                           ^ +
# y1 I S                           S I
#    + v                           ^ +
# y2 I S       R-->R-->R-->R       S I
#    + v       ^           v       ^ +
# y3 I S       R           R       S I
#    + v       ^           v       ^ +
# y4 I S       R           R       S I
#    + v       ^           V       ^ +
# y5 I S       R<--R<--R<--R       S I
#    + v                           ^ +
# y6 I S                           S I
#    + v                           ^ +
# y7 I S-->S-->S-->S-->S-->S-->S-->S I
#    +---+---+---+---+---+---+---+---+
#
# Mit Strg-C abbrechen!
 
# Instantierung
s = lausTrackerSelf()
r = lausTrackerRival()
 
while 1:
    # der eigene Roboter
    if   ((s.x == 0) and (s.y < 7)):
        s.y = s.y + 1
        s.orientation = 0 # south
    elif ((s.y == 7) and (s.x < 7)):
        s.x = s.x + 1
        s.orientation = 2 # east
    elif ((s.x == 7) and (s.y > 0)):
        s.y = s.y - 1
        s.orientation = 1 # north
    elif ((s.y == 0) and (s.x > 0)):
        s.x = s.x - 1
        s.orientation = 3 # west
    else:
        s.y = 0
        s.x = 0
        s.orientation = 0 # south
 
    # der gegnerische Roboter
    if   ((r.y == 2) and (r.x < 5)):
        r.x = r.x + 1
        r.orientation = 2 # east
    elif ((r.x == 5) and (r.y < 5)):
        r.y = r.y + 1
        r.orientation = 0 # south
    elif ((r.y == 5) and (r.x > 2)):
        r.x = r.x - 1
        r.orientation = 3 # west
    elif ((r.x == 2) and (r.y > 2)):
        r.y = r.y - 1
        r.orientation = 1 # north
    else:
        r.y = 2
        r.x = 2
        r.orientation = 2 # east
 
    print "self @(", s.x, ", ", s.y, ", ", s.orientation, ") and rival @(", \
      r.x, ", ", r.y, ")"
    comport.write(s.getAsString())
    comport.write(r.getAsString())
 
    # Daten einlesen (eigentlich sollte nichts reinkommen)
    tmp = comport.read(100)
    if (tmp != ""):
        print "in : ", repr(tmp)
    # Für automatische Auswertung der Packages muss auf tuc_bot Package
    # zurückgegriffen werden. Dokumentation ist noch in Arbeit.
 
    # warten - Roboter bewegen sich 1 Feld pro Sekunde
    sleep(1.0)