Uses of Class
jpigpio.PigpioException

Packages that use PigpioException 
Package Description
frc.team670.pi.sensors  
frc.team670.pi.tests  
frc.team670.robot.commands.drive  
jpigpio  
jpigpio.devices  
jpigpio.impl  
jpigpio.packet  
jpigpio.sensors  

  • Uses of PigpioException in frc.team670.pi.sensors

    Constructors in frc.team670.pi.sensors that throw PigpioException 
    Constructor Description
    Encoder​(int leftP, int rightP, boolean reversed)
    Creates an encoder on 2 pins which can be used to get data from the motor

  • Uses of PigpioException in frc.team670.pi.tests

    Methods in frc.team670.pi.tests that throw PigpioException 
    Modifier and Type Method Description
    static void EncoderTest.main​(java.lang.String[] args)  

  • Uses of PigpioException in frc.team670.robot.commands.drive

    Constructors in frc.team670.robot.commands.drive that throw PigpioException 
    Constructor Description
    CurveStraightDrive​(double dist, double lspeed, double rspeed, double secs)  

  • Uses of PigpioException in jpigpio

    Subclasses of PigpioException in jpigpio 
    Modifier and Type Class Description
    class  BadValueException
    An extension of the general PigpioException to indicate that a value is invalid
    class  NotImplementedException
    An extension of the general PigpioException to indicate that a function was called that has not yet been implemented.
    class  WrongModeException
    An exception that states that a pin is in the wrong mode.
    Methods in jpigpio that throw PigpioException 
    Modifier and Type Method Description
    void JPigpio.addCallback​(GPIOListener listener)
    Calls a user supplied function (a callback) whenever the specified GPIO edge is detected.

    The user supplied callback receives three parameters, the GPIO, the level, and the tick.

    If a user callback is not specified a default tally callback is provided which simply counts edges.
    void Pigpio.addCallback​(GPIOListener gpioListener)
    Not implemented
    void PigpioSocket.addCallback​(GPIOListener gpioListener)  
    void GPIO.delay​(long delay, int type)  
    long JPigpio.getCurrentTick()  
    long Pigpio.getCurrentTick()  
    long PigpioSocket.getCurrentTick()  
    int GPIO.getDirection()  
    int JPigpio.getPWMDutycycle​(int gpio)
    Returns the PWM dutycycle being used on the GPIO.

    For normal PWM the dutycycle will be out of the defined range for the GPIO (see [*getPWMRange*]).

    If a hardware clock is active on the GPIO the reported dutycycle will be 500000 (500k) out of 1000000 (1M).

    If hardware PWM is active on the GPIO the reported dutycycle will be out of a 1000000 (1M).
    int Pigpio.getPWMDutycycle​(int gpio)
    Not implemented
    int PigpioSocket.getPWMDutycycle​(int gpio)  
    int JPigpio.getPWMFrequency​(int gpio)
    Returns the frequency of PWM being used on the GPIO.

    Returns the frequency (in Hz) used for the GPIO.

    For normal PWM the frequency will be that defined for the GPIO by [*setPWMFrequency*].

    If a hardware clock is active on the GPIO the reported frequency will be that set by [*hardwareClock*].

    If hardware PWM is active on the GPIO the reported frequency will be that set by [*hardwarePWM*].
    int Pigpio.getPWMFrequency​(int gpio)
    Not implemented
    int PigpioSocket.getPWMFrequency​(int gpio)  
    int JPigpio.getPWMRange​(int gpio)
    Returns the range of PWM values being used on the GPIO.

    If a hardware clock or hardware PWM is active on the GPIO the reported range will be 1000000 (1M).
    int Pigpio.getPWMRange​(int gpio)
    Not implemented
    int PigpioSocket.getPWMRange​(int gpio)  
    int JPigpio.getPWMRealRange​(int gpio)
    Returns the real (underlying) range of PWM values being used on the GPIO.
    int Pigpio.getPWMRealRange​(int gpio)
    Not implemented
    int PigpioSocket.getPWMRealRange​(int gpio)  
    int JPigpio.getServoPulseWidth​(int gpio)
    Returns the servo pulsewidth being used on the GPIO.
    int Pigpio.getServoPulseWidth​(int gpio)
    Not implemented
    int PigpioSocket.getServoPulseWidth​(int gpio)
    Not implemented
    boolean GPIO.getValue()  
    void JPigpio.gpioDelay​(long delay)
    Delay for the specified number of microseconds
    void JPigpio.gpioDelay​(long delay, int type)  
    void Pigpio.gpioDelay​(long delay)  
    void PigpioSocket.gpioDelay​(long delay)  
    int JPigpio.gpioGetMode​(int gpio)
    Retrieve the mode of the given gpio
    int Pigpio.gpioGetMode​(int pin)  
    int PigpioSocket.gpioGetMode​(int pin)  
    void JPigpio.gpioInitialize()  
    void Pigpio.gpioInitialize()  
    void PigpioSocket.gpioInitialize()  
    boolean JPigpio.gpioRead​(int gpio)
    Retrieve the state of the gpio
    boolean Pigpio.gpioRead​(int pin)  
    boolean PigpioSocket.gpioRead​(int pin)  
    void JPigpio.gpioServo​(int gpio, int pulseWidth)
    Starts (500-2500) or stops (0) servo pulses on the GPIO.
    The selected pulsewidth will continue to be transmitted until changed by a subsequent call to set_servo_pulsewidth.

    The pulsewidths supported by servos varies and should probably be determined by experiment.
    void Pigpio.gpioServo​(int gpio, int pulseWidth)  
    void PigpioSocket.gpioServo​(int gpio, int pulseWidth)  
    void JPigpio.gpioSetAlertFunc​(int gpio, Alert alert)  
    void Pigpio.gpioSetAlertFunc​(int pin, Alert alert)  
    void PigpioSocket.gpioSetAlertFunc​(int pin, Alert gpioAlert)  
    void JPigpio.gpioSetMode​(int gpio, int mode)
    Set the mode of the gpio
    void Pigpio.gpioSetMode​(int pin, int mode)  
    void PigpioSocket.gpioSetMode​(int pin, int mode)  
    void JPigpio.gpioSetPullUpDown​(int gpio, int pud)  
    void Pigpio.gpioSetPullUpDown​(int pin, int pud)  
    void PigpioSocket.gpioSetPullUpDown​(int pin, int pud)  
    void JPigpio.gpioShiftOut​(int gpioData, int gpioClock, boolean clockLevel, boolean bitOrder, byte value)
    Shift out a byte of data to a given pin.
    void JPigpio.gpioShiftOut​(int gpioData, int gpioClock, boolean bitOrder, byte value)
    Shift out a byte of data to a given pin.
    void JPigpio.gpioShiftOut​(GPIO gpioData, GPIO gpioClock, boolean clockLevel, boolean bitOrder, byte value)  
    void JPigpio.gpioShiftOut​(GPIO gpioData, GPIO gpioClock, boolean bitOrder, byte value)  
    void JPigpio.gpioTerminate()
    Terminate the usage of the pigpio interfaces.
    void Pigpio.gpioTerminate()  
    void PigpioSocket.gpioTerminate()  
    long JPigpio.gpioTick()  
    long Pigpio.gpioTick()  
    long PigpioSocket.gpioTick()  
    void JPigpio.gpioTrigger​(int gpio, long pulseLen, boolean level)
    Set the specified gpio to the level specified by level for the duration (in micro-sec) specified by pulseLen and then set the gpio back to not-level.
    void Pigpio.gpioTrigger​(int gpio, long pulseLen, boolean level)  
    void PigpioSocket.gpioTrigger​(int gpio, long pulseLen, boolean level)  
    void JPigpio.gpioWrite​(int gpio, boolean value)
    Set the state of the gpio
    void Pigpio.gpioWrite​(int pin, boolean value)  
    void PigpioSocket.gpioWrite​(int pin, boolean value)  
    long JPigpio.gpioxPulseAndWait​(int outGpio, int inGpio, long waitDuration, long pulseHoldDuration, boolean pulseLow)
    Pulse a named pin and then wait for a response on a different pin.
    long Pigpio.gpioxPulseAndWait​(int outGpio, int inGpio, long waitDuration, long pulseHoldDuration, boolean pulseLow)  
    long PigpioSocket.gpioxPulseAndWait​(int outGpio, int inGpio, long waitDuration, long pulseHoldDuration, boolean pulseLow)
    Not implemented
    void JPigpio.i2cClose​(int handle)
    Closes the I2C device associated with handle.
    void Pigpio.i2cClose​(int handle)  
    void PigpioSocket.i2cClose​(int handle)  
    int JPigpio.i2cOpen​(int i2cBus, int i2cAddr)
    Returns a handle (>=0) for the device at the I2C bus address.

    i2c_flags:= 0, no flags are currently defined.

    Normally you would only use the [*i2c_**] functions if you are or will be connecting to the Pi over a network.
    int Pigpio.i2cOpen​(int i2cBus, int i2cAddr)  
    int PigpioSocket.i2cOpen​(int i2cBus, int i2cAddr)  
    int JPigpio.i2cReadDevice​(int handle, byte[] data)
    Returns count bytes read from the raw device associated with handle.
    int Pigpio.i2cReadDevice​(int handle, byte[] data)  
    int PigpioSocket.i2cReadDevice​(int handle, byte[] data)  
    void JPigpio.i2cWriteDevice​(int handle, byte[] data)
    Writes the data bytes to the raw device associated with handle.
    void Pigpio.i2cWriteDevice​(int handle, byte[] data)  
    void PigpioSocket.i2cWriteDevice​(int handle, byte[] data)  
    void JPigpio.notifyBegin​(int handle, int bits)
    Starts notifications on a handle.

    The notification sends state changes for each GPIO whose corresponding bit in bits is set.
    void Pigpio.notifyBegin​(int handle, int bits)
    Not implemented
    void PigpioSocket.notifyBegin​(int handle, int bits)  
    void JPigpio.notifyClose​(int handle)
    Stops notifications on a handle and releases the handle for reuse.
    void Pigpio.notifyClose​(int handle)
    Not implemented
    void PigpioSocket.notifyClose​(int handle)  
    int JPigpio.notifyOpen()
    Returns a notification handle (>=0).

    A notification is a method for being notified of GPIO state changes via a pipe.

    Pipes are only accessible from the local machine so this function serves no purpose if you are using Python from a remote machine.
    int Pigpio.notifyOpen()
    Not implemented
    int PigpioSocket.notifyOpen()  
    void JPigpio.notifyPause​(int handle)
    Pauses notifications on a handle.

    Notifications for the handle are suspended until [*notify_begin*] is called again.
    void Pigpio.notifyPause​(int handle)
    Not implemented
    void PigpioSocket.notifyPause​(int handle)  
    void JPigpio.reconnect()
    Try reconnecting to pigpio.
    void Pigpio.reconnect()
    Not implemented
    void PigpioSocket.reconnect()  
    void JPigpio.removeCallback​(GPIOListener listener)
    Remove callback listener object from notification thread.
    void Pigpio.removeCallback​(GPIOListener cgpioListener)
    Not implemented
    void PigpioSocket.removeCallback​(GPIOListener gpioListener)  
    void JPigpio.serialClose​(int handle)
    Closes the serial device associated with handle.
    void Pigpio.serialClose​(int handle)
    Not implemented
    void PigpioSocket.serialClose​(int handle)  
    int JPigpio.serialDataAvailable​(int handle)
    Returns the number of bytes available to be read from the device associated with handle.
    int Pigpio.serialDataAvailable​(int handle)
    Not implemented
    int PigpioSocket.serialDataAvailable​(int handle)  
    int JPigpio.serialOpen​(java.lang.String tty, int baudRate, int flags)
    Returns a handle for the serial tty device opened at baud bits per second.

    Normally you would only use the [*serial_**] functions if you are or will be connecting to the Pi over a network.
    int Pigpio.serialOpen​(java.lang.String tty, int baudRate, int flags)
    Not implemented
    int PigpioSocket.serialOpen​(java.lang.String tty, int baudRate, int flags)  
    byte[] JPigpio.serialRead​(int handle, int count)
    Reads up to count bytes from the device associated with handle.

    The returned value is a tuple of the number of bytes read and a bytearray containing the bytes.
    byte[] Pigpio.serialRead​(int handle, int count)
    Not implemented
    byte[] PigpioSocket.serialRead​(int handle, int count)  
    byte JPigpio.serialReadByte​(int handle)
    Returns a single byte from the device associated with handle.
    byte Pigpio.serialReadByte​(int handle)
    Not implemented
    byte PigpioSocket.serialReadByte​(int handle)  
    void JPigpio.serialWrite​(int handle, byte[] data)
    Writes the data bytes to the device associated with handle.
    void Pigpio.serialWrite​(int handle, byte[] data)
    Not implemented
    void PigpioSocket.serialWrite​(int handle, byte[] data)  
    void JPigpio.serialWriteByte​(int handle, byte data)
    Writes a single byte to the device associated with handle.
    void Pigpio.serialWriteByte​(int handle, byte data)
    Not implemented
    void PigpioSocket.serialWriteByte​(int handle, byte data)  
    void GPIO.setAlert​(Alert alert)  
    void JPigpio.setDebug​(boolean flag)  
    void PigpioSocket.setDebug​(boolean flag)
    Not implemented
    void GPIO.setDirection​(int direction)  
    void GPIO.setPulldown​(int pulldown)  
    void JPigpio.setPWMDutycycle​(int gpio, int dutycycle)
    Starts (non-zero dutycycle) or stops (0) PWM pulses on the GPIO.
    void Pigpio.setPWMDutycycle​(int gpio, int dutycycle)  
    void PigpioSocket.setPWMDutycycle​(int gpio, int dutycycle)  
    int JPigpio.setPWMFrequency​(int gpio, int frequency)
    Sets the frequency (in Hz) of the PWM to be used on the GPIO.

    Returns the frequency actually set.
    int Pigpio.setPWMFrequency​(int gpio, int frequency)
    Not implemented
    int PigpioSocket.setPWMFrequency​(int gpio, int frequency)  
    void JPigpio.setPWMRange​(int gpio, int range)
    Sets the range of PWM values to be used on the GPIO.
    void Pigpio.setPWMRange​(int gpio, int range)
    Not implemented
    void PigpioSocket.setPWMRange​(int gpio, int range)  
    void JPigpio.setServoPulseWidth​(int gpio, int pulseWidth)  
    void Pigpio.setServoPulseWidth​(int gpio, int pulseWidth)  
    void PigpioSocket.setServoPulseWidth​(int gpio, int pulseWidth)  
    void GPIO.setValue​(boolean value)  
    void GPIO.setValue​(int value)  
    void JPigpio.setWatchdog​(int userGpio, int timeout)
    Sets a watchdog timeout for a GPIO.

    The watchdog is nominally in milliseconds.

    Only one watchdog may be registered per GPIO.

    The watchdog may be cancelled by setting timeout to 0.

    If no level change has been detected for the GPIO for timeout milliseconds any notification for the GPIO has a report written to the fifo with the flags set to indicate a watchdog timeout.

    The callback class interprets the flags and will call registered notificationListeners for the GPIO with level TIMEOUT.
    void Pigpio.setWatchdog​(int userGpio, int timeout)
    Not implemented
    void PigpioSocket.setWatchdog​(int userGpio, int timeout)  
    void JPigpio.spiClose​(int handle)
    Closes the SPI device associated with handle.
    void Pigpio.spiClose​(int handle)  
    void PigpioSocket.spiClose​(int handle)  
    int JPigpio.spiOpen​(int channel, int baudRate, int flags)
    Returns a handle for the SPI device on channel.
    int Pigpio.spiOpen​(int channel, int baudRate, int flags)  
    int PigpioSocket.spiOpen​(int spiChannel, int spiBaudRate, int flags)  
    int JPigpio.spiRead​(int handle, byte[] data)
    Reads count bytes from the SPI device associated with handle.

    The returned value is a tuple of the number of bytes read and a bytearray containing the bytes.
    int Pigpio.spiRead​(int handle, byte[] data)  
    int PigpioSocket.spiRead​(int handle, byte[] data)  
    int JPigpio.spiWrite​(int handle, byte[] data)
    Writes the data bytes to the SPI device associated with handle.
    int Pigpio.spiWrite​(int handle, byte[] data)  
    int PigpioSocket.spiWrite​(int handle, byte[] data)  
    int JPigpio.spiXfer​(int handle, byte[] txData, byte[] rxData)
    Writes the data bytes to the SPI device associated with handle, returning the data bytes read from the device.

    The returned value is a tuple of the number of bytes read and a bytearray containing the bytes.
    int Pigpio.spiXfer​(int handle, byte[] txData, byte[] rxData)  
    int PigpioSocket.spiXfer​(int handle, byte[] txData, byte[] rxData)  
    int JPigpio.waveAddGeneric​(java.util.ArrayList<Pulse> pulses)
    Adds a list of pulses to the current waveform.

    Returns the new total number of pulses in the current waveform.

    The pulses are interleaved in time order within the existing waveform (if any).

    Merging allows the waveform to be built in parts, that is the settings for GPIO#1 can be added, and then GPIO#2 etc.

    If the added waveform is intended to start after or within the existing waveform then the first pulse should consist solely of a delay.
    int Pigpio.waveAddGeneric​(java.util.ArrayList<Pulse> pulses)
    Not implemented
    int PigpioSocket.waveAddGeneric​(java.util.ArrayList<Pulse> pulses)  
    void JPigpio.waveAddNew()
    Starts a new empty waveform.

    You would not normally need to call this function as it is automatically called after a waveform is created with the [*wave_create*] function.
    void Pigpio.waveAddNew()
    Not implemented
    void PigpioSocket.waveAddNew()  
    int JPigpio.waveAddSerial​(int gpio, int baud, byte[] data, int offset, int bbBits, int bbStop)
    Adds a waveform representing serial data to the existing waveform (if any).
    int Pigpio.waveAddSerial​(int userGpio, int baud, byte[] data, int offset, int bbBits, int bbStop)
    Not implemented
    int PigpioSocket.waveAddSerial​(int userGpio, int baud, byte[] data, int offset, int bbBits, int bbStop)  
    void JPigpio.waveClear()
    This function clears all waveforms and any data added by calls to the wave_add_* functions.
    void Pigpio.waveClear()
    Not implemented
    void PigpioSocket.waveClear()  
    int JPigpio.waveCreate()
    Creates a waveform from the data provided by the prior calls to the [*wave_add_**] functions.

    Returns a wave id (>=0) if OK, otherwise PI_EMPTY_WAVEFORM, PI_TOO_MANY_CBS, PI_TOO_MANY_OOL, or PI_NO_WAVEFORM_ID.

    The data provided by the [*wave_add_**] functions is consumed by this function.

    As many waveforms may be created as there is space available.
    int Pigpio.waveCreate()
    Not implemented
    int PigpioSocket.waveCreate()  
    void JPigpio.waveDelete​(int waveId)
    This function deletes the waveform with id wave_id.

    Wave ids are allocated in order, 0, 1, 2, etc.
    void Pigpio.waveDelete​(int waveId)
    Not implemented
    void PigpioSocket.waveDelete​(int waveId)  
    int JPigpio.waveSendOnce​(int waveId)
    Transmits the waveform with id wave_id.
    int Pigpio.waveSendOnce​(int waveId)
    Not implemented
    int PigpioSocket.waveSendOnce​(int waveId)  
    int JPigpio.waveSendRepeat​(int waveId)
    Transmits the waveform with id wave_id.
    int Pigpio.waveSendRepeat​(int waveId)
    Not implemented
    int PigpioSocket.waveSendRepeat​(int waveId)  
    boolean JPigpio.waveTxBusy()
    Returns 1 if a waveform is currently being transmitted, otherwise 0.
    boolean Pigpio.waveTxBusy()
    Not implemented
    boolean PigpioSocket.waveTxBusy()  
    int JPigpio.waveTxStop()
    Stops the transmission of the current waveform.

    This function is intended to stop a waveform started with wave_send_repeat.
    int Pigpio.waveTxStop()
    Not implemented
    int PigpioSocket.waveTxStop()  
    Constructors in jpigpio that throw PigpioException 
    Constructor Description
    GPIO​(JPigpio pigpio, int pin, int direction)  
    PigpioSocket​(java.lang.String host, int port)
    The constructor of the class.

  • Uses of PigpioException in jpigpio.devices

    Methods in jpigpio.devices that throw PigpioException 
    Modifier and Type Method Description
    void Stepper.backward()
    Move the stepper backwards one step.
    void LCD.clear()  
    void NRF24L01.clearRegisterBits​(int reg, byte bits)
    Clear specified bits in single-byte register
    void NRF24L01.config​(int payloadSize)
    Configure the parameters of the device.
    void NRF24L01.configRegister​(int reg, byte value)
    (DEPRECATED) Write single byte to specified register.
    Use method writeByteRegister instead.
    boolean NRF24L01.dataReady()
    Checks if data is available for reading in RX FIFO
    void NRF24L01.disableCRC()
    Disable CRC
    void VS1053.disableMidi()
    The LCtech board contains a design flaw.
    void VS1053.dump()  
    void VS1053.endSineTest()
    End the sine test
    void Stepper.forward()
    Move the stepper forward one step.
    void LCD.functionModeSet()  
    int NRF24L01.getAddressWidth()
    Return address width in bytes
    int VS1053.getAudata()  
    byte NRF24L01.getAutomaticRetransmission()  
    int VS1053.getBass()
    Get the Bass register value.
    byte NRF24L01.getChannel()
    Get frequency channel nRF24 chip is currently using
    int VS1053.getClockF()
    Read the ClockF register of the device.
    byte NRF24L01.getConfig()
    Read CONFIG register
    boolean NRF24L01.getData​(byte[] data)
    Read data received into the array
    byte NRF24L01.getFIFOStatus()  
    int VS1053.getMode()
    Retrieve the device mode register value.
    byte[][] NRF24L01.getRXAddresses()
    Read addresses receiver is listening from
    byte NRF24L01.getStatus()
    Read STATUS register
    int VS1053.getStatus()
    Retrieve the status register of the device.
    byte[] NRF24L01.getTXAddress()
    Read transmitter address - source address
    int VS1053.getVolume()
    Read the volume register of the device.
    void LCD.home()  
    boolean NRF24L01.init​(int cePin, int csnPin)
    Initialize nRF24 chip and set the defaults
    boolean NRF24L01.isSending()
    Test if chip is still sending.
    void VS1053.memoryTest()
    Perform a memory test
    void VS1053.playFile​(java.io.File file)
    Play a data file through the device.
    void NRF24L01.powerDown()  
    byte NRF24L01.readByteRegister​(int reg)
    Reads single one-byte register
    void NRF24L01.readRegister​(int reg, byte[] value)
    Reads an array of bytes from the given start position in the MiRF registers.
    void NRF24L01.reset()
    Set initial chip parameters according to nRF24 documentation
    boolean NRF24L01.rxFifoEmpty()  
    void SP0256.sayAlophone​(byte value)  
    void NRF24L01.send​(byte[] value)
    Send up to 32 bytes of data.
    void NRF24L01.setAddressWidth​(int width)
    Set RX/TX address width.
    void VS1053.setAudata​(int value)  
    void NRF24L01.setAutoACK​(boolean enable)
    Enable or disable automatic packet acknowledgements.
    void NRF24L01.setAutoACK​(int pipe, boolean enable)
    Enable or disable automatic packet acknowledgements for specific pipe.
    void LCD.setBlink​(boolean value)
    Set whether or not the cursor blinks.
    void NRF24L01.setChannel​(int ch)
    Set frequency channel nRF24 operates on
    void VS1053.setClockF​(int value)
    Set the ClockF value.
    void NRF24L01.setCRCSize​(int crcSize)
    Set CRC size
    void LCD.setCursor​(boolean value)
    Set whether or not the cursor is shown.
    void NRF24L01.setDataRate​(int dataRate)
    Sets data rate
    void LCD.setDisplay​(boolean value)
    Set the display visibility of the LCD.
    void LCD.setFontHeight​(int height)
    Set the height of the font.
    void VS1053.setLine​(boolean value)
    Set the Line vs Mic mode.
    void LCD.setLines​(int lines)
    Set the number of display lines ...
    void VS1053.setMode​(int value)
    Set the device mode register to a supplied value.
    void NRF24L01.setPALevel​(int level)
    Sets TX output power level.
    void NRF24L01.setPayloadSize​(int size)
    Set payload (packet) size for all pipes
    void NRF24L01.setPayloadSize​(int pipe, int size)
    Set payload (packet) size for specific pipe
    void NRF24L01.setRADDR​(byte[] adr)
    Sets receiving address P1.
    void NRF24L01.setRegisterBits​(int reg, byte bits)
    Set specified bits in single-byte register
    void NRF24L01.setRetries​(int delay, int count)
    Configure delay between retransmissions and number of retransmissions.

    Set 1500uS (minimum for 32B payload in ESB@250KBPS) timeouts, to make testing a little easier
    WARNING: If this is ever lowered, either 250KBS mode with AA is broken or maximum packet sizes must never be used.
    void NRF24L01.setTADDR​(byte[] adr, boolean setP0Too)
    Sets the transmitting address.
    void VS1053.setTestMode​(boolean mode)
    Enable or disable the test mode of the device.
    void Servo.setValue​(int value)
    Set a control value
    void VS1053.setVolume​(int value)
    A volume value is replicated in the high and low bytes of the volume word
    void VS1053.softReset()
    Perform a soft reset of the device.
    void NRF24L01.startListening()
    Tell NRF24 to start listening.
    void VS1053.startSineTest()
    Perform the sine test
    void NRF24L01.startTestCarrier​(int channel, int powerLevel)
    Start generating testing unodulated carrier wave.
    void Servo.stop()
    Stop being a servo
    void NRF24L01.stopListening()
    Stops receiving.
    void NRF24L01.stopTestCarrier()
    Stop generating testing carrier wave
    void NRF24L01.terminate()
    Terminate connection to nRF24 chip
    boolean NRF24L01.testRPD()
    Test whether a signal (carrier or otherwise) greater than or equal to -64dBm is present on the channel.
    void VS1053.waitForReady()
    Wait for the DREQ to signal that the device is ready for more work.
    void LCD.write​(java.lang.String text)
    Write a text string to the LCD.
    int NRF24L01.write​(byte[] value)
    Send data packet.
    void NRF24L01.writeByteRegister​(int reg, byte value)
    Writes value to single-byte register.
    void TM1638.writeNumber​(int number)  
    void NRF24L01.writeRegister​(int reg, byte[] data)
    Writes provided bytes into MiRF registers starting from provided register address.
    Good for multi-byte registers.
    Constructors in jpigpio.devices that throw PigpioException 
    Constructor Description
    LCD​(JPigpio pigpio, int registerSelect, int readWrite, int enable, int db4, int db5, int db6, int db7)  
    SP0256​(JPigpio pigpio, GPIO aldGpio, GPIO lrqGpio, GPIO a1Gpio, GPIO a2Gpio, GPIO a3Gpio, GPIO a4Gpio, GPIO a5Gpio, GPIO a6Gpio)  
    Stepper​(JPigpio pigpio, int blueGpio, int pinkGpio, int yellowGpio, int orangeGpio)
    Create an instance of the Stepper object used to control the stepper motor.
    TM1638​(JPigpio pigpio, GPIO stbGpio, GPIO clkGpio, GPIO dioGpio)  
    VS1053​(JPigpio pigpio, int gpioDREQ)  

  • Uses of PigpioException in jpigpio.impl

    Methods in jpigpio.impl that throw PigpioException 
    Modifier and Type Method Description
    void SPI.close()  
    void CommonPigpio.gpioDelay​(long delay, int type)  
    void CommonPigpio.gpioShiftOut​(int gpioData, int gpioClock, boolean clockLevel, boolean bitOrder, byte value)
    Shift out a byte of data to a given pin.
    void CommonPigpio.gpioShiftOut​(int gpioData, int gpioClock, boolean bitOrder, byte value)
    Shift out a byte of data to a given pin.
    void CommonPigpio.gpioShiftOut​(GPIO gpioData, GPIO gpioClock, boolean clockLevel, boolean bitOrder, byte value)  
    void CommonPigpio.gpioShiftOut​(GPIO gpioData, GPIO gpioClock, boolean bitOrder, byte value)  
    void SPI.read​(byte[] data)  
    void SPI.write​(byte[] data)  
    byte SPI.xfer​(byte txData)  
    void SPI.xfer​(byte[] txData, byte[] rxData)  
    Constructors in jpigpio.impl that throw PigpioException 
    Constructor Description
    SPI​(JPigpio pigpio, int channel, int baudRate, int flags)  

  • Uses of PigpioException in jpigpio.packet

    Methods in jpigpio.packet that throw PigpioException 
    Modifier and Type Method Description
    int Rf433tx.put​(byte[] data)
    Converts provided data to waveforms using properties of Protocol and transmits waveforms repeatedly (if required by Protocol).
    boolean Rf433tx.ready()
    Returns TRUE if available for another transmission.
    void Rf433rx.setCallback​(NotificationListener notificationListener)  
    void Rf433rx.terminate()
    Terminate receiving thread, cancel further notifications from pigpiod.
    void Rf433tx.terminate()
    Terminates transmission of all waveforms.
    Constructors in jpigpio.packet that throw PigpioException 
    Constructor Description
    Rf433rx​(JPigpio pi, int rxGpio, Protocol protocol)  
    Rf433tx​(JPigpio pi, int txGpio, Protocol protocol)  

  • Uses of PigpioException in jpigpio.sensors

    Methods in jpigpio.sensors that throw PigpioException 
    Modifier and Type Method Description
    void GY_271.close()
    Close our usage of the I2C bus.
    void WiiNunchuck.close()  
    long HC_SR04.getDelay()
    Get the delay in microseconds for a trigger/echo
    java.lang.String GY_271.getId()
    Get the device id.
    double HC_SR04.getImperialDistance()
    Get the distance in inches of detection or -1 if no object detected.
    double HC_SR04.getMetricDistance()
    Get the sensor measured distance to the target in meters.
    byte GY_271.getStatus()  
    void GY_271.initialize()
    Initialize the GY-271
    void WiiNunchuck.initialize()
    Initialize the Nunchuck
    void MFRC522.PCD_AntennaOff()
    Turns the antenna off by disabling pins TX1 and TX2.
    void MFRC522.PCD_AntennaOn()
    Turns the antenna on by enabling pins TX1 and TX2.
    byte MFRC522.PCD_CalculateCRC​(byte[] data, byte length, byte[] result)
    Use the CRC coprocessor in the MFRC522 to calculate a CRC_A.
    void MFRC522.PCD_ClearRegisterBitMask​(byte reg, byte mask)
    Clears the bits given in mask from register reg.
    byte MFRC522.PCD_GetAntennaGain()
    Get the current MFRC522 Receiver Gain (RxGain[2:0]) value.
    void MFRC522.PCD_Init()
    Initializes the MFRC522 chip.
    byte MFRC522.PCD_ReadRegister​(byte reg)
    Reads a byte from the specified register in the MFRC522 chip.
    void MFRC522.PCD_ReadRegister​(byte reg, byte[] values, byte rxAlign)
    Reads a number of bytes from the specified register in the MFRC522 chip.
    void MFRC522.PCD_Reset()
    Performs a soft reset on the MFRC522 chip and waits for it to be ready again.
    void MFRC522.PCD_SetAntennaGain​(byte mask)
    Set the MFRC522 Receiver Gain (RxGain) to value specified by given mask.
    void MFRC522.PCD_SetRegisterBitMask​(byte reg, byte mask)
    Sets the bits given in mask in register reg.
    void MFRC522.PCD_WriteRegister​(byte reg, byte value)
    Write single byte to specified register
    void MFRC522.PCD_WriteRegister​(byte reg, byte[] values)
    Write set of values (bytearray) to specified register.
    void GY_271.readValue()  
    void WiiNunchuck.readValue()
    Read a value from the Wii Nunchuck.
    void GY_271.setGain​(int value)  
    void GY_271.setMode​(int value)  
    void GY_271.setOutputRate​(int value)  
    void GY_271.setSamples​(int value)  
    Constructors in jpigpio.sensors that throw PigpioException 
    Constructor Description
    HC_SR04​(JPigpio pigpio, int triggerGpio, int echoGpio)
    Construct the object for this class.
    MFRC522​(JPigpio pigpio, int chipSelectPin, int resetPowerDownPin)
    Object constructor