def _run_jobs(self): """ Runs the control script with the selected json file """ self.is_controlling = True with open(self.window.filename, "r", encoding='utf-8') as f: events = Event.schema().load(json.load(f), many=True) ctrlr = Controller(events, self.controller_terminate) iterations = int(self.spinbox.get()) t = Thread(target=ctrlr.run, args=[iterations]) t.start()
def simulate(arm, traj, tf, dt_dyn, dt_control=None, u_inj=None): """ Inputs: arm: arm object traj: desired trajectory tf: desired final simulation time dt: desired dt for control u_inj: control injection """ dynamics = Dynamics(arm, dt_dyn) # dynamics = Dynamics(arm, dt_dyn, noise_torsion=[1e-3,0], noise_bending=[1e-3,0,0,0]) if dt_control is None: dt_control = dt_dyn else: dt_control = max(np.floor(dt_control / dt_dyn) * dt_dyn, dt_dyn) T = int(dt_control / dt_dyn) dyn_reduced = Dynamics(arm, dt_control, n=arm.state.n) controller = Controller(dyn_reduced) state_list = [] control_list = [] t_steps = int(np.floor(tf / dt_dyn)) t_arr = np.linspace(0, tf, t_steps + 1) for i, t in enumerate(t_arr): print('Progress: {:.2f}%'.format(float(i) / (len(t_arr) - 1) * 100), end='\r') # mode = finiteStateMachine(y,wp) # mode = 'none' # mode = 'damping' mode = 'mpc' if i % T == 0: j = i // T if j not in u_inj: wp = traj[:, j] y = simulateMeasurements(arm) u = controller.controlStep(y, wp, mode) else: u = {} u['rot'] = u_inj[j]['rot'] u['lat'] = u_inj[j]['lat'] arm = dynamics.dynamicsStep(arm, u) state_list.append(copy.copy(arm.state)) control_list.append(u) return state_list, control_list, t_arr
def main(): """Main function.""" # Create an instance of QApplication pycalc = QApplication(sys.argv) # Show the calculator's GUI view = GUI() view.show() # Create instances of the model and the controller Model = evaluateExpression Controller(model=Model, view=view) # Execute the calculator's main loop sys.exit(pycalc.exec_())
def est_final_params(gt_observations): # use dummy controller to run EM num_w, num_q = gt_observations.shape c = Controller(method=None, platform=None, num_workers=num_w, num_questions=num_q) params,_ = c.run_em(gt_observations) d = params['difficulties'] s = params['skills'] parse.params_to_file('gold_params.csv',params) return d,s
def Startup(self): # Importing takes sometime, therefore it will be done # while splash is being shown from gui.frame import Frame from control import Controller from project import Project self.main = Frame(None) self.control = Controller(self.main) self.fc = wx.FutureCall(1, self.ShowMain) wx.FutureCall(1, parse_comand_line) # Check for updates from threading import Thread p = Thread(target=utils.UpdateCheck, args=()) p.start()
def __init__(self, grid, astar, plan_and_drive): # other classes self.grid = grid self.astar = astar self.controller = Controller() # visual display self.fig, self.ax = plt.subplots() if plan_and_drive: self.display(False) else: self.display(True) self.l = 0.1 self.wait = 0.01 # threshold distance goal/waypoint self.threshold = 0.15
def main(screen): app_log = startLog(LOGFILE) screen.addstr(0, 0, 'Loading Nutmeg...') screen.refresh() with open('testuser-password', 'r') as passFile: PASSWORD = passFile.read().strip() HOMESERVER = 'lrizika.com' USERNAME = '******' ROOMNAME = '#test4:lrizika.com' app_log.info('Building Controller...') controller = Controller(screen, HOMESERVER, username=USERNAME, password=PASSWORD) inputController = InputController(controller) controller.stateManager.joinRoom(ROOMNAME) inputController.listen()
def main(): tf.compat.v1.disable_eager_execution() # dataset dset = Dataset(config) dset.build() config.vocab_size = len(dset.word2id) config.pos_size = len(dset.pos2id) config.ner_size = len(dset.ner2id) config.dec_start_id = dset.word2id["_GOO"] config.dec_end_id = dset.word2id["_EOS"] config.pad_id = dset.pad_id config.stop_words = dset.stop_words model = LatentBow(config) with tf.compat.v1.variable_scope(config.model_name): model.build() # controller controller = Controller(config) controller.train(model, dset)
def setUp(self) -> None: self.controller = Controller() self.controller.click_on_rel_pos( self.controller.start_button_rel_coord)
await websocket.send(json.dumps(web_config)) async def consumer_handler(websocket, path): logger.info("Client connected") await send_web_config(websocket) async for message in websocket: logger.info("Message received: {}".format(message)) try: data = json.loads(message) controller.parse(data) except ValueError: logger.warning("Message could not be parsed") __name__ = "start" # logging FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" logging.basicConfig(filename='app.log', filemode='a', format=FORMAT, level=logging.INFO) logger = logging.getLogger(__name__) logger.info("Application started") # configuration CONFIG_PATH = "config.json" controller = Controller(CONFIG_PATH) web_config = controller.get_webconfig() # websocket start_server = websockets.serve(consumer_handler, "0.0.0.0", 6789) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()
help='List of hosts') parser.add_argument('--clear', required=False, type=int, help='Clear control backup file') args = parser.parse_args() if (args.clear == 1): # Remove control layer data try: os.remove(args.control) except: pass controller = Controller(args.control) hosts = [] #hosts = [("172.17.0.2", 18861), ("172.17.0.3", 18861)] # IP,PORT TUPLE for host in args.hosts: hosts.append((host, args.port)) hasActiveHost = controller.generateNodes(hosts) if (not hasActiveHost): exit(0) k = Thread(target=t, args=(controller, )) k.start() print(f"Mounting {args.real} on {args.virtual}") FUSE(Passthrough(controller, args.real),
from threading import Thread import os import socket from control import Controller from time import sleep ip = (([ ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.") ] or [[(s.connect(("8.8.8.8", 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]]) + ["no IP found"])[0] app = Flask(__name__) api = Api(app) socketio = SocketIO(app, cors_allowed_origins="*") controller = Controller() x = 0 y = 0 connectedCount = 0 controller.Setup() def control(): print("is here") global x, y, controller while True: controller.set(x, y) sleep(0.01) thread = Thread(target=control)
# Django specific settings import os os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings") # Ensure settings are read from django.core.wsgi import get_wsgi_application application = get_wsgi_application() from control import Controller inst = Controller()
@author: Leon Bonde Larsen This is a quick test of the algorithm developed to generate s-curves in a system with varying setpoints. Most implementations are based on systems where the entire curve can be calculated on beforehand, but this is not possible in a system where the setpoint varies over time. The actual ode implemented in C++ is an exact copy of the code running in this simulation. Being just an internal test, the settings are placed in the init method on the Controller class. The controller is based on the constant jerk principle leading to linear accelerations and second order velocities. In the current test, the initial velocity is -1m/s and the user setpoint is +2m/s. What is seen in the plot is that the system first brakes with ramp to velocity 0m/S and then accelerates and decelerates to hit the 2m/s velocity. ''' from matplotlib import pyplot as plt from control import Controller plt.figure(num=None, figsize=(10, 6), dpi=80, facecolor='w', edgecolor='k') ctrl = Controller() ctrl.simulate() plt.plot(ctrl.time,ctrl.pos) plt.plot(ctrl.time,ctrl.vel) plt.plot(ctrl.time,ctrl.acc) plt.legend(["position","velocity","acceleration"]) plt.show()
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] ''' 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 = CNNEnv(args, 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 control import Controller main = Controller() main.inicio()
def turn_on_spot(v, angle, motor, g=None, c=None): """ Turn the robot or servo motor on the spot by the angle. :param v - the duty_cycle_sp at which the motor should travel at :param motor - either 'SERVO' or 'MOTOR' :param angle - If the angle is negative, it will turn CCW else CW. It sets the goal state of the robot or servo as the sum of its current heading (gyro.value()) and the angle. """ L = io.motA R = io.motB servo = io.servo gyro = io.gyro col = io.col if angle > 0: direction = 1 # set the polairty switch for the wheels elif angle < 0: direction = -1 else: # 0 degrees = no work to be done return print(direction) # -------------- ROBOT --------------------- if motor == 'ROBOT': desired_angle = gyro.value() + angle logging.info( 'Turning the robot to desired {} degrees'.format(desired_angle)) turn_control = Controller(.01, 0, 0, desired_angle, history=10) while True: signal, err = turn_control.control_signal(gyro.value()) signal, err = turn_control.control_signal(gyro.value()) if abs(err) <= 5 or io.btn.backspace: # tolerance L.stop() R.stop() L.duty_cycle_sp = v R.duty_cycle_sp = v return else: # if too small or too large, just use the default v if abs(v + signal) >= 100 or abs(v + signal) <= 20: signal = 0 L.run_direct(duty_cycle_sp=direction * abs(v + signal)) R.run_direct(duty_cycle_sp=-1 * direction * abs(v + signal)) logging.info( 'GYRO = {},\tcontrol = {},\t err={}, \tL = {}, \tR = {}'. format(gyro.value(), signal, err, L.duty_cycle_sp, R.duty_cycle_sp)) try: g.set_val(gyro.value()) c.set_val(col.value()) except AttributeError: pass # -------------- SERVO --------------------- elif motor == 'SERVO': turn_control = Controller(.001, 0, .5, servo.position + angle, history=10) # servo.duty_cycle_sp = servo.duty_cycle_sp * direction ev3.Sound.speak('Turning servo {} degrees'.format(angle)).wait() logging.info('Turning servo {} degrees'.format(angle)) while True: signal, err = turn_control.control_signal(servo.position) if abs(err) <= 4 or io.btn.backspace: # tolerance servo.stop() servo.speed_sp = v servo.duty_cycle_sp = servo.duty_cycle_sp * \ direction # return to the original number return if (v + abs(signal) >= 100): signal = 0 signal = (direction) * (v + abs(signal)) servo.run_direct(duty_cycle_sp=signal) logging.info( 'POS = {},\tcontrol = {},\t err={}, \tspd = {}'.format( servo.position, signal, err, servo.speed_sp)) try: g.set_val(gyro.value()) except AttributeError: pass else: raise NameError('motor should be "ROBOT" or "SERVO"')
def main(): con = Controller("sample.cfg", "True") con.run()
gold.get_difficulties()]), times=first_array_or_true([time_in, gold.get_times()]), skills=first_array_or_true([skill_in, gold.get_skills()]), thetas=gt_thetas) # run for p in policies: if run_once and p['type'] in ['greedy','greedy_reverse','accgain','accgain_reverse'] and p['name'] in policies_run: continue np.random.seed(rint) platform.reset() controller = Controller(policy=p, platform=platform, num_workers=platform.num_workers, num_questions=platform.num_questions, max_rounds=max_rounds_in) if 'offline' in p: r = controller.run_offline() else: r = controller.run() policies_run.add(p['name']) # save platform settings (don't have to do this every run, but we do)
import warnings warnings.simplefilter('ignore') import strategy from control import Controller agent = strategy.EdgeDetectionAgent(10) # agent = strategy.SiameseNetAgent(10) controller = Controller(agent, data_dir=None) controller.run()
class SelectSoundScreen(Screen): def __init__(self, sensor_controller, **kwargs): super().__init__(**kwargs) self.controller = sensor_controller class ThereminGUI(App): def __init__(self, controller, **kwargs): super().__init__(**kwargs) self.sensor_controller = controller def build(self): sm = ScreenManager() sm.add_widget(MenuScreen(self.sensor_controller, name='menu')) sm.add_widget(TuneScreen(self.sensor_controller, name='tune')) sm.add_widget(LoopScreen(self.sensor_controller, name='loop')) sm.add_widget(SelectSoundScreen(self.sensor_controller, name='select_sound')) sm.add_widget(OptionsScreen(self.sensor_controller, name='options')) return sm if __name__ == '__main__': if len(sys.argv) < 2: print('Usage: python3 gui.py host') host = sys.argv[1] controller = Controller(host=host) thread = controller.main() ThereminGUI(controller).run()
def train(dataset1, dataset2, initial_state, if_restore): 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=if_restore) # clear the previous files controller.remove_files() # create the Network Manager manager1 = NetworkManager(dataset1, epochs=MAX_EPOCHS, child_batchsize=CHILD_BATCHSIZE, clip_rewards=CLIP_REWARDS, acc_beta=ACCURACY_BETA) manager2 = NetworkManager(dataset2, epochs=MAX_EPOCHS, child_batchsize=CHILD_BATCHSIZE, clip_rewards=CLIP_REWARDS, acc_beta=ACCURACY_BETA) result_reward = [] result_total_reward = [] result_acc = [] result_moving_acc = [] result_explore_acc = [] result_exploit_acc = [] flag = None manager = None for trial in range(MAX_TRIALS): print("\nTrial %d:" % (trial + 1)) if 2 * trial < MAX_TRIALS: manager = manager1 if trial % 2 == 0: actions = state_space.get_local_state_space_add( int(trial / 2), initial_state) else: actions = state_space.get_local_state_space( int(trial / 2), initial_state) else: manager = manager2 with policy_sess.as_default(): K.set_session(policy_sess) flag, actions = controller.get_action( state) # get an action for the previous state # print the action probabilities # state_space.print_actions(actions) print("Actions : ", state_space.parse_state_space_list(actions)) # build a model, train and get reward and accuracy from the network manager reward, previous_acc, moving_acc = manager.get_rewards( state_space.parse_state_space_list(actions)) print("Rewards : ", reward) print("Accuracy : ", previous_acc) print("Movingacc :", moving_acc) with policy_sess.as_default(): K.set_session(policy_sess) total_reward += reward print("Total reward : ", total_reward) # actions and states are equivalent, save the state and reward state = actions controller.store_rollout(state, reward) # train the controller on the saved state and the discounted rewards loss = controller.train_step() print("Controller loss : %0.6f" % (loss)) # write the results of this trial into a file with open('train_history.csv', mode='a+') as f: data = [previous_acc, reward] data.extend(state_space.parse_state_space_list(state)) writer = csv.writer(f) writer.writerow(data) print() result_reward.append(reward) result_total_reward.append(total_reward) result_acc.append(previous_acc) result_moving_acc.append(moving_acc) if 2 * trial >= MAX_TRIALS: if not flag: result_explore_acc.append(previous_acc) else: result_exploit_acc.append(previous_acc) print("Rewards : ", result_reward) print("Total Rewards :", result_total_reward) print("Accuracy : ", result_acc) print("Moving acc : ", result_moving_acc) print("Explore acc :", result_explore_acc) print("Exploit acc : ", result_exploit_acc)
'depth': bod_depth, 'height': bod_height, 'cm': body_cm } wheel_params = { 'mass': wheel_mass, 'radius': wheel_rad, 'height': wheel_height, 'cm': wheel_cms, 'axis': wheel_axes } earth_rad = 6371 #km sat_alt = earth_rad + 300 vol_pos = (-6, 0) sat_pos0 = (6, 0) #number of iterations that the controller's cpu can run att_update = 0.01 time_sf = 10 w0 = [0, 0, 0] q0 = [1, 0, 0, 0] rate = 18 #frames/calculations per second controller = Controller(rate, body_params, q0=[1, 0, 0, 0], w0=[0, 0, 0]) anim_obj = Animate(controller, time_sf, real=False) #plt.waitforbuttonpress() #anim_obj.cid = anim_obj.orbit_fig.canvas.mpl_connect('button_press_event', anim_obj.onclick) #anim_obj.get_point() my_anim = anim_obj.make_animation() plt.show()
import tkinter as tk import gui.FirstInteface as FI import control.Controller as Con if __name__ == '__main__': root = tk.Tk() root.title("الحسابات") FI.MainInterface(root, Con.Controller()) root.mainloop()
import RPi.GPIO as GPIO import sensor import time, qwiic_vl53l1x from control import Controller c = Controller() sensor.get_sensors() pitch = sensor.get_pitch(c) volume = sensor.get_volume(c) while True: print(sensor.get_pitch(c)) print(sensor.get_volume(c)) time.sleep(2)
import logging from db import SQLQuery from control import Controller from telegram_bot import TelegramBot from config import TelegramConfig, DBConfig logging.basicConfig(filename='log', format='%(asctime)s - %(message)s', level=logging.INFO) if __name__ == '__main__': db = SQLQuery(DBConfig) controller = Controller(db) bot = TelegramBot(TelegramConfig, controller) bot.main()
def __init__(self): self.input = Controller() self.world = World(debug=True)
args = parser.parse_args() logger.critical("hoge") camera = PiCamera() # PiCamera object camera.resolution = (640, 480) camera.framerate = 30 window_size = 600 buffer = PiRGBArray(camera) # PiRGBArray object num_green = 5 time.sleep(0.1) # 100ms running = True con = serial.Serial("/dev/ttyACM0", 9600) con.write(b"I") controller = Controller(num_green, window_size) while running: for stream in camera.capture_continuous(buffer, format="bgr", use_video_port=True): frame = stream.array frame = imutils.resize(frame, width=window_size) blurred = cv2.GaussianBlur(frame, (11, 11), 0) hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) hsv = hsv[:-100, :, :] if (controller.key == "green"): centre_info = find_green(hsv) else: centre_info = find_red(hsv) controller.control(con, centre_info)
import sys from control import Controller from PyQt5.QtWidgets import QApplication if __name__ == "__main__": app = QApplication(sys.argv) control = Controller() app.exec_()