def keypadRead():
device = InputDevice("/dev/input/event3") # my keyboard
event = None
event = device.active_keys(verbose=True)
while event == []:
event = device.active_keys(verbose=True)
device.close()
event = event[0][0].split('KP')
event = event[1]
if (event == 'ASTERISK'):
event = '*'
elif (event == 'SLASH'):
event = '/'
elif (event == 'PLUS'):
event = '+'
elif (event == 'MINUS'):
event = '-'
elif (event == 'DOT'):
event = '.'
elif (event == 'ENTER'):
event = '\n'
else:
event = event
print(event)
return event
def _loop(self):
dev = InputDevice(
"/dev/input/by-path/platform-odroidgo2-joypad-event-joystick")
last_repeat = time.time()
while self._active:
ev = dev.read_one()
active = set(dev.active_keys())
if e.BTN_TRIGGER_HAPPY3 in active:
time.sleep(self.poll_freq)
continue
if ev:
last_repeat = time.time() + self.repeat_rate * 5
if ev.value == 1:
self._write(ev.code)
else:
now = time.time()
if now - last_repeat >= self.repeat_rate:
last_repeat = now
active_mask = active & InputPipe.repeat_mask
if active_mask:
for k in active_mask:
self._write(k)
time.sleep(self.poll_freq)
class Gamepad():
def __init__(self, device_name):
self._device_name = device_name
self._gamepad = InputDevice(self._device_name)
def get_active_keys(self):
return self._gamepad.active_keys()
def get_analog_value(self, id):
return self._gamepad.absinfo(id).value
def key_input_test():
dev = InputDevice('/dev/input/event0')
sr.sendbit(0)
foundkeys = 0
for i in range(len(KEYPRESSES)):
if (dev.active_keys() == KEYPRESSES[i]):
print('Found Key' , KEYPRESSES[i])
foundkeys += 1
else:
print('Fail!!',dev.active_keys() ,'Expected ', KEYPRESSES[i])
sleep(0.1)
sr.sendbit(1)
if( foundkeys == 16 ):
print( 'Test Passed')
dev.close()
return True
else:
print( 'Test FAIL!!!!!!!!!!!')
dev.close()
return False
def active_check():
dev = InputDevice('/dev/input/event7')
print(dev.path, dev.name, dev.phys)
while True:
keys = dev.active_keys()
if len(keys):
print(keys)
pad = dev.absinfo(ecodes.ABS_X)
if pad.value != 127:
print("DPAD X: ", pad.value)
pad = dev.absinfo(ecodes.ABS_Y)
if pad.value != 127:
print("DPAD Y: ", pad.value)
time.sleep(0.1)
def run(self):
global program
global plgn
global keys
device = InputDevice('/dev/input/event5')
while running:
program = runCmd('xdotool getwindowfocus getwindowname').rstrip()
if program == 'bash: xdotool: command not found':
print('xdotool must be installed')
keys = [k[0].replace('KEY_', '') for k in device.active_keys(verbose=True)]
newPlgn = plgn
for plugin in plugins:
if plugin.canBeActive(program, keys):
newPlgn = plugin
plgn = newPlgn
print('Program thread complete.')
class ShortcutsTab(QWidget):
def __init__(self):
self.dev = InputDevice("/dev/input/event6")
super(ShortcutsTab, self).__init__()
grid_main = QGridLayout()
form_left = QFormLayout()
form_right = QFormLayout()
self.add_image(form_left)
self.add_image(form_right)
self.add_image(form_left)
self.add_image(form_right)
grid_main.addLayout(form_left, 0, 0)
grid_main.addLayout(form_right, 0, 1)
self.setLayout(grid_main)
def add_image(self, v_box):
image = QPixmap(Images.rotate.value)
image = image.scaled(32, 32, Qt.KeepAspectRatio, Qt.SmoothTransformation)
imageLabel = QLabel()
imageLabel.setPixmap(image)
button_shortcuts = QPushButton("teste")
button_shortcuts.clicked.connect(self.change_button_name)
v_box.addRow(imageLabel, button_shortcuts)
def change_button_name(self):
button = self.sender()
array = list()
while (True):
array = self.dev.active_keys()
if 30 in array:
break
button.setText(str(array))
import mpd
import socket
import alsaaudio
import time
client = mpd.MPDClient(use_unicode=True)
dev = InputDevice('/dev/input/event2')
drop_lb_event = False
drop_rb_event = False
while True:
r,w,x = select([dev], [], [])
try:
for event in dev.read():
client.connect("192.168.0.2", 6600)
if event.code == 8:
if 272 in dev.active_keys():
drop_lb_event = True
if (event.value > 0):
client.seekcur("+5")
else:
client.seekcur("-5")
elif 273 in dev.active_keys():
drop_rb_event = True
if (event.value > 0):
client.seekcur("+30")
else:
client.seekcur("-30")
else:
mixer = alsaaudio.Mixer("PCM", **{"cardindex": 1})
if (event.value > 0):
mixer.setvolume(int(mixer.getvolume()[0])+2, -1)
e.KEY_9: e.KEY_F9,
e.KEY_0: e.KEY_F10,
e.KEY_MINUS: e.KEY_F11,
e.KEY_EQUAL: e.KEY_F12,
e.KEY_BACKSPACE: e.KEY_DELETE,
}
# The names can be found with evtest or in evdev docs.
esc = False
intercepted = False
# Create a new keyboard mimicking the original one.
with UInput.from_device(kbd, name='kbdremap') as ui:
for ev in kbd.read_loop(): # Read events from original keyboard.
if ev.type == e.EV_KEY: # Process key events.
# ke = evdev.categorize(ev)
act = kbd.active_keys()
# print(act)
# print(ev.value)
if e.KEY_ESC in act:
esc = True
for k, v in REMAP_TABLE.items():
if k in act:
intercepted = True
ui.write(e.EV_KEY, v, 1)
ui.write(e.EV_KEY, v, 0)
ui.syn()
elif esc and not intercepted:
ui.write(e.EV_KEY, e.KEY_ESC, 1)
ui.write(e.EV_KEY, e.KEY_ESC, 0)
ui.syn()
intercepted = False
def main():
"""Checks PS3 inputs and sends them via UDP"""
dev = InputDevice('/dev/input/by-id/usb-Sony_PLAYSTATION_R_3_Controller-event-joystick')
speed1 = 0
speed2 = 0
speed3 = 0
dir1 = 'F'
dir2 = 'F'
dir3 = 'F'
arm_pos = 0
print(dev)
print(dev.capabilities(verbose=True, absinfo=False))
UDP_IP = "192.168.43.2"
UDP_PORT = 5000
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
event = dev.read()
keys = dev.active_keys()
print(keys)
try:
for key in keys:
if key == 295:
arm_pos = 0
print("295")
if key == 292:
arm_pos = 1
print("292")
if key == 293:
arm_pos = 2
print("293")
if key == 294:
arm_pos = 3
print("294")
for evn in event:
if evn.code == 1: # right x
# print(ev)
speed1 = evn.value - 128
if speed1 < 0:
dir1 = 'F'
if speed1 == -128:
speed1 = -127
# ser.write('AF'.encode() + str(abs(dir * 2)).encode())
print("Motor A - Forward - " + str(abs(speed1 * 2)))
else:
dir1 = 'B'
# ser.write('AB'.encode() + str(dir).encode())
print("Motor A - Backward - " + str(abs(speed1 * 2)))
# ser.write('A'.encode() + str(evn.value - 128).encode())
elif evn.code == 5: # left x
speed2 = evn.value - 128
# print(ev)
if speed2 < 0:
dir2 = 'F'
if speed2 == -128:
speed2 = -127
# ser.write('BF'.encode() + str(abs(dir * 2)).encode())
print("Motor B - Forward - " + str(abs(speed2 * 2)))
else:
dir2 = 'B'
# ser.write('BB'.encode() + str(dir * 2).encode())
print("Motor B - Backward - " + str(abs(speed2 * 2)))
elif evn.code == 300: # left x
print("motor 3 F")
speed3 = 127
dir3 = 'F'
elif evn.code == 302:
print("motor 3 B")
speed3 = 127
dir3 = 'B'
elif evn.code == 301:
speed3 = 0
sock.sendto(dir1.encode() +
str(abs(speed1 * 2)).zfill(3).encode() +
dir2.encode() +
str(abs(speed2 * 2)).zfill(3).encode() +
dir3.encode() +
str(abs(speed3 * 2)).zfill(3).encode() +
# str(arm_pos).encode() +
"\n".encode(), (UDP_IP, UDP_PORT))
gc.collect()
except IOError:
pass
btn_num = int(eventstring[1])
if btn_num > 287 and btn_num < 300:
btn_num = btn_num-287
packet = [
ZabbixMetric('pimon', 'usb.joypad.b'+str(btn_num), int(eventstring[3]))
]
result = ZabbixSender(use_config=True).send(packet)
#Update Every so often just because
if CURRENT_INTERVAL > 0:
#print (CURRENT_INTERVAL)
CURRENT_INTERVAL = CURRENT_INTERVAL-1
else:
CURRENT_INTERVAL = UPDATE_INTERVAL
print("UPDATE: "+str(datetime.datetime.now()))
pressed = (gamepad.active_keys())
if 288 in pressed:
b1 = 1
else:
b1 = 0
if 289 in pressed:
b2 = 1
else:
b2 = 0
if 290 in pressed:
b3 = 1
else:
b3 = 0
if 291 in pressed:
b4 = 1
else:
query_value = argv[3]
else:
print(usage)
exit(1)
capabs = device.capabilities(verbose=True)
print('Device name: {.name}'.format(device))
print('Device info: {.info}'.format(device))
print('Repeat settings: {}\n'.format(device.repeat))
if ('EV_LED', ecodes.EV_LED) in capabs:
leds = ','.join(i[0] for i in device.leds(True))
print('Active LEDs: %s' % leds)
active_keys = ','.join(k[0] for k in device.active_keys(True))
print('Active keys: %s\n' % active_keys)
print('Device capabilities:')
for type, codes in capabs.items():
print(' Type {} {}:'.format(*type))
for i in codes:
# i <- ('BTN_RIGHT', 273) or (['BTN_LEFT', 'BTN_MOUSE'], 272)
if isinstance(i[1], AbsInfo):
print(' Code {:<4} {}:'.format(*i[0]))
print(' {}'.format(i[1]))
else:
# multiple names may resolve to one value
s = ', '.join(i[0]) if isinstance(i[0], list) else i[0]
print(' Code {:<4} {}'.format(s, i[1]))
print('')
Motor_Stop()
if (event.value == -1 and event.code == 16):
Motor_Left(Speed[count_1])
#Pomik desnih gosenic v paralelogramu
if (event.value == 1 and event.code == 309):
Motor_Stop()
print("Pomikanje desnih gosenic")
pos = sc.get_present_position(7)
while (1 == 1):
if (pos > 670 and count_2 == 0 or pos < 230 and count_2 == 1):
Right_Tracks(pos, 0)
break
else:
if Gamepad.active_keys(309):
if (count_2 == 0):
pos = pos + 20
Right_Tracks(pos, 300)
if (count_2 == 1):
pos = pos - 20
Right_Tracks(pos, 1023 + 300)
else:
break
if (event.value == -1 and event.code == 17):
print("OK")
#Spreminjanje smeri vrtenja motorja-> desne gosenice
if (event.value == 1 and event.code == 315):
class PixelRingSkill(MycroftSkill):
def __init__(self):
MycroftSkill.__init__(self)
self.en = mraa.Gpio(12)
if os.geteuid() != 0:
time.sleep(1)
self.en.dir(mraa.DIR_OUT)
self.en.write(0)
def initialize(self):
self.log.info("PixelRing initializing")
self.userkey = None
try:
self.userkey = InputDevice("/dev/input/event0")
except Exception as e:
self.log.debug("exception while reading InputDevice: {}".format(e))
if self.userkey:
self.schedule_repeating_event(self.handle_button, None, 0.1,
'PixelRing')
self.pixel_ring = PixelRing()
brightness = self.settings.get('brightness', 15)
self.pixel_ring.set_brightness(brightness)
self.add_event('recognizer_loop:wakeword', self.handler_wakeword)
self.add_event('recognizer_loop:record_begin',
self.handle_listener_listen)
self.add_event('recognizer_loop:record_end', self.handle_listener_off)
self.add_event('recognizer_loop:audio_output_start',
self.handle_listener_speak)
self.add_event('recognizer_loop:audio_output_end',
self.handle_listener_off)
self.add_event('mycroft.skill.handler.start',
self.handle_listener_think)
self.add_event('mycroft.skill.handler.complete',
self.handle_listener_off)
self.pixel_ring.off()
# def on_settings_changed(self):
# brightness = self.settings.get('brightness', 15)
# pattern = self.settings.get('pattern', 'echo')
# self.pixel_ring.set_brightness(brightness)
# self.pixel_ring.change_pattern(pattern)
@intent_file_handler('ring.pixel.change.intent')
def handle_ring_pixel_change(self, message):
pattern_type = message.data.get('type')
self.log.info(pattern_type)
def google():
self.pixel_ring.change_pattern('google')
def echo():
self.pixel_ring.change_pattern('echo')
def on():
self.pixel_ring.off()
self.en.write(0)
# self.pixel_ring.wakeup()
def off():
self.shutdown()
known_types = {
"google": google,
"echo": echo,
"amazon": echo,
"on": on,
"off": off
}
func = known_types.get(pattern_type,
lambda: self.speak("Sorry, I don't understand"))
return func()
def handler_wakeword(self, message):
self.log.debug("wakeword")
self.pixel_ring.wakeup()
def handle_listener_listen(self, message):
self.log.debug("listen")
self.pixel_ring.listen()
def handle_listener_think(self, message):
self.log.debug("think")
self.pixel_ring.think()
def handle_listener_speak(self, message):
self.log.debug("speak")
self.pixel_ring.speak()
def handle_listener_off(self, message):
self.log.debug("off")
self.pixel_ring.off()
@intent_file_handler('ring.pixel.demo.intent')
def handle_ring_pixel_demo(self, message):
self.pixel_ring.off()
self.log.info("Running Pixel Ring demo")
self.log.debug("PixelRing Wakeup")
self.pixel_ring.wakeup()
time.sleep(3)
self.log.debug("PixelRing Listen")
self.pixel_ring.listen()
time.sleep(3)
self.log.debug("PixelRing Think")
self.pixel_ring.think()
time.sleep(3)
self.log.debug("PixelRing Speak")
self.pixel_ring.speak()
time.sleep(3)
self.log.debug("PixelRing Off")
self.pixel_ring.off()
def handle_button(self, message):
if not self.userkey:
return
longpress_threshold = 4
respeaker_userkey_code = 194
if respeaker_userkey_code in self.userkey.active_keys():
pressed_time = time.time()
while respeaker_userkey_code in self.userkey.active_keys():
time.sleep(0.2)
pressed_time = time.time() - pressed_time
if pressed_time < longpress_threshold:
self.bus.emit(Message("mycroft.mic.listen"))
else:
self.bus.emit(Message("mycroft.stop"))
def stop(self):
self.log.debug("PixelRing stopping")
self.pixel_ring.off()
def shutdown(self):
self.log.debug("PixelRing shutting down")
self.pixel_ring.off()
self.en.write(1)
# grabs input device associated to game pad label
# check with $ ls /dev/input/
iCheck = inputCheck.inputCheck()
gamepadEvent = iCheck.printFnumber("Logitech Gamepad F310")
game_pad = InputDevice(str(gamepadEvent))
print "Input device Logitech Gamepad F310 ready to use."
#game_pad = InputDevice("/dev/input/event16")
game_pad.capabilities()
game_pad.capabilities(verbose=False)
lastKey = 0 # 1 == L1 or R1, 0 == other keys
for event in game_pad.read_loop():
key_event = categorize(event)
#print game_pad.active_keys(True)
if len(game_pad.active_keys()) < 1 and lastKey == 1: # only move gripper if L1/R1 pushed
switchLight = False
OWIarm.stopMotion(switchLight)
# Trigger for:
# Right/left button trigger, Y action button
elif event.type == ecodes.EV_KEY and key_event.keystate == KeyEvent.key_down:
scan_code = key_event.scancode
if scan_code == 311: # R1
#print "R1"
OWIarm.gripMotion(1)
lastKey = 1
elif scan_code == 310: # L1
#print "L1"
OWIarm.gripMotion(2)
lastKey = 1
# Returns 0 or 1 to shell, depending on touch screen is pressed
import sys
from evdev import InputDevice
dev = InputDevice('/dev/input/event0')
keys=dev.active_keys()
if keys:
if keys[0] == 330:
sys.exit(0)
else:
sys.exit(1)
"c": "ć",
"e": "ę",
"l": "ł",
"n": "ń",
"o": "ó",
"s": "ś",
"x": "ź",
"z": "ż",
}
LETTERS_CODES = [
getattr(ecodes, f'KEY_{letter}') for letter in string.ascii_uppercase
]
for event in dev.read_loop():
active_keys = dev.active_keys()
if event.type == ecodes.EV_KEY:
c_event = categorize(event)
if c_event.keystate == c_event.key_down:
if c_event.scancode not in LETTERS_CODES:
continue
letter = c_event.keycode[-1].lower()
if ecodes.KEY_RIGHTALT in active_keys:
try:
play(ACCENTS[letter])
except KeyError:
pass
else:
play(letter)
else:
print(usage)
exit(1)
capabs = device.capabilities(verbose=True)
print('Device name: {.name}'.format(device))
print('Device info: {.info}'.format(device))
print('Repeat settings: {}\n'.format(device.repeat))
if ('EV_LED', ecodes.EV_LED) in capabs:
leds = ','.join(i[0] for i in device.leds(True))
print('Active LEDs: %s' % leds)
active_keys = ','.join(k[0] for k in device.active_keys(True))
print('Active keys: %s\n' % active_keys)
print('Device capabilities:')
for type, codes in capabs.items():
print(' Type {} {}:'.format(*type))
for i in codes:
# i <- ('BTN_RIGHT', 273) or (['BTN_LEFT', 'BTN_MOUSE'], 272)
if isinstance(i[1], AbsInfo):
print(' Code {:<4} {}:'.format(*i[0]))
print(' {}'.format(i[1]))
else:
# multiple names may resolve to one value
s = ', '.join(i[0]) if isinstance(i[0], list) else i[0]
print(' Code {:<4} {}'.format(s, i[1]))
print('')
class SnakeGame:
score = 0
gamepad = None
newmatrix = None
snakeLen = 1
snakePos = [(0, 0)]
bait = (3, 3)
direct = (0, 0)
def __init__(self):
self.gamepad = InputDevice('/dev/input/event0')
self.newmatrix = Matrix.Matrix()
def playgame(self):
count = 0
self.newmatrix.ShowMsg("Start playing SNAKEEEE")
while True:
for event in self.gamepad.active_keys():
if event == yBtn:
if self.direct != DRECT[2] or self.snakeLen < 3:
self.direct = DRECT[0]
elif event == bBtn:
if self.direct != DRECT[3] or self.snakeLen < 3:
self.direct = DRECT[1]
elif event == aBtn:
if self.direct != DRECT[0] or self.snakeLen < 3:
self.direct = DRECT[2]
elif event == xBtn:
if self.direct != DRECT[1] or self.snakeLen < 3:
self.direct = DRECT[3]
if count == SPEED:
if self.checkLose():
self.score = self.snakeLen
for i in range(2):
self.newmatrix.ShowMsg("You lose!! Your score is %d"\
%(self.score))
print "\n\nYou lose!! Your score is %d\n\n" % (
self.score)
break
else:
self.checkState()
self.Display()
count = (count + 1) % (SPEED + 1)
def Display(self):
image = [[0 for x in range(8)] for y in range(8)]
for dot in self.snakePos:
image[dot[0]][dot[1]] = 1
image[self.bait[0]][self.bait[1]] = 1
self.newmatrix.DisplayImage(image)
def checkState(self):
if self.snakePos[0] == self.bait:
tmp = self.snakePos[self.snakeLen - 1]
self.snakeLen += 1
self.snakePos.append(tmp)
for i in range(self.snakeLen - 1, 0, -1):
self.snakePos[i] = self.snakePos[i - 1]
self.snakePos[0] = ((self.snakePos[0][0] + self.direct[0]) % 8,\
(self.snakePos[0][1] + self.direct[1]) % 8)
while self.checkBait():
self.bait = (randint(0, 7), randint(0, 7))
else:
for i in range(self.snakeLen - 1, 0, -1):
self.snakePos[i] = self.snakePos[i - 1]
self.snakePos[0] = ((self.snakePos[0][0] + self.direct[0]) % 8,\
(self.snakePos[0][1] + self.direct[1]) % 8)
def checkBait(self):
for dot in self.snakePos:
if self.bait == dot:
return True
return False
def checkLose(self):
for i in range(1, self.snakeLen):
if self.snakePos[i] == self.snakePos[0]:
return True
return False
class Gamepad(object):
def __init__(self, udev_device):
log.debug(f"Initializing device {udev_device.device_node}")
self._udev_device = udev_device
self._device = InputDevice(udev_device.device_node)
self._state = {}
self._leds = []
self._battery = None
hid_device = udev_device.find_parent("hid")
self.is_bluetooth = (udev_device.properties.get("ID_BUS") == "bluetooth")
if self.is_bluetooth:
self.bt_mac_address = hid_device.properties.get("HID_UNIQ")
log.info(f"Bluetooth addr: {self.bt_mac_address}")
for child in hid_device.children:
if child.subsystem == "power_supply":
log.info(f"Found power supply {child.sys_name}")
self._battery = child
if child.subsystem == "leds":
log.info(f"Found led {child.sys_name}")
self._leds.append(child)
def __repr__(self):
return '{}({})'.format(self.__class__.__name__, self._device)
def set_led_colors(self, red=0, green=0, blue=0):
log.info(f"Setting LED colors to 0x{red:02x}{green:02x}{blue:02x}")
for led in self._leds:
if os.path.basename(led.sys_path).endswith("red"):
open(os.path.join(led.sys_path, "brightness"), "w").write(f"{red}\n")
if os.path.basename(led.sys_path).endswith("green"):
open(os.path.join(led.sys_path, "brightness"), "w").write(f"{green}\n")
if os.path.basename(led.sys_path).endswith("blue"):
open(os.path.join(led.sys_path, "brightness"), "w").write(f"{blue}\n")
@property
def has_battery(self):
return self._battery is not None
@property
def battery_level(self):
if self._battery is None:
return -1
else:
return self._battery.properties.asint("POWER_SUPPLY_CAPACITY")
@property
def battery_status(self):
if self._battery is None:
return "No battery"
else:
return self._battery.properties.get("POWER_SUPPLY_STATUS")
def disconnect(self):
log.debug("disconnect()")
if not self.is_bluetooth:
return # We can only disconnect bluetooth gamepad
proc = subprocess.Popen(
"/usr/bin/bluetoothctl", stdin=subprocess.PIPE, stdout=subprocess.PIPE)
try:
log.debug("Sending disconnect signal via bluetoothctl")
proc.communicate(
"disconnect {}\nexit\n".format(self.bt_mac_address).encode(),
timeout=5)
except subprocess.TimeoutExpired:
proc.kill()
proc.communicate()
log.info("Gamepad disconnected")
def get_active_keys(self):
return self._device.active_keys()
def is_pressed(self, key, min_duration=None):
if key in self.get_active_keys():
if min_duration:
if key in self._state.keys():
now = time.time()
ts, event = self._state[key]
if (now - ts) >= min_duration:
del self._state[key]
return True
else:
return False
else:
return True
return False
def read(self):
r, _, _ = select.select([self._device], [], [], 0.5)
if self._device not in r:
return
for event in self._device.read():
if event.code in (ecodes.ABS_HAT0X, ecodes.ABS_HAT0Y):
event.type = ecodes.EV_KEY
if event.code == ecodes.ABS_HAT0X:
event.code = (event.value < 0) and ecodes.BTN_DPAD_LEFT or ecodes.BTN_DPAD_RIGHT
elif event.code == ecodes.ABS_HAT0Y:
event.code = (event.value < 0) and ecodes.BTN_DPAD_UP or ecodes.BTN_DPAD_DOWN
event.value = abs(event.value)
if event.type == ecodes.EV_KEY:
if event.value == 1:
self._state[event.code] = event.timestamp(), event
if event.value == 0 and event.code in self._state.keys():
del self._state[event.code]
if event.type in (ecodes.EV_KEY,):
log.debug(categorize(event))
yield event
def __iter__(self):
while True:
for event in self.read():
if event: yield event
@classmethod
def get_gamepad(cls):
context = pyudev.Context()
for js_device in context.list_devices(subsystem="input", ID_INPUT_JOYSTICK=1):
if js_device.device_node:
return cls(js_device)
def is_ctrl_z(e: InputEvent, keyboard: InputDevice) -> bool:
"""
Check whether event invokes ^z or not.
"""
return e.code == ecodes.KEY_Z and ecodes.KEY_LEFTCTRL in keyboard.active_keys(
)
def main():
"""Checks PS3 inputs and sends them via UDP"""
dev = InputDevice('/dev/input/by-id/usb-Sony_PLAYSTATION_R_3_Controller-event-joystick')
ser = serial.Serial('/dev/ttyACM3', 19200)
servo1 = 90
servo2 = 90
servo3 = 90
servo4 = 90
servo5 = 90
send = True
print(dev)
print(dev.capabilities(verbose=True, absinfo=False))
UDP_IP = "192.168.0.249"
UDP_PORT = 5000
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
event = dev.active_keys()
print(dev.active_keys())
print(servo1)
print(servo2)
print(servo3)
print(servo4)
print(servo5)
try:
for evn in event:
# 299 & 298
if evn == 299:
send = True
if servo1 >= 180:
servo1 = 180
servo2 = 0
else:
servo1 += 0.5
servo2 -= 0.5
elif evn == 298:
send = True
if servo1 <= 0:
servo1 = 0
servo2 = 180
else:
servo1 -= 0.5
servo2 += 0.5
# 296 & 297
if evn == 296:
send = True
if servo3 >= 180:
servo3 = 180
else:
servo3 += 0.5
elif evn== 297:
send = True
if servo3 <= 0:
servo3 = 0
else:
servo3 -= 0.5
# 295 & 293 - dcha izq
if evn== 295: # dcha
send = True
if servo4 >= 180:
servo4 = 180
else:
servo4 += 0.5
elif evn== 293: # izq
send = True
if servo4 <= 0:
servo4 = 0
else:
servo4 -= 0.5
# 292 & 294 - arriba abajo
if evn== 292: # arriba
send = True
if servo5 >= 180:
servo5 = 180
else:
servo5 += 0.5
elif evn== 294: # abajo
send = True
if servo5 <= 0:
servo5 = 0
else:
servo5 -= 0.5
if(send):
ser.write(str(int(servo1)).zfill(3).encode() +
str(int(servo2)).zfill(3).encode() +
str(int(servo3)).zfill(3).encode() +
str(int(servo4)).zfill(3).encode() +
str(int(servo5)).zfill(3).encode() +
"\n".encode())
send= False
gc.collect()
except IOError:
pass
class RespeakerIo(MycroftSkill):
def __init__(self):
MycroftSkill.__init__(self)
def initialize(self):
LOG.debug("initialising")
self.en = mraa.Gpio(12)
if os.geteuid() != 0:
time.sleep(1)
self.en.dir(mraa.DIR_OUT)
self.en.write(0)
pixel_ring.set_brightness(20)
pixel_ring.wakeup()
self.userkey = None
try:
self.userkey = InputDevice("/dev/input/event0")
except Exception as e:
LOG.debug("exception while reading InputDevice: {}".format(e))
if self.userkey:
self.schedule_repeating_event(self.handle_button, None, 0.1,
'RespeakerIo')
self.add_event('recognizer_loop:record_begin',
self.handle_listener_wakeup)
self.add_event('recognizer_loop:record_end', self.handle_listener_off)
self.add_event('recognizer_loop:audio_output_start',
self.handle_listener_speak)
self.add_event('recognizer_loop:audio_output_end',
self.handle_listener_off)
self.add_event('mycroft.skill.handler.start',
self.handle_listener_think)
self.add_event('mycroft.skill.handler.complete',
self.handle_listener_off)
pixel_ring.off()
def shutdown(self):
LOG.debug("shutdown")
pixel_ring.off()
self.en.write(1)
def handle_listener_wakeup(self, message):
LOG.debug("wakeup")
pixel_ring.wakeup()
def handle_listener_think(self, message):
LOG.debug("think")
pixel_ring.think()
def handle_listener_speak(self, message):
LOG.debug("speak")
pixel_ring.speak()
def handle_listener_off(self, message):
LOG.debug("off")
pixel_ring.off()
def handle_button(self, message):
if not self.userkey:
return
longpress_threshold = 2
respeaker_userkey_code = 194
if respeaker_userkey_code in self.userkey.active_keys():
pressed_time = time.time()
while respeaker_userkey_code in self.userkey.active_keys():
time.sleep(0.2)
pressed_time = time.time() - pressed_time
if pressed_time < longpress_threshold:
self.bus.emit(Message("mycroft.mic.listen"))
else:
self.bus.emit(Message("mycroft.stop"))
@intent_file_handler('ring.pixel.respeaker.intent')
def handle_ring_pixel_respeaker(self, message):
self.speak_dialog('ring.pixel.respeaker')
from evdev import InputDevice, categorize, ecodes
key_map = {
115: "FRWD",
114: "BKWD",
165: "LEFT",
163: "RIGHT",
164: "BTN_A",
304: "SUPER_UP",
305: "SUPER_DOWN",
}
remote = InputDevice("/dev/input/event2")
print("Device : {}".format(remote))
for event in remote.read_loop():
c_event = categorize(event)
# print("categorized event : {}".format())
if event.type == ecodes.EV_KEY:
print("key: {}".format(remote.active_keys(verbose=False)))
