Copyright	(c) 2017 Quixoftic LLC
License	BSD3
Maintainer	Drew Hess <dhess-src@quixoftic.com>
Stability	experimental
Portability	non-portable
Safe Haskell	Trustworthy
Language	Haskell2010

System.GPIO.Types

Contents

GPIO pins
Convenience functions
PinValue conversion to/from Bool
GPIO exceptions

Description

Basic GPIO types.

Synopsis

GPIO pins

newtype Pin Source #

A GPIO pin, identified by pin number.

Note that GPIO pin numbering is platform- and runtime-dependent. See the documentation for your particular platform for an explanation of how pin numbers are assigned to physical pins.

Constructors

Pin Int

Instances

Bounded Pin Source #
Methods minBound :: Pin # maxBound :: Pin #
Enum Pin Source #
Methods succ :: Pin -> Pin # pred :: Pin -> Pin # toEnum :: Int -> Pin # fromEnum :: Pin -> Int # enumFrom :: Pin -> [Pin] # enumFromThen :: Pin -> Pin -> [Pin] # enumFromTo :: Pin -> Pin -> [Pin] # enumFromThenTo :: Pin -> Pin -> Pin -> [Pin] #
Eq Pin Source #
Methods (==) :: Pin -> Pin -> Bool # (/=) :: Pin -> Pin -> Bool #
Data Pin Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pin -> c Pin # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pin # toConstr :: Pin -> Constr # dataTypeOf :: Pin -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Pin) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pin) # gmapT :: (forall b. Data b => b -> b) -> Pin -> Pin # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pin -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pin -> r # gmapQ :: (forall d. Data d => d -> u) -> Pin -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pin -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pin -> m Pin # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pin -> m Pin # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pin -> m Pin #
Ord Pin Source #
Methods compare :: Pin -> Pin -> Ordering # (<) :: Pin -> Pin -> Bool # (<=) :: Pin -> Pin -> Bool # (>) :: Pin -> Pin -> Bool # (>=) :: Pin -> Pin -> Bool # max :: Pin -> Pin -> Pin # min :: Pin -> Pin -> Pin #
Read Pin Source #
Methods readsPrec :: Int -> ReadS Pin # readList :: ReadS [Pin] # readPrec :: ReadPrec Pin # readListPrec :: ReadPrec [Pin] #
Show Pin Source #
Methods showsPrec :: Int -> Pin -> ShowS # show :: Pin -> String # showList :: [Pin] -> ShowS #
Ix Pin Source #
Methods range :: (Pin, Pin) -> [Pin] # index :: (Pin, Pin) -> Pin -> Int # unsafeIndex :: (Pin, Pin) -> Pin -> Int inRange :: (Pin, Pin) -> Pin -> Bool # rangeSize :: (Pin, Pin) -> Int # unsafeRangeSize :: (Pin, Pin) -> Int
Generic Pin Source #
Associated Types type Rep Pin :: * -> * # Methods from :: Pin -> Rep Pin x # to :: Rep Pin x -> Pin #
Arbitrary Pin Source #
Methods arbitrary :: Gen Pin # shrink :: Pin -> [Pin] #
type Rep Pin Source #
type Rep Pin = D1 * (MetaData "Pin" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" True) (C1 * (MetaCons "Pin" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

data PinInputMode Source #

GPIO pins may support a number of different physical configurations when used as a digital input.

Pins that are capable of input will at least support the InputDefault mode. InputDefault mode is special in that, unlike the other input modes, it does not represent a unique physical configuration, but is simply a pseudonym for another (actual) input mode. Exactly which mode is used by the hardware when InputDefault mode is specified is platform-dependent. By using InputDefaut mode, you are saying that you don't care about the pin's actual configuration, other than the fact that it's being used for input.

Constructors

InputDefault	The pin's default input mode, i.e., the mode used when a more specific mode is not specified
InputFloating	A floating / high-impedance / tri-state mode which uses little power, but when disconnected, may cause the pin's value to be indeterminate
InputPullUp	The pin is connected to an internal pull-up resistor such that, when the pin is disconnected or connected to a floating / high-impedance node, its physical value will be `High`
InputPullDown	The pin is connected to an internal pull-down resistor such that, when the pin is disconnected or connected to a floating / high-impedance node, its physical value will be `Low`

Instances

Bounded PinInputMode Source #
Methods minBound :: PinInputMode # maxBound :: PinInputMode #
Enum PinInputMode Source #
Methods succ :: PinInputMode -> PinInputMode # pred :: PinInputMode -> PinInputMode # toEnum :: Int -> PinInputMode # fromEnum :: PinInputMode -> Int # enumFrom :: PinInputMode -> [PinInputMode] # enumFromThen :: PinInputMode -> PinInputMode -> [PinInputMode] # enumFromTo :: PinInputMode -> PinInputMode -> [PinInputMode] # enumFromThenTo :: PinInputMode -> PinInputMode -> PinInputMode -> [PinInputMode] #
Eq PinInputMode Source #
Methods (==) :: PinInputMode -> PinInputMode -> Bool # (/=) :: PinInputMode -> PinInputMode -> Bool #
Data PinInputMode Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinInputMode -> c PinInputMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinInputMode # toConstr :: PinInputMode -> Constr # dataTypeOf :: PinInputMode -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinInputMode) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinInputMode) # gmapT :: (forall b. Data b => b -> b) -> PinInputMode -> PinInputMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinInputMode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinInputMode -> r # gmapQ :: (forall d. Data d => d -> u) -> PinInputMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinInputMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinInputMode -> m PinInputMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinInputMode -> m PinInputMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinInputMode -> m PinInputMode #
Ord PinInputMode Source #
Methods compare :: PinInputMode -> PinInputMode -> Ordering # (<) :: PinInputMode -> PinInputMode -> Bool # (<=) :: PinInputMode -> PinInputMode -> Bool # (>) :: PinInputMode -> PinInputMode -> Bool # (>=) :: PinInputMode -> PinInputMode -> Bool # max :: PinInputMode -> PinInputMode -> PinInputMode # min :: PinInputMode -> PinInputMode -> PinInputMode #
Read PinInputMode Source #
Methods readsPrec :: Int -> ReadS PinInputMode # readList :: ReadS [PinInputMode] # readPrec :: ReadPrec PinInputMode # readListPrec :: ReadPrec [PinInputMode] #
Show PinInputMode Source #
Methods showsPrec :: Int -> PinInputMode -> ShowS # show :: PinInputMode -> String # showList :: [PinInputMode] -> ShowS #
Generic PinInputMode Source #
Associated Types type Rep PinInputMode :: * -> * # Methods from :: PinInputMode -> Rep PinInputMode x # to :: Rep PinInputMode x -> PinInputMode #
type Rep PinInputMode Source #
type Rep PinInputMode = D1 * (MetaData "PinInputMode" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * ((:+:) * (C1 * (MetaCons "InputDefault" PrefixI False) (U1 )) (C1 (MetaCons "InputFloating" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "InputPullUp" PrefixI False) (U1 )) (C1 (MetaCons "InputPullDown" PrefixI False) (U1 *))))

data PinOutputMode Source #

GPIO pins may support a number of different physical configurations when used as a digital output.

Pins that are capable of output will at least support the OutputDefault mode. OutputDefault mode is special in that, unlike the other output modes, it does not represent a unique physical configuration, but is simply a pseudonym for another (actual) output mode. Exactly which mode is used by the hardware when OutputDefault mode is specified is platform-dependent. By using OutputDefaut mode, you are saying that you don't care about the pin's actual configuration, other than the fact that it's being used for output.

Constructors

OutputDefault	The pin's default output mode, i.e., the mode used when a more specific mode is not specified
OutputPushPull	The output actively drives both the `High` and `Low` states
OutputOpenDrain	The output actively drives the `Low` state, but `High` is left floating (also known as open collector)
OutputOpenDrainPullUp	The output actively drives the `Low` state, and is connected to an internal pull-up resistor in the `High` state.
OutputOpenSource	The output actively drives the `High` state, but `Low` is left floating (also known as open emitter)
OutputOpenSourcePullDown	The output actively drives the `High` state, and is connected to an internal pull-down resistor in the `Low` state.

Instances

Bounded PinOutputMode Source #
Methods minBound :: PinOutputMode # maxBound :: PinOutputMode #
Enum PinOutputMode Source #
Methods succ :: PinOutputMode -> PinOutputMode # pred :: PinOutputMode -> PinOutputMode # toEnum :: Int -> PinOutputMode # fromEnum :: PinOutputMode -> Int # enumFrom :: PinOutputMode -> [PinOutputMode] # enumFromThen :: PinOutputMode -> PinOutputMode -> [PinOutputMode] # enumFromTo :: PinOutputMode -> PinOutputMode -> [PinOutputMode] # enumFromThenTo :: PinOutputMode -> PinOutputMode -> PinOutputMode -> [PinOutputMode] #
Eq PinOutputMode Source #
Methods (==) :: PinOutputMode -> PinOutputMode -> Bool # (/=) :: PinOutputMode -> PinOutputMode -> Bool #
Data PinOutputMode Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinOutputMode -> c PinOutputMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinOutputMode # toConstr :: PinOutputMode -> Constr # dataTypeOf :: PinOutputMode -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinOutputMode) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinOutputMode) # gmapT :: (forall b. Data b => b -> b) -> PinOutputMode -> PinOutputMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinOutputMode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinOutputMode -> r # gmapQ :: (forall d. Data d => d -> u) -> PinOutputMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinOutputMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinOutputMode -> m PinOutputMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinOutputMode -> m PinOutputMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinOutputMode -> m PinOutputMode #
Ord PinOutputMode Source #
Methods compare :: PinOutputMode -> PinOutputMode -> Ordering # (<) :: PinOutputMode -> PinOutputMode -> Bool # (<=) :: PinOutputMode -> PinOutputMode -> Bool # (>) :: PinOutputMode -> PinOutputMode -> Bool # (>=) :: PinOutputMode -> PinOutputMode -> Bool # max :: PinOutputMode -> PinOutputMode -> PinOutputMode # min :: PinOutputMode -> PinOutputMode -> PinOutputMode #
Read PinOutputMode Source #
Methods readsPrec :: Int -> ReadS PinOutputMode # readList :: ReadS [PinOutputMode] # readPrec :: ReadPrec PinOutputMode # readListPrec :: ReadPrec [PinOutputMode] #
Show PinOutputMode Source #
Methods showsPrec :: Int -> PinOutputMode -> ShowS # show :: PinOutputMode -> String # showList :: [PinOutputMode] -> ShowS #
Generic PinOutputMode Source #
Associated Types type Rep PinOutputMode :: * -> * # Methods from :: PinOutputMode -> Rep PinOutputMode x # to :: Rep PinOutputMode x -> PinOutputMode #
type Rep PinOutputMode Source #
type Rep PinOutputMode = D1 * (MetaData "PinOutputMode" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * ((:+:) * (C1 * (MetaCons "OutputDefault" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "OutputPushPull" PrefixI False) (U1 )) (C1 (MetaCons "OutputOpenDrain" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "OutputOpenDrainPullUp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "OutputOpenSource" PrefixI False) (U1 )) (C1 (MetaCons "OutputOpenSourcePullDown" PrefixI False) (U1 *)))))

data PinCapabilities Source #

Catalog a pin's capabilities.

Constructors

PinCapabilities
Fields _inputModes :: Set PinInputMode The set of input modes that the pin supports _outputModes :: Set PinOutputMode The set of output modes that the pin supports _interrupts :: Bool Does the pin support interrupts in input mode?

Instances

Eq PinCapabilities Source #
Methods (==) :: PinCapabilities -> PinCapabilities -> Bool # (/=) :: PinCapabilities -> PinCapabilities -> Bool #
Show PinCapabilities Source #
Methods showsPrec :: Int -> PinCapabilities -> ShowS # show :: PinCapabilities -> String # showList :: [PinCapabilities] -> ShowS #
Generic PinCapabilities Source #
Associated Types type Rep PinCapabilities :: * -> * # Methods from :: PinCapabilities -> Rep PinCapabilities x # to :: Rep PinCapabilities x -> PinCapabilities #
type Rep PinCapabilities Source #
type Rep PinCapabilities = D1 * (MetaData "PinCapabilities" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) (C1 * (MetaCons "PinCapabilities" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "_inputModes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Set PinInputMode))) ((::) (S1 * (MetaSel (Just Symbol "_outputModes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Set PinOutputMode))) (S1 * (MetaSel (Just Symbol "_interrupts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)))))

data PinDirection Source #

A pin's direction (input/output).

Constructors

In
Out

Instances

Bounded PinDirection Source #
Methods minBound :: PinDirection # maxBound :: PinDirection #
Enum PinDirection Source #
Methods succ :: PinDirection -> PinDirection # pred :: PinDirection -> PinDirection # toEnum :: Int -> PinDirection # fromEnum :: PinDirection -> Int # enumFrom :: PinDirection -> [PinDirection] # enumFromThen :: PinDirection -> PinDirection -> [PinDirection] # enumFromTo :: PinDirection -> PinDirection -> [PinDirection] # enumFromThenTo :: PinDirection -> PinDirection -> PinDirection -> [PinDirection] #
Eq PinDirection Source #
Methods (==) :: PinDirection -> PinDirection -> Bool # (/=) :: PinDirection -> PinDirection -> Bool #
Data PinDirection Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinDirection -> c PinDirection # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinDirection # toConstr :: PinDirection -> Constr # dataTypeOf :: PinDirection -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinDirection) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinDirection) # gmapT :: (forall b. Data b => b -> b) -> PinDirection -> PinDirection # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinDirection -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinDirection -> r # gmapQ :: (forall d. Data d => d -> u) -> PinDirection -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinDirection -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinDirection -> m PinDirection # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinDirection -> m PinDirection # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinDirection -> m PinDirection #
Ord PinDirection Source #
Methods compare :: PinDirection -> PinDirection -> Ordering # (<) :: PinDirection -> PinDirection -> Bool # (<=) :: PinDirection -> PinDirection -> Bool # (>) :: PinDirection -> PinDirection -> Bool # (>=) :: PinDirection -> PinDirection -> Bool # max :: PinDirection -> PinDirection -> PinDirection # min :: PinDirection -> PinDirection -> PinDirection #
Read PinDirection Source #
Methods readsPrec :: Int -> ReadS PinDirection # readList :: ReadS [PinDirection] # readPrec :: ReadPrec PinDirection # readListPrec :: ReadPrec [PinDirection] #
Show PinDirection Source #
Methods showsPrec :: Int -> PinDirection -> ShowS # show :: PinDirection -> String # showList :: [PinDirection] -> ShowS #
Ix PinDirection Source #
Methods range :: (PinDirection, PinDirection) -> [PinDirection] # index :: (PinDirection, PinDirection) -> PinDirection -> Int # unsafeIndex :: (PinDirection, PinDirection) -> PinDirection -> Int inRange :: (PinDirection, PinDirection) -> PinDirection -> Bool # rangeSize :: (PinDirection, PinDirection) -> Int # unsafeRangeSize :: (PinDirection, PinDirection) -> Int
Generic PinDirection Source #
Associated Types type Rep PinDirection :: * -> * # Methods from :: PinDirection -> Rep PinDirection x # to :: Rep PinDirection x -> PinDirection #
Arbitrary PinDirection Source #
Methods arbitrary :: Gen PinDirection # shrink :: PinDirection -> [PinDirection] #
type Rep PinDirection Source #
type Rep PinDirection = D1 * (MetaData "PinDirection" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * (C1 * (MetaCons "In" PrefixI False) (U1 )) (C1 (MetaCons "Out" PrefixI False) (U1 *)))

data PinActiveLevel Source #

A pin's active level (active-high/active-low).

Constructors

ActiveLow
ActiveHigh

Instances

Bounded PinActiveLevel Source #
Methods minBound :: PinActiveLevel # maxBound :: PinActiveLevel #
Enum PinActiveLevel Source #
Methods succ :: PinActiveLevel -> PinActiveLevel # pred :: PinActiveLevel -> PinActiveLevel # toEnum :: Int -> PinActiveLevel # fromEnum :: PinActiveLevel -> Int # enumFrom :: PinActiveLevel -> [PinActiveLevel] # enumFromThen :: PinActiveLevel -> PinActiveLevel -> [PinActiveLevel] # enumFromTo :: PinActiveLevel -> PinActiveLevel -> [PinActiveLevel] # enumFromThenTo :: PinActiveLevel -> PinActiveLevel -> PinActiveLevel -> [PinActiveLevel] #
Eq PinActiveLevel Source #
Methods (==) :: PinActiveLevel -> PinActiveLevel -> Bool # (/=) :: PinActiveLevel -> PinActiveLevel -> Bool #
Data PinActiveLevel Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinActiveLevel -> c PinActiveLevel # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinActiveLevel # toConstr :: PinActiveLevel -> Constr # dataTypeOf :: PinActiveLevel -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinActiveLevel) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinActiveLevel) # gmapT :: (forall b. Data b => b -> b) -> PinActiveLevel -> PinActiveLevel # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinActiveLevel -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinActiveLevel -> r # gmapQ :: (forall d. Data d => d -> u) -> PinActiveLevel -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinActiveLevel -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinActiveLevel -> m PinActiveLevel # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinActiveLevel -> m PinActiveLevel # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinActiveLevel -> m PinActiveLevel #
Ord PinActiveLevel Source #
Methods compare :: PinActiveLevel -> PinActiveLevel -> Ordering # (<) :: PinActiveLevel -> PinActiveLevel -> Bool # (<=) :: PinActiveLevel -> PinActiveLevel -> Bool # (>) :: PinActiveLevel -> PinActiveLevel -> Bool # (>=) :: PinActiveLevel -> PinActiveLevel -> Bool # max :: PinActiveLevel -> PinActiveLevel -> PinActiveLevel # min :: PinActiveLevel -> PinActiveLevel -> PinActiveLevel #
Read PinActiveLevel Source #
Methods readsPrec :: Int -> ReadS PinActiveLevel # readList :: ReadS [PinActiveLevel] # readPrec :: ReadPrec PinActiveLevel # readListPrec :: ReadPrec [PinActiveLevel] #
Show PinActiveLevel Source #
Methods showsPrec :: Int -> PinActiveLevel -> ShowS # show :: PinActiveLevel -> String # showList :: [PinActiveLevel] -> ShowS #
Ix PinActiveLevel Source #
Methods range :: (PinActiveLevel, PinActiveLevel) -> [PinActiveLevel] # index :: (PinActiveLevel, PinActiveLevel) -> PinActiveLevel -> Int # unsafeIndex :: (PinActiveLevel, PinActiveLevel) -> PinActiveLevel -> Int inRange :: (PinActiveLevel, PinActiveLevel) -> PinActiveLevel -> Bool # rangeSize :: (PinActiveLevel, PinActiveLevel) -> Int # unsafeRangeSize :: (PinActiveLevel, PinActiveLevel) -> Int
Generic PinActiveLevel Source #
Associated Types type Rep PinActiveLevel :: * -> * # Methods from :: PinActiveLevel -> Rep PinActiveLevel x # to :: Rep PinActiveLevel x -> PinActiveLevel #
Arbitrary PinActiveLevel Source #
Methods arbitrary :: Gen PinActiveLevel # shrink :: PinActiveLevel -> [PinActiveLevel] #
type Rep PinActiveLevel Source #
type Rep PinActiveLevel = D1 * (MetaData "PinActiveLevel" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * (C1 * (MetaCons "ActiveLow" PrefixI False) (U1 )) (C1 (MetaCons "ActiveHigh" PrefixI False) (U1 *)))

data PinValue Source #

A pin's signal level as a binary value.

Constructors

Low
High

Instances

Bounded PinValue Source #
Methods minBound :: PinValue # maxBound :: PinValue #
Enum PinValue Source #
Methods succ :: PinValue -> PinValue # pred :: PinValue -> PinValue # toEnum :: Int -> PinValue # fromEnum :: PinValue -> Int # enumFrom :: PinValue -> [PinValue] # enumFromThen :: PinValue -> PinValue -> [PinValue] # enumFromTo :: PinValue -> PinValue -> [PinValue] # enumFromThenTo :: PinValue -> PinValue -> PinValue -> [PinValue] #
Eq PinValue Source #
Methods (==) :: PinValue -> PinValue -> Bool # (/=) :: PinValue -> PinValue -> Bool #
Data PinValue Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinValue -> c PinValue # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinValue # toConstr :: PinValue -> Constr # dataTypeOf :: PinValue -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinValue) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinValue) # gmapT :: (forall b. Data b => b -> b) -> PinValue -> PinValue # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinValue -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinValue -> r # gmapQ :: (forall d. Data d => d -> u) -> PinValue -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinValue -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinValue -> m PinValue # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinValue -> m PinValue # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinValue -> m PinValue #
Ord PinValue Source #
Methods compare :: PinValue -> PinValue -> Ordering # (<) :: PinValue -> PinValue -> Bool # (<=) :: PinValue -> PinValue -> Bool # (>) :: PinValue -> PinValue -> Bool # (>=) :: PinValue -> PinValue -> Bool # max :: PinValue -> PinValue -> PinValue # min :: PinValue -> PinValue -> PinValue #
Read PinValue Source #
Methods readsPrec :: Int -> ReadS PinValue # readList :: ReadS [PinValue] # readPrec :: ReadPrec PinValue # readListPrec :: ReadPrec [PinValue] #
Show PinValue Source #
Methods showsPrec :: Int -> PinValue -> ShowS # show :: PinValue -> String # showList :: [PinValue] -> ShowS #
Ix PinValue Source #
Methods range :: (PinValue, PinValue) -> [PinValue] # index :: (PinValue, PinValue) -> PinValue -> Int # unsafeIndex :: (PinValue, PinValue) -> PinValue -> Int inRange :: (PinValue, PinValue) -> PinValue -> Bool # rangeSize :: (PinValue, PinValue) -> Int # unsafeRangeSize :: (PinValue, PinValue) -> Int
Generic PinValue Source #
Associated Types type Rep PinValue :: * -> * # Methods from :: PinValue -> Rep PinValue x # to :: Rep PinValue x -> PinValue #
Arbitrary PinValue Source #
Methods arbitrary :: Gen PinValue # shrink :: PinValue -> [PinValue] #
Bits PinValue Source #
Methods (.&.) :: PinValue -> PinValue -> PinValue # (.\|.) :: PinValue -> PinValue -> PinValue # xor :: PinValue -> PinValue -> PinValue # complement :: PinValue -> PinValue # shift :: PinValue -> Int -> PinValue # rotate :: PinValue -> Int -> PinValue # zeroBits :: PinValue # bit :: Int -> PinValue # setBit :: PinValue -> Int -> PinValue # clearBit :: PinValue -> Int -> PinValue # complementBit :: PinValue -> Int -> PinValue # testBit :: PinValue -> Int -> Bool # bitSizeMaybe :: PinValue -> Maybe Int # bitSize :: PinValue -> Int # isSigned :: PinValue -> Bool # shiftL :: PinValue -> Int -> PinValue # unsafeShiftL :: PinValue -> Int -> PinValue # shiftR :: PinValue -> Int -> PinValue # unsafeShiftR :: PinValue -> Int -> PinValue # rotateL :: PinValue -> Int -> PinValue # rotateR :: PinValue -> Int -> PinValue # popCount :: PinValue -> Int #
FiniteBits PinValue Source #
Methods finiteBitSize :: PinValue -> Int # countLeadingZeros :: PinValue -> Int # countTrailingZeros :: PinValue -> Int #
type Rep PinValue Source #
type Rep PinValue = D1 * (MetaData "PinValue" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * (C1 * (MetaCons "Low" PrefixI False) (U1 )) (C1 (MetaCons "High" PrefixI False) (U1 *)))

data PinInterruptMode Source #

A pin's interrupt mode.

Note that the pin's interrupt mode is defined in terms of the pin's logical signal value; i.e., when the pin is configured for active-low logic, RisingEdge refers to the physical signal's trailing edge, and FallingEdge refers to the physical signal's rising edge.

Constructors

Disabled	Interrupts are disabled
RisingEdge	Interrupt on the pin's (logical) rising edge
FallingEdge	Interrupt on the pin's (logical) falling edge
Level	Interrupt on any change to the pin's signal level

Instances

Bounded PinInterruptMode Source #
Methods minBound :: PinInterruptMode # maxBound :: PinInterruptMode #
Enum PinInterruptMode Source #
Methods succ :: PinInterruptMode -> PinInterruptMode # pred :: PinInterruptMode -> PinInterruptMode # toEnum :: Int -> PinInterruptMode # fromEnum :: PinInterruptMode -> Int # enumFrom :: PinInterruptMode -> [PinInterruptMode] # enumFromThen :: PinInterruptMode -> PinInterruptMode -> [PinInterruptMode] # enumFromTo :: PinInterruptMode -> PinInterruptMode -> [PinInterruptMode] # enumFromThenTo :: PinInterruptMode -> PinInterruptMode -> PinInterruptMode -> [PinInterruptMode] #
Eq PinInterruptMode Source #
Methods (==) :: PinInterruptMode -> PinInterruptMode -> Bool # (/=) :: PinInterruptMode -> PinInterruptMode -> Bool #
Data PinInterruptMode Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PinInterruptMode -> c PinInterruptMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PinInterruptMode # toConstr :: PinInterruptMode -> Constr # dataTypeOf :: PinInterruptMode -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c PinInterruptMode) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PinInterruptMode) # gmapT :: (forall b. Data b => b -> b) -> PinInterruptMode -> PinInterruptMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PinInterruptMode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PinInterruptMode -> r # gmapQ :: (forall d. Data d => d -> u) -> PinInterruptMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PinInterruptMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PinInterruptMode -> m PinInterruptMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PinInterruptMode -> m PinInterruptMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PinInterruptMode -> m PinInterruptMode #
Ord PinInterruptMode Source #
Methods compare :: PinInterruptMode -> PinInterruptMode -> Ordering # (<) :: PinInterruptMode -> PinInterruptMode -> Bool # (<=) :: PinInterruptMode -> PinInterruptMode -> Bool # (>) :: PinInterruptMode -> PinInterruptMode -> Bool # (>=) :: PinInterruptMode -> PinInterruptMode -> Bool # max :: PinInterruptMode -> PinInterruptMode -> PinInterruptMode # min :: PinInterruptMode -> PinInterruptMode -> PinInterruptMode #
Read PinInterruptMode Source #
Methods readsPrec :: Int -> ReadS PinInterruptMode # readList :: ReadS [PinInterruptMode] # readPrec :: ReadPrec PinInterruptMode # readListPrec :: ReadPrec [PinInterruptMode] #
Show PinInterruptMode Source #
Methods showsPrec :: Int -> PinInterruptMode -> ShowS # show :: PinInterruptMode -> String # showList :: [PinInterruptMode] -> ShowS #
Generic PinInterruptMode Source #
Associated Types type Rep PinInterruptMode :: * -> * # Methods from :: PinInterruptMode -> Rep PinInterruptMode x # to :: Rep PinInterruptMode x -> PinInterruptMode #
Arbitrary PinInterruptMode Source #
Methods arbitrary :: Gen PinInterruptMode # shrink :: PinInterruptMode -> [PinInterruptMode] #
type Rep PinInterruptMode Source #
type Rep PinInterruptMode = D1 * (MetaData "PinInterruptMode" "System.GPIO.Types" "hpio-0.9.0.0-4Le2271dab5KLTBHMSo257" False) ((:+:) * ((:+:) * (C1 * (MetaCons "Disabled" PrefixI False) (U1 )) (C1 (MetaCons "RisingEdge" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "FallingEdge" PrefixI False) (U1 )) (C1 (MetaCons "Level" PrefixI False) (U1 *))))

Convenience functions

pinNumber :: Pin -> Int Source #

Get the pin number as an Int.

>>> pinNumber (Pin 5)
5

invertDirection :: PinDirection -> PinDirection Source #

Invert a PinDirection value.

>>> invertDirection In
Out
>>> invertDirection Out
In

invertValue :: PinValue -> PinValue Source #

Invert a PinValue.

>>> invertValue High
Low
>>> invertValue Low
High

PinValue conversion to/from Bool

valueToBool :: PinValue -> Bool Source #

Convert a PinValue to its logical boolean equivalent.

>>> valueToBool High
True
>>> valueToBool Low
False

boolToValue :: Bool -> PinValue Source #

Convert a Bool to its logical PinValue equivalent.

>>> boolToValue True
High
>>> boolToValue False
Low

GPIO exceptions

data SomeGpioException Source #

The top level of the GPIO exception hierarchy.

Constructors

Exception e => SomeGpioException e

Instances

Show SomeGpioException Source #
Methods showsPrec :: Int -> SomeGpioException -> ShowS # show :: SomeGpioException -> String # showList :: [SomeGpioException] -> ShowS #
Exception SomeGpioException Source #
Methods toException :: SomeGpioException -> SomeException # fromException :: SomeException -> Maybe SomeGpioException # displayException :: SomeGpioException -> String #

gpioExceptionToException :: Exception e => e -> SomeException Source #

Convert SomeGpioException to SomeException.

gpioExceptionFromException :: Exception e => SomeException -> Maybe e Source #

Ask whether an exception is SomeGpioException.