def run(self):
devices = map(InputDevice, list_devices())
for device in devices:
if device.name == RFID_DEVICE:
dev = InputDevice(device.fn)
try:
dev.grab()
except:
logger.error("Unable to grab InputDevice")
sys.exit(1)
logger.info("Starting the Kiosk Reader daemon...")
while True:
rfid = ""
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
data = categorize(event)
if data.keystate == 1 and data.scancode != 42: # Catch only keydown, and not Enter
if data.scancode == 28:
# We have a RFID tag
logger.info("RFID tag read: %s" % rfid)
url = "https://marmix.ig.he-arc.ch/gelato/w/rfid/%s/%s/" % (KIOSK, rfid)
url_string = "uri " + url
uzblctrl(url_string)
rfid = ""
else:
rfid += SCANCODES[data.scancode]
def run(self):
dev = InputDevice('/dev/input/event2')
print(dev)
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
key_pressed = str(categorize(event))
if ', down' in key_pressed:
print(key_pressed)
if 'KEY_PLAYPAUSE' in key_pressed:
print('play')
sendCommand('p')
if 'KEY_FASTFORWARD' in key_pressed:
print('fastforward')
sendCommand('n')
if 'KEY_NEXTSONG' in key_pressed:
print('skip')
sendCommand('n')
if 'KEY_POWER' in key_pressed:
print('power')
sendCommand('q')
if 'KEY_VOLUMEUP' in key_pressed:
print('volume up')
sendCommand('v%2b')
if 'KEY_VOLUMEDOWN' in key_pressed:
print('volume down')
sendCommand('v-')
if 'KEY_CONFIG' in key_pressed:
print('Random Station')
getRandomStation()
def initiate_gesture_find():
"""
This function will scan all input devices until it finds an
ELAN touchscreen. It will then enter a loop to monitor this device
without blocking its usage by the system.
"""
for device in list_devices():
dev = InputDevice(device)
if (dev.name == 'ELAN Touchscreen') or (dev.name == 'Atmel Atmel maXTouch Digitizer'):
break
codes = dev.capabilities()
Abs_events = {}
for code in codes:
if code == 3:
for type_code in codes[code]:
Abs_events[type_code[0]] = ecodes.ABS[type_code[0]]
MT_event = None
for event in dev.read_loop():
if MT_event:
if MT_event.discard == 1:
MT_event = None
if event.type == ecodes.EV_ABS:
if MT_event is None:
MT_event = TrackedEvent()
event_code = Abs_events[event.code]
if event_code == 'ABS_MT_SLOT':
MT_event.add_finger(event.value)
elif event_code == 'ABS_X' or event_code == 'ABS_Y':
MT_event.position_event(event_code, event.value)
elif event_code == 'ABS_MT_TRACKING_ID':
if event.value == -1:
MT_event.remove_fingers()
else:
MT_event.trackit()
def touchLoop():
dev = InputDevice('/dev/input/event0')
while True:
for event in dev.read_loop():
# match BTN_LEFT DOWN
if event.type == ecodes.EV_KEY and event.value == 1:
demoCycle();
def detectInputKey():
devices = [InputDevice(fn) for fn in list_devices()]
find_dev = False
for dev in devices:
dev_name = dev.name
if "keyboard" in dev_name or "kbd" in dev_name:
find_dev = True
break
if not find_dev:
return
dev = InputDevice(dev.fn)
key = Key()
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
key_event = categorize(event)
timestamp = key_event.event.timestamp()
if 1 in dev.leds():
key.caps_lock = 1
else:
key.caps_lock = 0
if 0 in dev.leds():
key.num_lock = True
try:
ks = ('up', 'down', 'hold')[key_event.keystate]
args = ({"key_code": key_event.scancode}, {"timestamp":timestamp, "key_code": key_event.scancode}, {"key_code": key_event.scancode})[key_event.keystate]
run_func = getattr(key, ks)(**args)
except IndexError:
ks = 'unknown'
def listen_key(result_queue):
seq_map = {"KEY_KPDOT": ".", "KEY_KPPLUS": "+", "KEY_KPMINUS": "-", "KEY_KPCOMMA": ",", "KEY_KPASTERISK": "*", "KEY_KPEQUAL": "=",
"KEY_KPRIGHTPAREN": ")", "KEY_KPLEFTPAREN": "(", "KEY_KPSLASH": "/", "KEY_KPENTER": "\n"}
ecodes_rev = dict((v, k) for k, v in ecodes.ecodes.items())
dev = InputDevice('/dev/input/event0')
print(dev)
sequence = ""
for event in dev.read_loop():
if event.type == ecodes.EV_KEY and event.value == 00:
print event.code
event_code_name = ecodes_rev[event.code]
if event_code_name in [k for k in ecodes.ecodes.keys() if re.match(r"KEY_KP\d", k)]:
sequence += event_code_name.replace("KEY_KP", "")
elif event_code_name in seq_map:
sequence += seq_map[event_code_name]
#if event.code == ecodes.ecodes['']:
# print "============= ENTER ============"
# result_queue.put("stop")
# #sequence +=
print sequence
print categorize(event)
def run(self):
gamepad = InputDevice("/dev/input/event3")
#print(gamepad.capabilities())
print(gamepad)
valuesDirection, valuesSpeed = 0, 0
constantDirection = 255/80
constantSpeed = 255/40
for event in gamepad.read_loop():
if event.type == ecodes.EV_ABS and event.code == 00:
absevent = categorize(event)
if(valuesDirection != int(event.value/constantDirection)):
valuesDirection = int(event.value/constantDirection)
list1 = ["girar",valuesDirection-40]
globalVariables.fila.put(list1)
#print(valuesDirection-40)
elif event.type == ecodes.EV_ABS and event.code == 49:
absevent = categorize(event)
if(valuesSpeed != int(event.value/constantSpeed)):
valuesSpeed = int(event.value/constantSpeed)
list2=["velocidad",valuesSpeed/4]
globalVariables.fila.put(list2)
if event.type == ecodes.EV_KEY:
keyevent = categorize(event)
if keyevent.keystate == KeyEvent.key_down:
if keyevent.keycode == 'BTN_BASE2':
print ("Left")
elif keyevent.keycode == 'BTN_PINKIE':
print ("Right")
elif keyevent.keycode == 'BTN_TOP2':
print ("Forward")
elif keyevent.keycode == 'BTN_BASE':
print ("Backward")
class KeyboardRemote(threading.Thread):
"""This interfaces with the inputdevice using evdev."""
def __init__(self, hass, device_descriptor, key_value):
"""Construct a KeyboardRemote interface object."""
from evdev import InputDevice
self.dev = InputDevice(device_descriptor)
threading.Thread.__init__(self)
self.stopped = threading.Event()
self.hass = hass
self.key_value = key_value
def run(self):
"""Main loop of the KeyboardRemote."""
from evdev import categorize, ecodes
_LOGGER.debug('KeyboardRemote interface started for %s', self.dev)
self.dev.grab()
while not self.stopped.isSet():
event = self.dev.read_one()
if not event:
continue
# pylint: disable=no-member
if event.type is ecodes.EV_KEY and event.value is self.key_value:
_LOGGER.debug(categorize(event))
self.hass.bus.fire(
KEYBOARD_REMOTE_COMMAND_RECEIVED,
{KEY_CODE: event.code}
)
def run (self):
sync = self.SyncQueue.get ()
dev = InputDevice(self.InputDeviceName)
for event in dev.read_loop ():
if event.type == ecodes.EV_KEY:
key = categorize (event)
if ecodes.KEY[ecodes.KEY_ESC] == key.keycode:
self.iRacer.Direction = Direction.Stop
self.iRacer.Speed = Speed.Stop
self.SyncQueue.task_done ()
return
if key.keystate == KeyEvent.key_down or key.keystate == KeyEvent.key_hold:
if ecodes.KEY[ecodes.KEY_UP] == key.keycode:
self.SetDirection (Direction.Forwards)
elif ecodes.KEY[ecodes.KEY_DOWN] == key.keycode:
self.SetDirection (Direction.Backwards)
elif ecodes.KEY[ecodes.KEY_LEFT] == key.keycode:
self.SetDirection (Direction.Left)
elif ecodes.KEY[ecodes.KEY_RIGHT] == key.keycode:
self.SetDirection (Direction.Right)
elif key.keystate == KeyEvent.key_up:
if ecodes.KEY[ecodes.KEY_UP] == key.keycode or ecodes.KEY[ecodes.KEY_DOWN] == key.keycode:
self.iRacer.Accelerating = False
elif ecodes.KEY[ecodes.KEY_LEFT] == key.keycode or ecodes.KEY[ecodes.KEY_RIGHT] == key.keycode:
self.iRacer.Straighten ()
def evdev_live_monitor(eventdev):
'''evdev: monitor all keypresses from device live'''
dev = InputDevice('/dev/input/' + eventdev)
print(dev)
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
print(categorize(event))
def register_handler(self, handler):
if handler.device_fn in self.devices_by_fn:
device = self.devices_by_fn[handler.device_fn]
else:
device = InputDevice(handler.device_fn)
self.devices_by_fn[handler.device_fn] = device
self.devices_by_fd[device.fd] = device
self.handlers_by_fd[device.fd] = set()
# Check if device has needed event
capabilities = device.capabilities()
if handler.event_type in capabilities:
for event_code in handler.event_codes:
if event_code in capabilities[handler.event_type]:
self.handlers_by_fd[device.fd].add(handler)
else:
logger.warning('Event {0} not found in input device "{1}"'.format(
ecodes.bytype[handler.event_type][handler.event_code], device.name))
return False
else:
logger.warning(
'Input device "{1}" has no capability {0}'.format(ecodes.EV[handler.event_type], device.name))
return False
return True
def event_stream(deadzone=0,scale=32768):
#_data = None
old_value=None
x=0
#Start up xboxdrv driver
subprocess = os.popen('sudo xboxdrv -d -D -v --dbus session','r',65536)
time.sleep(2)
#Get the xbox controller as a device
devicesNow = glob.glob('/dev/input/event*')
found = False
for dev in devicesNow:
device = InputDevice(dev)
if 'Xbox' in device.name:
print 'Found:',device.name,'on',dev
found = True;
break
if not found:
print 'XBOX READ ERROR: could not find xbox controller'
return
time.sleep(1)
#Setup for evdev
while True:
line = subprocess.readline()
# Turn off controller status light if controller is disconnected
if 'failed' in line:
raise ValueError(line)
#Run loop for each new evdev event
for evdev_event in device.read_loop():
value = None
#Convert evdev event code into xbox key
key=code2key(evdev_event.code)
#Special condition for X1 because it sends every other value as 0
if evdev_event.code == 0:
if evdev_event.value != 0:
value = apply_deadzone(evdev_event.value,deadzone,scale)
#Special conditions for joysticks
elif evdev_event.code == 1 or evdev_event.code == 3 or evdev_event.code == 4:
value = apply_deadzone(evdev_event.value,deadzone,scale)
#Special conditions for RT and LT
elif evdev_event.code == 9 or evdev_event.code == 10:
#Adds trigger deadzone of 125 (out of 255)
if evdev_event.value >= 125:
value=1
else:
value=0
else:
value=evdev_event.value
#Returns event data if different
if value != None:
event = Event(key,value,old_value)
#print(value)
yield event
old_value = value
def setup_keyboard():
dev = InputDevice('/dev/input/event1')
print(dev)
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
print(categorize(event).keycode)
tiny_screen.oled_putString(decode(categorize(event)))
class HidrawDS4Device(DS4Device):
def __init__(self, name, addr, type, hidraw_device, event_device):
try:
self.report_fd = os.open(hidraw_device, os.O_RDWR | os.O_NONBLOCK)
self.fd = FileIO(self.report_fd, "rb+", closefd=False)
self.input_device = InputDevice(event_device)
self.input_device.grab()
except (OSError, IOError) as err:
raise DeviceError(err)
self.buf = bytearray(self.report_size)
super(HidrawDS4Device, self).__init__(name, addr, type)
def read_report(self):
try:
ret = self.fd.readinto(self.buf)
except IOError:
return
# Disconnection
if ret == 0:
return
# Invalid report size or id, just ignore it
if ret < self.report_size or self.buf[0] != self.valid_report_id:
return False
if self.type == "bluetooth":
# Cut off bluetooth data
buf = zero_copy_slice(self.buf, 2)
else:
buf = self.buf
return self.parse_report(buf)
def read_feature_report(self, report_id, size):
op = HIDIOCGFEATURE(size + 1)
buf = bytearray(size + 1)
buf[0] = report_id
return fcntl.ioctl(self.fd, op, bytes(buf))
def write_report(self, report_id, data):
if self.type == "bluetooth":
# TODO: Add a check for a kernel that supports writing
# output reports when such a kernel has been released.
return
hid = bytearray((report_id,))
self.fd.write(hid + data)
def close(self):
try:
self.fd.close()
self.input_device.ungrab()
except IOError:
pass
class InputDevice(InputSkeleton):
""" A driver for HID devices. As for now, supports keyboards and numpads."""
def __init__(self, path=None, name=None, **kwargs):
"""Initialises the ``InputDevice`` object.
Kwargs:
* ``path``: path to the input device. If not specified, you need to specify ``name``.
* ``name``: input device name
"""
if not name and not path: #No necessary arguments supplied
raise TypeError("Expected at least path or name; got nothing. =(")
if not path:
path = get_path_by_name(name)
if not name:
name = get_name_by_path(path)
if not name and not path: #Seems like nothing was found by get_input_devices
raise IOError("Device not found")
self.path = path
self.name = name
self.init_hw()
InputSkeleton.__init__(self, mapping = [], **kwargs)
def init_hw(self):
try:
self.device = HID(self.path)
except OSError:
print("Failed HID")
return False
else:
self.device.grab() #Can throw exception if already grabbed
return True
def runner(self):
"""Blocking event loop which just calls supplied callbacks in the keymap."""
try:
while not self.stop_flag:
event = self.device.read_one()
if event is not None and event.type == ecodes.EV_KEY:
key = ecodes.keys[event.code]
value = event.value
if value == 0 and self.enabled:
self.send_key(key)
sleep(0.01)
except IOError as e:
if e.errno == 11:
#raise #Uncomment only if you have nothing better to do - error seems to appear at random
pass
def atexit(self):
InputSkeleton.atexit(self)
try:
self.device.ungrab()
except:
pass
def premain(argparser):
signal.signal(signal.SIGINT, SigHandler_SIGINT)
#here
devices = [evdev.InputDevice(path) for path in evdev.list_devices()]
for device in devices:
print(device.path, device.name, device.phys)
dev = InputDevice("/dev/input/event6")
for event in dev.read_loop():
print(categorize(event))
class HidrawDS4Device(DS4Device):
def __init__(self, name, addr, type, hidraw_device, event_device):
try:
self.fd = open(hidraw_device, "rb+", 0)
self.input_device = InputDevice(event_device)
self.input_device.grab()
except (OSError, IOError) as err:
raise DeviceError(err)
self.buf = bytearray(self.report_size)
super(HidrawDS4Device, self).__init__(name, addr, type)
def read_report(self):
ret = self.fd.readinto(self.buf)
# Disconnection
if ret == 0:
return
# Invalid report size, just ignore it
if ret < self.report_size:
return False
buf = self.get_trimmed_report_data()
return self.parse_report(buf)
def read_feature_report(self, report_id, size):
op = HIDIOCGFEATURE(size + 1)
buf = bytearray(size + 1)
buf[0] = report_id
return fcntl.ioctl(self.fd, op, bytes(buf))
def get_trimmed_report_data(self):
raise NotImplementedError
def write_report(self, report_id, data):
if self.type == "bluetooth":
# TODO: Add a check for a kernel that supports writing
# output reports when such a kernel has been released.
return
hid = bytearray((report_id,))
self.fd.write(hid + data)
def close(self):
try:
self.fd.close()
self.input_device.ungrab()
except IOError:
pass
@property
def report_size(self):
raise NotImplementedError
def detectInputKey():
dev = InputDevice('/dev/input/event1')
print(dev)
# while True:
# select([dev], [], [])
# for event in dev.read():
# print "code: %s value: %s" %(event.code, event.value)
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
print(categorize(event))
def detect_input_from_event(self, eventName):
dev = InputDevice("/dev/input/" + eventName)
while True:
select([dev], [], [])
for event in dev.read():
if (event.value == 1 or event.value == 0) and event.code != 0:
if event.value == 1:
self.sp.play(event.code)
self.check_show_window(event.code)
logger.debug("Key: %s Status: %s" % (event.code, "pressed" if event.value else "release"))
def initiate_gesture_find(use_pymouse=False, long_press_workaround=False):
"""
This function will scan all input devices until it finds an
ELAN touchscreen. It will then enter a loop to monitor this device
without blocking its usage by the system.
"""
for device in list_devices():
dev = InputDevice(device)
if (dev.name == 'ELAN Touchscreen') or \
(dev.name == 'Atmel Atmel maXTouch Digitizer'):
break
Abs_events = {}
abilities = {ecodes.EV_ABS: [ecodes.ABS_X, ecodes.ABS_Y],
ecodes.EV_KEY: (ecodes.BTN_LEFT, ecodes.BTN_RIGHT,
ecodes.BTN_TOUCH)}
# Assuming QHD screen on my Yoga 2 Pro as default for resolution measures
res_x = 13 # touch unit resolution # units/mm in x direction
res_y = 13 # touch unit resolution # units/mm in y direction
# would be weird if above resolutions differed, but will treat generically
codes = dev.capabilities()
for code in codes:
if code == 3:
for type_code in codes[code]:
human_code = ecodes.ABS[type_code[0]]
if human_code == 'ABS_X':
vals = type_code[1]
abilities[ecodes.EV_ABS][0] = (ecodes.ABS_X, vals)
res_x = vals[-1]
elif human_code == 'ABS_Y':
vals = type_code[1]
abilities[ecodes.EV_ABS][1] = (ecodes.ABS_Y, vals)
res_y = vals[-1]
Abs_events[type_code[0]] = human_code
# Average index finger width is 16-20 mm, assume 20 mm
# touch resolution noise assumed at 10% (5% radius), so 1.0 mm by default
# this seemed resonable from my own trial tests
var_x = 1.0 * res_x # variablity in movement allowed in x direction
var_y = 1.0 * res_y # variablity in movement allowed in y direction
MT_event = None
for event in dev.read_loop():
if event.type == ecodes.EV_ABS:
if MT_event is None:
MT_event = TrackedEvent(dev, abilities, var_x, var_y,
use_pymouse, long_press_workaround)
event_code = Abs_events[event.code]
if event_code == 'ABS_X' or event_code == 'ABS_Y':
MT_event.position_event(event_code, event.value)
elif event_code == 'ABS_MT_TRACKING_ID':
if event.value == -1:
MT_event.remove_fingers()
if MT_event.discard == 1:
MT_event = None
else:
MT_event.add_finger()
def getKeyboards():
keyboard_list = []
for device in list_devices():
dev = InputDevice(device)
result = str(dev.capabilities(verbose=True)).find('KEY_F1')
if result != -1:
#print(device + " é um Teclado")
keyboard_list.append(device)
return keyboard_list
def getMouses():
mouseList = []
for device in list_devices():
dev = InputDevice(device)
result = str(dev.capabilities(verbose=True)).find('BTN_MOUSE')
if result != -1:
#print(device + " é um Mouse")
mouseList.append(device)
return mouseList
def test(self):
""" Test if event device exists, is readable and has capability of
reading a keypress.
"""
if not os.access(self.path, os.R_OK | os.W_OK):
raise EvdevScannerTestError('Cannot access {}'.format(self.path))
# Check for EV_KEY capability
inputdev = InputDevice(self.path)
if 1 not in inputdev.capabilities():
raise EvdevScannerTestError('Device has no EV_KEY capability')
inputdev.close()
def get_tilt(self):
dev = InputDevice('/dev/input/event0')
cap = dev.capabilities()
axis_x = cap[3][0][1][0]
axis_y = cap[3][1][1][0]
axis_z = cap[3][2][1][0]
if abs(16384-math.sqrt(axis_x**2 + axis_y**2 + axis_z**2)) > 800:
raise Exception('Too much acceleration for accurate tilt reading')
return math.degrees(
math.atan2(math.sqrt(axis_y**2 + axis_z**2), abs(axis_x)))
def startKeylistener(): global logger dev = InputDevice(findKeyboard()) for event in dev.read_loop(): if logger: if event.type == ecodes.EV_KEY: temp = categorize(event) if temp.keystate == 1: key_lookup = scancodes.get(temp.scancode) sendMessage(format(key_lookup)) else: thread.exit()
def init_hardware(self):
path_dir = '/dev/input/by-path/'
paths = (
path_dir + 'platform-20980000.usb-usb-0:1.2:1.0-event-kbd',
path_dir + 'platform-20980000.usb-usb-0:1.2:1.1-event-mouse',
path_dir + 'platform-20980000.usb-usb-0:1.4:1.0-event-kbd',
path_dir + 'platform-20980000.usb-usb-0:1.4:1.1-event-mouse')
for path in paths:
i = InputDevice(path)
i.grab()
self.selector.register(i,EVENT_READ)
def detectInputKey(fname):
device_input = "/dev/input/%s"%fname
print "listening: %s" %device_input
dev = InputDevice(device_input)
checksum = 0
global g_distance;
while True:
select([dev], [], [])
for event in dev.read():
checksum = (checksum + 1)%2
key_code = event.code
key_value = event.value
print "code:%s value:%s" % (event.code, event.value)
if key_code == 5:
if key_value >= 0 and key_value < 1:
print "move up"
elif key_value > 254 and key_value <= 255:
print "move down"
if key_code == 2:
if key_value >= 0 and key_value < 1:
print "move left"
os.system("./control -l B,0,-%d,0" %g_distance);
elif key_value > 254 and key_value <= 255:
print "move right"
os.system("./control -l B,0,%d,0"%g_distance);
if key_code == 304:
if key_value >= 1:
print "speed up"
os.system("./control -l v,-5");
if key_code == 305:
if key_value >= 1:
print "speed down"
os.system("./control -l v,5");
if key_code == 307:
if key_value >= 1:
print "distance longer: now %d" %g_distance
g_distance += 5
if g_distance > 1000:
g_distance = 1000
if key_code == 308:
if key_value >= 1:
print "distance shorter: now %d" %g_distance
g_distance -= 5
if g_distance < 0:
g_distance = 0
def init(dev):
if str(dev) == 'None':
print "Device not found"
sys.exit(1)
try:
device = InputDevice(dev.fn)
device.grab()
except:
print "Unable to grab input device"
sys.exit(1)
return device
def main():
PATH = '/dev/input/by-path/platform-i8042-serio-1-event-mouse'
dev = InputDevice(PATH)
x, y, r, a = None, None, None, None
pressure = 0
prev_a = None
difference = 0 # interstep difference to be compensated later
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
if event.code == ecodes.BTN_LEFT and event.value:
if not r is None:
if r > R_CORNER:
if -pi < a < -pi/2: pitch_bend(4, 2)
if pi/2 < a < pi: pitch_bend(5, 2)
if -pi/2 < a < 0: pitch_bend(6, 2)
if 0 < a < pi/2: pitch_bend(7, 2)
else:
pitch_bend(8, 2)
else:
pitch_bend(9, 2)
if event.type == ecodes.EV_ABS:
if event.code in (ecodes.ABS_X, ecodes.ABS_Y, ecodes.ABS_PRESSURE):
if event.code == ecodes.ABS_PRESSURE:
if event.value > 0 and not pressure and not r is None:
if r > R_CORNER:
if -pi < a < -pi/2: pitch_bend(0, 2)
if pi/2 < a < pi: pitch_bend(1, 2)
if -pi/2 < a < 0: pitch_bend(2, 2)
if 0 < a < pi/2: pitch_bend(3, 2)
pressure = event.value
if not pressure:
prev_a = x = y = r = a = None
if r <= R_CORNER:
pitch_bend(int(max(0, pressure - 32)), 1)
continue
if event.code == ecodes.ABS_X: x = event.value - X_CENTER
if event.code == ecodes.ABS_Y: y = event.value - Y_CENTER
if (x is None or y is None): continue
r = sqrt(x*x + y*y)
a = atan2(x, y)
if not prev_a is None and r <= R_CORNER:
da = a - prev_a
if da > pi: da -= pi * 2
if da < -pi: da += pi * 2
z = -da * 45 * 10 + difference
w = int(z); w = min(max(w, -0x40), 0x40)
difference = z - w;
if abs(difference) < 0.25: difference = 0
pitch_bend(w, 0)
if (r > R_CORNER): pitch_bend(0, 0)
prev_a = a if pressure else None
class DedicatedKB(bpy.types.Operator):
'''Command Blender with a dedicated keyboard'''
bl_idname = "addkeyboard.modal_timer_operator"
bl_label = "DedicatedKB"
_timer = None
def modal(self, context, event):
global last_event
if event.type == 'ESC':
return self.cancel(context)
if event.type == 'TIMER':
r, w, e = select([self.device], [], [], 0) # the last 0 arg is for non-blocking
for i in range (0,3): #each keystroke produces 3 lines
ev = self.device.read_one()
if str(ev) == "None" : break
elif ev.type == 1 and ev.value == 1:
print(ev.code)
try:
last_event = ev.code
tab_exec = dedikb_list[ev.code].split(".")
print (context.space_data)
if tab_exec[2] == 'screen':
print('screen')
#override = {'window': window, 'screen': screen, 'area': area}
exec(dedikb_list[ev.code])
except:
print ("Oops")
return {'PASS_THROUGH'}
def execute(self, context):
self.device = InputDevice(bpy.context.scene.input_dev)
try:
self.device.grab()
except:
pass
InputDeviceDispatcher(self.device)
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(.1, context.window)
print('reading events')
global op_run
op_run = 1
return {'RUNNING_MODAL'}
def cancel(self, context):
context.window_manager.event_timer_remove(self._timer)
print('reading stopped')
return {'CANCELLED'}
from threading import Timer, Thread
from time import sleep
from evdev import InputDevice, categorize, ecodes
import pygame
FPS = 60
pygame.init()
pygame.mixer.quit()
clock = pygame.time.Clock()
if os.path.islink('/dev/input/by-id/usb-JoyLabz_Makey_Makey_v1.20aa_60000000-event-kbd'):
dev = InputDevice('/dev/input/by-id/usb-JoyLabz_Makey_Makey_v1.20aa_60000000-event-kbd')
elif os.path.islink('/dev/input/by-id/usb-JoyLabz_Makey_Makey_v1.20aa_60000000-if01-event-mouse'):
dev = InputDevice('/dev/input/by-id/usb-JoyLabz_Makey_Makey_v1.20aa_60000000-if01-event-mouse')
else:
print "No MakeyMakey/Arduino Leonardo found:-("
sys.exit(1)
inoteMap = {
ecodes.KEY_RIGHT: 'R1',
ecodes.KEY_LEFT: 'R2',
ecodes.KEY_UP: 'R3',
ecodes.KEY_DOWN: 'R4',
ecodes.KEY_SPACE: 'GO'
}
from evdev import InputDevice, categorize, ecodes
controller = InputDevice('/dev/input/event0')
print(controller)
def readInput():
events = controller.read()
try:
for event in events:
print(event)
except IOError:
pass
#return state
while (True):
readInput()
def Controller(pub, v, rate):
global autonomous
gamepad = InputDevice('/dev/input/event17')
for event in gamepad.read_loop():
if event.code == 04:
if event.value == 589834:
autonomous = True
break
elif event.value == 589833:
autonomous = False
v.leftwheel=v.rightwheel=0;
break
elif event.code == 17:
if event.value == -1:
v.leftwheel=v.rightwheel=24 # Forward
v.Check = 0
print (v)
break
if event.value == 1:
v.leftwheel=v.rightwheel=-24
v.Check = 0 # Backward
print (v)
break
elif event.code == 16:
if event.value == -1:
v.leftwheel=-24
v.rightwheel=24 #left
v.Check = 0
print (v)
break
if event.value == 1:
v.leftwheel=24
v.rightwheel=-24 #right
v.Check = 0
print (v)
break
elif event.value == 0:
v.leftwheel = v.rightwheel = 0
v.Check = 0
print (v)
break
else:
v.leftwheel=v.rightwheel = 0
v.Check=0
print(v)
break
pub.publish(v)
rate.sleep()
spec = importlib.util.spec_from_file_location("main_config", parsed_args.config_file)
main_config = importlib.util.module_from_spec(spec)
spec.loader.exec_module(main_config)
else:
import main_config
modeAwesome = main_config.main_mode
capup = False
powermode = False
awesomemode = True
key_states = {}
special_key = {}
print("grabbing and listening device /dev/input/event" + parsed_args.input_id)
dev = InputDevice('/dev/input/event' + parsed_args.input_id)
ui = UInput()
dev.grab()
def up_all_keys():
for key, is_kup in key_states.items():
if is_kup:
ui.write(e.EV_KEY, e.ecodes[key], 0)
ui.syn()
# TODO: should be encapsulated by a 'resolver'
for event in dev.read_loop():
if event.type == e.EV_KEY:
if parsed_args.debug:
print("event keycode",categorize(event).keycode)
kevent = categorize(event)
def __init__(self, config, inputdevice):
self.config = config
self.input_device = InputDevice(inputdevice)
import evdev
from evdev import InputDevice
import os
MOD_FILE = "/dev/input/by-id/usb-C-Media_Electronics_Inc._USB_Audio_Device-event-if03"
SH_VOLUME_DEC = """
CUR_VOL=$(amixer get Speaker | grep -E -o '[%[0-9]{1,3}%]' | head -1 | grep -E -o '[0-9]{1,3}')
let NEW_VOL=$CUR_VOL-5
amixer set 'Speaker' "$NEW_VOL%" > /dev/zero
"""
SH_VOLUME_INC = """
CUR_VOL=$(amixer get Speaker | grep -E -o '[%[0-9]{1,3}%]' | head -1 | grep -E -o '[0-9]{1,3}')
let NEW_VOL=$CUR_VOL+5
amixer set 'Speaker' "$NEW_VOL%" > /dev/zero
"""
head_set = InputDevice(MOD_FILE)
for evt in head_set.read_loop():
if evt.value == 1:
if evt.code == 114:
os.system(SH_VOLUME_DEC)
pass
elif evt.code == 115:
os.system(SH_VOLUME_INC)
pass
print(SH_VOLUME_INC)
def main():
ReStart()
# creates object gamepad
gamepad = InputDevice('/dev/input/event1')
# prints out device info at start
print(gamepad)
# define codes of the remote controllers
# Ground Movement
global lastcomm
lastcomm = 0
global climbmode
climbmode = 0
frwdBtn = 544
bkwdBtn = 545
lftBtn = 546
rgtBtn = 547
lBtn = 292
rBtn = 293
selBtn = 314
startBtn = 315
oBtn = 305
squareBtn = 308
triangleBtn = 307
xBtn = 304
L1btn = 310
R1btn = 311
# display codes
for event in gamepad.read_loop():
#Boutons | buttons
if event.type == ecodes.EV_KEY:
#print(event)
if event.value == 1:
if event.code == frwdBtn:
if climbmode == 0:
print("Forward")
moveforward()
elif climbmode == 1:
print("Climb Upward")
climbUpward()
continue
elif event.code == bkwdBtn:
if climbmode == 0:
print("Backward")
movebackward()
elif climbmode == 1:
print("Climb Downward")
climbDownward()
continue
elif event.code == lftBtn:
if climbmode == 0:
print("move left")
turnleft()
elif climbmode == 1:
print("climb Up Stroke")
climbUpStroke()
continue
elif event.code == rgtBtn:
if climbmode == 0:
print("move right")
turnright()
elif climbmode == 1:
print("climb Down Stroke")
climbDownStroke()
continue
elif event.code == triangleBtn:
if climbmode == 0:
### need something here
print("front leg forward")
frontlegforward()
elif climbmode == 1:
print("Front Leg Climb Up")
frontlegclimbup()
continue
elif event.code == squareBtn:
if climbmode == 0:
### need something here
print("front leg backward")
frontlegbackward()
elif climbmode == 1:
print("front leg climb down")
frontlegclimbdown()
continue
elif event.code == oBtn:
if climbmode == 0:
### need something here
print("rear leg forward")
rearlegforward()
elif climbmode == 1:
print("Rear Leg Climb Up")
rearlegclimbup()
continue
elif event.code == xBtn:
if climbmode == 0:
### need something here
print("rear leg backward")
rearlegbackward()
elif climbmode == 1:
print("rear leg climb down")
rearlegclimbdown()
continue
elif event.code == L1btn:
if kit.servo[1].angle >= 0 and kit.servo[
1].angle <= 170 and kit.servo[
3].angle >= 10 and kit.servo[3].angle <= 180:
print("1:" + str(kit.servo[1].angle + 10))
kit.servo[1].angle = kit.servo[1].angle + 10
print("3:" + str(kit.servo[3].angle - 10))
kit.servo[3].angle = kit.servo[3].angle - 10
pass
elif event.code == R1btn:
if kit.servo[7].angle >= 0 and kit.servo[
7].angle <= 170 and kit.servo[
5].angle >= 10 and kit.servo[5].angle <= 180:
kit.servo[5].angle = kit.servo[5].angle - 10
kit.servo[7].angle = kit.servo[7].angle + 10
pass
elif event.code == selBtn:
print("Select")
climbMode()
elif event.code == startBtn:
print("ReStart")
ReStart()
elif event.value == 0:
print("Release")
# Analog gamepad
elif event.type == ecodes.EV_ABS:
absevent = categorize(event)
#print ecodes.bytype[absevent.event.type][absevent.event.code], absevent.event.value
if ecodes.bytype[absevent.event.type][
absevent.event.code] == "ABS_Z": #L2
print("L1btn: Release the Front Grip")
kit.servo[1].angle = 30
kit.servo[3].angle = 150
elif ecodes.bytype[absevent.event.type][
absevent.event.code] == "ABS_RZ": #R2
print("R1btn: Release the Rear Grip")
kit.servo[5].angle = 150
kit.servo[7].angle = 30
# Incremental Spine Movement
elif ecodes.bytype[absevent.event.type][
absevent.event.code] == "ABS_X":
if absevent.event.value < 127:
tempangle = kit.servo[8].angle + 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[8].angle = tempangle
elif absevent.event.value > 127:
tempangle = kit.servo[8].angle - 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[8].angle = tempangle
elif absevent.event.value == 127:
print("Hold position")
pass
elif ecodes.bytype[absevent.event.type][
absevent.event.code] == "ABS_Y":
if absevent.event.value < 127:
tempangle = kit.servo[10].angle - 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[10].angle = tempangle
elif absevent.event.value > 127:
tempangle = kit.servo[10].angle + 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[10].angle = tempangle
elif absevent.event.value == 127:
print("Hold position")
pass
elif ecodes.bytype[absevent.event.type][
absevent.event.code] == "ABS_RX":
if absevent.event.value < 127:
tempangle = kit.servo[9].angle - 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[9].angle = tempangle
elif absevent.event.value > 127:
tempangle = kit.servo[9].angle + 5
if tempangle >= 0 and tempangle <= 180:
kit.servo[9].angle = tempangle
elif absevent.event.value == 127:
print("Hold position")
pass
pass
class EvTouch(object):
_logger = logging.getLogger('ev_touch')
_DEV_NAME = 'Qni Multitouch'
def __init__(self, is_tx=False):
mt_capabilities = {
ecodes.EV_ABS: [
(ecodes.ABS_MT_POSITION_X, (0, 0)),
(ecodes.ABS_MT_POSITION_Y, (0, 0)),
]
}
if is_tx:
self._mt_dev = UInput(mt_capabilities, self._DEV_NAME)
self.update = self._send
self._logger.info('Created %s device!', self._DEV_NAME)
else:
self._mt_dev = None
self._mt_x = None
self._mt_y = None
self._mt_points = []
self._reopen_mt_dev()
self.update = self._recv
def _reopen_mt_dev(self):
if self._mt_dev is not None:
self._mt_x = self._mt_y = None
self._mt_points.clear()
self._logger.warning('Reconnecting %s device..', self._DEV_NAME)
for i in list_devices():
self._mt_dev = InputDevice(i)
if self._mt_dev.name == self._DEV_NAME:
self._logger.info('Connected to %s device!', self._DEV_NAME)
return True
self._mt_dev.close()
self._mt_dev = None
return False
def _send(self, mt_points):
for i in mt_points:
self._mt_dev.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_X, i[0])
self._mt_dev.write(ecodes.EV_ABS, ecodes.ABS_MT_POSITION_Y, i[1])
self._mt_dev.write(ecodes.EV_SYN, ecodes.SYN_MT_REPORT, 0)
if not mt_points:
self._mt_dev.write(ecodes.EV_SYN, ecodes.SYN_MT_REPORT, 0)
self._mt_dev.syn()
def _recv(self):
mt_points = None
try:
events = list(self._mt_dev.read())
except BlockingIOError:
pass
except (OSError, AttributeError):
self._reopen_mt_dev()
else:
for event in events:
if event.type == ecodes.EV_ABS:
if event.code == ecodes.ABS_MT_POSITION_X:
self._mt_x = event.value
elif event.code == ecodes.ABS_MT_POSITION_Y:
self._mt_y = event.value
elif event.type == ecodes.EV_SYN:
if event.code == ecodes.SYN_MT_REPORT:
if (self._mt_x or self._mt_y) is not None:
self._mt_points.append((self._mt_x, self._mt_y))
elif event.code == ecodes.SYN_REPORT:
mt_points = self._mt_points.copy()
self._mt_x = self._mt_y = None
self._mt_points.clear()
return mt_points
def __exit__(self):
self._mt_dev.close()
from evdev import InputDevice, categorize, ecodes
#creates object 'gamepad' to store the data
#you can call it whatever you like
gamepad0 = InputDevice('/dev/input/event4')
gamepad1 = InputDevice('/dev/input/event5')
gamepad2 = InputDevice('/dev/input/event6')
gamepad3 = InputDevice('/dev/input/event7')
gamepad4 = InputDevice('/dev/input/event8')
#prints out device info at start
print(gamepad0)
print(gamepad1)
print(gamepad2)
print(gamepad3)
print(gamepad4)
#evdev takes care of polling the controller in a loop
for event in gamepad4.read_loop():
print(event.code, event.value)
def listen_rfid(self):
global pin
global accessLogId
keys = "X^1234567890XXXXqwertzuiopXXXXasdfghjklXXXXXyxcvbnmXXXXXXXXXXXXXXXXXXXXXXX"
dev = InputDevice('/dev/input/event0')
rfid_presented = ""
while True:
r,w,x = select([dev], [], [])
for event in dev.read():
if event.type==1 and event.value==1:
if event.code==28:
dbConnection = MySQLdb.connect(host=dbHost, user=dbUser, passwd=dbPass, db=dbName)
cur = dbConnection.cursor(MySQLdb.cursors.DictCursor)
cur.execute("SELECT * FROM access_list WHERE rfid_code = '%s'" % (rfid_presented))
if cur.rowcount != 1:
self.welcomeLabel.config(text="ACCESS DENIED")
# Log access attempt
cur.execute("INSERT INTO access_log SET rfid_presented = '%s', rfid_presented_datetime = NOW(), rfid_granted = 0" % (rfid_presented))
dbConnection.commit()
time.sleep(3)
self.welcomeLabel.grid_forget
self.show_idle()
else:
user_info = cur.fetchone()
userPin = user_info['pin']
self.welcomeLabel.grid_forget()
self.validUser = ttk.Label(self.tk, text="Welcome\n %s" % (user_info['name']), font='size, 15', justify='center', anchor='center')
self.validUser.grid(columnspan=3, sticky=tk.W+tk.E)
self.image = tk.PhotoImage(file=user_info['image'] + ".gif")
self.photoLabel = ttk.Label(self.tk, image=self.image)
self.photoLabel.grid(columnspan=3)
self.enterPINlabel = ttk.Label(self.tk, text="Please enter your PIN:", font='size, 18', justify='center', anchor='center')
self.enterPINlabel.grid(columnspan=3, sticky=tk.W+tk.E)
pin = ''
keypad = [
'1', '2', '3',
'4', '5', '6',
'7', '8', '9',
'*', '0', '#',
]
# create and position all buttons with a for-loop
# r, c used for row, column grid values
r = 4
c = 0
n = 0
# list(range()) needed for Python3
self.btn = list(range(len(keypad)))
for label in keypad:
# partial takes care of function and argument
#cmd = partial(click, label)
# create the button
self.btn[n] = tk.Button(self.tk, text=label, font='size, 18', width=4, height=1, command=lambda digitPressed=label:self.codeInput(digitPressed, userPin))
# position the button
self.btn[n].grid(row=r, column=c, ipadx=10, ipady=10)
# increment button index
n += 1
# update row/column position
c += 1
if c > 2:
c = 0
r += 1
# Log access attempt
cur.execute("INSERT INTO access_log SET rfid_presented = '%s', rfid_presented_datetime = NOW(), rfid_granted = 1" % (rfid_presented))
dbConnection.commit()
accessLogId = cur.lastrowid
self.PINentrytimeout = threading.Timer(10, self.returnToIdle_fromPINentry)
self.PINentrytimeout.start()
self.PINenteredtimeout = threading.Timer(5, self.returnToIdle_fromPINentered)
rfid_presented = ""
dbConnection.close()
else:
rfid_presented += keys[ event.code ]
def get_devices_from_paths(device_paths):
return [InputDevice(device_fn) for device_fn in device_paths]
ROUGE = [255, 0, 0]
VERT = [0, 255, 0]
FGC = WHITE
BGC = BLACK
print("Press Ctrl-C to quit")
time.sleep(1)
x=0; y=0;
enter = 0
sense = SenseHat()
sense.clear() # Blank the LED matrix
sense.low_light = True
found = False;
devices = [InputDevice(fn) for fn in list_devices()]
for dev in devices:
if dev.name == 'Raspberry Pi Sense HAT Joystick':
found = True;
break
if not(found):
print('Raspberry Pi Sense HAT Joystick not found. Aborting ...')
sys.exit()
# 0, 0 = Top left
# 7, 7 = Bottom right
UP_PIXELS = [[3, 0], [4, 0]]
DOWN_PIXELS = [[3, 7], [4, 7]]
LEFT_PIXELS = [[0, 3], [0, 4]]
RIGHT_PIXELS = [[7, 3], [7, 4]]
def get_devices_list():
return [InputDevice(device_fn) for device_fn in reversed(list_devices())]
from evdev import InputDevice, categorize, ecodes, KeyEvent
gamepad = InputDevice('/dev/input/event5')
for event in gamepad.read_loop():
event_r = str(event)
if (not ("code 00" in event_r) and not ("code 04" in event_r)
and not ("code 01" in event_r) and not ("code 03" in event_r)):
print(event_r)
class HidrawDS4Device(DS4Device):
def __init__(self, name, addr, type, hidraw_device, event_device):
try:
self.report_fd = os.open(hidraw_device, os.O_RDWR | os.O_NONBLOCK)
self.fd = FileIO(self.report_fd, "rb+", closefd=False)
self.input_device = InputDevice(event_device)
self.input_device.grab()
except (OSError, IOError) as err:
raise DeviceError(err)
self.buf = bytearray(self.report_size)
super(HidrawDS4Device, self).__init__(name, addr, type)
def read_report(self):
try:
ret = self.fd.readinto(self.buf)
except IOError:
return
# Disconnection
if ret == 0:
return
# Invalid report size or id, just ignore it
if ret < self.report_size or self.buf[0] != self.valid_report_id:
return False
if self.type == "bluetooth":
# Cut off bluetooth data
buf = zero_copy_slice(self.buf, 2)
else:
buf = self.buf
return self.parse_report(buf)
def read_feature_report(self, report_id, size):
op = HIDIOCGFEATURE(size + 1)
buf = bytearray(size + 1)
buf[0] = report_id
return fcntl.ioctl(self.fd, op, bytes(buf))
def write_report(self, report_id, report):
"""
Send a feature report.
"""
tmp = [0] * 79
tmp[:7] = [0xa2, 0x11, 0xC0, 0x00, 0xff, 0x00, 0x00]
tmp[7] = report[5] #rumble weak
tmp[8] = report[6] #rumble strong
tmp[9] = report[7] #red
tmp[10] = report[8] #green
tmp[11] = report[9] #blue
tmp[12] = report[10] # Time to flash bright (255 = 2.5 seconds)
tmp[13] = report[11] # Time to flash dim (255 = 2.5 seconds)
buf = bytearray(tmp)
crc = zlib.crc32(bytes(buf[:(len(buf) - 4)])) & 0xffffffff
buf[len(buf) - 4] = chr(crc & 0xFF)
buf[len(buf) - 3] = chr((crc & 0xFF00) >> 8)
buf[len(buf) - 2] = chr((crc & 0xFF0000) >> 16)
buf[len(buf) - 1] = chr((crc & 0xFF000000) >> 24)
self.fd.write(buf[1:])
def close(self):
try:
# Reset LED to original hidraw pairing colour.
self.set_led(0, 0, 1)
self.fd.close()
self.input_device.ungrab()
except IOError:
pass
def get_devices():
return [InputDevice(fn) for fn in list_devices()]
# if ref_pixel[2] > 160 and ref_pixel[0] <30 and ref_pixel[1] <30:
# convert_img[i][j] = DEBUG
# imsave(OUTPUT_PATH + '%06d' % frame + '_seg.png', convert_img)
return convert_img
# ==============================================================================
# -- main() --------------------------------------------------------------------
# ==============================================================================
if __name__ == '__main__':
import time
# force feedback
import evdev
from evdev import ecodes, InputDevice
device = evdev.list_devices()[0]
evtdev = InputDevice(device)
val = 25000 #[0,65535]
evtdev.write(ecodes.EV_FF, ecodes.FF_AUTOCENTER, val)
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument(
'-v', '--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument(
'--host',
metavar='H',
default='127.0.0.1',
help='IP of the host server (default: 127.0.0.1)')
from evdev import InputDevice, categorize, ecodes, KeyEvent, util
devices = [InputDevice(fn) for fn in util.list_devices()]
for device in devices:
if device.name == 'Logitech Gamepad F710' or device.name == 'Logitech Gamepad F310':
gamePad = InputDevice(device.fn)
break
print("\nPrint gamepad object information\n")
print(gamePad)
print("\n")
print("Press gamepad buttons\n")
for event in gamePad.read_loop():
if event.type == ecodes.EV_KEY:
keyevent = categorize(event)
print(keyevent)
print("")
if keyevent.keystate == KeyEvent.key_down:
print('key down detected')
print("keyevent.keycode")
print(keyevent.keycode)
print("")
if keyevent.keycode[1] == 'BTN_X':
print('button X\n')
elif keyevent.keycode[0] == 'BTN_B':
# import evdev
from evdev import InputDevice, categorize, ecodes
# creates object 'gamepad' to store the data
# you can call it whatever you like
gamepad = InputDevice("/dev/input/event15")
# prints out device info at start
print(gamepad)
# evdev takes care of polling the controller in a loop
for event in gamepad.read_loop():
# filters by event type
print("**------------------------------")
if event.type == ecodes.EV_KEY:
print(event)
else:
print(event.value)
# Não entendi o porque o código ev_key dos direcionais não
class Gamepad(GamepadCtrl):
def __init__(self, evt_f='/dev/input/event0'):
self.input = InputDevice(evt_f)
self.ctrls = set()
self.on = True
def register(self, ctrl: GamepadCtrl):
self.ctrls.add(ctrl)
def lt(self, val):
for ctrl in self.ctrls:
ctrl.lt(val)
def rt(self, val):
for ctrl in self.ctrls:
ctrl.rt(val)
def lb(self, val):
for ctrl in self.ctrls:
ctrl.lb(val)
def rb(self, val):
for ctrl in self.ctrls:
ctrl.rb(val)
def x(self, val):
for ctrl in self.ctrls:
ctrl.x(val)
def y(self, val):
for ctrl in self.ctrls:
ctrl.y(val)
def a(self, val):
for ctrl in self.ctrls:
ctrl.a(val)
def b(self, val):
for ctrl in self.ctrls:
ctrl.b(val)
def l_joy_x(self, val):
for ctrl in self.ctrls:
ctrl.l_joy_x(val)
def l_joy_y(self, val):
for ctrl in self.ctrls:
ctrl.l_joy_y(val)
def r_joy_x(self, val):
for ctrl in self.ctrls:
ctrl.r_joy_x(val)
def r_joy_y(self, val):
for ctrl in self.ctrls:
ctrl.r_joy_y(val)
def dir_x(self, val):
for ctrl in self.ctrls:
ctrl.dir_x(val)
def dir_y(self, val):
for ctrl in self.ctrls:
ctrl.dir_y(val)
async def read(self):
joy_mid = 0xFFFF / 2.0
max_trigger = 1023.0
async for event in self.input.async_read_loop():
if not self.on:
break
tp = int(event.type)
val = int(event.value)
code = int(event.code)
print(event)
# print(tp, val, code, code == 3, tp == 10)
if tp == 3:
if code == 0:
val = (val - joy_mid) / joy_mid
self.l_joy_x(val)
elif code == 1:
val = (val - joy_mid) / joy_mid
self.l_joy_y(val)
elif code == 2:
val = (val - joy_mid) / joy_mid
self.r_joy_x(val)
elif code == 5:
val = (val - joy_mid) / joy_mid
self.r_joy_y(val)
elif code == 9:
val /= max_trigger
self.rt(val)
elif code == 10:
val /= max_trigger
self.lt(val)
elif code == 16:
self.dir_x(val)
elif code == 17:
self.dir_y(val)
elif tp == 1:
if code == 304:
self.a(val == 1)
elif code == 305:
self.b(val == 1)
elif code == 307:
self.x(val == 1)
elif code == 308:
self.y(val == 1)
elif code == 310:
self.lb(val == 1)
elif code == 311:
self.rb(val == 1)
def start(self):
futures = [self.read()]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(futures))
loop.close()
def stop(self):
self.on = False
#!/usr/bin/env python
import rospy
from interfacing.msg import Velocity
from evdev import InputDevice, categorize, ecodes, events
import time
autonomous = True
gamepad = InputDevice('/dev/input/event17')
leftwheel = 0
rightwheel = 0
def Controller(pub, v, rate):
global autonomous
gamepad = InputDevice('/dev/input/event17')
for event in gamepad.read_loop():
if event.code == 04:
if event.value == 589834:
autonomous = True
break
elif event.value == 589833:
autonomous = False
v.leftwheel=v.rightwheel=0;
break
elif event.code == 17:
def __init__(self, evt_f='/dev/input/event0'):
self.input = InputDevice(evt_f)
self.ctrls = set()
self.on = True
def event_path(i):
return '/dev/input/event' + str(i)
## Call Testing Functions
test_forward()
test_backward()
test_right()
test_left()
## Setup GamePad
#gamepad = InputDevice('/dev/input/event1')
i = 0
while exists(event_path(i)):
gamepad = InputDevice(event_path(i))
if gamepad.name == "Logitech Gamepad F310":
break
i += 1
else:
print("ERROR: Game pad cannot be found!")
quit()
button_commands = {
304: bck, # btn_a
305: rgt, # btn_b
308: fwd, # btn_y
307: lft, # btn_x
#17 : fwd, # pad_up
#17 : bck, # pad_down
#16 : rgt, # pad_right
devlist = devfd.readlines()
devlist2 = "".join(devlist).split("\n\n")
for dev in devlist2:
if "Sysfs" in dev and "keyboard" in dev.lower():
for line in filter(lambda str: str.startswith("H: Handlers="),
dev.split("\n")):
for unit in line.split(" "):
if unit.startswith("event"):
devname = "/dev/input/" + unit
if not devname:
exit(1)
time.sleep(1)
dev = InputDevice(devname)
pressTime = None
releaseTime = None
longPressTime = None
"""
run loop.
"""
while True:
r, w, x = select([dev], [], [])
for event in dev.read():
if (event.type == 1): # vaild key event
print(event.code)
if event.code in Keys.keyDic.values():
# The Key Value 1 Is Means Press
import threading
from evdev import InputDevice, ecodes
import control as control
import constants as CONST
# thread
infrared_thread = None
dev = InputDevice("/dev/input/event0")
dev.grab()
def _infrared_loop():
t = threading.current_thread()
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
if t.name == "stop":
break
if event.code == 78 and event.value:
control.control_up(CONST.VOLUME_CHANGE_DIFF)
elif event.code == 74 and event.value:
control.control_down(-CONST.VOLUME_CHANGE_DIFF)
elif event.code == 208 and event.value:
control.control_next()
elif event.code == 168 and event.value:
control.control_prev()
elif event.code == 207 and event.value:
control.control_pause_toggle()
elif event.code == 139 and event.value:
control.control_mute_toggle()
from evdev import InputDevice, categorize, ecodes
gamepad = InputDevice('/dev/input/eventX') #replace w/ actual address
#replace w/ actual ecodes
lTrig = 0
rTrig = 0
up = 0
down = 0
left = 0
right = 0
def testController(gamepad):
print(gamepad)
for event in gamepad.read_loop():
print(categorize(event))
def findEcodes(gamepad):
print(gamepad)
for event in gamepad.read_loop():
if event.type == ecodes.___: #replace w/ event code (ecode) type
print(categorize(event))
def testEcodes(gamepad):
for event in gamepad.read_loop():
if event.type == ecodes.___: #gotta find this
# Code and setup from https://core-electronics.com.au/tutorials/using-usb-and-bluetooth-controllers-with-python.html
#import evdev
from evdev import InputDevice, categorize, ecodes
#creates object 'gamepad' to store the data
#you can call it whatever you like
media_buttons = InputDevice('/dev/input/event1')
#prints out device info at start
print(media_buttons)
#evdev takes care of polling the controller in a loop
for event in media_buttons.read_loop():
# print(categorize(event))
#filters by event type
if event.type == ecodes.EV_KEY:
print(event)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import requests
from evdev import InputDevice
from select import select
from conf import *
params = {}
webmoteurl = ''
dev = InputDevice(mouse)
while True:
(r, w, x) = select([dev], [], [])
for event in dev.read():
print event.value
# scroll wheel event is 8
# buttons left 272, right 273
if event.code == 8:
print 'wheel'
print event.value
if event.value == -1:
print 'vol down'
params = {'command': 'volume-down'}
webmoteurl = 'http://localhost/command'
myheaders = {'User-Agent': 'Mozilla/5.0'}
r = requests.post(webmoteurl, data=params,
headers=myheaders)
print r.status_code
class RFIDReader(Application, log_app.LogApp):
""" RFID Reader loop app """
dev_id_dir = '%s/by-id' % DEV_DIR
def __init__(self, args):
self.do_read_one = True
self.card_num_list = []
self.postponed = False
log_app.LogApp.__init__(self, args=args)
script_name = os.path.splitext(os.path.basename(__file__))[0]
self.get_config('{}.conf'.format(script_name))
super(RFIDReader, self).__init__()
self.reader = InputDevice(self.dev_file)
self.reader.grab()
self.csv_writer = CSVWriter(self.config)
logging.debug('base_dir=%s', self.base_dir)
#self.tmp_dir = ''
#self.csv_dir = ''
@property
def base_dir(self):
""" base_dir from conf file if present """
if 'base_dir' in self.config['DIRS'].keys():
loc_dir = self.config['DIRS']['base_dir']
else:
loc_dir = os.path.dirname(__file__)
return loc_dir
@property
def tmp_dir(self):
""" tmp_dir from conf file """
return '{}/{}'.format(self.base_dir, self.config['DIRS']['tmp_dir'])
@property
def csv_dir(self):
""" csv_dir from conf file """
return '{}/{}'.format(self.base_dir, self.config['DIRS']['csv_dir'])
@property
def dev_file(self):
""" Find RFID reader in /dev/input """
dev_file = None
for inp in os.listdir(self.dev_id_dir):
if RFID_NAME in inp:
dev_link = os.readlink('%s/%s' % (self.dev_id_dir, inp))
dev_file = '%s/%s' % (DEV_DIR, dev_link.replace('../', ''))
logging.info('RFID device found=%s', dev_file)
break
if not dev_file:
raise NameError('RFID [{}] reader not found'.format(RFID_NAME))
return dev_file
def _signal_handler(self):
logging.info('RFID signal_handler')
self.do_read_one = False
super(RFIDReader, self)._signal_handler()
def _write_card_num(self):
""" Write card_num to CSV """
card_num = ''.join(self.card_num_list)
logging.info('Try to save card_num=%s', card_num)
csv_str = '{}^{}'.format(card_num, datetime.now())
tmp_file = '{}/{}-{}.tmp'.format(self.tmp_dir, int(time.time()),
card_num)
with open(tmp_file, 'w') as tmp:
try:
tmp.write(csv_str + '\n')
except IOError as err:
logging.error('Cannot write csv=[%s] to tmp_file. err=%s',
csv_str, err)
except:
logging.error("Unexpected error:%s", sys.exc_info()[0])
raise
else:
logging.info('Written to tmp:%s', tmp_file)
csv_file = '{}/{}.csv'.format(self.csv_dir, \
os.path.splitext(os.path.basename(tmp_file))[0])
os.rename(tmp_file, csv_file)
def _proc_until_enter(self, arg_event):
""" recognize pressed key """
res = False
c_ev = categorize(arg_event)
if c_ev.keystate == 0: # key UP
logging.debug('st=%s, code=%s', c_ev.keystate, c_ev.keycode)
if c_ev.keycode != 'KEY_ENTER': # and c_ev.keystate == 0:
self.card_num_list.append(c_ev.keycode.replace('KEY_', ''))
else:
logging.debug('ENTER detected. Exiting...')
res = True
return res
@property
def _missed_dirs(self):
missed_dirs = []
for i_dir in self.config['DIRS'].values():
logging.debug('check config dir=%s', i_dir)
loc_dir = '{}/{}'.format(self.base_dir, i_dir)
if not os.path.exists(loc_dir):
logging.error('missed loc_dir=%s', loc_dir)
missed_dirs.append(i_dir)
return missed_dirs
def _main(self):
""" Just main """
self.terminated = self._missed_dirs
if self.terminated:
return
#self.tmp_dir = '{}/{}'.format(self.base_dir, self.config['DIRS']['tmp_dir'])
#self.csv_dir = '{}/{}'.format(self.base_dir, self.config['DIRS']['csv_dir'])
th_csv = StoppableThread(target=self.csv_writer.chk_csv_dir, \
kwargs={"stop": lambda: self.terminated})
"""
th_csv = StoppableThread(target=self.csv_writer.chk_csv_dir, \
kwargs={"csv_dir": self.config['DIRS']['csv_dir'],
"arch_dir": self.config['DIRS']['arch_dir'],
"failed_dir": self.config['DIRS']['failed_dir'],
"stop": lambda: self.terminated})
"""
th_csv.start()
while not self.terminated:
self.card_num_list = []
#for event in READER.read_loop():
self.do_read_one = True
logging.debug('DB Thread is_alive=%s', th_csv.is_alive())
while self.do_read_one:
event = self.reader.read_one()
if event and event.type == EV_KEY: # read completed and EV_KEY
if self._proc_until_enter(event):
self._write_card_num()
break
if th_csv:
th_csv.stop()
def close(self):
""" Close everything """
self.reader.ungrab()
self.reader.close()
self.csv_writer.pg_close()
]
###
### GAMEPAD CONFIG
gamepads = []
def devicenum(device_path):
digits = re.findall(r'\d+$', device_path)
return [int(i) for i in digits]
if gamepadsAvailable:
devices = sorted(list_devices('/dev/input'), key=devicenum)
devices = devices = [InputDevice(path) for path in devices]
for device in devices:
if 'Shinecon' in device.name:
gamepads += [device]
def getGamepad(name):
for gamepad in gamepads:
if name in gamepad.name:
return gamepad
return None
###
### PLAYER CONFIG
