def __init__(self, parent, **kwargs):
Control.__init__(self, Label(master=parent._frame), **kwargs)
# Tk does not have a truly dedicated "Image" object
# unless you install PIL
self._picture = Picture(self._ctrl)
if kwargs.get('file'):
self._picture.open_file(kwargs['file'])
def mainWindow(self):
config = {
'address': self.addressEdit.text(),
'port': self.portEdit.text(),
'bankcard': self.bankcardEdit.text(),
'password': self.passwordEdit.text()
}
# 输入检查
flag = True
for key in config.keys():
if config[key] == "":
flag = False
self.statusBar().showMessage("Please input the {}.".format(key))
break
if key == 'port':
try:
config[key] = int(config[key])
except Exception as e:
self.statusBar().showMessage("Please input the right number at port")
break
if flag:
self.control = Control(**config)
reply = self.control.login()
self.statusBar().showMessage('{}'.format(reply['msg']))
logging.debug("reply: {}".format(str(reply)))
if reply['status'] == True: # login sucessfully
self.close()
self.main = Ui_main(self.control)
def heating(self, Indoor, Parameter, Control):
if Indoor.get_temperature(
) < Parameter.hearting_start_lowest_temperature:
Control.set_heating("on")
elif Indoor.get_temperature(
) > Parameter.hearting_stop_highest_temperature:
Control.set_heating("off")
def move():
print(request.json)
data = request.get_json()
x = int(data['x'])
y = int(data['y'])
con = psycopg2.connect(database="postgres",
user="******",
password="******",
host="localhost",
port="5432")
cur = con.cursor()
cur.execute("SELECT MVE, X, Y from MOUSE WHERE ID = '1'")
row = cur.fetchall()
if (row[0][0] == '1'):
c = Control()
c.moveMouse(x, y, row[0][1], row[0][2])
cur.execute("UPDATE MOUSE set x = %s, y=%s where id = 1", (x, y))
con.commit()
print("Coordinates updated")
con.close()
return ""
else:
print("No movement. toggle off")
return ""
class Anna(sleekxmpp.ClientXMPP):
def __init__(self):
config = ConfigParser()
config.read("config.ini")
jid = config.get("general", "jid")
resource = config.get("general", "resource")
password = config.get("general", "password")
self._owners = config.get("general", "owner").split(",")
sleekxmpp.ClientXMPP.__init__(self, jid + "/" + resource, password)
self._rooms = []
self._control = Control(self)
self.add_event_handler("session_start", self.handle_XMPP_connected)
self.add_event_handler("message", self.handle_incoming_message)
for r in config.get("general", "rooms").split(","):
self._rooms.append(room.Room(self, config.get(r, "room"), config.get(r, "modules").split(','), config.get(r, "botname")))
def handle_XMPP_connected(self, event):
self.sendPresence(pstatus = "<3")
self.getRoster()
for room in self._rooms:
room.connect()
def handle_incoming_message(self, message):
if message['type'] == 'chat':
for room in self._rooms:
if room.get_roomname() == message['from'].bare and message['from'].resource in room.get_roster():
room.handle_private_message(message, message['from'])
break
if message['from'].bare in self._owners:
self._control.handle_message(message, message['from'])
def fogging(self,Indoor,Parameter,Control):
if Indoor.get_temperature()>Parameter.temperature_to_open_fogging+1:
Control.set_fogging("on")
# if Control.get_thermal_screen()=="on"
# Control.set_thermal_screen("off")
elif Indoor.get_temperature()<Parameter.temperature_to_open_fogging-1:
Control.set_fogging("off")
def main():
cfg = Config()
# PyGame init
pygame.init()
screen = pygame.display.set_mode(cfg.getDisplay())
pygame.display.set_caption("Solar Mechanics")
# Space init
bg = Surface(cfg.getDisplay())
bg.fill(Color(cfg.getSpaceColor()))
# Draw fixed stars
for i in range(cfg.getStarNumber()):
draw.circle(bg, Color(random.sample(cfg.getStarColors(), 1)[0]),
(random.randrange(bg.get_width()),
random.randrange(bg.get_height())),
0)
# Timer init
timer = pygame.time.Clock()
control = Control(timer, screen, bg, cfg)
control.run()
# Farewell
print(":-)")
def main():
global mainloop
parser = argparse.ArgumentParser(description="KNoT DBUS-Control Daemon")
parser.add_argument("-w", "--working-dir", metavar="<path>",
default="/usr/local/bin",
type=str,
help="Daemon working directory")
parser.add_argument("-p", "--pid-filepath", metavar="<path/control>",
default="/tmp/control", type=str,
help="PID file path and name")
parser.add_argument("-n", "--detach-process", action="store_false",
help="Detached process")
args = parser.parse_args()
context = daemon.DaemonContext(
working_directory=args.working_dir,
umask=0o002,
detach_process=args.detach_process,
pidfile=lockfile.FileLock(args.pid_filepath),
signal_map={signal.SIGTERM: quit_cb, signal.SIGINT: quit_cb},
stdout=sys.stdout,
stderr=sys.stderr,
)
with context:
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
control = Control()
control.start()
mainloop = GObject.MainLoop()
mainloop.run()
def __init__(self, twin=process_models.RegressionDynamicTwin()):
Control.__init__(self)
self.twin = twin
self.interval = .1 # sec
# control parameters
self.htrP = 0.02 # .02
self.htrI = 0.00005 # .0005
self.htrD = 0.0
self.htrPIDint = .5 # sec
self.htrPID_last_time = 0.0
self.tempPID = pid1()
self.tempPID.is_running = False
self.tempPID.iomax = 1.0 # .3
self.spoolP = 0.1 # .1
self.spoolI = 0.5 # .5
self.spoolD = 0.0
self.spoolPIDint = .25 # sec
self.spoolPID_last_time = 0.0
self.spoolPID = pid1()
self.spoolPID.is_running = False
self.spool_cur_dia = 20.0 # mm
self.wind_set_freq = 0.0
self.wind_count = 1
self.fibP = 0.0
self.fibI = 0.0
self.fibD = 0.0
self.fibPIDint = .5 # sec
self.fibPID = pid1()
def __init__(self):
# init pygame components
pygame.init()
pygame.display.set_caption(GAME_TITLE)
self._screen = pygame.display.set_mode(SCREEN_RESOLUTION)
self._background = pygame.Surface(self._screen.get_size()).convert()
self._background.fill(colors.WHITE)
self._font = pygame.font.SysFont(None, 24)
self._set_message("Press PAUSE key to start!", colors.GREEN)
# init game components
rect_pixel_length = 20
self._field = GameField(self._screen, GRID_COLUMNS, GRID_ROWS,
rect_pixel_length)
self._preview = Preview(self._screen, SCREEN_RESOLUTION[0] - 100, 20,
Brick.DIMENSION, int(rect_pixel_length / 2))
self._figure_factory = FigureFactory(self._field)
self._figure = next(self._figure_factory)
self._next_figure = next(self._figure_factory)
self._score = Score()
self._control = Control(START_FPS)
# init speed and game state
self._stepover = START_GAME_STEPOVER
self._nostep = self._stepover
self._looping = True
self._was_started = False
self._has_stopped = False
self._is_paused = True
def main(stdscr):
CLOCK_CYCLE = 0.1
t = 0
s = Control(stdscr)
stdscr.nodelay(True)
curses.curs_set(0)
stdscr.resize(24, 80)
stdscr.clear()
stdscr.border(0, 0, 0, 0, 0, 0, 0, 0)
while (True):
c = stdscr.getch()
curses.flushinp()
stdscr.clear()
# Game preprocessing logic: make aliens, etc
t = (t + CLOCK_CYCLE) % 10
s.refreshAlien()
if (t <= CLOCK_CYCLE):
s.genAlien()
# draw board
s.draw(t)
# deal with input
if (c == ord('q')):
return
s.keyIn(c)
stdscr.border(0, 0, 0, 0, 0, 0, 0, 0)
stdscr.resize(24, 80)
time.sleep(CLOCK_CYCLE)
def __init__(self, params):
Control.__init__(self, params)
self.params = { \
'Kp' : 'Proportional gain of speed controller', \
'Ki' : 'Integration gain of speed controller', \
'Ti' : 'Integration time of speed controller', \
'Kpt' : 'Proportional gain of torque controller', \
'Kit' : 'Integration gain of torque controller', \
'Tit' : 'Integration time of torque controller', \
'P' : 'Motor polepairs', \
'Sf' : 'Speed filter time constant [s]', \
'Umax' : 'Maximum output voltage amplitude [V]', \
'Ts' : 'Controller execution interval [s]'
}
self.Ts = 1.0 / 5.0e3 # Controller run interval (control cycle) [s]
self.Tnext = self.Ts # Time to next run if calculation step is shorter than control cycle
self.output = [0.0] * 3 # Output voltages in 3-phase system
self.vsupply = [
0.0
] * 2 # Output (motor supply) voltages in alpha-beta frame
self.current = [0.0] * 2 # Output (motor) currents in alpha-beta frame
# Motor model, this is default
self.model = Model_BLDC_Slide()
self.set_parameters(params)
return
def playRandomValve():
vCtl = Control(choirs)
v = vCtl.getControlsByType("valve");
rand = randint(0, len(v))
v[rand].isActive = True
v[rand].isDynamic = True
v[rand].goTo(Vector(utils.pickPosition()),speed=2, active=True)
def play():
pygame.init() # инициализируем библиотеку pygame
window = pygame.display.set_mode((441, 480)) # создание окна c размером
pygame.display.set_caption("Змейка") # задаём название окна
control = Control()
snake = Snake()
bot = Bot()
#is_basic True -- запуск обычный, False -- запуск рандомной карты из файлов
gui = Gui(is_basic=False)
food = Food()
gui.init_field()
food.get_food_position(gui, snake.body, bot.body)
var_speed = 0 # переменная для регулировки скорости выполнения программы
#gui.create_image()
while control.flag_game:
gui.check_win_lose(snake.body)
control.control()
window.fill(pygame.Color(
"Black")) # закрашивание предыдущего квадрата чёрным цветом
if gui.game == "GAME": # если флаг равен "GAME"
snake.draw_snake(
window) # то вызываем метод отрисовки змеи на экране
bot.draw_snake(window) #отрисовка бота-змеи
if (food.timer <= 0): # проверка на жизнь еды
food.get_food_position(gui, snake.body, bot.body)
food.draw_food(window) # и метод отрисовки еды
elif gui.game == "WIN": # если флаг равен "WIN"
if (bot.points <=
snake.points): #проверка очков, кто больше набрал
gui.draw_win(window)
else:
gui.draw_lose(window)
elif gui.game == "LOSE": # если флаг равен "LOSE"
gui.draw_lose(window) # то отрисовываем избражение поражения
gui.draw_indicator(window)
gui.draw_level(window)
if var_speed % 50 == 0 and control.flag_pause: # если делится без остатка, то производим изменение координаты квадрата and реакция на паузу
snake.moove(control.flag_direction)
snake.check_barrier(gui)
mv = "" #проверка бота, все ли работает правильно (можно убрать, но так спокойнее)
try:
mv = bot.move(food.food_position, gui.level)
except:
mv = bot.move(food.food_position, gui.level)
#print(mv)
bot.moove(mv)
#не трубуется, тк бот никогда к ним не подлезет bot.check_barrier(gui)
#проверка на съедение и генерация новой еды вне тела змеи
if snake.eat(food, gui) or bot.eat(food, gui):
food.get_food_position(gui, snake.body, bot.body)
bot.check_end_window()
snake.check_end_window()
bot.animation()
snake.animation()
var_speed += 1
pygame.display.flip() # метод отображения окна
def viz_sys(system_id):
logging.info('Check on first base %s', system_id)
try:
target = System.get(System.id == system_id)
family = Control().family(target)
mynodes = ["{id: 9999, hidden: true, value: 0.001 }"]
myedges = []
logging.info('Check on family: %s', family)
pathway = target.name
# unknown_body_distance = range(1, 10, 1)is not working with the vis.js vizualization
for member in family:
data = Control().jsonviz(member)
# except:
# logging.warning('jsonwiz func failture - on %s', member.name)
if data[1]:
print data[1]
myedges.append(data[1])
mynodes.append(data[0])
# use the code below to order bodies by their distance one day
# try:
# sem = member.semimajoraxis * 215
# except:
# sem = (unknown_body_distance.pop(0)/2.0) * 215
#
logging.info('here are nodes: %s and edges: %s', mynodes, myedges)
return render_template('vizsys2.html',
pathway=pathway,
mynodes=mynodes,
myedges=myedges)
except:
return redirect(url_for('Main'))
def __init__(self, debug, ip_address=None):
self._debug_print("SshControl::init")
Control.__init__(self, debug)
self._ip_address = ip_address
if sys.platform.startswith('win'):
print "Windows SSH not support yet!"
sys.exit(-1)
def cooling_pump(self, Indoor, Parameter, Control):
if Indoor.get_temperature() > (
Parameter.temperature_to_open_cooling_pad + 1):
Control.set_cooling_pad("on")
elif Indoor.get_temperature() < (
Parameter.temperature_to_open_cooling_pad -
1): # 此时侧窗是与湿帘风机对应的，所以暂时不需要考虑90度方向的侧窗是否关闭
Control.set_cooling_pad("off")
def tubeLengths():
vCtl = Control(telescopics)
lenghts = vCtl.getControlsByType("length")
print("[] lengths", lenghts)
for i in lenghts:
i.goTo(Vector(utils.pickPosition()),speed=60, active=True)
i.isActive = True
i.isDynamic = True
def api_control_power():
action = request.args.get('action')
control = Control(config['control'])
if action == 'halt':
control.halt()
elif action == 'reboot':
control.reboot()
return json.dumps('OK')
def __init__(self, parent, **kwargs):
Control.__init__(self, TkScale(parent._frame), **kwargs)
self.min = 0
self.max = 100
self.value = 0
self.ticks = 0
self.show_label = False
self.orientation = HORIZONTAL
def pipeTiraps(vertical=0.1, horizontal=0.1):
c = Control(pipes)
# c.addControllers("Tele", "speed", "Forceer")
horiz = c.getControlsByType("tirapVert")
for h in horiz:
liblo.send(oneShotAddress, h.oscurl, vertical)
vert = c.getControlsByType("tirapHoriz")
for v in vert:
liblo.send(oneShotAddress, v.oscurl, horizontal)
def __init__(self, null_control=False, **kwargs):
"""
null_control boolean:
"""
Control.__init__(self, **kwargs)
self.DOF = 2
self.null_control = null_control
def __init__(self, **kwargs):
Control.__init__(self, **kwargs)
self.target = None
# generalized coordinates
self.target_gain = 2*np.pi
self.target_bias = -np.pi
def removeChoirSpeedDynamics():
global irTriggered
intonaData = ctl.getIntonaData()
c = Control(choirs)
s = c.getControlsByType("speed")
for speed in s:
speed.stopDynamics()
speed.setParent("Forceer")
irTriggered = False
def set_motor(self, motor):
if motor.get_config_word('Name') != 'BLDC':
print('Motor type not BLDC')
return False
Control.set_motor(self, motor)
return True
def __init__(self, **kwargs):
Control.__init__(self, **kwargs)
self.target = None
# generalized coordinates
self.target_gain = 2 * np.pi
self.target_bias = -np.pi
def allOut():
global ENERGY
for c in [choirs, pipes, telescopics]:
ctl = Control(c)
v = ctl.getControlsByType("valve")
for valve in v:
valve.removeParent()
valve.stopDynamics()
valve.goTo(Vector((-20, 0, 5)), speed=3, active=True, callback=energyZero)
def __init__(self, null_control=False, **kwargs):
"""
null_control boolean:
"""
Control.__init__(self, **kwargs)
self.DOF = 2
self.null_control = null_control
def telescopicMotors(speed=0.3):
c = Control(telescopics)
# c.addControllers("Tele", "speed", "Forceer")
s = c.getControlsByType("speed")
for sp in s:
liblo.send(oneShotAddress, sp.oscurl, 0.3)
l = c.getControlsByType("length")
for length in l:
rLen = random()
liblo.send(oneShotAddress, length.oscurl, rLen)
def __init__(self, parent, **kwargs):
Control.__init__(self, TkProgressBar(), **kwargs)
self._min = 0
self._max = 0
self._value = 0
self.max = 100
self.min = 0
self.value = 50
def main():
global users
users = dict()
t = Control()
t.start()
reactor.listenTCP(PORT, ServerFactory())
log("Server started, port {0}\n".format(PORT))
reactor.run()
class AscendModule:
update_thread = None
vessel = None
conn = None
ref_frame = None
target_parameters = None
actual_parameters = None
controller = None
ruleset = None
finish = False
def __init__(self, conn, vessel, ruleset):
self.vessel = vessel
self.conn = conn
self.ruleset = ruleset
self.ref_frame = conn.space_center.ReferenceFrame.create_hybrid(
position=vessel.orbit.body.reference_frame,
rotation=vessel.surface_reference_frame)
self.controller = Control(conn, vessel, ruleset, self.ref_frame)
self.vessel.auto_pilot.engage()
self.update_thread = threading.Thread(target=self.update,
name="Ascent Update Thread")
self.update_thread.run()
print(self.update_thread)
def set_orbital_parameters(self, params):
self.target_parameters = params
def update(self):
while not self.finish:
self.actual_parameters = OrbitalParameters(self.vessel)
if self.actual_parameters == self.target_parameters:
self.stop()
self.controller.update()
#self.conn.drawing.add_direction((1, 0, 0), self.ref_frame)
#self.conn.drawing.add_direction((0, 1, 0), self.ref_frame)
time.sleep(0.1)
def stop(self):
self.finish = True
self.update_thread.join(1)
def __init__(self):
Object.__init__(self)
self.dash = list()
self.radius = 20
control = Control()
self.handler.control.append(control)
control = Control()
self.handler.control.append(control)
self.block = False
def main():
log.startLogging(sys.stdout)
opt = parse_args()
control = Control(opt['control_port'], opt['tls_conf'])
control.start_listen()
from twisted.internet import reactor
reactor.run()
def event_switch_to_list_view(self, widget, event, data=None):
TixMode.current = TixMode.LIST
self.status_bar.update("- Search: %s" % Control.get_last_regex() if Control.get_last_regex() else "")
if Control.reload_notes:
self.stored_items.load(self.notes_root, self.recursive)
self.create_list()
Control.reload_notes = False
self.vbox.remove(self.editor.get_parent())
self.vbox.pack_start(self.commandline, False, False, 0)
self.vbox.add(self.tree_view.get_parent())
self.tree_view.grab_focus()
self.main_window.show_all()
def __init__(self):
"""
Initializes the app and creates an control instance
"""
super().__init__(sys.argv)
self.control = Control()
while self.control.view.isVisible():
self.control.update()
self.processEvents()
sys.exit()
def home_post():
object_control = Control()
object_control.user_question = request.get_json()
object_control.all_steps()
if object_control.case == 0:
return jsonify(
dialog_to_show=object_control.list_dialog,
gmap_key=object_control.object_gmap.googlemap_key,
latitude=object_control.object_gmap.googlemap_coordinates[0],
longitude=object_control.object_gmap.googlemap_coordinates[1])
else:
return jsonify(dialog_to_show=object_control.list_dialog)
def __init__(self, config):
self.config = config
self.game = Game()
self.queue = Queue.Queue(0)
pp("Initiating Irc Thread")
self.c1 = Control(1, "Controller-1", self.config, self.queue, Irc.from_config(self.config, self.queue).start)
self.c1.daemon = True
self.c1.start()
pp("Initiating Tornado Thread")
self.c2 = Control(2, "Controller-2", self.config, self.queue, web.run)
self.c2.daemon = True
self.c2.start()
def test_control_andi(self):
control = Control()
control.update(create_sized_binary_num(12, 6))
self.assertEqual(False, control.RegDst)
self.assertEqual(True, control.ALUSrc)
self.assertEqual(False, control.MemtoReg)
self.assertEqual(True, control.RegWrite)
self.assertEqual(False, control.MemRead)
self.assertEqual(False, control.MemWrite)
self.assertEqual(False, control.Branch)
self.assertEqual(0b11, control.ALUOp)
self.assertEqual(False, control.jump)
class Handler:
"""This class represents a rectangular control points handler"""
def __init__(self):
self.control = list()
self.can_pivot = True
self.center_pivot = False
self.pivot = Control()
self.pivot.pivot = True
self.line = False
self.is_testing = False
index = 0
while index < ANONIMOUS:
control = Control()
self.control.append(control)
index += 1
def draw_handler(self, context):
if not self.line:
context.set_antialias(cairo.ANTIALIAS_NONE)
context.set_line_width(1.0 / context.get_matrix()[0])
context.set_source_rgb(0.5, 0.5, 1.0)
dash = []
context.set_dash(dash)
context.rectangle(self.x, self.y, self.width, self.height)
context.stroke()
context.set_antialias(cairo.ANTIALIAS_DEFAULT)
def draw_controls(self, context):
for control in self.control:
control.draw(context)
def draw_pivot(self, context):
self.pivot.draw(context)
def draw(self, context):
self.draw_handler(context)
self.draw_controls(context)
if self.can_pivot:
self.draw_pivot(context)
def at_position(self, x, y):
return self.get_direction(x, y) is not NONE
def get_direction(self, x, y):
for direction, control in enumerate(self.control):
if control.at_position(x, y):
return direction
return NONE
def main():
print sys.argv
arg = sys.argv[1]
command = Command()
command.room = 'living'
command.action = 'power'
command.value = 'on'
if arg == '1':
command.value = 'on'
elif arg == '2':
command.value = 'off'
control = Control()
control.execute_command(command)
def main():
print sys.argv
arg = sys.argv[1]
command = Command()
command.room='living'
command.action='power'
command.value='on'
if arg == '1':
command.value = 'on'
elif arg == '2':
command.value = 'off'
control = Control()
control.execute_command(command)
def datagramReceived(self, data, addr):
"""Event handler of receiving a UDP request.
Verify the identity of the client and assign a Control
to it if it is trusted.
"""
logging.debug("received DNS request from %s:%d" % (addr[0], addr[1]))
if not self.transmit:
try:
dnsq = dnslib.DNSRecord.parse(data)
query_data = str(dnsq.q.qname).split('.')
# Give a NXDOMAIN response
self.answer(dnsq, addr)
except KeyError:
logging.info("Corrupt request")
try:
# One control corresponds to one client (with a unique SHA1)
# TODO: get obfs level from query length
if self.transmit:
main_pw, client_sha1, number, tcp_port, remote_ip, certs_str, signature = \
self.parse_udp_msg_transmit(data)
else:
main_pw, client_sha1, number, tcp_port, remote_ip, certs_str, signature = \
self.parse_udp_msg(*query_data[:6])
if (client_sha1 + main_pw) not in self.controls:
cert = self.certs_db.query(client_sha1)
control = Control(self, signature, client_sha1, cert[0], cert[1],
remote_ip, tcp_port,
main_pw, number, certs_str)
self.controls[client_sha1 + main_pw] = control
else:
control = self.controls[client_sha1 + main_pw]
control.update(remote_ip, tcp_port, number)
control.connect()
except CorruptedReq:
logging.debug("corrupt request")
except KeyError:
logging.warning("untrusted client attempting to connect")
except AssertionError:
logging.debug("authentication failed or corrupt request")
except BlacklistReq:
logging.debug("request or salt on blacklist")
except IllegalReq:
logging.debug("request for too many connections")
def game_loop(self):
clock = pygame.time.Clock()
#Initialize
self.scoreboard = Scoreboard()
self.timer = CountDown()
self.control = Control()
self.graphics = Graphics(self.scoreboard, self.timer);
self.player = Player(self.graphics)
self.world = World(self.graphics, self.player)
self.logic = Logic(self.player, self.world, self.graphics, self.scoreboard, self.timer, self.control)
while globalvars.run_game:
delta = clock.tick(30) # fps
# Catch input event
for event in pygame.event.get():
if event.type == QUIT:
return
else:
self.control.update(event)
# Update
self.logic.update(delta)
self.world.update(delta)
self.graphics.update(self.screen, delta)
# Render
self.graphics.draw(self.screen, delta);
self.screen.blit(self.player.speedmsg, (0, 35))
self.screen.blit(self.player.rotmsg, (0, 55))
pygame.display.flip()
def __init__(self, config):
self.config = config
self.game = Game()
self.queue = Queue.Queue(0)
pp("Initiating Irc Thread")
self.control = Control(1, "Controller-1", config, self.queue)
self.control.start()
def start():
setup_logging()
logging.getLogger('pyro').info("started")
db = DataStore(setup=True)
db.apply_active_profile()
settings = db.get_settings()
settings['enabled'] = 0
db.save_settings(settings)
settings = db.get_settings()
logging.getLogger('pyro').debug('starting with settings: %s'% settings)
control = Control()
control.start()
print('starting web')
web.start()
def main():
try:
joystick = init_pygame()
except Exception:
print "Pygame initialization failed - it MIGHT require (for unknown reasons) root"
print "You can try with root, but that won't be safer"
print
raise
control = Control(joystick)
try:
control.loop()
except Exception:
import traceback as tb
print "GOT EXCEPTION"
tb.print_exc()
raise
def main(): queue = Queue.Queue() control = Control(queue, exit_marker) control.start() mac_domain = MacDomain(queue) control.join() #time.sleep(10) print (control.is_alive()) control.close() del control
def post(self):
controls = len(self.handler.control)
while controls > ANONIMOUS:
controls -= 1
del self.handler.control[controls]
columns = self.get_property("columns").split(':')
offset = 0
for i, column in enumerate(columns):
offset += int(column)
if i:
offset += self.horizontal_spacing
control = Control()
self.handler.control.append(control)
control.x = self.x + offset
control.y = self.y + self.height / 2
control.limbus = True
def datagramReceived(self, data, addr):
"""Event handler of receiving a UDP request.
Verify the identity of the client and assign a Control
to it if it is trusted.
"""
logging.debug("received DNS request from %s:%d" % (addr[0], addr[1]))
try:
dnsq = dnslib.DNSRecord.parse(data)
query_data = str(dnsq.q.qname).split('.')
# Give a NXDOMAIN response
self.answer(dnsq, addr)
except KeyError:
logging.info("Corrupt request")
try:
# One control corresponds to one client (with a unique SHA1)
# TODO: get obfs level from query length
main_pw, client_sha1, number, tcp_port, remote_ip, certs_str = \
self.parse_udp_msg(*query_data[:6])
if client_sha1 is None:
raise DuplicateError
if client_sha1 not in self.controls:
client_pub = self.certs[client_sha1][0]
control = Control(self, client_pub, self.certs[client_sha1][1],
remote_ip, tcp_port,
main_pw, number, certs_str)
self.controls[client_sha1] = control
else:
control = self.controls[client_sha1]
control.update(remote_ip, tcp_port, main_pw, number)
control.connect()
except CorruptedReq:
logging.info("Corrupt request")
except KeyError:
logging.error("untrusted client")
except AssertionError:
logging.error("authentication failed or corrupt request")
except ClientAddrChanged:
logging.error("client address or port changed")
def __init__(self):
self.control = Control()
self.register = Registers(32)
self.pcreg = PipelineReg()
self.if_id = PipelineReg()
self.id_exe = PipelineReg()
self.exe_mem = PipelineReg()
self.mem_wb = PipelineReg()
self.alu = Alu()
self.memory = Memory()
self.initializePipeline()
def main():
try:
joystick = init_pygame()
except Exception:
print "Pygame initialization failed - it MIGHT require (for unknown reasons) root"
print "You can try with root, but that won't be safer"
print
raise
pi = pigpio.pi()
pump = Pump(pi, pin=config.PIN_PUMP)
pump.off()
robot = Robot(pi, config.PIN_SERVO1, config.PIN_SERVO2, config.PIN_SERVO3)
robot.disable()
control = Control(joystick, pump, robot)
try:
control.loop()
finally:
pump.off()
def _create_player(self):
self.control = Control()
self.player = Player(self, self.control, self.sprites, DATADIR)
self.sprites.add(self.player)
self.sprites.add(self.player.shadow)
self.sprites.add(self.player.bandage)
self.energy = energy.EnergyView(10, 10, self.world.font)
self.energy.set_model(self.player.energy_model)
self.sprites_in_front.add(self.energy)
self.enemy_energy = energy.EnergyView(440, 10, self.world.font)
self.sprites_in_front.add(self.enemy_energy)
class Bot:
def __init__(self, config):
self.config = config
self.game = Game()
self.queue = Queue.Queue(0)
pp("Initiating Irc Thread")
self.control = Control(1, "Controller-1", config, self.queue)
self.control.start()
def run(self):
pp("Starting Monitoring Loop")
last_start = time.time()
if self.config["polling"]["enabled"]:
polling = time.time()
tick = self.config["polling"]["time"]
poll = {"a":0, "b":0, "up":0, "down":0, "left":0, "right":0, "start":0, "select":0}
while not exitFlag:
if self.config["polling"]["enabled"] and time.time() > (polling + tick):
polling = time.time()
turn = max(poll.iteritems(), key=operator.itemgetter(1))[0]
if poll[turn] != 0:
self.game.push_button(turn)
print turn
poll = dict.fromkeys(poll, 0)
if not self.queue.empty():
job = self.queue.get()
button = job["msg"]
user = job["user"].capitalize()
pbutton(user, button)
if self.config['start_throttle']['enabled'] and button == 'start':
if time.time() - last_start < self.config['start_throttle']['time']:
continue
last_start = time.time()
if self.config["polling"]["enabled"]:
poll[button] += 1
else:
self.game.push_button(button)
def __init__(self, **kwargs):
Control.__init__(self)
if not Form._main_form:
Form._main_form = self
master = Tk()
else:
master = Toplevel()
master.withdraw()
self._ctrl = master
self._frame = Frame(master)
self._frame.pack(fill=BOTH, expand=1)
self._hidden_width = 0
self._hidden_height = 0
self.caption = kwargs.get('caption', 'Untitled')
self.width = kwargs.get('width', 640)
self.height = kwargs.get('height', 480)
self._icon = None
self._ctrl.protocol("WM_DELETE_WINDOW", self._on_close_handler)
Form._active_forms.append(self)
def __init__(self):
config = ConfigParser()
config.read("config.ini")
jid = config.get("general", "jid")
resource = config.get("general", "resource")
password = config.get("general", "password")
self._owners = config.get("general", "owner").split(",")
sleekxmpp.ClientXMPP.__init__(self, jid + "/" + resource, password)
self._rooms = []
self._control = Control(self)
self.add_event_handler("session_start", self.handle_XMPP_connected)
self.add_event_handler("message", self.handle_incoming_message)
for r in config.get("general", "rooms").split(","):
self._rooms.append(room.Room(self, config.get(r, "room"), config.get(r, "modules").split(','), config.get(r, "botname")))
def __init__(self):
self.control = list()
self.can_pivot = True
self.center_pivot = False
self.pivot = Control()
self.pivot.pivot = True
self.line = False
self.is_testing = False
index = 0
while index < ANONIMOUS:
control = Control()
self.control.append(control)
index += 1
def filter(self, function_while_processing=None):
from control import Control
list_modes = self.modes()
current_mode = list_modes[UserMode.current]
nbr_visible = 0
for i, note in enumerate(self.list):
if not note.is_processed: note.process_meta(i)
if (current_mode == UserMode.ALL or current_mode in note.modes) \
and note.is_search_match(Control.get_last_regex()):
note.visible(True)
nbr_visible += 1
else:
note.visible(False)
if function_while_processing and i % 100 == 0:
function_while_processing()
return nbr_visible
