def connect(self):
self.log.info("Connecting ...")
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except Exception as error:
raise RobotConnectionError(error)
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
self.log.info("Set up Motors")
try:
#self.kicker.turn(100, 100, brake=True)
self.log.debug(self.__read_motor_state(self.KICKER))
except Exception as error:
self.log.error("kicker reset error: " + str(error))
self.state = self.STATE_IDLE
self.__get_info()
self.log.info("Conected to {name}".format(name=self.name))
self.buzz()
def main():
# Coonecting with server
host,port = "127.0.0.1" , 10160
# Connecting with Robot via Bluetooth
sock = BlueSock(ID)
b = sock.connect()
clientSocket = socket.socket()
clientSocket.connect((host,port))
clientSocket.send('bluetooth '+'#')
flag=0
Chartext = clientSocket.recv(1024)
print Chartext
# Always listening for command
while Chartext != "Exit":
try:
Chartext = clientSocket.recv(1024)
if Chartext=='a':
left(b)
elif Chartext=='d':
right(b)
elif Chartext=='e':
off(b)
elif Chartext=='x':
on(b)
if flag==1:
b = sock.connect()
flag=0
# Exception Handling
except:
sock.close()
clientSocket.send('Exit')
clientSocket.close()
break
class BrickGetter:
def __init__(self):
self.sock = None
def getBrick(self):
# Create socket to NXT brick
self.sock = BlueSock(ID)
# On success, socket is non-empty
if self.sock:
print('Connecting...');
# Connect to brick
brick = self.sock.connect()
print('Connected!');
return brick
# Play tone A above middle C for 1000 msec
# brick.play_tone_and_wait(440, 500)
# Failure
else:
print('No NXT bricks found')
#not neccessary since when brick is garabage collected
#brick automatically closes
def close(self):
self.sock.close()
def connect(self):
print "Connecting ..."
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except BluetoothError as error:
raise RobotConnectionError(error)
self.__get_info()
print "Conected to {name}".format(name=self.name)
def connect(self):
self.log.info("Connecting ...")
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except Exception as error:
raise RobotConnectionError(error)
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
self.log.info("Set up Motors")
try:
# self.kicker.turn(100, 100, brake=True)
self.log.debug(self.__read_motor_state(self.KICKER))
except Exception as error:
self.log.error("kicker reset error: " + str(error))
self.state = self.STATE_IDLE
self.__get_info()
self.log.info("Conected to {name}".format(name=self.name))
self.buzz()
def setUp(cls):
ID = '00:16:53:17:EF:0A' # MAC address NXT11
cls.sock = BlueSock(ID)
brick = cls.sock.connect()
cls.leftMotor = nxt.Motor(brick, nxt.PORT_B)
cls.rightMotor = nxt.Motor(brick, nxt.PORT_A)
cls.leftMotor.reset_position(False)
cls.rightMotor.reset_position(False)
class NXTReceiver(object):
"Slave to the NXT"
bs = None
sock = None
def __init__(self):
self.bs = BlueSock("00:16:53:12:C0:CA:00")
self.bs.debug = True
self.bs.connect()
self.sock = self.bs.sock
def recv(self, len):
"Iteratively waits for input until the desired size is achieved"
received = 0
payload = ""
while received < len:
t = self.sock.recv(len - received)
received += t.__len__()
payload += t
return payload
def __init__(self,
baddr,
pin,
direct=False,
method='bluetooth',
dryrun=False):
'''
initialize robot. by default robot is found using bluetooth,
remember to install bluetooth lib before usage!
:param baddr: The bluetooth mac address
:param pin: The pin to ensure the connection
'''
self.dryrun = dryrun
if self.dryrun:
print('Running in dryrun mode, will NOT initialize!')
return
if method == 'bluetooth':
# Pair with nxt via bluetooth before connecting
self.stable_connection = Pair(baddr, pin)
self.brick = BlueSock(baddr).connect()
elif method == 'usb':
# explicitly deactivate bluetooth
usb_only = Method(usb=True, bluetooth=False)
self.brick = find_one_brick(method=usb_only, debug=True)
# initialize basic functions
self.init_motors()
self.init_sensors()
# initialize some useful vars
self.touch_right = False
self.touch_left = False
# locked is used to stop robo from moving when it has collided
# getting orders from http-server
self.locked = False
self.calibrating = False
# player for beeps and stuff
self.player = Nxt_Player(self.brick)
# Initialize pad and autopilot modules
# TODO: do not start padmode if server
if direct:
self.pad_controller = PadController(self)
self.autopilot = AutoPilot(self)
self.calibrate()
def connect(self):
print "Connecting ..."
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except BluetoothError as error:
raise RobotConnectionError(error)
self.__get_info()
print "Conected to {name}".format(name=self.name)
def _nxt_search(self):
ret = []
devices = []
try:
devices = usb.core.find(find_all=True, idVendor=ID_VENDOR_LEGO, idProduct=ID_PRODUCT_NXT)
except:
pass
for dev in devices:
ret.append(USBSock(dev))
devices = []
try:
devices = bluetooth.discover_devices()
except:
pass
for dev in devices:
ret.append(BlueSock(dev))
return ret
def getBrick(self):
# Create socket to NXT brick
self.sock = BlueSock(ID)
# On success, socket is non-empty
if self.sock:
print('Connecting...');
# Connect to brick
brick = self.sock.connect()
print('Connected!');
return brick
# Play tone A above middle C for 1000 msec
# brick.play_tone_and_wait(440, 500)
# Failure
else:
print('No NXT bricks found')
def btConnect(nxtName):
# use linux system tool to list bluetooth devices
p = sp.Popen(["bt-device", "--list"],
stdin=sp.PIPE,
stdout=sp.PIPE,
close_fds=True)
(stdout, stdin) = (p.stdout, p.stdin)
data = stdout.readlines()
# first line either 'Added devices:' or 'No devices Found' - skip
ind = 1
mac = ''
while ((ind < len(data)) and (mac == '')):
line = str(data[ind]).split(" ") # to separate name and MAC
if (" ".join(line[:-1]) == nxtName):
mac = line[-1].strip()[1:-1] # MAC address, chop () off
ind += 1
if (mac == ''):
print("Error: Device not found. Make sure it is already paired.")
exit()
else:
return BlueSock(mac).connect()
class Robot(object):
LEFT_WHEEL = 0x02 # port C
RIGHT_WHEEL = 0x00 # port A
KICKER = 0x01 # port B
DEFAULT_POWER = 80
TURN_POWER = 0.8
BUZZER = 769
#NAME = "BrickAshley"
NAME = "BrickAsh"
def __init__(self, host=None):
self.power = self.DEFAULT_POWER
self.address = host
self.connect()
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
print "Set up Motors"
try:
self.kicker.turn(100, 100, brake=True)
except Exception as error:
print error
def connect(self):
print "Connecting ..."
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except BluetoothError as error:
raise RobotConnectionError(error)
self.__get_info()
print "Conected to {name}".format(name=self.name)
def disconnect(self):
try:
self.brick = None
gc.collect()
except:
print "Unsafe disconect"
def get_name(self):
self.__get_info()
return self.name
def set_name(self, name):
self.brick.set_brick_name(name)
self.disconnect()
self.connect()
self.__get_info()
def set_power(self, value):
value=int(value)
if value < -128 or value > 128:
pass
# TODO
self.power = value
def get_power(self):
return self.power
def __get_info(self):
threading.Timer(30, self.__get_info).start()
self.name, self.host, self.signal_strength, self.user_flash = self.brick.get_device_info()
self.battery = self.brick.get_battery_level()
print "Info: \n\tName: {name}" \
"\n\tBT MAC: {host}\n\tBT signal: {signal}\n\t" \
"Memory: {memory}\n\tBattery: {voltage}mV".format(name=self.name, host=self.host, \
signal=self.signal_strength, memory=self.user_flash, voltage=self.battery)
def up(self):
print "go up"
self.leftWhell.run(power=self.power)
self.rightWhell.run(power=self.power)
def down(self):
print "go down"
self.brick.play_tone_and_wait(self.BUZZER, 1000)
self.leftWhell.run(power=-self.power)
self.rightWhell.run(power=-self.power)
def right(self, withBrake=False):
print "go right"
self.leftWhell.run(power=self.power*self.TURN_POWER)
if withBrake:
self.rightWhell.brake()
else:
self.rightWhell.run(power=-self.power*self.TURN_POWER)
def left(self, withBrake=False):
print "go left"
if withBrake:
self.leftWhell.brake()
else:
self.leftWhell.run(power=-self.power*self.TURN_POWER)
self.rightWhell.run(power=self.power*self.TURN_POWER)
def stop(self):
print "go stop"
self.leftWhell.brake()
self.rightWhell.brake()
self.kicker.brake()
def buzz(self):
print "buzz"
self.brick.play_tone_and_wait(self.BUZZER, 1000)
def kick(self):
print "kick"
self.kicker.turn(-127, 85, brake=True)
sleep(1.5)
self.kicker.turn(127, 90, brake=True)
class Robot(object):
LEFT_WHEEL = 0x02 # port C
RIGHT_WHEEL = 0x00 # port A
KICKER = 0x01 # port B
DEFAULT_POWER = 80
TURN_POWER = 0.8
BUZZER = 769
#NAME = "BrickAshley"
NAME = "BrickAsh"
def __init__(self, host=None):
self.power = self.DEFAULT_POWER
self.address = host
self.log = logging.getLogger("Robot")
self.connect()
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
self.log.info("Set up Motors")
try:
#self.kicker.turn(100, 100, brake=True)
self.log.debug(self.__read_motor_state(self.KICKER))
except Exception as error:
self.log.error("kicker reset error: " + str(error))
def connect(self):
self.log.info("Connecting ...")
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except Exception as error:
raise RobotConnectionError(error)
self.__get_info()
self.log.info("Conected to {name}".format(name=self.name))
def disconnect(self):
try:
self.brick = None
#self.get_info_thread.stop()
gc.collect()
except:
self.log.warning("Unsafe disconect")
pass
def get_name(self):
self.__get_info()
return self.name
def set_name(self, name):
self.brick.set_brick_name(name)
self.disconnect()
self.connect()
self.__get_info()
def set_power(self, value):
value=int(value)
if value < -127 or value > 127:
raise ValueError("Power can only be +-127")
self.power = value
def get_power(self):
return self.power
def __get_info(self):
#self.get_info_thread = threading.Timer(30, self.__get_info)
#self.get_info_thread.start()
self.name, self.host, self.signal_strength, self.user_flash = self.brick.get_device_info()
self.battery = self.brick.get_battery_level()
self.log.info(
"Info: \n\tName: {name}" \
"\n\tBT MAC: {host}\n\tBT signal: {signal}\n\t" \
"Memory: {memory}\n\tBattery: {voltage}mV".format(name=self.name, host=self.host, \
signal=self.signal_strength, memory=self.user_flash, voltage=self.battery)
)
def up(self):
self.log.debug("go up")
self.leftWhell.run(power=self.power)
self.rightWhell.run(power=self.power)
def down(self):
self.log.debug("go down")
self.brick.play_tone_and_wait(self.BUZZER, 1000)
self.leftWhell.run(power=-self.power)
self.rightWhell.run(power=-self.power)
def right(self, withBrake=False):
self.log.debug("go right")
self.leftWhell.run(power=self.power*self.TURN_POWER)
if withBrake:
self.rightWhell.brake()
else:
self.rightWhell.run(power=-self.power*self.TURN_POWER)
def left(self, withBrake=False):
self.log.debug("go left")
if withBrake:
self.leftWhell.brake()
else:
self.leftWhell.run(power=-self.power*self.TURN_POWER)
self.rightWhell.run(power=self.power*self.TURN_POWER)
def stop(self):
self.log.debug("go stop")
self.leftWhell.brake()
self.rightWhell.brake()
#self.kicker.brake()
def buzz(self):
self.log.debug("buzz")
self.brick.play_tone_and_wait(self.BUZZER, 1000)
def kick(self):
self.log.debug("kick")
self.kicker.turn(-127, 85, brake=True)
threading.Timer(1.5, self.__kick_reset).start()
def __kick_reset(self):
self.kicker.turn(127, 90, brake=False)
#def __del__(self):
# self.log.debug("__del__")
# if self.brick != None:
# self.disconnect()
def __read_motor_state(self, port):
values = self.brick.get_output_state(port)
self.log.debug("__read_motor_state: values='{0}'".format(values))
#state, tacho = get_tacho_and_state(values)
#self.log.debug("__read_motor_state: state='{0}', tacho='{1}'".format(state, tacho))
left, kick, right = values[-3:]
if port == self.KICKER:
return kick
elif port == self.LEFT_WHEEL:
return left
elif port == self.RIGHT_WHEEL:
return left
else:
raise Exception("meh")
def get_state(self):
self.__read_motor_state(self.KICKER)
self.__read_motor_state(self.LEFT_WHEEL)
self.__read_motor_state(self.RIGHT_WHEEL)
def kick_to(self, angle, kpower=127, withBrake=True):
state, tacho = self.__read_motor_state(self.KICKER)
if angle < tacho:
self.kicker.turn(-kpower, tacho-angle, brake=withBrake)
else:
self.kicker.turn(+kpower, angle-tacho, brake=withBrake)
def __init__(self):
self.bs = BlueSock("00:16:53:12:C0:CA:00")
self.bs.debug = True
self.bs.connect()
self.sock = self.bs.sock
import nxt, thread, time import numpy as np import drive import arm # this find_one_brick method is unreliable #b = nxt.find_one_brick(host=ID) from nxt.bluesock import BlueSock # connection to first brick "JAWS" ID1 = '00:16:53:17:52:EE' # MAC address sock1 = BlueSock(ID1) b1 = sock1.connect() # connection to 2nd brick "pie" #ID2 = '00:16:53:0A:4B:2B' # MAC address #sock2 = BlueSock(ID2) #b2 = sock2.connect() mx = nxt.Motor(b1, nxt.PORT_A) # left-side my = nxt.Motor(b1, nxt.PORT_B) # right-side d = drive.Drive(mx,my) marm = nxt.Motor(b1, nxt.PORT_C) # arm motor
class Robot(object):
LEFT_WHEEL = 0x02 # port C
RIGHT_WHEEL = 0x00 # port A
KICKER = 0x01 # port B
DEFAULT_POWER = 80
TURN_POWER = 0.8
BUZZER_HZ = 769
KICK_DISTANCE = 90
STATE_DISCONNECTED = -1
STATE_IDLE = 0
STATE_UP = 1
STATE_DOWN = 2
STATE_RIGHT = 3
STATE_LEFT = 4
MAX_MOTOR_POWER = 127
#NAME = "BrickAshley"
NAME = "BrickAsh"
def __init__(self, host=None):
self.power = -1 * self.DEFAULT_POWER
self.address = host
self.state = self.STATE_DISCONNECTED
self.log = logging.getLogger("Robot")
def connect(self):
self.log.info("Connecting ...")
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except Exception as error:
raise RobotConnectionError(error)
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
self.log.info("Set up Motors")
try:
#self.kicker.turn(100, 100, brake=True)
self.log.debug(self.__read_motor_state(self.KICKER))
except Exception as error:
self.log.error("kicker reset error: " + str(error))
self.state = self.STATE_IDLE
self.__get_info()
self.log.info("Conected to {name}".format(name=self.name))
self.buzz()
def disconnect(self):
try:
self.brick = None
#self.get_info_thread.stop()
gc.collect()
except:
self.log.warning("Unsafe disconect")
self.state = self.STATE_DISCONNECTED
def get_name(self):
self.__get_info()
return self.name
def set_name(self, name):
self.brick.set_brick_name(name)
self.disconnect()
self.connect()
self.__get_info()
def set_power(self, value):
if value < -1 * self.MAX_MOTOR_POWER or value > self.MAX_MOTOR_POWER:
raise ValueError("Power can only be +-127")
else:
self.power = value
self.log.info("power set to: " + str(self.power))
def get_power(self):
return self.power
def __get_info(self):
#self.get_info_thread = threading.Timer(30, self.__get_info)
#self.get_info_thread.start()
self.name, self.host, self.signal_strength, self.user_flash = self.brick.get_device_info(
)
self.battery = self.brick.get_battery_level()
self.log.info(
"Info: \n\tName: {name}" \
"\n\tBT MAC: {host}\n\tBT signal: {signal}\n\t" \
"Memory: {memory}\n\tBattery: {voltage}mV".format(name=self.name, host=self.host, \
signal=self.signal_strength, memory=self.user_flash, voltage=self.battery)
)
def up(self):
self.log.debug("go up")
if self.state != self.STATE_UP:
self.state = self.STATE_UP
self.leftWhell.run(power=self.power)
self.rightWhell.run(power=self.power)
def down(self):
self.log.debug("go down")
if self.state != self.STATE_DOWN:
self.state = self.STATE_DOWN
self.leftWhell.run(power=-1 * self.power)
self.rightWhell.run(power=-1 * self.power)
def right(self, withBrake=False):
self.log.debug("go right")
if self.state != self.STATE_RIGHT:
self.state = self.STATE_RIGHT
self.leftWhell.run(power=self.power * self.TURN_POWER)
if withBrake:
self.rightWhell.brake()
else:
self.rightWhell.run(power=-self.power * self.TURN_POWER)
def left(self, withBrake=False):
self.log.debug("go left")
if self.state != self.STATE_LEFT:
self.state = self.STATE_LEFT
if withBrake:
self.leftWhell.brake()
else:
self.leftWhell.run(power=-self.power * self.TURN_POWER)
self.rightWhell.run(power=self.power * self.TURN_POWER)
def stop(self):
self.log.debug("go stop")
self.state = self.STATE_IDLE
self.leftWhell.brake()
self.rightWhell.brake()
def buzz(self):
self.log.debug("buzz")
self.brick.play_tone_and_wait(self.BUZZER_HZ, 1000)
def kick(self):
self.log.debug("kick")
self.kicker.turn(-127, self.KICK_DISTANCE, brake=True)
threading.Timer(1.5, self.__kick_reset).start()
def __kick_reset(self):
self.kicker.turn(127, self.KICK_DISTANCE, brake=True)
#def __del__(self):
# self.log.debug("__del__")
# if self.brick != None:
# self.disconnect()
def __read_motor_state(self, port):
values = self.brick.get_output_state(port)
self.log.debug("__read_motor_state: values='{0}'".format(values))
#state, tacho = get_tacho_and_state(values)
#self.log.debug("__read_motor_state: state='{0}', tacho='{1}'".format(state, tacho))
left, kick, right = values[-3:]
if port == self.KICKER:
return kick
elif port == self.LEFT_WHEEL:
return left
elif port == self.RIGHT_WHEEL:
return left
else:
raise Exception("meh")
def get_state(self):
self.__read_motor_state(self.KICKER)
self.__read_motor_state(self.LEFT_WHEEL)
self.__read_motor_state(self.RIGHT_WHEEL)
def kick_to(self, angle, kpower=127, withBrake=True):
state, tacho = self.__read_motor_state(self.KICKER)
if angle < tacho:
self.kicker.turn(-kpower, tacho - angle, brake=withBrake)
else:
self.kicker.turn(+kpower, angle - tacho, brake=withBrake)
class Robot(object):
LEFT_WHEEL = 0x02 # port C
RIGHT_WHEEL = 0x00 # port A
KICKER = 0x01 # port B
DEFAULT_POWER = 80
TURN_POWER = 0.8
BUZZER = 769
#NAME = "BrickAshley"
NAME = "BrickAsh"
def __init__(self, host=None):
self.power = self.DEFAULT_POWER
self.address = host
self.connect()
self.leftWhell = Motor(self.brick, self.LEFT_WHEEL)
self.rightWhell = Motor(self.brick, self.RIGHT_WHEEL)
self.kicker = Motor(self.brick, self.KICKER)
print "Set up Motors"
try:
self.kicker.turn(100, 100, brake=True)
except Exception as error:
print error
def connect(self):
print "Connecting ..."
try:
if self.address == None:
self.brick = nxt.find_one_brick().connect()
else:
self.brick = BlueSock(self.address).connect()
except nxt.locator.BrickNotFoundError:
raise RobotNotFoundError
except BluetoothError as error:
raise RobotConnectionError(error)
self.__get_info()
print "Conected to {name}".format(name=self.name)
def disconnect(self):
try:
self.brick = None
gc.collect()
except:
print "Unsafe disconect"
def get_name(self):
self.__get_info()
return self.name
def set_name(self, name):
self.brick.set_brick_name(name)
self.disconnect()
self.connect()
self.__get_info()
def set_power(self, value):
value = int(value)
if value < -128 or value > 128:
pass
# TODO
self.power = value
def get_power(self):
return self.power
def __get_info(self):
threading.Timer(30, self.__get_info).start()
self.name, self.host, self.signal_strength, self.user_flash = self.brick.get_device_info(
)
self.battery = self.brick.get_battery_level()
print "Info: \n\tName: {name}" \
"\n\tBT MAC: {host}\n\tBT signal: {signal}\n\t" \
"Memory: {memory}\n\tBattery: {voltage}mV".format(name=self.name, host=self.host, \
signal=self.signal_strength, memory=self.user_flash, voltage=self.battery)
def up(self):
print "go up"
self.leftWhell.run(power=self.power)
self.rightWhell.run(power=self.power)
def down(self):
print "go down"
self.brick.play_tone_and_wait(self.BUZZER, 1000)
self.leftWhell.run(power=-self.power)
self.rightWhell.run(power=-self.power)
def right(self, withBrake=False):
print "go right"
self.leftWhell.run(power=self.power * self.TURN_POWER)
if withBrake:
self.rightWhell.brake()
else:
self.rightWhell.run(power=-self.power * self.TURN_POWER)
def left(self, withBrake=False):
print "go left"
if withBrake:
self.leftWhell.brake()
else:
self.leftWhell.run(power=-self.power * self.TURN_POWER)
self.rightWhell.run(power=self.power * self.TURN_POWER)
def stop(self):
print "go stop"
self.leftWhell.brake()
self.rightWhell.brake()
self.kicker.brake()
def buzz(self):
print "buzz"
self.brick.play_tone_and_wait(self.BUZZER, 1000)
def kick(self):
print "kick"
self.kicker.turn(-127, 85, brake=True)
sleep(1.5)
self.kicker.turn(127, 90, brake=True)
class NXTBT:
ID = '00:16:53:0B:AE:FD'
CHANNEL = 0
MAILBOX = 0
slave = 0
tgt = [ {'wait':0, 'score':0, 'hit':0},{'wait':0, 'score':0, 'hit':0},{'wait':0, 'score':0, 'hit':0}]
totalScore = 0
# Create socket to NXT brick
sock = BlueSock(ID)
def getTgt(self):
return self.tgt
def resetScore(self):
self.totalScore = 0
def getScore(self):
return self.totalScore
def resetTgt(self):
for i in range(3):
self.tgt[i]['score'] = 0
self.tgt[i]['wait'] = 0
self.tgt[i]['hit'] = 0
def getRoundScore(self):
total = 0
for t in self.tgt:
total += t['score']
return total
def getMaxWaitTime():
maxWT = 0
for t in self.tgt:
if maxWT < t['wait']:
maxWT = t['wait']
return maxWT
def openConnection(self):
# On success, socket is non-empty
if self.sock:
# Connect to brick
self.slave = self.sock.connect()
return True
else:
return False
def closeConnection(self):
if self.sock:
self.sock.close()
return True
else:
return False
def Cmd_EchoMsg(self, msg):
if self.slave:
cmdStr = "eo " + msg
self.slave.message_write(self.CHANNEL, cmdStr)
try:
time.sleep(0.01)
local_box, message = self.slave.message_read(self.MAILBOX+10, self.MAILBOX, True)
#print local_box, message
return message
except nxt.error.DirProtError, e:
pass
return ""
# Program to make NXT brick beep using NXT Python with Bluetooth socket
#
# Simon D. Levy CSCI 250 Washington and Lee University April 2011
# Change this ID to match the one on your brick. You can find the ID by doing Settings / NXT Version.
# You will have to put a colon between each pair of digits.
ID = '00:16:53:11:3D:03'
# This is all we need to import for the beep, but you'll need more for motors, sensors, etc.
from nxt.bluesock import BlueSock
# Create socket to NXT brick
sock = BlueSock(ID)
# On success, socket is non-empty
if sock:
# Connect to brick
brick = sock.connect()
# Play tone A above middle C for 1000 msec
brick.play_tone_and_wait(440, 1000)
# Close socket
sock.close()
# Failure
else:
print ('No NXT bricks found')
# Program to make NXT brick beep using NXT Python with Bluetooth socket # # Simon D. Levy CSCI 250 Washington and Lee University April 2011 # Change this ID to match the one on your brick. You can find the ID by doing Settings / NXT Version. # You will have to put a colon between each pair of digits. ID = '00:16:53:05:15:50' # This is all we need to import for the beep, but you'll need more for motors, sensors, etc. from nxt.bluesock import BlueSock # Create socket to NXT brick sock = BlueSock(ID) # Connect to brick brick = sock.connect() # Play tone A above middle C for 1000 msec brick.play_tone_and_wait(440, 1000) # Close socket sock.close() # EOF
from __future__ import print_function
from nxt.bluesock import BlueSock
from struct import unpack
bs = BlueSock("00:16:53:12:C0:CA:00")
bs.debug = True
bs.connect()
sock = bs.sock
for i in range(0, 2):
for j in range(0, 128):
try:
t = sock.recv(2)
(val,) = unpack("H", t)
print(val, end=",")
except Exception:
pass
#!/usr/bin/env python
#
# Converted from mary.rb found in ruby_nxt package
# Plays "Mary Had A Little Lamb"
# Author: Christopher Continanza <*****@*****.**>
from time import sleep
import nxt
ID = '00:16:53:17:41:FE'
IDD = '00:16:53:17:47:6F'
from nxt.bluesock import BlueSock
sock = BlueSock(ID)
b = sock.connect()
#b.stop_program()
b.start_program('hanse.rxe')
#b.StartProgram("kostwein.rxe")
sock.close;
