Device.Nintendo.Switch

Types and functions for connecting to Nintendo Switch controllers, reading input (e.g., buttons, sensors) and sending commands (e.g., rumble).

Connection

Switch Console

data Console

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

Instances

Eq Console

Defined in Device.Nintendo.Switch.Connection

Methods

(==) :: Console -> Console -> Bool

(/=) :: Console -> Console -> Bool

Ord Console

Defined in Device.Nintendo.Switch.Connection

Methods

compare :: Console -> Console -> Ordering

(<) :: Console -> Console -> Bool

(<=) :: Console -> Console -> Bool

(>) :: Console -> Console -> Bool

(>=) :: Console -> Console -> Bool

max :: Console -> Console -> Console

min :: Console -> Console -> Console

Read Console

Defined in Device.Nintendo.Switch.Connection

Methods

readsPrec :: Int -> ReadS Console

readList :: ReadS [Console]

readPrec :: ReadPrec Console

readListPrec :: ReadPrec [Console]

Show Console

Defined in Device.Nintendo.Switch.Connection

Methods

showsPrec :: Int -> Console -> ShowS

show :: Console -> String

showList :: [Console] -> ShowS

init :: IO Console

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.

exit :: Console -> IO ()

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

withConsole :: (Console -> IO a) -> IO a

A convenient wrapper around init and exit.

Switch Controllers

data ControllerType

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).

Constructors

LeftJoyCon

RightJoyCon

ProController

Instances

Eq ControllerType

Defined in Device.Nintendo.Switch.Controller

Methods

(==) :: ControllerType -> ControllerType -> Bool

(/=) :: ControllerType -> ControllerType -> Bool

Read ControllerType

Defined in Device.Nintendo.Switch.Controller

Methods

readsPrec :: Int -> ReadS ControllerType

readList :: ReadS [ControllerType]

readPrec :: ReadPrec ControllerType

readListPrec :: ReadPrec [ControllerType]

Show ControllerType

Defined in Device.Nintendo.Switch.Controller

Methods

showsPrec :: Int -> ControllerType -> ShowS

show :: ControllerType -> String

showList :: [ControllerType] -> ShowS

HasInputMode 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasInputMode 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasPlayerLights 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasPlayerLights 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasPlayerLights 'ProController

Defined in Device.Nintendo.Switch.Output

HasRightRumble 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasRightRumble 'ProController

Defined in Device.Nintendo.Switch.Output

HasLeftRumble 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasLeftRumble 'ProController

Defined in Device.Nintendo.Switch.Output

HasHomeLight 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasHomeLight 'ProController

Defined in Device.Nintendo.Switch.Output

data ControllerInfo (t :: ControllerType)

A handle which represents an unconnected Nintendo Switch controller.

Instances

Show (ControllerInfo t)

Defined in Device.Nintendo.Switch.Connection

Methods

showsPrec :: Int -> ControllerInfo t -> ShowS

show :: ControllerInfo t -> String

showList :: [ControllerInfo t] -> ShowS

data Controller (t :: ControllerType)

A handle which represents a connected Nintendo Switch controller.

getControllerInfos :: forall t. IsController t => Console -> IO [ControllerInfo t]

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

connect

Arguments

:: forall t. HasCalibration t

=> ControllerInfo t

The detected Nintendo Switch controller.

-> IO (Controller t)

The connected Nintendo Switch controller.

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).

disconnect :: Controller t -> IO ()

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

withController :: HasCalibration t => ControllerInfo t -> (Controller t -> IO a) -> IO a

A convenient wrapper around connect and disconnect.

Controller Input

Input Mode

data InputMode

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

Constructors

Standard

The default input mode. In this mode, controllers push Input packages in a 60Hz (Joy-Con) or 120Hz (Pro Controller) frequency, including battery information, Analog stick directions (stickLeft, stickRight) and Inertial sensor data (extras) if activated via setInertialMeasurement.

Simple

A simple input mode where a controller only pushes its Input whenever a button is pressed or a CommandReply (extras) is sent. In this mode, controllers only send Discrete stick directions (stickLeft, stickRight) and no inertial sensor data. Furthermore, battery information is only sent in combination with command replies.

Instances

Eq InputMode

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: InputMode -> InputMode -> Bool

(/=) :: InputMode -> InputMode -> Bool

Read InputMode

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS InputMode

readList :: ReadS [InputMode]

readPrec :: ReadPrec InputMode

readListPrec :: ReadPrec [InputMode]

Show InputMode

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> InputMode -> ShowS

show :: InputMode -> String

showList :: [InputMode] -> ShowS

setInputMode :: HasInputMode t => InputMode -> Controller t -> IO ()

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.

setInertialMeasurement :: Bool -> Controller t -> IO ()

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.

Getting Input

getInput :: HasInput t => Controller t -> IO Input

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

getTimeoutInput

Arguments

:: HasInput t

=> Int

The time interval in milliseconds.

-> Controller t

The controller to read the input from.

-> IO (Maybe Input)

Returns Nothing if the controller does not provide an input within the specified time interval.

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

Input Types

type Input = ControllerInput Float Float

The input provided by a Nintendo Switch controller.

data ControllerInput s e

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).

Constructors

Input

Fields

• btnL :: Bool
• btnZL :: Bool
• btnMinus :: Bool
• btnLeftStick :: Bool
• btnUp :: Bool
• btnLeft :: Bool
• btnRight :: Bool
• btnDown :: Bool
• btnCapture :: Bool
• btnLeftSL :: Bool
• btnLeftSR :: Bool
• btnR :: Bool
• btnZR :: Bool
• btnPlus :: Bool
• btnX :: Bool
• btnY :: Bool
• btnA :: Bool
• btnB :: Bool
• btnRightStick :: Bool
• btnHome :: Bool
• btnRightSL :: Bool
• btnRightSR :: Bool
• stickLeft :: StickDirection s
• stickRight :: StickDirection s
• extras :: ExtraInput e
• battery :: Maybe BatteryInfo

Instances

(Eq s, Eq e) => Eq (ControllerInput s e)

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: ControllerInput s e -> ControllerInput s e -> Bool

(/=) :: ControllerInput s e -> ControllerInput s e -> Bool

(Read s, Read e) => Read (ControllerInput s e)

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS (ControllerInput s e)

readList :: ReadS [ControllerInput s e]

readPrec :: ReadPrec (ControllerInput s e)

readListPrec :: ReadPrec [ControllerInput s e]

(Show s, Show e) => Show (ControllerInput s e)

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> ControllerInput s e -> ShowS

show :: ControllerInput s e -> String

showList :: [ControllerInput s e] -> ShowS

data StickDirection a

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

Constructors

Discrete Direction

In Simple input mode, controllers send discrete stick directions.

Analog a a

In Standard input mode, controllers send analog stick directions. The first value is left/right (interval [-1,1]), the second value is down/up (interval [-1,1]).

Instances

Functor StickDirection

Defined in Device.Nintendo.Switch.Input

Methods

fmap :: (a -> b) -> StickDirection a -> StickDirection b

(<$) :: a -> StickDirection b -> StickDirection a

Eq a => Eq (StickDirection a)

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: StickDirection a -> StickDirection a -> Bool

(/=) :: StickDirection a -> StickDirection a -> Bool

Read a => Read (StickDirection a)

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS (StickDirection a)

readList :: ReadS [StickDirection a]

readPrec :: ReadPrec (StickDirection a)

readListPrec :: ReadPrec [StickDirection a]

Show a => Show (StickDirection a)

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> StickDirection a -> ShowS

show :: StickDirection a -> String

showList :: [StickDirection a] -> ShowS

data Direction

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

Constructors

None

Left

Up

Right

Down

LeftUp

LeftDown

RightUp

RightDown

Instances

Eq Direction

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: Direction -> Direction -> Bool

(/=) :: Direction -> Direction -> Bool

Read Direction

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS Direction

readList :: ReadS [Direction]

readPrec :: ReadPrec Direction

readListPrec :: ReadPrec [Direction]

Show Direction

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> Direction -> ShowS

show :: Direction -> String

showList :: [Direction] -> ShowS

data BatteryInfo

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.

Constructors

BatteryInfo

Fields

• batteryStatus :: BatteryStatus
• charging :: Bool

Instances

Eq BatteryInfo

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: BatteryInfo -> BatteryInfo -> Bool

(/=) :: BatteryInfo -> BatteryInfo -> Bool

Read BatteryInfo

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS BatteryInfo

readList :: ReadS [BatteryInfo]

readPrec :: ReadPrec BatteryInfo

readListPrec :: ReadPrec [BatteryInfo]

Show BatteryInfo

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> BatteryInfo -> ShowS

show :: BatteryInfo -> String

showList :: [BatteryInfo] -> ShowS

data BatteryStatus

The battery status of a Nintendo Switch controller.

Constructors

Empty

Low

Medium

Good

Full

Instances

Eq BatteryStatus

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: BatteryStatus -> BatteryStatus -> Bool

(/=) :: BatteryStatus -> BatteryStatus -> Bool

Ord BatteryStatus

Defined in Device.Nintendo.Switch.Input

Methods

compare :: BatteryStatus -> BatteryStatus -> Ordering

(<) :: BatteryStatus -> BatteryStatus -> Bool

(<=) :: BatteryStatus -> BatteryStatus -> Bool

(>) :: BatteryStatus -> BatteryStatus -> Bool

(>=) :: BatteryStatus -> BatteryStatus -> Bool

max :: BatteryStatus -> BatteryStatus -> BatteryStatus

min :: BatteryStatus -> BatteryStatus -> BatteryStatus

Read BatteryStatus

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS BatteryStatus

readList :: ReadS [BatteryStatus]

readPrec :: ReadPrec BatteryStatus

readListPrec :: ReadPrec [BatteryStatus]

Show BatteryStatus

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> BatteryStatus -> ShowS

show :: BatteryStatus -> String

showList :: [BatteryStatus] -> ShowS

data ExtraInput a

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).

Constructors

CommandReply ReplyData

After sending commands to the controller (e.g., setting the InputMode), a command reply is returned as extra data in the next input.

Inertial (Accelerometer a) (Gyroscope a)

A controller provides inertial sensor data (i.e., accelerometer and gyroscope) only if it is in Standard input mode and inertial measurement is activated via setInertialMeasurement.

Regarding the x/y/z coordinate system, consider the left Joy-Con lying flat on a table, the analog stick pointing up. The x-axis then points towards the Z/ZL shoulder buttons (or alternatively: to where the up arrow button is pointing), the y-axis points to the opposite side of the SL/SR buttons (or alternatively: to where the left arrow button is pointing), and the z-axis points up in the air. The coordinate system is the same for all controller types.

Unavailable

Indicates that there is no additional input data.

Instances

Functor ExtraInput

Defined in Device.Nintendo.Switch.Input

Methods

fmap :: (a -> b) -> ExtraInput a -> ExtraInput b

(<$) :: a -> ExtraInput b -> ExtraInput a

Eq a => Eq (ExtraInput a)

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: ExtraInput a -> ExtraInput a -> Bool

(/=) :: ExtraInput a -> ExtraInput a -> Bool

Read a => Read (ExtraInput a)

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS (ExtraInput a)

readList :: ReadS [ExtraInput a]

readPrec :: ReadPrec (ExtraInput a)

readListPrec :: ReadPrec [ExtraInput a]

Show a => Show (ExtraInput a)

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> ExtraInput a -> ShowS

show :: ExtraInput a -> String

showList :: [ExtraInput a] -> ShowS

type Accelerometer a = ((a, a, a), (a, a, a), (a, a, a))

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.

type Gyroscope a = ((a, a, a), (a, a, a), (a, a, a))

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 ReplyData

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

Constructors

SetHomeLight (Acknowledgement ())

SetInertialMeasurement (Acknowledgement ())

SetInputMode (Acknowledgement ())

SetPlayerLights (Acknowledgement ())

SetVibration (Acknowledgement ())

Instances

Eq ReplyData

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: ReplyData -> ReplyData -> Bool

(/=) :: ReplyData -> ReplyData -> Bool

Read ReplyData

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS ReplyData

readList :: ReadS [ReplyData]

readPrec :: ReadPrec ReplyData

readListPrec :: ReadPrec [ReplyData]

Show ReplyData

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> ReplyData -> ShowS

show :: ReplyData -> String

showList :: [ReplyData] -> ShowS

data Acknowledgement a

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

Constructors

ACK a

The command was executed successfully, possibly holding some response data (e.g., if the command was a query of the internal SPI flash memory).

NACK

The command was not executed successfully.

Instances

Functor Acknowledgement

Defined in Device.Nintendo.Switch.Input

Methods

fmap :: (a -> b) -> Acknowledgement a -> Acknowledgement b

(<$) :: a -> Acknowledgement b -> Acknowledgement a

Eq a => Eq (Acknowledgement a)

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: Acknowledgement a -> Acknowledgement a -> Bool

(/=) :: Acknowledgement a -> Acknowledgement a -> Bool

Read a => Read (Acknowledgement a)

Defined in Device.Nintendo.Switch.Input

Methods

readsPrec :: Int -> ReadS (Acknowledgement a)

readList :: ReadS [Acknowledgement a]

readPrec :: ReadPrec (Acknowledgement a)

readListPrec :: ReadPrec [Acknowledgement a]

Show a => Show (Acknowledgement a)

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> Acknowledgement a -> ShowS

show :: Acknowledgement a -> String

showList :: [Acknowledgement a] -> ShowS

Convenience

noInput :: ControllerInput s e

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 }

coordinates :: StickDirection Float -> (Float, Float)

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.

mergeInputs

Arguments

:: Input

The left-side input to be merged.

-> Input

The right-side input to be merged.

-> Input

The merged input, without extras and battery.

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).

withCommandReply

Arguments

:: Int

The maximum count of inputs that should be consumed.

-> Int

The timeout per input read (see getTimeoutInput).

-> Controller t

The controller to read the input from.

-> (ReplyData -> Maybe a)

The function which checks the command reply. It must return Nothing if a ReplyData is encountered which we are not looking for, or Just a if everything went well.

-> IO a

The data extracted from the expected command reply.

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).

Controller Output

Home Light

setHomeLight :: HasHomeLight t => HomeLightConfig -> Controller t -> IO ()

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.

data HomeLightConfig

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

Constructors

Off

Turn off the home light.

Once BaseDuration Intensity CycleConfig

Given a start intensity of the home light LED, fade to a target LED intensity in a given time, and then keep this LED intensity up for a given amount of time.

The fade duration in milliseconds is calculated by multiplying the BaseDuration with the FadeFactor of the CycleConfig. The light upkeep duration in milliseconds is calculated by multiplying the BaseDuration with the LightFactor of the CycleConfig.

Example - fade from a switched off LED (0) to a fully bright LED (100) in 500ms (50ms * 10), stay there for one second (50ms * 20), then turn it off:

    Once 50 0 (100, 10, 20)

Cyclic BaseDuration Intensity [CycleConfig] RepeatBehaviour

Given a start intensity of the home light LED, repeatedly fade to a target LED intensity in a given time, and then keep this LED intensity up for a given amount of time. The fade durations and light upkeep durations are calculated per cycle configuration as described for Once. See endlessPulse for a cyclic configuration example.

Instances

Eq HomeLightConfig

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: HomeLightConfig -> HomeLightConfig -> Bool

(/=) :: HomeLightConfig -> HomeLightConfig -> Bool

Read HomeLightConfig

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS HomeLightConfig

readList :: ReadS [HomeLightConfig]

readPrec :: ReadPrec HomeLightConfig

readListPrec :: ReadPrec [HomeLightConfig]

Show HomeLightConfig

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> HomeLightConfig -> ShowS

show :: HomeLightConfig -> String

showList :: [HomeLightConfig] -> ShowS

type CycleConfig = (Intensity, FadeFactor, LightFactor)

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.

type BaseDuration = Word8

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.

type Intensity = Word8

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

type FadeFactor = Word8

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.

type LightFactor = Word8

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.

data RepeatBehaviour

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

Instances

Eq RepeatBehaviour

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: RepeatBehaviour -> RepeatBehaviour -> Bool

(/=) :: RepeatBehaviour -> RepeatBehaviour -> Bool

Read RepeatBehaviour

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS RepeatBehaviour

readList :: ReadS [RepeatBehaviour]

readPrec :: ReadPrec RepeatBehaviour

readListPrec :: ReadPrec [RepeatBehaviour]

Show RepeatBehaviour

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> RepeatBehaviour -> ShowS

show :: RepeatBehaviour -> String

showList :: [RepeatBehaviour] -> ShowS

endlessPulse :: HomeLightConfig

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.

Player Lights

setPlayerLights :: HasPlayerLights t => PlayerLightsConfig -> Controller t -> IO ()

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.

data PlayerLightsConfig

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).

Constructors

PlayerLightsConfig

Fields

• led0 :: LightMode
• led1 :: LightMode
• led2 :: LightMode
• led3 :: LightMode

Instances

Eq PlayerLightsConfig

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: PlayerLightsConfig -> PlayerLightsConfig -> Bool

(/=) :: PlayerLightsConfig -> PlayerLightsConfig -> Bool

Read PlayerLightsConfig

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS PlayerLightsConfig

readList :: ReadS [PlayerLightsConfig]

readPrec :: ReadPrec PlayerLightsConfig

readListPrec :: ReadPrec [PlayerLightsConfig]

Show PlayerLightsConfig

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> PlayerLightsConfig -> ShowS

show :: PlayerLightsConfig -> String

showList :: [PlayerLightsConfig] -> ShowS

data LightMode

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

Constructors

LightOn

LightOff

Flashing

Instances

Eq LightMode

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: LightMode -> LightMode -> Bool

(/=) :: LightMode -> LightMode -> Bool

Read LightMode

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS LightMode

readList :: ReadS [LightMode]

readPrec :: ReadPrec LightMode

readListPrec :: ReadPrec [LightMode]

Show LightMode

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> LightMode -> ShowS

show :: LightMode -> String

showList :: [LightMode] -> ShowS

noPlayerLights :: PlayerLightsConfig

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

playerOne :: PlayerLightsConfig

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

playerTwo :: PlayerLightsConfig

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

playerThree :: PlayerLightsConfig

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

playerFour :: PlayerLightsConfig

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

flashAll :: PlayerLightsConfig

A convenient player lights configuration where all LEDs are flashing.

Rumble

setVibration :: Bool -> Controller t -> IO ()

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.

setLeftRumble :: HasLeftRumble t => RumbleConfig -> Controller t -> IO ()

Sets the left rumble of a Nintendo Switch controller.

setRightRumble :: HasRightRumble t => RumbleConfig -> Controller t -> IO ()

Sets the right rumble of a Nintendo Switch controller.

setRumble

Arguments

:: (HasLeftRumble t, HasRightRumble t)

=> RumbleConfig

The left-side rumble configuration.

-> RumbleConfig

The right-side rumble configuration.

-> Controller t

The controller which should rumble.

-> IO ()

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.

data RumbleConfig

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.

Constructors

RumbleConfig

Fields

• highFrequency :: Double

  The high frequency. It will always be limited to an interval between 81.75177 Hz and 1252.572266 Hz.

• highAmplitude :: Double

  The high amplitude. It will always be limited to an interval between 0.0 and 1.0.

• lowFrequency :: Double

  The low frequency. It will always be limited to an interval between 40.875885 Hz and 626.286133 Hz.

• lowAmplitude :: Double

  The low amplitude. It will always be limited to an interval between 0.0 and 1.0.

Instances

Eq RumbleConfig

Defined in Device.Nintendo.Switch.Output

Methods

(==) :: RumbleConfig -> RumbleConfig -> Bool

(/=) :: RumbleConfig -> RumbleConfig -> Bool

Read RumbleConfig

Defined in Device.Nintendo.Switch.Output

Methods

readsPrec :: Int -> ReadS RumbleConfig

readList :: ReadS [RumbleConfig]

readPrec :: ReadPrec RumbleConfig

readListPrec :: ReadPrec [RumbleConfig]

Show RumbleConfig

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> RumbleConfig -> ShowS

show :: RumbleConfig -> String

showList :: [RumbleConfig] -> ShowS

normalRumble :: RumbleConfig

A convenient rumble configuration indicating a medium rumble strength.

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

noRumble :: RumbleConfig

A convenient rumble configuration indicating no rumble.

Exceptions

data ConnectionException

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).

Constructors

NoFactoryStickException

Indicates that a controller has no factory stick calibration.

NoFactoryAxisException

Indicates that a controller has no factory sensor calibration.

Instances

Eq ConnectionException

Defined in Device.Nintendo.Switch.Connection

Methods

(==) :: ConnectionException -> ConnectionException -> Bool

(/=) :: ConnectionException -> ConnectionException -> Bool

Show ConnectionException

Defined in Device.Nintendo.Switch.Connection

Methods

showsPrec :: Int -> ConnectionException -> ShowS

show :: ConnectionException -> String

showList :: [ConnectionException] -> ShowS

Exception ConnectionException

Defined in Device.Nintendo.Switch.Connection

Methods

toException :: ConnectionException -> SomeException

fromException :: SomeException -> Maybe ConnectionException

displayException :: ConnectionException -> String

data InputException

An InputException is thrown if something goes wrong with getInput.

Constructors

NoReplyException

Indicates that an expected reply wasn't received in a specific time interval.

UnknownFormatException ByteString

Indicates that the controller input has an unexpected format. It essentially means that a specific part of the protocol has not been implemented yet. This should not occur as long as you stick to the public API of this library.

Instances

Eq InputException

Defined in Device.Nintendo.Switch.Input

Methods

(==) :: InputException -> InputException -> Bool

(/=) :: InputException -> InputException -> Bool

Show InputException

Defined in Device.Nintendo.Switch.Input

Methods

showsPrec :: Int -> InputException -> ShowS

show :: InputException -> String

showList :: [InputException] -> ShowS

Exception InputException

Defined in Device.Nintendo.Switch.Input

Methods

toException :: InputException -> SomeException

fromException :: SomeException -> Maybe InputException

displayException :: InputException -> String

data OutputException

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

Constructors

WriteException

Instances

Show OutputException

Defined in Device.Nintendo.Switch.Output

Methods

showsPrec :: Int -> OutputException -> ShowS

show :: OutputException -> String

showList :: [OutputException] -> ShowS

Exception OutputException

Defined in Device.Nintendo.Switch.Output

Methods

toException :: OutputException -> SomeException

fromException :: SomeException -> Maybe OutputException

displayException :: OutputException -> String

Type Classes

class IsController (t :: ControllerType)

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

Minimal complete definition

productID

Instances

IsController 'LeftJoyCon

Defined in Device.Nintendo.Switch.Connection

Methods

productID :: ProductID

vendorID :: VendorID

IsController 'RightJoyCon

Defined in Device.Nintendo.Switch.Connection

Methods

productID :: ProductID

vendorID :: VendorID

IsController 'ProController

Defined in Device.Nintendo.Switch.Connection

Methods

productID :: ProductID

vendorID :: VendorID

class HasCalibration (t :: ControllerType)

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

Minimal complete definition

calibrate

Instances

HasCalibration 'LeftJoyCon

Defined in Device.Nintendo.Switch.Controller

Methods

calibrate :: RawCalibration -> Calibration

HasCalibration 'RightJoyCon

Defined in Device.Nintendo.Switch.Controller

Methods

calibrate :: RawCalibration -> Calibration

HasCalibration 'ProController

Defined in Device.Nintendo.Switch.Controller

Methods

calibrate :: RawCalibration -> Calibration

class HasInputMode t

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

Instances

HasInputMode 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasInputMode 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

class HasInput t

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

Minimal complete definition

convert

Instances

HasInput 'LeftJoyCon

Defined in Device.Nintendo.Switch.Input

Methods

convert :: Controller 'LeftJoyCon -> RawInput -> Input

HasInput 'RightJoyCon

Defined in Device.Nintendo.Switch.Input

Methods

convert :: Controller 'RightJoyCon -> RawInput -> Input

HasInput 'ProController

Defined in Device.Nintendo.Switch.Input

Methods

convert :: Controller 'ProController -> RawInput -> Input

class HasHomeLight t

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

Instances

HasHomeLight 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasHomeLight 'ProController

Defined in Device.Nintendo.Switch.Output

class HasPlayerLights t

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

Instances

HasPlayerLights 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasPlayerLights 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasPlayerLights 'ProController

Defined in Device.Nintendo.Switch.Output

class HasLeftRumble t

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

Instances

HasLeftRumble 'LeftJoyCon

Defined in Device.Nintendo.Switch.Output

HasLeftRumble 'ProController

Defined in Device.Nintendo.Switch.Output

class HasRightRumble t

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

Instances

HasRightRumble 'RightJoyCon

Defined in Device.Nintendo.Switch.Output

HasRightRumble 'ProController

Defined in Device.Nintendo.Switch.Output