class application(object):
ENABLED = 0
DISABLED = 1
UNCHANGED = 2
def __init__(self):
app.soar = self
self.top = app.top
app.top.wm_title('soar' + soar.version.format_version())
app.top.protocol('WM_DELETE_WINDOW', self.exit)
self.initializeNamespace()
self.userfn = UserFunctionIF()
io.configure_io(self.namespace)
self.soar_toolbar_commands = formulae.FormulaPool()
self.flowtriplets = [(self.startstepper, self.step, self.stopstepper)]
soar_dir = soar.__path__[0]
self.readConfigFile()
if self.main_geom:
app.top.geometry(self.main_geom[self.main_geom.find('+'):])
media_dir = soar_dir + '/media'
self.toolbar = widgets.ToolbarFrame(app.top,
self.soar_toolbar_commands)
self.toolbar.pack(side=TOP)
start_images = {'normal': media_dir + "/start.gif"}
step_images = {'normal': media_dir + "/step.gif"}
stop_images = {'normal': media_dir + "/stop.gif"}
simulator_images = {'normal': media_dir + "/simulator.gif"}
eBot_images = {'normal': media_dir + "/eBot.gif"}
robot_images = {'normal': media_dir + "/robot.gif"}
brain_images = {'normal': media_dir + "/brain.gif"}
joystick_images = {'normal': media_dir + "/joystick.gif"}
oscillo_images = {'normal': media_dir + "/oscillo.gif"}
Amigo_simulator_images = {'normal': media_dir + "/simulator.gif"}
# if we're on the mac, the buttons won't stay pushed, so
# we have a different image to indicate active buttons
self.use_active_button_images = (platform.system() == 'Darwin')
if (self.use_active_button_images):
start_images['active'] = media_dir + "/start_active.gif"
stop_images['active'] = media_dir + "/stop_active.gif"
simulator_images['active'] = media_dir + "/simulator_active.gif"
eBot_images['active'] = media_dir + "/eBot_active.gif"
robot_images['active'] = media_dir + "/robot_active.gif"
brain_images['active'] = media_dir + "/brain_active.gif"
joystick_images['active'] = media_dir + "/joystick_active.gif"
oscillo_images['active'] = media_dir + "/oscillo_active.gif"
Amigo_simulator_images[
'active'] = media_dir + "/simulator_active.gif"
self.soar_toolbar_commands.addFormula(
('start', self.startall, 'Start', start_images, lambda: []))
self.soar_toolbar_commands.addFormula(
('step', self.stepall, 'Step', step_images, lambda: []))
self.soar_toolbar_commands.addFormula(
('stop', self.stopall, 'Stop', stop_images, lambda: []))
self.pushToolbarButton('stop')
self.disableToolbarButton('start')
self.disableToolbarButton('step')
Label(self.toolbar, text="Outputs:").pack(side=LEFT)
#self.simulator_dir_default = soar_dir + "/6.01/worlds"
self.soar_toolbar_commands.addFormula(
('simulator', self.openSimulator, 'Simulator', simulator_images,
self.openSimulatorDialog))
self.soar_toolbar_commands.addFormula(
('Amigosimulator', self.openAmigoSimulator, 'AmigoSimulator',
Amigo_simulator_images, self.openAmigoSimulatorDialog))
#self.soar_toolbar_commands.addFormula(('pioneer', self.openPioneer,
# 'Pioneer', robot_images,
# lambda: []))
self.soar_toolbar_commands.addFormula(
('eBot', self.openEBot, 'eBot', eBot_images, lambda: []))
#CHANGED: robot name
self.soar_toolbar_commands.addFormula(
('pioneer', self.openPioneer, 'Amigobot', robot_images,
lambda: []))
Label(self.toolbar, text="Controls:").pack(side=LEFT)
#self.brain_dir_default = '~'
self.soar_toolbar_commands.addFormula(
('brain', self.openBrain, 'Brain', brain_images,
self.openBrainDialog))
self.disableToolbarButton('brain')
#CHANGED: commented out
#self.soar_toolbar_commands.addFormula(('joystick', self.openJoystick,
# 'Joystick', joystick_images,
# lambda: []))
#self.disableToolbarButton('joystick')
# self.soar_toolbar_commands.addFormula(('oscillo', self.openOscillo,
# ' Oscilloscope ', oscillo_images,
# lambda: []))
self.minibuffer = widgets.MiniBuffer(app.mainframe,
self.namespace,
width=78)
self.minibuffer.pack(side=TOP, fill=X, expand=1)
self.stderrbuffer = None
# self.stderrframe = app.tabframe.addFrameWithHideCB("errors",
# self.clearErrors)
# self.stderrframe = app.tabframe.addFrame("errors")
self.stderrbuffer = widgets.OutputBufferFrame(
app.mainframe) #self.stderrframe)
self.stderrbuffer.box_.config(foreground='red')
self.stderrbuffer.pack(fill=BOTH, expand=1)
sys.stderr = parallel.PipeSyndicator([sys.stderr, self.stderrbuffer])
self.clearErrors()
self.stdoutbuffer = None
# self.stdoutframe = app.tabframe.addFrameWithHideCB("standard output",
# self.clearOutput)
# self.stdoutframe = app.tabframe.addFrame("standard output")
self.stdoutbuffer = widgets.OutputBufferFrame(
app.mainframe) #self.stdoutframe)
self.stdoutbuffer.pack(fill=BOTH, expand=1)
sys.stdout = parallel.PipeSyndicator([sys.stdout, self.stdoutbuffer])
self.clearOutput()
self.reloadAllButton = Button(app.mainframe,
text="Reload Brain and World",
command=self.reloadAll)
self.reloadAllButton.pack()
self.disableButton(self.reloadAllButton)
self.reloadBrainButton = Button(app.mainframe,
text="Reload Brain",
command=self.reloadBrain)
self.reloadBrainButton.pack()
self.brainfile = ""
self.disableButton(self.reloadBrainButton)
#self.reloadWorldButton = Button(app.mainframe, text="Reload World",
# command = self.reloadWorld)
#self.reloadWorldButton.pack()
#self.disableButton(self.reloadWorldButton)
self.sonar_monitor = None
self.oscope = None
self.control = None
self.output = None
self.readfile = False
self.writefile = False
def readConfigFile(self):
# defaults for if no file exists
self.simulator_dir_default = soar.__path__[0] + "/worlds"
self.brain_dir_default = '~'
self.main_geom = None
self.simulator_geom = None
self.scope_geom = None
self.sonarmon_geom = None
homedir = os.path.expanduser('~')
homedir.replace('\\', '/')
try:
f = open(homedir + "/.soarc")
except:
# it's okay if there's no config file; we'll write one at the end
return
vars = {}
for line in f.readlines():
if '=' in line:
key, value = list(map(str.strip, line.split('=', 1)))
vars[key] = value
f.close()
if 'OPEN_PATH' in vars and os.path.exists(vars['OPEN_PATH']):
self.brain_dir_default = vars['OPEN_PATH']
if 'WORLD_PATH' in vars and os.path.exists(vars['WORLD_PATH']):
self.simulator_dir_default = vars['WORLD_PATH']
# get geometry for the windows for each standard widget
if 'MAIN_GEOM' in vars: self.main_geom = vars['MAIN_GEOM']
if 'SIM_GEOM' in vars: self.simulator_geom = vars['SIM_GEOM']
if 'SCOPE_GEOM' in vars: self.scope_geom = vars['SCOPE_GEOM']
if 'SONAR_MON_GEOM' in vars:
self.sonarmon_geom = vars['SONAR_MON_GEOM']
def writeConfigFile(self):
homedir = os.path.expanduser('~')
homedir.replace('\\', '/')
try:
f = open(homedir + "/.soarc", "w")
f.write('%s=%s\n' % ('OPEN_PATH', self.brain_dir_default))
f.write('%s=%s\n' % ('WORLD_PATH', self.simulator_dir_default))
f.write('%s=%s\n' % ('MAIN_GEOM', self.top.geometry()))
if self.simulator_geom:
f.write('%s=%s\n' % ('SIM_GEOM', self.simulator_geom))
if self.scope_geom:
f.write('%s=%s\n' % ('SCOPE_GEOM', self.scope_geom))
if self.sonarmon_geom:
f.write('%s=%s\n' % ('SONAR_MON_GEOM', self.sonarmon_geom))
except:
sys.stderr.write("Could not write soar config file .soarc\n")
def exit(self):
# askyesno seems to be broken in current Tk (always returns False)
#answer = form.widgets.askyesno("Exit", "Are you sure you want to exit?")
answer = form.widgets.askquestion("Exit",
"Are you sure you want to exit?")
if answer == 'no':
return
try:
self.stopall()
except:
pass
try:
self.unloadModule(self.control)
except:
pass
try:
self.unloadModule(self.output)
except:
pass
self.closeSonarMonitor()
self.closeOscillo()
self.writeConfigFile()
form.main.tk.destroy()
form.main.sys.exit(0)
def clearErrors(self):
self.stderrbuffer.clear()
sys.stderr.write("Error output will appear in this window.\n")
def clearOutput(self):
self.stdoutbuffer.clear()
print("Ordinary output will appear in this window.")
def openSimulator(self, world):
import soar.outputs.simulator
if (len(world) > 0):
#self.enableButton(self.reloadWorldButton)
# do this before we try to read the file so we can reload even
# if there is an error in the file
if self.control:
self.enableButton(self.reloadAllButton)
try:
self.setOutput(lambda: \
soar.outputs.simulator.Simulator(world,
self.simulator_geom))
except:
sys.stderr.write(
"Error loading world. Perhaps you accidentally chose a brain file?\n"
)
return
self.pushToolbarButton('simulator')
self.unpushToolbarButton('Amigosimulator')
self.unpushToolbarButton('pioneer')
self.unpushToolbarButton('eBot')
self.unpushToolbarButton('brain')
#CHANGED commented out
#self.unpushToolbarButton('joystick')
self.reloadBrain(True)
def openAmigoSimulator(self, world):
import soar.outputs.amigo_simulator
if (len(world) > 0):
#self.enableButton(self.reloadWorldButton)
# do this before we try to read the file so we can reload even
# if there is an error in the file
if self.control:
self.enableButton(self.reloadAllButton)
try:
self.setOutput(lambda: \
soar.outputs.amigo_simulator.amigo_simulator(world,
self.simulator_geom))
except:
sys.stderr.write(
"Error loading world. Perhaps you accidentally chose a brain file?\n"
)
return
self.pushToolbarButton('Amigosimulator')
self.unpushToolbarButton('simulator')
self.unpushToolbarButton('pioneer')
self.unpushToolbarButton('eBot')
self.unpushToolbarButton('brain')
#CHANGED commented out
#self.unpushToolbarButton('joystick')
self.reloadBrain(True)
def openEBot(self):
import soar.outputs.eBot
# allow pioneer button to be unpushed to disconnect
if self.toolbar.buttons['eBot'].cget('relief') == SUNKEN:
self.closeEBot(False)
else:
if self.setOutput(lambda: soar.outputs.eBot.eBot()):
sys.stderr.write("Set output to eBot.\n")
#self.disableButton(self.reloadWorldButton)
self.disableButton(self.reloadAllButton)
# allowing reinit to pioneer is most likely to cause crashing, so don't
self.pushToolbarButton('eBot', self.ENABLED)
self.enableToolbarButton('brain')
#CHANGED commented out
#self.enableToolbarButton('joystick')
# can't step the real robot
self.disableToolbarButton('step')
if self.brainfile != "":
self.enableButton(self.reloadBrainButton)
self.enableButton(self.reloadAllButton)
self.unpushToolbarButton('simulator')
self.unpushToolbarButton('Amigosimulator')
self.reloadBrain(True)
# print "Hello"
# import soar.outputs.eBotDemo
#from soar.outputs.eBotDemo import eBotDemo
#eBotDemo()
def closeEBot(self, callUserFn=True):
self.stopall(callUserFn)
self.setOutput(lambda: None)
self.unpushToolbarButton('eBot')
# don't have output, so disable brain loading
#CHANGED commented out
#self.disableToolbarButton('joystick')
self.disableToolbarButton('brain')
self.disableButton(self.reloadBrainButton)
self.disableButton(self.reloadAllButton)
def openPioneer(self):
import soar.outputs.pioneer
# allow pioneer button to be unpushed to disconnect
if self.toolbar.buttons['pioneer'].cget('relief') == SUNKEN:
self.closePioneer(False)
else:
if self.setOutput(lambda: soar.outputs.pioneer.Pioneer()):
#self.disableButton(self.reloadWorldButton)
self.disableButton(self.reloadAllButton)
# allowing reinit to pioneer is most likely to cause crashing, so don't
self.pushToolbarButton('pioneer', self.ENABLED)
self.enableToolbarButton('brain')
#CHANGED commented out
#self.enableToolbarButton('joystick')
# can't step the real robot
self.disableToolbarButton('step')
if self.brainfile != "":
self.enableButton(self.reloadBrainButton)
self.enableButton(self.reloadAllButton)
self.unpushToolbarButton('simulator')
self.reloadBrain(True)
def closePioneer(self, callUserFn=True):
self.stopall(callUserFn)
self.setOutput(lambda: None)
self.unpushToolbarButton('pioneer')
# don't have output, so disable brain loading
#CHANGED commented out
#self.disableToolbarButton('joystick')
self.disableToolbarButton('brain')
self.disableButton(self.reloadBrainButton)
self.disableButton(self.reloadAllButton)
def openBrain(self, brainfile, reload=False):
import soar.controls.brain
if (len(brainfile) > 0):
# clear error, output windows
self.clearOutput()
self.clearErrors()
if (reload):
print("***Reloading Brain***")
else:
print("***Loading Brain***")
print("'" + brainfile + "'")
self.setControl(
lambda: soar.controls.brain.Brain(brainfile, reload),
not reload)
if self.control:
self.pushToolbarButton('brain', self.ENABLED)
self.enableButton(self.reloadBrainButton)
self.chooseStop(self.output != None)
if self.output:
#CHANGED commented out
#self.unpushToolbarButton('joystick')
self.enableButton(self.reloadAllButton)
print("Successfully loaded brain file")
print("'" + brainfile + "'")
else:
#self.disableButton(self.reloadBrainButton)
print("Failed to load brain file '" + brainfile + "'")
def reloadAll(self):
self.reloadWorld()
self.reloadBrain()
def reloadBrain(self, quiet=False):
if self.brainfile == "" and not quiet:
sys.stderr.write("No valid brain filename to reload.\n")
if self.control is not None:
try:
self.control.reload()
except AttributeError:
# we must have tried to reload the joystick (yes, this is ugly)
if self.brainfile != "":
self.openBrain(self.brainfile, True)
# if we failed, and we have a brainfile, just try loading the brain
# as opposed to REloading
if self.control is None and self.brainfile != "":
self.openBrain(self.brainfile, False)
def reloadWorld(self):
if self.output is not None:
try:
self.output.initGlobals(True)
except AttributeError:
pass
def openSonarMonitor(self):
if not self.sonar_monitor:
if self.toolbar.buttons['eBot'].cget('relief') == SUNKEN:
self.sonar_monitor = SonarMonitor(
soar.outputs.eBot.EBOT_POINTS, self.sonarmon_geom)
elif self.toolbar.buttons['Amigosimulator'].cget(
'relief') == SUNKEN:
self.sonar_monitor = AmigoSonarMonitor(
soar.outputs.amigo_simulator.ROBOT_POINTS,
self.sonarmon_geom)
elif self.toolbar.buttons['simulator'].cget('relief') == SUNKEN:
self.sonar_monitor = SonarMonitor(
soar.outputs.simulator.ROBOT_POINTS, self.sonarmon_geom)
elif self.toolbar.buttons['pioneer'].cget('relief') == SUNKEN:
self.sonar_monitor = AmigoSonarMonitor(
soar.outputs.amigo_simulator.ROBOT_POINTS,
self.sonarmon_geom)
self.sonar_monitor.openWindow()
def closeSonarMonitor(self):
if self.sonar_monitor:
self.sonar_monitor.closeWindow()
self.sonar_monitor = None
def openJoystick(self):
import soar.controls.joystick
self.setControl(lambda: soar.controls.joystick.Joystick())
#CHANGED commented out
#self.pushToolbarButton('joystick')
self.unpushToolbarButton('brain')
def closeOscillo(self):
if self.oscope:
self.oscope.closeWindow()
self.oscope = None
def openOscillo(self):
if not self.oscope:
self.oscope = Oscilloscope(self.scope_geom)
self.oscope.openWindow()
def add_scope_probe_function(self, name, func):
self.oscope.add_probeFunction(name, func)
def clear_scope(self):
if self.oscope:
self.oscope.clearProbes()
self.oscope.closeWindow()
def openSimulatorDialog(self):
filename = widgets.askopenfilename(
title="Open a World File...",
initialdir=self.simulator_dir_default,
filetypes=[("World Files", "*.py")])
if (len(filename) > 0):
self.simulator_dir_default = filename[0:filename.rfind("/")]
return [filename]
def openAmigoSimulatorDialog(self):
filename = widgets.askopenfilename(
title="Open a World File...",
initialdir=self.simulator_dir_default,
filetypes=[("World Files", "*.py")])
if (len(filename) > 0):
self.simulator_dir_default = filename[0:filename.rfind("/")]
return [filename]
def openBrainDialog(self):
filename = widgets.askopenfilename(title="Open a Brain File...",
initialdir=self.brain_dir_default,
filetypes=[("Brain Files", "*.py")])
self.brainfile = filename
if (len(filename) > 0):
self.brain_dir_default = filename[0:filename.rfind("/")]
os.chdir(self.brain_dir_default)
self.enableButton(self.reloadBrainButton)
return [filename]
def removeFlowTriplet(self, trip):
self.flowtriplets.remove(trip)
def addFlowTriplet(self, trip):
self.flowtriplets.append(trip)
def setReadLog(self, f):
self.control.readfile = open(f, 'rb')
def setWriteLog(self, f):
self.control.writefile = open(f, 'wb')
def enableToolbarButton(self, name):
self.enableButton(self.toolbar.buttons[name])
def disableToolbarButton(self, name):
self.disableButton(self.toolbar.buttons[name])
def pushToolbarButton(self, name, state=DISABLED):
self.pushButton(self.toolbar.buttons[name], state)
self.toolbar.buttonImage(name, 'active')
def unpushToolbarButton(self, name, state=ENABLED):
self.unpushButton(self.toolbar.buttons[name], state)
self.toolbar.buttonImage(name, 'normal')
def flashToolbarButton(self, name):
self.toolbar.buttons[name].flash()
def enableButton(self, button):
button.config(state=NORMAL)
def disableButton(self, button):
button.config(state=DISABLED)
def buttonState(self, button, state):
if state == self.DISABLED:
self.disableButton(button)
elif state == self.ENABLED:
self.enableButton(button)
def pushButton(self, button, state=DISABLED):
button.config(relief=SUNKEN)
self.buttonState(button, state)
def unpushButton(self, button, state=ENABLED):
button.config(relief=RAISED)
self.buttonState(button, state)
def chooseStart(self):
self.pushToolbarButton('start')
self.unpushToolbarButton('stop')
self.pushToolbarButton('step')
# can't choose control or output while running
self.disableToolbarButton('simulator')
self.disableToolbarButton('pioneer')
self.disableToolbarButton('brain')
#CHANGED commented out
#self.disableToolbarButton('joystick')
self.disableButton(self.reloadBrainButton)
self.disableButton(self.reloadAllButton)
def chooseStop(self, allowStart=1):
if (allowStart):
self.unpushToolbarButton('start')
self.unpushToolbarButton('step')
else:
self.unpushToolbarButton('start', self.DISABLED)
self.unpushToolbarButton('step', self.DISABLED)
self.unpushToolbarButton('stop', self.DISABLED)
# now we can choose control and output again
self.enableToolbarButton('simulator')
self.enableToolbarButton('Amigosimulator')
self.enableToolbarButton('pioneer')
self.enableToolbarButton('brain')
#CHANGED commented out
#self.enableToolbarButton('joystick')
if self.brainfile != "":
self.enableButton(self.reloadBrainButton)
self.enableButton(self.reloadAllButton)
def disableStartStop(self):
self.unpushToolbarButton('start', self.DISABLED)
self.unpushToolbarButton('stop', self.DISABLED)
self.unpushToolbarButton('step', self.DISABLED)
def setControl(self, lazy_control, allow_start=1):
if self.readfile:
self.readfile.close()
if self.writefile:
self.writefile.close()
self.unloadModule(self.control)
# try to read in the brain file. if it fails, unload the module
try:
self.control = lazy_control()
except Exception as e:
self.disableStartStop()
self.unloadModule(self.control)
self.control = None
raise e
self.readfile = False
self.writefile = False
# if we did read in the file, try to call the setup function
# if the setup function fails, unload the module
if self.control != None:
try:
self.userfn.call_functions('setup')
self.loadModule(self.control)
except:
self.unloadModule(self.control)
self.control = None
if ((self.output != None) and allow_start):
self.chooseStop(True)
elif (self.output is None):
self.disableStartStop()
def setOutput(self, lazy_output):
self.unloadModule(self.output)
try:
self.output = lazy_output()
if self.output == None:
self.disableStartStop()
return 0
else:
self.loadModule(self.output)
self.logstep()
if (self.control != None):
self.chooseStop(True)
else:
self.disableStartStop()
return 1
except common.CancelGUIAction:
self.output = None
self.disableStartStop()
return 0
def register_user_function(self, type, f):
self.userfn.registerFn(type, f)
def initializeNamespace(self):
if hasattr(self, 'namespace'):
self.namespace.clear()
else:
self.namespace = {}
self.setters = {}
self.getters = {}
self.cachedvalues = {}
self.namespace["robot"] = common.Container()
self.namespace["readLog"] = self.setReadLog
self.namespace["writeLog"] = self.setWriteLog
self.namespace["register_user_function"] = self.register_user_function
def startall(self):
for i in self.flowtriplets:
i[0]()
self.chooseStart()
try:
self.userfn.call_functions('brain_start')
self.control.start()
except AttributeError:
pass
self.disableButton(self.reloadBrainButton)
self.disableButton(self.reloadAllButton)
if (self.use_active_button_images):
self.flashToolbarButton('stop')
def stopall(self, callUserFn=True):
for i in self.flowtriplets:
i[2]()
self.chooseStop()
try:
if callUserFn:
self.userfn.call_functions('brain_stop')
except AttributeError:
pass
try:
self.control.stop()
except AttributeError:
pass
if self.brainfile != "":
self.enableButton(self.reloadBrainButton)
self.enableButton(self.reloadAllButton)
if (self.use_active_button_images):
self.flashToolbarButton('start')
def stepall(self, dt=0.1):
for i in self.flowtriplets:
i[1](dt)
def stopstepper(self):
try:
self.currentstepper.stop()
except AttributeError:
pass
def startstepper(self):
self.stopstepper()
self.currentstepper = parallel.Stepper(self.step, 20.0)
self.currentstepper.start()
def logstep(self):
if self.readfile:
try:
for pair in pickle.load(self.readfile):
self.cachedvalues[pair[0]].set(pair[1])
except KeyError:
app.alert("Log from an incompatible getter/setter interface")
self.stopall()
except EOFError:
app.alert("Log Finished")
self.stopall()
else:
for k in self.getters:
try:
self.cachedvalues[k].set(self.getters[k]())
except:
common.formerror()
if self.writefile:
pickle.dump([(k, self.cachedvalues[k].get())
for k in self.cachedvalues[k]], self.writefile)
def step(self, dt):
if self.output is not None:
try:
self.userfn.call_functions('step')
if self.sonar_monitor:
self.sonar_monitor.update(self.output.storedsonars.get())
if self.oscope: self.oscope.step()
self.logstep()
self.control.step(dt)
except KeyError:
common.formerror()
# self.stopall()
except:
self.stopall()
#raise
def unloadModule(self, obj):
if (obj == None):
return
try:
self.userfn.call_functions('shutdown')
obj.shutdown()
self.userfn.clearFunctions()
except:
pass
try:
for name in obj.getters:
self.getters.pop(name)
self.namespace.pop(name)
except AttributeError:
pass
try:
for name in obj.setters:
self.setters.pop(name)
self.namespace.pop(name)
except AttributeError:
pass
try:
obj.destroy()
except AttributeError:
pass # OK if modules have no cleanup code
except:
common.formerror()
def loadModule(self, obj):
try:
for name in obj.getters:
self.getters[name] = obj.getters[name]
self.cachedvalues[name] = parallel.SharedVar()
self.namespace[name] = self.cachedvalues[name].get
except AttributeError:
obj.getters = {}
try:
for name in obj.setters:
self.setters[name] = obj.setters[name]
self.namespace[name] = obj.setters[name]
except AttributeError:
obj.setters = {}
try:
obj.setup()
except AttributeError:
pass
