def main(argv=None):
# instantiate COMM object
comm = RobotComm(1, -50) #maxRobot = 1, minRSSI = -50
if comm.start():
print 'Communication starts'
else:
print 'Error: communication'
return
# instanciate Robot
robotList = comm.get_robotList()
global gFrame
gFrame = tk.Tk()
gFrame.geometry('600x500')
#gFrame.focus_set()
#gFrame.bind('<KeyPress>', joystick)
gRobotDraw = draw.RobotDraw(gFrame, tk)
# create behaviors using set
global gBehaviors
gBehaviors = {}
# gBehaviors[0] = color.Behavior("color", robotList)
# gBehaviors[1] = sound.Behavior("sound", robotList)
# gBehaviors[2] = motion.Behavior("motion", robotList, 10)
# gBehaviors[3] = proxy.Behavior("proxy", robotList, 85, 0.01, gRobotDraw.get_queue())
gBehaviors[0] = scanning.Behavior("scanning", robotList, 16.0, gRobotDraw.get_queue())
# start behavior threads using list
behavior_threads = []
for i in range(0, len(gBehaviors)):
gBehaviors[i].set_bQuit(False)
behavior_threads.append(threading.Thread(target=gBehaviors[i].behavior_loop, name = gBehaviors[i].get_name()))
for thread in behavior_threads:
thread.daemon = True
thread.start()
gRobotDraw.start()
gFrame.mainloop()
for behavior in behavior_threads:
print "joining... ", behavior.getName()
behavior.join()
print behavior.getName(), "joined!"
for robot in robotList:
robot.reset()
comm.stop()
comm.join()
print("terminated!")
def main(argv=None):
paths = getPaths(1000, 600, 500, 200)
drawList.append((500, 200))
drawList.append((1500, 200))
drawList.append((500, 800))
drawList.append((1500, 800))
# instantiate COMM object
comm = RobotComm(2, -50) #maxRobot = 1, minRSSI = -50
if comm.start():
print 'Communication starts'
else:
print 'Error: communication'
return
# instantiate Robot
robotList = comm.get_robotList()
# create behaviors using set
global gBehaviors
gBehaviors = {}
# start behavior threads using list
behavior_threads = []
behavior_threads.append(threading.Thread(target=command, args=(paths, robotList)))
for thread in behavior_threads:
thread.daemon = True
thread.start()
# start the cv thread
main_thread()
for behavior in behavior_threads:
print "joining... ", behavior.getName()
behavior.join()
print behavior.getName(), "joined!"
for robot in robotList:
robot.reset()
comm.stop()
comm.join()
print("terminated!")
def main(argv=None):
# instantiate COMM object
comm = RobotComm(1, -50) #maxRobot = 1, minRSSI = -50
if comm.start():
print 'Communication starts'
else:
print 'Error: communication'
return
# instantiate Robot
robotList = comm.get_robotList()
# instantiate global variables gFrame and gBehavior
settings.init()
settings.gFrame = tk.Tk()
settings.gFrame.geometry('600x500')
gRobotDraw = draw.RobotDraw(settings.gFrame, tk)
# create behaviors
settings.gBehaviors[0] = scanning.Behavior("scanning", robotList, 4.0, gRobotDraw.get_queue())
settings.gBehaviors[1] = collision.Behavior("collision", robotList, -50)
gRobotDraw.start()
settings.gFrame.mainloop()
for behavior in behavior_threads:
print "joining... ", behavior.getName()
behavior.join()
print behavior.getName(), "joined!"
for robot in robotList:
robot.reset()
comm.stop()
comm.join()
print("terminated!")
def main():
comm = RobotComm(gVars.gMaxRobotNum,-70) #maxRobot, minRSSI
comm.start()
print 'Bluetooth starts'
#instanciate robot list and GUI root
gVars.grobotList = comm.get_robotList()
gVars.m = tk.Tk() #root
drawQueue = Queue.Queue(0)
#creating the GUI canvas
canvas_width = 700 # half width
canvas_height = 300 # half height
rCanvas = tk.Canvas(gVars.m, bg="white", width=canvas_width*2, height=canvas_height*2)
#create the prisoner vitual robot
prisoner = pris_bot.Prisoner(comm, rCanvas)
# visual elements of the virtual robot
poly_points = [0,0,0,0,0,0,0,0]
prisoner.vrobot.poly_id = rCanvas.create_polygon(poly_points, fill='orange') #robot
prisoner.vrobot.prox_l_id = rCanvas.create_line(0,0,0,0, fill="red") #prox sensors
prisoner.vrobot.prox_r_id = rCanvas.create_line(0,0,0,0, fill="red")
prisoner.vrobot.floor_l_id = rCanvas.create_oval(0,0,0,0, outline="white", fill="white") #floor sensors
prisoner.vrobot.floor_r_id = rCanvas.create_oval(0,0,0,0, outline="white", fill="white")
update_pvrobot_thread = threading.Thread(target=prisoner.update_virtual_robot)
update_pvrobot_thread.daemon = True
update_pvrobot_thread.start()
#create the prisoner vitual robot
guard = guard_bot.Guard(comm, rCanvas)
# visual elements of the virtual robot
poly_points = [0,0,0,0,0,0,0,0]
guard.vrobot.poly_id = rCanvas.create_polygon(poly_points, fill='green') #robot
guard.vrobot.prox_l_id = rCanvas.create_line(0,0,0,0, fill="red") #prox sensors
guard.vrobot.prox_r_id = rCanvas.create_line(0,0,0,0, fill="red")
guard.vrobot.floor_l_id = rCanvas.create_oval(0,0,0,0, outline="white", fill="white") #floor sensors
guard.vrobot.floor_r_id = rCanvas.create_oval(0,0,0,0, outline="white", fill="white")
update_gvrobot_thread = threading.Thread(target=guard.update_virtual_robot)
update_gvrobot_thread.daemon = True
update_gvrobot_thread.start()
#create the virtual worlds that contains the virtual robot
vWorld = draw.virtual_world(drawQueue, prisoner.vrobot, guard.vrobot, rCanvas, canvas_width, canvas_height)
#objects in the world
rect_slider = [-150, 160, -60, 120]
rect_l1 = [-150, 0, -110, 120] #left 1
rect_l2 = [-112, -100, -110, -5] #left 2 (paper flap)
rect_b1 = [-250, -105, 265, -100] #back wall
rect_r1 = [260, -100, 265, 200] #right 1
rect_f1 = [-110, 100, -40, 105] #front 1
rect_f2 = [40, 100, 260, 105] #front 2
rect_lh = [-250, -100, -245, 210] #left hallway wall
rect_rh = [-150, 160, -145, 210]
vWorld.add_obstacle(rect_l1)
vWorld.add_obstacle(rect_l2)
vWorld.add_obstacle(rect_b1)
vWorld.add_obstacle(rect_r1)
vWorld.add_obstacle(rect_f1)
vWorld.add_obstacle(rect_f2)
vWorld.add_obstacle(rect_lh)
vWorld.add_obstacle(rect_rh)
vWorld.add_obstacle(rect_slider)
#create boundary for decoy box starting position
vWorld.add_boundary([50,0,170,80])
#start thread to draw the virtual world
draw_world_thread = threading.Thread(target=GUI.draw_virtual_world, args=(vWorld, prisoner, guard))
draw_world_thread.daemon = True
draw_world_thread.start()
graphics = GUI.VirtualWorldGui(vWorld, gVars.m)
#create FSM for guard
guard_fsm = guard_FSM.EventFsm()
print "Guard: Created the guard state machine. \n"
guard_FSM.build_states(guard_fsm, vWorld, guard)
guard_fsm.set_start("init")
guard_fsm.set_current("init")
#start thread to monitor events in guard FSM
guard_event_thread = threading.Thread(target=guard_FSM.monitor_events, args=(guard_fsm,))
guard_event_thread.daemon = True
guard_event_thread.start()
#start thread to run guard FSM
guard_fsm_thread = threading.Thread(target=guard_fsm.run)
guard_fsm_thread.daemon = True
guard_fsm_thread.start()
#create FSM for prisoner
pris_fsm = pris_FSM.EventFsm()
print "Prisoner: Ceated the prisoner state machine. \n"
pris_FSM.build_states(pris_fsm, vWorld, prisoner, guard_fsm)
pris_fsm.set_start("init")
pris_fsm.set_current("init")
#start thread to monitor events in prisoner FSM
pris_event_thread = threading.Thread(target=pris_FSM.monitor_events, args =(pris_fsm, prisoner, guard_fsm))
pris_event_thread.daemon = True
pris_event_thread.start()
#start thread to run prisoner FSM
pris_fsm_thread = threading.Thread(target=pris_fsm.run)
pris_fsm_thread.daemon = True
pris_fsm_thread.start()
rCanvas.after(200, graphics.updateCanvas, drawQueue)
gVars.m.mainloop()
print "Cleaning up"
#reset robot list and join active threads
for robot in gVars.grobotList:
robot.reset()
comm.stop()
comm.join()
if pris_event_thread.isAlive():
pris_event_thread.join(.5)
if pris_fsm_thread.isAlive():
pris_fsm_thread.join(.5)
if guard_event_thread.isAlive():
guard_event_thread.join(.5)
if guard_fsm_thread.isAlive():
guard_fsm_thread.join(.5)
if draw_world_thread.isAlive():
draw_world_thread.join(.5)
print "Goodbye."
