A handle which represents a virtual Nintendo Switch console. The handle is used to detect controllers and manage their connections.

Initializes a Nintendo Switch console handle. In other words, it lets us pretend to be Nintendo Switch console in order to detect controllers and manage their connections. You must call this first before doing anything else.

Destroys a virtual Nintendo Switch handle. You must call this when you are finished talking to the controllers.

A convenient wrapper around init and exit.

The types of Nintendo Switch controllers that are currently supported by this library.

Note that this type is mostly used on the type level (using DataKinds) in order to prevent programming mistakes at compile-time (e.g., to prevent sending a rumble command to a controller which has no rumble feature).

Chances are very high that you don't need this type on the value level, but rather on the type level, for example via TypeApplications (see getControllerInfos).

A handle which represents an unconnected Nintendo Switch controller.

A handle which represents a connected Nintendo Switch controller.

Detects all Nintendo Switch controllers of a specific ControllerType, usually connected via Bluetooth.

You may want to use this function with TypeApplications if the controller type cannot be inferred, like:

    getControllerInfos @'LeftJoyCon console

Connects to a detected Nintendo Switch controller.

Can throw a ConnectionException if something is very wrong with your internal controller memory (i.e., if you have tampered with it).

Disconnects a Nintendo Switch controller. You must not use the controller handle after disconnecting.

A convenient wrapper around connect and disconnect.

The input mode of a Nintendo Switch controller determines the frequency and amount of information received by getInput.

Sets the input mode of a Nintendo Switch controller.

Note: After sending a command like this to a controller, it is highly advised to check its corresponding CommandReply (SetInputMode, to be exact) or at least call getInput once before sending another command to that controller. The function withCommandReply is a convenient way to wait for a specific command reply from the controller.

Enables (True) or disables (False) the inertial measurement unit (i.e., accelerometer, gyroscope) of a Nintendo Switch controller. Inertial measurement is disabled by default.

Note: After sending a command like this to a controller, it is highly advised to check its corresponding CommandReply (SetInertialMeasurement, to be exact) or at least call getInput once before sending another command to that controller. The function withCommandReply is a convenient way to wait for a specific command reply from the controller.

Reads input from a Nintendo Switch controller. Blocks until controller input is available.

Reads input from a Nintendo Switch controller. Blocks until controller input is available or a given time interval elapses.

The input provided by a Nintendo Switch controller.

The input provided by a Nintendo Switch controller, where s is the numeric type of the analog stick direction and e is the numeric type of the sensor readings (i.e., accelerometer and gyroscope).

The direction of the left (stickLeft) and right (stickRight) analog sticks.

The nine possible discrete positions of the analog stick in Simple input mode.

Information about the battery of a Nintendo Switch controller. It is only returned by getInput (see battery) if the controller sends a command reply or the input mode of the controller is Standard.

The battery status of a Nintendo Switch controller.

Depending on the InputMode, Input can contain additional information: Replies to commands (e.g., an acknowledgement when sending a rumble command) and inertial sensor data (i.e., accelerometer and gyroscope).

Accelerometer data consists of three measurements recorded in 15ms (i.e., the precision is 5ms). Each measurement is an x/y/z triple measured in Gs.

Gyroscope data consists of three measurements recorded in 15ms (i.e., the precision is 5ms). Each measurement is an x/y/z triple measured in radians per second.

Data type that combines the command type and its corresponding acknowledgement.

Whenever a command is sent to a controller (e.g., setting the InputMode), the controller replies with an Acknowledgement.

A convenient constant that represents no input. This can be used to set specific buttons and stick directions in order to test functions without having a Nintendo Switch controller at hand, like:

    noInput { btnX = True, stickLeft = Discrete Up }

Converts stick directions into x/y coordinates in the interval [-1,1]. Analog values are taken as is, while Discrete directions are converted to their analog counterpart.

Merges the inputs of two Nintendo Switch controllers. The resulting input contains the left button states and left analog stick direction from one input, and the right button states and right analog stick direction from the other input. This can be used to unify the inputs of two controllers that belong together (e.g., a pair of left and right Joy-Cons).

Note that the extras and battery information of the original inputs are discarded in the merged input (they are set to Unavailable and Nothing, respectively).

Consumes inputs from a Nintendo Switch controller until a specific command reply is encountered. Throws a NoReplyException if the expected command reply is not encountered within a specified count of inputs.

This function can be used to make sure that the controller is in an expected state after sending commands (e.g., to wait for an Acknowledgement after switching its InputMode).

Sets the home light (i.e., the LED ring around the home button) of a Nintendo Switch controller.

Note: After sending a command like this to a controller, it is highly advised to check its corresponding CommandReply (SetHomeLight, to be exact) or at least call getInput once before sending another command to that controller. The function withCommandReply is a convenient way to wait for a specific command reply from the controller.

The home light of a Nintendo Switch Controller can be controlled using repeatable configuration cycles. See endlessPulse for an example configuration.

A home light cycle consists of a target LED intensity, a fade factor which controls the time needed to reach that LED intensity, and a light factor which controls how long to keep the target LED intensity up.

The base duration of a home light configuration in milliseconds. It will always be limited to an interval between 8ms and 175ms. It is called base duration because it will be multiplied with other factors in order to obtain the overall durations of fadings within home light configurations.

The LED intensity of the home light. It will always be limited to an interval between 0 and 100.

The fade duration factor of the home light. It will always be limited to an interval between 0 and 15 and is multiplied with the BaseDuration to obtain the overall fade duration in milliseconds.

The light duration factor of the home light. It will always be limited to an interval between 0 and 15 and is multiplied with the BaseDuration to obtain the overall light duration in milliseconds.

Defines the repeat behaviour after all the home light configuration cycles have ended.

A convenient home light configuration which pulsates the home light LED:

    Cyclic
      ( 100 )         -- Base duration factor is 100ms.
      (   0 )         -- LED is turned off at the beginning (intensity 0).
      [ (100, 5, 1)   -- Fade to LED intensity 100 in 500ms (100ms * 5) and stay there for 100ms (100ms * 1).
      , (  0, 5, 1) ] -- Fade to LED intensity   0 in 500ms (100ms * 5) and stay there for 100ms (100ms * 1).
      ( Forever )     -- Repeat these two cycles forever, thus generating a pulse-like LED.

Sets the player lights of a Nintendo Switch controller.

Note: After sending a command like this to a controller, it is highly advised to check its corresponding CommandReply (SetPlayerLights, to be exact) or at least call getInput once before sending another command to that controller. The function withCommandReply is a convenient way to wait for a specific command reply from the controller.

Nintendo Switch controllers have four LEDs that can be used to indicate various things, for example the player number or the Bluetooth pairing status. The LEDs are numbered from left to right (i.e., led0 is the leftmost LED, led3 is the rightmost LED).

Each player light LED can be individually turned on, turned off or used in a pulsating manner (i.e., flashing).

A convenient player lights configuration where all LEDs are turned off.

A convenient player lights configuration indicating player one (i.e., led0 is set).

A convenient player lights configuration indicating player two (i.e., led1 is set).

A convenient player lights configuration indicating player three (i.e., led2 is set).

A convenient player lights configuration indicating player four (i.e., led3 is set).

A convenient player lights configuration where all LEDs are flashing.

Enables (True) or disables (False) the rumble feature of a Nintendo Switch controller. The rumble feature is disabled by default.

Note: After sending a command like this to a controller, it is highly advised to check its corresponding CommandReply (SetVibration, to be exact) or at least call getInput once before sending another command to that controller. The function withCommandReply is a convenient way to wait for a specific command reply from the controller.

Sets the left rumble of a Nintendo Switch controller.

Sets the right rumble of a Nintendo Switch controller.

Sets both the left rumble and right rumble of a Nintendo Switch controller. Note that this is more efficient than setting the left rumble and right rumble separately via setLeftRumble and setRightRumble.

Nintendo Switch controllers have a HD rumble feature which allows fine-grained control of rumble strengths and directions. As a consequence, a rumble is not configured by a mere numeric value, but by two (high and low) pairs of frequencies and amplitudes. This library constrains the value ranges of frequencies and amplitudes in order to always obtain sane configurations. However, sending extreme values for these pairs over an extended period of time may still damage a controller, so experiment wisely with rather short rumbles.

For technical discussions and the meaning of these values, one can read this, for example. A sample rumble configuration is provided by normalRumble.

A convenient rumble configuration indicating a medium rumble strength.

    RumbleConfig
      { highFrequency = 800
      , highAmplitude = 0.5
      , lowFrequency  = 330
      , lowAmplitude  = 0.75
      }

A convenient rumble configuration indicating no rumble.

A ConnectionException is thrown if something goes wrong when reading the internal data of a Nintendo Switch controller when connecting to it. This should not occur if you have an unmodified controller (i.e., you have not tampered with its internal SPI flash memory).

An InputException is thrown if something goes wrong with getInput.

An OutputException is thrown if something goes wrong when sending commands to a Nintendo Switch controller.

A constraint which indicates that a controller is a valid Nintendo Switch controller that can be detected and connected to.

A constraint which indicates that a Nintendo Switch controller is able to turn portions of its internal flash memory into valid calibration information.

A constraint which indicates that a Nintendo Switch controller supports multiple input modes (see setInputMode).

A constraint which indicates that a Nintendo Switch controller can provide Input (see getInput).

A constraint which indicates that a Nintendo Switch controller has a home light (see setHomeLight).

A constraint which indicates that a Nintendo Switch controller has player lights (i.e., the four LEDs which represent the player number; see setPlayerLights).

A constraint which indicates that a Nintendo Switch controller has a left-side rumble unit (see setLeftRumble).

A constraint which indicates that a Nintendo Switch controller has a right-side rumble unit (see setRightRumble).