def test_login(self):
a = Authentication(self.test_db)
c = Controller(self.test_db)
a.create_user('employee', 'user1')
self.assertTrue(c.login('user1', '12345'))
def __init__(self, root, state=None):
self.root = root
ShetClient.__init__(self)
Controller.__init__(self, state)
self.add_action("set_state", self.set_state)
def test_get_user_id(self):
c = Controller(self.test_db)
cl_id = c.create_client('user1')
cl_data = c.get_client('id', cl_id)[0]
self.assertEqual(cl_id, cl_data['id'])
def main():
"""
Quick game setup for testing purposes.
"""
win = pygcurse.PygcurseWindow(80, 30)
win.font = pygame.font.Font(pygame.font.match_font("consolas"), 18)
level1 = Dungeon.load_from_file("map/bigmap.txt")
player = Player(1, 1)
level1.add_player(player)
msgbox = MessageBox()
view = GameView(
win, {ScrollingView(level1): (0, 0), HUDView(player): (700, 0), MessageBoxView(msgbox, 80, 5): (0, 460)}
)
controller = Controller(level1, msgbox, view)
win.autoupdate = False
mainClock = pygame.time.Clock()
running = True
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
else:
controller.process_event(event)
controller.view.draw()
win.blittowindow()
mainClock.tick(30)
pygame.quit()
sys.exit()
def __init__(self, parent):
Cell.__init__(self, parent)
Controller.__init__(self, self.parent.canvas, parent)
self.offset_x = 0
self.offset_y = 0
self.update_request = False
self.old_zoom = False
def load_controller(botengine):
"""
Load the Controller object
:param botengine: Execution environment
"""
logger = botengine.get_logger()
try:
controller = botengine.load_variable("controller")
logger.info("Loaded the controller")
except:
controller = None
logger.info("Unable to load the controller")
if controller == None:
botengine.get_logger().info("Bot : Creating a new Controller object. Hello.")
controller = Controller()
botengine.save_variable("controller", controller, required_for_each_execution=True)
import importlib
try:
analytics = importlib.import_module('analytics')
analytics.get_analytics(botengine).track(botengine, 'reset')
except ImportError:
pass
controller.track_new_and_deleted_devices(botengine)
controller.initialize(botengine)
return controller
def main(_):
import pprint
pprint.pprint(FLAGS.__flags)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as session:
model = Controller(
session,
is_training=FLAGS.is_train,
save_dir=FLAGS.save_dir,
dataset_name=FLAGS.dataset,
checkpoint_dir=FLAGS.checkpoint_dir,
size_batch=FLAGS.batch_size,
y_dim=FLAGS.y_dim,
rb_dim=FLAGS.rb_dim,
is_simple_q=FLAGS.is_simple_q,
num_z_channels=FLAGS.z_dim
)
if FLAGS.is_train:
print '\n\tTraining Mode'
model.train(
num_epochs=FLAGS.epoch,
)
else:
print '\n\tVisualization Mode'
model.custom_visualize(testing_samples_dir=FLAGS.test_dir + '/*.jpeg')
class Simulator:
def __init__(self):
self._drone = Drone()
self._controller = Controller(self._drone)
self._loop = asyncio.get_event_loop()
self._drone.set_init([0., 0., 0.], [2., 0., 0.])
# self._AOO = []
# self._drone.dt = 5e-4
# self._drone.noise_z = 1e-10
def run(self):
logger.info('starting simulation...')
self._loop.run_until_complete(self._controller.takeoff())
self._loop.call_soon_threadsafe(
self._loop.create_task,
self._controller.run()
)
logger.info('started.')
@asyncio.coroutine
def get_data(self):
pos = self._drone.get_position()
ori = self._drone.rot
# oori = ori[:, 2]
# self._AOO.append(self._drone.acc_sensor[2])
# self._AOO.append(oori)
return pos, ori
@asyncio.coroutine
def stop(self):
yield from self._controller.stop()
yield from self._drone.stop()
def mainloop(self):
self.clock = pygame.time.Clock()
self.player.rect.center = [self.display.arena[0]/2, self.display.arena[1]/2]
controller = Controller()
while self.gameRunning:
dirty = []
self.clock.tick(FPS)
self.framerate = self.clock.get_fps()
self.display.paint_background(dirty)
self.player.state.set_current_state(self)
d = self.display.paint_sprite(self.player)
dirty.insert(len(dirty), d)
self.steine.update()
self.ladders.update()
self.barrels.update()
self.meanies.update(dirty)
self.hud.showinfo(self, dirty)
controller.handle_keyboard_input(self.player)
self.player.update()
pygame.display.update(dirty)
def _handle(self, sock):
while True:
header_length = struct.calcsize(self._header)
header_buffer = self._recv_n(sock, header_length)
if header_buffer is None:
break
controller_length, = struct.unpack(self._header, header_buffer)
controller_buffer = self._recv_n(sock, controller_length)
if controller_buffer is None:
break
controller = Controller()
controller.sock = sock
try:
controller.proto.ParseFromString(controller_buffer)
except DecodeError:
continue
if not controller.proto.stub:
self._handle_response(controller)
elif controller.proto.notify:
self._handle_notify(controller)
else:
self._handle_request(controller)
def __init__(self, event_manager, server_url=None):
# Setup inital states
Controller.__init__(self, event_manager)
self._server_url = server_url
self.system_state = SystemState.ARMED
self.user_list = []
self.input_devices = []
self.door_timer_delay = DOOR_EVENT_TIMER_DELAY
# Load the event handlers functions into a dictionary to make calling
# the appropriate function easier through the enum
self.event_handling_functions = {
EventType.DOOR_SENSOR_EVENT: self._handle_door_event,
EventType.WINDOW_SENSOR_EVENT: self._handle_window_event,
EventType.FLOOD_SENSOR_EVENT: self._handle_flood_event,
EventType.TEMP_SENSOR_EVENT: self._handle_temp_event,
EventType.MOTION_SENSOR_EVENT: self._handle_motion_event,
EventType.ALARM_EVENT: self._handle_alarm_event,
EventType.KEYPAD_EVENT: self._handle_keypad_event,
EventType.NFC_EVENT: self._handle_nfc_event,
}
# Subscribe to events
if self.event_manager is not None:
for event_type in self.event_handling_functions.keys():
self.event_manager.subscribe(event_type, self)
def run(self, curr_dims=(1600, 875)):
"""
function that runs the game. like the cpu of the game. kind of.
"""
rand_outer = [0., pi/2., pi, 3.*pi/2.]
curr_polypos = [[rand_outer[randint(0, 3)], randint(1, 2), 2, (200, 200, 230)], [rand_outer[randint(0, 3)], randint(3, 4), 2, (200, 200, 230)]]
screen, buttons, polys = self.init(curr_dims, polypos=curr_polypos)
control = Controller()
curr_highScore = 2
while True:
pg.event.pump()
for event in pg.event.get():
if event.type == QUIT:
self.quit()
elif event.type == VIDEORESIZE:
curr_dims = (event.w, event.h)
screen, buttons, polys = self.init(curr_dims, polypos=curr_polypos)
elif event.type == MOUSEBUTTONUP:
for i, butt in enumerate(buttons):
buttNumb = butt.liveButton(i)
if buttNumb == 0:
print "new game"
self.run(curr_dims=curr_dims)
else:
break
elif event.type == KEYDOWN:
if event.key != K_ESCAPE:
curr_polypos, curr_highScore = control.keys(event, polys, curr_highScore)
if curr_highScore > self.highScore:
self.highScore = curr_highScore
screen, buttons, polys = self.init(curr_dims, polypos=curr_polypos)
else:
self.quit()
pg.display.update()
class PachongWin(object):
def run(self):
self.root=Tkinter.Tk()
title='%s爬虫控制窗口'%settings.S_target_website
self.root.title(title)
#画界面
self.root.geometry('190x80')
self.f = Tkinter.Frame(self.root)
self.b_start=Tkinter.Button(self.f,text='启动',command=self.start)
self.b_start.config(height=3,width=10)
self.b_start.pack()
self.b_stop=Tkinter.Button(self.f,text='退出',state=Tkinter.DISABLED,command=self.stop)
self.b_stop.config(height=3,width=10)
self.b_stop.pack()
self.f.pack()
Tkinter.mainloop()
def start(self):
self.controller=Controller()
self.controller.start()
self.b_start.config(state=Tkinter.DISABLED)
while not self.controller.engine_is_running:
pass
self.b_stop.config(state=Tkinter.ACTIVE)
def stop(self):
self.controller.stop()
self.b_stop.config(state=Tkinter.DISABLED)
while True:
t_list=[t for t in self.controller.eng.threads if t.is_running==False]
if len(t_list)==len(self.controller.eng.threads):
break;
self.b_start.config(state=Tkinter.ACTIVE)
class Watcher(object):
def __init__(self, logger):
os.chdir("../")
self.programPath = os.getcwd()
os.chdir("app")
self.__fs = FileSystem(".")
self.__utils = Utils()
self.__config = Config(fileSystem=self.__fs)
self.__db = None
self.__controller = None
self.__feeder = None
self.__webServer = None
self.__logger = logger
self.__configWatcher = None
self.__stompClient = None
dbName = self.__config.watcher.get("db", "sqlite")
sys.path.insert(0, "../db/%s" % dbName)
Database = __import__(dbName).Database
dbFileName = self.__config.watcher.get("dbFile", "queue.db")
print "Starting file watcher..."
#------------------------
self.__db = Database(dbFileName)
self.__controller = Controller(self.__db, self.__fs, self.__config, \
FileWatcher, WatchDirectory, update=False)
#self.__controller.configChanged(config)
#self.__config.addReloadWatcher(self.__controller.configChanged)
if self.__config.messaging.enabled:
self.__stompClient = StompClient(self.__config, self.__utils)
def stompListener(file, eventTime, eventName, isDir):
if not isDir:
try:
self.__stompClient.queueUpdate(file, eventName)
except Exception, e:
msg = "ERROR in stompClient.queueUpdate('%s', '%s) - '%s'"
print msg % (file, eventName, str(e))
self.__controller.addListener(stompListener)
## Log events
def logCallback(file, eventTime, eventName, isDir):
tStr = time.strftime("%Y%m%dT%H:%M:%S", time.localtime(eventTime))
print "%s \t%s \t%s \t%s" % (tStr, eventName, isDir, file)
self.__controller.addListener(logCallback)
##
self.__configWatcher = FileWatcher(self.__config.configFile, self.__fs)
self.__configWatcher.startWatching()
def configChanged(file, eventName, **kwargs):
#file=path, eventTime=eventTime, eventName=eventName, isDir=isDir, walk=False
if eventName!="del" and file==self.__config.configFile:
print "configChanged - reloading"
self.__config.reload()
self.__controller.configChanged(self.__config)
self.__configWatcher.addListener(configChanged)
self.__feeder = Feeder(self.__utils, self.__controller)
feedservice = self.__config.watcher.get("feedservice", {})
self.host = feedservice.get("host", "*")
self.port = feedservice.get("port", 9000)
s = webServe(self.host, self.port, self.__feeder)
self.__webServer = s
class GUI(Tk):
"represents GUI"
def __init__(self):
super().__init__()
self.title("CM Manager " + ".".join(version()))
self.option_add("*tearOff", FALSE)
self.resizable(FALSE, FALSE)
'''
# used when size of the window is changed for placeWindow arguments
self.after(250, lambda: print(self.winfo_width()))
self.after(250, lambda: print(self.winfo_height()))
'''
placeWindow(self, 1010, 834)
# notebook
self.selectFunction = ttk.Notebook(self)
self.selectFunction.grid()
# FileStorage is associated with the Notebook
self.selectFunction.fileStorage = FileStorage()
self.processor = Processor(self.selectFunction)
self.explorer = Explorer(self.selectFunction)
self.controller = Controller(self.selectFunction)
notepageWidth = 20
self.selectFunction.add(self.processor, text = "{:^{}}".format("Process", notepageWidth))
self.selectFunction.add(self.explorer, text = "{:^{}}".format("Explore", notepageWidth))
self.selectFunction.add(self.controller, text = "{:^{}}".format("Control", notepageWidth))
self.selectFunction.bind("<<NotebookTabChanged>>", lambda e: self.checkProcessing(e))
# menu
self["menu"] = MenuCM(self)
if not optionGet("Developer", False, 'bool'):
self.protocol("WM_DELETE_WINDOW", self.closeFun)
self.mainloop()
def closeFun(self):
"ask for saving files on exit"
if doesFileStorageRequiresSave(self):
answ = messagebox.askyesno(message = "Do you want to save files before leaving?",
icon = "question", title = "Save files?")
if answ:
saveFileStorage(self)
self.destroy()
def checkProcessing(self, event):
"""checks whether it is possible for processor and controller to process files and change
states of buttons accordingly"""
self.processor.checkProcessing()
self.controller.checkProcessing()
self.explorer.checkProcessing()
def __init__(self, source, size):
"""Default constructor.
:param source: Path of the source file the neuron will be created from.
:param size: Number of neuron to be created through this controller.
"""
Controller.__init__(self, size, "Creating neurons")
self.source = source
def __init__(self, params):
'''Initialize internal variables'''
Controller.__init__(self,params)
# This angle shows the direction that the controller
# tries to follow. It is used by the supervisor
# to draw and debug this controller
self.heading_angle = 0
def test_create_task(self):
c = Controller(self.test_db)
task_id = c.create_task(subject='Underwater photos', priority='Medium')
task_data = c.get_task('id', task_id)[0]
self.assertEqual('Underwater photos', task_data['subject'])
self.assertEqual('Medium', task_data['priority'])
def unittest():
from controller import Controller
from fake_robot import FakeRobot
fake_robot = FakeRobot()
controller = Controller(fake_robot)
controller.app = DummyApp()
syncer = SyncToServer('http://localhost:8080/api/', 5, controller)
syncer.run()
def test_create_client(self):
c = Controller(self.test_db)
cl_id = c.create_client('cl12345', name='Foo Bar', age='23')
cl_data = c.get_client('id', cl_id)[0]
self.assertEqual('Foo Bar', cl_data['name'])
self.assertEqual('23', cl_data['age'])
def test_run(self):
event_manager = EventManager([])
controller = Controller(event_manager)
controller_thread = threading.Thread(target=controller.run)
controller_thread.start()
controller.stop()
controller_thread.join()
def __init__(self, params):
"""init
@params:
"""
Controller.__init__(self,params)
self.E_k = 0 # integrated error
self.e_k_1 = 0 # last step error
def test_create_employee(self):
c = Controller(self.test_db)
em_id = c.create_employee('em12345', name='Foo Bar', age='23', pos='3')
em_data = c.get_employee('id', em_id)[0]
self.assertEqual('Foo Bar', em_data['name'])
self.assertEqual('23', em_data['age'])
self.assertEqual('3', em_data['pos'])
def test_stop(self):
mock_event_manager = mox.MockObject(EventManager)
mox.Replay(mock_event_manager)
controller = Controller(mock_event_manager)
controller.stop()
controller.run()
mox.Verify(mock_event_manager)
def buildValuesBackwards(self, startDate, endDate, location, tracking, storageMWh): #reverse the arrays containing price and solar data. print "Building Values Backwards" tz = SydneyTimezone() lat= location[0] lon = location[1] state= location[2] # locationName = location[3] startDate = startDate.astimezone(tz) endDate = endDate.astimezone(tz) controller = Controller(gui=False) data = controller.getTimeseriesNemDNICos(state=state, lat = lat, lon = lon, startDate = startDate, endDate = endDate) plant = Plant(namePlateMW = 1) storage = Storage(storageLevels = self.numStates, effectiveCapacityMWh = storageMWh, batteryType = self.batteryType) plant = Plant(1) values=np.zeros(shape=(data.shape[0] + 1, storage.getNumStorageLevels()+1)) destinations = np.zeros(shape=( data.shape[0] + 1, storage.getNumStorageLevels()+1)) totalArrayOutput = 0 # if self.shaved: # data = self.shaveNemData(data) if tracking: COS_INDEX = self.TRACKING_COS_INDEX else: COS_INDEX = self.FIXED_COS_INDEX #iterate backwards through time. for timeIndex in np.arange(0, data.shape[0])[::-1]: # Get the timeperiod outputs cos = data[timeIndex][COS_INDEX] price = data[timeIndex][self.PRICE_INDEX] if self.capped: price = min(price, 300) dni = data[timeIndex][self.DNI_INDEX] ghi_factor = data[timeIndex][self.GHI_FACTOR_INDEX] ghi = np.multiply(ghi_factor, dni) arrayOutput = plant.getPlantOutput(dni=dni, ghi=ghi, timePeriodHrs=0.5, cosine=cos) totalArrayOutput = totalArrayOutput + arrayOutput date = datetime.datetime(year=int(data[timeIndex][self.YEAR_INDEX]), month = int(data[timeIndex][self.MONTH_INDEX]), day = int(data[timeIndex][self.DAY_INDEX]), hour=int(data[timeIndex][self.HOUR_INDEX]), minute=int(data[timeIndex][self.MINUTE_INDEX]), tzinfo=SydneyTimezone()) # iterate through the storagelevels for storageLevel in np.arange(storage.getNumStorageLevels()+1): # Find the optimal destination and its corresponding value valueAndDestination = self.getValueAndDestination(storage = storage, price=price, solarOutputMWh=arrayOutput, storageLevel=storageLevel, nextTimePeriodValues = values[timeIndex + 1], date = date) values[ timeIndex, storageLevel] = valueAndDestination[0] destinations[timeIndex, storageLevel] = valueAndDestination[1] prices = np.transpose(data)[self.PRICE_INDEX] sun = np.transpose(data)[self.DNI_INDEX] return (values, destinations,prices, sun, totalArrayOutput)
class Shuffle:
def __init__(self):
usage = """shuffle.py [input_folder]"""
parser = optparse.OptionParser(usage = usage)
(options, args) = parser.parse_args()
if len(args) == 0:
print "A video folder needs to be specified."
exit()
else:
self.folder = args[0]
if self.folder.endswith("/"):
self.folder = self.folder[:-1]
if len(args) == 2:
self.bpm = int(args[1])
else:
self.bpm = 30
self.engine = Engine()
self.controller = Controller(self.engine)
self.tree = []
self.folder_short = self.folder.split("/")[-1]
ls = os.listdir(self.folder)
# Populating database of files in input directory.
self.browse_folder(ls, self.folder, self.tree)
self.length = len(self.tree)
print ""
print "Found " + str(self.length) + " videos."
print ""
self.timeout_id = gobject.timeout_add((60000/self.bpm), self.loop_callback)
loop = gobject.MainLoop()
loop.run()
def loop_callback(self):
video = random.choice(self.tree)
self.controller.play(video, 1.0, 0)
return True
def browse_folder(self, folder, dir, tree):
'''Creates a tree of all the files and folder inside the in put dir.'''
for files in folder:
if not files.startswith(".") and (not files == folder):
files = dir + "/" + files
tree.append(files)
if os.path.isdir(files):
temp = files[files.find(self.folder_short):]
temp = "".join("%s/" % (n) for n in \
temp.split("/")[1:])
new = os.listdir(files)
self.browse_folder(new, files, tree)
def main():
args = get_parser().parse_args()
if args.uri is None:
args.uri = conf.General["uri"]
if args.handler == "show_info":
args.handler = "info"
ctrl = Controller(args.server, args.server_port)
ctrl.all(vars(args))
def check_for_missing_inmates(self, start_date):
self._debug('started check_for_missing_inmates')
inmates = Inmates(Inmate, self._monitor)
inmates_scraper = InmatesScraper(Http(), inmates, InmateDetails, self._monitor, workers_to_start=70)
search_commands = SearchCommands(inmates_scraper, self._monitor)
controller = Controller(self._monitor, search_commands, inmates_scraper, inmates)
controller.find_missing_inmates(start_date)
self._debug('waiting for check_for_missing_inmates processing to finish')
controller.wait_for_finish()
self._debug('finished check_for_missing_inmates')
def test_handle_event(self):
# This function should be a no-op, nothing should be called on
# the EventManager
mock_event_manager = mox.MockObject(EventManager)
mox.Replay(mock_event_manager)
controller = Controller(mock_event_manager)
controller.handle_event('foo')
mox.Verify(mock_event_manager)
def run(self):
self._debug('started')
inmates = Inmates(Inmate, self._monitor)
inmates_scraper = InmatesScraper(Http(), inmates, InmateDetails, self._monitor)
search_commands = SearchCommands(inmates_scraper, self._monitor)
controller = Controller(self._monitor, search_commands, inmates_scraper, inmates)
controller.run()
self._debug('waiting for processing to finish')
controller.wait_for_finish()
self._debug('finished')
class UI:
def __init__(self, n):
self.__problem = Problem(n)
self.__controller = Controller(self.__problem)
self.__eaAverage = []
self.__psoAverage = []
def particleSwarmOptimization(self):
startClock = time()
noIteratii = int(input("Enter the number of iterations = "))
dimPopulation = int(input("Enter the dimension of the population = "))
# numbers for permutations will be in interval [1, n]
vmin = 1
vmax = n
# maximum fitness possible
maximumFitness = 4 * vmax
# specific parameters for PSO
w = 1.0
c1 = 1.
c2 = 2.5
sizeOfNeighborhood = 20
optimIndividual, fitnessOptim = self.__controller.ParticleSwarmOptimization(noIteratii, dimPopulation, vmin, vmax, w, c1, c2, sizeOfNeighborhood)
print ('Result: The detected matrix after ', noIteratii, ' iterations is: ')
print(optimIndividual)
print (' with fitness optim = ', fitnessOptim, '/', maximumFitness)
print('execution time = ', time() - startClock, " seconds")
def animate_EA(self, x_vals, y_vals, index, r):
population = 40
P = ChromozomePopulation(population, 1, n) #population = 40
pop = P.getPopulation()
r = random.randrange(1, 40)
x_vals.append(next(index))
y_vals.append(P.fitness(pop[r], n))
self.__eaAverage.append(P.fitness(pop[r], n))
plt.cla()
plt.plot(x_vals, y_vals)
plt.show()
def animate_PSO(self, x_vals, y_vals, index, r):
population = 40
P = ParticlePopulation(population, 1, n) #population = 40
pop = P.getPopulation()
r = random.randrange(1, 40)
particle = pop[r]
x_vals.append(next(index))
y_vals.append(particle.fitness(particle))
self.__psoAverage.append(particle.fitness(particle))
plt.cla()
plt.plot(x_vals, y_vals)
plt.show()
def statisticsEvolutionaryAlgorithm(self, n):
plt.style.use('fivethirtyeight')
x_vals = []
y_vals = []
index = count()
for run in range(30): #run = 30
r = random.randrange(1, 40)
#evaluation = 1000 (interval)
FuncAnimation(plt.gcf(), self.animate_EA(x_vals, y_vals, index, r), interval = 1000)
plt.tight_layout()
#average display for best solution
sum_num = 0
for t in self.__eaAverage:
sum_num = sum_num + t
avg = sum_num / len(self.__eaAverage)
print ("Average of fitness score is: ", avg)
#standard deviation display for best solution
deviation = statistics.stdev(self.__eaAverage)
print ("Standard deviation of fitness score is: ", deviation)
def statisticsParticleSwarmOptimization(self, n):
plt.style.use('fivethirtyeight')
x_vals = []
y_vals = []
index = count()
for run in range(30): #run = 30
r = random.randrange(1, 40)
#evaluation = 1000 (interval)
FuncAnimation(plt.gcf(), self.animate_PSO(x_vals, y_vals, index, r), interval = 1000)
plt.tight_layout()
#average display for best solution
sum_num = 0
for t in self.__psoAverage:
sum_num = sum_num + t
avg = sum_num / len(self.__psoAverage)
print ("Average of fitness score is: ", avg)
#standard deviation display for best solution
deviation = statistics.stdev(self.__psoAverage)
print ("Standard deviation of fitness score is: ", deviation)
def evolutionaryAlgorithm(self):
startClock = time()
noIteratii = int(input("Enter the number of iterations = "))
dimPopulation = int(input("Enter the dimension of the population = "))
# numbers for permutations will be in interval [1, n]
vmin = 1
vmax = n
# the mutation probability
pM = float(input("Enter the mutation probability = "))
# maximum fitness possible
maximumFitness = 4 * vmax
optimIndividual, fitnessOptim = self.__controller.EvolutionaryAlgorithm(noIteratii, dimPopulation, vmin, vmax, pM)
print ('Result: The detected matrix after ', noIteratii, ' iterations is: ')
print(optimIndividual)
print (' with fitness optim = ', fitnessOptim, '/', maximumFitness)
print('execution time = ', time() - startClock, " seconds")
def hillClimbing(self):
startClock = time()
# maximum fitness possible
maximumFitness = 4 * n
optimIndividual, fitnessOptim = self.__controller.HillClimbing(n)
print ('Result: The detected matrix is: ')
print(optimIndividual)
print (' with fitness optim = ', fitnessOptim, '/', maximumFitness)
print('execution time = ', time() - startClock, " seconds")
def run(self):
runM = True
printMainMenu()
while runM:
command = int(input(">>"))
if command == 0:
runM = False
elif command == 1:
self.statisticsEvolutionaryAlgorithm(n)
#self.evolutionaryAlgorithm()
elif command == 2:
self.hillClimbing()
elif command == 3:
self.statisticsParticleSwarmOptimization(n)
#self.particleSwarmOptimization()
else:
print ("Invalid command")
import matplotlib.pyplot as plt
import numpy as np
import sys
sys.path.append('..') # add parent directory
import vtolParam as P
from controller import Controller
from signalGenerator import signalGenerator
from vtolAnimation import vtolAnimation
from plotData import plotData
from vtolDynamics import vtolDynamics
# instantiate reference input classes
vtol = vtolDynamics()
ctrl = Controller()
z_reference = signalGenerator(amplitude=2, frequency=0.08)
h_reference = signalGenerator(amplitude=1, frequency=0.05)
# set disturbance input
disturbance = 0.1
# instantiate the simulation plots and animation
dataPlot = plotData()
animation = vtolAnimation()
t = P.t_start # time starts at t_start
while t < P.t_end: # main simulation loop
# set variables
z_r = z_reference.square(t)
h_r = h_reference.square(t)
# Propagate dynamics in between plot samples
policy_model = MLPNormalPolicy([state_dim, 20, action_dim],
sigma=2,
learning_rate=1e-3,
act_bound=2,
activation=F.relu,
init_value=0.4)
value_model = MLPValue([state_dim, 20, 1],
learning_rate=5e-4,
epsilon=0.1,
activation=F.relu)
model = Controller(
name,
policy_model,
value_model,
reset_prob=0.02,
history_depth=2,
verbose=True,
)
model.set_seeds(41)
model.train(iterations=30,
exp_episodes=50,
exp_timesteps=100,
val_epochs=200,
pol_epochs=200,
batch_size=64,
pickle_name='v0.1')
policy_model.save('../run/' + name + '.pth')
def Get_PhysicalPersonForName(name):
pp = PhysicalPerson()
pp.Name = name
ctr = Controller(pp)
result = ctr.Get_PhysicalPersonForName()
return result
else:
print(
"Usage: $rushour.py [-v] [-i] [file_path] \n\t-v: Verbose mode \n\t-i: Interactive mode (overrides file usage) \n\tfile_path: Parse a text file containing a game board"
)
sys.exit()
if verbose:
print("\nBoard acquired: ")
for x in range(0, rows):
print(board[x])
print("\nFinding any solution...")
board = ''.join(board)
model = Model(rows, cols, board)
controller = Controller(model, verbose)
if (controller.play()):
if len(model.solution) > 0: #Paranoia
depth = len(model.solution)
if interactive or verbose:
for x in range(1, depth):
print("\nStep {} - {}".format(x, model.solution[x]))
for z in range(0, rows):
print(model.solution_frames[x][z])
print("\nWon in {} steps!".format(depth - 1))
print("\nTime: {0:.3} seconds".format(time.time() - start_time))
else:
f = open(file_path + '.solved', 'w')
f.write("Step 0 - Origin board")
for x in range(0, rows):
def test_load_word_file(self):
controller = Controller()
actual = controller.load_file("test2.docx")
expected = [['class ToyBox {\n', ' name : String\n', '}\n'],
['class Toy {\n', '}\n']]
self.assertEqual(expected, actual)
from loop import Loop
from controller import Controller
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
from line import Line
print('running')
pygame.init()
win_w = 500
win_h = 500
win = pygame.display.set_mode((win_w, win_h))
pygame.display.set_caption("Wernk-Pong")
controller = Controller()
paddle_1 = Paddle(win_w, win_h, 10, "assets/wernkepaddle3.png", 10,
controller.up, controller.down)
paddle_2 = Paddle(win_w, win_h, win_w - 30, "assets/beckpaddle3.png", 10,
controller.up, controller.down)
scoreboard = Scoreboard(win_w, win_h)
ball = Ball(paddle_1, paddle_2, scoreboard, win_w, win_h, 30,
"assets/wernkeball2.png",
"assets/beckball.png") # 15 seems to fast for the player
line = Line(win_w, win_h)
sprites = pygame.sprite.Group([paddle_1, paddle_2, scoreboard, ball, line])
run = True
while run:
ground_shape = igeBullet.shape(igeBullet.STATIC_PLANE_PROXYTYPE,
normal=(0, 1, 0),
constant=0)
ground_body = igeBullet.rigidBody(ground_shape, 0, (0, 0, 0), (0, 0, 0, 1))
world.add(ground_body)
efig = utl.GetFigure()
efig.clearMesh()
shape = igeBullet.shape(igeBullet.SPHERE_SHAPE_PROXYTYPE, radius=1)
body2 = igeBullet.rigidBody(shape, 5, (0, 10, 0), (0, 0, 0, 1))
world.add(body2)
utl.AddShapeMesh(shape)
char = Character(world)
cam = TargetCamera()
controller = Controller()
# sphere = core.figure('sphere')
# sphere.position = (0,10,0)
# poss = sphere.getVertexElements(0,core.ATTRIBUTE_ID_POSITION, space=core.WorldSpace)
# tris = sphere.getTriangles(0)
# soft = igeBullet.softBody(world, poss, tris)
# sphere.position = (0,0,0)
showcase2D = core.showcase('2dcase')
showcase3D = core.showcase("3dcase")
showcase3D.add(ground)
showcase3D.add(char.figure)
showcase3D.add(efig)
# FULLSCREEN = 5 # SCREENSHOT = 6 # Old Controls: # - K_SPACE: 'nab' # - K_TAB: toggle feat display # - K_UP: 'leap' combo; increase an amount in menu # - K_LEFT # - K_RIGHT # - K_DOWN: decrease an amount in menu # DOCUMENTATION: Ensure that the instructions in the "CONTROLS" section # of the readme match this file. # capitalized ones are not related to controlling the character: controller1 = Controller() controller1.addKeyAsAxisValue(K_LEFT, 'x', -1) controller1.addKeyAsAxisValue(K_RIGHT, 'x', 1) controller1.addKeyAsAxisValue(K_UP, 'y', -1) controller1.addKeyAsAxisValue(K_DOWN, 'y', 1) # for menus & "easy mode" controller1.addKeyAsAxisValue(K_a, 'x', -1) controller1.addKeyAsAxisValue(K_d, 'x', 1) controller1.addKeyAsAxisValue(K_w, 'y', -1) controller1.addKeyAsAxisValue(K_s, 'y', 1) controller1.addKey(K_RETURN, 'nab') # formerly K_SPACE controller1.addKey(K_TAB, 'feat') controller1.addKey(K_SPACE, 'jump') # formerly K_UP; combo is 'leap' controller1.addKey(K_BACKSPACE, 'BACK') controller1.addKey(K_ESCAPE, 'EXIT') controller1.addKey(K_f, 'FULLSCREEN') controller1.addKey(K_F12, 'SCREENSHOT')
class ConsoleUI:
def __init__(self, platform):
self.platform = platform
self.is_running = False
self.controller = Controller()
self.menu = {
'1': (self.add_numbers, "Adunati 2 numere"),
'2': (self.subtract_numbers, "Scadeti 2 numere"),
'3': (self.multiply_numbers, "Inmultiti 2 numere"),
'4': (self.divide_numbers, "Impartiti 2 numere"),
'5': (self.convert_general,
"Convertiti dintr-o baza in alta prin detectare automata"),
'6':
(self.convert_intermediary,
"Convertiti dintr-o baza in alta folosind o baza intermediara"),
'7': (self.convert_substitution,
"Convertiti dintr-o baza in alta prin substitutie"),
'8': (self.convert_division,
"Convertiti dintr-o baza in alta prin impartiri succesive"),
'9': (self.convert_fast,
"Convertiti dintr-o baza in alta prin conversie rapida"),
'10': (self.print_start_message, "Afisati mesajul initial"),
'x': (self.close, "Inchide aplicatia")
}
def close(self):
self.is_running = False
def add_numbers(self):
"""
Adds 2 numbers read from the console in a given base and outputs the result
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
B = input("Introduceti numarul B: ")
B = parse_to_bignumber(B)
validate_number(B)
try:
base = int(input("Introduceti baza pentru a efectua A + B: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
A = self.controller.convert_general(A, base)
B = self.controller.convert_general(B, base)
print(A, "+", B, "=", A + B)
def subtract_numbers(self):
"""
Subtracts 2 numbers read from the console in a given base and outputs the result
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
B = input("Introduceti numarul B: ")
B = parse_to_bignumber(B)
validate_number(B)
try:
base = int(input("Introduceti baza pentru a efectua A - B: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
A = self.controller.convert_general(A, base)
B = self.controller.convert_general(B, base)
print(A, "-", B, "=", A - B)
def multiply_numbers(self):
"""
Multiplies 2 numbers read from the console in a given base and outputs the result
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
B = input("Introduceti cifra B: ")
B = parse_to_bignumber(B)
validate_number(B)
try:
base = int(input("Introduceti baza pentru a efectua A * B: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
A = self.controller.convert_general(A, base)
B = self.controller.convert_general(B, base)
print(A, "*", B, "=", A * B)
def divide_numbers(self):
"""
Divides 2 numbers read from the console in a given base and outputs the result and the remainder
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
B = input("Introduceti cifra B: ")
B = parse_to_bignumber(B)
validate_number(B)
try:
base = int(input("Introduceti baza pentru a efectua A / B: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
A = self.controller.convert_general(A, base)
B = self.controller.convert_general(B, base)
result, remainder = A // B
print(A, "/", B, "=", str(result) + ", rest =", remainder)
def convert_general(self):
"""
Converts a number to a given base in the most optimal approach
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
try:
base = int(input("Introduceti baza destinatie: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
self.controller.convert_general(A, base)
def convert_intermediary(self):
"""
Converts a number to a given base using an intermediary base
Raises:
ValueError: if either the number or the base is wrong
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
try:
intermediary_base = int(input("Introduceti baza intermediara: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(intermediary_base)
try:
base = int(input("Introduceti baza destinatie: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
self.controller.convert_intermediary(A, base, intermediary_base)
def convert_substitution(self):
"""
Converts a number to a given base using the substitution method
Raises:
ValueError: if either the number or the base is wrong
if the number base is bigger than the given base
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
try:
base = int(input("Introduceti baza destinatie: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
self.controller.convert_substitution(A, base)
def convert_division(self):
"""
Converts a number to a given base using the division method
Raises:
ValueError: if either the number or the base is wrong
if the number base is smaller than the given base
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
try:
base = int(input("Introduceti baza destinatie: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
self.controller.convert_division(A, base)
def convert_fast(self):
"""
Converts a number to a given base using the fast conversion method
Raises:
ValueError: if either the number or the base is wrong
if the number base or the destination base are not powers of 2
"""
A = input("Introduceti numarul A: ")
A = parse_to_bignumber(A)
validate_number(A)
try:
base = int(input("Introduceti baza destinatie: "))
except ValueError:
raise ValueError(
"Baza trebuie sa fie din multimea {2, 3, 4, 5, 6, 7, 8, 9, 10, 16}"
)
validate_base(base)
self.print_delimiter()
self.controller.convert_fast(A, base)
def print_menu(self):
for id, task in self.menu.items():
print(str(id) + '.' + task[1])
def print_delimiter(self):
print("-" * 30)
def print_start_message(self):
self.print_delimiter()
print("Aplicatie realizata de Cazaciuc Valentin, grupa 211")
print("Indicatii de utilizare:")
print(
" -la fiecare iteratie va aparea un meniu; introduceti cifra sau litera respectiva si apasati Enter"
)
print(
" -cand aveti de introdus un numar, el trebuie sa fie de forma [numar(baza)]; de exemplu pentru a introduce pe 13 in baza 10 si 16 se va scrie 13(10), respectiv 13(16)"
)
print(
" -cand aveti de introdus o baza, ea trebuie sa fie de forma [baza]; de exemplu pentru baza 10 introduceti 10 si apasati Enter"
)
print(
" -daca se fac greseli(cum ar fi o baza diferita de cele posibile, un numar cu cifrele mai mari sau egale decat baza, caractere indisponibile sau format gresit) ele vor fi semnalate, iar programul va continua"
)
self.print_delimiter()
def run(self):
"""
Runs the console application
Steps:
-print menu
-take input
-call functions based on input
-clear screen
"""
self.print_start_message()
self.is_running = True
while self.is_running:
self.print_menu()
self.print_delimiter()
cmd = input("Introduceti comanda: ").strip()
try:
self.menu[cmd][0]()
except KeyError:
print("Introduceti o comanda valida")
except ValueError as error:
print(error)
cmd = input("Apasati tasta Enter pentru a continua...")
#print("\n" * 20)
if self.platform == "Windows":
os.system("cls")
else:
os.system("clear")
class ControllerNode():
def __init__(self):
"""Initialize a new controller instance."""
self.freq = 100 # in Hz
# self.s = 3 # battery configuration 3s/4s
# self.v_c = 4.7 # voltage per lipo cell
# self.v_s = self.s * self.v_c # supply voltage
# self.k_v = 580 # RPM/Volt e.g. MN3508 580/ MN3110 700Kv
# self.idle_rpm = self.k_v * self.v_s # idle RPM
# An old regression model
# self.prop_size = 13 # in inch
# self.zero_rpm = 5974.71 - 350.00 * self.prop_size
# half throttle RPM 4000
# self.hover_rpm = 5974.71 - 350.00 * self.prop_size + 5340 * 0.5
# full throttle RPM 6600
# self.full_rpm = 5974.71 - 350.00 * self.prop_size + 5340 * 1
self.zero_rpm = 2500
self.hover_rpm = 2600
self.full_rpm = 2800
print("Controlling rpm between", self.zero_rpm, " and ", self.full_rpm)
self.sub = rospy.Subscriber('/phoenix/imu', Imu, self.imu_callback)
self.pub = rospy.Publisher('/phoenix/cmd_motor', MotorMessage)
r = rospy.Rate(self.freq)
self.drone = Drone()
self.controller = Controller(self.drone)
self.xdot_desired = np.zeros((3, 1))
self.thetadot_desired = np.zeros((3, 1))
self.last = rospy.get_time()
while not rospy.is_shutdown():
r.sleep()
def imu_callback(self, imu_msg):
"""React on new imu measurements."""
now = rospy.get_time()
dt = now - self.last
self.last = now
# Update the drones internal state
self.drone.thetadot[0] = imu_msg.angular_velocity.x
self.drone.thetadot[1] = imu_msg.angular_velocity.y
self.drone.thetadot[2] = imu_msg.angular_velocity.z
self.drone.xdoubledot[0] = imu_msg.linear_acceleration.x
self.drone.xdoubledot[1] = imu_msg.linear_acceleration.y
self.drone.xdoubledot[2] = imu_msg.linear_acceleration.z
self.drone.xdot = self.drone.xdot # +self.drone.xdoubledot*dt
# calculate motor commands
cmds = self.controller.calculate_control_command(self.xdot_desired,
self.thetadot_desired.item(2))
print("cmds", cmds)
cmds = np.clip(cmds, 0, 3)
print("clipped cmds", cmds)
cmds = self.zero_rpm + cmds * (self.full_rpm - self.hover_rpm)
cmds = np.clip(cmds, 2500, 2800)
# publish MotorMessage to uart bridge
motor_msg = MotorMessage()
motor_msg.motor0 = cmds[0] # Front left
motor_msg.motor1 = cmds[1] # Front right
motor_msg.motor2 = cmds[2] # Back left
motor_msg.motor3 = cmds[3] # Back right
self.pub.publish(motor_msg)
"""
"""
from maze import Maze
from nezha import Nezha
from controller import Controller
maze_list = [
[1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
[1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
[1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1],
[1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1],
]
Maze(maze_list)
nezha = Nezha(maze_list, 0, 5, 12, 7)
Controller(nezha.go_up, nezha.go_down, nezha.go_left, nezha.go_right)
class Main:
controller = Controller()
controller.run()
def __init__(
self,
experiment_name='test',
multiplemode="no", # yes or no
enemies=[1], # array with 1 to 8 items, values from 1 to 8
loadplayer="yes", # yes or no
loadenemy="yes", # yes or no
level=2, # integer
playermode="ai", # ai or human
enemymode="static", # ai or static
speed="fastest", # normal or fastest
inputscoded="no", # yes or no
randomini="no", # yes or no
sound="on", # on or off
contacthurt="player", # player or enemy
logs="on", # on or off
savelogs="yes", # yes or no
clockprec="low",
timeexpire=3000, # integer
overturetime=100, # integer
solutions=None, # any
player_controller=None, # controller object
enemy_controller=None): # controller object
# initializes parameters
self.experiment_name = experiment_name
self.multiplemode = multiplemode
self.enemies = enemies
self.enemyn = enemies[0] # initial current enemy
self.loadplayer = loadplayer
self.loadenemy = loadenemy
self.level = level
self.playermode = playermode
self.enemymode = enemymode
self.speed = speed
self.inputscoded = inputscoded
self.randomini = randomini
self.sound = sound
self.contacthurt = contacthurt
self.logs = logs
self.savelogs = savelogs
self.clockprec = clockprec
self.timeexpire = timeexpire
self.overturetime = overturetime
self.solutions = solutions
# initializes default random controllers
if self.playermode == "ai" and player_controller == None:
self.player_controller = Controller()
else:
self.player_controller = player_controller
if self.enemymode == "ai" and enemy_controller == None:
self.enemy_controller = Controller()
else:
self.enemy_controller = enemy_controller
# initializes log file
if self.logs == "on" and self.savelogs == "yes":
file_aux = open(self.experiment_name + '/evoman_logs.txt', 'w')
file_aux.close()
# initializes pygame library
pygame.init()
self.print_logs("MESSAGE: Pygame initialized for simulation.")
# initializes sound library for playing mode
if self.sound == "on" and self.playermode == "human":
pygame.mixer.init()
self.print_logs("MESSAGE: sound has been turned on.")
# initializes joystick library
if self.playermode == "human":
pygame.joystick.init()
self.joy = pygame.joystick.get_count()
self.clock = pygame.time.Clock() # initializes game clock resource
# generates screen
if self.playermode == 'human': # playing mode in fullscreen
flags = DOUBLEBUF | FULLSCREEN
else:
flags = DOUBLEBUF
self.screen = pygame.display.set_mode((736, 512), flags)
self.screen.set_alpha(None) # disables uneeded alpha
pygame.event.set_allowed([QUIT, KEYDOWN,
KEYUP]) # enables only needed events
self.load_sprites()
def setUp(self):
'''Method run before every test. Use this to prepare the test fixture.'''
self.controller = Controller()
self.w = self.controller.right_widget.automatic_mode.window
Controller.allWidgets_setCheckable(self.controller.app)
from controller import Controller
controller = Controller()
count = 0
while count < 3:
name = str(input("Digite o nome da música: "))
author = str(input("Digite o nome do autor: "))
genre = str(input("Digite o nome da (gênero): "))
count = count+1
controller.save(name, author, genre)
pass
© 2020 GitHub, Inc.
def test_load_incorrect_file_format(self):
controller = Controller()
actual = controller.load_file("test.pdf")
self.assertRaises(NameError, actual)
def test_load_file_not_found_exception(self):
controller = Controller()
actual = controller.load_file("C:\\Users\\Luna\\ICT\\test2.txt")
self.assertRaises(FileNotFoundError, actual)
def users_by_tags(self):
tags = Controller.get_value("Enter tags: ", str)
res = self.__server.users_by_tags(tags)
View.print_list("Users: ", res)
def Get_PhysicalPersonForID(id):
pp = PhysicalPerson()
pp.Id = id
ctr = Controller(pp)
result = ctr.Get_PhysicalPersonForID()
return result
def test_load_txt_file3(self):
controller = Controller()
actual = controller.load_file("test3.txt")
expected = [['class ToyBox {\n', ' name : String\n', '}\n'],
['class Toy {\n', ' number: int\n', '}\n']]
self.assertEqual(expected, actual)
def shortest_path(self):
username1 = Controller.get_value("Enter first user: "******"Enter second user: ", str)
res = self.__server.shortest_path(username1, username2)
View.show_way(res)
def test_load_incorrect_file_exception(self):
controller = Controller()
actual = controller.load_file("test2.csv")
self.assertRaises(NameError, actual)
BatchConverter(780, 200, 6, [1, 1, 1, 0, 0, 0, 0, 0], [link_2], "C", 70))
pipes.append(Pipe(800, 100, 20, 100, batchReactors[len(batchReactors) - 1]))
sources.append(ChemicalSource(800, 80, 0, [pipes[len(pipes) - 1]], 20, "C1"))
pipes.append(Pipe(500, 220, 280, 20, batchReactors[len(batchReactors) - 1]))
sources.append(ChemicalSource(480, 220, 1, [pipes[len(pipes) - 1]], 40, "C2"))
pipes.append(Pipe(940, 220, -100, 20, batchReactors[len(batchReactors) - 1]))
sources.append(ChemicalSource(940, 220, 2, [pipes[len(pipes) - 1]], 20, "C3"))
batchReactors.append(
BatchConverter(620, 20, 7, [1, 1, 0, 0, 0, 0, 0, 0], [link_3], "D", 70))
pipes.append(Pipe(420, 40, 200, 20, batchReactors[len(batchReactors) - 1]))
sources.append(ChemicalSource(400, 40, 0, [pipes[len(pipes) - 1]], 20, "D1"))
pipes.append(Pipe(880, 40, -200, 20, batchReactors[len(batchReactors) - 1]))
sources.append(ChemicalSource(880, 40, 1, [pipes[len(pipes) - 1]], 40, "D2"))
controller = Controller(batchReactors, sources, pipes)
if enableLog:
logger = Logger(logName, controller)
controller.updateControls([
# [BaR, Chm, Fuz, Src, Val],
[4, 0, 1, 0, 0.5],
[4, 0, 2, 0, 0.75],
[4, 0, 1, 1, 0.5],
[4, 0, 2, 1, 0.75],
[4, 0, 1, 2, 0.5],
[4, 0, 2, 2, 1],
[4, 0, 1, 3, 0.5],
[4, 0, 2, 3, 1],
[4, 0, 1, 4, 0.5],
[4, 0, 2, 4, 1],
def __init__(self):
self.map = Map()
self.map.random_map()
self.controller = Controller(Drone(PARAM_BATTERY), self.map)
def main():
lqr.init()
clock = pygame.time.Clock()
pos = np.asmatrix([0., 1., 0.]).T
vel = np.asmatrix([3., 0., 3.]).T
visualizer = vis.Visualizer()
fps = 60
dt = 1.0 / fps
t = 0.0
i = 0
maxon_motor = motor.Motor(
resistance=1.03,
torque_constant=0.0335,
speed_constant=0.0335,
rotor_inertia=135*1e-3*(1e-2**2))
gearbox = motor.Gearbox(gear_ratio=20.0 / 60.0, gear_inertia=0)
gear_motor = motor.GearMotor(maxon_motor, gearbox)
our_robot = robot.Robot(
robot_mass=6.5,
robot_radius=0.085,
gear_motor=gear_motor,
robot_inertia=6.5*0.085*0.085*0.5,
wheel_radius=0.029,
wheel_inertia=2.4e-5,
wheel_angles = np.deg2rad([45, 135, -135, -45]))
# wheel_angles=np.deg2rad([60, 129, -129, -60]))
controller = Controller(dt, our_robot)
while not visualizer.close:
visualizer.update_events()
v = 3
rx = np.asmatrix([np.sin(v * t), np.cos(v * t / 3), v * np.sin(t)]).T
rv = v * np.asmatrix([np.cos(v * t), -np.sin(v * t / 3) / 3, np.cos(t)]).T
ra = v ** 2 * np.asmatrix([-np.sin(v * t), -np.cos(v * t / 3) / 9, -np.sin(t) / v]).T
vel_b = np.linalg.inv(rotation_matrix(pos[2,0])) * vel
rv_b = np.linalg.inv(rotation_matrix(pos[2,0])) * rv
rx_b = np.linalg.inv(rotation_matrix(pos[2,0])) * rx
pos_b = np.linalg.inv(rotation_matrix(pos[2,0])) * pos
# u = controller.feedforward_control(pos, vel, rx, rv, ra)
state_vector = np.vstack((rx_b-pos_b,rv_b-vel_b))
u = lqr.controlLQR(state_vector) # +=
u = u[2:,0]
# u = controller.control(pos, vel, rx, rv, ra)
vdot_b = our_robot.forward_dynamics_body(vel_b, u)
vdot = our_robot.forward_dynamics_world(pos, vel, u)
# print(u - our_robot.inverse_dynamics_body(vel_b, vdot_b))
robot.sysID(u[0,0], u[1,0], u[2,0], u[3,0], vel_b[0,0], vel_b[1,0], vel_b[2,0], vdot_b[0,0], vdot_b[1,0], vdot_b[2,0])
visualizer.draw(pos, rx)
pos += dt * vel + 0.5 * vdot * dt ** 2
vel += dt * vdot
# robot_data_line = [vdot_b[0,0], vdot_b[1,0], vdot_b[2,0], vel_b[0,0], vel_b[1,0], vel_b[2,0], u[0,0], u[1,0], u[2,0], u[3,0]]
# robot_data.append(robot_data_line)
clock.tick(60)
t += dt
i += 1
if t > 20:
print("t = 20")
t = 0.0
i = 0
pos = np.asmatrix([0, 1, 0.]).T
vel = np.asmatrix([3, 0, 3.]).T
controller.reset()
robot.main()
def __init__(self,
address,
port,
queue,
scope_on=False,
n_frames=100,
n_fft=1e3,
n_avg=10,
save_raw=False,
save_psd=True,
convert=None):
"""
constructs the DAQ class, starts the logger
args:
address - (string) : string containing the IPv4 address of the controller, eg. '192.168.1.28'
port - (int) : port number the controller is on, eg. 10000
queue - (Queue) : queue object to write the data to in a thread safe way
n_frames - (int) : number of frames to acquire each time the circular buffer is read out
n_fft - (int) : number of frames in each PSD and CSV file
scope_on - (bool) : boolean flag to specify if the scope is being used, if so puts the decoded frames in the queue
save_raw - (bool) : boolean flag to specify if the raw traces (converted if conversions provided) are saved to a CSV file
save_psd - (bool) : boolean flag to specify if the psd (converted if conversions provided) are saved to a CSV file
convert - (None or dict) : optional parameter to pass that gives a conversion for variables if the key matches the controller
returns:
nothing
"""
self.logger = logging.getLogger('vib_daq.daq.DAQ')
self.ctrl = Controller(address, port)
self.udbf = UDBF()
#queue for storing the data
self.queue = queue
#boolean options which dictate behaviour of DAQ
self.take_data = True
self.paused = False
self.scope_on = scope_on
self.save_raw = save_raw
self.save_psd = save_psd
#optional conversion argument, either None or a dict
self.convert = convert
#parameters regarding the number of frames acquired and psd/file size
self.n_frames = n_frames
self.n_fft = n_fft
self.n_avg = n_avg
self.logger.info('Created DAQ successfully')
#get the binary header from the controller
bin_head = self.ctrl.acquire_head()
#decode the binary header
self.udbf.decode_header(bin_head)
self.logger.info('Succesfully decoded binary header')
#get sampling frequency
self.fs = self.udbf.SampleRate
def __init__(self, n):
self.__problem = Problem(n)
self.__controller = Controller(self.__problem)
self.__eaAverage = []
self.__psoAverage = []
x_test = x_test.astype('float32') / 255.
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
dataset = [x_train, y_train, x_test,
y_test] # pack the dataset for the NetworkManager
previous_acc = 0.0
total_reward = 0.0
with policy_sess.as_default():
# create the Controller and build the internal policy network
controller = Controller(policy_sess,
NUM_LAYERS,
state_space,
reg_param=REGULARIZATION,
exploration=EXPLORATION,
controller_cells=CONTROLLER_CELLS,
embedding_dim=EMBEDDING_DIM,
restore_controller=RESTORE_CONTROLLER)
# create the Network Manager
manager = NetworkManager(dataset,
epochs=MAX_EPOCHS,
child_batchsize=CHILD_BATCHSIZE,
clip_rewards=CLIP_REWARDS,
acc_beta=ACCURACY_BETA)
# get an initial random state space if controller needs to predict an
# action from the initial state
state = state_space.get_random_state_space(NUM_LAYERS)
print("Initial Random State : ", state_space.parse_state_space_list(state))
from controller import Controller
from model import Model
if __name__ == "__main__":
''' Model creation. '''
model = Model("source")
''' Controller creation. Use model as agruement. '''
controller = Controller(model)
''' The start of console application. '''
controller.start()
''' The save of the model. '''
model.save()
