| Copyright | © Patrick Pelletier 2017 |
|---|---|
| License | BSD3 |
| Maintainer | code@funwithsoftware.org |
| Stability | experimental |
| Portability | Raspberry Pi |
| Safe Haskell | None |
| Language | Haskell2010 |
System.Hardware.WiringPi
Description
This is a Haskell binding to the wiringPi library.
The functions here (mostly) correspond directly to the functions in the C
library, except for how initialization and pin numbering are handled.
To use this library, you must either run as root, or set the WIRINGPI_GPIOMEM
environment variable. However, if you set WIRINGPI_GPIOMEM, then
PWM does not work,
so to use PWM you must be root.
- data Pin
- data Value
- data Mode
- = INPUT
- | OUTPUT
- | PWM_OUTPUT
- | GPIO_CLOCK
- data Pud
- data PwmMode
- type PwmValue = Word16
- wiringPiSetupGpio :: IO ()
- pinMode :: Pin -> Mode -> IO ()
- pullUpDnControl :: Pin -> Pud -> IO ()
- digitalRead :: Pin -> IO Value
- digitalWrite :: Pin -> Value -> IO ()
- pwmWrite :: Pin -> PwmValue -> IO ()
- digitalWriteByte :: Word8 -> IO ()
- pwmSetMode :: PwmMode -> IO ()
- pwmSetRange :: PwmValue -> IO ()
- pwmSetClock :: PwmValue -> IO ()
- piBoardRev :: IO Int
- pinToBcmGpio :: Pin -> Maybe Int
Types
Represents a pin number. The constructor determines which one of the three pin numbering schemes is used.
Digital logic level.
Pin mode, used with pinMode.
Constructors
| INPUT | digital input |
| OUTPUT | digital output |
| PWM_OUTPUT | pulse-width modulation; only supported on wiringPi pin 1 |
| GPIO_CLOCK | clock output; only supported on wiringPi pin 7 |
Use with pullUpDnControl to enable internal pull-up or pull-down
resistor.
Argument to pwmSetMode to set "balanced" mode or "mark-space" mode.
Constructors
| PWM_MODE_BAL | balanced mode |
| PWM_MODE_MS | mark-space mode |
type PwmValue = Word16 Source #
Value used with pwmWrite. Typically ranges from 0-1024, but the
range can be increased up to 4096 by calling pwmSetRange.
Setup function
See WiringPi Setup functions.
Unlike the C version of wiringPi, the Haskell binding will automatically
call the setup function the first time a wiringPi function is called.
The only reason to call it manually is if you want to check for errors
earlier than your first call. It is also harmless to call it multiple
times. In the Haskell binding the "GPIO"
numbering scheme is always used internally, but the Pin constructors
allow you to choose whichever numbering scheme you want, on a pin-by-pin
basis. This avoids having to choose a single pin numbering scheme at
initialization time, as you do with the C library.
wiringPiSetupGpio :: IO () Source #
Initialize the wiringPi library. This is optional, because it will
automatically be called on the first use of a wiringPi function.
Raises an exception if the underlying C function returns an error
code. However, in practice, the C function wiringPiSetupGpio
terminates the program on error. Setting the environment variable
WIRINGPI_CODES is supposed to change this behavior, but in my
experience it doesn't, and the program is still terminated on error.
Core functions
pwmWrite :: Pin -> PwmValue -> IO () Source #
Default range is 0-1024, but it can be changed with pwmSetRange.
Additional functions
digitalWriteByte :: Word8 -> IO () Source #
Write 8 bits to the 8 pins that have wiringPi pin numbers 0-7.
pwmSetMode :: PwmMode -> IO () Source #
pwmSetRange :: PwmValue -> IO () Source #
Change the range used by pwmWrite. Default is 1024.
Maxium is 4096.
piBoardRev :: IO Int Source #
pinToBcmGpio :: Pin -> Maybe Int Source #
Converts a pin to its "Broadcom GPIO" number. This relies on
unsafePerformIO internally, because the pin mapping depends on
the board revision. Returns Nothing if the pin number is
invalid; e. g. it is out of range or is a power or ground pin
on the physical connector.