def open_device(device): """Device should either be the index of a valid SDL device or its joystick name. The list of attached devices and names can be retrieved with enumerate_devices().""" if not SDL_INITED: raise RuntimeError('SDL not initialized. Call init_sdl() from the the thread that will run the event loop.') input_device_count = sdl2.SDL_NumJoysticks() if input_device_count == 0: raise RuntimeError('No joysticks/game controllers attached.') if isinstance(device, int): if not 0 <= device < input_device_count: raise ValueError('Invalid device index {}; there are only {} available devices.'.format(device, input_device_count)) index = device name = sdl2.SDL_JoystickNameForIndex(index).decode('utf-8') else: name = device namebytes = device.encode('utf-8') for index in range(sdl2.SDL_NumJoysticks()): if sdl2.SDL_JoystickNameForIndex(index) == namebytes: break else: raise ValueError('No device recognized by SDL has the name "{}".'.format(name)) is_game_controller = bool(sdl2.SDL_IsGameController(index)) device = (sdl2.SDL_GameControllerOpen if is_game_controller else sdl2.SDL_JoystickOpen)(index) if not device: raise RuntimeError('Failed to open {} at device index {} with name "{}".'.format( 'game controller' if is_game_controller else 'joystick', index, name)) return device, name, index, is_game_controller
def open_device(input_device_index=0, input_device_name=None, _used_idx_and_name=None): if input_device_name is None and int( input_device_index) != input_device_index: raise ValueError( 'If input_device_name is not specified, the value supplied for input_device_index must be an integer.' ) input_device_count = sdl2.SDL_NumJoysticks() if input_device_count == 0: raise RuntimeError( 'According to SDL, there are no joysticks/game controllers attached.' ) if input_device_name is None: if not 0 <= input_device_index < input_device_count: isare, ssuffix = ('is', '') if input_device_count == 1 else ('are', 's') e = ( 'According to SDL, there {0} {1} joystick{2}/game controller{2} attached. Therefore, input_device_index must be ' 'an integer in the closed interval [0, {3}], which the supplied value, {4}, is not.' ) raise ValueError( e.format(isare, input_device_count, ssuffix, input_device_count - 1, input_device_index)) input_device_name = sdl2.SDL_JoystickNameForIndex(input_device_index) else: if isinstance(input_device_name, str): input_device_name = input_device_name.encode('utf-8') else: input_device_name = bytes(input_device_name) for sdl_dev_idx in range(sdl2.SDL_NumJoysticks()): if sdl2.SDL_JoystickNameForIndex(sdl_dev_idx) == input_device_name: input_device_index = sdl_dev_idx break else: raise ValueError( 'No connected joystick or game controller device recognized by SDL has the name "{}".' .format(input_device_name.decode('utf-8'))) device_is_game_controller = bool( sdl2.SDL_IsGameController(input_device_index)) device = (sdl2.SDL_GameControllerOpen if device_is_game_controller else sdl2.SDL_JoystickOpen)(input_device_index) if not device: raise RuntimeError( 'Failed to open {} at device index {} with name "{}".'.format( 'game controller' if device_is_game_controller else 'joystick', input_device_index, input_device_name.decode('utf-8'))) if _used_idx_and_name is not None: _used_idx_and_name[0] = input_device_index _used_idx_and_name[1] = input_device_name return device, device_is_game_controller
def __init__(self, joyName=b'FrSky Taranis Joystick'): # Set up the joystick sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK) # Enumerate joysticks joyList = [] for i in range(0, sdl2.SDL_NumJoysticks()): joyList.append(sdl2.SDL_JoystickNameForIndex(i)) print(joyList) # By default, load the first available joystick or joyName. if (len(joyList) > 0): indxJoy = 0 try: indxJoy = joyList.index(joyName) except: pass self.joy = sdl2.SDL_JoystickOpen(indxJoy) else: print("Joystick Fail!") print("Joystick Name:", sdl2.SDL_JoystickName(self.joy)) print("Joystick NumAxes", sdl2.SDL_JoystickNumAxes(self.joy)) # print( "Joystick NumTrackballs:", sdl2.SDL_JoystickNumBalls(self.joy)) print("Joystick Buttons:", sdl2.SDL_JoystickNumButtons(self.joy)) # print( "Joystick NumHats:", sdl2.SDL_JoystickNumHats(self.joy)) self.axis = [] self.button = [] self.msg = [0.0] * 16
def enumerate_devices(): with contextlib.ExitStack() as estack: # We may be called from a different thread than the one that will run the SDL event loop. In case that # will happen, if SDL is not already initialized, we do not leave it initialized (if we did, it would be # bound to our current thread, which may not be desired). if not SDL_INITED: if sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK | sdl2.SDL_INIT_GAMECONTROLLER) < 0: sdl_e = sdl2.SDL_GetError() sdl_e = sdl_e.decode('utf-8') if sdl_e else 'UNKNOWN ERROR' sdl2.SDL_Quit() raise RuntimeError( 'Failed to initialize SDL ("{}").'.format(sdl_e)) estack.callback(lambda: sdl2.SDL_QuitSubSystem( sdl2.SDL_INIT_JOYSTICK | sdl2.SDL_INIT_GAMECONTROLLER)) estack.callback(sdl2.SDL_Quit) rows = [] for sdl_dev_idx in range(sdl2.SDL_NumJoysticks()): device_is_game_controller = bool( sdl2.SDL_IsGameController(sdl_dev_idx)) device_type = 'game controller' if device_is_game_controller else 'joystick' cols = [ sdl_dev_idx, device_type, sdl2.SDL_JoystickNameForIndex(sdl_dev_idx).decode('utf-8') ] if device_is_game_controller: cols.append( sdl2.SDL_GameControllerNameForIndex(sdl_dev_idx).decode( 'utf-8')) rows.append(cols) return rows
def enumerate_controllers(): print('Controllers connected to this system:') for n in range(sdl2.SDL_NumJoysticks()): name = sdl2.SDL_JoystickNameForIndex(n) if name is not None: name = name.decode('utf8') print(n, ':', name) print('Note: These are numbered by connection order. Numbers will change if you unplug a controller.')
def __init__(self, controller_id, axis_deadzone=10000, trigger_deadzone=0): # Make sure we get joystick events even if in window mode and not focused. sdl2.SDL_SetHint(sdl2.SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, b"1") sdl2.SDL_Init(sdl2.SDL_INIT_GAMECONTROLLER) # Mapping for X-box S Controller sdl2.SDL_GameControllerAddMapping( b"030000005e0400008902000021010000,Classic XBOX Controller," b"a:b0,b:b1,y:b4,x:b3,start:b7,guide:,back:b6,leftstick:b8," b"rightstick:b9,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2," b"leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2," b"righttrigger:a5,leftshoulder:b5,rightshoulder:b2,") # Mapping for 8bitdo sdl2.SDL_GameControllerAddMapping( b"05000000c82d00002038000000010000,8Bitdo NES30 Pro," b"a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8," b"dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6," b"leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1," b"rightshoulder:b7,rightstick:b14,righttrigger:a4," b"rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,") self.controller = None self.name = 'controller {:s}'.format(controller_id) self.which = None try: n = int(controller_id, 10) if n < sdl2.SDL_NumJoysticks(): self.controller = sdl2.SDL_GameControllerOpen(n) self.which = n except ValueError: for n in range(sdl2.SDL_NumJoysticks()): name = sdl2.SDL_JoystickNameForIndex(n) if name is not None: name = name.decode('utf8') if name == controller_id: self.controller = sdl2.SDL_GameControllerOpen(n) self.which = n if self.controller is None: raise Exception('Controller not found: {:s}'.format(controller_id)) try: self.name = sdl2.SDL_JoystickName( sdl2.SDL_GameControllerGetJoystick( self.controller)).decode('utf8') except AttributeError: pass logger.info('Using {:s} for input.'.format(self.name)) self.axis_deadzone = axis_deadzone self.trigger_deadzone = trigger_deadzone self.previous_state = State()
def list_joysticks(self): # Read Number of joysticks and # print the name and index to console number_of_sticks = sdl2.SDL_NumJoysticks() if number_of_sticks > 0: for i in range(number_of_sticks): print("Joystick %d : %s" % (i + 1, sdl2.SDL_JoystickNameForIndex(i))) else: print("No Joysticks connected")
def get_controller(c): try: n = int(c, 10) return sdl2.SDL_GameControllerOpen(n) except ValueError: for n in range(sdl2.SDL_NumJoysticks()): name = sdl2.SDL_JoystickNameForIndex(n) if name is not None: name = name.decode('utf8') if name == c: return sdl2.SDL_GameControllerOpen(n) raise Exception('Controller not found: %s'.format(c))
def main(): parser = argparse.ArgumentParser(description=SHORT_DESCRIPTION) parser.add_argument('server', help='Server address') parser.add_argument('port', help='Server port', type=int, default=2010, nargs='?') parser.add_argument('ship', help='Selected ship', type=int, default=0, nargs='?') parser.add_argument('--enable-pitch', help='Turn on pitch control', action='store_true') parser.add_argument('--enable-warp', help='Turn on warp lever', action='store_true') args = parser.parse_args() SDL.SDL_Init(SDL.SDL_INIT_JOYSTICK) for joy in range(SDL.SDL_NumJoysticks()): name = SDL.SDL_JoystickNameForIndex(joy) if name == b'CH FLIGHT SIM YOKE USB': joystick = Joystick(SDL.SDL_JoystickOpen(joy)) break else: print('Could not find yoke.') exit(1) tx, rx = connect(args.server, args.port) track = Tracker() def handle_input(): for packet in rx: if isinstance(packet, diana.packet.WelcomePacket): print("Connected.") tx(diana.packet.SetShipPacket(args.ship)) tx( diana.packet.SetConsolePacket(diana.packet.Console.data, True)) tx(diana.packet.ReadyPacket()) track.rx(packet) launch_thread(handle_input) while True: process_frame(joystick, tx, lambda: track.player_ship, args)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-l', '--list-controllers', action='store_true', help='Display a list of controllers attached to the system.') parser.add_argument('-c', '--controller', type=str, default='0', help='Controller to use. Default: 0.') parser.add_argument('-m', '--macro-controller', metavar='CONTROLLER:RECORD_BUTTON:PLAY_BUTTON', type=str, default=None, help='Controller and buttons to use for macro control. Default: None.') parser.add_argument('-p', '--port', type=str, default='/dev/ttyUSB0', help='Serial port or "functionfs" for direct USB mode. Default: /dev/ttyUSB0.') parser.add_argument('-b', '--baud-rate', type=int, default=115200, help='Baud rate. Default: 115200.') parser.add_argument('-u', '--udc', type=str, default='dummy_udc.0', help='UDC for direct USB mode. Default: dummy_udc.0 (loopback mode).') parser.add_argument('-R', '--record', type=str, default=None, help='Record events to file.') parser.add_argument('-P', '--playback', type=str, default=None, help='Play back events from file.') parser.add_argument('-d', '--dontexit', action='store_true', help='Switch to live input when playback finishes, instead of exiting. Default: False.') parser.add_argument('-q', '--quiet', action='store_true', help='Disable speed meter. Default: False.') parser.add_argument('-M', '--macros-dir', type=str, default='.', help='Directory to save macros. Default: current directory.') parser.add_argument('-f', '--function', type=str, nargs='*', default=[], help='Map a macro function to a button.') parser.add_argument('-D', '--log-level', type=str, default='INFO', help='Debugging level. CRITICAL, ERROR, WARNING, INFO, DEBUG. Default=INFO') args = parser.parse_args() numeric_level = getattr(logging, args.log_level.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % args.log_level) root_logger.setLevel(numeric_level) if args.list_controllers: Controller.enumerate() exit(0) states = [] if args.playback is None or args.dontexit: if args.controller == 'fake': states = fakeinput() else: states = Controller(args.controller) if args.playback is not None: states = itertools.chain(replay_states(args.playback), states) macro_controller = None macro_record = None macro_play = None if args.macro_controller is not None: try: macro_controller, macro_record, macro_play = args.macro_controller.rsplit(':', maxsplit=3) macro_record = int(macro_record, 10) macro_play = int(macro_play, 10) except ValueError: logger.critical('Macro controller must be <controller number or name>:<record button>:<play button>') exit(-1) try: n = int(macro_controller, 10) if n < sdl2.SDL_NumJoysticks(): sdl2.SDL_JoystickOpen(n) macro_controller = n except ValueError: for n in range(sdl2.SDL_NumJoysticks()): name = sdl2.SDL_JoystickNameForIndex(n) if name is not None: name = name.decode('utf8') if name == macro_controller: sdl2.SDL_JoystickOpen(n) macro_controller = n window = None try: window = Window() except sdl2.ext.common.SDLError: logger.warning('Could not create a window with SDL. Keyboard input will not be available.') pass function_macros = {} for arg in args.function: try: b,f = arg.split(':') function_macros[int(b, 10)] = macros_dict[f] except ValueError: logger.error('Invalid function macro ignored.') except KeyError: logger.error('Invalid function macro ignored.') with MacroManager(states, macros_dir=args.macros_dir, record_button=macro_record, play_button=macro_play, function_macros=function_macros) as mm: with Recorder(args.record) as record: with HAL(args.port, args.baud_rate, args.udc) as hal: with tqdm(unit=' updates', disable=args.quiet, dynamic_ncols=True) as pbar: try: while True: for event in sdl2.ext.get_events(): # we have to fetch the events from SDL in order for the controller # state to be updated. if event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE: raise WindowClosed else: if event.type == sdl2.SDL_KEYDOWN and event.key.repeat == 0: logger.debug('Key down: {:s}'.format(sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf8'))) mm.key_event(event.key.keysym.sym, True) elif event.type == sdl2.SDL_KEYUP: logger.debug('Key up: {:s}'.format(sdl2.SDL_GetKeyName(event.key.keysym.sym).decode('utf8'))) mm.key_event(event.key.keysym.sym, False) elif event.jdevice.which == macro_controller: if event.type == sdl2.SDL_JOYBUTTONDOWN: logger.debug('Macro controller button down: {:d}'.format(event.jbutton.button)) mm.button_event(event.jbutton.button, True) elif event.type == sdl2.SDL_JOYBUTTONUP: mm.button_event(event.jbutton.button, False) # wait for the arduino to request another state. if hal.poll(): state = next(mm) hal.write(state) record.write(state) pbar.set_description('Sent {:s}'.format(state.hexstr)) pbar.update() if window is not None: window.update(state) except StopIteration: logger.info('Exiting because replay finished.') except KeyboardInterrupt: logger.info('Exiting due to keyboard interrupt.') except WindowClosed: logger.info('Exiting because input window was closed.')
def on_joydeviceaddedevent(event): return 'idx: {} j_name: {}'.format(event.jdevice.which, sdl2.SDL_JoystickNameForIndex(event.jdevice.which).decode('utf-8'))
SIXAXIS try: import cPickle as pickle except: import pickle # ______ Constants & configuration ______ # # initialise joysticking error = sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK) numsticks = sdl2.SDL_NumJoysticks() print("{} Sticks found".format(numsticks+1)) for stick in range(numsticks): name = sdl2.SDL_JoystickNameForIndex(stick) print("Name of stick {} is {}".format(stick, name)) if name == b"PLAYSTATION(R)3 Controller": gamepad_obj = sdl2.SDL_JoystickOpen(stick) if sdl2.SDL_JoystickNumAxes(gamepad_obj) == 4: # Let's do a test read sdl2.SDL_PumpEvents() result = sdl2.SDL_JoystickGetAxis(gamepad_obj, 0) if result < -30000: print("Stick {} disconnected".format(stick)) else: print("Selected stick {}".format(stick)) break # Gamepad config gamepad = SIXAXIS.copy() # Copy dict from settings