def select_file(self):
"""
Select a file. If one is already loaded, it gets replaced.
"""
# Delete old data if available
if self._simulation_data:
self._simulation_data.remove()
# Find the new file
file = vizinput.fileOpen(
title="Please choose your file containing the simulation data.",
filter=[('VTK Files', '*.vtk')],
directory=cfg.standard_directory)
# If no file is selected close the application
if file == '':
viz.quit()
return
# Load data
self._simulation_data = Simulation_Data.Simulation_Data(file)
# Update Controls for new data
self._grab_and_zoom.set_item(self._simulation_data.origin_node)
Controls.set_material_range(self._simulation_data.get_material_range())
self.callback(Controls.CONTROL_CYCLE_VIEW_MODE,
self._simulation_data.cycle_view_mode)
self.callback(Controls.CONTROL_MATERIAL,
self._simulation_data.toggle_material)
# Place model in a nice position
self._simulation_data.origin_node.setPosition(0, 1, 0)
self._simulation_data.origin_node.setScale(.1, .1, .1)
self._simulation_data.origin_node.setEuler(0, 0, -90)
def printData(data):
#print(data)
dataFront = get_data_array(data.ranges, 100, 140)
dataRight = get_data_array(data.ranges, 30 - 15, 30 + 15)
dataLeft = get_data_array(data.ranges, 240 - 30 - 15, 240 - 15)
distleft = dataLeft.mean()
distright = dataRight.mean()
distInFront = dataFront.mean()
spaceLeft = 0
spaceRight = 0
if (distInFront > 2 and distright > 2):
spaceRight = distleft
spaceLeft = distleft
elif (distInFront > 2 and distleft > 2): # previously 3
spaceLeft = distright
spaceRight = distright
else:
spaceRight = distright
spaceLeft = distleft
pturn = (spaceLeft - spaceRight) / (spaceLeft +
spaceRight) / distInFront * 9
print(distleft)
go = True
x = 1
speed = distInFront
turn = pturn
c.move(x, turn, speed)
def getSlatStatus(lightIn, lightOut):
print(" get slat status")
stSlat = int(sp.get(slatStatus))
print(" slat status from preference: " + str(stSlat))
if ((float(lightIn) > 0) and (float(lightOut) > 0)):
#print(" light in: "+str(lightIn) +" lux")
#print(" light out: "+str(lightOut) +" lux")
if ((float(lightOut) - float(lightIn)) >
float(3000)): #value have different motr than 2,000 lux
if (stSlat != int(0)):
print(
" light in and out different more 3000 lux, But slat status = open (1)"
)
if (ctrl.closeSlat()): #if can close slat
time.sleep(10)
sp.put(slatStatus, int(0))
global isConn
if (isConn):
gear.publisSlatStatus(0)
stSlat = 0
else:
if (int(stSlat) == 0):
if ((float(lightOut) - float(lightIn)) < float(1000)):
if (ctrl.openSlat()):
time.sleep(10)
sp.put(slatStatus, int(1))
global isConn
if (isConn):
gear.publisSlatStatus(1)
stSlat = 1
else:
print(" sensor light error!!")
return stSlat
def write_3bit_ckt(self, bits, theta):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i \sum_{k1 < k2} \sum{k3 != k1, k2}
theta(k1, k2, k3) a^\dag(k1) a(k2) n(k3) + h.c.)
Parameters
----------
bits : list[int]
theta : float
Returns
-------
None
"""
assert len(bits) == 3
assert bits[0] < bits[1]
trols02 = Controls(self.data.num_orbitals + 1)
trols02.bit_pos_to_kind = {bits[0]: True, bits[2]: True}
trols02.refresh_lists()
self.write_controlled_one_bit_gate(bits[1], trols02,
OneBitGates.rot_ax, [theta, 1])
def collectTurtle(mazeWidth):
turtle = Maze.generateMazeBoundries(mazeWidth);
Controls.createControls(turtle, screen);
mazeWalls = {'xWalls' : Maze.xWalls, 'yWalls' : Maze.yWalls};
return mazeWalls;
def printData(data):
#print(data)
dataFront = get_data_array(data.ranges, 100, 140)
dataRight = get_data_array(data.ranges, 30 - 15, 30 + 15)
dataLeft = get_data_array(data.ranges, 240 - 30 - 15, 240 - 15)
distleft = dataLeft.mean()
distright = dataRight.mean()
distInFront = dataFront.mean()
pturn = (distleft - distright) / (distleft + distright) / distInFront * 9
print(distInFront)
go = True
x = 1
speed = distInFront
if ((distInFront > 2 and distright > 2)
or (distInFront > 2 and distleft > 2)): #previously 3
turn = 0
else:
turn = pturn
c.move(x, turn, speed)
def read_multi_controls(self, tokens, allow_only_TF=False):
"""
Given a list of tokens of the form:
* an int followed by either T or F,
* int, colon, int,
construct a control out of it.
Parameters
----------
tokens : list[str]
allow_only_TF : bool
Returns
-------
Controls
"""
# safe to use when no "IF"
# when no "IF", will return controls with _numControls=0
controls = Controls(self.num_bits)
if tokens:
for t in tokens:
t_end = t[-1]
if allow_only_TF:
assert t_end in ['T', 'F']
if t_end == 'T':
controls.set_control(int(t[:-1]), True)
elif t_end == 'F':
controls.set_control(int(t[:-1]), False)
else:
k1, k2 = t.split(':')
controls.set_control(int(k1), int(k2))
controls.refresh_lists()
return controls
def write_3bit_ckt(self, bits, theta):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i \sum_{k1 < k2} \sum{k3 != k1, k2}
theta(k1, k2, k3) a^\dag(k1) a(k2) n(k3) + h.c.)
Parameters
----------
bits : list[int]
theta : float
Returns
-------
None
"""
assert len(bits) == 3
assert bits[0] < bits[1]
trols02 = Controls(self.data.num_orbitals+1)
trols02.bit_pos_to_kind = {bits[0]: True, bits[2]: True}
trols02.refresh_lists()
self.write_controlled_one_bit_gate(
bits[1], trols02, OneBitGates.rot_ax, [theta, 1])
def read_multi_controls(self, tokens, allow_only_TF=False):
"""
Given a list of tokens of the form:
* an int followed by either T or F,
* int, opening parenthesis, int,
construct a control out of it.
Parameters
----------
tokens : list[str]
allow_only_TF : bool
Returns
-------
Controls
"""
# safe to use when no "IF"
# when no "IF", will return controls with _numControls=0
controls = Controls(self.num_bits)
if tokens:
for t in tokens:
t_end = t[-1]
if allow_only_TF:
assert t_end in ['T', 'F']
if t_end == 'T':
controls.set_control(int(t[:-1]), True)
elif t_end == 'F':
controls.set_control(int(t[:-1]), False)
else:
k1, k2 = t.split('(')
controls.set_control(int(k1), int(k2))
controls.refresh_lists()
return controls
def perform_action(action):
if (action == 1):
controls.turnLeft()
if (action == 2):
controls.turnRight()
timer.run()
player.updatePos()
player.checkBounds()
sm.calcTestpoints()
sm.updateState()
class GameScreen: def __init__(self): self.backgrounds = RenderPlain() self.controls = Controls() self.sprites = RenderPlain() def update(self, events): self.backgrounds.update(events) self.controls.update(events) self.sprites.update(events) def draw(self, surface): self.backgrounds.draw(surface) self.sprites.draw(surface) self.controls.draw(surface)
def main():
grid = Grid(42, 85)
#grid.printTiles()
# Create deck from a test preset
#deck = Deck(cards=tests.createPresetDeck())
deck = Deck(cards=tests.createRandomDeck(8))
Controls.cycle(deck)
deck.shuffleDeck()
# Show cards of the deck, 4 per line
deck.showAllCards(4)
def __init__(self, master, file_name, input_info, output_info,
duration_estimate):
self.master = master
border_width = 15
self.canvas_width = master.winfo_width()
self.canvas_height = master.winfo_height()
self.output_info = output_info
arrow_width = self.canvas_height / 200
border = 0
#processor must be initialized first
OutTop.OutTop(master, self.canvas_width, self.canvas_height, border,
border_width)
OutBottom.OutBottom(master, self.canvas_width, self.canvas_height,
border, border_width)
OutLeft.OutLeft(master, self.canvas_width, self.canvas_height, border,
border_width)
OutRight.OutRight(master, self.canvas_width, self.canvas_height,
border, border_width)
self.processor = Processor.Processor(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.wheel = Wheel.Wheel(master, self.canvas_width, self.canvas_height,
border, arrow_width)
self.register = Register.Register(master, self.canvas_width,
self.canvas_height, border,
self.processor.exit_height,
arrow_width)
self.memory = Memory.Memory(master, self.canvas_width,
self.canvas_height, border)
self.memory_op = MemoryOp.MemoryOp(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.cable = Cable.Cable(master, self.canvas_width, self.canvas_height,
arrow_width, border,
self.processor.entry_width,
self.memory_op.entry_width,
self.wheel.exit_height, self)
self.controls = Controls.Controls(master, self.canvas_width,
self.canvas_height, self, input_info,
duration_estimate)
## TODO : MEANINGFUL EXCEPTIONS
# file_name = sys.argv[1]
self.command_sequence = []
memory_preset = []
input_file = open(file_name, 'r')
for line in input_file:
line = line.strip()
if line.strip().startswith('#') or line == '':
continue
elif line.strip().startswith('['):
memory_preset = line[1:-1].split(',')
else:
self.command_sequence.append(line.strip().upper())
self.memory.init(memory_preset, self.command_sequence)
self.wheel.init(self.command_sequence)
input_file.close()
def late_bind():
global Controls
import Controls
Controls.late_bind()
from Manager import Manager
global Welder_Templates, Dialogs, ScriptEditor, Manager
import Welder_Templates
import Dialogs
import ScriptEditor
#late_binding
Dialogs.late_bind()
ScriptEditor.late_bind()
global Actors_Panel, Animations_Panel, Armors_Panel, AudioPlayer_Panel, BattleTestActor_Panel
global Classes_Panel, CommonEvents_Panel, Configuration_Panel, Enemies_Panel
global EventCommands1_Panel, EventCommands2_Panel, EventCommands3_Panel, EventEditor_Panel, EventPage_Panel
global Items_Panel, ParameterGraph_Panel, Skills_Panel, States_Panel, System_Panel, Tilesets_Panel, Troops_Panel, Weapons_Panel
from Actors_Panel import Actors_Panel
from Animations_Panel import Animations_Panel
from Armors_Panel import Armors_Panel
from AudioPlayer_Panel import AudioPlayer_Panel
from BattleTestActor_Panel import BattleTestActor_Panel
from Classes_Panel import Classes_Panel
from CommonEvents_Panel import CommonEvents_Panel
from Configuration_Panel import Configuration_Panel
from Enemies_Panel import Enemies_Panel
from Items_Panel import Items_Panel
from ParameterGraph_Panel import ParameterGraph_Panel
from Skills_Panel import Skills_Panel
from States_Panel import States_Panel
from System_Panel import System_Panel
from Tilesets_Panel import Tilesets_Panel
from Troops_Panel import Troops_Panel
from Weapons_Panel import Weapons_Panel
Welder_Templates.late_bind()
def __init__(self, x, z, theta, pos):
self.trans_vel = x
self.ang_vel = z
self.orientation = theta
self.curr_pos = pos
self.state = np.array([[pos[0]], [0], [pos[1]], [0], [theta], [0]])
self.__wheel_dist = 0.43
self.kalman = Kalman.Kalman()
self.controls = Controls.Controls()
def write_bit_swap(self, bit1, bit2):
"""
Write a line in eng & pic files for a 'SWAP' with no controls.
Parameters
----------
bit1 : int
bit2 : int
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_bit_swap(bit1, bit2, trols)
def __init__(self, num, node_type):
"""
:param num: Number of nodes including base and end nodes
:param node_type: Type of node: Base, End, Robot
:return:
"""
if node_type == "Base":
self.type = "Base"
self.right_neighbor = num + 1
self.left_neighbor = -1
elif node_type == "End":
self.type = "End"
self.right_neighbor = -1
self.left_neighbor = num - 1
else:
self.type = "Robot"
self.left_neighbor = num - 1
self.right_neighbor = num + 1
self.node = num
# All positions measured with UWB-radios.
self.measured_positions = np.array([], dtype=np.float32)
self.measured_x_positions = np.array([], dtype=np.float32)
self.measured_y_positions = np.array([], dtype=np.float32)
# All positions corrected with kalman + measurements.
self.corrected_positions = np.array([], dtype=np.float32)
self.corrected_x_positions = np.array([], dtype=np.float32)
self.corrected_y_positions = np.array([], dtype=np.float32)
# Target positions storage, for align1.0 the node knows the target positions
self.target_positions = np.array([], dtype=np.float32)
self.target_x_positions = np.array([], dtype=np.float32)
self.target_y_positions = np.array([], dtype=np.float32)
# Controls storage
self.contplot_x = np.array([], dtype=np.float64)
self.contplot_z = np.array([], dtype=np.float64)
self.x = 0 # velocity
self.z = 0 # angular velocity
self.state = np.array([[0.0], [0.0], [0.0], [0.0], [0.0], [
0.0]]) # state = x_position, x_velocity, y_position, y_velocity, theta, theta_velocity(rotation velocity)
self.kalman = Kalman.Kalman()
self.controls = Controls.Controls()
def handleEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
return False
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.escape=True
return False
if event.key == self.fourthKey and self.optionIndex!=2: #If key down is pressed and it is not at the end of menu
self.optionIndex+=1 #adds one to index
self.lazer.play() #Plays the sound loaded
elif event.key == self.firstKey and self.optionIndex!=0: #or if key up pressed and not at top of menu
self.optionIndex-=1 #subtracts one from index
self.lazer.play()
elif event.key == K_RETURN and self.optionIndex==2: #if enter is pressed
self.lazer.play()
return Controls.main() #Goes to controls
#Same menus but for submenus instead of main options menu
#Volume list control
elif event.key == self.secondKey and self.optionIndex==1 and self.volumeIndex!=0:
self.volumeIndex-=1
pygame.mixer.music.set_volume(self.backgroundVolume[self.volumeIndex])
self.lazer.play()
elif event.key == self.thirdKey and self.optionIndex==1 and self.volumeIndex!=5:
self.volumeIndex+=1
pygame.mixer.music.set_volume(self.backgroundVolume[self.volumeIndex])
self.lazer.play()
#Music list control
elif event.key == self.secondKey and self.optionIndex==0 and self.musicIndex!=0:
self.musicIndex-=1
self.lazer.play()
pygame.mixer.music.load(self.backgroundMusic[self.musicIndex])
pygame.mixer.music.play(-1)
print self.musicIndex
elif event.key == self.thirdKey and self.optionIndex==0 and self.musicIndex!=3:
self.musicIndex+=1
self.lazer.play()
pygame.mixer.music.load(self.backgroundMusic[self.musicIndex])
pygame.mixer.music.play(-1)
print self.musicIndex
return True
def write_bit_swap(self, bit1, bit2, rads_list=None):
"""
Write a line in eng & pic files for a 'SWAP' if rads_list=None or
'SWAY' if rads_list!=None, with no controls.
Parameters
----------
bit1 : int
bit2 : int
rads_list : list[float | str] | None
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_bit_swap(bit1, bit2, trols, rads_list)
def write_4bit_ckt(self, bits, thetas):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i sum_{k1 < k2 < k3 < k4}
theta_0(k1, k2, k3, k4) a^\dag(k1) a^\dag(k2) a(k3) a(k4) + h.c.
theta_1(k1, k2, k3, k4) a^\dag(k1) a(k2) a^\dag(k3) a(k4) + h.c.
theta_2(k1, k2, k3, k4) a^\dag(k1) a(k2) a(k3) a^\dag(k4) + h.c.
Parameters
----------
bits : list[int]
thetas : list[float]
Returns
-------
None
"""
assert len(bits) == 4
assert len(thetas) == 3
assert bits[0] < bits[1] < bits[2] < bits[3]
for theta_index in range(0, 3):
theta = ut.centered_rads(thetas[theta_index])
if theta_index == 1:
sign = +1
else:
sign = -1
if abs(theta) > ut.TOL:
trols = Controls(self.data.num_orbitals + 1)
for r in range(0, 3):
if r == 2 - theta_index:
trols.set_control(bits[r], False)
else:
trols.set_control(bits[r], True)
trols.refresh_lists()
self.write_controlled_one_bit_gate(bits[3], trols,
OneBitGates.rot_ax,
[sign * theta, 1])
def write_global_phase_fac(self, ang_rads):
"""
Write a line in eng & pic files for a global phase factor 'PHAS'
with no controls.
Parameters
----------
ang_rads : float
Returns
-------
None
"""
tar_bit_pos = 0 # anyone will do
trols = Controls(2) # dummy with zero controls
gate_fun = OneBitGates.phase_fac
self.write_controlled_one_bit_gate(tar_bit_pos, trols, gate_fun,
[ang_rads])
def __init__(self, num_bits_bef, num_bits_aft, bit_map=None):
"""
Constructor
Parameters
----------
num_bits_bef : int
num_bits_aft : int
Returns
-------
"""
self.num_bits_bef = num_bits_bef
self.num_bits_aft = num_bits_aft
assert num_bits_bef <= num_bits_aft
if num_bits_aft > num_bits_bef:
assert bit_map, "must give a bit_map"
self.bit_map = bit_map
self.extra_controls = Controls(num_bits_aft)
def write_one_bit_gate(self,
tar_bit_pos,
one_bit_gate_fun,
fun_arg_list=None):
"""
Write a line in eng & pic files for a one qubit gate (from class
OneBitGates) with no controls.
Parameters
----------
tar_bit_pos : int
one_bit_gate_fun : function
fun_arg_list : list
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_one_bit_gate(tar_bit_pos, trols,
one_bit_gate_fun, fun_arg_list)
def write_4bit_ckt(self, bits, thetas):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i sum_{k1 < k2 < k3 < k4}
theta_0(k1, k2, k3, k4) a^\dag(k1) a^\dag(k2) a(k3) a(k4) + h.c.
theta_1(k1, k2, k3, k4) a^\dag(k1) a(k2) a^\dag(k3) a(k4) + h.c.
theta_2(k1, k2, k3, k4) a^\dag(k1) a(k2) a(k3) a^\dag(k4) + h.c.
Parameters
----------
bits : list[int]
thetas : list[float]
Returns
-------
None
"""
assert len(bits) == 4
assert len(thetas) == 3
assert bits[0] < bits[1] < bits[2] < bits[3]
for theta_index in range(0, 3):
theta = ut.centered_rads(thetas[theta_index])
if theta_index == 1:
sign = +1
else:
sign = -1
if abs(theta) > ut.TOL:
trols = Controls(self.data.num_orbitals+1)
for r in range(0, 3):
if r == 2 - theta_index:
trols.set_control(bits[r], False)
else:
trols.set_control(bits[r], True)
trols.refresh_lists()
self.write_controlled_one_bit_gate(
bits[3], trols, OneBitGates.rot_ax, [sign*theta, 1])
def compareMosture(timeStamp, mosObj, isConn):
result = False
timeExceptWater = 0
print("Compare, check moisture...")
if (float(mosObj["average"]) >
0): #if sensor not error # chamge point1 to average
if (float(mosObj["average"]) < float(sp.get(mosStd))):
print(" moisture less than standard")
if (ctrl.water()):
time.sleep(30) #wait 30 second
newMosObj = json.loads(inputs.getMoistureObject())
print(" old moisture: " +
str(mosObj["average"])) # chamge point1 to average
print(" new moisture: " +
str(newMosObj["average"])) # chamge point1 to average
if (
(float(newMosObj["point1"] - float(mosObj["average"]) > 5))
): # if moisture value more than valus before chamge point1 to average
print(" All success")
db.insertLogData(
timeStamp, 1, 1, float(mosObj["average"]),
float(newMosObj["average"])) #insert log to database
result = True
else:
print(" Error! water to true Arare")
timeExceptWater = onExceptWater(timeStamp, 2, isConn)
else:
print(" Error! water not flows")
timeExceptWater = onExceptWater(timeStamp, 1, isConn)
else:
print(" no working...")
else:
print(" moisture sensor error!!")
return result, timeExceptWater
from Peter import *
from Controls import *
from time import sleep
from gpiozero import PWMOutputDevice
joy = Controls()
sol = DoubleSolenoid(21, 20, 16, 13, 26, 19)
tilt = Motor(25, 24, 23)
pan = PWMOutputDevice(pin=12, frequency=500)
#comp = Compressor(12, 5)
#comp.start()
trigger_timer = 0
trigger_bool = False
while True:
#comp.update()
joy.update()
if joy.z > 0.7: pan.value = 0.77
elif joy.z < -0.7: pan.value = 0.68
else: pan.value = 0
tilt.set(joy.y)
if joy.trigger == 1:
trigger_bool = True
if trigger_bool:
if trigger_timer < 0.5:
sol.set(1)
elif trigger_timer < 0.8:
sol.set(-1)
def controlsDevices(working):
success = False
data = ""
if (working == 1):
print(" Water from alarm clock")
mosObj = json.loads(inputs.getMoistureObject())
if (ctrl.water()):
time.sleep(30) #wait 30 second
newMosObj = json.loads(inputs.getMoistureObject())
print(" old moisture: " + str(mosObj["average"]))
print(" new moisture: " + str(newMosObj["average"]))
if ((float(newMosObj["average"] - float(mosObj["average"]) > 5)
)): # if moisture value more than valus before
result = db.insertLogData(
int(time.time()), 1, 3, float(mosObj["average"]),
float(newMosObj["average"])) #insert log to database
if (result):
print(" All success")
success = True
data = {
"valBefore": float(mosObj["average"]),
"valAfter": float(newMosObj["average"])
}
else:
data = {
"errorCode": 0,
"msg": "database error",
"valBefore": float(mosObj["average"]),
"valAfter": float(newMosObj["average"])
}
else:
print(" Error! water not true Arare")
data = {"errorCode": 2, "msg": "water not true arare"}
else:
print(" Error! water not flows")
data = {"errorCode": 1, "msg": "water not flows"}
elif (working == 2):
print(" Shower from alarm clock")
temObj = json.loads(inputs.getTempObject())
if (ctrl.shower()):
time.sleep(20)
newTemObj = json.loads(inputs.getTempObject())
print(" old temp: " + str(temObj["average"]))
print(" new temp: " + str(newTemObj["average"]))
if (float(newTemObj["average"]) <= float(temObj["average"])):
result = db.insertLogData(
int(time.time()), 2, 3, float(temObj["average"]),
float(newTemObj["average"])) #insert log to database
if (result):
success = True
data = {
"valBefore": float(temObj["average"]),
"valAfter": float(newTemObj["average"])
}
print(" All success")
sp.put("lastTimeShower", int(time.time()))
else:
print(" Error! temp not decrease after shower")
data = {
"errorCode": 3,
"msg": "temp not decrease after shower"
}
else:
print(" Error! water not flows")
data = {"errorCode": 1, "msg": "water not flows"}
elif (working == 3):
print(" Open slat from alarm clock")
slatStatus = sp.get("slatStatus") #status of slat
print(" slatStatus: " + str(slatStatus))
if (int(slatStatus) != 1):
ligObj = json.loads(inputs.getLightObject())
if (ctrl.openSlat()): #if can open slat
time.sleep(20)
newLigObj = json.loads(inputs.getLightObject())
sp.put("slatStatus", str("1"))
result = db.insertLogData(
int(time.time()), 3, 3, float(ligObj["light_in"]),
float(newLigObj["light_in"])) #insert log to database
if (result):
success = True
data = {
"valBefore": float(ligObj["light_in"]),
"valAfter": float(newLigObj["light_in"])
}
print(" All success")
else:
data = {
"errorCode": 0,
"msg": "database error",
"valBefore": float(ligObj["light_in"]),
"valAfter": float(newLigObj["light_in"])
}
else:
print(" slat is opened (1)")
data = {"errorCode": 5, "msg": "slat is opened"}
print(str(data))
elif (working == 4):
print(" Close slat from alarm clock")
slatStatus = sp.get("slatStatus") #status of slat
print(" slatStatus: " + str(slatStatus))
if (int(slatStatus) != 0):
ligObj = json.loads(inputs.getLightObject())
if (ctrl.closeSlat()): #if can close slat
time.sleep(20)
newLigObj = json.loads(inputs.getLightObject())
print(" old light: " + str(ligObj["light_in"]))
print(" new light: " + str(newLigObj["light_in"]))
sp.put("slatStatus", str("0"))
result = db.insertLogData(
int(time.time()), 4, 3, float(ligObj["light_in"]),
float(newLigObj["light_in"])) #insert log to database
if (result == False):
data = {
"errorCode": 0,
"msg": "database error",
"valBefore": float(ligObj["light_in"]),
"valAfter": float(newLigObj["light_in"])
}
if (float(newLigObj["light_in"]) < float(ligObj["light_in"])):
success = True
data = {
"valBefore": float(ligObj["light_in"]),
"valAfter": float(newLigObj["light_in"])
}
else:
print(" new light value not decrease")
data = {"errorCode": 7, "msg": "light value not decrease"}
else:
print(" slat is closed (0)")
data = {"errorCode": 6, "msg": "slat is closed"}
return success, data
def ControlsTool(self):
import Controls
reload(Controls)
controlsTool = Controls.Controls()
controlsTool.CreateUI()
def qubiter_pic_file_to_mosaic_word_list(file_path, num_bits, ZL):
"""
Reads Qubiter native pic file and returns a mosaic word list,
which is a list of words all of which have the same number (
=num_bits) of characters.
Parameters
----------
file_path : str
Path to Qubiter native pic file.
num_bits : int
Number of qubits. The name of every native pic file generated by
Qubiter states the value of num_bits.
ZL : bool
Set to True iff file is using Zero bit Last convention. Opposite
of ZL is ZF (Zero First). The name of every native pic file
generated by Qubiter states either ZL or ZF.
Returns
-------
list[str]
"""
mosaic_word_list = []
inside_if_m_block = False
pic_file_in = open(file_path)
while not pic_file_in.closed:
line = pic_file_in.readline()
if not line:
pic_file_in.close()
break
line = line.replace('-', ' ')
split_line = line.split()
ch_list = []
# print("..", split_line)
if not inside_if_m_block:
m_block_controls = Controls(num_bits)
for vtx in split_line:
# print('vtx', vtx)
if vtx in ['@', '<', '>', '|', ':', '%', '+',
'H', 'M', 'O', 'Ph',
'Rx', 'Ry', 'Rz', 'R', 'X', 'Y', 'Z']:
ch_list.append(vtx[0])
elif vtx in ['OP', '@P']:
ch_list.append('?')
elif vtx in ['M1', 'M2']:
assert False, "unsupported measurement type"
elif vtx in ['LOOP', 'NEXT']:
assert False, "loops not supported by Mosaic"
elif vtx in ['NOTA', 'PRINT']:
break
elif vtx == 'IF_M(':
inside_if_m_block = True
# m_block_controls should be empty at this point
assert not m_block_controls.bit_pos_to_kind
trols = split_line[1:-1]
# print('trols', trols)
trol_bits = [int(x[:-1]) for x in trols]
trol_kinds = \
[True if x[-1] == 'T' else False for x in trols]
for bit, kind in zip(trol_bits, trol_kinds):
m_block_controls.bit_pos_to_kind[bit] = kind
m_block_controls.refresh_lists()
break
elif vtx == '}IF_M':
inside_if_m_block = False
break
else:
assert False, "unexpected circuit node: '" + vtx + "'"
# print("split_line", split_line)
# ch_list may be empty in cases where broke out of vtx loop
if ch_list:
# give controls of if_m block to gates inside block
assert len(ch_list) == num_bits, str(ch_list)
if inside_if_m_block:
for bit, kind in m_block_controls.bit_pos_to_kind.items():
if not ZL:
ch_list[bit] = '@' if kind else 'O'
else:
ch_list[num_bits - bit - 1] = '@' if kind else 'O'
# replace : by |
ch_list = [ch if ch != ':' else '|' for ch in ch_list]
# replace | by + when justified
gate_has_inter_qubit_wires = False
for ch in ch_list:
if ch in ['@', 'O', '<', '>', '+']:
gate_has_inter_qubit_wires = True
break
if gate_has_inter_qubit_wires:
non_vertical_pos = [k for k in range(num_bits)
if ch_list[k] != '|']
min_non_vert = min(non_vertical_pos)
max_non_vert = max(non_vertical_pos)
for k in range(min_non_vert+1, max_non_vert):
if ch_list[k] == '|':
ch_list[k] = '+'
mosaic_word_list.append(''.join(ch_list))
return mosaic_word_list
def qubiter_pic_file_to_tiny_word_list(file_path, num_bits, ZL):
"""
Reads Qubiter native pic file and returns a tiny word list, which is
a list of words all of which have the same number (=num_bits) of
characters.
Parameters
----------
file_path : str
Path to Qubiter native pic file.
num_bits : int
Number of qubits. The name of every native pic file generated by
Qubiter states the value of num_bits.
ZL : bool
Set to True iff file is using Zero bit Last convention. Opposite
of ZL is ZF (Zero First). The name of every native pic file
generated by Qubiter states either ZL or ZF.
Returns
-------
list[str]
"""
tiny_word_list = []
inside_if_m_block = False
pic_file_in = open(file_path)
while not pic_file_in.closed:
line = pic_file_in.readline()
if not line:
pic_file_in.close()
break
line = line.replace('-', ' ')
split_line = line.split()
ch_list = []
# print("..", split_line)
if not inside_if_m_block:
m_block_controls = Controls(num_bits)
for vtx in split_line:
# print('vtx', vtx)
if vtx in [
'@', '<', '>', '|', ':', '%', '+', 'H', 'M', 'O', 'Ph',
'Rx', 'Ry', 'Rz', 'R', 'X', 'Y', 'Z'
]:
ch_list.append(vtx[0])
elif vtx in ['OP', '@P']:
ch_list.append('?')
elif vtx in ['M1', 'M2']:
assert False, "unsupported measurement type"
elif vtx in ['LOOP', 'NEXT']:
assert False, "loops not supported by Tiny"
elif vtx in ['NOTA', 'PRINT']:
break
elif vtx == 'IF_M(':
inside_if_m_block = True
# m_block_controls should be empty at this point
assert not m_block_controls.bit_pos_to_kind
trols = split_line[1:-1]
# print('trols', trols)
trol_bits = [int(x[:-1]) for x in trols]
trol_kinds = \
[True if x[-1] == 'T' else False for x in trols]
for bit, kind in zip(trol_bits, trol_kinds):
m_block_controls.bit_pos_to_kind[bit] = kind
m_block_controls.refresh_lists()
break
elif vtx == '}IF_M':
inside_if_m_block = False
break
else:
assert False, "unexpected circuit node: '" + vtx + "'"
# print("split_line", split_line)
# ch_list may be empty in cases where broke out of vtx loop
if ch_list:
# give controls of if_m block to gates inside block
assert len(ch_list) == num_bits, str(ch_list)
if inside_if_m_block:
for bit, kind in m_block_controls.bit_pos_to_kind.items():
if not ZL:
ch_list[bit] = '@' if kind else 'O'
else:
ch_list[num_bits - bit - 1] = '@' if kind else 'O'
# replace : by |
ch_list = [ch if ch != ':' else '|' for ch in ch_list]
# replace | by + when justified
gate_has_inter_qubit_wires = False
for ch in ch_list:
if ch in ['@', 'O', '<', '>', '+']:
gate_has_inter_qubit_wires = True
break
if gate_has_inter_qubit_wires:
non_vertical_pos = [
k for k in range(num_bits) if ch_list[k] != '|'
]
min_non_vert = min(non_vertical_pos)
max_non_vert = max(non_vertical_pos)
for k in range(min_non_vert + 1, max_non_vert):
if ch_list[k] == '|':
ch_list[k] = '+'
tiny_word_list.append(''.join(ch_list))
return tiny_word_list
Returns
-------
None
"""
num_controls = len(controls.bit_pos)
assert num_controls == controls.get_num_int_controls(),\
"some of the controls of this multiplexor are not half-moons"
self.write_controlled_multiplexor_gate(
tar_bit_pos, controls, with_minus, rad_angles)
if __name__ == "__main__":
num_bits = 5
emb = CktEmbedder(num_bits, num_bits)
trols = Controls(num_bits)
trols.bit_pos_to_kind = {3: True, 4: False}
trols.refresh_lists()
ang_rads = 30*np.pi/180
for zf in [False, True]:
wr = SEO_writer('io_folder//wr_test', emb, zero_bit_first=zf)
wr.write_NOTA('zero bit first = ' + str(zf))
wr.write_LOOP(10, 15)
wr.write_NEXT(10)
wr.write_controlled_bit_swap(0, 2, trols)
def __init__(self):
pygame.init()
pygame.mixer.init()
pygame.display.set_caption("Sokoben")
self.asset = Asset()
self.background = self.asset.createBackground()
self.sound = Sound(self.asset)
self.asset.loadImages()
self.asset.loadLevels()
self.asset.loadSounds()
self.asset.loadFonts()
self.asset.loadControls()
self.levelIndex = 0
self.level = None
Controls.add('sound_enabled', self.asset.controls['sound_enabled'],
(const.MAPWIDTH * const.TILEWIDTH) - ((1 * 64) + 64), 10,
self.sound.enabled)
Controls.add('sound_disabled', self.asset.controls['sound_disabled'],
(const.MAPWIDTH * const.TILEWIDTH) - ((1 * 64) + 64), 10,
not self.sound.enabled)
Controls.add('reset', self.asset.controls['reset'],
(const.MAPWIDTH * const.TILEWIDTH) - ((2 * 64) + 64), 10,
True)
Controls.add('undo', self.asset.controls['undo'],
(const.MAPWIDTH * const.TILEWIDTH) - ((3 * 64) + 64), 10,
True)
Controls.add('next', self.asset.controls['next'],
(const.MAPWIDTH * const.TILEWIDTH) - ((4 * 64) + 64), 10,
True)
Controls.add('back', self.asset.controls['back'],
(const.MAPWIDTH * const.TILEWIDTH) - ((5 * 64) + 64), 10,
True)
Controls.add('solution', self.asset.controls['solution'],
(const.MAPWIDTH * const.TILEWIDTH) - ((6 * 64) + 64), 10,
False)
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(
(const.MAPWIDTH * const.TILEWIDTH,
(const.MAPHEIGHT - 1) * const.TILEANGLEHEIGHT + const.TILEHEIGHT))
def main():
num_bits = 5
emb = CktEmbedder(num_bits, num_bits)
trols = Controls(num_bits)
trols.bit_pos_to_kind = {3: True, 4: False}
trols.refresh_lists()
ang_rads = 30 * np.pi / 180
for ZL in [False, True]:
wr = SEO_writer('io_folder/wr_test', emb, ZL=ZL)
wr.write_NOTA('zero bit last = ' + str(ZL))
wr.write_IF_M_beg(trols)
wr.write_IF_M_end()
wr.write_LOOP(10, 15)
wr.write_NEXT(10)
tar_bit_pos = 1
for kind in [0, 1, 2]:
wr.write_MEAS(tar_bit_pos, kind)
wr.write_PRINT('F2')
wr.write_controlled_bit_swap(0, 2, trols)
wr.write_bit_swap(1, 2)
gate = OneBitGates.phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
wr.write_global_phase_fac(30 * np.pi / 180)
gate = OneBitGates.P_0_phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
gate = OneBitGates.P_1_phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
gate = OneBitGates.sigx
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.sigy
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.sigz
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.had2
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 1])
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 2])
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 3])
gate = OneBitGates.rot
wr.write_controlled_one_bit_gate(
2, trols, gate, [ang_rads / 3, ang_rads * 2 / 3, ang_rads])
gate = OneBitGates.sigx
wr.write_one_bit_gate(2, gate)
wr.write_cnot(2, 1)
tar_bit_pos = 0
trols1 = Controls(num_bits)
trols1.bit_pos_to_kind = {1: 0, 2: 1, 3: True, 4: False}
trols1.refresh_lists()
wr.write_controlled_multiplexor_gate(
tar_bit_pos, trols1,
[ang_rads / 3, ang_rads * 2 / 3, ang_rads, ang_rads * 4 / 3])
trols2 = Controls(num_bits)
trols2.bit_pos_to_kind = {1: 0, 2: 1}
trols2.refresh_lists()
wr.write_multiplexor_gate(
tar_bit_pos, trols2,
[ang_rads / 3, ang_rads * 2 / 3, ang_rads, ang_rads * 4 / 3])
wr.close_files()
def __init__(self): self.backgrounds = RenderPlain() self.controls = Controls() self.sprites = RenderPlain()
import pygame
from pygame.locals import*
from Controls import*
from os import walk
from Game.ObjectManager import*
from Coding_Bar.Coding_Bar import*
import thread
import sys
import time
pygame.init()
nextFrame = pygame.time.Clock()
rightEdge = 1020
screenUpdate = True
Window = pygame.display.set_mode((rightEdge,480))
pygame.display.set_caption("Project Code")
controls = Controls()
controlsPressed = []
controlsHold = []
codingBar = Coding_Bar()
codingBar.setString([""]);
mousePressed = False
mousePos = False
gameLoop = True
OBJMAN = ObjectManager()
OBJMAN.room = int(sys.argv[1])
OBJMAN.setUpRoom()
if (int(sys.argv[2]) > -1):
for i in range(0,len(OBJMAN.instance)):
if (OBJMAN.instance[i].name == "Player"):
OBJMAN.instance[i].x = int(sys.argv[2])
OBJMAN.instance[i].y = int(sys.argv[3])
def __init__(self, *args, **kwargs):
Tkinter.Tk.__init__(self, *args, **kwargs)
ct = Controls.Main(root=self)
self.hook = ct.hook
self.controls_ = ct.hook2
self.creating_menu_bar()
truetheta[:, 0] = 2*np.pi*np.random.rand(n_robots)
measpos[:, :, 0] = truepos[:, :, 0]
currpos[:, :, 0] = truepos[:, :, 0]
currtheta[:, 0] = truetheta[:, 0]
"""
truepos[:, :, 0] = np.array([[-6, 7, 1],
[7, -2, -8]]).T
truetheta[:, 0] = 2*np.pi*np.random.rand(n_robots)
currpos[:, :, 0] = truepos[:, :, 0]
currtheta[:, 0] = truetheta[:, 0]
"""
kal = [Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[0, 0]),
Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[1, 0]),
Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[2, 0])]
ctrl = [Controls.Controls(0.05, 1, 0, 1),
Controls.Controls(0.05, 1, 0, 1),
Controls.Controls(0.05, 1, 0, 1)]
basepos = 10*np.random.rand(2)-5
endnodepos = 10*np.random.rand(2)-5
"""
basepos = np.array([8, 7])
endnodepos = np.array([-7, -8])
"""
X = np.zeros((n_robots, n_iter_no_corr*iterations))
Z = np.zeros((n_robots, n_iter_no_corr*iterations))
for j in range(0, iterations):
controlnoiset = np.random.normal(0, sigma_X)
controlnoiser = np.random.normal(0, sigma_Z)
def __init__(self):
self.controls = Controls()
self.sensors = Sensors()
self.brains = AI()
def controlsDevices(payload):
success = False
message = ""
response = None
if(payload == 1):
print(" Water from user command")
mosObj = json.loads(inputs.getMoistureObject())
if(ctrl.water()):
time.sleep(10) #wait 10 second
newMosObj = json.loads(inputs.getMoistureObject())
print(" old moisture: "+str(mosObj["average"]))
print(" new moisture: "+str(newMosObj["average"]))
if((float(newMosObj["average"]-float(mosObj["average"])>5))):# if moisture value more than valus before
onRefreshRawData()
result = db.insertLogData(int(time.time()),1,2,float(mosObj["average"]),float(newMosObj["average"])) #insert log to database
if(result):
print(" All success")
success = True
message = json.dumps({"working":payload,"valBefore":float(mosObj["average"]),"valAfter":float(newMosObj["average"])})
publisLogDataList()
else:
message = json.dumps({"errorCode":0,"msg":"database error","working":payload,"valBefore":float(mosObj["average"]),"valAfter":float(newMosObj["average"])})
else:
if((float(newMosObj["average"])>float(mosObj["average"]))>=1):
message = json.dumps({"errorCode":8,"working":payload,"valBefore":float(mosObj["average"]),"valAfter":float(newMosObj["average"])})
publisLogDataList()
else:
print(" Error! water not true Arare")
message = json.dumps({"working":payload,"errorCode":2,"msg":"water not true arare"})
else:
print(" Error! water not flows")
message = json.dumps({"working":payload,"errorCode":1,"msg":"water not flows"})
elif(payload == 2):
print(" Shower from user command")
fqShower = "fqShower" #frequency to shower (0 = auto, > 0 = user setting)
timeStamp = int(time.time())
lastTimeShower = sp.get("lastTimeShower")
print("lastTimeShower: "+str(lastTimeShower))
minStamp = 60
m = ""
fq = sp.get(fqShower)
if(fq == 0):
fq = t.getFqShower()#get ferquency from system (fq in minute *60) minStamp
if(int(timeStamp)>=(int(lastTimeShower)+(int(fq)*int(minStamp)))):
temObj = json.loads(inputs.getTempObject())
if(ctrl.shower()):
time.sleep(10)
newTemObj = json.loads(inputs.getTempObject())
print(" old temp: "+str(temObj["average"]))
print(" new temp: "+str(newTemObj["average"]))
if(float(newTemObj["average"])<=float(temObj["average"])):
onRefreshRawData()
result = db.insertLogData(timeStamp,2,2,float(temObj["average"]),float(newTemObj["average"])) #insert log to database
if(result):
success = True
message = json.dumps({"working":payload,"valBefore":float(temObj["average"]),"valAfter":float(newTemObj["average"])})
print(" All success")
publisLogDataList()
sp.put("lastTimeShower",timeStamp)
else:
message = json.dumps({"errorCode":0,"msg":"database error","working":payload,"valBefore":float(temObj["average"]),"valAfter":float(newTemObj["average"])})
else:
print(" Error! temp not decrease after shower")
message = json.dumps({"working":payload,"errorCode":3,"msg":"temp not decrease after shower"})
else:
print(" Error! water not flows")
message = json.dumps({"working":payload,"errorCode":1,"msg":"water not flows"})
else:
nextTime = (int(lastTimeShower)+(int(fq)*int(minStamp)))
print(" not time to shower, Working again at "+str(t.timeStampToDateTime(nextTime)))
message = json.dumps({"working":payload,"errorCode":4,"msg":str(nextTime)})
elif(payload == 3):
print(" Open slat from user command")
slatStatus = sp.get("slatStatus") #status of slat
print(" slatStatus: " +str(slatStatus))
if(int(slatStatus) != 1):
ligObj = json.loads(inputs.getLightObject())
if(ctrl.openSlat()):#if can open slat
time.sleep(10)
newLigObj = json.loads(inputs.getLightObject())
sp.put("slatStatus",str("1"))
publisSlatStatus(1)
result = db.insertLogData(int(time.time()),3,2,float(ligObj["light_in"]),float(newLigObj["light_in"])) #insert log to database
onRefreshRawData()
if(result):
publisLogDataList()
success = True
message = json.dumps({"working":payload,"valBefore":float(ligObj["light_in"]),"valAfter":float(newLigObj["light_in"])})
print(" All success")
else:
message = json.dumps({"errorCode":0,"msg":"database error","working":payload,"valBefore":float(ligObj["light_in"]),"valAfter":float(newLigObj["light_in"])})
else:
print(" slat is opened (1)")
message = json.dumps({"working":payload,"errorCode":5,"msg":"slat is opened"})
elif(payload == 4):
print(" Close slat from user command")
slatStatus = sp.get("slatStatus") #status of slat
print(" slatStatus: " +str(slatStatus))
if(int(slatStatus) != 0):
ligObj = json.loads(inputs.getLightObject())
if(ctrl.closeSlat()): #if can close slat
time.sleep(10)
newLigObj = json.loads(inputs.getLightObject())
print(" old light: "+str(ligObj["light_in"]))
print(" new light: "+str(newLigObj["light_in"]))
sp.put("slatStatus",str("0"))
publisSlatStatus(0)
result = db.insertLogData(int(time.time()),4,2,float(ligObj["light_in"]),float(newLigObj["light_in"])) #insert log to database
onRefreshRawData()
if(result):
publisLogDataList()
else:
message = json.dumps({"errorCode":0,"msg":"database error","working":payload,"valBefore":float(ligObj["light_in"]),"valAfter":float(newLigObj["light_in"])})
if(float(newLigObj["light_in"]) < float(ligObj["light_in"])):
success = True
message = json.dumps({"working":payload,"valBefore":float(ligObj["light_in"]),"valAfter":float(newLigObj["light_in"])})
else:
print(" new light value not decrease")
message = json.dumps({"working":payload,"errorCode":7,"msg":"light value not decrease"})
else:
print(" slat is closed (0)")
message = json.dumps({"working":payload,"errorCode":6,"msg":"slat is closed"})
response = json.dumps({"topic":"controlDevices","success":success,"message":message})
#print("response: "+str(response))
if(isConnect()):
microgear.publish("/response",str(response))
