class KeyboardOutputDevice:
device = None
def isConnected(self):
return self.device is not None
def __init__(self, deviceName='LilyFrog'):
print 'Open keyboard output device.'
self.device = UInput(name=deviceName)
def stop(self):
if self.isConnected():
print 'Close keyboard output device.'
self.device.close()
self.device = None
def pressKeyString(self, keystr):
# print 'pressKeyString => %s' % keystr
if not len(keystr): return
scancodes = []
for keychr in keystr:
if keychr in KeyChrToCodeMap:
scancode = KeyChrToCodeMap[keychr]
scancodes.extend(scancode)
else:
raise ValueError('Invalid key string value \'%s\'!' % keychr)
self.pressKeys(scancodes)
def pressKeys(self, scancodes):
if not len(scancodes): return
for scancode in scancodes:
isShiftRequired = isinstance(scancode, list)
if not isShiftRequired:
self.device.write(EV_KEY, scancode, KeyEvent.key_down)
self.device.write(EV_KEY, scancode, KeyEvent.key_up)
else:
self.device.write(EV_KEY, KEY_LEFTSHIFT, KeyEvent.key_down)
self.device.write(EV_KEY, scancode[0], KeyEvent.key_down)
self.device.write(EV_KEY, scancode[0], KeyEvent.key_up)
self.device.write(EV_KEY, KEY_LEFTSHIFT, KeyEvent.key_up)
self.device.syn()
class FakeTouchscreen:
def __init__(self):
if not os.path.exists('/dev/uinput'):
print 'error /dev/uinput does not exist. cannot make device'
self.d = None
return
self.d = UInput(cap, name='Fake Touchscreen', version=0x3)
def down(self, x, y):
if not self.d: return
trackid = int(random.random() * TRACKIDMAX)
self.d.write(EV_ABS, ABS_MT_TRACKING_ID, trackid)
self.d.write(EV_ABS, ABS_MT_POSITION_X, x)
self.d.write(EV_ABS, ABS_MT_POSITION_Y, y)
self.d.write(EV_ABS, ABS_X, x)
self.d.write(EV_ABS, ABS_Y, y)
self.d.write(EV_KEY, BTN_TOUCH, 1)
self.d.write(EV_ABS, ABS_PRESSURE, 255)
self.d.write(EV_ABS, ABS_MT_PRESSURE, 255)
self.d.syn()
def up(self):
if not self.d: return
self.d.write(EV_ABS, ABS_MT_TRACKING_ID, -1)
self.d.write(EV_KEY, BTN_TOUCH, 0)
self.d.write(EV_ABS, ABS_PRESSURE, 0)
self.d.write(EV_ABS, ABS_MT_PRESSURE, 0)
self.d.syn()
def touch(self, x, y):
if not self.d: return
self.down(x, y)
time.sleep(TMIN)
self.up()
class udev_evdev_emit:
def __init__(self):
print('initializing udev_evdev_emit')
#several of these cap mappings are fake and just intended to ensure that Godot sees us as a valid controller
#actual mappings: volup = BTN_0; voldown = BTN_1; app button = BTN_2; daydream button = BTN_3; touchpad button = BTN_4
cap = { e.EV_KEY : [e.BTN_A, e.BTN_THUMBL, e.BTN_TRIGGER, e.BTN_0, e.BTN_1, e.BTN_2, e.BTN_3, e.BTN_4],
e.EV_ABS : [(e.ABS_X, AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)),
(e.ABS_Y, AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)),
(e.ABS_HAT0X, AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)),
(e.ABS_GAS, AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0)),
(e.ABS_RUDDER, AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=0))]}
self.ui = UInput(cap, name="daydream controller", version=0x3)
def pressed_to_int(self, data):
if data == "pressed":
return 1
else:
return 0
def emit(self, data):
self.ui.write(e.EV_KEY, e.BTN_0, self.pressed_to_int(data['buttons']['volup']))
self.ui.write(e.EV_KEY, e.BTN_1, self.pressed_to_int(data['buttons']['voldown']))
self.ui.write(e.EV_KEY, e.BTN_2, self.pressed_to_int(data['buttons']['app']))
self.ui.write(e.EV_KEY, e.BTN_3, self.pressed_to_int(data['buttons']['daydream']))
self.ui.write(e.EV_KEY, e.BTN_4, self.pressed_to_int(data['buttons']['touchpad']))
self.ui.write(e.EV_ABS, e.ABS_X, data['touchpad']['x'])
self.ui.write(e.EV_ABS, e.ABS_Y, data['touchpad']['y'])
self.ui.syn()
def write_release(ui: UInput, *codes: int) -> None:
"""
Inject specified key codes into UInput with key_up.
"""
for code in codes:
ui.write(ecodes.EV_KEY, code, KeyEvent.key_up)
ui.syn()
class Mouse:
def __init__(self, mul=(20, 20)):
cap = {
e.EV_REL: (e.REL_X, e.REL_Y),
e.EV_KEY: (e.BTN_LEFT, e.BTN_RIGHT),
}
self.ui = UInput(cap)
# , name='Microsoft X-Box pad v1 (US)', product=0x0202, vendor=0x045e)
self.prev = {}
self.mul = mul
def callback(self, data):
euler = data["eulerData"]
prev = self.prev.get("eulerData", (0, 0, 0))
self.ui.write(e.EV_REL, e.REL_X, int(
(euler[0] - prev[0]) * self.mul[0]))
self.ui.write(e.EV_REL, e.REL_Y, int(
(euler[1] - prev[1]) * self.mul[1]))
self.ui.write(e.EV_KEY, e.BTN_LEFT, data["trigger"] == 2)
self.ui.write(e.EV_KEY, e.BTN_RIGHT, data["trigger"] == 4)
self.prev = data
self.ui.syn()
def write_tap(ui: UInput, code: int) -> None:
"""
Write press and release.
"""
write_press(ui, code)
write_release(ui, code)
ui.syn()
def pointer_handler():
global ui2
global xFactor
global yFactor
xFactor = yFactor = 0
#capture current mouse coordinates. TODO If user uses a real mouse/touchpad input could confuses
x = 0
y = 0
try:
ui2 = UInput(cap, name='virtual-mouse', version=0x3)
#it's unknown but needs 2 times to work :S
ui2 = UInput(cap, name='virtual-mouse', version=0x3)
except:
logger.warning("no uinput was defined (MOUSE)")
#just to avoid init effect of cursor, joystick.py puts the cursor
#ui2.write(e.EV_ABS, e.ABS_X, 0)
#ui2.write(e.EV_ABS, e.ABS_Y, HEIGHT)
#ui2.syn()
while True:
if x+xFactor<WIDTH and x+xFactor >=0:
x=x+xFactor
if y+yFactor<HEIGHT and y+yFactor >=0:
y=y+yFactor
ui2.write(e.EV_ABS, e.ABS_X, x)
ui2.write(e.EV_ABS, e.ABS_Y, HEIGHT-y)
ui2.syn()
#logger.debug("x: %s y: %s, xF: %s yF: %s" % (x,y,xFactor,yFactor))
time.sleep(0.01)
def write_press(ui: UInput, *codes: int) -> None:
"""
Inject specified key codes into UInput with key_down.
"""
for code in codes:
ui.write(ecodes.EV_KEY, code, KeyEvent.key_down)
ui.syn()
async def handle_events(input: InputDevice, output: UInput, remappings,
modifier_groups):
active_group = {}
try:
async for event in input.async_read_loop():
if not active_group:
active_mappings = remappings
else:
active_mappings = modifier_groups[active_group['name']]
if (event.code == active_group.get('code') or
(event.code in active_mappings
and 'modifier_group' in active_mappings.get(event.code)[0])):
if event.value == 1:
active_group['name'] = \
active_mappings[event.code][0]['modifier_group']
active_group['code'] = event.code
elif event.value == 0:
active_group = {}
else:
if event.code in active_mappings:
remap_event(output, event, active_mappings[event.code])
else:
output.write_event(event)
output.syn()
finally:
del registered_devices[input.path]
print('Unregistered: %s, %s, %s' %
(input.name, input.path, input.phys),
flush=True)
input.close()
def read_data(ep_in):
"""
Read the transmitted android keycodes from the input endpoint and trigger the corresponding key presses in linux.
:param ep_in: input endpoint of the accessory device.
"""
ui = UInput()
while True:
try:
data = ep_in.read(3)
keycode = data[1] * 0xFF + data[2]
evdev_keycode = get_evdev_keycode(keycode)
if data[0] == 0:
print("Key down {}".format(keycode))
if evdev_keycode != -1:
ui.write(ecodes.EV_KEY, evdev_keycode, 1)
ui.syn()
elif data[0] == 1:
print("Key up {}".format(keycode))
if evdev_keycode != -1:
ui.write(ecodes.EV_KEY, evdev_keycode, 0)
ui.syn()
except usb.core.USBError as e:
# ignore exceptions caused by read timeout
if e.errno == 110:
pass
else:
print("failed to read input")
print(e)
break
class KeyboardOutputDevice:
device = None
def isConnected(self):
return self.device is not None
def __init__(self, deviceName='LilyFrog'):
print 'Open keyboard output device.'
self.device = UInput(name=deviceName)
def stop(self):
if self.isConnected():
print 'Close keyboard output device.'
self.device.close()
self.device = None
def pressKeyString(self, keystr):
# print 'pressKeyString => %s' % keystr
if not len(keystr): return
scancodes = []
for keychr in keystr:
if keychr in KeyChrToCodeMap:
scancode = KeyChrToCodeMap[keychr]
scancodes.extend(scancode)
else: raise ValueError('Invalid key string value \'%s\'!' % keychr)
self.pressKeys(scancodes)
def pressKeys(self, scancodes):
if not len(scancodes): return
for scancode in scancodes:
isShiftRequired = isinstance(scancode, list)
if not isShiftRequired:
self.device.write(EV_KEY, scancode, KeyEvent.key_down)
self.device.write(EV_KEY, scancode, KeyEvent.key_up)
else:
self.device.write(EV_KEY, KEY_LEFTSHIFT, KeyEvent.key_down)
self.device.write(EV_KEY, scancode[0], KeyEvent.key_down)
self.device.write(EV_KEY, scancode[0], KeyEvent.key_up)
self.device.write(EV_KEY, KEY_LEFTSHIFT, KeyEvent.key_up)
self.device.syn()
class Input:
def __init__(self):
self._ui = UInput()
def inject_event(self, keycode, typ):
print "Injecting keycode: %s\n" % keycode
self._ui.write(ecodes.EV_KEY, keycode, typ)
self._ui.syn()
def execute(self):
print "Executing " + e.KEY[self.macroKey] + " macro."
ui = UInput()
for i in range(len(self.keySequence)):
ui.write(e.EV_KEY, self.keySequence[i], self.keyState[i]);
ui.syn()
ui.close()
class Input:
def __init__(self):
self._ui = UInput()
def inject_event(self, keycode, typ):
print "Injecting keycode: %s\n" % keycode
self._ui.write(ecodes.EV_KEY, keycode, typ)
self._ui.syn()
class Keyboard:
def __init__(self):
self.uinput = UInput()
def close(self):
self.uinput.close()
def send_key(self, js_keycode, state):
self.uinput.write(ecodes.EV_KEY, js_map[js_keycode], 1 if state else 0)
self.uinput.syn()
class DeviceWriter:
def __init__(self, scale):
self.scale = scale
# most values were taken from running
# InputDevice('/dev/input/event$N').capabilities()
vendor = 1133
product = 0
version = 273
bustype = 3
caps = {
e.EV_KEY: [e.BTN_0, e.BTN_1],
e.EV_REL: [e.REL_X, e.REL_Y, e.REL_Z, e.REL_RX, e.REL_RY, e.REL_RZ],
}
device_name = 'Virtual SpaceNav'
self.state = True
self.ui = UInput(caps, vendor=vendor, product=product,
version=version, bustype=bustype, name=device_name)
def make_event(self, data):
if not self.state:
return
for v in (data.linear, data.angular):
# We don't want to write zeroes because the real spacenav never does,
# instead write a small value inside Earth's gutter to prevent drift.
if v.x == 0:
v.x = 1.0 / self.scale
if v.y == 0:
v.y = 1.0 / self.scale
if v.z == 0:
v.z = 1.0 / self.scale
# write some event to self.ui based off of the twist data
_time = time.time()
stime = int(_time)
utime = int((float(_time) - stime) * 10 ** 6)
x = InputEvent(stime, utime, e.EV_REL, e.REL_X, -self.translate(data.linear.y))
y = InputEvent(stime, utime, e.EV_REL, e.REL_Y, -self.translate(data.linear.x))
z = InputEvent(stime, utime, e.EV_REL, e.REL_Z, -self.translate(data.linear.z))
ax = InputEvent(stime, utime, e.EV_REL, e.REL_RX, -self.translate(data.angular.y))
ay = InputEvent(stime, utime, e.EV_REL, e.REL_RY, -self.translate(data.angular.x))
az = InputEvent(stime, utime, e.EV_REL, e.REL_RZ, -self.translate(data.angular.z))
# write all events
self.ui.write_event(x)
self.ui.write_event(y)
self.ui.write_event(z)
self.ui.write_event(ax)
self.ui.write_event(ay)
self.ui.write_event(az)
# syn to alert input subsystem
self.ui.syn()
def translate(self, n):
return int(n * self.scale) # TODO find the translation...
def set_state(self, msg):
self.state = msg.state == ApplicationState.VISIBLE
class Keyboard(object):
def __init__(self):
self.ui = UInput()
def press(self, key):
self.ui.write(e.EV_KEY, key, 1)
self.ui.write(e.EV_KEY, key, 0)
self.ui.syn()
def __del__(self):
self.ui.close()
class vjoy(object):
""" send virtual joystick data to linux event system """
def __init__(self, can_id):
self.can_id = can_id
axis_cap = AbsInfo(-32700, 32700, 0, 0, 0, 0)
self._ev = UInput(
name='vjoy',
events={
ecodes.EV_ABS: [(ecodes.ABS_X, axis_cap),
(ecodes.ABS_Y, axis_cap),
(ecodes.ABS_Z, axis_cap)],
ecodes.EV_KEY:
[ecodes.BTN_TRIGGER, ecodes.BTN_TOP, ecodes.BTN_TOP2]
})
def __enter__(self):
return self
def __exit__(self, type, value, tb):
self._ev.close()
def signal(self, x, y, z, b0, b1, b2):
self._ev.write(ecodes.EV_ABS, ecodes.ABS_X, x)
self._ev.write(ecodes.EV_ABS, ecodes.ABS_Y, y)
self._ev.write(ecodes.EV_ABS, ecodes.ABS_Z, z)
self._ev.write(ecodes.EV_KEY, ecodes.BTN_TRIGGER, b0)
self._ev.write(ecodes.EV_KEY, ecodes.BTN_TOP, b1)
self._ev.write(ecodes.EV_KEY, ecodes.BTN_TOP2, b2)
self._ev.syn()
def process_can_data(self, msg):
#print(msg)
if (msg.mid == (0x180 + self.can_id)):
# convert axis data to signed
abs_x = (msg[0] - 256) if (msg[0] > 127) else msg[0]
abs_y = (msg[1] - 256) if (msg[1] > 127) else msg[1]
abs_z = (msg[2] - 256) if (msg[2] > 127) else msg[2]
# flip y
abs_y = -abs_y
# rescale from -100..100 to -32700..32700:
abs_x = abs_x * 327
abs_y = abs_y * 327
abs_z = abs_z * 327
# fetch buttons
b0 = 1 if (msg[5] & 32) else 0
b1 = 1 if (msg[5] & 1) else 0
b2 = 1 if (msg[5] & 8) else 0
# debug data
print(" X: " + str(abs_x) + " Y: " + str(abs_y) + " Z: " +
str(abs_z) + " B0: " + str(b0) + " B1: " + str(b1) +
" B2: " + str(b2))
# send data
self.signal(abs_x, abs_y, abs_z, b0, b1, b2)
async def translate_input(device: InputDevice, ui: UInput,
disabled: Sequence[int],
mapping: Mapping[int, int]) -> None:
"""Read inputs from device, filter out disabled, apply mapping, and write to ui."""
async for ev in device.async_read_loop():
if ev.type == e.EV_KEY:
if ev.code in disabled:
continue
if ev.code in mapping:
ev.code = mapping[ev.code]
ui.write_event(ev)
ui.syn()
def trigger_display_switch (self):
''' Trigger super+p twice '''
ui = UInput()
ui.write(e.EV_KEY, e.KEY_LEFTMETA, 1)
ui.syn()
time.sleep(1)
ui.write(e.EV_KEY, e.KEY_P, 1)
ui.write(e.EV_KEY, e.KEY_P, 0)
ui.write(e.EV_KEY, e.KEY_P, 1)
ui.write(e.EV_KEY, e.KEY_P, 0)
ui.write(e.EV_KEY, e.KEY_LEFTMETA, 0)
ui.syn()
ui.close()
class Device(object):
def __init__(self):
self.ui = UInput()
def send(self, data):
for d in data:
self.ui.write(e.EV_KEY, keydict[d], 1)
self.ui.syn()
self.ui.write(e.EV_KEY, keydict[d], 0)
self.ui.syn()
def close(self):
self.ui.close()
class TestListener(Leap.Listener):
hand_id = 0
spread_win = False
curtime = 0
ui = None
def on_init(self, controller):
self.ui = UInput()
print "Initialized"
def on_connect(self, controller):
print "Connected"
def on_disconnect(self, controller):
print "Disconnected"
def on_exit(self, controller):
print "Exited"
def on_frame(self, controller):
frame = controller.frame()
if not frame.hands.is_empty:
hand = frame.hands[0]
fingers = hand.fingers
if not fingers.is_empty:
if hand.id == self.hand_id and not self.spread_win and len(fingers) >= 4 and (frame.timestamp - self.curtime) <= 1000000:
#print "(Spread) Old timestamp is %d, current is %d (%d)" % (self.curtime, frame.timestamp, (frame.timestamp - self.curtime))
self.spread_windows()
#print "Spread windows"
self.spread_win = True
self.curtime = frame.timestamp
#print "Hand open timestamp is %d" % self.curtime
else:
if hand.id == self.hand_id and self.spread_win and (frame.timestamp - self.curtime) <= 1000000:
#print "(Unspread) Old timestamp is %d, current is %d (%d)" % (self.curtime, frame.timestamp, (frame.timestamp - self.curtime))
self.spread_windows()
#print "Unspread windows"
self.spread_win = False
else:
self.hand_id = hand.id
self.curtime = frame.timestamp
#print "Fist timestamp is %d" % self.curtime
def spread_windows(self):
self.ui.write(e.EV_KEY, e.KEY_LEFTMETA, 1) # <super> key down
self.ui.write(e.EV_KEY, e.KEY_W, 1) # 'W' key down
self.ui.write(e.EV_KEY, e.KEY_W, 0) # 'W' key up
self.ui.write(e.EV_KEY, e.KEY_LEFTMETA, 0) # <super> key up
self.ui.syn()
class EvdevWriter(Writer):
def __init__(self):
self.event_to_ecode_translator = EventToEcodeTranslator()
self.ui = UInput()
def write_iterable(self, events_iterable):
for event in events_iterable:
if isinstance(event, list):
self.write_combo(event)
else:
self.__buffer_event(event)
self.ui.syn()
def write_event(self, event):
self.__buffer_event(event)
self.ui.syn()
def __buffer_event(self, event):
ecode = self.event_to_ecode_translator.translate(event)
self.ui.write(ecodes.EV_KEY, ecode, 1)
self.ui.write(ecodes.EV_KEY, ecode, 0)
def write_combo(self, events):
for event in events:
ecode = self.event_to_ecode_translator.translate(event)
self.ui.write(ecodes.EV_KEY, ecode, 1)
self.ui.syn()
for event in reversed(events):
ecode = self.event_to_ecode_translator.translate(event)
self.ui.write(ecodes.EV_KEY, ecode, 0)
self.ui.syn()
def close(self):
self.ui.close()
class PointerWatcher(Thread):
def __init__(self):
Thread.__init__(self)
self.ui = UInput()
self.devices = []
self.running = True
self.device_search()
def device_search(self):
devices_list = []
files = []
for (dirpath, dirnames, filenames) in walk(INPUTDIR):
files.extend(filenames)
break
for f in files:
try:
dev = InputDevice(path.join(INPUTDIR, f))
if dev.name == "W WirelessUSB":
devices_list.append(dev)
except (IOError, OSError, TypeError):
pass
self.devices = {dev.fd: dev for dev in devices_list}
def run(self):
c = 0
if len(self.devices) > 0:
while self.running:
r, w, x = select(self.devices, [], [])
for fd in r:
try:
for event in self.devices[fd].read():
if event.code == ecodes.KEY_UP and event.value == 1:
self.ui.write(ecodes.EV_KEY, ecodes.KEY_DOWN, 1)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_DOWN, 0)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_LEFT, 1)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_LEFT, 0)
self.ui.syn()
c += 1
elif event.code == ecodes.KEY_DOWN and event.value == 1:
self.ui.write(ecodes.EV_KEY, ecodes.KEY_UP, 1)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_UP, 0)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_RIGHT, 1)
self.ui.write(ecodes.EV_KEY, ecodes.KEY_RIGHT, 0)
self.ui.syn()
c -= 1
except IOError:
self.running = False
break
self.ui.close()
def pointer_handler():
global ui2
global xsession
global factor
xsession = False
ui2 = None
factor = 5
global xFactor
global yFactor
xFactor = yFactor = 0
cap = {
e.EV_KEY : [e.BTN_LEFT, e.BTN_RIGHT, e.BTN_MIDDLE],
e.EV_ABS : [
(e.ABS_X, AbsInfo(value=0, min=0, max=255,fuzz=0, flat=0, resolution=0)) ,
(e.ABS_Y, AbsInfo(0, 0, 255, 0, 0, 0)) ,
(e.ABS_MT_POSITION_X, (0, 128, 255, 0))
]
}
#capture current mouse coordinates. TODO If user uses a real mouse/touchpad input could confuses
x = 20
y = 20
try:
ui2 = UInput(cap, name='virtual-mouse', version=0x3)
#it's unknown but needs 2 times to work :S
ui2 = UInput(cap, name='virtual-mouse', version=0x3)
except:
logger.warning("no uinput was defined (for MOUSE virtual device)")
pass
#just to avoid init effect of cursor, joystick.py puts the cursor
#ui2.write(e.EV_ABS, e.ABS_X, 0)
#ui2.write(e.EV_ABS, e.ABS_Y, HEIGHT)
#ui2.syn()
while True:
#logger.debug("%s %s" % (xFactor,yFactor))
if x+xFactor<WIDTH and x+xFactor >=0:
x=x+xFactor
if y+yFactor<HEIGHT and y+yFactor >=0:
y=y+yFactor
if ui2:
ui2.write(e.EV_ABS, e.ABS_X, x)
ui2.write(e.EV_ABS, e.ABS_Y, HEIGHT-y)
ui2.syn()
logger.debug("x: %s y: %s, xF: %s yF: %s" % (x,y,xFactor,yFactor))
time.sleep(0.01)
def call(k, conf=False):
if conf:
keys = defns._k[k]
else:
keys = defns.default[k]
try:
ui = UInput()
for key in keys:
ui.write(defns.k["EV_KEY"], defns.k["KEY_" + key.upper()], 1)
defns._k[k].reverse()
for key in keys:
ui.write(defns.k["EV_KEY"], defns.k["KEY_" + key.upper()], 0)
ui.syn()
ui.close()
except err:
print "Not enough permissions. Are you root?"
def call(k, conf=False):
if conf:
keys = defns._k[k]
else:
keys = defns.default[k]
try:
ui = UInput()
for key in keys:
ui.write(defns.k["EV_KEY"], defns.k["KEY_" + key.upper()], 1)
defns._k[k].reverse()
for key in keys:
ui.write(defns.k["EV_KEY"], defns.k["KEY_" + key.upper()], 0)
ui.syn()
ui.close()
except err:
print "Not enough permissions. Are you root?"
class GameportJoystick:
caps = {
e.EV_KEY: [e.BTN_TRIGGER, e.BTN_THUMB],
e.EV_ABS: [(e.ABS_X,
AbsInfo(value=0,
min=0,
max=1024,
fuzz=0,
flat=0,
resolution=0)),
(e.ABS_Y,
AbsInfo(value=0,
min=0,
max=1024,
fuzz=0,
flat=0,
resolution=0)),
(e.ABS_HAT0X,
AbsInfo(value=0,
min=-1,
max=1,
fuzz=0,
flat=0,
resolution=0)),
(e.ABS_HAT0Y,
AbsInfo(value=0,
min=-1,
max=1,
fuzz=0,
flat=0,
resolution=0))],
}
def __init__(self, name="Gameport Joystick"):
self.name = name
self.ui = UInput(events=GameportJoystick.caps, name=name)
def write(self, type, key, value):
self.ui.write(type, key, value)
self.ui.syn()
def pressAndHoldTriggerButton(self):
toggle = 0
for i in range(1000):
self.ui.write(e.EV_KEY, e.BTN_TRIGGER, toggle)
self.ui.syn()
toggle = 1 - toggle
class joystickMCP:
def __init__(self, ppins, keys, name):
self._name = name
self._pins = {}
self._prevStatus = {}
self.ui=""
self._mcp= MCP23017()
self.active=True
for x in range(len(ppins)):
self._pins[ppins[x]] = keys[x]
self._prevStatus[ppins[x]]=True
os.system("sudo modprobe uinput")
self.ui = UInput({e.EV_KEY:self._pins.values()},name="retrogame",bustype=e.BUS_USB)
self.setup()
self.loop()
def setup(self):
#GPIO.setmode(GPIO.BOARD) # Numbers GPIOs by physical location
#self._mcp = MCP23017()
#self._mcp.setup(8,1)
#self._mcp.pullup(8,True)
for pin in self._pins.keys():
self._mcp.setup(pin, GPIO.IN)#tutti i pin in input
self._mcp.pullup(pin,True)#lì setto a 3.3v
def checkKeyPress(self, ev=None):
if self._mcp.input(ev) != self._prevStatus[ev]:
if self._mcp.input(ev) == GPIO.LOW:
# print('Down: Push!')
self.ui.write(e.EV_KEY, self._pins[ev], 1)
else:
# print('Up: Push!')
self.ui.write(e.EV_KEY, self._pins[ev], 0)
self._prevStatus[ev] = self._mcp.input(ev)
self.ui.syn()
def loop(self):
while self.active:
for pin in self._pins.keys():
self.checkKeyPress(pin)
def destroy(self):
self.active=False
class App(object):
_logger = logging.getLogger('evdev_mt_a')
def __init__(self, hardware_version):
logging.basicConfig(level=LOGGING_LEVEL, **LOGGING_FORMATS)
self.electrodes = electrodes_by_hardware_version(hardware_version)
self.electrodes.init()
ev_multitouch = {
ecodes.EV_ABS: [
(ecodes.ABS_MT_POSITION_X, (0, 0,
self.electrodes.grid_sizes[0])),
(ecodes.ABS_MT_POSITION_Y, (0, 0,
self.electrodes.grid_sizes[1])),
]
}
self.ui_multitouch = UInput(ev_multitouch,
name='capacitive_electrodes',
version=0x3)
def __loop__(self):
self._logger.info('loop')
while True:
self.electrodes.update()
if self.electrodes.get_newly_touched(
) or self.electrodes.get_newly_released():
touched = self.electrodes.get_touched()
for i in touched:
self.ui_multitouch.write(ecodes.EV_ABS,
ecodes.ABS_MT_POSITION_X,
i.grid_indexes[0])
self.ui_multitouch.write(ecodes.EV_ABS,
ecodes.ABS_MT_POSITION_Y,
i.grid_indexes[1])
self.ui_multitouch.write(ecodes.EV_SYN,
ecodes.SYN_MT_REPORT, 0)
if not touched:
self.ui_multitouch.write(ecodes.EV_SYN,
ecodes.SYN_MT_REPORT, 0)
self._logger.info('send multitouch_a[%d] report', len(touched))
self.ui_multitouch.syn()
time.sleep(0.01)
def __exit__(self):
self.ui_multitouch.close()
def writeWord(word):
listOfLetters = list(word)
ui = UInput()
for letter in listOfLetters:
if letter.isupper():
letter = letter.lower()
case = 'upper'
else:
case = 'lower'
writeUiCase(letter, ui, case)
ui.syn()
ui.close()
def call(vals):
"""
The call function receives a list of keys to be pressed and loops over
them switching them to pressed state, then loops over the reversed list
unpressing them. That way it can process key combinations.
"""
try:
ui = UInput()
for k in vals:
ui.write(ecodes["EV_KEY"], ecodes["KEY_" + keys[k]], 1)
vals.reverse()
for k in vals:
ui.write(ecodes["EV_KEY"], ecodes["KEY_" + keys[k]], 0)
ui.syn()
ui.close()
except err:
print "Not enough permissions. Are you root?"
def call(vals):
'''
The call function receives a list of keys to be pressed and loops over
them switching them to pressed state, then loops over the reversed list
unpressing them. That way it can process key combinations.
'''
try:
ui = UInput()
for k in vals:
ui.write(ecodes["EV_KEY"], ecodes["KEY_" + keys[k]], 1)
vals.reverse()
for k in vals:
ui.write(ecodes["EV_KEY"], ecodes["KEY_" + keys[k]], 0)
ui.syn()
ui.close()
except err:
print "Not enough permissions. Are you root?"
class ModifyKeyEvent(object):
key_up = 0x0
key_down = 0x1
key_hold = 0x2
def __init__(self):
self.holding_key = set()
self.u_input = UInput()
# self.test()
def test(self):
self.inject_key('KEY_A')
self.inject_key('KEY_B')
self.inject_key('KEY_RIGHT')
def is_holding(self, keycodes):
for k in keycodes:
if k not in self.holding_key:
return False
return True
def handle_key(self, keycode, keystate):
print 'handle_key', self.holding_key, keycode
if keystate == self.key_hold:
self.holding_key.add(keycode)
elif keystate == self.key_up:
if keycode in self.holding_key:
self.holding_key.remove(keycode)
elif keystate == self.key_down:
self.keydown_event(keycode)
def keydown_event(self, keycode):
if self.is_holding(need_holdings):
self.custom_direction_key(keycode)
def custom_direction_key(self, keycode):
self.inject_key(modify_map.get(keycode, ''))
def inject_key(self, keycode):
if keycode:
code = getattr(ecodes, keycode)
self.u_input.write(ecodes.EV_KEY, code, self.key_down)
self.u_input.write(ecodes.EV_KEY, code, self.key_up)
self.u_input.syn()
print 'inject_key', self.holding_key, keycode
class KeyboardSimuThread(Thread):
def __init__(self, thNo):
Thread.__init__(self)
self.thNo = thNo
self.ui = UInput()
self.keep_running = True
self.waitingOnKey = True
self.key = ecodes.KEY_Q
#
def run(self):
print "KeyboardSimuThread Started!"
while self.keep_running:
if self.waitingOnKey == False:
#print "Buzzer " + str(self.thNo)
#self.ui.write_event(InputEvent(1, 200, ecodes.EV_KEY, self.key, 1)) does not work in Blender
self.ui.write(ecodes.EV_KEY, self.key, 1) #Press key down
self.ui.syn()
time.sleep(
0.3
) #Hold it down for 300ms so that Blender is able to read it
self.ui.write(ecodes.EV_KEY, self.key, 0) #Relase
self.ui.syn()
self.waitingOnKey = True #Now we can send a new key
#If another key of this buzzer had been pressed it will not be taken in concideration
# before waitingOnKey is set to True. So 300ms after last key was pressed
time.sleep(0.1)
self.ui.close()
print "KeyboardSimuThread terminated!"
def simulateKey(self, key):
#If the thread is waiting for a key we send it, otherwise we ignore it because the thread is already managing one key
if self.waitingOnKey == True:
self.key = key
self.waitingOnKey = False
# Each thread runs until explicitly signaled to stop
def signal(self):
print "KeyboardSimuThread will terminate!"
self.keep_running = False
class VirtualJoystick(object):
def __init__(self, top_rpm, top_wheel):
e = ecodes
cap = {
e.EV_ABS: [ (e.ABS_X,
AbsInfo(value=top_wheel, min=0, max=top_wheel*2, fuzz=0, flat=15, resolution=0)),
(e.ABS_Y,
AbsInfo(value=128, min=0, max=255, fuzz=0, flat=15, resolution=0)),
(e.ABS_Z,
AbsInfo(value=top_rpm, min=0, max=top_rpm*2, fuzz=0, flat=15, resolution=0)),
],
e.EV_KEY: [e.BTN_JOYSTICK,
e.BTN_THUMB,
e.BTN_THUMB2,
e.BTN_TOP,
e.BTN_TOP2,
e.BTN_PINKIE,
e.BTN_BASE,
e.BTN_BASE2,
e.BTN_BASE3,
e.BTN_BASE4,
e.BTN_BASE5,
e.BTN_BASE6],
}
self.joystick = UInput(cap, name='gpad-bike')
def __del__(self):
self.joystick.close()
def set_wheel(self, value):
self.set_axis(ecodes.ABS_X, value)
def set_rpm(self, value):
self.set_axis(ecodes.ABS_Z, value)
def set_axis(self, axis, value):
#value = 255
self.joystick.write(ecodes.EV_ABS, axis, value)
self.joystick.syn()
def write(self, etype, code, value):
self.joystick.write(etype, code, value)
class joystick:
def __init__(self,ppins,keys,name):
self._name=name
self._pins={}
self.ui = ""
for x in range(len(ppins)):
self._pins[ppins[x]]=keys[x]
self.setup()
os.system("sudo modprobe uinput")
self.ui = UInput(name="fex",vendor=9999,product=8888)
self.addEvents()
def setup(self):
GPIO.setmode(GPIO.BOARD) # Numbers GPIOs by physical location
for pin in self._pins.keys():
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # Set BtnPin's mode is input, and pull up to high level(3.3V)
def keyPress(self,ev=None):
#ui.write(e.EV_KEY, key, state)
#ui.syn()
if GPIO.input(ev)==GPIO.LOW:
#print('%s: Down: %s - %s' % (self._name,ev,self._pins[ev]))
self.ui.write(e.EV_KEY,self._pins[ev],1)
else:
#print('%s: Up: %s - %s' % (self._name,ev,self._pins[ev]))
self.ui.write(e.EV_KEY,self._pins[ev],0)
self.ui.syn()
def addEvents(self):
for pin in self._pins.keys():
GPIO.add_event_detect(pin, GPIO.BOTH, callback=self.keyPress,bouncetime=1) # wait for falling
# GPIO.add_event_detect(pin, GPIO.RISING, callback=keyUp,bouncetime=250) # wait for falling
def destroy(self):
GPIO.cleanup() # Release resource
class Player(Thread):
def __init__(self, n, m):
Thread.__init__(self)
self.n = n
self.stop = False
self.sleep = False
self.ui = UInput()
self.m = m
def sendEvent(self):
i = 0
while i < len(history):
now = history[i]
if i < len(history)-1: after = history[i+1]
if self.stop: break
if not self.sleep:
m.move( now.get("mouse")[0], now.get("mouse")[1])
if now.get("event").type == ecodes.EV_KEY:
self.ui.write(ecodes.EV_KEY, now.get("event").code, now.get("event").value)
self.ui.syn()
if i < len(history):
time.sleep(float(after.get("event").sec - now.get("event").sec)+float(after.get("event").usec - now.get("event").usec)/1000000)
i += 1
# sobrescrevendo o metodo run()
def run(self):
if self.n == 0:
while not self.stop:
self.sendEvent()
elif self.n > 0:
for i in range(self.n):
self.sendEvent()
self.stop = True
print "\rEnd "
ui.close()
def Stop(self):
self.stop = True
def Sleep(self):
self.sleep = not self.sleep
async def generate_kb_input(keys=None):
if not keys:
raise ValueError("Can't iterate over nothing")
ui = UInput()
for k in keys:
if isinstance(k, str) and ',' in k:
for state in [1, 0]:
for kk in k.split(','):
kk = e.__getattribute__('KEY_' + kk)
print("SENDING KEY", kk)
ui.write(e.EV_KEY, kk, state)
ui.syn()
else:
if isinstance(k, str):
k = e.__getattribute__('KEY_' + k)
print("SENDING KEY", k)
ui.write(e.EV_KEY, k, 1)
ui.write(e.EV_KEY, k, 0)
ui.syn()
ui.close()
class Keyboard:
def __init__(self):
self.ui = UInput()
def press_key(self, list_ecodes):
"""
Write events to keyboard based on a list of ecodes
:param list_ecodes
"""
# key down event (press)
for code in list_ecodes:
self.ui.write(ecodes.EV_KEY, code, 1)
# key up event (release)
for code in list_ecodes:
self.ui.write(ecodes.EV_KEY, code, 0)
# after all keys are writen sync
self.ui.syn()
class KbdOutput(object):
def __init__(self):
self.ui = UInput()
logging.info('Creating uinput device: ' + to_str(self.ui))
def __enter__(self):
return self
def press(self, key):
self.ui.write(e.EV_KEY, keycode(key), etype.KEY_PRESS)
def release(self, key):
self.ui.write(e.EV_KEY, keycode(key), etype.KEY_RELEASE)
def sync(self):
self.ui.syn()
def close(self):
self.ui.close()
def __exit__(self, exc_type, exc_value, traceback):
logging.info('Closing uinput device: ' + to_str(self.ui))
self.close()
class evdev_mouse(cGenericMouseOut):
pos_x = 0
pos_y = 0
def __init__(self):
logger.info('Plugin evdev_mouse initializing...')
super().__init__()
width=1920
height=1080
cap = {
ecodes.EV_KEY: [
ecodes.BTN_LEFT,
ecodes.BTN_MIDDLE,
ecodes.BTN_RIGHT,
],
ecodes.EV_REL: [
ecodes.REL_WHEEL,
ecodes.REL_HWHEEL,
],
ecodes.EV_ABS: [
(ecodes.ABS_X, AbsInfo(value=0, min=0, max=width, fuzz=0, flat=0, resolution=0)),
(ecodes.ABS_Y, AbsInfo(value=0, min=0, max=height, fuzz=0, flat=0, resolution=0)),
(ecodes.ABS_PRESSURE, AbsInfo(value=0, min=0, max=70, fuzz=0, flat=0, resolution=0)),
],
}
self.__mouse = UInput(cap, name='xHID evdev pointer', version=0x1, vendor=0x1, product=0x1, props=[])
self.__onscreen = False
def event_handler(self, props):
#logger.debug('event_handler called {}'.format(pformat(props)))
if (props[field.EVENT] == event.SCREEN_IN):
self.__onscreen = True
elif (props[field.EVENT] == event.SCREEN_OUT):
self.__onscreen = False
else:
if (self.__onscreen):
if (props[field.EVENT] == event.MOUSE_MOVE):
x = props[field.POSITION_X]
y = props[field.POSITION_Y]
self.__mouse.write(ecodes.EV_ABS, ecodes.ABS_X, x)
self.__mouse.write(ecodes.EV_ABS, ecodes.ABS_Y, y)
self.__mouse.syn()
elif (props[field.EVENT] == event.MOUSE_BUTTON_UP or props[field.EVENT] == event.MOUSE_BUTTON_DOWN):
up_down = int(props[field.EVENT] == event.MOUSE_BUTTON_DOWN)
btn = btn_map.get(props[field.BUTTON_ID], 0)
if btn > 0:
self.__mouse.write(ecodes.EV_KEY, btn, up_down)
self.__mouse.syn()
elif (props[field.EVENT] == event.MOUSE_WHEEL):
x = props[field.RELATIVE_X]
y = props[field.RELATIVE_Y]
self.__mouse.write(ecodes.EV_REL, ecodes.REL_WHEEL, y)
self.__mouse.write(ecodes.EV_REL, ecodes.REL_HWHEEL, x)
self.__mouse.syn()
pass
def initialize(self, module_type, params):
return { 'register_event_method': self.event_handler }
class evdev_keyboard(cGenericKeyboardOut):
pos_x = 0
pos_y = 0
def __init__(self):
logger.info('Plugin evdev_keyboard initializing...')
super().__init__()
cap = {}
self.__keyboard = UInput(cap,
name='xHID evdev keyboard',
version=0x1,
vendor=0x1,
product=0x1,
props=[])
self.__onscreen = False
def event_handler(self, props):
#logger.debug('event_handler called {}'.format(pformat(props)))
if (props[field.EVENT] == event.SCREEN_IN):
self.__onscreen = True
elif (props[field.EVENT] == event.SCREEN_OUT):
self.__onscreen = False
else:
if (self.__onscreen):
if (props[field.EVENT] in [
event.KEYBOARD_UP, event.KEYBOARD_DOWN,
event.KEYBOARD_REPEAT
]):
#logger.debug('event_handler called {}'.format(pformat(props)))
up_down = int(props[field.EVENT] == event.KEYBOARD_DOWN)
btn = props[field.BUTTON_ID]
self.__keyboard.write(ecodes.EV_KEY, btn, up_down)
self.__keyboard.syn()
pass
def initialize(self, module_type, params):
return {'register_event_method': self.event_handler}
def polling_loop(mapping, combinations): init_gpio() uinput = UInput() pin_state = [1]*len(PINS) combination_state = [False]*len(combinations) while True: #start = time() # update pin states and trigger single pin events for pin in PINS: prev = pin_state[pin] # previous pin state curr = GPIO.input(pin) # current pin state # detect edges if prev and not curr and pin in mapping: # falling edge uinput.write(ecodes.EV_KEY, mapping[pin], 1) # key down uinput.syn() elif not prev and curr and pin in mapping: # rising edge uinput.write(ecodes.EV_KEY, mapping[pin], 0) # key up uinput.syn() # update pin state pin_state[pin] = curr # query pin combinations for i, (pins, key) in enumerate(combinations): hit = True for pin in pins: if pin_state[pin] == 1: hit = False break if hit and not combination_state[i]: combination_state[i] = True uinput.write(ecodes.EV_KEY, key, 1) # key down uinput.syn() elif not hit and combination_state[i]: combination_state[i] = False uinput.write(ecodes.EV_KEY, key, 0) # key up uinput.syn() #print time() - start # wait for next polling cycle sleep(POLLING_INTERVAL)
class KeyHandler:
def __init__(self, mod_mapping, key_mapping):
self._ui = UInput()
self._mod_mapping = mod_mapping
self._key_mapping = key_mapping
def chord_event(self, mods, virtual_mods, chord, value):
chord_keys = self.map_chord(virtual_mods, chord)
if value == 0:
chord_keys = chord_keys + self.map_mods(mods)
else:
chord_keys = self.map_mods(mods) + chord_keys
for key in chord_keys:
self._ui.write(EV_KEY, key, value)
self._ui.syn()
def map_chord(self, virtual_mods, chord):
frozen_vmods = frozenset(virtual_mods)
if frozen_vmods not in self._key_mapping:
return []
current_mapping = self._key_mapping[frozen_vmods]
frozen_chord = frozenset(chord)
if frozen_chord not in current_mapping:
return []
return current_mapping[frozen_chord]
def map_mods(self, keys):
mods = []
for key in keys:
mods.append(self._mod_mapping[key])
return mods
def close(self):
self._ui.close()
class K:
__space_mode_map = {
ecodes.KEY_1: [ecodes.KEY_1, True],
ecodes.KEY_2: [ecodes.KEY_2, True],
ecodes.KEY_3: [ecodes.KEY_3, True],
ecodes.KEY_4: [ecodes.KEY_4, True],
ecodes.KEY_5: [ecodes.KEY_5, True],
ecodes.KEY_6: [ecodes.KEY_6, True],
ecodes.KEY_7: [ecodes.KEY_7, True],
ecodes.KEY_8: [ecodes.KEY_8, True],
ecodes.KEY_9: [ecodes.KEY_9, True],
ecodes.KEY_0: [ecodes.KEY_0, True],
ecodes.KEY_Q: [ecodes.KEY_1, True],
ecodes.KEY_W: [ecodes.KEY_2, True],
ecodes.KEY_E: [ecodes.KEY_3, True],
ecodes.KEY_R: [ecodes.KEY_4, True],
ecodes.KEY_T: [ecodes.KEY_5, True],
ecodes.KEY_Y: [ecodes.KEY_6, True],
ecodes.KEY_U: [ecodes.KEY_7, True],
ecodes.KEY_I: [ecodes.KEY_8, True],
ecodes.KEY_O: [ecodes.KEY_9, True],
ecodes.KEY_P: [ecodes.KEY_0, True],
ecodes.KEY_A: [ecodes.KEY_MINUS, True],
ecodes.KEY_S: [ecodes.KEY_MINUS, False],
ecodes.KEY_D: [ecodes.KEY_LEFTBRACE, False],
ecodes.KEY_F: [ecodes.KEY_RIGHTBRACE, False],
ecodes.KEY_G: [ecodes.KEY_APOSTROPHE, False],
ecodes.KEY_H: [ecodes.KEY_APOSTROPHE, True],
ecodes.KEY_J: [ecodes.KEY_LEFTBRACE, True],
ecodes.KEY_K: [ecodes.KEY_RIGHTBRACE, True],
ecodes.KEY_L: [ecodes.KEY_GRAVE, True],
ecodes.KEY_SEMICOLON: [ecodes.KEY_SEMICOLON, True],
#ecodes.KEY_Z: used for control mode!
ecodes.KEY_X: [ecodes.KEY_GRAVE, False],
ecodes.KEY_C: [ecodes.KEY_BACKSLASH, False],
ecodes.KEY_V: [ecodes.KEY_EQUAL, False],
ecodes.KEY_B: [ecodes.KEY_BACKSLASH, True],
ecodes.KEY_N: [ecodes.KEY_EQUAL, True],
ecodes.KEY_M: [ecodes.KEY_SPACE, False],
ecodes.KEY_COMMA: [ecodes.KEY_COMMA, True],
ecodes.KEY_DOT: [ecodes.KEY_DOT, True],
ecodes.KEY_SLASH: [ecodes.KEY_SLASH, True],
}
__tenkey_mode_map = {
ecodes.KEY_Q: [ecodes.KEY_1, False],
ecodes.KEY_W: [ecodes.KEY_2, False],
ecodes.KEY_E: [ecodes.KEY_3, False],
ecodes.KEY_R: [ecodes.KEY_4, False],
ecodes.KEY_T: [ecodes.KEY_5, False],
ecodes.KEY_Y: [ecodes.KEY_6, False],
ecodes.KEY_U: [ecodes.KEY_7, False],
ecodes.KEY_I: [ecodes.KEY_8, False],
ecodes.KEY_O: [ecodes.KEY_9, False],
ecodes.KEY_P: [ecodes.KEY_0, False],
ecodes.KEY_A: [ecodes.KEY_TAB, False],
ecodes.KEY_S: [ecodes.KEY_DELETE, False],
ecodes.KEY_D: [ecodes.KEY_BACKSPACE, False],
ecodes.KEY_F: [ecodes.KEY_ESC, False],
ecodes.KEY_G: [ecodes.KEY_F1, False],
ecodes.KEY_H: [ecodes.KEY_LEFT, False],
ecodes.KEY_J: [ecodes.KEY_DOWN, False],
ecodes.KEY_K: [ecodes.KEY_UP, False],
ecodes.KEY_L: [ecodes.KEY_RIGHT, False],
ecodes.KEY_SEMICOLON: [ecodes.KEY_ENTER, False],
}
def __init__(self):
self.sink = UInput()
self.reset_state()
self.buffered_event = None
def set_state(self, state):
self.__state = state
def pop_state(self):
self.__state.state_exit()
self.__state.popState()
def emit_with_space_mode(self, event):
if event.event.scancode in self.__space_mode_map:
translated_event = self.__space_mode_map[event.event.scancode]
if translated_event[1]:
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 2)
self.sink.write(ecodes.EV_KEY, translated_event[0], 1)
self.sink.write(ecodes.EV_KEY, translated_event[0], 0)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0)
else:
self.sink.write(ecodes.EV_KEY, translated_event[0], 1)
self.sink.write(ecodes.EV_KEY, translated_event[0], 0)
else:
self.sink.write(ecodes.EV_KEY, event.event.scancode, 1)
self.sink.write(ecodes.EV_KEY, event.event.scancode, 0)
def emit_with_tenkey_mode(self, event):
if event.event.scancode in self.__tenkey_mode_map:
translated_event = self.__tenkey_mode_map[event.event.scancode]
if translated_event[1]:
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 2)
self.sink.write(ecodes.EV_KEY, translated_event[0], 1)
self.sink.write(ecodes.EV_KEY, translated_event[0], 0)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0)
else:
self.sink.write(ecodes.EV_KEY, translated_event[0], 1)
self.sink.write(ecodes.EV_KEY, translated_event[0], 0)
else:
self.sink.write(ecodes.EV_KEY, event.event.scancode, 1)
self.sink.write(ecodes.EV_KEY, event.event.scancode, 0)
def emit_with_control_mode(self, event):
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTCTRL, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTCTRL, 2)
if self.__space_mode:
self.emit_with_space_mode(event)
elif self.__tenkey_mode:
#print("control tenkey")
self.emit_with_tenkey_mode(event)
else:
self.sink.write(ecodes.EV_KEY, event.event.scancode, 1)
self.sink.write(ecodes.EV_KEY, event.event.scancode, 0)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTCTRL, 0)
def emit_with_shift_mode(self, event):
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 2)
self.sink.write(ecodes.EV_KEY, event.event.scancode, 1)
self.sink.write(ecodes.EV_KEY, event.event.scancode, 0)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0)
def emit_with_normal_mode(self, event):
self.sink.write(ecodes.EV_KEY, event.event.scancode, event.event.keystate)
def emit(self, event):
#if event.event.scancode == ecodes.KEY_CAPSLOCK:# or event.event.scancode == ecodes.KEY_SYSRQ:
# self.sink.write(ecodes.EV_KEY, ecodes.KEY_F1, event.event.keystate)
#elif event.event.scancode == ecodes.KEY_LEFTMETA and event.event.keystate == events.KeyEvent.key_hold:
# pass
# #self.sink.write(ecodes.EV_KEY, ecodes.KEY_F1, event.event.keystate)
if self.__control_mode and event.event.keystate != events.KeyEvent.key_up:
self.emit_with_control_mode(event)
elif self.__space_mode and event.event.keystate != events.KeyEvent.key_up:
self.emit_with_space_mode(event)
elif self.__shift_mode and event.event.keystate != events.KeyEvent.key_up:
self.emit_with_shift_mode(event)
elif self.__tenkey_mode and event.event.keystate != events.KeyEvent.key_up:
self.emit_with_tenkey_mode(event)
else:
self.emit_with_normal_mode(event)
self.sink.syn()
def emit_space(self):
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SPACE, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SPACE, 0)
self.sink.syn()
def emit_z(self):
self.sink.write(ecodes.EV_KEY, ecodes.KEY_Z, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_Z, 0)
self.sink.syn()
def emit_slash(self):
if self.__space_mode:
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 2)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SLASH, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SLASH, 0)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0)
else:
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SLASH, 1)
self.sink.write(ecodes.EV_KEY, ecodes.KEY_SLASH, 0)
self.sink.syn()
def emit_as_buffered(self, event):
self.buffered_event = event
def emit_buffered(self):
self.emit(self.buffered_event)
self.buffered_event = None
def buffer(self, event):
self.emit_as_buffered(event)
def flush(self):
self.emit_buffered()
def reset_state(self):
self.__buffer = None
self.__space_mode = False
self.__control_mode = False
self.__meta_mode = False
self.__tenkey_mode = False
self.__shift_mode = False
def space_mode(self, flag):
self.__space_mode = flag
def control_mode(self, flag):
self.__control_mode = flag
def meta_mode(self, flag):
self.__meta_mode = flag
def shift_mode(self, flag):
self.__shift_mode = flag
def tenkey_mode(self, flag):
self.__tenkey_mode = flag
def close(self):
self.sink.close()
class HIDMapperController (object):
def __init__ (self):
self._profile = None
self._running = False
self._input_devices = None
self._file_descriptors = None
self._allowed_event_types = None
self._event_status = None
self._gesture_codes = deque()
self._last_queued = None
self._virtual_input = None
self._matcher = None
@property
def profile (self, profile_obj):
self._profile=profile_obj
@profile.setter
def profile (self, profile_obj):
self._profile=profile_obj
def _prepare_device (self):
#print("device: %s" % self._profile.device.name)
self._event_status = {key:0 for key in self._profile.device.get_events_supported()}
#print("Events supported",self._event_status)
self._allowed_event_types = set([getattr(ecodes,i[-1].split(':')[0]) for i in self._event_status])
self._input_devices = map(InputDevice, self._profile.device.devices)
self._file_descriptors = { dev.fd: i for i, dev in enumerate(self._input_devices) }
print("Mappings for '" + self._profile.name+"' " + '-'*30)
for k,v in sorted(self._profile.mapping.items()):
print(str(k.replace("EV_KEY:KEY_","").replace("ENTER","<-'").replace("APOSTROPHE","'").replace(",","")).lower().rjust(20)+" as "+(', '.join(v)).replace("r_hand_tap_", "").replace("_vs_thumb", ""))
# Prepare virtual device for event injection
capabilities = {}
for ev_chain in self._profile.mapping:
for k in re.split('[+,]', ev_chain):
et, ec = k.split(':', 1)
etype = ecodes.ecodes[et]
if etype in capabilities:
capabilities[etype].append(ecodes.ecodes[ec])
else:
capabilities[etype] = [ ecodes.ecodes[ec] ]
#print("Capabilities", capabilities)
self._virtual_input = UInput(events = capabilities)
# Prepare matcher
self._matcher = Matcher(self._profile)
def start (self):
"""
Start capturing from the device(s) of the current profile
"""
self._prepare_device()
try:
for dev in self._input_devices: dev.grab()
except Exception as e:
print("Unable to grab device", e)
self._running = True
spawn(self._capture_loop)
spawn(self._process_loop)
sleep(0)
def stop (self):
"""
Stop capturing and release the device(s)
"""
self._running = False
try:
for dev in self._input_devices: dev.ungrab()
except:
pass
if self._virtual_input:
self._virtual_input.close()
def _capture_loop (self):
try:
devices = {dev.fd : dev for dev in self._input_devices}
while self._running:
r,_,_ = select(devices, [], [], timeout=self._profile.double_click_timeout/1000.0)
for fd in r:
for event in devices[fd].read():
#print("Lo que", event)
if self.is_allowed_event(event, fd):
event_code = self.get_event_code(event, fd)
if event.value == 1:
#print("Pressed!", event_code)
self.set_event_status(event_code, 1)
#print("Statuses", self._event_status)
self._store_gestures()
elif event.value == 0:
#print("Released!", event_code)
self.set_event_status(event_code, 0)
#print("Statuses", self._event_status)
#self._store_gestures()
else:
print("What is this?",event)
except:
self._running = False
traceback.print_exc()
def _store_gestures (self):
"""
Fetch current gestures, select those allowed in the profile and store them in the queue of gesture codes
"""
filtered_gestures = set([
gesture for gesture in self.get_current_gestures() if gesture in self._profile.gestures
])
if not filtered_gestures:
return
if filtered_gestures != self._last_queued:
distance = 1.0
if self._last_queued:
distance = self._profile.get_gestures_distance(filtered_gestures, self._last_queued)
#print("Distance is", distance)
self._last_queued = filtered_gestures
if distance <= 0.5:
try:
timestamp, last_queued = self._gesture_codes.pop()
#print("Time interval", time.time() - timestamp)
if time.time() - timestamp > self._profile.double_click_timeout/6000.0:
self._gesture_codes.append((timestamp, last_queued))
except IndexError:
pass #print("Empty queue!")
self._gesture_codes.append((time.time(), filtered_gestures))
def _process_loop (self):
"""
TODO: Process the queue of gestures and inject remapped events
"""
while self._running:
try:
timestamp, prefixes = self._gesture_codes.pop()
reduced = self._profile.reduce_gestures(prefixes)
self._matcher.add_prefix(timestamp, reduced)
# With every possible option if any...
for candidate, output_event in self._matcher.get_matching_codes():
#print("Candidate(s)",candidate, "would generate events(s)", output_event)
self._inject_event(output_event)
except IndexError:
pass
except:
print("Processing error")
traceback.print_exc()
sleep(self._profile.double_click_timeout/5000.0)
def _inject_event (self, event_codes):
"""
Insert one or several events in the virtual input
event_code is a string, normally, that contains an event, like 'EV_KEY:KEY_A'
event_code can have a sequence of events, like 'EV_KEY:KEY_A,EV_KEY:KEY_B,EV_KEY:KEY_C'
event_code can contain chained events, to make combination of keys, like: 'EV_KEY:KEY_LEFTCTRL+EV_KEY:KEY_C'
"""
if isinstance(event_codes, str):
event_codes = event_codes.split(",")
for event_code_combo in event_codes:
for operation in [1, 0]:
for event_code in event_code_combo.split("+"):
if isinstance(event_code, str):
event_code = event_code.split(':')
if len(event_code) == 1 and ':' in event_code[0]:
event_code = event_code[0].split(':')
etype = ecodes.ecodes[event_code[0]]
ecode = ecodes.ecodes[event_code[1]]
#names = ecodes.bytype[etype][ecode]
#if not isinstance(names, list):
# names = [names]
#print("Inject event {} {}".format(names[0], "pressed" if operation==1 else "released"))
self._virtual_input.write(etype, ecode, operation) # pressed
self._virtual_input.syn()
def find_event_keys (self, event_code, where):
"""
param event_code: Event code to search (as a tuple)
param where: A dictionary whose keys are event codes
Search and returns a list of matching keys for an event code, in the dictionary or list 'where'
"""
matches = []
event_keys = [event_code]
if len(event_code) < 2:
for dev_num, _ in enumerate(self._file_descriptors):
event_keys.append(('DEV_%d' % dev_num, event_code[0]))
else:
event_keys.append((event_code[1],))
for ev in event_keys:
if ev in where:
matches.append(ev)
return matches
def is_allowed_event (self, event, fd = None):
"""
Decide if the controller must capture this event or not
"""
if event.type in self._allowed_event_types:
event_code = self.get_event_code(event)
if fd is not None:
key1 = ('DEV_%d' % self._file_descriptors[fd], event_code[0])
key2 = event_code
return key1 in self._event_status or key2 in self._event_status
else:
if not event_code in self._event_status:
for dev_num, _ in enumerate(self._file_descriptors):
key = ('DEV_%d' % dev_num, event_code[0])
if key in self._event_status:
return True
else:
return True
return False
def get_event_code (self, event, fd = None):
"""
Returns the event code (type+code), prefixed by the device if 'fd' is present
"""
name = ecodes.bytype[event.type][event.code]
#print("Event code from", event, "is", name)
if isinstance(name, list):
name = name[0]
event_code = "%s:%s" % (ecodes.EV[event.type], name)
if fd is not None:
return ('DEV_%d' % self._file_descriptors[fd], event_code)
return (event_code, )
def get_current_gestures (self, where_to_find = None, current_gestures = None):
"""
return: A set of gestures activated at this moment
"""
if where_to_find is None:
where_to_find = self._profile.device.gestures_lut
if current_gestures is None:
current_gestures = set([])
for ev in self._event_status:
if self._event_status[ev]: # Is pressed?
for found in self.find_event_keys(ev, where_to_find):
result = where_to_find[found]
if isinstance(result, dict):
self.get_current_gestures(result, current_gestures)
else:
current_gestures.add(result)
return current_gestures
def set_event_status (self, event_code, status):
"""
Sets the status for every event that matches the event_code
"""
for ev_key in self.find_event_keys(event_code, self._event_status):
self._event_status[ev_key] = status
def __del__ (self):
print("Stopping capturer")
if self._running:
self.stop()
moveX = 0 moveY = 0 FPS = 30 TIME = .1/FPS while True: time.sleep(TIME) try: gen = device.read(); for event in gen: if(event.type == BUTTON_TYPE): options[event.code](keyboard,event.value) keyboard.syn() if(event.type == MOVEMENT_TYPE): move = options[event.code](mouse,event.value) if(0 in move): moveY = move[0] elif(1 in move): moveX = move[1] if(moveX < 0): moveX = -1 elif(moveX > 0): moveX = 1 else: moveX = 0 if(moveY < 0): moveY = -1
class PPMDecoder(object):
"""Decodes the audio data into PPM pulse data, and then into uinput
joystick events.
"""
def __init__(self, rate):
"""
Parameters
----------
rate : int
sample rate
"""
self._rate = float(rate)
self._lf = None
self._threshold = 15000
self._last_edge = None
self._ch = None
# Size in sampling intervals, of the frame space marker
self._marker = int(2.0 * 0.0025 * self._rate)
# Mapping of channels to events
self._mapping = {0: ecodes.ABS_X,
1: ecodes.ABS_Y,
2: ecodes.ABS_Z,
3: ecodes.ABS_THROTTLE}
events = [(v, (0, 255, 5, 0)) for v in self._mapping.values()]
self._ev = UInput(name='ppmadapter',
events={
ecodes.EV_ABS: events,
ecodes.EV_KEY: {288: 'BTN_JOYSTICK'}
})
def __enter__(self):
return self
def __exit__(self, type, value, tb):
self._ev.close()
def feed(self, data):
"""Feeds the decoder with a block of sample data.
The data should be integer values, and should only be a single channel.
Parameters
----------
data : list
sample data
"""
sync_req = False
for i in range(len(data)):
this_edge = data[i] > self._threshold
if self._last_edge is None:
self._last_edge = this_edge
continue
if this_edge and not self._last_edge:
# rising
if self._lf is not None:
sync_req |= self.signal(i - self._lf)
elif not this_edge and self._last_edge:
# falling
self._lf = i
self._last_edge = this_edge
if sync_req:
self._ev.syn()
if self._lf is not None:
self._lf = self._lf - len(data)
if self._lf < (-self._rate):
print("Lost sync")
self._ch = None
self._lf = None
def signal(self, w):
"""Process the detected signal.
The signal is the number of sampling intervals between the falling
edge and the rising edge.
Parameters
----------
w : int
signal width
Returns
-------
bool
does uinput require sync
"""
if w > self._marker:
if self._ch is None:
print("Got sync")
self._ch = 0
return False
if self._ch is None or self._ch not in self._mapping:
return False
duration = float(w) / self._rate
value = int((duration - 0.0007) * 1000 * 255)
self._ev.write(ecodes.EV_ABS, self._mapping[self._ch], value)
self._ch += 1
return True
class UInputDevice(object):
def __init__(self, xpad=False, mouse=False):
self.mouse = None
if xpad:
self.create_joystick_xpad()
else:
self.create_joystick_ds4()
if mouse:
self.create_mouse()
def create_mouse(self):
events = {
ecodes.EV_REL: (ecodes.REL_X, ecodes.REL_Y),
ecodes.EV_KEY: (ecodes.BTN_LEFT, ecodes.BTN_RIGHT)
}
self.mouse = UInput(events)
self.mouse_pos = None
def create_joystick(self, name, axes, buttons, hats, axes_options={}):
events = {ecodes.EV_ABS: [], ecodes.EV_KEY: []}
device_name = name
for name in axes:
key = getattr(ecodes, name)
params = axes_options.get(name, (0, 255, 0, 15))
events[ecodes.EV_ABS].append((key, params))
for name in hats:
key = getattr(ecodes, name)
params = (-1, 1, 0, 0)
events[ecodes.EV_ABS].append((key, params))
for name in buttons:
events[ecodes.EV_KEY].append(getattr(ecodes, name))
self.joystick = UInput(name=device_name, events=events)
self.axes = axes
self.buttons = buttons
self.hats = hats
def create_joystick_ds4(self):
axes_map = {
"ABS_X": "left_analog_x",
"ABS_Y": "left_analog_y",
"ABS_Z": "right_analog_x",
"ABS_RZ": "right_analog_y",
"ABS_RX": "l2_analog",
"ABS_RY": "r2_analog",
"ABS_THROTTLE": "orientation_roll",
"ABS_RUDDER": "orientation_pitch",
"ABS_WHEEL": "orientation_yaw",
"ABS_DISTANCE": "motion_z",
"ABS_TILT_X": "motion_x",
"ABS_TILT_Y": "motion_y",
}
axes_options = {
"ABS_THROTTLE": (-16385, 16384, 0, 0),
"ABS_RUDDER": (-16385, 16384, 0, 0),
"ABS_WHEEL": (-16385, 16384, 0, 0),
"ABS_DISTANCE": (-32768, 32767, 0, 10),
"ABS_TILT_X": (-32768, 32767, 0, 10),
"ABS_TILT_Y": (-32768, 32767, 0, 10),
}
button_map = {
"BTN_TR2": "button_options",
"BTN_MODE": "button_ps",
"BTN_TL2": "button_share",
"BTN_B": "button_cross",
"BTN_C": "button_circle",
"BTN_A": "button_square",
"BTN_X": "button_triangle",
"BTN_Y": "button_l1",
"BTN_Z": "button_r1",
"BTN_TL": "button_l2",
"BTN_TR": "button_r2",
"BTN_SELECT": "button_l3",
"BTN_START": "button_r3",
"BTN_THUMBL": "button_trackpad"
}
hat_map = {
"ABS_HAT0X": ("dpad_left", "dpad_right"),
"ABS_HAT0Y": ("dpad_up", "dpad_down")
}
self.create_joystick(axes=axes_map, axes_options=axes_options,
buttons=button_map, hats=hat_map,
name="Sony Computer Entertainment Wireless Controller")
def create_joystick_xpad(self):
axes_map = {
"ABS_X": "left_analog_x",
"ABS_Y": "left_analog_y",
"ABS_RX": "right_analog_x",
"ABS_RY": "right_analog_y",
"ABS_Z": "l2_analog",
"ABS_RZ": "r2_analog"
}
button_map = {
"BTN_START": "button_options",
"BTN_MODE": "button_ps",
"BTN_SELECT": "button_share",
"BTN_A": "button_cross",
"BTN_B": "button_circle",
"BTN_X": "button_square",
"BTN_Y": "button_triangle",
"BTN_TL": "button_l1",
"BTN_TR": "button_r1",
"BTN_THUMBL": "button_l3",
"BTN_THUMBR": "button_r3"
}
hat_map = {
"ABS_HAT0X": ("dpad_left", "dpad_right"),
"ABS_HAT0Y": ("dpad_up", "dpad_down")
}
self.create_joystick(axes=axes_map, buttons=button_map, hats=hat_map,
name="Microsoft X-Box 360 pad")
def emit(self, report):
self.emit_joystick(report)
if self.mouse:
self.emit_mouse(report)
def emit_joystick(self, report):
for name, attr in self.axes.items():
name = getattr(ecodes, name)
value = getattr(report, attr)
self.joystick.write(ecodes.EV_ABS, name, value)
for name, attr in self.buttons.items():
name = getattr(ecodes, name)
value = getattr(report, attr)
self.joystick.write(ecodes.EV_KEY, name, value)
for name, attr in self.hats.items():
name = getattr(ecodes, name)
if getattr(report, attr[0]):
value = -1
elif getattr(report, attr[1]):
value = 1
else:
value = 0
self.joystick.write(ecodes.EV_ABS, name, value)
self.joystick.syn()
def emit_mouse(self, report):
if report.trackpad_touch0_active:
if not self.mouse_pos:
self.mouse_pos = (report.trackpad_touch0_x,
report.trackpad_touch0_y)
sensitivity = 0.5
rel_x = (report.trackpad_touch0_x - self.mouse_pos[0]) * sensitivity
rel_y = (report.trackpad_touch0_y - self.mouse_pos[1]) * sensitivity
self.mouse.write(ecodes.EV_REL, ecodes.REL_X, int(rel_x))
self.mouse.write(ecodes.EV_REL, ecodes.REL_Y, int(rel_y))
self.mouse_pos = (report.trackpad_touch0_x, report.trackpad_touch0_y)
else:
self.mouse_pos = None
self.mouse.write(ecodes.EV_KEY, ecodes.BTN_LEFT,
int(report.button_trackpad))
self.mouse.syn()
class Chatpad():
#Some hard-coded things about the ChatPad protocol
kInitMessage = bytearray([ 0x87, 0x02, 0x8C, 0x1F, 0xCC ])
kAwakeMessage = bytearray([ 0x87, 0x02, 0x8C, 0x1B, 0xD0 ])
kShiftMask = (1 << 0)
kGreenSquareMask = (1 << 1)
kOrangeCircleMask = (1 << 2)
kPeopleMask = (1 << 3)
#Modifier dictionary
mod_dict = {kShiftMask:1, kGreenSquareMask: 2, kOrangeCircleMask: 3, kPeopleMask: 4}
#Key dictionary
key_dict = {17: 'KEY_7', 18: 'KEY_6', 19: 'KEY_5', 20: 'KEY_4', 21: 'KEY_3', 22: 'KEY_2', 23: 'KEY_1', 33: 'KEY_U', 34: 'KEY_Y', 35: 'KEY_T', 36: 'KEY_R', 37: 'KEY_E', 38: 'KEY_W', 39: 'KEY_Q', 49: 'KEY_J', 50: 'KEY_H', 51: 'KEY_G', 52: 'KEY_F', 53: 'KEY_D', 54: 'KEY_S', 55: 'KEY_A', 65: 'KEY_N', 66: 'KEY_B', 67: 'KEY_V', 68: 'KEY_C', 69: 'KEY_X', 70: 'KEY_Z', 81: 'KEY_RIGHT', 82: 'KEY_M', 83: 'KEY_DOT', 84: 'KEY_SPACE', 85: 'KEY_LEFT', 98: 'KEY_COMMA', 99: 'KEY_ENTER', 100: 'KEY_P', 101: 'KEY_0', 102: 'KEY_9', 103: 'KEY_8', 113: 'KEY_BACKSPACE', 114: 'KEY_L', 117: 'KEY_O', 118: 'KEY_I', 119: 'KEY_K'}
key_dict.update({1: 'KEY_LEFTSHIFT', 2: 'KEY_LEFTCTRL', 3: 'KEY_RIGHTALT', 4:'KEY_LEFTMETA'}) #Adding modifiers in the dictionary - we'll be injecting their keycodes if modifiers will be found
def __init__(self, port = "/dev/ttyAMA0", name="xbox_chatpad_input", keycode_callback = None, ecode_callback = None):
self.keycode_callback = keycode_callback
self.ecode_callback = ecode_callback
if ecode_callback == None and name: #If we don't have any external callback provided, we should be using a built-in one that uses uinput
self.ecode_callback = self.uinput_callback
self.uinput = UInput(name=name, devnode='/dev/uinput')
if self.keycode_callback == None: #If keycode_callback is not provided
self.keycode_callback = lambda *args: None #Setting callback to empty function to avoid exceptions
if self.ecode_callback == None: #If ecode_callback is not provided
self.ecode_callback = lambda *args: None #Setting callback to empty function to avoid exceptions
self.name = name
self.port = port
self.serial = Serial(port, 19200)
def send_init_message(self):
#print "Init message sent"
self.serial.write(self.kInitMessage)
def send_awake_message(self):
#print "Awake message sent"
self.serial.write(self.kAwakeMessage)
def test_chatpad_on_serial(self):
# TODO: Add Chatpad detection on a serial port (using 5-byte init response messages starting with A5)
return NotImplementedError
def uinput_callback(self, pressed, released):
for key in pressed:
#print "Key pressed: "+self.key_dict[key]
self.uinput.write(ecodes.EV_KEY, ecodes.ecodes[key], 1)
for key in released:
#print "Key released: "+self.key_dict[key]
self.uinput.write(ecodes.EV_KEY, ecodes.ecodes[key], 0)
self.uinput.syn()
def listen(self):
self.send_init_message()
self.send_awake_message()
counter = 0
counter_treshold = 100
pressed_keys = []
previous_keys = []
pressed_modifiers = []
previous_modifiers = []
while True:
while self.serial.inWaiting() > 8:
#print self.serial.inWaiting()
data = self.serial.read(1)
rdata = bytearray(data[0])[0]
expected = bytearray([0xB4])[0]
if rdata != expected:
#print "Invalid first byte, shuffling further: "+str(rdata)+", expected: "+str(expected)
continue
#print "First byte OK, checking second byte:"
data += self.serial.read(1)
rdata = bytearray(data[1])[0]
expected = bytearray([0xC5])[0]
if rdata != expected:
#print "Invalid second byte, shuffling further: "+str(rdata)+", expected: "+str(expected)
continue
data += self.serial.read(6)
#Data package received
#I won't be checking the checksum, too lazy =)
#print "Data package received: "+str(data)
pressed_keys = []
pressed_modifiers = []
modifiers = bytearray(data[3])[0]
key0 = bytearray(data[4])[0]
key1 = bytearray(data[5])[0]
if key0:
#print "Key 0 is: "+str(key0)
pressed_keys.append(key0)
if key1:
#print "Key 1 is: "+str(key1)
pressed_keys.append(key1)
if not key0 and not key1:
#print "All keys released"
pressed_keys = []
for modifier in self.mod_dict.keys():
if modifier & modifiers == modifier:
pressed_modifiers.append(self.mod_dict[modifier])
if previous_keys == pressed_keys and previous_modifiers == pressed_modifiers:
continue #Duplicate message received, no need to worry
#Next lines would be a perfect example of where to use sets - wonder what is their performance and if that would be premature optimisation
pressed = [key for key in pressed_keys if key not in previous_keys]
for mod in pressed_modifiers:
if mod not in previous_modifiers:
#Append modifier to pressed keys
pressed.append(mod)
released = [key for key in previous_keys if key not in pressed_keys]
for mod in previous_modifiers:
if mod not in pressed_modifiers:
#Append modifier to released keys
released.append(mod)
#Keys read, time to process
self.keycode_callback(pressed, released)
self.ecode_callback([self.key_dict[keycode] for keycode in pressed], [self.key_dict[keycode] for keycode in released])
#All done, prepare for the next iteration
previous_keys = pressed_keys
previous_modifiers = pressed_modifiers
sleep(1.0/counter_treshold)
counter += 1
if counter == counter_treshold:
self.send_awake_message()
counter = 0
class History(Thread):
def __init__(self):
Thread.__init__(self)
self.n = 0
self.st = True # Stop
self.sl = False # Sleep
self.ui = UInput()
self.history = []
self.m = PyMouse()
self.flag = True
self.rec = False
def send_event(self):
i = 0
while i < len(self.history):
now = self.history[i]
if i < len(self.history)-1: after = self.history[i+1]
if self.st: break
if not self.sl:
self.m.move( now.get("mouse")[0], now.get("mouse")[1])
if now.get("event").type == ecodes.EV_KEY:
self.ui.write(ecodes.EV_KEY, now.get("event").code, now.get("event").value)
self.ui.syn()
if i < len(self.history):
time.sleep(float(after.get("event").sec - now.get("event").sec)+float(after.get("event").usec - now.get("event").usec)/1000000)
i += 1
# sobrescrevendo o metodo run()
def run(self):
while self.flag:
if not self.st:
if self.n == 0:
while not self.stop:
self.send_event()
elif self.n > 0:
for i in range(self.n):
self.send_event()
self.st = True
# print self.history
print("\nEnd")
def exit(self):
self.stop()
self.flag = False
def play(self):
self.st = False
def stop(self):
print("Stop")
self.st = True
def sleep(self):
if self.sl:
print("Play")
else:
print("Pause")
self.sl = not self.sleep
def reset(self):
self.history = []
def append_event(self, event):
# if event.type == ecodes.EV_KEY:
self.history.append({"mouse": self.m.position(), 'event': event})
# print(self.m.position())
# if self.rec:
def set_n(self, n):
self.n = n
def save(self):
s = raw_input("\nDigite o nome do arquivo: ")
pickle.dump( self.history, open(s, 'wb'), -1)
print("Salvo em %s" %s)
def load(self):
""" Carrega um historico. """
s = raw_input("\nDigite o nome do arquivo: ")
try:
self.history = pickle.load(open(s, 'rb'))
print("Carregado de %s" %s)
except FileNotFoundError:
print("Arquivo inexistente!")
class UInputDevice(object):
def __init__(self, layout):
self.joystick_dev = None
self.evdev_dev = None
self.ignored_buttons = set()
self.create_device(layout)
def create_mouse(self):
events = {
ecodes.EV_REL: (ecodes.REL_X, ecodes.REL_Y),
ecodes.EV_KEY: (ecodes.BTN_LEFT, ecodes.BTN_RIGHT)
}
self.mouse = UInput(events)
self.mouse_pos = None
def create_device(self, layout):
events = {ecodes.EV_ABS: [], ecodes.EV_KEY: [],
ecodes.EV_REL: []}
# Joystick device
if layout.axes or layout.buttons or layout.hats:
self.joystick_dev = next_joystick_device()
for name in layout.axes:
key = getattr(ecodes, name)
params = layout.axes_options.get(name, (0, 255, 0, 15))
events[ecodes.EV_ABS].append((key, params))
for name in layout.hats:
key = getattr(ecodes, name)
params = (-1, 1, 0, 0)
events[ecodes.EV_ABS].append((key, params))
for name in layout.buttons:
events[ecodes.EV_KEY].append(getattr(ecodes, name))
if layout.mouse:
self.mouse_pos = {}
for name in layout.mouse:
events[ecodes.EV_REL].append(getattr(ecodes, name))
self.device = UInput(name=layout.name, events=events,
bustype=layout.bustype, vendor=layout.vendor,
product=layout.product, version=layout.version)
self.layout = layout
def emit(self, report):
for name, attr in self.layout.axes.items():
name = getattr(ecodes, name)
value = getattr(report, attr)
self.device.write(ecodes.EV_ABS, name, value)
for name, attr in self.layout.buttons.items():
name = getattr(ecodes, name)
if attr in self.ignored_buttons:
value = False
else:
value = getattr(report, attr)
self.device.write(ecodes.EV_KEY, name, value)
for name, attr in self.layout.hats.items():
name = getattr(ecodes, name)
if getattr(report, attr[0]):
value = -1
elif getattr(report, attr[1]):
value = 1
else:
value = 0
self.device.write(ecodes.EV_ABS, name, value)
if self.layout.mouse:
self.emit_mouse(report)
self.device.syn()
def emit_mouse(self, report):
for name, attr in self.layout.mouse.items():
if attr.startswith("trackpad_touch"):
active_attr = attr[:16] + "active"
if not getattr(report, active_attr):
self.mouse_pos.pop(name, None)
continue
pos = getattr(report, attr)
if name not in self.mouse_pos:
self.mouse_pos[name] = pos
sensitivity = 0.5
rel = (pos - self.mouse_pos[name]) * sensitivity
self.device.write(ecodes.EV_REL, getattr(ecodes, name), int(rel))
self.mouse_pos[name] = pos
class RemoteServer(object):
def __init__(self):
self.ui = UInput()
cap = {e.EV_REL: [e.REL_X, e.REL_Y]}
cap = {
e.EV_REL : (e.REL_X, e.REL_Y),
e.EV_KEY : (e.BTN_MOUSE,),
}
self.mouse = UInput(cap)
def run(self, args):
proc = run(args, check=False, stdout=PIPE, stderr=PIPE)
return (args, proc.returncode, proc.stderr,proc.stdout)
def handshake(self):
return
@Pyro4.oneway
def sleep(self):
log.debug("Putting system to sleep")
proc = run(["sudo","systemctl","suspend"], check=False)
def keycombo(self,keys):
for key in keys:
self.ui.write(e.EV_KEY, key, 1)
for key in keys:
self.ui.write(e.EV_KEY, key, 0)
self.ui.syn()
def mouseaction(self, events):
for ev in events:
self.mouse.write(ev['type'],ev['code'],ev['value'])
self.mouse.syn()
def pause(self,appname):
if appname == "spotify":
return self.pause_spotify()
elif appname == "kodi":
return self.pause_kodi()
def pause_spotify(self):
log.debug("Pausing spotify")
args = ["dbus-send", "--print-reply",
"--dest=org.mpris.MediaPlayer2.spotify",
"/org/mpris/MediaPlayer2",
"org.mpris.MediaPlayer2.Player.Pause"]
return self.run(args)
def pause_kodi(self):
log.debug("Pausing Kodi")
kodi = XBMC("http://192.168.1.69:8080/jsonrpc")
playerid_result = kodi.Player.GetActivePlayers()['result']
if playerid_result:
playerid = playerid_result[0]['playerid']
else:
return
speed = kodi.Player.GetProperties(
{'playerid':playerid,'properties':['speed']}
)['result']['speed']
if speed != 0:
kodi.Player.PlayPause({'playerid': playerid})
def mute_app(self, appname):
Pulse.mute_input(appname)
def unmute_app(self, appname):
Pulse.unmute_input(appname)
def pause_service(self,appname):
log.debug("Suspending service: %s" % appname)
args = ["systemctl","--user","kill","-s","STOP","%s.service" %appname]
result = self.run(args)
return result
def continue_service(self,appname):
log.debug("Resuming_ service: %s" % appname)
args = ["systemctl","--user","kill","-s","CONT","%s.service" %appname]
return self.run(args)
class UInputDevice(object):
def __init__(self, layout):
self.joystick_dev = None
self.evdev_dev = None
self.ignored_buttons = set()
self.create_device(layout)
self._write_cache = {}
self._scroll_details = {}
def create_device(self, layout):
"""Creates a uinput device using the specified layout."""
events = {ecodes.EV_ABS: [], ecodes.EV_KEY: [],
ecodes.EV_REL: []}
# Joystick device
if layout.axes or layout.buttons or layout.hats:
self.joystick_dev = next_joystick_device()
for name in layout.axes:
params = layout.axes_options.get(name, DEFAULT_AXIS_OPTIONS)
events[ecodes.EV_ABS].append((name, params))
for name in layout.hats:
params = (-1, 1, 0, 0)
events[ecodes.EV_ABS].append((name, params))
for name in layout.buttons:
events[ecodes.EV_KEY].append(name)
if layout.mouse:
self.mouse_pos = {}
self.mouse_rel = {}
self.mouse_analog_sensitivity = float(
layout.mouse_options.get("MOUSE_SENSITIVITY",
DEFAULT_MOUSE_SENSITIVTY)
)
self.mouse_analog_deadzone = int(
layout.mouse_options.get("MOUSE_DEADZONE",
DEFAULT_MOUSE_DEADZONE)
)
self.scroll_repeat_delay = float(
layout.mouse_options.get("MOUSE_SCROLL_REPEAT_DELAY",
DEFAULT_SCROLL_REPEAT_DELAY)
)
self.scroll_delay = float(
layout.mouse_options.get("MOUSE_SCROLL_DELAY",
DEFAULT_SCROLL_DELAY)
)
for name in layout.mouse:
if name in (ecodes.REL_WHEELUP, ecodes.REL_WHEELDOWN):
if ecodes.REL_WHEEL not in events[ecodes.EV_REL]:
# This ensures that scroll wheel events can work
events[ecodes.EV_REL].append(ecodes.REL_WHEEL)
else:
events[ecodes.EV_REL].append(name)
self.mouse_rel[name] = 0.0
self.device = UInput(name=layout.name, events=events,
bustype=layout.bustype, vendor=layout.vendor,
product=layout.product, version=layout.version)
self.layout = layout
def write_event(self, etype, code, value):
"""Writes a event to the device, if it has changed."""
last_value = self._write_cache.get(code)
if last_value != value:
self.device.write(etype, code, value)
self._write_cache[code] = value
def emit(self, report):
"""Writes axes, buttons and hats with values from the report to
the device."""
for name, attr in self.layout.axes.items():
value = getattr(report, attr)
self.write_event(ecodes.EV_ABS, name, value)
for name, attr in self.layout.buttons.items():
attr, modifier = attr
if attr in self.ignored_buttons:
value = False
else:
value = getattr(report, attr)
if modifier and "analog" in attr:
if modifier == "+":
value = value > (128 + DEFAULT_A2D_DEADZONE)
elif modifier == "-":
value = value < (128 - DEFAULT_A2D_DEADZONE)
self.write_event(ecodes.EV_KEY, name, value)
for name, attr in self.layout.hats.items():
if getattr(report, attr[0]):
value = -1
elif getattr(report, attr[1]):
value = 1
else:
value = 0
self.write_event(ecodes.EV_ABS, name, value)
self.device.syn()
def emit_reset(self):
"""Resets the device to a blank state."""
for name in self.layout.axes:
params = self.layout.axes_options.get(name, DEFAULT_AXIS_OPTIONS)
self.write_event(ecodes.EV_ABS, name, int(sum(params[:2]) / 2))
for name in self.layout.buttons:
self.write_event(ecodes.EV_KEY, name, False)
for name in self.layout.hats:
self.write_event(ecodes.EV_ABS, name, 0)
self.device.syn()
def emit_mouse(self, report):
"""Calculates relative mouse values from a report and writes them."""
for name, attr in self.layout.mouse.items():
if attr.startswith("trackpad_touch"):
active_attr = attr[:16] + "active"
if not getattr(report, active_attr):
self.mouse_pos.pop(name, None)
continue
pos = getattr(report, attr)
if name not in self.mouse_pos:
self.mouse_pos[name] = pos
sensitivity = 0.5
self.mouse_rel[name] += (pos - self.mouse_pos[name]) * sensitivity
self.mouse_pos[name] = pos
elif "analog" in attr:
pos = getattr(report, attr)
if (pos > (128 + self.mouse_analog_deadzone)
or pos < (128 - self.mouse_analog_deadzone)):
accel = (pos - 128) / 10
else:
continue
sensitivity = self.mouse_analog_sensitivity
self.mouse_rel[name] += accel * sensitivity
# Emulate mouse wheel (needs special handling)
if name in (ecodes.REL_WHEELUP, ecodes.REL_WHEELDOWN):
ecode = ecodes.REL_WHEEL # The real event we need to emit
write = False
if getattr(report, attr):
self._scroll_details['direction'] = name
now = time.time()
last_write = self._scroll_details.get('last_write')
if not last_write:
# No delay for the first button press for fast feedback
write = True
self._scroll_details['count'] = 0
if name == ecodes.REL_WHEELUP:
value = 1
elif name == ecodes.REL_WHEELDOWN:
value = -1
if last_write:
# Delay at least one cycle before continual scrolling
if self._scroll_details['count'] > 1:
if now - last_write > self.scroll_delay:
write = True
elif now - last_write > self.scroll_repeat_delay:
write = True
if write:
self.device.write(ecodes.EV_REL, ecode, value)
self._scroll_details['last_write'] = now
self._scroll_details['count'] += 1
continue # No need to proceed further
else:
# Reset so you can quickly tap the button to scroll
if self._scroll_details.get('direction') == name:
self._scroll_details['last_write'] = 0
self._scroll_details['count'] = 0
rel = int(self.mouse_rel[name])
self.mouse_rel[name] = self.mouse_rel[name] - rel
self.device.write(ecodes.EV_REL, name, rel)
self.device.syn()
if (readadc(joyX2, SPICLK, SPIMOSI, SPIMISO, SPICS) > 1148):
#print("Right")
if (isRight != True):
dev.write(e.EV_KEY, e.KEY_LEFT, 1)
isRight = True
else:
if (isRight == True):
dev.write(e.EV_KEY, e.KEY_LEFT, 0)
isRight = False
if (readadc(joyY2, SPICLK, SPIMOSI, SPIMISO, SPICS) < 900):
#print("Down")
if (isDown != True):
dev.write(e.EV_KEY, e.KEY_DOWN, 1)
isDown = True
else:
if (isDown == True):
dev.write(e.EV_KEY, e.KEY_DOWN, 0)
isDown = False
if (readadc(joyY2, SPICLK, SPIMOSI, SPIMISO, SPICS) > 1148):
#print("Up")
if (isUp != True):
dev.write(e.EV_KEY, e.KEY_UP, 1)
isUp = True
else:
if (isUp == True):
dev.write(e.EV_KEY, e.KEY_UP, 0)
isUp = False
dev.syn()
readerPort = 100 rfid_data = readData(readerIP, readerPort) print(rfid_data) books = rfid_data['books'] patron = rfid_data['patron'] ui = UInput() #Alt-tabing, for testing purpose only ui.write(e.EV_KEY, e.ecodes['KEY_LEFTALT'], 1) # KEY down ui.write(e.EV_KEY, e.ecodes['KEY_TAB'], 1) # KEY down ui.write(e.EV_KEY, e.ecodes['KEY_TAB'], 0) # KEY up ui.write(e.EV_KEY, e.ecodes['KEY_LEFTALT'], 0) # KEY up ui.syn() sleep(.5) #sending patronid keyboard_events = [e.ecodes['KEY_' + i.upper()] for i in patron] for key in keyboard_events: ui.write(e.EV_KEY, key, 1) # KEY down ui.write(e.EV_KEY, key, 0) # KEY up ui.write(e.EV_KEY, e.ecodes['KEY_ENTER'], 1) # KEY down ui.write(e.EV_KEY, e.ecodes['KEY_ENTER'], 0) # KEY up ui.syn() sleep(.5)
class UInputDevice(object):
def __init__(self, layout):
self.joystick_dev = None
self.evdev_dev = None
self.ignored_buttons = set()
self.create_device(layout)
self._write_cache = {}
def create_device(self, layout):
events = {ecodes.EV_ABS: [], ecodes.EV_KEY: [],
ecodes.EV_REL: []}
# Joystick device
if layout.axes or layout.buttons or layout.hats:
self.joystick_dev = next_joystick_device()
for name in layout.axes:
params = layout.axes_options.get(name, DEFAULT_AXIS_OPTIONS)
events[ecodes.EV_ABS].append((name, params))
for name in layout.hats:
params = (-1, 1, 0, 0)
events[ecodes.EV_ABS].append((name, params))
for name in layout.buttons:
events[ecodes.EV_KEY].append(name)
if layout.mouse:
self.mouse_pos = {}
self.mouse_rel = {}
self.mouse_analog_sensitivity = float(layout.mouse_options.get("MOUSE_SENSITIVITY", 0.3))
self.mouse_analog_deadzone = int(layout.mouse_options.get("MOUSE_DEADZONE", 5))
for name in layout.mouse:
events[ecodes.EV_REL].append(name)
self.mouse_rel[name] = 0.0
self.device = UInput(name=layout.name, events=events,
bustype=layout.bustype, vendor=layout.vendor,
product=layout.product, version=layout.version)
self.layout = layout
def write_event(self, etype, code, value):
last_value = self._write_cache.get(code)
if last_value != value:
self.device.write(etype, code, value)
self._write_cache[code] = value
def emit(self, report):
for name, attr in self.layout.axes.items():
value = getattr(report, attr)
self.write_event(ecodes.EV_ABS, name, value)
for name, attr in self.layout.buttons.items():
attr, modifier = attr
if attr in self.ignored_buttons:
value = False
else:
value = getattr(report, attr)
if modifier and "analog" in attr:
if modifier == "+":
value = value > (128 + A2D_DEADZONE)
elif modifier == "-":
value = value < (128 - A2D_DEADZONE)
self.write_event(ecodes.EV_KEY, name, value)
for name, attr in self.layout.hats.items():
if getattr(report, attr[0]):
value = -1
elif getattr(report, attr[1]):
value = 1
else:
value = 0
self.write_event(ecodes.EV_ABS, name, value)
self.device.syn()
def emit_reset(self):
for name in self.layout.axes:
params = self.layout.axes_options.get(name, DEFAULT_AXIS_OPTIONS)
self.write_event(ecodes.EV_ABS, name, int(sum(params[:2]) / 2))
for name in self.layout.buttons:
self.write_event(ecodes.EV_KEY, name, False)
for name in self.layout.hats:
self.write_event(ecodes.EV_ABS, name, 0)
self.device.syn()
def emit_mouse(self, report):
for name, attr in self.layout.mouse.items():
if attr.startswith("trackpad_touch"):
active_attr = attr[:16] + "active"
if not getattr(report, active_attr):
self.mouse_pos.pop(name, None)
continue
pos = getattr(report, attr)
if name not in self.mouse_pos:
self.mouse_pos[name] = pos
sensitivity = 0.5
self.mouse_rel[name] += (pos - self.mouse_pos[name]) * sensitivity
self.mouse_pos[name] = pos
elif "analog" in attr:
pos = getattr(report, attr)
if (pos > (128 + self.mouse_analog_deadzone)
or pos < (128 - self.mouse_analog_deadzone)):
accel = (pos - 128) / 10
else:
continue
sensitivity = self.mouse_analog_sensitivity
self.mouse_rel[name] += accel * sensitivity
rel = int(self.mouse_rel[name])
self.mouse_rel[name] = self.mouse_rel[name] - rel
self.device.write(ecodes.EV_REL, name, rel)
self.device.syn()
def executaAcao(tecla):
ui = UInput()
print tecla
ui.write(e.EV_KEY, e.ecodes[tecla], 1) #key down
ui.write(e.EV_KEY, e.ecodes[tecla], 0) #key up
ui.syn()
ui.close()
