def __init__(self, engine): """Constructor""" System.__init__(self, engine) ogre.FrameListener.__init__(self) ogre.WindowEventListener.__init__(self) OIS.KeyListener.__init__(self) OIS.MouseListener.__init__(self) OIS.JoyStickListener.__init__(self) self.handlers = [dict() for x in range(InputEvent.NUM)] self.mouse_handlers = [dict() for x in range(MouseEvent.NUM)] self.joy_handlers = [dict() for x in range(JoyEvent.NUM)] self.key_states = {} self.keys_down = list() self.mouse_buttons_down = {} self.mouse_down_pos = {} self.mouse_down_over = {} self.mouse_down_modifiers = {} self.input_locks = {} for mb in MouseButton.LIST: self.mouse_buttons_down[mb] = False self.mouse_down_pos[mb] = None self.mouse_down_over[mb] = None self.mouse_down_modifiers[mb] = [False for x in range(Modifier.NUM)] self.input_locks[mb] = InputLock() self.mouse_state = None #box selection #self.selection_dd_context = self.engine.debugDrawSystem.getContext() #self.boxSelection = None #self.maintainDDContext = self.engine.debugDrawSystem.getContext() self.translation_to_apply = vector3(0,0,0) self.translation_to_apply_time_left = 0
def menu(arguments): if arguments['list']: if arguments['--YAML'] or arguments['--JSON']: where = dict(name=arguments['<name>']) if arguments['<name>'] else dict() systems = System.list(**where) common.dump(systems, toyaml=arguments['--YAML'], tojson=arguments['--JSON'], entry=lambda item: item.__dict__) else: _system_list_table(arguments) elif system_execute(arguments): pass else: try: if arguments['create']: System.create(**_system_create_kwargs(arguments)) elif arguments['read']: system_read(arguments) elif arguments['set']: system_set(arguments) elif arguments['delete']: System(arguments['<name>']).delete() elif arguments['reset']: system_reset(arguments) except NameError as exc: print(PACKAGE_NAME, 'Error!', exc) sys.exit(1)
def __init__(self): global _requests self.camip = "sonycam.msgroup.ucla.edu" self.ourip = socket.gethostbyaddr(socket.gethostname())[-1][0] self.port = 9218 self.camtool = "./camctrl" self.pan=0 self.tilt=0 self.zoom=0 self.setCam() print "Start parsing xml file" espmlFile = 'sonyCamSystem.xml' espmlDocObject = espml.parse(espmlFile) systemElement = espmlDocObject.getSystem() systemElement.setId('http://'+str(self.ourip)+':'+self.port) espmlDocObject.export(file(espmlFile, 'w'), 0) System.__init__(self, self.port, "http://128.97.93.5:1718/", "sonyCamSystem.xml") print "Registered system" #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def main(): # Solar system data comes from # http://hyperphysics.phy-astr.gsu.edu/hbase/solar/soldata2.html sun = Body(1.98892e30, 0, 0, 0, 0, 15, 1, 1, 0) mercury = Body(.06 * EM, -.3871 * AU, 0, 0, 47890, 3, 1, .4, 0) venus = Body(.82 * EM, -.7233 * AU, 0, 0, 35040, 6, 0, .6, .2) earth = Body(1.0 * EM, -1.0 * AU, 0, 0, 29790, 7, 0, .4, 1) mars = Body(.11 * EM, -1.524 * AU, 0, 0, 24140, 4, .8, .2, 0) solar_system = System([sun, mercury, venus, earth, mars]) set_clear_color(0, 0, 0) # black background enable_smoothing() while not window_closed(): clear() # Draw the system in its current state. solar_system.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER) # Update the system for its next state. solar_system.update(TIMESTEP * TIME_SCALE) # Draw the frame and take a brief nap. request_redraw() sleep(TIMESTEP)
class BRTest(unittest.TestCase): def showMsg(self, msg): print "[%s/%s/%s] %s" % (self.testname, self.testinstance, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), msg) def setUp(self): if os.getenv("REUSE_BUILD"): self.builddir = os.getenv("REUSE_BUILD").rstrip("/") skip_build = True else: skip_build = False b = subprocess.check_output(["mktemp", "-d", "buildroot.XXXXX"], cwd=configtest.builddir) b = b.strip() self.builddir = os.path.join(configtest.builddir, b) self.testname = self.__class__.__name__ self.testinstance = os.path.basename(self.builddir) self.buildlog = self.builddir + "-build.log" self.runlog = self.builddir + "-run.log" self.s = None self.showMsg("Starting") self.b = Builder(self.__class__.config, self.builddir, self.buildlog) if not skip_build: self.showMsg("Building") self.b.build() self.showMsg("Building done") self.s = System(self.runlog) def tearDown(self): self.showMsg("Cleaning up") if self.s: self.s.stop() if self.b and os.getenv("KEEP_BUILD"): self.b.delete()
class BaseTest(unittest.TestCase): def __init__(self, *args, **kwargs): super(BaseTest, self).__init__(*args, **kwargs) self.auto_power_on = True def setUp(self): obc_com = config['OBC_COM'] sys_bus_com = config['SYS_BUS_COM'] payload_bus_com = config['PAYLOAD_BUS_COM'] use_single_bus = config['SINGLE_BUS'] gpio_com = config['GPIO_COM'] self.gpio = Pins(gpio_com) extensions.set_up(test_id=self.id()) self.system = System(obc_com, sys_bus_com, payload_bus_com, use_single_bus, self.gpio, self.auto_power_on) def tearDown(self): self.system.close() self.gpio.close() extensions.tear_down(test_id=self.id()) def power_on_obc(self): self.system.obc.power_on() def power_on_and_wait(self): self.power_on_obc() self.system.obc.wait_to_start()
def __init__(self): global _requests System.__init__(self, 8081, "http://128.97.93.154:8080/", "sos_system.xml") # start the SOAP server self.sossrvClient = sossrv_tools.SossrvClient() _requests = {'field_getCurrent': {}, 'field_average': {}, 'sensor_getCurrentValue': {}, 'sensor_getAverageValue': {} } self.sensorModule = SensorModule() self.sossrvClient.register_module(self.sensorModule) # connect to the sossrv application self.sossrvClient.connect() SocketServer.TCPServer.__init__(self, ('128.97.93.154', 8082) , ESPRequestHandler) esphttpserver = thread.start_new_thread(self.serve_forever, ()) #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def set_screen(target, on=True): log = logging.getLogger('Screen') if not on: log.info('Setting screen OFF') System.sleep(target) return log.info('Setting screen ON') System.wakeup(target)
def startup(self, verbosity): '''Initialisation for the objects that have variable startup behaviour''' self.myInfoDisplay = infodisplay.InfoDisplay() # self.myKey = keyboardpoller.KeyboardPoller() # self.myKey.start() try: if keys.board == 'emulator': import gpio_emulator import mpc_emulator self.myGpio = gpio_emulator.Gpio() self.myMpc = mpc_emulator.Mpc() host = 'dummy host' self.programmename = 'dummy prog\nTest\nSecond row' if keys.board == 'lcd': host = 'rotary host' import rotary self.myGpio = rotary.Rotary() self.myVol = rotary.Rotary(1) self.myMpc = mpc2.Mpc() print 'mpc has been setup' # count = self.myMpc.podcounter() self.mySystem = System() host = self.mySystem.return_hostname() print 'Hostname:', host self.programmename = self.myMpc.progname() print 'Prog:', self.programmename # remaining = self.myMpc.check_time_left() else: from mpc2 import Mpc import gpio self.myGpio = gpio.Gpio() self.myMpc = Mpc(False, True) # Test mode, podmode count = self.myMpc.podcounter() self.mySystem = System() host = self.mySystem.return_hostname() self.programmename = self.myMpc.progname() remaining = self.myMpc.check_time_left() except: self.cleanup('Failed to start gpio') # self.myInfoDisplay.writerow(0,host) # self.myInfoDisplay.update_display() self.myInfoDisplay.prog = self.programmename self.myInfoDisplay.start() time.sleep(2) self.myInfoDisplay.prog = self.myMpc.progname() self.ending = False self.t = threading.Timer(AUDIOTIMEOUT, self.audiofunc) self.t.start() self.t.name = 'audiot' print threading.enumerate() # helps debug print 'Thread count: ', threading.active_count() # self.check_threads() if False: # set to true for testing self.cleanup('Forced cleanup') self.dt = threading.Timer(DEBUGTIMEOUT, self.debugfunc) # self.dt.start() self.dt.name = 'debugt'
def __init__(self): global _requests System.__init__(self, 7082, "128.97.93.5:1817", "sensorbase_system.xml") #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def __init__(self): global _requests System.__init__(self, 7081, "http://128.97.93.154:8080/", "soundscape_system.xml") #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def qa_linker(): import time from gnuradio import window from system import System from signal_psk31 import PSK31Signal def mag(c): """Magnitude of complex number.""" return (c*c.conjugate()).real src = gr.wavfile_source("../example.WAV", False) samp_rate = 44100 tb = gr.top_block() system = System(tb, src, samp_rate, throttle=False, src_is_float=True, center_freq=0) linker = Linker(1000, 80, samp_rate) snk = gr.null_sink(gr.sizeof_gr_complex) system.connect(system.out, linker, snk) system.refresh() system.start() time.sleep(5) system.stop() data = linker.probe.level() print(data[:10]) print(linker.samp_rate) plot_fft([mag(x) for x in data], linker.samp_rate)
class Alive(object): def __init__(self): self.system = System() logging.info('Alive Initialization Succeeded!') def data(self): cpu = self.system.cpu() memory = self.system.memory() message = "Cpu %s / Memory %s" % (cpu, memory) logging.info(message)
def __init__(self): global _requests print "Start parsing xml file" System.__init__(self, 8081, "http://127.0.0.1:8080/", "iTunesSystem.xml") print "Registered system" #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def __init__(self): global _requests print "Start parsing xml file" System.__init__(self, 9181, "http://128.97.93.154:8080/", "beachCamSystem.xml") print "Registered system" #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def test_next(self): rules = [ Rule("A", 0, 1, True, "B"), Rule("B", 0, 1, False, "A"), Rule("C", 0, 1, False, "B"), Rule("A", 1, 1, False, "C"), Rule("B", 1, 1, True, "B"), Rule("C", 1, 1, True, "HALT"), ] m = Machine(rules) t = Tape() s = System(m, t) s.next() self.assertEqual(s.steps, 1)
def test_iterate_until_halt_max(self): rules = [ Rule("A", 0, 1, True, "B"), Rule("B", 0, 1, False, "A"), Rule("C", 0, 1, False, "B"), Rule("A", 1, 1, False, "C"), Rule("B", 1, 1, True, "B"), Rule("C", 1, 1, True, "HALT"), ] m = Machine(rules) t = Tape() s = System(m, t) with self.assertRaises(DidNotHalt): s.iterate_until_halt(max_steps=10) self.assertNotEqual(s.machine.state, "HALT")
def main(): # load in the images for all the planets # like hitting ctrl+r and loading your blitz suni = load_image("sun.png") merci = load_image("mercury.gif") venusi = load_image("venus.gif") earthi = load_image("earth.png") marsi = load_image("mars.png") # initialize all the planets as an object # hope that the values are all correct sun = Body(1.98892e30, 0, 0, 0, 0, 12, 1, 1, 0,suni,17,17,0,17,17) mercury = Body(.06*EM,0,.3871*AU,47890,0,3,1,0,0,merci,8,8,.2,16,16) venus = Body(.82*EM,0,-.7233*AU,-35040,0,8,0,1,0,venusi,10,9,.3,20,18) earth = Body(EM,AU,0,0,-29790,6,0,0,1,earthi,13,13,.4,26,26) mars = Body(.11*EM,-1.524*AU,0,0,24140,4,0,1,1,marsi,10,10,.3,20,20) listp = [sun,mercury,venus,earth,mars] # put em in a list, for safekeeping # as of now, the planets are still sleeping solar = System(listp) # kill the backlights, set up the stage, # draw things inside the page set_clear_color(0, 0, 0) enable_smoothing() player = Spaceship(3*WINDOW_HEIGHT/4,3*WINDOW_HEIGHT/4) while not window_closed(): # draw the spaceship yo clear() player.spaceshipupdate() player.draw() # Draw the system in its current state. solar.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER) # Update the system for its next state. solar.update(SEC_PER_FRAME) # Draw the frame and take a brief nap. request_redraw() sleep(TIMESTEP)
def __init__(self): global _requests print "Start parsing xml file" System.__init__(self, 9081, "http://128.97.93.154:8080/", "weatherSystem.xml") print "Registered system" # start the SOAP server SocketServer.TCPServer.__init__(self, ('128.97.93.154', 9082) , ESPRequestHandler) esphttpserver = thread.start_new_thread(self.serve_forever, ()) #the next call is blocking! print "starting..." self.start() raw_input("Press a key when done")
def test_get_state_tape_contents_and_index(self): rules = [ Rule("A", 0, 1, True, "B"), Rule("B", 0, 1, False, "A"), Rule("C", 0, 1, False, "B"), Rule("A", 1, 1, False, "C"), Rule("B", 1, 1, True, "B"), Rule("C", 1, 1, True, "HALT"), ] m = Machine(rules) t = Tape() s = System(m, t) s.next() state, contents, index = s.get_state_tape_contents_and_head_index() self.assertEqual(state, "B") self.assertEqual(contents, [1, 0]) self.assertEqual(index, 1)
def test_iterate_until_halt(self): rules = [ Rule("A", 0, 1, True, "B"), Rule("B", 0, 1, False, "A"), Rule("C", 0, 1, False, "B"), Rule("A", 1, 1, False, "C"), Rule("B", 1, 1, True, "B"), Rule("C", 1, 1, True, "HALT"), ] m = Machine(rules) t = Tape() s = System(m, t) steps = s.iterate_until_halt() self.assertEqual(steps, 14) state, contents, index = s.get_state_tape_contents_and_head_index() self.assertEqual(state, "HALT") self.assertEqual(contents, 6 * [1]) self.assertEqual(index, 4)
def main(): earth = Body(5.9736e24, 0, 0, 0, 0, 24, 0, 0, 1) # blue earth moon = Body(7.3477e22, 3.84403e8, 0, 0, 1022, 4, 1, 1, 1) # white moon earth_moon = System([earth, moon]) set_clear_color(0, 0, 0) # black background enable_smoothing() while not window_closed(): clear() # Draw the system in its current state. earth_moon.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER) # Update the system for its next state. earth_moon.update(TIMESTEP * TIME_SCALE) # Draw the frame and take a brief nap. request_redraw() sleep(TIMESTEP)
def setUp(self): obc_com = config['OBC_COM'] sys_bus_com = config['SYS_BUS_COM'] payload_bus_com = config['PAYLOAD_BUS_COM'] use_single_bus = config['SINGLE_BUS'] gpio_com = config['GPIO_COM'] self.gpio = Pins(gpio_com) extensions.set_up(test_id=self.id()) self.system = System(obc_com, sys_bus_com, payload_bus_com, use_single_bus, self.gpio, self.auto_power_on)
def main(): # initialize system system = System.getInstance() # parse commandline options = parseCommandLine() if options is None: sys.exit(1) # initialize and run PyNode node = PyNode(options) node.run()
class Signal(): def __init__(self,fc_p,fc_v,fc_a,dt=1/30.0): s = control.tf([1.0,0.0],[1.0]) self.pos = System( 1 ,dt=dt) self.vel = System( s/(1+s/(fc_v*2.0*math.pi)) ,dt=dt) self.acc = System( (s/(1+s/(fc_a*2.0*math.pi)) )**2 ,dt=dt) def append(self,s,t): self.p = self.pos.output(s,t) self.v = self.vel.output(s,t) self.a = self.acc.output(s,t) self.pos.next_state() self.vel.next_state() self.acc.next_state() def get(self): return [self.p, self.v, self.a]
def runTest( self ): context = Context( 'root' ) context.start() listener = TestListener() listener.context = context node = System( 'system', listener ) node.addListener( listener ) context.queue( Event( System.EVENT_START ), node ) # from message import * s = 'INVITE sip:[email protected] SIP/2.0\r\n' \ 'Call-ID: abcde\r\nContent-Length: 136\r\nContent-Type: application/simple-message-summary\r\n\r\nMessages-Waiting: yes\r\nMessage-Account: sip:[email protected]\r\nvoice-message: 1/5(2/4)\r\nfax-message: 0/1\r\ntext-message: 3/7\r\n' \ '\r\n' message = Request( s ) e = MessageEvent( MessageEvent.EVENT_RX, message ) context.queue( e, node ) #context.queue( Event( System.EVENT_STOP ), node ) context.stop()
def prepare(self): """ prepare new root system suitable to create an initrd from it """ self.__load_boot_xml_description() boot_image_name = self.boot_xml_state.xml_data.get_name() self.__import_system_description_elements() log.info('Preparing boot image') system = System( xml_state=self.boot_xml_state, root_dir=self.boot_root_directory, allow_existing=True ) manager = system.setup_repositories() system.install_bootstrap( manager ) system.install_system( manager ) profile = Profile(self.boot_xml_state) profile.add('kiwi_initrdname', boot_image_name) defaults = Defaults() defaults.to_profile(profile) setup = SystemSetup( self.boot_xml_state, self.__boot_description_directory(), self.boot_root_directory ) setup.import_shell_environment(profile) setup.import_description() setup.import_overlay_files( follow_links=True ) setup.call_config_script() system.pinch_system( manager=manager, force=True ) setup.call_image_script() setup.create_init_link_from_linuxrc()
def run_simulation(repo_path, gen_max): logger.info("Running simulation with: REPO_PATH={}, GENERATION_MAX={}" .format(repo_path, gen_max)) # Init base system sys=System(repo_path=repo_path) sys.setLowestVersions() sys.dump() # Init goal (latest version) goal=System.latestVersion(sys) goal.dump() # Init population pop=Population(DEFAULT_POP_SIZE, sys, goal) # Init dataframe for storing results ## TODO logger.info("Starting simulation...") for i in range(gen_max): ''' For each generation we need to go through all the genomes and evolve them (mutate/crossover/rebel) and test. The more successful a genome is (more programs installed/tests), the more likely it is to create offspring for the next generation ''' logger.info("Generation #{}".format(i)) for genome in pop.getGenomes(): # TODO some evaluation, score, record logger.info("\t{}".format(genome)) #Check if objective has been met yet if pop.isGoalMet(): # TODO logger.info("Goal configuration has been found!") break pop=pop.nextGeneration() logger.debug("System state at end of this generation") pop.sys.dump() #TODO do some final reporting logger.info("Final configuration after {} generations looks like:".format(i)) pop.sys.dump()
def reset(self): self.system = System.getInstance() self.config = AttributeDict() self.resources = [ ] self.delayedActions = set() now = datetime.now() self.updateConfig({ 'date': now, 'pynode.version': version(), 'pynode.longVersion': longVersion(), 'pynode.backup.path': '/tmp/pynode/backup', 'pynode.backup.prefix': now.strftime("%Y%m%d%H%M%S"), })
class SystemUpdateTask(CliTask): """ Implements update and maintenance of root systems """ def process(self): self.manual = Help() if self.__help(): return Privileges.check_for_root_permissions() self.load_xml_description( self.command_args['--root'] ) package_requests = False if self.command_args['--add-package']: package_requests = True if self.command_args['--delete-package']: package_requests = True log.info('Updating system') self.system = System( self.xml_state, self.command_args['--root'], allow_existing=True ) manager = self.system.setup_repositories() if not package_requests: self.system.update_system(manager) else: if self.command_args['--add-package']: self.system.install_packages( manager, self.command_args['--add-package'] ) if self.command_args['--delete-package']: self.system.delete_packages( manager, self.command_args['--delete-package'] ) def __help(self): if self.command_args['help']: self.manual.show('kiwi::system::update') else: return False return self.manual
def __init__(self,markers,ship,name): self.ship = ship # The markers tracked by the system can change over time, so save the original self.markers = list(markers) self.system = System(markers,ship.player,name)
def exercise2(): """ Main function to run for Exercise 2. Parameters ---------- None Returns ------- None """ # Define and Setup your pendulum model here # Check PendulumSystem.py for more details on Pendulum class pendulum_params = PendulumParameters() # Instantiate pendulum parameters pendulum_params.L = 0.5 # To change the default length of the pendulum pendulum_params.m = 1. # To change the default mass of the pendulum pendulum = PendulumSystem(pendulum_params) # Instantiate Pendulum object #### CHECK OUT PendulumSystem.py to ADD PERTURBATIONS TO THE MODEL ##### pylog.info('Pendulum model initialized \n {}'.format( pendulum.parameters.showParameters())) # Define and Setup your pendulum model here # Check MuscleSytem.py for more details on MuscleSytem class M1_param = MuscleParameters() # Instantiate Muscle 1 parameters M1_param.f_max = 1500 # To change Muscle 1 max force M2_param = MuscleParameters() # Instantiate Muscle 2 parameters M2_param.f_max = 1500 # To change Muscle 2 max force M1 = Muscle(M1_param) # Instantiate Muscle 1 object M2 = Muscle(M2_param) # Instantiate Muscle 2 object # Use the MuscleSystem Class to define your muscles in the system muscles = MuscleSytem(M1, M2) # Instantiate Muscle System with two muscles pylog.info('Muscle system initialized \n {} \n {}'.format( M1.parameters.showParameters(), M2.parameters.showParameters())) # Define Muscle Attachment points m1_origin = np.array([-0.17, 0.0]) # Origin of Muscle 1 m1_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 1 m2_origin = np.array([0.17, 0.0]) # Origin of Muscle 2 m2_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 2 # Attach the muscles muscles.attach(np.array([m1_origin, m1_insertion]), np.array([m2_origin, m2_insertion])) # Create a system with Pendulum and Muscles using the System Class # Check System.py for more details on System class sys = System() # Instantiate a new system sys.add_pendulum_system(pendulum) # Add the pendulum model to the system sys.add_muscle_system(muscles) # Add the muscle model to the system ##### Time ##### t_max = 3 # Maximum simulation time time = np.arange(0., t_max, 0.004) # Time vector ##### Model Initial Conditions ##### x0_P = np.array([0., 0.]) # Pendulum initial condition # Muscle Model initial condition x0_M = np.array([0., M1.L_OPT, 0., M2.L_OPT]) x0 = np.concatenate((x0_P, x0_M)) # System initial conditions ##### System Simulation ##### # For more details on System Simulation check SystemSimulation.py # SystemSimulation is used to initialize the system and integrate # over time sim = SystemSimulation(sys) # Instantiate Simulation object # Add muscle activations to the simulation # Here you can define your muscle activation vectors # that are time dependent ''' #act1 = np.ones((len(time), 1)) * 1. #act2 = np.ones((len(time), 1)) * 0.05 act1 = (np.sin((time/t_max)*10*np.pi)+1)/2 act2 = (np.sin((time/t_max)*10*np.pi + np.pi)+1)/2 act1 = np.reshape(act1, (len(time),1)) act2 = np.reshape(act2, (len(time),1)) activations = np.hstack((act1, act2)) # Plotting the results plt.figure('Activations') plt.title('Muscle activations') plt.plot(time, act1, label = 'Activation muscle 1') plt.plot(time, act2, label = 'Activation muscle 2') plt.xlabel('Time [s]') plt.ylabel('Activation') plt.legend() plt.grid() # Method to add the muscle activations to the simulation sim.add_muscle_activations(activations) ''' max_amplitude = np.zeros([10, 10]) i = 0 j = 0 # Simulate the system for given time for activation_max in np.arange(0, 1, 0.9): i = 0 for frequency in np.arange(1, 10, 4): act1 = ((np.sin( (time / t_max) * frequency * np.pi) + 1) / 2) * activation_max act2 = ((np.sin((time / t_max) * frequency * np.pi + 1) + 1) / 2) * activation_max act1 = np.reshape(act1, (len(time), 1)) act2 = np.reshape(act2, (len(time), 1)) activations = np.hstack((act1, act2)) sim.add_muscle_activations(activations) sim.initalize_system(x0, time) # Initialize the system state #: If you would like to perturb the pedulum model then you could do # so by sim.sys.pendulum_sys.parameters.PERTURBATION = False # The above line sets the state of the pendulum model to zeros between # time interval 1.2 < t < 1.25. You can change this and the type of # perturbation in # pendulum_system.py::pendulum_system function # Integrate the system for the above initialized state and time sim.simulate() # Obtain the states of the system after integration # res is np.array [time, states] # states vector is in the same order as x0 res = sim.results() # In order to obtain internal states of the muscle # you can access the results attribute in the muscle class muscle1_results = sim.sys.muscle_sys.Muscle1.results muscle2_results = sim.sys.muscle_sys.Muscle2.results max_amplitude[i, j] = np.max(np.abs(res[:, 1])) i += 1 # Plotting the results plt.figure('Pendulum') plt.title('Pendulum Phase') plt.plot(res[:, 1], res[:, 2], label='activation %.2f - frequency %f' % (activation_max, frequency)) plt.xlabel('Position [rad]') plt.ylabel('Velocity [rad.s]') plt.grid() j += 1 plt.figure('Amplitude') fig, ax1 = plt.subplots(1, 1) ax1.set_xticklabels(np.array([0, 0, 0.2, 0.4, 0.8, 1])) ax1.set_yticklabels(np.array([0, 1, 3, 5, 7, 9])) plt.title('Ampliudes') plt.imshow(max_amplitude, aspect='equal', origin='lower') plt.xlabel('Activation') plt.ylabel('Frequncy') # To animate the model, use the SystemAnimation class # Pass the res(states) and systems you wish to animate simulation = SystemAnimation(res, pendulum, muscles) # To start the animation if DEFAULT["save_figures"] is False: simulation.animate() if not DEFAULT["save_figures"]: plt.show() else: figures = plt.get_figlabels() pylog.debug("Saving figures:\n{}".format(figures)) for fig in figures: plt.figure(fig) save_figure(fig) plt.close(fig)
def zero_test(): System.register_power_hardware("HDD", 200, 200) System.register_power_hardware("HDD", 200, 200) System.register_heavy_hardware("SSD", 400, 400) print(System.analyze()) System.register_light_software("HDD", "Test", 0, 10) print(System.register_express_software("HDD", "Test2", 100, 100)) System.register_express_software("HDD", "Test3", 50, 100) System.register_light_software("SSD", "Windows", 20, 50) System.register_express_software("SSD", "Linux", 50, 100) System.register_light_software("SSD", "Unix", 20, 50) print(System.analyze()) System.release_software_component("SSD", "Linux") print(System.system_split())
from flask import Flask, render_template, request, redirect, url_for, flash from system import System app = Flask(__name__) app.secret_key = 'what is the secret key used for?' system_instance = System() @app.route('/') @app.route('/home') def home(): return render_template('home.html') @app.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'POST': user = system_instance.client_login_details( Email_inp=request.form['Email'], Password_inp=request.form['Password']) if 'message' in user: flash("Invalid Credentials !") return render_template('login.html') flash('Login Successful !!') return render_template('my_details.html', FirstName=user['FirstName'], LastName=user['LastName'], Email=user['Email'], DateOfBirth=user['DateOfBirth'], Mobile=user['Mobile'], Address=user['Address'])
import pygame from pygame.locals import * import sys from missile import Missile from player import Player from enemy import Enemy from projectile import Projectile from system import System import random TIMER_SPAWN_ENEMY = 3000 X_MARGIN_ENEMY_SPAWN = 50 # OBJECTS INITIALIZATION game_system = System('Shoot them all!', (600, 1000)) player = Player(game_system.window_center) objects = {} objects["player"] = player objects["missiles"] = [] objects["enemies"] = [] objects["projectiles"] = [] objects["effects"] = [] enemy = Enemy((random.randint(0+X_MARGIN_ENEMY_SPAWN, game_system.width-X_MARGIN_ENEMY_SPAWN), 0)) objects["enemies"].append(enemy) projectile = Projectile(game_system.window, enemy.rect.center,game_system.aim_projectile_vector(enemy,player)) # MAIN LOOP background_iter = 0
class Termud(object): def __init__(self): self.log = open("log", 'w', 0) self.boot() self.bootWorld() self.loop() def boot(self): try: self.interface = Interface() self.system = System() self.manager = Manager(self.system, self.interface) except: self.stop('Failed to boot Termud:\n\n' + traceback.format_exc()) def bootWorld(self): try: self.world = World() self.manager.setWorld(self.world) self.world.registerWindows(self.manager) self.interface.setLayoutSize(self.world.sidebarWidth, self.world.topbarHeight) self.interface.build() self.system.connect(self.world.host, self.world.port) except: self.stop('Failed to boot World:\n\n' + traceback.format_exc()) def loop(self): try: while True: sleep(1.0 / 30.0) self.step() except KeyboardInterrupt as e: self.stop("Gud bye!") except Exception as e: self.stop('Runtime error:\n\n' + traceback.format_exc()) def step(self): while True: key = self.interface.getch() if not key: break self.system.input(key) self.world.input(key, self.manager) self.interface.setInput(self.system.getInput()) actions = self.system.step() self.interface.checkResize() for action in actions: self.log.write(str(action) + "\n") if action[0] == "connected": self.world.onConnect(self.manager) if action[0] == "gmcp": self.world.handleGMCP(action[1], action[2], self.manager) else: self.interface.step(action) self.interface.refresh() def stop(self, reason=False): try: self.interface.stop() except: try: import curses curses.endwin() except: pass if reason: print reason exit()
def case(): """ In this example, one cantilever beam is bent towards another. Contact, static analysis. """ mat = { 'area': 7.85398e-5, 'elastic_modulus': 1.0e9, 'shear_modulus': 1.0e9, 'inertia_primary': 4.90874e-10, 'inertia_secondary': 4.90874e-10, 'inertia_torsion': 9.81748e-10, 'density': 8.0e-7, 'contact_radius': 0.005 } (coordinates1, elements1) = mesh.line_mesh(A=(0, 0, 0), B=(2.0, 0, 0), n_elements=3, order=1, material=mat, reference_vector=(0, 0, 1)) (coordinates2, elements2) = mesh.line_mesh(A=(0.05, 0, 0.015), B=(0.85, 0, 0.015), n_elements=2, order=1, material=mat, reference_vector=(0, 0, 1), starting_node_index=coordinates1.shape[1], possible_contact_partners=elements1, dual_basis_functions=False, n_contact_integration_points=None) coordinates1[0, 1] = 0.9 coordinates1[0, 2] = 1.2 coordinates = np.hstack((coordinates1, coordinates2)) elements = elements1 + elements2 system = System(coordinates, elements) system.time_step = 1.0 system.final_time = 101.0 system.solver_type = 'static' system.convergence_test_type = 'RES' system.contact_detection = True system.print_residual = True system.max_number_of_newton_iterations = 10 def user_distributed_force_load(self): q = [] for ele in self.elements: qe = np.zeros((6, ele.int_pts[1].n_pts)) p = 1.0 qe[2] = -p q.append(qe) return q def user_displacement_load(self): n_nodes = self.get_number_of_nodes() U = np.zeros((6, n_nodes)) if self.current_time > 1: U[0, coordinates1.shape[1]] = 1.001 / 100 return U system.degrees_of_freedom[-1][0, coordinates1.shape[ 1]] = False # [current time, dof 0 through 5, first node of the top beam] system.degrees_of_freedom[-1][ 6, coordinates1. shape[1]:] = True # [current time, dof 6, all nodes of the top beam] system.degrees_of_freedom[-1][:6, :coordinates1.shape[ 1]] = False # [current time, dof 0 through 5, all nodes of the bottom beam] system.distributed_force_load = functools.partial( user_distributed_force_load, system) system.displacement_load = functools.partial(user_displacement_load, system) return system
def main(inp): """ Main interface """ if inp is None: # generate basis of system graph = nx.gnp_random_graph(10, 0.6) dim = len(graph.nodes()) assert nx.is_connected(graph), 'Graph not connected' orig_A = nx.to_numpy_matrix(graph) orig_B = np.random.uniform(10, 20, size=dim) nz = np.nonzero(orig_A) orig_A[nz] = np.random.uniform(2, 5, size=len(nz[0])) print('Original A:\n', orig_A) print('Original B:', orig_B) omega = 3 OMEGA_list = [2.9, 3.05, 3.1, 3.2] #np.arange(3.7, 4.3, 0.05) # generate solutions data = [] for OMEGA in tqdm(OMEGA_list): runs = [] for i in trange(dim): mask = np.ones(dim, dtype=bool) mask[i] = 0 Bvec = orig_B.copy() Bvec[mask] = 0 syst = System(orig_A, Bvec, omega, OMEGA) sols, ts = syst.solve(0.01, 100) pdiffs = Reconstructor.extract_phase_differences( sols, ts, syst.Phi) #print(pdiffs) #System.plot_solution(syst.Phi(ts), sols, ts) if pdiffs is not None: runs.append(pdiffs) if len(runs) > 0: data.append(((OMEGA, omega), runs)) # cache results fname = '{}_{}'.format(datetime.now().strftime('%Y%m%d%H%M%S'), dim) np.save('cache/{}'.format(fname), { 'data': data, 'ts': ts, 'orig_A': orig_A, 'orig_B': orig_B }) else: data, ts = inp.item()['data'], inp.item()['ts'] orig_A, orig_B = inp.item()['orig_A'], inp.item()['orig_B'] dim = orig_A.shape[0] print('Original A:\n', orig_A) print('Original B:', orig_B) # reconstruct parameters recon = Reconstructor(ts, data, dim) rec_A, rec_B = recon.reconstruct() print('Reconstructed A:\n', rec_A) print('Reconstructed B:', rec_B) # plot result bundle = DictWrapper({ 'orig_A': orig_A, 'orig_B': orig_B, 'rec_A': rec_A, 'rec_B': rec_B }) show_reconstruction_overview(bundle, verbose=dim < 20)
def exercise3a(): """ Main function to run for Exercise 3. Parameters ---------- None Returns ------- None """ # Define and Setup your pendulum model here # Check Pendulum.py for more details on Pendulum class P_params = PendulumParameters() # Instantiate pendulum parameters P_params.L = 0.5 # To change the default length of the pendulum P_params.m = 1. # To change the default mass of the pendulum pendulum = PendulumSystem(P_params) # Instantiate Pendulum object #### CHECK OUT Pendulum.py to ADD PERTURBATIONS TO THE MODEL ##### pylog.info('Pendulum model initialized \n {}'.format( pendulum.parameters.showParameters())) # Define and Setup your pendulum model here # Check MuscleSytem.py for more details on MuscleSytem class M1_param = MuscleParameters() # Instantiate Muscle 1 parameters M1_param.f_max = 1500 # To change Muscle 1 max force M2_param = MuscleParameters() # Instantiate Muscle 2 parameters M2_param.f_max = 1500 # To change Muscle 2 max force M1 = Muscle(M1_param) # Instantiate Muscle 1 object M2 = Muscle(M2_param) # Instantiate Muscle 2 object # Use the MuscleSystem Class to define your muscles in the system muscles = MuscleSytem(M1, M2) # Instantiate Muscle System with two muscles pylog.info('Muscle system initialized \n {} \n {}'.format( M1.parameters.showParameters(), M2.parameters.showParameters())) # Define Muscle Attachment points m1_origin = np.array([-0.17, 0.0]) # Origin of Muscle 1 m1_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 1 m2_origin = np.array([0.17, 0.0]) # Origin of Muscle 2 m2_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 2 # Attach the muscles muscles.attach(np.array([m1_origin, m1_insertion]), np.array([m2_origin, m2_insertion])) ##### Neural Network ##### # The network consists of four neurons N_params = NetworkParameters() # Instantiate default network parameters N_params.D = 2. # To change a network parameter # Similarly to change w -> N_params.w = (4x4) array print(N_params.w) ############################# Exercise 3A ###################### N_params.w = np.transpose( np.asarray([[0, -1, 1, -1], [-1, 0, -1, 1], [-1, 0, 0, 0], [0, -1, 0, 0]])) * 5 print(N_params.w, N_params.D, N_params.tau, N_params.b, N_params.exp) # Create a new neural network with above parameters neural_network = NeuralSystem(N_params) pylog.info('Neural system initialized \n {}'.format( N_params.showParameters())) # Create system of Pendulum, Muscles and neural network using SystemClass # Check System.py for more details on System class sys = System() # Instantiate a new system sys.add_pendulum_system(pendulum) # Add the pendulum model to the system sys.add_muscle_system(muscles) # Add the muscle model to the system # Add the neural network to the system sys.add_neural_system(neural_network) ##### Time ##### t_max = 2. # Maximum simulation time time = np.arange(0., t_max, 0.001) # Time vector ##### Model Initial Conditions ##### x0_P = np.array([0., 0.]) # Pendulum initial condition # Muscle Model initial condition x0_M = np.array([0., M1.L_OPT, 0., M2.L_OPT]) x0_N = np.array([-0.5, 1, 0.5, 1]) # Neural Network Initial Conditions x0 = np.concatenate((x0_P, x0_M, x0_N)) # System initial conditions ##### System Simulation ##### # For more details on System Simulation check SystemSimulation.py # SystemSimulation is used to initialize the system and integrate # over time sim = SystemSimulation(sys) # Instantiate Simulation object # Add external inputs to neural network # sim.add_external_inputs_to_network(np.ones((len(time), 4))) # wave_h1 = np.sin(time*3)*2 #makes a sinusoidal wave from 'time' # wave_h2 = np.sin(time*3 + np.pi)*1 #makes a sinusoidal wave from 'time' # # wave_h1[wave_h1<0] = 0 #formality of passing negative values to zero # wave_h2[wave_h2<0] = 0 #formality of passing negative values to zero # # act1 = wave_h1.reshape(len(time), 1) #makes a vertical array like act1 # act2 = wave_h2.reshape(len(time), 1) #makes a vertical array like act1 # column = np.ones((len(time), 1)) # ext_in = np.hstack((act1, column, act2, column)) # sim.add_external_inputs_to_network(ext_in) sim.initalize_system(x0, time) # Initialize the system state sim.sys.pendulum_sys.parameters.PERTURBATION = False # Integrate the system for the above initialized state and time sim.simulate() # Obtain the states of the system after integration # res is np.array [time, states] # states vector is in the same order as x0 res = sim.results() # Obtain the states of the system after integration # res is np.array [time, states] # states vector is in the same order as x0 res = sim.results() # In order to obtain internal states of the muscle # you can access the results attribute in the muscle class muscle1_results = sim.sys.muscle_sys.Muscle1.results muscle2_results = sim.sys.muscle_sys.Muscle2.results # Plotting the results: Position(phase) vs time plt.figure('Pendulum Phase') plt.title('Pendulum Phase') plt.plot(res[:, 0], res[:, 1]) #to plot pendulum Position (phase) # plt.plot(res[:, 0], time) #to plot position # plt.plot(res[:, 0], res[:, -5:-1]) # to Plot neurons' states plt.xlabel('time [s]') plt.ylabel('Position [rad]') plt.grid() # Plotting the results: Velocity vs Position (phase) plt.figure('Pendulum Vel v.s. Phase') plt.title('Pendulum Vel v.s. Phase') plt.plot(res[:, 1], res[:, 2]) #to plot Velocity vs Position (phase) plt.xlabel('Position [rad]') plt.ylabel('Velocity [rad.s]') plt.grid() # Plotting the results: Velocity vs time plt.figure('Pendulum Velocity') plt.title('Pendulum Velocity') plt.plot(res[:, 0], res[:, 2]) #to plot Velocity vs Position plt.xlabel('time [s]') plt.ylabel('Velocity [rad.s]') plt.grid() # Plotting the results: Output of the network plt.figure('Network output') plt.title('Network output') plt.plot(res[:, 0], res[:, -1], label='neuron1') #to plot Velocity vs Position plt.plot(res[:, 0], res[:, -2], label='neuron2') plt.plot(res[:, 0], res[:, -3], label='neuron3') plt.plot(res[:, 0], res[:, -4], label='neuron4') plt.xlabel('time [s]') plt.ylabel('Stimulation ') plt.legend(loc='upper right') plt.grid() if DEFAULT["save_figures"] is False: plt.show() else: figures = plt.get_figlabels() pylog.debug("Saving figures:\n{}".format(figures)) for fig in figures: plt.figure(fig) save_figure(fig) plt.close(fig) # To animate the model, use the SystemAnimation class # Pass the res(states) and systems you wish to animate simulation = SystemAnimation(res, sim.sys.pendulum_sys, sim.sys.muscle_sys, sim.sys.neural_sys) # To start the animation simulation.animate()
class PasswordManager: def __init__(self, id_user: int = 0): """ Init method. """ self.database = Database() self.system = System() self.id_user = id_user self.alert = "" def menu(self): """ This method print a menu and checks the data entered by the user. """ self.system.clear_terminal() if self.alert != "": print(f"{self.alert}\n") print(("-" * 19) + " Menu " + ("-" * 19)) print("1. Create a new password") print("2. Search for all sites you have registered") print("3. Find a password for a site or application") print("Q. Quit") print("-" * 44) self.choice = input(": ").lower() while self.choice != "q" and self.choice != "1" and self.choice != "2" and self.choice != "3": print("Sorry, I don't understand !") self.choice = input(": ").lower() if self.choice == "1": self.create_new_password() elif self.choice == "2": self.search_all_sites_registered() elif self.choice == "3": self.find_password() else: self.system.exit_program("You leave the program.") def create_new_password(self): """ This method is a form to create a new password for an application or site. """ app_name = input("Please enter the application name : ").capitalize() identifier = input("Please enter the identifier : ") password = input("Please enter the password : "******"Please enter the url : ").lower() while app_name == "" or identifier == "" or password == "" or url == "": print("\nPlease complete all fields !") app_name = input( "Please enter the application name : ").capitalize() identifier = input("Please enter the identifier : ") password = input("Please enter the password : "******"Please enter the url : ").lower() verify_app_name = self.database.research_app_name( self.id_user, app_name) if verify_app_name != []: self.alert = f"{app_name} is already registered !" self.menu() password_hashed = self.hash(password) pyperclip.copy(password_hashed) pyperclip.paste() self.database.insert_new_password(self.id_user, app_name, identifier, password_hashed, url) self.alert = f"The password for the site or the application {app_name} has been saved !" self.menu() def search_all_sites_registered(self): """ This method displays all accounts of the logged in user. """ data = ("App Name: ", "Identifier: ", "Password: "******"Url: ") result = self.database.search_all_sites(self.id_user) if result == []: self.alert = "You have not registered an account !" self.menu() print("\nResult:\n") for row in result: [print(str(data[i]) + str(row[i])) for i in range(len(row))] print("") print("-" * 30) def find_password(self): """ This method saves the password of the application that the user to request. """ app_name = input( "Please enter the name of application/site : ").capitalize() result = self.database.find_password_to_application( self.id_user, app_name) if result == []: self.alert = f"{app_name} has not been registered !" self.menu() pyperclip.copy(result[0][0]) pyperclip.paste() self.alert = f"The password for {app_name} has been copied to the clipboard !" self.menu() def hash(self, password: str): """ This method encrypts the password passed as a parameter. """ return sha256((password + KEY + password).encode("utf-8")).hexdigest()
from system import System x = System() print('Rock, Paper, Scissors'+' '+'Author: Mahtab') computer_point = 0 user_point = 0 opt = True willplay = True name = None while willplay: if opt: print("Enter 'r' for rock, 'p' for paper, 's' for scissors\nRock Wins With Scissors\nPaper Wins With Rock\nScissors Wins With Paper") print() if not name: name = input('Enter Your Name Here: ') p = 'a' while p.isalpha(): p = input('Enter The Winning Point Here: ') print('Match Has Started..') print() user = '******' p = int(p) computer_point = 0 user_point = 0
import threading from system import System from random import randint process1 = threading.Thread(target=System(randint(5101, 5200), 1, 'ceico', 5000).main, args=()) process2 = threading.Thread(target=System(randint(5201, 5300), 2, 'ceico', 5000).main, args=()) process3 = threading.Thread(target=System(randint(5301, 5400), 3, 'ceico', 5000).main, args=()) process1.start() process2.start() process3.start() process1.join() process2.join() process3.join()
import main from system import System DISPLAY = False SYSTEM = System(DISPLAY) for i in range(2): main.run_simulation(SYSTEM=SYSTEM, DISPLAY=DISPLAY)
set_clear_color(0, 0, 0) # black background clear() # Draw the system in its current state. solar.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER) # Update the system for its next state. solar.update(TIMESTEP * TIME_SCALE) if pressed: planet_preview() sun = Body(1.98892e30, 0, 0, 0, 0, 30, 1, 1, 0) mercury = Body(3.30e23, 5.79e10, 0, 0, -47400, 3, 1, 0.5, 0) venus = Body(4.87e24, 1.082e11, 0, 0, -35000, 8, 0, 1, 0) earth = Body(5.9736e24, 1.496e11, 0, 0, -29800, 8, 0, 0, 1) mars = Body(6.42e23, 2.279e11, 0, 0, -24100, 4, 1, 0, 0) solar = System([sun, mercury, venus, earth, mars]) # added these variables for interactive planet creating functionality press_time = None press_coords = [] pressed = False new_planet_size = 1 start_graphics(main, 2400, framerate=FRAMERATE, height=WINDOW_HEIGHT, width=WINDOW_WIDTH, mouse_press=press, mouse_release=release)
test = Grid(*build_from_segments(((1,Ns),))) test.rectangle(1,(0.5,0.5),0.4,0.7) test.rectangle(1,(0.2,0.4),0.02,0.02) #test.show(color=(0,0,0,0.1)) amr_system = AMR_system(test) amr_system.SOR(w=w,max_iter=10000,max_time=150,tol=1e-10,verbose=False) print('amr time:',clock()-start) #amr_system.show() start = clock() system = System(Ns+1) system.add(Shape(Ns+1,1,(0.5,0.5),0.4,0.7,shape='rectangle')) system.add(Shape(Ns+1,1,(0.2,0.4),0.02,0.02,shape='rectangle')) #system.show_setup() system.SOR_single(w=w,max_iter=10000,max_time=150,tol=1e-10,verbose=False) print('normal time:',clock()-start) #system.show() source_diff = system.source_potentials - amr_system.grid.source_potentials plt.figure() plt.title('source diffs') plt.imshow(source_diff.T,origin='lower',interpolation='none')
def main(): system = System() while True: system.menu() oper = input('请输入您的操作:') if oper == '1': system.addphone() elif oper == '2': system.search_phone() elif oper == '3': system.display_all_phones() elif oper == '4': system.update_price() elif oper == '5': system.del_phone() elif oper == '6': exit() time.sleep(2)
from body import Body WINDOW_WIDTH = 400 WINDOW_HEIGHT = 400 TIME_SCALE = 100000 # real seconds per simulation second PIXELS_PER_METER = 3 / 1e7 # distance scale for the simulation FRAMERATE = 30 # frames per second TIMESTEP = 1.0 / FRAMERATE # time between drawing each frame def main(): set_clear_color(0, 0, 0) # black background clear() # Draw the system in its current state. earth_moon.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER) # Update the system for its next state. earth_moon.update(TIMESTEP * TIME_SCALE) earth = Body(5.9736e24, 0, 0, 0, 0, 24, 0, 0, 1) # blue earth moon = Body(7.3477e22, 3.84403e8, 0, 0, 1022, 4, 1, 1, 1) # white moon earth_moon = System( [earth, moon]) # list of bodies that are an object of the System class start_graphics(main, 2400, framerate=FRAMERATE)
def test_set_val_const(self): system = System() cpu = C8cpu() opcode = 0x6277 cpu.set_val_const(opcode, system) self.assertEqual(system.registers[2], 0x77)
from system import System if __name__ == '__main__': s = System.System() s.initialize() s.core()
from drawer import Drawer from system import System rules = {'X': 'F[-X][X]F[-X]+FX', 'F': 'pFF'} s = System('X', rules) d = Drawer(draw_speed=0, init_angle=0, init_size=7, fwd_amt=5, turn_amt=30, inc_amt=0.1) d.draw(s.get_str(6)) try: input('any key to exit') except: pass
loop = new_event_loop() set_event_loop(loop) loop.create_task( start_unix_server(self._read_commands_from_socket, "/home/austin/uds_socket")) loop.run_forever() async def _read_commands_from_socket(self, reader, writer): request = (await reader.read(256)) cmd = Command.Parse(request) response = cmd.exec(system=system) payload = json.dumps(response.value).encode() writer.write(cmd.command_id.encode().ljust(8, b"\0") + str(len(payload)).encode().ljust(8, b"\0") + payload) await writer.drain() writer.close() system = System(ships=[_create_test_ship()], inert_bodies=_create_asteroids()) system.clock = GameClock if __name__ == "__main__": GameClock() thread = CommandServer() thread.start() while True: print("=================== Loop {} ===================".format( system.clock.time())) responses = system.perform_tick() system.clock.next() sleep(0.05)
def __init__(self): self.manager = System()
def test_call(self): system = System() cpu = C8cpu() opcode = 0x0ABD cpu.call(opcode, system) self.assertEqual(system.pc, 0xABD)
def test_flow_goto(self): system = System() cpu = C8cpu() opcode = 0x1123 cpu.flow_goto(opcode, system) self.assertEqual(system.pc, 0x123)
from Apps.sleepSecurity import SleepSecurity from environment import Environment from system import System def update(): env.update() sys_.process() sys_.show_current_state() env = Environment() sys_ = System(env) # # # # # SENSORS # # # # # outdoor_motion_detector = MotionSensor(env) sys_.register_sensor(outdoor_motion_detector) power_meter = PowerMeter(env) sys_.register_sensor(power_meter) power_rate = PowerRate(env) sys_.register_sensor(power_rate) user_locator = UserLocator(env) sys_.register_sensor(user_locator) outdoor_brightness = OutdoorBrightnessSensor(env)
def test_call_subrutine(self): system = System() cpu = C8cpu() opcode = 0x2ABD cpu.call_subrutine(opcode, system) self.assertEqual(system.pc, 0xABD)
def test_mem_set(self): system = System() cpu = C8cpu() opcode = 0xA123 cpu.mem_set(opcode, system) self.assertEqual(system.index, 0x123)
def __init__(self,ship,system,markers,name): self.markers = list(markers) newsystem = System(markers,None,name) YellowAction.__init__(self,ship,system,newsystem)
def test_execute(self): cpu = C8cpu(testing=True) system = System() # Call instruction = 0x0123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # display_clear instruction = 0x00E0 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # flow_return instruction = 0x00EE system.stack.append(0x999) opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # flow_goto instruction = 0x1123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # call subrutine instruction = 0x2123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # skip if eqv instruction = 0x3123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # skip if neqv instruction = 0x4123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # skip if eq instruction = 0x5120 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # set val const instruction = 0x6120 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # add val const instruction = 0x7120 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # addign reg instruction = 0x8120 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # bit op or instruction = 0x8121 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # bit op and instruction = 0x8122 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # bit op xor instruction = 0x8123 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # math add instruction = 0x8124 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # math sub instruction = 0x8125 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # bit op right shift instruction = 0x8126 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # math sub regs instruction = 0x8127 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # bit op left shift instruction = 0x812E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # skip if neqr instruction = 0x9120 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # mem set instruction = 0xA12E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # flow jmp instruction = 0xB12E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # flow random_valr instruction = 0xC12E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # display instruction = 0xD12E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # key op skip eq instruction = 0xE19E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # key op skip neq instruction = 0xE1A1 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # timer get delay instruction = 0xF107 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # key op get key instruction = 0xF10A opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # set delay timer instruction = 0xF115 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # set sound timer instruction = 0xF118 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # mem add instruction = 0xF11E opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # mem set spritaddr instruction = 0xF129 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # binary coded decimal store instruction = 0xF133 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # mem reg dump instruction = 0xF155 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system) # mem reg load instruction = 0xF165 opcode = cpu.decode(instruction) cpu.execute(instruction, opcode, system)
def exercise2(): """ Main function to run for Exercise 2. Parameters ---------- None Returns ------- None """ #----------------# Exercise 2a #----------------# theta = np.linspace(-np.pi/4, np.pi/4,num=50) h1=[] a1= 1 a2a1=np.linspace(0.5,2,num=4) plt.figure('2a_Muscle_Length_vs_Theta') plt.title('Muscle Length vs Theta') plt.xlabel('Position [rad]') plt.ylabel('Muscle length [m]') plt.grid() plt.figure('2a_Moment_arm_vs_Theta') plt.title('Moment arm vs Theta') plt.xlabel('Position [rad]') plt.ylabel('Moment arm [m]') plt.grid() for i in range(0,len(a2a1)): a2=a2a1[i]*a1 L1=(np.sqrt(a1**2+a2**2+2*a1*a2*np.sin(theta))) h1=((a1*a2*np.cos(theta))/L1) plt.figure('2a_Muscle_Length_vs_Theta') plt.plot(theta,L1,label=('a2/a1 = %.1f' %(a2a1[i]))) plt.figure('2a_Moment_arm_vs_Theta') plt.plot(theta,h1,label=('a2/a1= %.1f' %(a2a1[i]))) plt.figure('2a_Muscle_Length_vs_Theta') plt.legend() plt.figure('2a_Moment_arm_vs_Theta') plt.legend() #----------------# Exercise 2a finished #----------------# # Define and Setup your pendulum model here # Check PendulumSystem.py for more details on Pendulum class pendulum_params = PendulumParameters() # Instantiate pendulum parameters pendulum_params.L = 0.5 # To change the default length of the pendulum pendulum_params.m = 1. # To change the default mass of the pendulum pendulum = PendulumSystem(pendulum_params) # Instantiate Pendulum object #### CHECK OUT PendulumSystem.py to ADD PERTURBATIONS TO THE MODEL ##### pylog.info('Pendulum model initialized \n {}'.format( pendulum.parameters.showParameters())) # Define and Setup your pendulum model here # Check MuscleSytem.py for more details on MuscleSytem class M1_param = MuscleParameters() # Instantiate Muscle 1 parameters M1_param.f_max = 1500 # To change Muscle 1 max force M2_param = MuscleParameters() # Instantiate Muscle 2 parameters M2_param.f_max = 1500 # To change Muscle 2 max force M1 = Muscle(M1_param) # Instantiate Muscle 1 object M2 = Muscle(M2_param) # Instantiate Muscle 2 object # Use the MuscleSystem Class to define your muscles in the system muscles = MuscleSytem(M1, M2) # Instantiate Muscle System with two muscles pylog.info('Muscle system initialized \n {} \n {}'.format( M1.parameters.showParameters(), M2.parameters.showParameters())) # Define Muscle Attachment points m1_origin = np.array([-0.17, 0.0]) # Origin of Muscle 1 m1_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 1 m2_origin = np.array([0.17, 0.0]) # Origin of Muscle 2 m2_insertion = np.array([0.0, -0.17]) # Insertion of Muscle 2 # Attach the muscles muscles.attach(np.array([m1_origin, m1_insertion]), np.array([m2_origin, m2_insertion])) # Create a system with Pendulum and Muscles using the System Class # Check System.py for more details on System class sys = System() # Instantiate a new system sys.add_pendulum_system(pendulum) # Add the pendulum model to the system sys.add_muscle_system(muscles) # Add the muscle model to the system ##### Time ##### t_max = 5 # Maximum simulation time time = np.arange(0., t_max, 0.001) # Time vector ##### Model Initial Conditions ##### x0_P = np.array([np.pi/4, 0.]) # Pendulum initial condition # Muscle Model initial condition x0_M = np.array([0., M1.L_OPT, 0., M2.L_OPT]) x0 = np.concatenate((x0_P, x0_M)) # System initial conditions ##### System Simulation ##### # For more details on System Simulation check SystemSimulation.py # SystemSimulation is used to initialize the system and integrate # over time sim = SystemSimulation(sys) # Instantiate Simulation object # Add muscle activations to the simulation # Here you can define your muscle activation vectors # that are time dependent activationFunction = ['sin','square'] for idx, act in enumerate(activationFunction): #----------------# Exercise 2c #----------------# w = np.linspace(0.2,4,4) # w = 0.5 # a = np.linspace(0.1,1,4) plt.figure('2c_LimitCycle_'+str(act)) # plt.figure('2c_LimitCycle_Amplitude_'+str(act)) plt.title('Pendulum Phase') plt.figure('2c_Amplitude_'+str(act)) # plt.figure('2c_Amplitude_Amplitude_'+str(act)) plt.title('Amplitude vs. Frequency') # plt.title('Amplitude vs. Stimulation Amplitude') for i in range(0,len(w)): # for i in range(0,len(a)): # plt.figure('2c_LimitCycle_Amplitude_'+str(act)) plt.figure('2c_LimitCycle_'+str(act)) print('Running simulation %d out of %d'%(i+1,len(w))) # print('Running simulation %d out of %d'%(i+1,len(a))) if act == 'sin': sinAct = np.sin(2*np.pi*w[i]*time).reshape(len(time),1) # sinAct = a[i]*np.sin(2*np.pi*w*time).reshape(len(time),1) else: sinAct = signal.square(2*np.pi*w[i]*time).reshape(len(time),1) # sinAct = a[i]*signal.square(2*np.pi*w*time).reshape(len(time),1) sinFlex = sinAct.copy() sinFlex[sinAct<0] = 0 sinExt = sinAct.copy() sinExt[sinAct>0] = 0 sinExt = abs(sinExt) sinAct1 = np.ones((len(time),1)) sinAct2 = np.ones((len(time),1)) sinAct1 = sinFlex sinAct2 = sinExt sinActivations = np.hstack((sinAct1,sinAct2)) # Method to add the muscle activations to the simulation sim.add_muscle_activations(sinActivations) # Simulate the system for given time sim.initalize_system(x0, time) # Initialize the system state #: If you would like to perturb the pedulum model then you could do # so by sim.sys.pendulum_sys.parameters.PERTURBATION = False # The above line sets the state of the pendulum model to zeros between # time interval 1.2 < t < 1.25. You can change this and the type of # perturbation in # pendulum_system.py::pendulum_system function # Integrate the system for the above initialized state and time sim.simulate() # Obtain the states of the system after integration # res is np.array [time, states] # states vector is in the same order as x0 res = sim.results() # In order to obtain internal states of the muscle # you can access the results attribute in the muscle class muscle1_results = sim.sys.muscle_sys.Muscle1.results muscle2_results = sim.sys.muscle_sys.Muscle2.results # Plotting the results plt.plot(res[:, 1], res[:, 2], label='Act. $%s(2\cdot{}\\pi\cdot{}%.1f\cdot{}t)$'%(act,w[i])) # plt.plot(res[:, 1], res[:, 2], label='Act. $%.1f\cdot{}%s(2\cdot{}\\pi\cdot{}0.5\cdot{}t)$'%(a[i],act)) plt.figure('2c_Amplitude_'+str(act)) plt.plot(time,res[:, 1], label='Frequency = %.1f'%(w[i])) # plt.figure('2c_Amplitude_Amplitude_'+str(act)) # plt.plot(time,res[:, 1], label='Amplitude = %.1f'%(a[i])) plt.figure('2c_LimitCycle_'+str(act)) # plt.figure('2c_LimitCycle_Amplitude_'+str(act)) plt.xlabel('Position [rad]') plt.ylabel('Velocity [rad/s]') plt.grid() plt.legend() plt.figure('2c_Amplitude_'+str(act)) # plt.figure('2c_Amplitude_Amplitude_'+str(act)) plt.xlabel('Time [s]') plt.ylabel('Amplitude [rad]') plt.grid() plt.legend() #----------------# Exercise 2c finished #----------------# #----------------# Exercise 2b #----------------# w = 0.5 if act == 'sin': sinAct = np.sin(2*np.pi*w*time).reshape(len(time),1) else: sinAct = signal.square(2*np.pi*w*time).reshape(len(time),1) sinFlex = sinAct.copy() sinFlex[sinAct<0] = 0 sinExt = sinAct.copy() sinExt[sinAct>0] = 0 sinExt = abs(sinExt) sinAct1 = np.ones((len(time),1)) sinAct2 = np.ones((len(time),1)) sinAct1 = sinFlex sinAct2 = sinExt activations = np.hstack((sinAct1,sinAct2)) # Method to add the muscle activations to the simulation sim.add_muscle_activations(activations) # Simulate the system for given time sim.initalize_system(x0, time) # Initialize the system state #: If you would like to perturb the pedulum model then you could do # so by sim.sys.pendulum_sys.parameters.PERTURBATION = True # The above line sets the state of the pendulum model to zeros between # time interval 1.2 < t < 1.25. You can change this and the type of # perturbation in # pendulum_system.py::pendulum_system function # Integrate the system for the above initialized state and time sim.simulate() # Obtain the states of the system after integration # res is np.array [time, states] # states vector is in the same order as x0 res = sim.results() # In order to obtain internal states of the muscle # you can access the results attribute in the muscle class muscle1_results = sim.sys.muscle_sys.Muscle1.results muscle2_results = sim.sys.muscle_sys.Muscle2.results # Plotting the results plt.figure('2b_LimitCycle_'+str(act)) plt.title('Pendulum Phase') plt.plot(res[:, 1], res[:, 2], label='Act. $%s(2\cdot{}\\pi\cdot{}%.1f\cdot{}t)$, Pert. ($t=3.2,\\theta = 1, \dot{\\theta} = -0.5$)' %(act,w)) plt.xlabel('Position [rad]') plt.ylabel('Velocity [rad/s]') plt.grid() plt.legend() plt.figure('2b_ActivationFunction_'+str(act)) plt.title('Activation Function') plt.plot(time, sinAct1, label='Flexor') plt.plot(time, sinAct2, label='Extensor') plt.xlabel('Time [s]') plt.ylabel('Activation') plt.grid() plt.legend() #----------------# Exercise 2b finished #----------------# # To animate the model, use the SystemAnimation class # Pass the res(states) and systems you wish to animate simulation = SystemAnimation(res, pendulum, muscles) # To start the animation if DEFAULT["save_figures"] is False: simulation.animate() if not DEFAULT["save_figures"]: plt.show() else: figures = plt.get_figlabels() pylog.debug("Saving figures:\n{}".format(figures)) for fig in figures: plt.figure(fig) save_figure(fig) #plt.close(fig) plt.show