Example #1
0
def main():
    rend = renderer()
    vshader = """#version 330
        attribute vec2 inVertex;
        attribute vec4 inCol;
	uniform mat4 matrix;
	uniform vec3 lightPos;
	varying vec4 outCol;
	void main(){
		gl_Position = matrix*vec4(inVertex.xy, 1.0, 1.0);
		gl_PointSize = 15.0;
		outCol = inCol;
		
	}"""
    fshader = """#version 330
        varying vec4 outCol;
        void main(){
	    gl_FragColor = outCol;
	}"""
    rend.buildShader(vshader, fshader, ['inVertex','inCol'], ['matrix','lightPos'],
                     'default')
    cR = controller()
    sim = sbd()
    cR.addSim(sim)
    cR.addRenderer(rend)
    cR.addCallback(sim.stepSimulation)
    cR.createControls()
    cR.rend.addRenderCall(lambda rend: sim.renderParticles(rend))
    cR.loop()
Example #2
0
 def __init__(self):
     self.ctrl = controller.controller()
     #self.fm = file_manager.file_manager()
     #self.ss = file_manager.db_standard()
     #self.off = file_manager.db_offsource()
     #self.db_observer = file_manager.db_observer()
     return
Example #3
0
    def __init__(self, argv):
        risk = 4
        p = True
        yolo = False

        try:
            opts, args = getopt.getopt(argv,"ry:h", ["help", "risk", "noprint", "yolo"])
        except getopt.GetoptError:
            self.error("Invalid argument. Use <roulettebot.py -help> for instructions.")

        for opt, arg in opts:
            if opt in ("-h", "--help"):
                print "DISPLAY HELP HERE"
            elif opt in ("--noprint"):
                p = False
            elif opt in ("-r", "--risk"):
                try:
                    r = int(arg)
                except ValueError:
                    self.error(opt + " requires an int > 0")
                
                if r >= 1:
                    print "\x1b[35m[NOTICE]\x1b[0m Using risklevel " + arg
                    risk = r
                else:
                    self.error(opt + " requires and int > 0")
            elif opt in ("-y", "--yolo"):
                self.yolo = True
                self.yolorisk = int(arg)

        self.controller = controller.controller(risk, p)
        self.graphics = graphics.graphics()
Example #4
0
	def post(self):
		logger.info("Called POST")
		endpoint = self.get_argument('endpoint')
		query = self.get_argument('query')
		if endpoint == '':
			form_response = "{'error': true, 'msg': 'Please enter an endpoint.'}"
		elif query == '':
			form_response = "{'error': true, 'msg': 'Please enter a query.'}"
		else:
			#sparql.query(endpoint, query)
			#self.write(query)
			controller.controller(query, endpoint)
			form_response = "{'error': false, 'msg': 'Query registered.'}"

		if form_response:
			logger.warning(form_response)

		self.render("form.html")
Example #5
0
def cost(*params):
    c1 = 1.74070476
    k1 = 1.23444907
    k2 = 1.6318585

    control = controller.controller('slc', (c1, k1, k2))
    data = simulation.result(control, 0, 1, 0.05, *params)
    errors = np.sum(data['coords'][:, :2].transpose() ** 2, axis = 0) ** 0.5
    J = sum(errors ** 2) * data['step']
    return J
Example #6
0
def main():
    app = QApplication(sys.argv)
    window=QDialog()
    ui=Ui_Form()
    ui.setupUi(window)
    
    control=controller(ui,window)
    window.show()
    
    sys.exit(app.exec_())
    pass
Example #7
0
    def __init__(self):
        self.pub = rospy.Publisher('/command',Command, queue_size=10, latch=True)
        self.command_msg = Command()
        self.command_msg.mode = self.command_msg.MODE_ROLL_PITCH_YAWRATE_THROTTLE
        self.count = True # used for initiating time
        self.past_start = True # used for initiating time for starting trajectory

        rospy.Subscriber('/odom',Odometry,self.callback)

        # with open('/home/matiss/demo_ws/src/demo/scripts/demo.yaml','r') as f:
        #   param = yaml.safe_load(f)

        param = rospy.get_param('~')

        self.mass = param['dynamics']['mass']
        self.g = param['dynamics']['g']

        self.controller = controller(param) # initiate controller
        # calculate the equilibrium force
        self.force_adjust = param['dynamics']['mass']*param['dynamics']['g']/param['controller']['equilibrium_throttle']
    def validation(self):
        fitnessOptimForACO = []
        for i in range(30):
            n = 4
            noEpoch = 10
            noAnts = 3
            alpha = 1.9
            beta = 0.9
            rho = 0.05
            q0 = 0.5
            ctrl = controller()
            pr = Problem(ctrl)
            sol = []
            bestSol = []
            trace = {}
            for i in list(
                    itertools.permutations([item
                                            for item in range(1, n + 1)])):
                trace[i] = {}
                for j in list(
                        itertools.permutations(
                            [item for item in range(1, n + 1)])):
                    trace[i][j] = {}
                    trace[i][j] = 1

            for i in range(noEpoch):
                sol = ctrl.epoca(n, n, noAnts, trace, alpha, beta, q0,
                                 rho).copy()
                if pr.fitness(sol) < pr.fitness(bestSol):
                    bestSol = sol.copy()

            fitnessOptimForACO.append(pr.fitness(bestSol))

        plt.plot(fitnessOptimForACO)  # plotting by columns
        np1 = np.array(fitnessOptimForACO)
        std1 = np.std(np1)
        m1 = np.mean(np1)
        plt.xlabel("standard deviation= " + str(std1) + ";mean= " + str(m1) +
                   "            Trials")
        plt.ylabel("ACO algorithm" + "              Fitness")
        plt.show()
Example #9
0
    def __init__(self):
        Global.__init__(self)
        scene.width = 800
        scene.height = 600
        scene.title = "Симуляция квадрокоптера"
        scene.autoscale = False
        scene.center = vector(30, 5, 100)

        self.ground = box(pos = vector(0, self.offset, 0), length = 50, height = 0.1, width = 50, color = color.green)

        self.quad = Quadcopter()

        # PID coeffs after 456 experiments
        pParam = 3.71465074
        iParam = 4.31005646
        dParam = 4.92253341

        start_time = 0
        end_time = 25

        dt = 0.01

        # cntrllr = controller.controller('pid', (pParam, iParam, dParam))
        # result = simulation.result(cntrllr, start_time, end_time, dt)

        c1 = 0.76106523
        k1 = 1.02742286
        k2 = 0.48344825

        p, i, d = 3.93171837, 0.33270504, 2.57237279

        cntrllr = controller.controller('slc', (c1, k1, k2))
        result = simulation.result(cntrllr, start_time, end_time, dt, (p, i, d))

        times = result['times']


        for i in range(times):
            rate(times / (end_time / 1.3))
            self.quad.translate_to_state(*result['coords'][i])
            self.quad.rotate_to_state(*result['angles'][i])
Example #10
0
def main():
    """
	Check if database exists, then launch app window

	:return: returns nothing
	"""
    if db_func.db_exists('db/database'):
        db = sqlite3.connect('db/database')
        cursor = db.cursor()
    else:
        db = sqlite3.connect("db/database")
        db_func.create_db(db)
        cursor = db.cursor()

    root = tk.Tk()
    root.geometry("640x480+10+10")
    app = controller(root, db)
    root.mainloop()

    db.commit()
    db.close()
Example #11
0
def main():
	"""
	Check if database exists, then launch app window

	:return: returns nothing
	"""
	if db_func.db_exists('db/database'):
		db = sqlite3.connect('db/database')
		cursor = db.cursor()
	else:
		db = sqlite3.connect("db/database")
		db_func.create_db(db)
		cursor = db.cursor()

	root = tk.Tk()
	root.geometry("640x480+10+10")
	app = controller(root, db)
	root.mainloop()

	db.commit()
	db.close();
Example #12
0
def simulate(n_simul, agents, grid_size, fruit_ratio = 1., max_iter = 500):
    print("Simulations")
    wins = dict((id, 0.) for id in range(len(agents)))
    points = dict((id, []) for id in range(len(agents)))
    scores = dict((id, []) for id in range(len(agents)))

    iterations = []
    for it in range(n_simul):
        progressBar(it, n_simul)
        endState = controller(agents, grid_size, fruit_ratio = fruit_ratio, max_iter = max_iter, verbose = 0)
        if len(endState.snakes) == 1:
            wins[list(endState.snakes.keys())[0]] += 1. / n_simul
            points[list(endState.snakes.keys())[0]].append(list(endState.snakes.values())[0].points)

        for id in range(len(agents)):
            temp = endState.scores[id]
            scores[id].append(temp)

        iterations.append(endState.iter)
    progressBar(n_simul, n_simul)
    points = dict((id, sum(val)/len(val)) for id,val in points.items())
    return wins, points, scores, iterations
Example #13
0
def start_curator(args):
    # We need a controller
    control = controller(verbose=(verbose_level>1))
    
    # Lets create a set of sets
    if len(args)>0:
        for uri in args:
            control.add_set_by_uri(uri)

    # We have sets to deal with now
    if verbose:
        print "Project using %d photo sets" % (control.get_set_count())

    cwd = os.getcwd()
    if os.path.dirname(sys.argv[0]) == cwd:
        bp=cwd+"/../"
    else:
        bp=cwd

    sys.path.append(bp+"/ui/"+gui_mode)
    from gui import start_gui
    gui = start_gui(verbose=(verbose_level>1), basepath=bp, controller=control)
    gui.run()
Example #14
0
def main():
    c = controller()
    # using timeout to turn off light
    timeOut = datetime.datetime.now() + datetime.timedelta(seconds=6)
    placeholder = True

    while True:
        # turn off led at the start and turn on when motion is detected
        c.light(0)
        detect_ms = c.motionSensed()
        if (detect_ms):
            timeOut = datetime.datetime.now() + datetime.timedelta(seconds=6)
            c.light(1)

        # if pin was entered wrong 5 times, proceed to take picture if required
        sig = signal(detect_ms)
        name = timestamp()
        pic = c.takePic(name, detect_ms, sig)
        sendPic(name, pic)

        if (datetime.datetime.now() > timeOut):
            c.light(0)
    return
Example #15
0
def main(x=initial_x,ax=init_figure("guerledan.png",[-200,200,-100,100])):
	""" boucle principale """
	x_hat = x.copy() # position estimée
	# cap = 0
	for t in arange(0,150,dt):
		clear(ax)
		point = mission(x)
		x_hat[2,0],x_hat[3,0],x_hat[4,0] = x[2,0],x[3,0],x[4,0]

		get_position(x_hat,point) # màj position avec slam
		u = controller(x,point)

		xdot,δs=f(x,u)
		x = x + dt*xdot
		security(ax,x_hat)
		
		for centre_bouee in liste_centre_bouee:
			draw_disk(centre_bouee,2,ax,"orange",α=0.8)
		for centre_bouee in liste_centre_bouee:
			draw_disk(centre_bouee,rayon_gps_bouee,ax,"cyan",α=0.2)
		draw_arrow(-175,50,ψ,2*awind,'white')
		draw_sailboat(x,δs,u[0,0],ψ,awind,str(t))
		draw_sailboat(x_hat,δs,u[0,0],ψ,awind,str(round(t,2)),color='green', color_chassis= "yellow")
	return None
Example #16
0
 def __init__(self):
     self.controller = controller()
Example #17
0
from gen_map import Graph_Map
from controller import controller
from floyd import *
crosspath = 'C:/Dev/华为比赛/source/naive/1-map-training-1/cross.txt'
roadpath = 'C:/Dev/华为比赛/source/naive/1-map-training-1/road.txt'
carpath = 'C:/Dev/华为比赛/source/naive/1-map-training-1/car.txt'
import time
import copy

if __name__ == "__main__":
    '''
    start = time.time()
    a = copy.deepcopy(map)
    for i in range(20):
        map.crosslist = copy.deepcopy(a.crosslist)
        #map.carlist = copy.deepcopy(a.carlist)
        map.roadlist = copy.deepcopy(a.roadlist)
    print(time.time()-start)
    '''
    since = time.time()
    map = Graph_Map(crosspath, roadpath, carpath)
    dis_matrix, path_matrix = floyd(map.matrix)
    print(path_matrix)
    control = controller(map, path_matrix)
    control.main()
    print(time.time() - since, 's cost')
Example #18
0
from controller import controller
import tkinter as tk

if __name__ == '__main__':
    root = tk.Tk()
    root.withdraw()
    app = controller(root)
    root.mainloop()
Example #19
0
def main():
    """The main boucle for the program"""
    controller()
Example #20
0
 def setUp(self):
     '''
     Sets up the initial state for all the test cases.
     '''
     self.controller = controller()
     self.maths = Maths()
Example #21
0
# Thruster - Library for controlling thrusters of WSROV's ROV
# Created by WSROV team

import pygame
import serial
from pygame.locals import *

import thrusterControl
import sensors
import helper
import communication
import controller

port = ""     # port object used in init()

controller = controller.controller()
thruster = thrusterControl.thruster()

def init(port_val = "/dev/ttyACM1",
        timeout=1
         ):
    global port
    port = serial.Serial(port_val, timeout=timeout)
    pygame.joystick.init()
    global xbox
    xbox = pygame.joystick.Joystick(0)
    xbox.init()
    screen = pygame.display.set_mode((320, 160))
    pygame.display.set_caption("WSROV")
    while not port.isOpen():  # Waits until port opens
        pass
Example #22
0
    def test(self):
        cooridinates = ["a1","a2","a3","a4","a5","a6","a7","a8","a9",
                        "b1","b2","b3","b4","b5","b6","b7","b8","b9",
                        "c1","c2","c3","c4","c5","c6","c7","c8","c9",
                        "d1","d2","d3","d4","d5","d6","d7","d8","d9",
                        "e1","e2","e3","e4","e5","e6","e7","e8","e9",                        
                        "f1","f2","f3","f4","f5","f6","f7","f8","f9",
                        "g1","g2","g3","g4","g5","g6","g7","g8","g9",
                        "h1", "h2","h3","h4","h5","h6","h7","h8","h9",                        
                        "i1","i2","i3","i4","i5","i6","i7","i8","i9"]
        timeout = time.time() + 10
        while(cooridinates):
            self.getent()
            if(time.time() > timeout):
                self.root4 = tk.Tk()
                self.root4.title("Time Error")
                errMessage = "The given time has elapsed."
                self.error1 = tk.Label(self.root4, text = errMessage)
                self.error1.grid(row=0, column=0)
                self.error2 = tk.Label(self.root4, text = "Re-enter your inputs.\n Please make sure you have entered inputs of a solvable puzzle.\n If there are no errors with your inputs,\n enter an easier puzzle to solve.")
                self.error2.grid(row=1, column=0)
                self.errButton = tk.Button(self.root4, text = "Close", command=lambda:self.root4.destroy())
                self.errButton.grid(row=2, column=0)
                break
            if(self.checkError() == False):
                break
            for item in cooridinates:
                if(self.entries[item] == 0):
                    self.ctrl = ctrl.controller(item,self.entries)
                    if(self.ctrl.getCommon()[0] != 0 and len(self.ctrl.getCommon()) == 1):
                        if(item == "a1"):
                            self.a1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a2"):
                            self.a2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a3"):
                            self.a3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a4"):
                            self.a4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a5"):
                            self.a5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a6"):
                            self.a6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a7"):
                            self.a7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a8"):
                            self.a8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "a9"):
                            self.a9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b1"):
                            self.b1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b2"):
                            self.b2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b3"):
                            self.b3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b4"):
                            self.b4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b5"):
                            self.b5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b6"):
                            self.b6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b7"):
                            self.b7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b8"):
                            self.b8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "b9"):
                            self.b9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c1"):
                            self.c1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c2"):
                            self.c2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c3"):
                            self.c3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c4"):
                            self.c4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c5"):
                            self.c5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c6"):
                            self.c6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c7"):
                            self.c7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c8"):
                            self.c8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "c9"):
                            self.c9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d1"):
                            self.d1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d2"):
                            self.d2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d3"):
                            self.d3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d4"):
                            self.d4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d5"):
                            self.d5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d6"):
                            self.d6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d7"):
                            self.d7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d8"):
                            self.d8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "d9"):
                            self.d9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e1"):
                            self.e1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e2"):
                            self.e2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e3"):
                            self.e3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e4"):
                            self.e4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e5"):
                            self.e5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e6"):
                            self.e6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e7"):
                            self.e7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e8"):
                            self.e8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "e9"):
                            self.e9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f1"):
                            self.f1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f2"):
                            self.f2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f3"):
                            self.f3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f4"):
                            self.f4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f5"):
                            self.f5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f6"):
                            self.f6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f7"):
                            self.f7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f8"):
                            self.f8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "f9"):
                            self.f9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g1"):
                            self.g1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g2"):
                            self.g2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g3"):
                            self.g3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g4"):
                            self.g4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g5"):
                            self.g5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g6"):
                            self.g6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g7"):
                            self.g7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g8"):
                            self.g8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "g9"):
                            self.g9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h1"):
                            self.h1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h2"):
                            self.h2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h3"):
                            self.h3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h4"):
                            self.h4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h5"):
                            self.h5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h6"):
                            self.h6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h7"):
                            self.h7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h8"):
                            self.h8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "h9"):
                            self.h9.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i1"):
                            self.i1.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i2"):
                            self.i2.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i3"):
                            self.i3.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i4"):
                            self.i4.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i5"):
                            self.i5.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i6"):
                            self.i6.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i7"):
                            self.i7.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i8"):
                            self.i8.insert(0,self.ctrl.getCommon()[0])
                        if(item == "i9"):
                            self.i9.insert(0,self.ctrl.getCommon()[0])
                        self.entries[item] == self.ctrl.getCommon()[0]
                        cooridinates.remove(item)
                else:
                    cooridinates.remove(item)
        boxes = 0
        for key in self.entries:
            if(self.entries[key] == 0 or self.entries[key] == "0"):
                boxes = boxes + 1
        if(boxes == 0):
            self.root5 = tk.Tk()
            self.root5.title("Why?")
            self.message = tk.Label(self.root5, text = "What are you doing?\n Why would you enter something in every box?\n Do you even understand what this program is?\n")
            self.message.grid(row=0, column=0)
        if(len(cooridinates) == 0 and boxes != 0):
            var = []
            window = Tk()
            canvas = Canvas(window, width = 370, height = 270)
            window.title("Solved")
            canvas.pack()
            x0 = 10
            y0 = 50
            x1 = 60
            y1 = 100
            a0 = 10
            b0 = 50
            a1 = 60
            b1 = 100
            c0 = 10
            d0 = 50
            c1 = 60
            d1 = 100

            i = 0
            deltax = 2
            deltay = 3
            deltaa = 3
            deltab = 2
            deltac = 2
            deltad = 3

            w1 = canvas.create_text(x0,y0,text ="SOLVED!",fill="red", tag='red')
            w2 = canvas.create_text(a0,b0,text ="SOLVED!",fill="blue", tag='blue')
            w3 = canvas.create_text(c0,d0,text ="SOLVED!",fill="green", tag='green')
            try:
                while(True):
                    canvas.move('red', deltax, deltay)
                    canvas.move('blue', deltaa, deltab)
                    canvas.move('green', deltac, deltad)
                    canvas.after(20)
                    canvas.update()
                    if x1 >= 380:
                        deltax = -2
                    if x0 < 50:
                        deltax = 2
                    if y1 > 280:
                        deltay = -3
                    if y0 < 20:
                        deltay = 2
                    if a1 >= 280:
                        deltaa = -3
                    if a0 < 50:
                        deltaa = 3
                    if b1 > 280:
                        deltab = -2
                    if b0 < 20:
                        deltab = 3
                    if c1 >= 380:
                        deltac = -3
                    if c0 < 50:
                        deltac = 3
                    if d1 > 280:
                        deltad = -2
                    if d0 < 20:
                        deltad = 3
                    x0 += deltax
                    x1 += deltax
                    y0 += deltay
                    y1 += deltay
                    a0 += deltaa
                    a1 += deltaa
                    b0 += deltab
                    b1 += deltab
                    c0 += deltac
                    c1 += deltac
                    d0 += deltad
                    d1 += deltad
            except:
                canvas.mainloop()
                window.mainloop()
Example #23
0
def main():
    #threads start
    controllerObj = controller.controller()
    controllerObj.run()
 	def __init__(self):
 		tok = "8051bf89-e115-4147-8e5a-ff9d6f39f0d7"
 		url = "hermes.wha.la"
 		
		value = {
		"Command": "INIT",
		"Token": tok
		}
		headers = {
		            'Content-type': 'application/json',
		            'Accept': 'application/json',
		            }

		jvalue = json.dumps(value)
		conn = httplib.HTTPConnection(url, 80)
		conn.request('POST', '/api/hermes', jvalue, headers)
		response = conn.getresponse()
		ret = json.loads(str((response.status, response.reason, response.read())[2]))
		conn.close()
		DS = DataStore(ret["ServerState"]["ServerTiers"]["DB"]["ServerStartTurnTime"])
		ctrl = controller()
		# myFile = open('output.txt', 'w')
		# myFile.write(str(ret))
		# myFile.close()
		looptime = ret['ServerState']['ServerTiers']['DB']['ServerStartTurnTime']
		coef = (ret["ServerState"]["CostPerServer"] / ret["ServerState"]["ProfitConstant"])

		WebRefresh = ret["ServerState"]["ServerTiers"]["WEB"]["ServerStartTurnTime"]
		JavaRefresh = ret["ServerState"]["ServerTiers"]["JAVA"]["ServerStartTurnTime"]
		DBRefresh = ret["ServerState"]["ServerTiers"]["DB"]["ServerStartTurnTime"]

		DS.setCoef(coef)
		infra = False
		p = None
		research = None
		didGrid = False
		progression = [None, "GRID", "GREEN", None ]


		#while ret['ServerState']['TurnNo'] < 10080:
		while True:
			x = 0

			value = {
			"Command": "PLAY",
			"Token": tok
			}
			headers = {
			            'Content-type': 'application/json',
			            'Accept': 'application/json',
			            }
			jvalue = json.dumps(value)
			conn = httplib.HTTPConnection(url, 80)
			conn.request('POST', '/api/hermes', jvalue, headers)
			response = conn.getresponse()
			ret = json.loads(str((response.status, response.reason, response.read())[2]))
			turnnumber = ret['ServerState']['TurnNo']
			#Get demand from server
			demand = [ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']['NoOfTransactionsInput']]
			demand.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['EU']['NoOfTransactionsInput'])
			demand.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['AP']['NoOfTransactionsInput'])
			
			config = [ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']['NodeCount']]
			config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['AP']['NodeCount'])

			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['NA']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['AP']['NodeCount'])

			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['NA']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['AP']['NodeCount'])

			# if turnnumber % (DBRefresh*2):
			# 	DS.resetDemand(demand)
			# else:
			# 	DS.avgDemand(demand)
			DS.runningDemand(demand)
			DS.setConfig(config)
			coef = (ret["ServerState"]["CostPerServer"] / ret["ServerState"]["ProfitConstant"])
			DS.setCoef(coef)
			

			conn.close()

			lastProfit = ret["ServerState"]["ProfitEarned"]
			GridCost = ret["ServerState"]["ResearchUpgradeLevels"][1]["UpgradeCost"]
			GridTurns = ret["ServerState"]["ResearchUpgradeLevels"][1]["NoOfTurnsRequired"]
			GridTotalCost = GridTurns * GridCost

			#init research when its swaggin to do so
			if ret['ServerState']['TurnNo'] <= 2000 and ret["ServerState"]["ProfitAccumulated"] >= GridTotalCost/8 and GridCost < (lastProfit - (lastProfit/3)):
				didGrid = True
				try:
					if ret["ServerState"]["ResearchUpgradeState"]["GRID"] == -1:
						#research = "GREEN"
						pass
				except:
					research = "GRID"
					pass
				#p = research
			#Calculate free space

			#AVERAGE CAPACITY
			# capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2]
			# capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2)
			# capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  ) / 2)

			#97%
			capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']+ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] ) / 3]
			capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] ) / 3)
			capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit']) / 3)

			#93%
			# capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']+ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3]
			# capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3)
			# capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']) / 3)

			#100% CAPACITY
			# capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit']]
			# capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])
			# capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])

			# #90% CAPACITY
			# capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']]
			# capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])
			# capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])

			DS.setCapacity(capacity)
			webchanges = [0,0,0,0,0,0,0,0,0]
			javachanges = [0,0,0,0,0,0,0,0,0]
			dbchanges = [0,0,0,0,0,0,0,0,0]
			
			
			if turnnumber%WebRefresh == 0:
				webchanges = ctrl.calcWeb(DS,WebRefresh*1.5)
			if turnnumber%JavaRefresh == 0:
				javachanges = ctrl.calcJava(DS,JavaRefresh*1.5 )
			if turnnumber%DBRefresh == 0:
				dbchanges = ctrl.calcDB(DS,DBRefresh*1.5)

			#create 'changes' to know what servers to bring up/down
			changes = []
			changes.append(webchanges[0])
			changes.append(webchanges[1])
			changes.append(webchanges[2])
			changes.append(javachanges[3])
			changes.append(javachanges[4])
			changes.append(javachanges[5])
			changes.append(dbchanges[6])
			changes.append(dbchanges[7])
			changes.append(dbchanges[8])

			jsonchange = {"Servers":{
				"WEB":{
					"ServerRegions":{
						"AP":{
							"NodeCount":changes[2]
							},
						"EU":{
							"NodeCount":changes[1]
							},
						"NA":{
							"NodeCount":changes[0]
							}
						}
					},

				"JAVA":{
					"ServerRegions":{
						"NA":{
							"NodeCount":changes[3]
							},
						"EU":{
							"NodeCount":changes[4]
							},
						"AP":{
							"NodeCount":changes[5]
							}
						}
					},

				"DB":{
					"ServerRegions":{
						"NA":{
							"NodeCount":changes[6]
							},
						"EU":{
							"NodeCount":changes[7]
							},
						"AP":{
							"NodeCount":changes[8]
							}
						}
					}
				
					},
					"UpgradeInfraStructure": infra,
					"UpgradeToResearch": research


				}
			if research != None:
				research = None

			value = {
			"Command": "CHNG",
			"Token": tok,
			"ChangeRequest": jsonchange
			}
			headers = {
			            'Content-type': 'application/json',
			            'Accept': 'application/json',
			}
			jvalue = json.dumps(value)
			conn = httplib.HTTPConnection(url, 80)

			conn.request('POST', '/api/hermes', jvalue, headers)
			response = conn.getresponse()
			ret2 = json.loads(str((response.status, response.reason, response.read())[2]))
			conn.close()
			

			#print Stuff
			print 'Turn: ' + str(ret['ServerState']['TurnNo'])
			print 'Total Profit: $' + str(ret["ServerState"]["ProfitAccumulated"])
			# print "WEB capacity: " + str(capacity[0])
			# print "JAVA capacity: " + str(capacity[1])
			# print "DB capacity: " + str(capacity[2])
			# print "ServerCost: " + str(ret["ServerState"]["CostPerServer"])


			#print didGrid
			#if didGrid:
			try:
				inf = str(ret["ServerState"]["InfraStructureUpgradeState"]["Value"])
				if inf >=0:
					#print "INFRA value: " + inf
					pass
			except:
		 		pass
			try:
				grid = str(ret["ServerState"]["ResearchUpgradeState"]["GRID"])
				if grid != "-1":
					print "---Researching: "+ "GRID" +"---\nTurns Left: " + grid
					if int(grid) <= 1441 and int(grid) >= 1430:
						#infra = True
						pass
					else:
						infra = False
				else:
					print "GRID UPGRADE COMPLETE"
			except:
				pass

			try:
				green = str(ret["ServerState"]["ResearchUpgradeState"]["GREEN"])
				if green != "-1":
					print "---Researching: "+ "GREEN" +"---\nTurns Left: " + green
				else:
					print "GREEN UPGRADE COMPLETE"
			except:
				pass
				
				
			print demand
			print '  ' + str(config[0]) + '    ' + str(config[1]) + '    ' + str(config[2]) + '    ' + '\n  ' + str(config[3]) + '    ' + str(config[4]) + '    ' + str(config[5]) + '   ' + '\n  ' + str(config[6]) + '    ' + str(config[7]) + '    ' + str(config[8])
			print ''
			conn.close()
def bench():
    """ Integration test for controller. """

    clock = Signal(bool(False))
    clockFtdi = Signal(bool(False))
    reset = Signal(bool(False))
    
    ft245din = Signal(intbv(0)[8:])
    ft245dout = Signal(intbv(0)[8:])
    ft245rw = Signal(bool(False))
    ft245clock = Signal(bool(False))
    ft245reset = Signal(bool(False))
    ft245busy = Signal(bool(False))
    ft245oe = Signal(bool(False))
    ft245dataWaitIn = Signal(bool(False))
    ft245dataWaitOut = Signal(bool(False))
    ft245strobe = Signal(bool(False))
    dacReset = Signal(bool(False))
    dacBusy = Signal(bool(False))
    dacStrobe = Signal(bool(False))
    dacVrefTopA = Signal(intbv(0)[8:])
    dacVrefTopB = Signal(intbv(0)[8:])
    dacVrefBotA = Signal(intbv(0)[8:])
    dacVrefBotB = Signal(intbv(0)[8:])
    digipotValue = Signal(intbv(0)[7:])
    digipotReset = Signal(bool(False))
    digipotBusy = Signal(bool(False))
    digipotStrobe = Signal(bool(False))
    bufferclock = Signal(bool(False))
    bufferReset = Signal(bool(False))
    bufferDataIn = Signal(intbv(0)[16:])
    bufferDataOut = Signal(intbv(0)[16:])
    bufferReady = Signal(bool(False))
    bufferOutputInputReady = Signal(bool(False))
    bufferAllowWriteOverlap = Signal(bool(False))
    bufferUseSdram = Signal(bool(False))
    bufferDataDirection = Signal(bool(False))
    decimatorclockOut = Signal(bool(False))
    decimationRatioBase = Signal(intbv(0, min = 0, max = 11))
    decimationStyle = Signal(intbv(0)[2:])
    analogTrigger1Reset = Signal(bool(False))
    trigger1Type = Signal(bool(False))
    trigger1Slope = Signal(bool(False))
    analog1Trigger = Signal(bool(False))
    trigger1Value = Signal(intbv(0)[8:])
    analogTrigger2Reset = Signal(bool(False))
    trigger2Type = Signal(bool(False))
    trigger2Slope = Signal(bool(False))
    analog2Trigger = Signal(bool(False))
    trigger2Value = Signal(intbv(0)[8:])
    digitalTriggerReset = Signal(bool(False))
    digiTrigger = Signal(bool(False))
    triggerPattern = Signal(intbv(0)[64:])
    triggerSamples = Signal(intbv(0, min = 0, max = 4))
    decimator1out = Signal(intbv(0)[8:])
    decimator2out = Signal(intbv(0)[8:])
    decimator1in = Signal(intbv(0)[8:])
    decimator2in = Signal(intbv(0)[8:])
    adc1pd = Signal(bool(False))
    adc2pd = Signal(bool(False))
    adc1relatt = Signal(bool(False))
    adc2relatt = Signal(bool(False))
    adc1relco = Signal(bool(False))
    adc2relco = Signal(bool(False))
    led0 = Signal(bool(False))
    led1 = Signal(bool(False))
    logicAnalyzer = Signal(intbv(0)[16:])
    la1dir = Signal(bool(False))
    la2dir = Signal(bool(False))
    la1oe  = Signal(bool(False))
    la2oe  = Signal(bool(False))
    
    decimator1clockOut = Signal(bool(False))
    decimator2clockOut = Signal(bool(False))
    
    serialOut = Signal(bool(False))
    load = Signal(bool(False))
    ldac = Signal(bool(False))
    clkDacOut = Signal(bool(False))
    
    sda = TristateSignal(bool(False))
    scl = TristateSignal(bool(False))
    sda_d = sda.driver()
    scl_d = scl.driver()
    sda_dpull = sda.driver()
    scl_dpull = scl.driver()
    
    rxf = Signal(bool(False))
    txe = Signal(bool(False))
    rd = Signal(bool(False))
    wr = Signal(bool(False))
    siwu = Signal(bool(False))
    adbus = TristateSignal(intbv(0)[8:])
    
    lfsr = Signal(intbv(0)[LFSR_WIDTH:])
    adbus_drv = adbus.driver()
    data = [Signal(intbv(0)[8:]) for i in range(9)]
    
    dut_controller = controller(clockFtdi, reset, ft245din, ft245dout, ft245clock, ft245rw, ft245busy, ft245oe,
                   ft245dataWaitIn, ft245dataWaitOut, ft245strobe, ft245reset, dacReset, 
                   dacVrefTopA, dacVrefTopB, dacVrefBotA, dacVrefBotB, dacStrobe, dacBusy,
                   digipotReset, digipotValue, digipotStrobe, digipotBusy, bufferReset, 
                   bufferDataOut, bufferDataIn, bufferReady, bufferOutputInputReady, bufferclock,
                   bufferAllowWriteOverlap, bufferUseSdram, bufferDataDirection, decimator1clockOut,
                   decimationRatioBase, decimationStyle, decimator1out, decimator2out,
                   trigger1Type, trigger1Slope, analogTrigger1Reset, trigger1Value,
                   analog1Trigger, trigger2Type, trigger2Slope, analogTrigger2Reset,
                   trigger2Value, analog2Trigger, digitalTriggerReset, triggerPattern, 
                   triggerSamples, digiTrigger, adc1pd, adc2pd, adc1relatt, adc2relatt, 
                   adc1relco, adc2relco, led0, led1, logicAnalyzer, la1dir, la2dir, la1oe, la2oe)
               
    inst_decimator1 = decimator(clock, reset, decimator1in, decimator1out, decimationRatioBase, decimationStyle, decimator1clockOut)
    inst_decimator2 = decimator(clock, reset, decimator2in, decimator2out, decimationRatioBase, decimationStyle, decimator2clockOut)
    inst_trigger_analog1 = trigger_analog(decimator1clockOut, analogTrigger1Reset, decimator1out, 
                                        trigger1Type, trigger1Slope, trigger1Value, analog1Trigger)
    inst_trigger_analog2 = trigger_analog(decimator2clockOut, analogTrigger2Reset, decimator2out, 
                                        trigger2Type, trigger2Slope, trigger2Value, analog2Trigger)
    inst_trigger_digital = trigger_digital(clock, digitalTriggerReset, logicAnalyzer, triggerPattern, triggerSamples, digiTrigger)
    inst_dac_controller = dac_controller(clock, dacReset, dacVrefTopA, dacVrefTopB, dacVrefBotA, dacVrefBotB, dacStrobe, 
                                       serialOut, load, ldac, clkDacOut, dacBusy)
    inst_digipot_controller = digipot_controller(clock, digipotReset, digipotValue, digipotStrobe, digipotBusy, sda, scl)
    inst_ft245sync = ft245sync(clockFtdi, ft245reset, rxf, txe, rd, wr, ft245oe, siwu, adbus, ft245din, ft245dout, 
                               ft245rw, ft245busy, ft245dataWaitIn, ft245dataWaitOut, ft245strobe)
    inst_buffer = buff(bufferclock, bufferReset, bufferDataIn, bufferDataOut, bufferReady, bufferOutputInputReady, 
                        bufferAllowWriteOverlap, bufferUseSdram, bufferDataDirection)

    @instance
    def clkgen():
        clock.next = not clock
        yield delay(HALF_PERIOD)
    
    @instance
    def clkgen_f():
        clockFtdi.next = not clockFtdi
        yield delay(HALF_PERIOD_FTDI)
    
    @always(clock.posedge, reset.posedge)
    def lfsr_proc():
        if(reset == 1):
            lfsr.next = LFSR_SEED
        else:
            lfsr.next = concat(lfsr[LFSR_WIDTH-1:0], lfsr[9] ^ lfsr[6])
    
    @always_comb
    def adcGen():
        if(reset == 1):
            decimator1in.next = 0
            decimator2in.next = 0
        else:
            if(adc1pd):
                decimator1in.next = 0
            else:
                decimator1in.next = lfsr[10:2]
            if(adc2pd):
                decimator2in.next = 0
            else:
                decimator2in.next = lfsr[8:]
    
    @instance
    def stimulus():
        i = int(0)
        reset.next = True
        adbus_drv.next = None
        rxf.next = True
        txe.next = True
        sda_d.next = None
        scl_d.next = None
        sda_dpull.next = None
        scl_dpull.next = None
        yield delay(32)
        reset.next = False
        #set VREF
        yield ft245busy.negedge
        print ("FT245 ready")
        rxf.next = False
        print ("FT245 RXF low")
        yield clockFtdi.posedge
        yield (ft245oe.negedge)
        print ("OE came low, pushing data from FTDI")
        adbus_drv.next = 0x10
        i = 0
        data[0].next = 100
        data[1].next = 80
        data[2].next = 150
        data[3].next = 40
        data[4].next = 0
        data[5].next = 0
        data[6].next = 0
        data[7].next = 0
        data[8].next = 0
        while(rxf == 0):
            yield clockFtdi.negedge
            adbus_drv.next = data[i]
            if(i == 8):
                break
            i = i + 1
            yield clockFtdi.posedge
        yield clockFtdi.negedge
        adbus_drv.next = None
        rxf.next = True
        if(ft245busy != 0):
            print ("Error: Busy should be low")
            yield ft245busy.negedge
        #SET decimation
        print ("FT245 ready")
        rxf.next = False
        print ("FT245 RXF low")
        yield clockFtdi.posedge
        yield (ft245oe.negedge)
        print ("OE came low, pushing data from FTDI")
        adbus_drv.next = 0x30
        i = 0
        data[0].next = 0x00
        data[1].next = 0x00
        data[2].next = 0
        data[3].next = 0
        data[4].next = 0
        data[5].next = 0
        data[6].next = 0
        data[7].next = 0
        data[8].next = 0
        while(rxf == 0):
            yield clockFtdi.negedge
            adbus_drv.next = data[i]
            if(i == 8):
                break
            i = i + 1
            yield clockFtdi.posedge
        yield clockFtdi.negedge
        adbus_drv.next = None
        rxf.next = True
        if(ft245busy != 0):
            print ("Error: Busy should be low")
            yield ft245busy.negedge
        #SET attenuators
        print ("FT245 ready")
        rxf.next = False
        print ("FT245 RXF low")
        yield clockFtdi.posedge
        yield (ft245oe.negedge)
        print ("OE came low, pushing data from FTDI")
        adbus_drv.next = 0x20
        i = 0
        data[0].next = 0xFF
        data[1].next = 0xFF
        data[2].next = 0
        data[3].next = 0
        data[4].next = 0
        data[5].next = 0
        data[6].next = 0
        data[7].next = 0
        data[8].next = 0
        while(rxf == 0):
            yield clockFtdi.negedge
            adbus_drv.next = data[i]
            if(i == 8):
                break
            i = i + 1
            yield clockFtdi.posedge
        yield clockFtdi.negedge
        adbus_drv.next = None
        rxf.next = True
        if(ft245busy != 0):
            print ("Error: Busy should be low")
            yield ft245busy.negedge
        
        #SET trigger
        print ("FT245 ready")
        rxf.next = False
        print ("FT245 RXF low")
        yield clockFtdi.posedge
        yield (ft245oe.negedge)
        print ("OE came low, pushing data from FTDI")
        adbus_drv.next = 0x31
        i = 0
        data[0].next = 120
        data[1].next = 0
        data[2].next = 145
        data[3].next = 0
        data[4].next = 0
        data[5].next = 0
        data[6].next = 0
        data[7].next = 0
        data[8].next = 0
        while(rxf == 0):
            yield clockFtdi.negedge
            adbus_drv.next = data[i]
            if(i == 8):
                break
            i = i + 1
            yield clockFtdi.posedge
        yield clockFtdi.negedge
        rxf.next = True
        adbus_drv.next = None
        if(ft245busy != 0):
            print ("Error: Busy should be low")
            yield ft245busy.negedge
        #Start capture
        print ("FT245 ready")
        rxf.next = False
        print ("FT245 RXF low")
        yield clockFtdi.posedge
        yield (ft245oe.negedge)
        print ("OE came low, pushing data from FTDI")
        adbus_drv.next = 0x40
        i = 0
        data[0].next = 0xF0
        data[1].next = 0
        data[2].next = 0
        data[3].next = 0
        data[4].next = 0
        data[5].next = 0
        data[6].next = 0
        data[7].next = 0
        data[8].next = 0
        while(rxf == 0):
            yield clockFtdi.negedge
            adbus_drv.next = data[i]
            if(i == 8):
                break
            i = i + 1
            yield clockFtdi.posedge
        yield clockFtdi.negedge
        rxf.next = True
        adbus_drv.next = None
        if(ft245busy != 0):
            print ("Error: Busy should be low")
            yield ft245busy.negedge
        yield bufferDataDirection.negedge
        yield ft245busy.posedge
        txe.next = False
        yield clockFtdi.posedge
        for i in range(0, 100000):
            if(ft245dataWaitOut):
                print("Data wait out")
            print("Data:")
            print(adbus)
            yield clockFtdi.posedge
            if(bufferReady == 0):
                break
        
        raise StopSimulation

    return inst_buffer, inst_ft245sync, inst_digipot_controller, inst_dac_controller, inst_trigger_digital, lfsr_proc, adcGen, \
           inst_trigger_analog2, inst_trigger_analog1, inst_decimator2, inst_decimator1, dut_controller, clkgen, clkgen_f, stimulus
Example #26
0
#!/usr/bin/env python

import controller as c
import sys

x=c.controller(0.15,float(sys.argv[2])/100)
x.write_sequence(sys.argv[1])
x.play()
print sys.argv[1]
print sys.argv[2]
Example #27
0
from controller import controller
from model.player import Human
from model.map_placement import place_sprites, move_monsters
from model.monster_generation import generate_monsters
from view.view import max_x, max_y, board, render_map

still_playing = True 
last_move = ''

player = Human()
monsters = generate_monsters() 
rendered_map = copy.deepcopy(board)
place_sprites(rendered_map, player, monsters, max_x, max_y)

render_map(rendered_map, [])

# main game loop
while(still_playing):
    
    freshly_rendered_map = copy.deepcopy(board)
    d = raw_input("Please enter a direction (n,ne,e,se,s,sw,w,nw), hit 'enter' to repeat last command, or q to quit: ").strip("\n")

    controller_data = controller(rendered_map, last_move, player, d)
    last_move = controller_data['last_move']
    still_playing = controller_data['still_playing']

    move_monsters(board, monsters, player) # we pass board in so you can check legal moves

    rendered_map = render_map(freshly_rendered_map, [player] + monsters)
 def __init__(self):
    self.melo=c.controller()
Example #29
0
        self.hi_there["text"] = "Hello World\n(click me)"
        self.hi_there["command"] = self.say_hi
        self.hi_there.pack(side="top")

        self.quit = tk.Button(self,
                              text="QUIT",
                              fg="red",
                              command=self.master.destroy)
        self.quit.pack(side="bottom")

    def say_hi(self):
        print("hi there, everyone!")


if __name__ == "__main__":
    root = tk.Tk()
    root.geometry('200x100')
    app = Application(master=root)

    # connect flight controller
    mc = mavcomm('udp:0.0.0.0:14551')

    # bind keys
    ctr = controller(mc)
    root.bind_all("<KeyPress>", ctr.keydown)
    root.bind_all("<KeyRelease>", ctr.keyup)

    root.mainloop()

    ctr.stop_command_loop()
Example #30
0
from flask import Flask, render_template, url_for, request
from app import app

import numpy as np
import base64

from controller import controller

#Initialize the useless part of the base64 encoded image.
init_Base64 = 21

model = controller()


#First route : Render the initial drawing template
@app.route('/')
def home():
    return render_template('draw.html')


#Second route : Use our model to make prediction - render the results page.
@app.route('/predict', methods=['POST'])
def predict():

    if request.method == 'POST':

        #Access the image
        draw = request.form['url']

        #Removing the useless part of the url.
        draw = draw[init_Base64:]
def top(reset, clock, clockFtdi, adc1data, adc2data, adc1pd, adc2pd, adc1relatt, adc2relatt, 
        adc1relco, adc2relco, led0, led1, logicAnalyzer, la1dir, la2dir, la1oe, la2oe,
        serialOut, load, ldac, clkDacOut, sda, scl, rxf, oe, txe, rd, wr, siwu, adbus):
    
    decimatorNewValueFlag = Signal(bool(False))
    ft245din = Signal(intbv(0)[8:])
    ft245din.driven = 'reg'
    ft245dout = Signal(intbv(0)[8:])
    ft245dout.driven = 'reg'
    ft245rw = Signal(bool(False))
    ft245rw.driven = 'reg'
    ft245reset = Signal(bool(False))
    ft245reset.driven = 'wire'
    ft245busy = Signal(bool(False))
    ft245busy.driven = 'wire'
    ft245dataWaitIn = Signal(bool(False))
    ft245dataWaitIn.driven = 'wire'
    ft245dataWaitOut = Signal(bool(False))
    ft245dataWaitOut.driven = 'wire'
    ft245strobe = Signal(bool(False))
    ft245strobe.driven = 'wire'
    dacReset = Signal(bool(False))
    dacReset.driven = 'wire'
    dacBusy = Signal(bool(False))
    dacBusy.driven = 'wire'
    dacStrobe = Signal(bool(False))
    dacStrobe.driven = 'wire'
    dacVrefTopA = Signal(intbv(0)[8:])
    dacVrefTopA.driven = 'reg'
    dacVrefTopB = Signal(intbv(0)[8:])
    dacVrefTopB.driven = 'reg'
    dacVrefBotA = Signal(intbv(0)[8:])
    dacVrefBotA.driven = 'reg'
    dacVrefBotB = Signal(intbv(0)[8:])
    dacVrefBotB.driven = 'reg'
    digipotValue = Signal(intbv(0)[7:])
    digipotValue.driven = 'reg'
    digipotReset = Signal(bool(False))
    digipotReset.driven = 'wire'
    digipotBusy = Signal(bool(False))
    digipotBusy.driven = 'wire'
    digipotStrobe = Signal(bool(False))
    digipotStrobe.driven = 'wire'
    bufferclock = Signal(bool(False))
    bufferclock.driven = 'wire'
    bufferReset = Signal(bool(False))
    bufferReset.driven = 'wire'
    bufferDataIn = Signal(intbv(0)[32:])
    bufferDataIn.driven = 'reg'
    bufferDataOut = Signal(intbv(0)[32:])
    bufferDataOut.driven = 'reg'
    bufferReady = Signal(bool(False))
    bufferReady.driven = 'wire'
    bufferOutputInputReady = Signal(bool(False))
    bufferOutputInputReady.driven = 'wire'
    bufferAllowWriteOverlap = Signal(bool(False))
    bufferAllowWriteOverlap.driven = 'wire'
    bufferUseSdram = Signal(bool(False))
    bufferUseSdram.driven = 'wire'
    bufferDataDirection = Signal(bool(False))
    bufferDataDirection.driven = 'wire'
    decimationRatioBase = Signal(intbv(0, min = 0, max = 9))
    decimationRatioBase.driven = 'reg'
    decimationRatio = Signal(intbv(0, min = 0, max = MAXIMAL_RATIO+1))
    
    decimationStyle = Signal(intbv(0)[2:])
    decimationStyle.driven = 'reg'
    analogTrigger1Reset = Signal(bool(False))
    analogTrigger1Reset.driven = 'wire'
    trigger1Type = Signal(bool(False))
    trigger1Type.driven = 'wire'
    trigger1Slope = Signal(bool(False))
    trigger1Slope.driven = 'wire'
    analog1Trigger = Signal(bool(False))
    analog1Trigger.driven = 'wire'
    trigger1Value = Signal(intbv(0)[8:])
    trigger1Value.driven = 'reg'
    analogTrigger2Reset = Signal(bool(False))
    analogTrigger2Reset.driven = 'wire'
    trigger2Type = Signal(bool(False))
    trigger2Type.driven = 'wire'
    trigger2Slope = Signal(bool(False))
    trigger2Slope.driven = 'wire'
    analog2Trigger = Signal(bool(False))
    analog2Trigger.driven = 'wire'
    trigger2Value = Signal(intbv(0)[8:])
    trigger2Value.driven = 'reg'
    digitalTriggerReset = Signal(bool(False))
    digitalTriggerReset.driven = 'wire'
    digiTrigger = Signal(bool(False))
    digiTrigger.driven = 'wire'
    triggerPattern = Signal(intbv(0)[64:])
    triggerPattern.driven = 'reg'
    triggerSamples = Signal(intbv(0, min = 0, max = 4))
    triggerSamples.driven = 'reg'
    decimator1out = Signal(intbv(0)[8:])
    decimator1out.driven = 'reg'
    decimator2out = Signal(intbv(0)[8:])
    decimator2out.driven = 'reg'
    decimatorclock = Signal(bool(False))
    #decimatorclock.driven = 'wire'
    decimator1in = Signal(intbv(0)[8:])
    decimator2in = Signal(intbv(0)[8:])
    oe_i = Signal(bool(False))
    rxf_i = Signal(bool(False))
    txe_i = Signal(bool(False))
    rd_i = Signal(bool(False))
    wr_i = Signal(bool(False))
    siwu_i = Signal(bool(False))
    serialOut_i = Signal(bool(False))
    load_i = Signal(bool(False))
    ldac_i = Signal(bool(False))
    clkDacOut_i = Signal(bool(False))
    adc1pd_i = Signal(bool(False))
    adc2pd_i = Signal(bool(False))
    adc1relatt_i = Signal(bool(False))
    adc2relatt_i = Signal(bool(False))
    adc1relco_i = Signal(bool(False))
    adc2relco_i = Signal(bool(False))
    led0_i = Signal(bool(False))
    led1_i = Signal(bool(False))
    logicAnalyzer_i = Signal(intbv(0)[16:])
    logicAnalyzer_dec = Signal(intbv(0)[16:])
    la1dir_i = Signal(bool(False))
    la2dir_i = Signal(bool(False))
    la1oe_i  = Signal(bool(False))
    la2oe_i  = Signal(bool(False))
    clock_i = Signal(bool(False))
    clockFtdi_i = Signal(bool(False))
    reset_i = Signal(bool(False))
    alwaysEn  = Signal(bool(False))
    
    @always_comb
    def connectSignals():
        decimator1in.next = adc1data
        decimator2in.next = adc2data
        oe.next = oe_i
        rxf_i.next = rxf
        txe_i.next = txe
        rd.next = rd_i
        wr.next = wr_i
        siwu.next = siwu_i
        serialOut.next = serialOut_i
        load.next = load_i
        ldac.next = ldac_i
        clkDacOut.next = clkDacOut_i
        adc1pd.next = adc1pd_i
        adc2pd.next = adc2pd_i
        adc1relatt.next = adc1relatt_i
        adc2relatt.next = adc2relatt_i
        adc1relco.next = adc1relco_i
        adc2relco.next = adc2relco_i
        led0.next = led0_i
        led1.next = led1_i
        logicAnalyzer_i.next = logicAnalyzer
        la1dir.next = la1dir_i
        la2dir.next = la2dir_i
        la1oe.next  = la1oe_i
        la2oe.next  = la2oe_i
        clock_i.next = clock
        clockFtdi_i.next = clockFtdi
        reset_i.next = reset
    
    
    controller.vhdl_instance = "controller"
    inst_controller = controller(clockFtdi_i, reset_i, ft245din, ft245dout, ft245rw, ft245busy, oe_i, wr_i,
                   ft245dataWaitIn, ft245dataWaitOut, ft245strobe, ft245reset, dacReset, 
                   dacVrefTopA, dacVrefTopB, dacVrefBotA, dacVrefBotB, dacStrobe, dacBusy,
                   digipotReset, digipotValue, digipotStrobe, digipotBusy, bufferReset, 
                   bufferDataOut, bufferDataIn, bufferReady, bufferOutputInputReady,
                   bufferAllowWriteOverlap, bufferDataDirection, decimatorNewValueFlag,
                   decimationRatioBase, decimationStyle, decimator1out, decimator2out,
                   trigger1Type, trigger1Slope, analogTrigger1Reset, trigger1Value,
                   analog1Trigger, trigger2Type, trigger2Slope, analogTrigger2Reset,
                   trigger2Value, analog2Trigger, digitalTriggerReset, triggerPattern, 
                   triggerSamples, digiTrigger, adc1pd_i, adc2pd_i, adc1relatt_i, adc2relatt_i, 
                   adc1relco_i, adc2relco_i, led0_i, led1_i, logicAnalyzer_dec, la1dir_i, la2dir_i, la1oe_i, la2oe_i, clock_i)
    
    decimator_clock_divisor.vhdl_instance = "decimator_clock_divisor"
    inst_decimator_clock_divisor = decimator_clock_divisor(clock_i, reset_i, decimationRatioBase, decimationRatio, decimatorclock, decimatorNewValueFlag, alwaysEn)
    
    digital_decimator.vhdl_instance = "digital_decimator"
    inst_digital_decimator = digital_decimator(clock_i, reset_i, logicAnalyzer_i, logicAnalyzer_dec, decimationRatio, decimatorclock)
    
    decimator.vhdl_instance = "decimator"
    inst_decimator1 = decimator(clock_i, reset_i, decimator1in, decimator1out, decimationRatio, decimationRatioBase, decimationStyle, decimatorclock, decimatorNewValueFlag)
    inst_decimator2 = decimator(clock_i, reset_i, decimator2in, decimator2out, decimationRatio, decimationRatioBase, decimationStyle, decimatorclock, decimatorNewValueFlag)
    trigger_analog.vhdl_instance = "trigger_analog"
    inst_trigger_analog1 = trigger_analog(clock_i, analogTrigger1Reset, decimator1out, 
                                        trigger1Type, trigger1Slope, trigger1Value, analog1Trigger, decimatorclock, alwaysEn)
    inst_trigger_analog2 = trigger_analog(clock_i, analogTrigger2Reset, decimator2out, 
                                        trigger2Type, trigger2Slope, trigger2Value, analog2Trigger, decimatorclock, alwaysEn)
    trigger_digital.vhdl_instance = "trigger_digital"
    inst_trigger_digital = trigger_digital(decimatorclock, digitalTriggerReset, logicAnalyzer_dec, triggerPattern, triggerSamples, digiTrigger, decimatorclock, alwaysEn)
    dac_controller.vhdl_instance = "dac_controller"
    inst_dac_controller = dac_controller(clockFtdi_i, dacReset, dacVrefTopA, dacVrefTopB, dacVrefBotA, dacVrefBotB, dacStrobe, 
                                       serialOut_i, load_i, ldac_i, clkDacOut_i, dacBusy)
    digipot_controller.vhdl_instance = "digipot_controller"
    inst_digipot_controller = digipot_controller(clockFtdi_i, digipotReset, digipotValue, digipotStrobe, digipotBusy, sda, scl)
    
    buff.vhdl_instance = "buff"
    inst_buffer = buff(clock_i, bufferReset, bufferDataIn, bufferDataOut, bufferReady, bufferOutputInputReady, 
                        bufferAllowWriteOverlap, bufferDataDirection, decimatorclock, clockFtdi, alwaysEn)
    ft245sync.vhdl_instance = "ft245sync"
    inst_ft245sync = ft245sync(clockFtdi_i, ft245reset, rxf_i, txe_i, rd_i, wr_i, oe_i, siwu_i, adbus, ft245din, ft245dout, 
                                                   ft245rw, ft245busy, ft245dataWaitIn, ft245dataWaitOut, ft245strobe)
    return connectSignals, inst_decimator1, inst_decimator2, inst_controller, inst_trigger_analog1, inst_trigger_analog2, \
           inst_buffer, inst_ft245sync, inst_digipot_controller, inst_dac_controller, inst_trigger_digital, \
           inst_digital_decimator, inst_decimator_clock_divisor
Example #32
0
#!/usr/bin/python

import redis
import controller
import cgi
import sys
import json as jsonmod

httpcontroller = controller.controller( [] )
httpcontroller.load()		# from redis

httpr = redis.StrictRedis( host='localhost', port=6379, db=0)

# jquery is available at /js/jquery.js

try:
	if globals()['json']:
		# build dictionary
		d = {"airtemp" : int(httpcontroller.getairtemp()),
			"watertemp" : int(httpcontroller.getwatertemp()),
			"spasettemp" :  int(httpcontroller.getspasettemp()),
			"poolsettemp" :  int(httpcontroller.getpoolsettemp()),
			}
		cl = httpcontroller.getcircuitlist()
		for c in cl:
			d["circuit%s" % (c.getNumber())] = c.todict()

		print jsonmod.dumps(d)

except:		# json not defined, give a text/html response
	print '<html> <head> <title>Pool Controller</title> '
Example #33
0
opt = ''

# Argument handler
# ================

p = argparse.ArgumentParser(description=description)
p.add_argument('--opt', type=str, help='For optical. Need 1.')

args = p.parse_args()

if args.opt is not None: opt = args.opt

# Main
# ====

obs_log.start_script(name)
obs_log.weather_log()

ctrl = controller.controller()
ctrl.drive_on()
print("dome_open")
ctrl.dome_open()

if opt:
    print("memb_open")
    ctrl.memb_open()
print("Init end")
ctrl.dome_track()

obs_log.end_script(name)
Example #34
0
if obs['lo1st_sb_2'] == 'U':  #後半に似たのがあるけど気にしない
    sb2 = 1
else:
    sb2 = -1
if obs['cosydel'].lower() == 'j2000' or obs['cosydel'].lower() == 'b1950':
    cosydel = 'EQUATORIAL'
elif obs['cosydel'].lower() == 'galactic':
    cosydel = 'GALACTIC'
elif obs['cosydel'].lower() == 'horizontal':
    cosydel = 'HORIZONTAL'
else:
    print('cosydel:Error')
    sys.exit()

import controller
con = controller.controller()
con.dome_track()


def handler(num, flame):
    con.tracking_end()
    print("!!ctrl + c!!")
    print("Stop antenna")
    sys.exit()


signal.signal(signal.SIGINT, handler)

# Initial configurations
# ----------------------
Example #35
0
from controller import controller

con = controller()
con.loadFromFile()

def showMenu():
    print '1)Adauga cuvant'
    print '2)Sterge cuvant'
    print '3)Traduce text din fisier'
    return raw_input('Alegerea ta: ')



def adaugaCuvant():
    limbaSursa = raw_input('Limba sursa: ')
    cuvant = raw_input('Cuvant: ')
    limbaDestinatie = raw_input('Limba destinatie: ')
    traducerea = raw_input('Traducere: ')

    rez = con.addTraducere(limbaSursa,cuvant,limbaDestinatie,traducerea)
    if rez.succes == False:
        print rez.mesaj
    else:
        print 'Traducere adaugata'
        con.save()

def stergeCuvant():
    cuvant=raw_input('Cuvant: ')

    rez=con.stergeTraducere(cuvant)
    if rez.succes == False:
Example #36
0
 def __init__(self):
     self.ctrl = controller.controller()
     self.ccd = ccd.ccd_client("172.20.0.12", 8010)
     return
Example #37
0
Terminate()
Function: - Attempts to exit the program cleanly when called  
'''     
def Terminate(exitcode):
    sys.exit(exitcode)

'''
main()
This is the mainline section of the program and makes calls to the 
various other sections of the code
'''    
if __name__ == '__main__':
    
        ret = 0

        CON = controller()
                   
        ret = Parse(sys.argv)

        if (ret == -1):
            Usage()
            Terminate(ret) 

        ret = ConfRead()        

        if (ret == -1):
            print 'Terminated reading the configuration file...'
            Terminate(ret)

        if (CON.listmodules == True):
            ListModules()
Example #38
0
import SoftLayer
from pprint import pprint as pp
import os
import controller
import connection
import time

clear = lambda: os.system('cls')


if __name__ == '__main__':
    clear()
    try:
        db = connection.connect()
        db.start_connection()
        while (True):
            db.refresh()
            control = controller.controller(db)
            sleep(60)

    except KeyboardInterrupt:
        #clear()
        db.close_connection()
        print("The application is Exiting")
        raise SystemExit




    #spaces
Example #39
0
def loadSettings():  #Load all settings here
    global primaryController, secondaryController, boardFileName, arenaImageScale, arenarotation
    try:
        try:
            primaryController.closeWin()
            secondaryController.closeWin()
        except:
            print "No robot windows open"

        Config.read(filepath)
        #result = tkMessageBox.askquestion("Load configuration?","Are you sure you want to load? Any modifications will be deleted.", icon='warning')
        #if result == 'yes':
        e1.delete(0, END)
        e1.insert(0, Config.getint('Arena', 'datumx'))
        e2.delete(0, END)
        e2.insert(0, Config.getint('Arena', 'datumy'))
        e3.delete(0, END)
        e3.insert(0, Config.getint('Arena', 'length'))
        e4.delete(0, END)
        e4.insert(0, Config.getint('Arena', 'width'))
        boardFileName = Config.get('Arena', 'boardfilename')
        arenaImageScale[0] = Config.getfloat('Arena', 'scale')
        arenaImageScale[1] = Config.getfloat('Arena', 'scale')
        arenarotation = Config.getint('Arena', 'rotation')
        setArena()
        primaryController = controller(w, primaryWindow, pixeltoCM, datum,
                                       boundsize, "Primary", "white", "blue")
        primaryController.e5.delete(0, END)
        primaryController.e5.insert(0, Config.getint('Primary', 'startx'))
        primaryController.e6.delete(0, END)
        primaryController.e6.insert(0, Config.getint('Primary', 'starty'))
        primaryController.e7.delete(0, END)
        primaryController.e7.insert(0, Config.getint('Primary', 'heading'))
        primaryController.e8.delete(0, END)
        primaryController.e8.insert(0, Config.getint('Primary', 'track'))
        primaryController.e9.delete(0, END)
        primaryController.e9.insert(0, Config.getint('Primary', 'diameter'))
        primaryController.setPrimary()
        secondaryController = controller(w, primaryWindow, pixeltoCM, datum,
                                         boundsize, "Secondary", "black",
                                         "yellow")
        secondaryController.e5.delete(0, END)
        secondaryController.e5.insert(0, Config.getint('Secondary', 'startx'))
        secondaryController.e6.delete(0, END)
        secondaryController.e6.insert(0, Config.getint('Secondary', 'starty'))
        secondaryController.e7.delete(0, END)
        secondaryController.e7.insert(0, Config.getint('Secondary', 'heading'))
        secondaryController.e8.delete(0, END)
        secondaryController.e8.insert(0, Config.getint('Secondary', 'track'))
        secondaryController.e9.delete(0, END)
        secondaryController.e9.insert(0, Config.getint('Secondary',
                                                       'diameter'))
        secondaryController.setPrimary()
        print "Config loaded"
        #else:
        #    print "Load failed."
    except:
        tkMessageBox.showerror(
            "Error!", "Config file doesn't exist. Please save before loading.")
        primaryController = controller(w, primaryWindow, pixeltoCM, datum,
                                       boundsize)
        secondaryController = controller(w, primaryWindow, pixeltoCM, datum,
                                         boundsize)
Example #40
0
 def isa_facebook(self):
     ip = self.parser.get('elastic', 'isa')
     es = Elasticsearch(ip, port=5200)
     if 'user_id' in request.args:
         userid = request.args['user_id']
         query = es.search(index='ima-facebook-*',
                           body={
                               "sort": [{
                                   "created_at": {
                                       "order": "desc"
                                   }
                               }],
                               "query": {
                                   "bool": {
                                       "must": [{
                                           "match": {
                                               "user_id":
                                               "{}".format(userid)
                                           }
                                       }]
                                   }
                               },
                               "size": 1
                           })
         if query['hits']['total'] == 0:
             last_update = bool(False)
             source = "not found"
             last_data_stream = bool(False)
         else:
             _source = query['hits']['hits'][0]['_source']
             source = _source['user_full_name']
             last_data_stream = "https://fb.com/{}".format(_source['id'])
             last = _source['created_at']
             lasted = re.sub('\+[^\s]+', '', last)
             utc_to_local = datetime.strptime(lasted,
                                              '%a %b %d %H:%M:%S %Y')
             utc_to_local = utc_to_local.replace(tzinfo=self.from_zone)
             last_update = str(utc_to_local.astimezone(self.to_zone))
         jsons = {
             "source": source,
             "last_update": last_update,
             "last_data_stream": last_data_stream
         }
         if 'date' in request.args:
             date = request.args['date']
             spliter = str(date).split('-')
             if spliter.__len__() == 2:
                 day = controller().getdays(int(spliter[0]),
                                            int(spliter[1]))
                 getpost = es.search(
                     index='ima-facebook-*',
                     body={
                         "sort": [{
                             "created_at": {
                                 "order": "desc"
                             }
                         }],
                         "query": {
                             "bool": {
                                 "must": [{
                                     "match": {
                                         "user_id": "{}".format(userid)
                                     }
                                 }, {
                                     "range": {
                                         "created_at": {
                                             "gte":
                                             "{}-01 00:00:00".format(date),
                                             "lte":
                                             "{0}-{1} 23:59:59".format(
                                                 date, day),
                                             "format":
                                             "yyyy-MM-dd HH:mm:ss",
                                             "time_zone":
                                             "+07:00"
                                         }
                                     }
                                 }]
                             }
                         },
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         },
                         "size": 0
                     })
                 getcomment = es.search(
                     index='ima-facebook-*',
                     body={
                         "sort": [{
                             "created_at": {
                                 "order": "desc"
                             }
                         }],
                         "query": {
                             "bool": {
                                 "must": [{
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "page_id":
                                                 "{}".format(userid)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{}-01 00:00:00".
                                                     format(date),
                                                     "lte":
                                                     "{0}-{1} 23:59:59".
                                                     format(date, day),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "status": "comment"
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{}-01 00:00:00".
                                                     format(date),
                                                     "lte":
                                                     "{0}-{1} 23:59:59".
                                                     format(date, day),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }]
                             }
                         },
                         "size": 0
                     })
             elif spliter.__len__() == 3:
                 getpost = es.search(
                     index='ima-facebook-*',
                     body={
                         "sort": [{
                             "created_at": {
                                 "order": "desc"
                             }
                         }],
                         "query": {
                             "bool": {
                                 "must": [{
                                     "match": {
                                         "user_id": "{}".format(userid)
                                     }
                                 }, {
                                     "range": {
                                         "created_at": {
                                             "gte":
                                             "{} 00:00:00".format(date),
                                             "lte":
                                             "{} 23:59:59".format(date),
                                             "format":
                                             "yyyy-MM-dd HH:mm:ss",
                                             "time_zone": "+07:00"
                                         }
                                     }
                                 }]
                             }
                         },
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         },
                         "size": 0
                     })
                 getcomment = es.search(
                     index='ima-facebook-*',
                     body={
                         "sort": [{
                             "created_at": {
                                 "order": "desc"
                             }
                         }],
                         "query": {
                             "bool": {
                                 "must": [{
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "page_id":
                                                 "{}".format(userid)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{} 00:00:00".format(
                                                         date),
                                                     "lte":
                                                     "{} 23:59:59".format(
                                                         date),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "status": "comment"
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{} 00:00:00".format(
                                                         date),
                                                     "lte":
                                                     "{} 23:59:59".format(
                                                         date),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }]
                             }
                         },
                         "size": 0
                     })
             else:
                 getcomment = False
                 getpost = False
             totalcom = getcomment['hits']['total']
             totalpost = getpost['hits']['total']
             postdetails = controller().getdetails(getpost)
             jsons['Data'] = {'post_total': totalpost, 'comment': totalcom}
             if 'details' in request.args:
                 jsons['Data']['post_details'] = postdetails
         result = json.dumps(jsons)
         return result
     else:
         return 'No parameter'
    dronesID = list(OFFSETS.keys())

    ip_id = f"127.0.0.{options.ip}"
    client = airsim.MultirotorClient(ip=ip_id)
    client.confirmConnection()

    if GLOBAL_HAWK_ACTIVE:
        setGlobalHawk(client)

    controllers = []
    for drone in dronesID:
        controllers.append(
            controller(client,
                       drone,
                       OFFSETS[drone],
                       ip=options.ip,
                       wayPointsSize=wayPointsSize,
                       estimatorWindow=options.estimatorWindow))

    # Setting Camera Orientation
    for ctrl in controllers:
        ctrl.setCameraOrientation(CAM_YAW, CAM_PITCH, CAM_ROOL)

    print("Taking off all drones")
    tasks = []
    for ctrl in controllers:
        t = ctrl.takeOff()
        tasks.append(t)
    for t in tasks:
        t.join()
def main():
    squirrel = sqrl()
    nm = nuts_manager(squirrel)
    if squirrel.dic_argv.get("mode", False) == "controller":
        ct = controller(squirrel)
        ct.daemon_controller()
    elif squirrel.dic_argv.get("mode", False) == "cronjob" \
      or squirrel.dic_argv.get("mode", False) == "rotation-apps" \
      or squirrel.dic_argv.get("mode", False) == "rotation-secrets":

        if squirrel.dic_argv.get("mode", False) == "cronjob" \
          or squirrel.dic_argv.get("mode", False) == "rotation-apps":
            print("[INFO] Exec rotation credentials for apps")
            nm.rotation()
        if squirrel.dic_argv.get("mode", False) == "cronjob" \
          or squirrel.dic_argv.get("mode", False) == "rotation-secrets":
            print("[INFO] Exec rotation secrets")
            nm.rotation_secrets()

    elif squirrel.dic_argv.get("mode", False) == "client-create-key":
        pass_not_ok = True
        while pass_not_ok:
            key_pass = getpass("Password: "******"Enter the password again: ")
            if key_pass == key_pass_copy:
                pass_not_ok = False
                key_file = squirrel.dic_argv.get("key-file", False)
                email = squirrel.dic_argv.get("email", False)
                bits = squirrel.dic_argv.get("bits", 4096)
                if email and key_file:
                    nm.createKey(key_file, email, key_pass, bits, "RSA")
                else:
                    print(
                        "Use: mode='client-create-key' key-file='local.pub' email='*****@*****.**'"
                    )
            else:
                print("Passwords do not match...")
    elif squirrel.dic_argv.get("mode", False) == "import-key":
        key_file = squirrel.dic_argv.get("key-file", False)
        if key_file:
            nm.importKey(key_file)
        else:
            print("Use: mode='import-key' key-file='local.pub'")
    elif squirrel.dic_argv.get("mode", False) == "decrypt-text":
        # Decrypt for client
        encrypted_string = squirrel.dic_argv.get("encrypted-string", False)
        if encrypted_string:
            key_pass = getpass()
            print(nm.dencryptText(key_pass, encrypted_string, "base64"))
        else:
            print("Use: mode='decrypt-text' encrypted-string='XXXXXXXXX'")
    elif squirrel.dic_argv.get("mode", False) == "encrypt-text":
        email = squirrel.dic_argv.get("email", False)
        text = squirrel.dic_argv.get("text", False)
        if email:
            print(nm.encryptText(email, text))
        else:
            print(
                "Use: mode='encrypt-text' email='*****@*****.**' text='hello!'"
            )
    elif squirrel.dic_argv.get("mode", False) == "list-keys":
        print(squirrel.gpg.list_keys())
    else:
        print("Use: mode=(controller or cronjob)")
def main():
    env = SlipEnv(0.001)

    obs_dim = env.observation_space.shape[0]
    action_dim = env.action_space.shape[0]

    X, y = Tensor(TRJ_LEN, obs_dim), Tensor(TRJ_LEN, action_dim)
    epoch_losses = np.zeros(EPOCHS * DAGGER_ITR)

    imitation_policy = MLP(obs_dim, action_dim, (N, ), F.tanh)

    #scheduler = LambdaLR(imitation_policy.optimizer,
    #                     lambda itr: 1 / (itr + 1))

    loss_plt, = ax.plot([], [])
    plt.ylabel("MSE Loss")
    plt.xlabel("Epoch")
    plt.tight_layout()

    dagger_init = True
    for d in range(DAGGER_ITR):
        #scheduler.step()

        X_new, y_new = Tensor(TRJ_LEN, obs_dim), Tensor(TRJ_LEN, action_dim)

        obs = env.reset().astype(float)
        for t in range(TRJ_LEN):
            action = imitation_policy(V(Tensor(obs[None, :]))).data.numpy()
            action = action[0].astype(float)

            expert_action = controller(env.cstate, 0, 1, 0)
            if dagger_init:
                obs = env.step(expert_action)[0].astype(float)
                X[t, :], y[t, :] = Tensor(obs), Tensor(expert_action)

            else:
                obs, _, done, _ = env.step(action)
                if done:
                    print(t)
                    X_new, y_new = X_new[0:t, :], y_new[0:t, :]
                    break

                obs = obs.astype(float)
                X_new[t, :], y_new[t, :] = Tensor(obs), Tensor(expert_action)

            # print(expert_action-action)
            env.render()

        if not dagger_init:
            X, y = torch.cat((X, X_new), 0), torch.cat((y, y_new), 0)

        dataset = SplitDataset(X.numpy(), y.numpy())
        dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)

        for e in range(EPOCHS):
            running_loss = 0
            for batch_idx, (X_batch, y_batch) in enumerate(dataloader):
                X_batch, y_batch = V(Tensor(X_batch)), V(Tensor(y_batch))

                running_loss += imitation_policy.fit(X_batch, y_batch)[0]
                progress(e * len(dataloader) + batch_idx,
                         len(dataloader) * EPOCHS,
                         "DAgger iteration: %s / %s" % (d + 1, DAGGER_ITR))

            # plotting stuff
            epoch_losses[d * EPOCHS + e] = running_loss / len(dataloader)
            progress_plot(fig, ax, d * EPOCHS + e, loss_plt, epoch_losses)

        torch.save(imitation_policy, "model001.pkl")
        dagger_init = False

    plt.ioff()
    plt.show()
    """
    env.reset()
    for t in range(5000):
        action = controller(env.cstate, 0, 1, 0)
        env.step(action)
        time.sleep(1/float(1000))
        env.render()
    """

    render_policy(env, imitation_policy, EVAL_LEN)
    plot_policy(env, EVAL_LEN, 1, imitation_policy)
    plt.tight_layout()
    plt.show()
Example #44
0
 def __init__(self):
     self.controller = controller()
     self.ci = clientInterface(self.controller)
Example #45
0
#!/usr/bin/python

import redis
import controller
import cgi
import sys
import json as jsonmod
import circuit
import time

httpcontroller = controller.controller( [] )
httpcontroller.load()		# from redis
httpr = redis.StrictRedis( host='localhost', port=6379, db=0)

# jquery is available at /js/jquery.js

if 'method' in globals() and method == 'GET':
	print '["status":"Invalid GET request. You need to POST."]'
else:
	# check for json POST
	if 'json' in globals():
		json = 1
	else:
		json = 0;

	if json == 1:
		# take json input and convert to object
		params = jsonmod.loads(query_string)
		updatecontroller = controller.controller([])
		for i in params.keys():
			if i == "spasettemp":
Example #46
0
    sez = categorie.get(sezione)
    # print (len(termini), "" ,len(terms_to_recap))
    chosen_cat_for_stat = chosen_cat_for_stat.removesuffix(",")
    #print (chosen_cat_for_stat)
    #print(terms_to_recaprs)
    controllerEx.gestisci_ripasso_sezione(terms_to_recap, categorie,
                                          chosen_cat_for_stat, stats)


# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    filename = "vocabolario.txt"
    termini = []
    categorie = {}
    stats = []
    controllerEx = controller.controller()
    controllerEx.welcome_message()
    controllerEx.loadFile(termini, categorie, filename)
    termini_counter = len(termini)
    if termini_counter == 0:
        print("Nessun termine presente in ", filename,
              " il programma sarà chiuso")
        exit(0)
    else:
        print("Caricati: ", termini_counter, "termini\n\n")

    stats = controllerEx.loadStats(stats)

    #menu()
    #ripassa_tutto()
    #ripassa_sezione("1")
Example #47
0
 def isa_twitter(self):
     ip = self.parser.get('elastic', 'isa')
     es = Elasticsearch(ip, port=5200)
     if 'username' in request.args:
         username = request.args['username']
         query = es.search(index='ima-twitter-*',
                           body={
                               "sort": [{
                                   "created_at": {
                                       "order": "desc"
                                   }
                               }],
                               "query": {
                                   "bool": {
                                       "must": [{
                                           "match": {
                                               "username":
                                               "******".format(username)
                                           }
                                       }]
                                   }
                               },
                               "size": 1
                           })
         if query['hits']['total'] == 0:
             last_update = bool(False)
             source = username
             last_data_stream = bool(False)
         else:
             _source = query['hits']['hits'][0]['_source']
             last = _source['created_at']
             lasted = re.sub('\+[^\s]+', '', last)
             source = _source['username']
             last_data_stream = query['hits']['hits'][0]['_id']
             utc_to_local = datetime.strptime(lasted,
                                              '%a %b %d %H:%M:%S %Y')
             utc_to_local = utc_to_local.replace(tzinfo=self.from_zone)
             last_update = str(utc_to_local.astimezone(self.to_zone))
         jsons = {
             "source": source,
             "last_update": last_update,
             "last_data_stream": last_data_stream
         }
         if 'date' in request.args:
             date = request.args['date']
             spliter = str(date).split('-')
             if spliter.__len__() == 2:
                 day = controller().getdays(int(spliter[0]),
                                            int(spliter[1]))
                 posttweet = es.search(
                     index='ima-twitter-*',
                     body={
                         "query": {
                             "bool": {
                                 "must": [{
                                     "match": {
                                         "username": "******".format(username)
                                     }
                                 }, {
                                     "range": {
                                         "created_at": {
                                             "gte":
                                             "{}-01 00:00:00".format(date),
                                             "lte":
                                             "{0}-{1} 23:59:59".format(
                                                 date, day),
                                             "format":
                                             "yyyy-MM-dd HH:mm:ss",
                                             "time_zone":
                                             "+07:00"
                                         }
                                     }
                                 }]
                             }
                         },
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         },
                         "size": 0
                     })
                 postretweet = es.search(
                     index='ima-twitter-*',
                     body={
                         "query": {
                             "bool": {
                                 "should": [{
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "retweeted_user_screen_name":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{}-01 00:00:00".
                                                     format(date),
                                                     "lte":
                                                     "{0}-{1} 23:59:59".
                                                     format(date, day),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "mention":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{}-01 00:00:00".
                                                     format(date),
                                                     "lte":
                                                     "{0}-{1} 23:59:59".
                                                     format(date, day),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "in_quote_to_screen_name":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{}-01 00:00:00".
                                                     format(date),
                                                     "lte":
                                                     "{0}-{1} 23:59:59".
                                                     format(date, day),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }]
                             }
                         },
                         "size": 0,
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         }
                     })
                 totaltweet = posttweet['hits']['total']
                 totalretweet = postretweet['hits']['total']
                 tweetdetails = controller().getdetails(posttweet)
                 retweetdetails = controller().getdetails(postretweet)
             elif spliter.__len__() == 3:
                 posttweet = es.search(
                     index='ima-twitter-*',
                     body={
                         "query": {
                             "bool": {
                                 "must": [{
                                     "match": {
                                         "username": "******".format(username)
                                     }
                                 }, {
                                     "range": {
                                         "created_at": {
                                             "gte":
                                             "{} 00:00:00".format(date),
                                             "lte":
                                             "{} 23:59:59".format(date),
                                             "format":
                                             "yyyy-MM-dd HH:mm:ss",
                                             "time_zone": "+07:00"
                                         }
                                     }
                                 }]
                             }
                         },
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         },
                         "size": 0
                     })
                 postretweet = es.search(
                     index='ima-twitter-*',
                     body={
                         "query": {
                             "bool": {
                                 "should": [{
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "retweeted_user_screen_name":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{} 00:00:00".format(
                                                         date),
                                                     "lte":
                                                     "{} 23:59:59".format(
                                                         date),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "mention":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{} 00:00:00".format(
                                                         date),
                                                     "lte":
                                                     "{} 23:59:59".format(
                                                         date),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }, {
                                     "bool": {
                                         "must": [{
                                             "match": {
                                                 "in_quote_to_screen_name":
                                                 "{}".format(username)
                                             }
                                         }, {
                                             "range": {
                                                 "created_at": {
                                                     "gte":
                                                     "{} 00:00:00".format(
                                                         date),
                                                     "lte":
                                                     "{} 23:59:59".format(
                                                         date),
                                                     "format":
                                                     "yyyy-MM-dd HH:mm:ss",
                                                     "time_zone":
                                                     "+07:00"
                                                 }
                                             }
                                         }]
                                     }
                                 }]
                             }
                         },
                         "size": 0,
                         "aggs": {
                             "type": {
                                 "terms": {
                                     "field": "type"
                                 }
                             }
                         }
                     })
                 totaltweet = posttweet['hits']['total']
                 totalretweet = postretweet['hits']['total']
                 tweetdetails = controller().getdetails(posttweet)
                 retweetdetails = controller().getdetails(postretweet)
             else:
                 totaltweet = False
                 tweetdetails = False
                 totalretweet = False
                 retweetdetails = False
             jsons['Data'] = {}
             jsons['Data']['Tweet'] = {'Total': totaltweet}
             jsons['Data']['Retweet'] = {'Total': totalretweet}
             if 'details' in request.args:
                 jsons['Data']['Tweet']['details'] = tweetdetails
                 jsons['Data']['Retweet']['details'] = retweetdetails
         result = json.dumps(jsons)
         return result
     else:
         return 'No parameter'
Example #48
0
file = str(dtime.year) + month + day + '.txt'


f = open(file,"a")



tel = antenna_nanten_controller.antenna_monitor_client('172.20.0.11',8004)
enc = antenna_enc.enc_monitor_client('172.20.0.11',8002)
dome = dome.dome_monitor_client('172.20.0.11',8008)
#dome_pos = dome_pos.dome_pos_monitor_client('172.20.0.11',8006)


#for get status
import controller
ctrl = controller.controller()
del ctrl


while(1):
    telstatus = tel.read_error()
    telstatus2 = tel.read_status()
    encstatus = enc.read_azel()
    domestatus = dome.read_status()
    domeposstatus = dome.read_domepos()

    tv = time.time()
    mjd = tv/24./3600. + 40587.0 # 40587.0 = MJD0

    ntime = dt.now()
    secofday = ntime.hour*60*60 + ntime.minute*60 + ntime.second + ntime.microsecond*0.000001
Example #49
0
    def start(self, **kwargs):
        self.tStart = time.time()

        ## Read input settings
        self.simSettings = {}
        self.speciesSettings = []
        self.pLoaderSettings = []
        self.meshSettings = {}
        self.mLoaderSettings = {}
        self.analysisSettings = {}
        self.dataSettings = {}

        if 'simSettings' in kwargs:
            simSettings = kwargs['simSettings']
        simSettings['simSettings'] = cp.copy(simSettings)

        if 'speciesSettings' in kwargs:
            speciesSettings = kwargs['speciesSettings']
        simSettings['speciesSettings'] = speciesSettings

        if 'meshSettings' in kwargs:
            meshSettings = kwargs['meshSettings']
        simSettings['meshSettings'] = meshSettings

        if 'pLoaderSettings' in kwargs:
            pLoaderSettings = kwargs['pLoaderSettings']
        simSettings['pLoaderSettings'] = pLoaderSettings

        if 'mLoaderSettings' in kwargs:
            mLoaderSettings = kwargs['mLoaderSettings']
        simSettings['mLoaderSettings'] = mLoaderSettings

        if 'analysisSettings' in kwargs:
            analysisSettings = kwargs['analysisSettings']
        simSettings['analysisSettings'] = analysisSettings

        if 'dataSettings' in kwargs:
            dataSettings = kwargs['dataSettings']
        simSettings['dataSettings'] = dataSettings

        ## Load required modules
        sim = controller(**simSettings)
        sim.inputPrint()

        print("Setting up...")

        t_setup = time.time()
        species_list = []
        for setting in speciesSettings:
            species = species_class(**setting)
            species_list.append(species)

        pLoader_list = []
        for setting in pLoaderSettings:
            pLoader = pLoader_class(**setting)
            pLoader_list.append(pLoader)

        fields = mesh(**meshSettings)

        mLoader = meshLoader(**mLoaderSettings)

        analyser = kpps_analysis(simulationManager=sim, **analysisSettings)

        dHandler = dataHandler(controller_obj=sim, **dataSettings)

        t_ploader = time.time()
        for loader in pLoader_list:
            loader.run(species_list, sim)

        t_mloader = time.time()
        mLoader.run(fields, sim)

        t_pre = time.time()
        analyser.run_preAnalyser(species_list, fields, sim)
        t_Start = time.time()

        sim.runTimeDict['object_instantiation'] = t_ploader - t_setup
        sim.runTimeDict['particle_load'] = t_mloader - t_ploader
        sim.runTimeDict['mesh_load'] = t_pre - t_mloader
        sim.runTimeDict['pre_processing'] = t_Start - t_pre

        dHandler.run_setup(sim)
        dHandler.run(species_list, fields, sim)

        ########################## RUN TIME! ##################################
        sim.runTimeDict['setup'] = time.time() - self.tStart
        dHandler = self.run(species_list, fields, sim, analyser, dHandler)

        return dHandler
 	def __init__(self):
		value = {
		"Command": "INIT",
		"Token": "8051bf89-e115-4147-8e5a-ff9d6f39f0d7"
		}
		headers = {
		            'Content-type': 'application/json',
		            'Accept': 'application/json',
		            }

		jvalue = json.dumps(value)
		conn = httplib.HTTPConnection('107.20.243.77', 80)
		conn.request('POST', '/api/hermes', jvalue, headers)
		response = conn.getresponse()
		ret = json.loads(str((response.status, response.reason, response.read())[2]))
		conn.close()
		DS = DataStore()
		ctrl = controller()
		myFile = open('output.txt', 'w')
		myFile.write(str(ret))
		myFile.close()
		looptime = ret['ServerState']['ServerTiers']['DB']['ServerStartTurnTime']
		coef = (ret["ServerState"]["CostPerServer"] / ret["ServerState"]["ProfitConstant"])

		DS.setCoef(coef)
		infra = False
		p = None
		research = None
		didGrid = False
		progression = [None, "GRID", "GREEN", None ]


		#while ret['ServerState']['TurnNo'] < 10080:
		while True:
			x = 0

			while x <=looptime-1:
				value = {
				"Command": "PLAY",
				"Token": "8051bf89-e115-4147-8e5a-ff9d6f39f0d7"
				}
				headers = {
				            'Content-type': 'application/json',
				            'Accept': 'application/json',
				            }
				jvalue = json.dumps(value)
				conn = httplib.HTTPConnection('107.20.243.77', 80)
				conn.request('POST', '/api/hermes', jvalue, headers)
				response = conn.getresponse()
				ret = json.loads(str((response.status, response.reason, response.read())[2]))

				#Get demand from server
				demand = [ret['ServerState']['ServerTiers']['DB']['ServerRegions']['NA']['NoOfTransactionsInput']]
				demand.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['EU']['NoOfTransactionsInput'])
				demand.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['AP']['NoOfTransactionsInput'])
				
				config = [ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']['NodeCount']]
				config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['EU']['NodeCount'])
				config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['AP']['NodeCount'])

				config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['NA']['NodeCount'])
				config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['EU']['NodeCount'])
				config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['AP']['NodeCount'])

				config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['NA']['NodeCount'])
				config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['EU']['NodeCount'])
				config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['AP']['NodeCount'])

				DS.avgDemand(demand)
				DS.setConfig(config)

				conn.close()
				x+=1
			lastProfit = ret["ServerState"]["ProfitEarned"]
			GridCost = ret["ServerState"]["ResearchUpgradeLevels"][1]["UpgradeCost"]
			GridTurns = ret["ServerState"]["ResearchUpgradeLevels"][1]["NoOfTurnsRequired"]
			GridTotalCost = GridTurns * GridCost

			if ret['ServerState']['TurnNo'] <= 9000 and ret["ServerState"]["ProfitAccumulated"] >= GridTotalCost/10 and GridCost < (lastProfit - (lastProfit/3)):
				didGrid = True
				try:
					if ret["ServerState"]["ResearchUpgradeState"]["GRID"] == -1:
						#research = "GREEN"
						pass
				except:
					research = "GRID"
				#p = research
			#Calculate free space

			#AVERAGE CAPACITY
			# capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2]
			# capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2)
			# capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  ) / 2)

			#97%
			capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']+ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] ) / 3]
			capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] ) / 3)
			capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit']) / 3)

			#93%
			# capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']+ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3]
			# capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3)
			# capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']) / 3)

			#100% CAPACITY
			# capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit']]
			# capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])
			# capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])

			# #90% CAPACITY
			# capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']]
			# capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])
			# capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])

			DS.setCapacity(capacity)
			changes = ctrl.calc(DS)
			jsonchange = {"Servers":{
				"WEB":{
					"ServerRegions":{
						"AP":{
							"NodeCount":changes[2]
							},
						"EU":{
							"NodeCount":changes[1]
							},
						"NA":{
							"NodeCount":changes[0]
							}
						}
					},

				"JAVA":{
					"ServerRegions":{
						"NA":{
							"NodeCount":changes[3]
							},
						"EU":{
							"NodeCount":changes[4]
							},
						"AP":{
							"NodeCount":changes[5]
							}
						}
					},

				"DB":{
					"ServerRegions":{
						"NA":{
							"NodeCount":changes[6]
							},
						"EU":{
							"NodeCount":changes[7]
							},
						"AP":{
							"NodeCount":changes[8]
							}
						}
					}
				
					},
					"UpgradeInfraStructure": infra,
					"UpgradeToResearch": research


				}
			if research != None:
				research = None

			value = {
			"Command": "CHNG",
			"Token": "8051bf89-e115-4147-8e5a-ff9d6f39f0d7",
			"ChangeRequest": jsonchange
			}
			headers = {
			            'Content-type': 'application/json',
			            'Accept': 'application/json',
			}
			jvalue = json.dumps(value)
			conn = httplib.HTTPConnection('107.20.243.77', 80)

			conn.request('POST', '/api/hermes', jvalue, headers)
			response = conn.getresponse()
			ret = json.loads(str((response.status, response.reason, response.read())[2]))
			# if research != None:
			# 	research = None
			# 	jsonchange = {"Servers":{
			# 		"WEB":{"UpgradeToResearch": "Green"}}}
			# 	value = {
			# 	"Command": "CHNG",
			# 	"Token": "8051bf89-e115-4147-8e5a-ff9d6f39f0d7",
			# 	#"Token": "7440b0b0-c5a2-4ab3-bdc3-8935865bb9d1",
			# 	"ChangeRequest": jsonchange
			# 	}
			# 	headers = {'Content-type': 'application/json','Accept': 'application/json',}
			# 	jvalue = json.dumps(value)
			# 	conn = httplib.HTTPConnection('107.20.243.77', 80)
			# 	#conn = httplib.HTTPConnection('uat.hermes.wha.la', 80)
			# 	conn.request('POST', '/api/hermes', jvalue, headers)
			# 	response = conn.getresponse()
			# 	ret = json.loads(str((response.status, response.reason, response.read())[2]))

			#play
			value = {
			"Command": "PLAY",
			"Token": "8051bf89-e115-4147-8e5a-ff9d6f39f0d7"
			}
			headers = {
			            'Content-type': 'application/json',
			            'Accept': 'application/json',
			            }
			jvalue = json.dumps(value)
			conn = httplib.HTTPConnection('107.20.243.77', 80)
			conn.request('POST', '/api/hermes', jvalue, headers)
			response = conn.getresponse()
			ret = json.loads(str((response.status, response.reason, response.read())[2]))

			#Get demand from server
			demand = [ret['ServerState']['ServerTiers']['DB']['ServerRegions']['NA']['NoOfTransactionsInput']]
			demand.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['EU']['NoOfTransactionsInput'])
			demand.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['AP']['NoOfTransactionsInput'])
			
			config = [ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']['NodeCount']]
			config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['AP']['NodeCount'])

			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['NA']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['JAVA']['ServerRegions']['AP']['NodeCount'])

			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['NA']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['EU']['NodeCount'])
			config.append(ret['ServerState']['ServerTiers']['DB']['ServerRegions']['AP']['NodeCount'])


			DS.resetDemand(demand)
			DS.setConfig(config)

			coef = (ret["ServerState"]["CostPerServer"] / ret["ServerState"]["ProfitConstant"])
			DS.setCoef(coef)

			# f = open('myfile.txt','w')
			# f.write(str(ret)) # python will convert \n to os.linesep
			# f.close()

			conn.close()
			print 'Turn: ' + str(ret['ServerState']['TurnNo'])
			print "WEB capacity: " + str(capacity[0])
			print "JAVA capacity: " + str(capacity[1])
			print "DB capacity: " + str(capacity[2])
			
			print "ServerCost: " + str(ret["ServerState"]["CostPerServer"])
			#print didGrid
			#if didGrid:
			try:
				inf = str(ret["ServerState"]["InfraStructureUpgradeState"]["Value"])
				if inf >=0:
					print "INFRA value: " + inf
			except:
		 		pass
			try:
				grid = str(ret["ServerState"]["ResearchUpgradeState"]["GRID"])
				if grid != "-1":
					print "---Researching: "+ "GRID" +"---\nTurns Left: " + grid
					if int(grid) <= 1441 and int(grid) >= 1430:
						#infra = True
						pass
					else:
						infra = False
				else:
					print "GRID UPGRADE COMPLETE"
			except:
				pass

			try:
				green = str(ret["ServerState"]["ResearchUpgradeState"]["GREEN"])
				if green != "-1":
					print "---Researching: "+ "GREEN" +"---\nTurns Left: " + green
				else:
					print "GREEN UPGRADE COMPLETE"
			except:
				pass
				
				
			print demand
			print '  ' + str(config[0]) + '    ' + str(config[1]) + '    ' + str(config[2]) + '    ' + '\n  ' + str(config[3]) + '    ' + str(config[4]) + '    ' + str(config[5]) + '   ' + '\n  ' + str(config[6]) + '    ' + str(config[7]) + '    ' + str(config[8])
			print ''
			conn.close()
Example #51
0
import controller as c
import utility as ut
import sys
import numpy
import model

numpy.set_printoptions(threshold=sys.maxsize)

con = c.controller()
con.play_with_UI()


Example #52
0

def Terminate(exitcode):
    sys.exit(exitcode)


'''
main()
This is the mainline section of the program and makes calls to the 
various other sections of the code
'''
if __name__ == '__main__':

    ret = 0

    CON = controller()

    ret = Parse(sys.argv)

    if (ret == -1):
        Usage()
        Terminate(ret)

    ret = ConfRead()

    if (ret == -1):
        print 'Terminated reading the configuration file...'
        Terminate(ret)

    if (CON.listmodules == True):
        ListModules()
Example #53
0
def sigint_handler(signum, frame):
    global bExit
    # clean up and stop threads
    print "CTRL-C pressed, cleaning up"
    bExit = True


# switch to DEBUG for packet level byte data (but then that writes to the SD
# card so do not keep it there in normal operation

#logging.basicConfig( filename='debug.log', level=logging.DEBUG )
logging.basicConfig(filename='debug.log', level=logging.DEBUG)

# pass the circuits to the serial thread for decoding and stuffing
# in the redis database
controller = controller.controller(circuitlist)
#controller.save()
serialT = serialThread.serialThread('/dev/ttyUSB0', controller, 2)
cmdT = serialThread.cmdThread()
httpT = httpThread.httpThread(1, 2)

serialT.start()
httpT.start()
cmdT.start()

print "Type CTRL-C to quit..."

signal.signal(signal.SIGINT, sigint_handler)

#line = ''
Example #54
0
    def __init__(self):
        tok = "8051bf89-e115-4147-8e5a-ff9d6f39f0d7"
        url = "hermes.wha.la"

        value = {"Command": "INIT", "Token": tok}
        headers = {
            'Content-type': 'application/json',
            'Accept': 'application/json',
        }

        jvalue = json.dumps(value)
        conn = httplib.HTTPConnection(url, 80)
        conn.request('POST', '/api/hermes', jvalue, headers)
        response = conn.getresponse()
        ret = json.loads(
            str((response.status, response.reason, response.read())[2]))
        conn.close()
        DS = DataStore(
            ret["ServerState"]["ServerTiers"]["DB"]["ServerStartTurnTime"])
        ctrl = controller()
        # myFile = open('output.txt', 'w')
        # myFile.write(str(ret))
        # myFile.close()
        looptime = ret['ServerState']['ServerTiers']['DB'][
            'ServerStartTurnTime']
        coef = (ret["ServerState"]["CostPerServer"] /
                ret["ServerState"]["ProfitConstant"])

        WebRefresh = ret["ServerState"]["ServerTiers"]["WEB"][
            "ServerStartTurnTime"]
        JavaRefresh = ret["ServerState"]["ServerTiers"]["JAVA"][
            "ServerStartTurnTime"]
        DBRefresh = ret["ServerState"]["ServerTiers"]["DB"][
            "ServerStartTurnTime"]

        DS.setCoef(coef)
        infra = False
        p = None
        research = None
        didGrid = False
        progression = [None, "GRID", "GREEN", None]

        #while ret['ServerState']['TurnNo'] < 10080:
        while True:
            x = 0

            value = {"Command": "PLAY", "Token": tok}
            headers = {
                'Content-type': 'application/json',
                'Accept': 'application/json',
            }
            jvalue = json.dumps(value)
            conn = httplib.HTTPConnection(url, 80)
            conn.request('POST', '/api/hermes', jvalue, headers)
            response = conn.getresponse()
            ret = json.loads(
                str((response.status, response.reason, response.read())[2]))
            turnnumber = ret['ServerState']['TurnNo']
            #Get demand from server
            demand = [
                ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']
                ['NoOfTransactionsInput']
            ]
            demand.append(ret['ServerState']['ServerTiers']['WEB']
                          ['ServerRegions']['EU']['NoOfTransactionsInput'])
            demand.append(ret['ServerState']['ServerTiers']['WEB']
                          ['ServerRegions']['AP']['NoOfTransactionsInput'])

            config = [
                ret['ServerState']['ServerTiers']['WEB']['ServerRegions']['NA']
                ['NodeCount']
            ]
            config.append(ret['ServerState']['ServerTiers']['WEB']
                          ['ServerRegions']['EU']['NodeCount'])
            config.append(ret['ServerState']['ServerTiers']['WEB']
                          ['ServerRegions']['AP']['NodeCount'])

            config.append(ret['ServerState']['ServerTiers']['JAVA']
                          ['ServerRegions']['NA']['NodeCount'])
            config.append(ret['ServerState']['ServerTiers']['JAVA']
                          ['ServerRegions']['EU']['NodeCount'])
            config.append(ret['ServerState']['ServerTiers']['JAVA']
                          ['ServerRegions']['AP']['NodeCount'])

            config.append(ret['ServerState']['ServerTiers']['DB']
                          ['ServerRegions']['NA']['NodeCount'])
            config.append(ret['ServerState']['ServerTiers']['DB']
                          ['ServerRegions']['EU']['NodeCount'])
            config.append(ret['ServerState']['ServerTiers']['DB']
                          ['ServerRegions']['AP']['NodeCount'])

            # if turnnumber % (DBRefresh*2):
            # 	DS.resetDemand(demand)
            # else:
            # 	DS.avgDemand(demand)
            DS.runningDemand(demand)
            DS.setConfig(config)
            coef = (ret["ServerState"]["CostPerServer"] /
                    ret["ServerState"]["ProfitConstant"])
            DS.setCoef(coef)

            conn.close()

            lastProfit = ret["ServerState"]["ProfitEarned"]
            GridCost = ret["ServerState"]["ResearchUpgradeLevels"][1][
                "UpgradeCost"]
            GridTurns = ret["ServerState"]["ResearchUpgradeLevels"][1][
                "NoOfTurnsRequired"]
            GridTotalCost = GridTurns * GridCost

            #init research when its swaggin to do so
            if ret['ServerState']['TurnNo'] <= 2000 and ret["ServerState"][
                    "ProfitAccumulated"] >= GridTotalCost / 8 and GridCost < (
                        lastProfit - (lastProfit / 3)):
                didGrid = True
                try:
                    if ret["ServerState"]["ResearchUpgradeState"][
                            "GRID"] == -1:
                        #research = "GREEN"
                        pass
                except:
                    research = "GRID"
                    pass
                #p = research
            #Calculate free space

            #AVERAGE CAPACITY
            # capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2]
            # capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 2)
            # capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  ) / 2)

            #97%
            capacity = [
                (ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']
                 ['CapactityLevels'][1]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit']) / 3
            ]
            capacity.append(
                (ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']
                 ['CapactityLevels'][1]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit']) / 3)
            capacity.append(
                (ret['ServerState']['ServerTiers']['DB']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['DB']['ServerPerformance']
                 ['CapactityLevels'][1]['UpperLimit'] +
                 ret['ServerState']['ServerTiers']['DB']['ServerPerformance']
                 ['CapactityLevels'][0]['UpperLimit']) / 3)

            #93%
            # capacity = [ ( ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']+ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3]
            # capacity.append(( ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'] ) / 3)
            # capacity.append(( ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'] + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']  + ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']) / 3)

            #100% CAPACITY
            # capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit']]
            # capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])
            # capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][0]['UpperLimit'])

            # #90% CAPACITY
            # capacity = [ ret['ServerState']['ServerTiers']['WEB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit']]
            # capacity.append(ret['ServerState']['ServerTiers']['JAVA']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])
            # capacity.append(ret['ServerState']['ServerTiers']['DB']['ServerPerformance']['CapactityLevels'][1]['UpperLimit'])

            DS.setCapacity(capacity)
            webchanges = [0, 0, 0, 0, 0, 0, 0, 0, 0]
            javachanges = [0, 0, 0, 0, 0, 0, 0, 0, 0]
            dbchanges = [0, 0, 0, 0, 0, 0, 0, 0, 0]

            if turnnumber % WebRefresh == 0:
                webchanges = ctrl.calcWeb(DS, WebRefresh * 1.5)
            if turnnumber % JavaRefresh == 0:
                javachanges = ctrl.calcJava(DS, JavaRefresh * 1.5)
            if turnnumber % DBRefresh == 0:
                dbchanges = ctrl.calcDB(DS, DBRefresh * 1.5)

            #create 'changes' to know what servers to bring up/down
            changes = []
            changes.append(webchanges[0])
            changes.append(webchanges[1])
            changes.append(webchanges[2])
            changes.append(javachanges[3])
            changes.append(javachanges[4])
            changes.append(javachanges[5])
            changes.append(dbchanges[6])
            changes.append(dbchanges[7])
            changes.append(dbchanges[8])

            jsonchange = {
                "Servers": {
                    "WEB": {
                        "ServerRegions": {
                            "AP": {
                                "NodeCount": changes[2]
                            },
                            "EU": {
                                "NodeCount": changes[1]
                            },
                            "NA": {
                                "NodeCount": changes[0]
                            }
                        }
                    },
                    "JAVA": {
                        "ServerRegions": {
                            "NA": {
                                "NodeCount": changes[3]
                            },
                            "EU": {
                                "NodeCount": changes[4]
                            },
                            "AP": {
                                "NodeCount": changes[5]
                            }
                        }
                    },
                    "DB": {
                        "ServerRegions": {
                            "NA": {
                                "NodeCount": changes[6]
                            },
                            "EU": {
                                "NodeCount": changes[7]
                            },
                            "AP": {
                                "NodeCount": changes[8]
                            }
                        }
                    }
                },
                "UpgradeInfraStructure": infra,
                "UpgradeToResearch": research
            }
            if research != None:
                research = None

            value = {
                "Command": "CHNG",
                "Token": tok,
                "ChangeRequest": jsonchange
            }
            headers = {
                'Content-type': 'application/json',
                'Accept': 'application/json',
            }
            jvalue = json.dumps(value)
            conn = httplib.HTTPConnection(url, 80)

            conn.request('POST', '/api/hermes', jvalue, headers)
            response = conn.getresponse()
            ret2 = json.loads(
                str((response.status, response.reason, response.read())[2]))
            conn.close()

            #print Stuff
            print 'Turn: ' + str(ret['ServerState']['TurnNo'])
            print 'Total Profit: $' + str(
                ret["ServerState"]["ProfitAccumulated"])
            # print "WEB capacity: " + str(capacity[0])
            # print "JAVA capacity: " + str(capacity[1])
            # print "DB capacity: " + str(capacity[2])
            # print "ServerCost: " + str(ret["ServerState"]["CostPerServer"])

            #print didGrid
            #if didGrid:
            try:
                inf = str(
                    ret["ServerState"]["InfraStructureUpgradeState"]["Value"])
                if inf >= 0:
                    #print "INFRA value: " + inf
                    pass
            except:
                pass
            try:
                grid = str(ret["ServerState"]["ResearchUpgradeState"]["GRID"])
                if grid != "-1":
                    print "---Researching: " + "GRID" + "---\nTurns Left: " + grid
                    if int(grid) <= 1441 and int(grid) >= 1430:
                        #infra = True
                        pass
                    else:
                        infra = False
                else:
                    print "GRID UPGRADE COMPLETE"
            except:
                pass

            try:
                green = str(
                    ret["ServerState"]["ResearchUpgradeState"]["GREEN"])
                if green != "-1":
                    print "---Researching: " + "GREEN" + "---\nTurns Left: " + green
                else:
                    print "GREEN UPGRADE COMPLETE"
            except:
                pass

            print demand
            print '  ' + str(config[0]) + '    ' + str(
                config[1]) + '    ' + str(config[2]) + '    ' + '\n  ' + str(
                    config[3]) + '    ' + str(config[4]) + '    ' + str(
                        config[5]) + '   ' + '\n  ' + str(
                            config[6]) + '    ' + str(
                                config[7]) + '    ' + str(config[8])
            print ''
            conn.close()
Example #55
0
import json
import threading
import traceback

import sys
import os

from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
from controller import controller

rotationControl = controller()


class SimpleEcho(WebSocket):
    def handleMessage(self):

        #self.sendMessage(self.data)
        try:
            rotationControl.receivedMotionData(json.loads(self.data))
        except Exception as e:
            print(e)

    def handleConnected(self):
        print(self.address, 'connected')
        print("Websocket Opened")

    def handleClose(self):
        print(self.address, 'closed')
        print("Websocket closed")

Example #56
0

# -------------------------------------------------------------------------
Discoverer = discoverer.discoverer(
    PEER_IP, PEER_PORT, PEER_ID, discoveryHandler, '192.168.10.255')


# --------------------------------------------------------------------------
FileManager = fileManager.fileManager(FOLDER_PATH, Discoverer)

#---------------------------------------------------------------------------
FolderReceiver = fileTransporter.folderReceiver(
    FOLDER_PATH, Communicator, FileManager)

# ---------------------------------------------------------------------------
Controller = controller.controller(Communicator, Discoverer, FileManager, FolderReceiver)

# --------------------------------------------------------------------------
FileTransporter = fileTransporter.fileTransporter(
    Controller, FOLDER_PATH, Communicator, FileManager)


Communicator.run()
Discoverer.startDiscovery()
FileManager.start()
FileTransporter.startSendFromQ()
sleep(5)
print Discoverer.dbPresent()
while 1:
    a = raw_input()
    if(a == 'remote'):
Example #57
0
import yaml
import time 
import numpy as np
import controller as contr
import interlock as intr

with open('testing/lidar_data.yaml', 'r') as stream:
    rows_to_data_lists = yaml.safe_load(stream)

data = []
for data_list in rows_to_data_lists.values():
    data.extend(data_list)
data = np.array(data)

start = time.time()
cert = contr.controller(data)
end = time.time()
print('Controller said', cert.action)
print(str(end - start) + "s to call controller")

start = time.time()
result = intr.interlock(cert)
end = time.time()
print('Interlock said', result)
print(str(end - start) + "s to call interlock")
Example #58
0
#!/usr/bin/python2
import controller, functions, items, var, interpreter, words, sys
if var.debug: import time
import cursed

var.window = cursed.cursed()
var.window.create_window('log',(26,1),(80,16))
var.window.create_window('status',(0,24),(79,25),pad=True)
var.window.create_window('health',(26,16),(79,17),pad=True)

var._c = controller.controller()

if len(sys.argv)>1 and sys.argv[1] == 'recompile':
	words.load_config_files(flush=True)
else:
	words.load_config_files(flush=False)

if var.debug: _starttime = time.time()

var._c.generate()
var._c.make_human_race()
#var._c.tick(300)
#var._c.tick_year(1)

if var.debug: print 'Generation took %s' % (str(time.time()-_starttime))

var._c.log('')
var.window.clear('log')
var.window.refresh('log')
var._c.draw_map()