module Pigpio::IF
This module is a ruby binding to pigpio library.
Public Class Methods
This function stops bit banging I2C on a pair of GPIO previously opened with [bb_i2c_open].
. .
pi: >=0 (as returned by [*pigpio_start*]). SDA: 0-31, the SDA GPIO used in a prior call to [*bb_i2c_open*]
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, or PI_NOT_I2C_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_bb_i2c_close(VALUE self, VALUE pi, VALUE SDA){
This function selects a pair of GPIO for bit banging I2C at a specified baud rate.
Bit banging I2C allows for certain operations which are not possible with the standard I2C driver.
baud rates as low as 50 repeated starts clock stretching I2C on any pair of spare GPIO
. .
pi: >=0 (as returned by [*pigpio_start*]). SDA: 0-31 SCL: 0-31 baud: 50-500000
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_I2C_BAUD, or PI_GPIO_IN_USE.
NOTE:
The GPIO used for SDA and SCL must have pull-ups to 3V3 connected. As a guide the hardware pull-ups on pins 3 and 5 are 1k8 in value.
See also: pigpio site
VALUE pigpio_rbfn_bb_i2c_open(VALUE self, VALUE pi, VALUE SDA, VALUE SCL, VALUE baud){
This function executes a sequence of bit banged I2C operations. The operations to be performed are specified by the contents of inBuf which contains the concatenated command codes and associated data.
. .
pi: >=0 (as returned by [*pigpio_start*]). SDA: 0-31 (as used in a prior call to [*bb_i2c_open*]) inBuf: the concatenated I2C commands, see below outBuf: buffer to hold returned data outLen: size of output buffer
. .
Returns >= 0 if OK (the number of bytes read), otherwise PI_BAD_USER_GPIO, PI_NOT_I2C_GPIO, PI_BAD_POINTER, PI_BAD_I2C_CMD, PI_BAD_I2C_RLEN, PI_BAD_I2C_WLEN, PI_I2C_READ_FAILED, or PI_I2C_WRITE_FAILED.
The following command codes are supported:
Name @ Cmd & Data @ Meaning End @ 0 @ No more commands Escape @ 1 @ Next P is two bytes Start @ 2 @ Start condition Stop @ 3 @ Stop condition Address @ 4 P @ Set I2C address to P Flags @ 5 lsb msb @ Set I2C flags to lsb + (msb << 8) Read @ 6 P @ Read P bytes of data Write @ 7 P ... @ Write P bytes of data
The address, read, and write commands take a parameter P. Normally P is one byte (0-255). If the command is preceded by the Escape command then P is two bytes (0-65535, least significant byte first).
The address and flags default to 0. The address and flags maintain their previous value until updated.
No flags are currently defined.
The returned I2C data is stored in consecutive locations of outBuf.
…
Set address 0x53 start, write 0x32, (re)start, read 6 bytes, stop Set address 0x1E start, write 0x03, (re)start, read 6 bytes, stop Set address 0x68 start, write 0x1B, (re)start, read 8 bytes, stop End 0x04 0x53 0x02 0x07 0x01 0x32 0x02 0x06 0x06 0x03 0x04 0x1E 0x02 0x07 0x01 0x03 0x02 0x06 0x06 0x03 0x04 0x68 0x02 0x07 0x01 0x1B 0x02 0x06 0x08 0x03 0x00
…
See also: pigpio site
VALUE pigpio_rbfn_bb_i2c_zip(VALUE self, VALUE pi, VALUE SDA, VALUE inBuf, VALUE outLen_v){
This function inverts serial logic for big bang serial reads.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31, previously opened with [*bb_serial_read_open*]. invert: 0-1, 1 invert, 0 normal.
. .
Returns 0 if OK, otherwise PI_NOT_SERIAL_GPIO or PI_BAD_SER_INVERT.
See also: pigpio site
VALUE pigpio_rbfn_bb_serial_invert(VALUE self, VALUE pi, VALUE user_gpio, VALUE invert){
This function copies up to bufSize bytes of data read from the bit bang serial cyclic buffer to the buffer starting at buf.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31, previously opened with [*bb_serial_read_open*]. bufSize: >=0
. .
Returns to buf.ret_code attribute the number of bytes copied if OK, otherwise PI_BAD_USER_GPIO or PI_NOT_SERIAL_GPIO.
The received data is get by the buf.to_s method.
The bytes returned for each character depend upon the number of data bits [data_bits] specified in the [bb_serial_read_open] command.
For [*data_bits*] 1-8 there will be one byte per character. For [*data_bits*] 9-16 there will be two bytes per character. For [*data_bits*] 17-32 there will be four bytes per character.
See also: pigpio site
VALUE pigpio_rbfn_bb_serial_read(VALUE self, VALUE pi, VALUE user_gpio, VALUE bufSize){
This function closes a GPIO for bit bang reading of serial data.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31, previously opened with [*bb_serial_read_open*].
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, or PI_NOT_SERIAL_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_bb_serial_read_close(VALUE self, VALUE pi, VALUE user_gpio){
This function opens a GPIO for bit bang reading of serial data.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
baud: 50-250000
data_bits: 1-32
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_WAVE_BAUD, or PI_GPIO_IN_USE.
The serial data is returned in a cyclic buffer and is read using bb_serial_read.
It is the caller's responsibility to read data from the cyclic buffer in a timely fashion.
See also: pigpio site
VALUE pigpio_rbfn_bb_serial_read_open(VALUE self, VALUE pi, VALUE user_gpio, VALUE baud, VALUE data_bits){
This function stops bit banging SPI on a set of GPIO opened with [bbSPIOpen].
. .
pi: >=0 (as returned by [*pigpio_start*]). CS: 0-31, the CS GPIO used in a prior call to [*bb_spi_open*]
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, or PI_NOT_SPI_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_bb_spi_close(VALUE self, VALUE pi, VALUE CS){
This function selects a set of GPIO for bit banging SPI at a specified baud rate.
. .
pi: >=0 (as returned by [*pigpio_start*]).
CS: 0-31
MISO: 0-31
MOSI: 0-31
SCLK: 0-31
baud: 50-250000
spi_flags: see below
. .
spi_flags consists of the least significant 22 bits.
. .
21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0 R T 0 0 0 0 0 0 0 0 0 0 0 p m m
. .
mm defines the SPI mode, defaults to 0
. .
Mode CPOL CPHA 0 0 0 1 0 1 2 1 0 3 1 1
. .
p is 0 if CS is active low (default) and 1 for active high.
T is 1 if the least significant bit is transmitted on MOSI first, the default (0) shifts the most significant bit out first.
R is 1 if the least significant bit is received on MISO first, the default (0) receives the most significant bit first.
The other bits in flags should be set to zero.
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_SPI_BAUD, or PI_GPIO_IN_USE.
If more than one device is connected to the SPI bus (defined by SCLK, MOSI, and MISO) each must have its own CS.
…
bb_spi_open(pi,10, MISO, MOSI, SCLK, 10000, 0); // device 1 bb_spi_open(pi,11, MISO, MOSI, SCLK, 20000, 3); // device 2
…
See also: pigpio site
VALUE pigpio_rbfn_bb_spi_open(VALUE self, VALUE pi, VALUE CS, VALUE MISO, VALUE MOSI, VALUE SCLK, VALUE baud, VALUE spi_flags){
This function executes a bit banged SPI transfer.
. .
pi: >=0 (as returned by [*pigpio_start*]). CS: 0-31 (as used in a prior call to [*bb_spi_open*]) txBuf: binary string buffer to hold data to be sent rxBuf: binary string buffer to hold returned data
. .
Returns >= 0 if OK (the number of bytes read), otherwise PI_BAD_USER_GPIO, PI_NOT_SPI_GPIO or PI_BAD_POINTER.
See also: pigpio site
VALUE pigpio_rbfn_bb_spi_xfer(VALUE self, VALUE pi, VALUE CS, VALUE txBuf){
This function allows the Pi to act as a slave I2C device.
The data bytes (if any) are written to the BSC transmit FIFO and the bytes in the BSC receive FIFO are returned.
. .
pi: >=0 (as returned by [*pigpio_start*]).
i2c_addr: 0-0x7F.
bscxfer: a structure defining the transfer.
typedef struct
{
uint32_t control; // N/A
int rxCnt; // Read only
char rxBuf[BSC_FIFO_SIZE]; // Read only
int txCnt; // Write
char txBuf[BSC_FIFO_SIZE]; // Write
} bsc_xfer_t;
. .
txCnt is set to the number of bytes to be transmitted, possibly zero. The data itself should be copied to txBuf.
Any received data will be written to rxBuf with rxCnt set.
See [bsc_xfer] for details of the returned status value.
If there was an error the status will be less than zero (and will contain the error code).
Note that an i2c_address of 0 may be used to close the BSC device and reassign the used GPIO (18/19) as inputs.
See also: pigpio site
VALUE pigpio_rbfn_bsc_i2c(VALUE self, VALUE pi, VALUE i2c_addr, VALUE bscxfer){
This function provides a low-level interface to the SPI/I2C Slave peripheral. This peripheral allows the Pi to act as a slave device on an I2C or SPI bus.
I can't get SPI to work properly. I tried with a control word of 0x303 and swapped MISO and MOSI.
The function sets the BSC mode, writes any data in the transmit buffer to the BSC transmit FIFO, and copies any data in the BSC receive FIFO to the receive buffer.
. .
pi: >=0 (as returned by [*pigpio_start*]).
bscxfer: a structure defining the transfer.
typedef struct
{
uint32_t control; // Write
int rxCnt; // Read only
char rxBuf[BSC_FIFO_SIZE]; // Read only
int txCnt; // Write
char txBuf[BSC_FIFO_SIZE]; // Write
} bsc_xfer_t;
. .
To start a transfer set control (see below) and copy the bytes to be sent (if any) to txBuf and set the byte count in txCnt.
Upon return rxCnt will be set to the number of received bytes placed in rxBuf.
The returned function value is the status of the transfer (see below).
If there was an error the status will be less than zero (and will contain the error code).
The most significant word of the returned status contains the number of bytes actually copied from txBuf to the BSC transmit FIFO (may be less than requested if the FIFO already contained untransmitted data).
Note that the control word sets the BSC mode. The BSC will stay in that mode until a different control word is sent.
The BSC peripheral uses GPIO 18 (SDA) and 19 (SCL) in I2C mode and GPIO 18 (MOSI), 19 (SCLK), 20 (MISO), and 21 (CE) in SPI mode. You need to swap MISO/MOSI between master and slave.
When a zero control word is received GPIO 18-21 will be reset to INPUT mode.
control consists of the following bits.
. .
22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 a a a a a a a - - IT HC TF IR RE TE BK EC ES PL PH I2 SP EN
. .
Bits 0-13 are copied unchanged to the BSC CR register. See pages 163-165 of the Broadcom peripherals document for full details.
aaaaaaa @ defines the I2C slave address (only relevant in I2C mode) IT @ invert transmit status flags HC @ enable host control TF @ enable test FIFO IR @ invert receive status flags RE @ enable receive TE @ enable transmit BK @ abort operation and clear FIFOs EC @ send control register as first I2C byte ES @ send status register as first I2C byte PL @ set SPI polarity high PH @ set SPI phase high I2 @ enable I2C mode SP @ enable SPI mode EN @ enable BSC peripheral
The returned status has the following format
. .
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 S S S S S R R R R R T T T T T RB TE RF TF RE TB
. .
Bits 0-15 are copied unchanged from the BSC FR register. See pages 165-166 of the Broadcom peripherals document for full details.
SSSSS @ number of bytes successfully copied to transmit FIFO RRRRR @ number of bytes in receieve FIFO TTTTT @ number of bytes in transmit FIFO RB @ receive busy TE @ transmit FIFO empty RF @ receive FIFO full TF @ transmit FIFO full RE @ receive FIFO empty TB @ transmit busy
See also: pigpio site
VALUE pigpio_rbfn_bsc_xfer(VALUE self, VALUE pi, VALUE bscxfer){
This function initialises a new callback.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
edge: RISING_EDGE, FALLING_EDGE, or EITHER_EDGE.
. .
The function returns a callback id if OK, otherwise pigif_bad_malloc, pigif_duplicate_callback, or pigif_bad_callback.
The callback is called with the GPIO, edge, and tick, whenever the GPIO has the identified edge.
. .
Parameter Value Meaning
GPIO 0-31 The GPIO which has changed state
edge 0-2 0 = change to low (a falling edge)
1 = change to high (a rising edge)
2 = no level change (a watchdog timeout)
tick 32 bit The number of microseconds since boot
WARNING: this wraps around from
4294967295 to 0 roughly every 72 minutes
. .
If you call this method without a block, this method raises an Pigpio::CallbackError exception.
See also: pigpio site
VALUE pigpio_rbfn_callback(int argc, VALUE *argv, VALUE self){
This function cancels a callback identified by its id.
. .
callback_id: >=0, as returned by a call to [*callback*] or [*callback_ex*].
. .
The function returns 0 if OK, otherwise pigif_callback_not_found.
See also: pigpio site
VALUE pigpio_rbfn_callback_cancel(VALUE self,VALUE callback){
Clears GPIO 0-31 if the corresponding bit in bits is set.
. .
pi: >=0 (as returned by [*pigpio_start*]).
bits: a bit mask with 1 set if the corresponding GPIO is
to be cleared.
. .
Returns 0 if OK, otherwise PI_SOME_PERMITTED.
A status of PI_SOME_PERMITTED indicates that the user is not allowed to write to one or more of the GPIO.
See also: pigpio site
VALUE pigpio_rbfn_clear_bank_1(VALUE self, VALUE pi, VALUE bits){
Clears GPIO 32-53 if the corresponding bit (0-21) in bits is set.
. .
pi: >=0 (as returned by [*pigpio_start*]).
bits: a bit mask with 1 set if the corresponding GPIO is
to be cleared.
. .
Returns 0 if OK, otherwise PI_SOME_PERMITTED.
A status of PI_SOME_PERMITTED indicates that the user is not allowed to write to one or more of the GPIO.
See also: pigpio site
VALUE pigpio_rbfn_clear_bank_2(VALUE self, VALUE pi, VALUE bits){
This function deletes a stored script.
. .
pi: >=0 (as returned by [*pigpio_start*]). script_id: >=0, as returned by [*store_script*].
. .
The function returns 0 if OK, otherwise PI_BAD_SCRIPT_ID.
See also: pigpio site
VALUE pigpio_rbfn_delete_script(VALUE self,VALUE pi, VALUE script_id){
This function initialises an event callback.
. .
pi: >=0 (as returned by [*pigpio_start*]). event: 0-31.
. .
The function returns a callback id if OK, otherwise pigif_bad_malloc, pigif_duplicate_callback, or pigif_bad_callback.
The callback is called with the event id, and tick, whenever the event occurs.
If you call this method without a block, this method raises an Pigpio::CallbackError exception.
See also: pigpio site
VALUE pigpio_rbfn_event_callback(int argc, VALUE *argv, VALUE self){
This function cancels an event callback identified by its id.
. .
callback_id: >=0, as returned by a call to [*event_callback*] or [*event_callback_ex*].
. .
The function returns 0 if OK, otherwise pigif_callback_not_found.
See also: pigpio site
VALUE pigpio_rbfn_event_callback_cancel(VALUE self,VALUE callback_id){
This function signals the occurrence of an event.
. .
pi: >=0 (as returned by [*pigpio_start*]). event: 0-31.
. .
Returns 0 if OK, otherwise PI_BAD_EVENT_ID.
An event is a signal used to inform one or more consumers to start an action. Each consumer which has registered an interest in the event (e.g. by calling [event_callback]) will be informed by a callback.
One event, PI_EVENT_BSC (31) is predefined. This event is auto generated on BSC slave activity.
The meaning of other events is arbitrary.
Note that other than its id and its tick there is no data associated with an event.
See also: pigpio site
VALUE pigpio_rbfn_event_trigger(VALUE self,VALUE pi, VALUE event){
Return the PWM dutycycle in use on a GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31.
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO or PI_NOT_PWM_GPIO.
For normal PWM the dutycycle will be out of the defined range for the GPIO (see [get_PWM_range]).
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).
See also: pigpio site
VALUE pigpio_rbfn_get_PWM_dutycycle(VALUE self, VALUE pi, VALUE user_gpio){
Get the frequency of PWM being used on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31.
. .
For normal PWM the frequency will be that defined for the GPIO by [set_PWM_frequency].
If a hardware clock is active on the GPIO the reported frequency will be that set by [hardware_clock].
If hardware PWM is active on the GPIO the reported frequency will be that set by [hardware_PWM].
Returns the frequency (in hertz) used for the GPIO if OK, otherwise PI_BAD_USER_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_get_PWM_frequency(VALUE self, VALUE pi, VALUE user_gpio){
Get the range of PWM values being used on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31.
. .
Returns the dutycycle range used for the GPIO if OK, otherwise PI_BAD_USER_GPIO.
If a hardware clock or hardware PWM is active on the GPIO the reported range will be 1000000 (1M).
See also: pigpio site
VALUE pigpio_rbfn_get_PWM_range(VALUE self, VALUE pi, VALUE user_gpio){
Get the real underlying range of PWM values being used on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31.
. .
Returns the real range used for the GPIO if OK, otherwise PI_BAD_USER_GPIO.
If a hardware clock is active on the GPIO the reported real range will be 1000000 (1M).
If hardware PWM is active on the GPIO the reported real range will be approximately 250M divided by the set PWM frequency.
See also: pigpio site
VALUE pigpio_rbfn_get_PWM_real_range(VALUE self, VALUE pi, VALUE user_gpio){
Gets the current system tick.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Tick is the number of microseconds since system boot.
As tick is an unsigned 32 bit quantity it wraps around after 2**32 microseconds, which is approximately 1 hour 12 minutes.
See also: pigpio site
VALUE pigpio_rbfn_get_current_tick(VALUE self,VALUE pi){
Get the Pi's hardware revision number.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
The hardware revision is the last few characters on the Revision line of /proc/cpuinfo.
If the hardware revision can not be found or is not a valid hexadecimal number the function returns 0.
The revision number can be used to determine the assignment of GPIO to pins (see [gpio]).
There are at least three types of board.
Type 1 boards have hardware revision numbers of 2 and 3.
Type 2 boards have hardware revision numbers of 4, 5, 6, and 15.
Type 3 boards have hardware revision numbers of 16 or greater.
See also: pigpio site
VALUE pigpio_rbfn_get_hardware_revision(VALUE self,VALUE pi){
Get the GPIO mode.
. .
pi: >=0 (as returned by [*pigpio_start*]). gpio: 0-53.
. .
Returns the GPIO mode if OK, otherwise PI_BAD_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_get_mode(VALUE self,VALUE pi, VALUE gpio){
This function returns the pad drive strength in mA.
. .
pi: >=0 (as returned by [*pigpio_start*]). pad: 0-2, the pad to get.
. .
Returns the pad drive strength if OK, otherwise PI_BAD_PAD.
Pad @ GPIO 0 @ 0-27 1 @ 28-45 2 @ 46-53
…
strength = get_pad_strength(pi, 0); // get pad 0 strength
…
See also: pigpio site
VALUE pigpio_rbfn_get_pad_strength(VALUE self, VALUE pi, VALUE pad){
Returns the pigpio version.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_get_pigpio_version(VALUE self,VALUE pi){
Return the servo pulsewidth in use on a GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31.
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO or PI_NOT_SERVO_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_get_servo_pulsewidth(VALUE self, VALUE pi, VALUE user_gpio){
Read the GPIO level.
. .
pi: >=0 (as returned by [*pigpio_start*]). gpio:0-53.
. .
Returns the GPIO level if OK, otherwise PI_BAD_GPIO.
See also: pigpio site
VALUE pigpio_rbfn_gpio_read(VALUE self,VALUE pi, VALUE gpio){
This function sends a trigger pulse to a GPIO. The GPIO is set to level for pulseLen microseconds and then reset to not level.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
pulseLen: 1-100.
level: 0,1.
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_LEVEL, PI_BAD_PULSELEN, or PI_NOT_PERMITTED.
See also: pigpio site
VALUE pigpio_rbfn_gpio_trigger(VALUE self,VALUE pi, VALUE user_gpio, VALUE pulseLen, VALUE level){
Write the GPIO level.
. .
pi: >=0 (as returned by [*pigpio_start*]). gpio: 0-53. level: 0, 1.
. .
Returns 0 if OK, otherwise PI_BAD_GPIO, PI_BAD_LEVEL, or PI_NOT_PERMITTED.
Notes
If PWM or servo pulses are active on the GPIO they are switched off.
See also: pigpio site
VALUE pigpio_rbfn_gpio_write(VALUE self,VALUE pi, VALUE gpio, VALUE level){
Starts hardware PWM on a GPIO at the specified frequency and dutycycle. Frequencies above 30MHz are unlikely to work.
NOTE: Any waveform started by [wave_send_*] or [wave_chain] will be cancelled.
This function is only valid if the pigpio main clock is PCM. The main clock defaults to PCM but may be overridden when the pigpio daemon is started (option -t).
. .
pi: >=0 (as returned by [*pigpio_start*]). gpio: see descripton PWMfreq: 0 (off) or 1-125000000 (125M) PWMduty: 0 (off) to 1000000 (1M)(fully on)
. .
Returns 0 if OK, otherwise PI_NOT_PERMITTED, PI_BAD_GPIO, PI_NOT_HPWM_GPIO, PI_BAD_HPWM_DUTY, PI_BAD_HPWM_FREQ, or PI_HPWM_ILLEGAL.
The same PWM channel is available on multiple GPIO. The latest frequency and dutycycle setting will be used by all GPIO which share a PWM channel.
The GPIO must be one of the following.
. .
12 PWM channel 0 All models but A and B 13 PWM channel 1 All models but A and B 18 PWM channel 0 All models 19 PWM channel 1 All models but A and B 40 PWM channel 0 Compute module only 41 PWM channel 1 Compute module only 45 PWM channel 1 Compute module only 52 PWM channel 0 Compute module only 53 PWM channel 1 Compute module only
. .
The actual number of steps beween off and fully on is the integral part of 250 million divided by PWMfreq.
The actual frequency set is 250 million / steps.
There will only be a million steps for a PWMfreq of 250. Lower frequencies will have more steps and higher frequencies will have fewer steps. PWMduty is automatically scaled to take this into account.
See also: pigpio site
VALUE pigpio_rbfn_hardware_PWM(VALUE self, VALUE pi, VALUE gpio, VALUE PWMfreq, VALUE PWMduty){
Starts a hardware clock on a GPIO at the specified frequency. Frequencies above 30MHz are unlikely to work.
. .
pi: >=0 (as returned by [*pigpio_start*]).
gpio: see description
frequency: 0 (off) or 4689-250000000 (250M)
. .
Returns 0 if OK, otherwise PI_NOT_PERMITTED, PI_BAD_GPIO, PI_NOT_HCLK_GPIO, PI_BAD_HCLK_FREQ,or PI_BAD_HCLK_PASS.
The same clock is available on multiple GPIO. The latest frequency setting will be used by all GPIO which share a clock.
The GPIO must be one of the following.
. .
4 clock 0 All models 5 clock 1 All models but A and B (reserved for system use) 6 clock 2 All models but A and B 20 clock 0 All models but A and B 21 clock 1 All models but A and Rev.2 B (reserved for system use) 32 clock 0 Compute module only 34 clock 0 Compute module only 42 clock 1 Compute module only (reserved for system use) 43 clock 2 Compute module only 44 clock 1 Compute module only (reserved for system use)
. .
Access to clock 1 is protected by a password as its use will likely crash the Pi. The password is given by or'ing 0x5A000000 with the GPIO number.
See also: pigpio site
VALUE pigpio_rbfn_hardware_clock(VALUE self, VALUE pi, VALUE gpio, VALUE clkfreq){
This writes data bytes to the specified register of the device associated with handle and reads a device specified number of bytes of data in return.
. .
pi: >=0 (as returned by [*pigpio_start*]).
handle: >=0, as returned by a call to [*i2c_open*].
i2c_reg: 0-255, the register to write/read.
buf: an binary string with the data to send and to receive the read data.
. .
Returns the number of bytes read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
The smbus 2.0 documentation states that a minimum of 1 byte may be sent and a minimum of 1 byte may be received. The total number of bytes sent/received must be 32 or less.
Block write-block read. SMBus 2.0 5.5.8 . .
S Addr Wr [A] i2c_reg [A] count [A] buf0 [A] ... S Addr Rd [A] [Count] A [Data] ... A P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_block_process_call(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE buf){
This closes the I2C device associated with the handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*].
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
See also: pigpio site
VALUE pigpio_rbfn_i2c_close(VALUE self, VALUE pi, VALUE handle){
This returns a handle for the device at address i2c_addr on bus i2c_bus.
. .
pi: >=0 (as returned by [*pigpio_start*]). i2c_bus: >=0. i2c_addr: 0-0x7F. i2c_flags: 0.
. .
No flags are currently defined. This parameter should be set to zero.
Physically buses 0 and 1 are available on the Pi. Higher numbered buses will be available if a kernel supported bus multiplexor is being used.
Returns a handle (>=0) if OK, otherwise PI_BAD_I2C_BUS, PI_BAD_I2C_ADDR, PI_BAD_FLAGS, PI_NO_HANDLE, or PI_I2C_OPEN_FAILED.
For the SMBus commands the low level transactions are shown at the end of the function description. The following abbreviations are used.
. .
S (1 bit) : Start bit P (1 bit) : Stop bit Rd/Wr (1 bit) : Read/Write bit. Rd equals 1, Wr equals 0. A, NA (1 bit) : Accept and not accept bit. Addr (7 bits): I2C 7 bit address. i2c_reg (8 bits): A byte which often selects a register. Data (8 bits): A data byte. Count (8 bits): A byte defining the length of a block operation. [..]: Data sent by the device.
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_open(VALUE self, VALUE pi, VALUE i2c_bus, VALUE i2c_addr, VALUE i2c_flags){
This writes 16 bits of data to the specified register of the device associated with handle and and reads 16 bits of data in return.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. i2c_reg: 0-255, the register to write/read. wVal: 0-0xFFFF, the value to write.
. .
Returns the word read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
Process call. SMBus 2.0 5.5.6 . .
S Addr Wr [A] i2c_reg [A] wVal_Low [A] wVal_High [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_process_call(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE wVal){
This reads a block of up to 32 bytes from the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]).
handle: >=0, as returned by a call to [*i2c_open*].
i2c_reg: 0-255, the register to read.
buf: an binary string to receive the read data.
. .
The amount of returned data is set by the device.
Returns the number of bytes read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
Block read. SMBus 2.0 5.5.7 . .
S Addr Wr [A] i2c_reg [A] S Addr Rd [A] [Count] A [buf0] A [buf1] A ... A [bufn] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_block_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg){
This reads a single byte from the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*].
. .
Returns the byte read (>=0) if OK, otherwise PI_BAD_HANDLE, or PI_I2C_READ_FAILED.
Receive byte. SMBus 2.0 5.5.3 . .
S Addr Rd [A] [Data] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_byte(VALUE self, VALUE pi, VALUE handle){
This reads a single byte from the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. i2c_reg: 0-255, the register to read.
. .
Returns the byte read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
Read byte. SMBus 2.0 5.5.5 . .
S Addr Wr [A] i2c_reg [A] S Addr Rd [A] [Data] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_byte_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg){
This reads count bytes from the raw device into buf.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. buf: an binary string to receive the read data bytes. count: >0, the number of bytes to read.
. .
Returns count (>0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
. .
S Addr Rd [A] [buf0] A [buf1] A ... A [bufn] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_device(VALUE self, VALUE pi, VALUE handle, VALUE count){
This reads count bytes from the specified register of the device associated with handle . The count may be 1-32.
. .
pi: >=0 (as returned by [*pigpio_start*]).
handle: >=0, as returned by a call to [*i2c_open*].
i2c_reg: 0-255, the register to read.
buf: an array to receive the read data.
count: 1-32, the number of bytes to read.
. .
Returns the number of bytes read (>0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
. .
S Addr Wr [A] i2c_reg [A] S Addr Rd [A] [buf0] A [buf1] A ... A [bufn] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_i2c_block_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE count){
This reads a single 16 bit word from the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. i2c_reg: 0-255, the register to read.
. .
Returns the word read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_READ_FAILED.
Read word. SMBus 2.0 5.5.5 . .
S Addr Wr [A] i2c_reg [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_read_word_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg){
This writes up to 32 bytes to the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]).
handle: >=0, as returned by a call to [*i2c_open*].
i2c_reg: 0-255, the register to write.
buf: an binary string with the data to send.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
Block write. SMBus 2.0 5.5.7 . .
S Addr Wr [A] i2c_reg [A] count [A] buf0 [A] buf1 [A] ... [A] bufn [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_block_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE buf){
This sends a single byte to the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. bVal: 0-0xFF, the value to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
Send byte. SMBus 2.0 5.5.2 . .
S Addr Wr [A] bVal [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_byte(VALUE self, VALUE pi, VALUE handle, VALUE bVal){
This writes a single byte to the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. i2c_reg: 0-255, the register to write. bVal: 0-0xFF, the value to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
Write byte. SMBus 2.0 5.5.4 . .
S Addr Wr [A] i2c_reg [A] bVal [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_byte_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE bVal){
This writes count bytes from buf to the raw device.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. buf: an array containing the data bytes to write. count: >0, the number of bytes to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
. .
S Addr Wr [A] buf0 [A] buf1 [A] ... [A] bufn [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_device(VALUE self, VALUE pi, VALUE handle, VALUE buf){
This writes 1 to 32 bytes to the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]).
handle: >=0, as returned by a call to [*i2c_open*].
i2c_reg: 0-255, the register to write.
buf: the data to write.
count: 1-32, the number of bytes to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
. .
S Addr Wr [A] i2c_reg [A] buf0 [A] buf1 [A] ... [A] bufn [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_i2c_block_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE buf){
This sends a single bit (in the Rd/Wr bit) to the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. bit: 0-1, the value to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
Quick command. SMBus 2.0 5.5.1 . .
S Addr bit [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_quick(VALUE self, VALUE pi, VALUE handle, VALUE bit){
This writes a single 16 bit word to the specified register of the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2c_open*]. i2c_reg: 0-255, the register to write. wVal: 0-0xFFFF, the value to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_I2C_WRITE_FAILED.
Write word. SMBus 2.0 5.5.4 . .
S Addr Wr [A] i2c_reg [A] wval_Low [A] wVal_High [A] P
. .
See also: pigpio site
VALUE pigpio_rbfn_i2c_write_word_data(VALUE self, VALUE pi, VALUE handle, VALUE i2c_reg, VALUE wVal){
This function executes a sequence of I2C operations. The operations to be performed are specified by the contents of inBuf which contains the concatenated command codes and associated data.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*i2cOpen*] inBuf: the concatenated I2C commands, see below outBuf: buffer to hold returned data outLen: size of output buffer
. .
Returns >= 0 if OK (the number of bytes read), otherwise PI_BAD_HANDLE, PI_BAD_POINTER, PI_BAD_I2C_CMD, PI_BAD_I2C_RLEN. PI_BAD_I2C_WLEN, or PI_BAD_I2C_SEG.
The following command codes are supported:
Name @ Cmd & Data @ Meaning End @ 0 @ No more commands Escape @ 1 @ Next P is two bytes On @ 2 @ Switch combined flag on Off @ 3 @ Switch combined flag off Address @ 4 P @ Set I2C address to P Flags @ 5 lsb msb @ Set I2C flags to lsb + (msb << 8) Read @ 6 P @ Read P bytes of data Write @ 7 P ... @ Write P bytes of data
The address, read, and write commands take a parameter P. Normally P is one byte (0-255). If the command is preceded by the Escape command then P is two bytes (0-65535, least significant byte first).
The address defaults to that associated with the handle. The flags default to 0. The address and flags maintain their previous value until updated.
The returned I2C data is stored in consecutive locations of outBuf.
…
Set address 0x53, write 0x32, read 6 bytes Set address 0x1E, write 0x03, read 6 bytes Set address 0x68, write 0x1B, read 8 bytes End 0x04 0x53 0x07 0x01 0x32 0x06 0x06 0x04 0x1E 0x07 0x01 0x03 0x06 0x06 0x04 0x68 0x07 0x01 0x1B 0x06 0x08 0x00
…
See also: pigpio site
VALUE pigpio_rbfn_i2c_zip(VALUE self, VALUE pi, VALUE handle, VALUE inBuf, VALUE outLen_v){
Start notifications on a previously opened handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: 0-31 (as returned by [*notify_open*]) bits: a mask indicating the GPIO to be notified.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
The notification sends state changes for each GPIO whose corresponding bit in bits is set.
Each notification occupies 12 bytes in the fifo as follows:
. . typedef struct
{
uint16_t seqno;
uint16_t flags;
uint32_t tick;
uint32_t level;
} gpioReport_t;
. .
seqno: starts at 0 each time the handle is opened and then increments by one for each report.
flags: three flags are defined, PI_NTFY_FLAGS_WDOG, PI_NTFY_FLAGS_ALIVE, and PI_NTFY_FLAGS_EVENT.
If bit 5 is set (PI_NTFY_FLAGS_WDOG) then bits 0-4 of the flags indicate a GPIO which has had a watchdog timeout.
If bit 6 is set (PI_NTFY_FLAGS_ALIVE) this indicates a keep alive signal on the pipe/socket and is sent once a minute in the absence of other notification activity.
If bit 7 is set (PI_NTFY_FLAGS_EVENT) then bits 0-4 of the flags indicate an event which has been triggered.
tick: the number of microseconds since system boot. It wraps around after 1h12m.
level: indicates the level of each GPIO. If bit 1<<x is set then GPIO x is high.
See also: pigpio site
VALUE pigpio_rbfn_notify_begin(VALUE self, VALUE pi, VALUE handle, VALUE bits){
Stop notifications on a previously opened handle and release the handle for reuse.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: 0-31 (as returned by [*notify_open*])
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
See also: pigpio site
VALUE pigpio_rbfn_notify_close(VALUE self, VALUE pi, VALUE handle){
Get a free notification handle.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns a handle greater than or equal to zero if OK, otherwise PI_NO_HANDLE.
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 the library from a remote machine. The in-built (socket) notifications provided by [callback] should be used instead.
Notifications for handle x will be available at the pipe named /dev/pigpiox (where x is the handle number). E.g. if the function returns 15 then the notifications must be read from /dev/pigpio15.
See also: pigpio site
VALUE pigpio_rbfn_notify_open(VALUE self, VALUE pi){
Pause notifications on a previously opened handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: 0-31 (as returned by [*notify_open*])
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
Notifications for the handle are suspended until
- notify_begin
-
is called again.
See also: pigpio site
VALUE pigpio_rbfn_notify_pause(VALUE self, VALUE pi, VALUE handle){
Return a text description for an error code.
. .
errnum: the error code.
. .
See also: pigpio site
VALUE pigpio_rbfn_pigpio_error(VALUE self,VALUE errnum){
Connect to the pigpio daemon. Reserving command and notification streams.
. .
addrStr: specifies the host or IP address of the Pi running the
pigpio daemon. It may be NULL in which case localhost
is used unless overridden by the PIGPIO_ADDR environment
variable.
portStr: specifies the port address used by the Pi running the
pigpio daemon. It may be NULL in which case "8888"
is used unless overridden by the PIGPIO_PORT environment
variable.
. .
Returns an integer value greater than or equal to zero if OK.
This value is passed to the GPIO routines to specify the Pi to be operated on.
See also: pigpio site
VALUE pigpio_rbfn_pigpio_start(int argc, VALUE *argv, VALUE self){
Terminates the connection to a pigpio daemon and releases resources used by the library.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_pigpio_stop(VALUE self,VALUE pi){
Return the pigpiod_if2 version.
See also: pigpio site
VALUE pigpio_rbfn_pigpiod_if_version(VALUE self){
Read the levels of the bank 1 GPIO (GPIO 0-31).
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
The returned 32 bit integer has a bit set if the corresponding GPIO is logic 1. GPIO n has bit value (1<<n).
See also: pigpio site
VALUE pigpio_rbfn_read_bank_1(VALUE self, VALUE pi){
Read the levels of the bank 2 GPIO (GPIO 32-53).
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
The returned 32 bit integer has a bit set if the corresponding GPIO is logic 1. GPIO n has bit value (1<<(n-32)).
See also: pigpio site
VALUE pigpio_rbfn_read_bank_2(VALUE self, VALUE pi){
This function runs a stored script.
. .
pi: >=0 (as returned by [*pigpio_start*]).
script_id: >=0, as returned by [*store_script*].
numPar: 0-10, the number of parameters.
param: an array of parameters.
. .
The function returns 0 if OK, otherwise PI_BAD_SCRIPT_ID, or PI_TOO_MANY_PARAM
param is an array of up to 10 parameters which may be referenced in the script as p0 to p9.
See also: pigpio site
VALUE pigpio_rbfn_run_script(VALUE self,VALUE pi, VALUE script_id, VALUE param){
This function returns the run status of a stored script as well as the current values of parameters 0 to 9.
. .
pi: >=0 (as returned by [*pigpio_start*]).
script_id: >=0, as returned by [*store_script*].
param: an array to hold the returned 10 parameters.
. .
The function returns greater than or equal to 0 if OK, otherwise PI_BAD_SCRIPT_ID.
The run status may be
. .
PI_SCRIPT_INITING PI_SCRIPT_HALTED PI_SCRIPT_RUNNING PI_SCRIPT_WAITING PI_SCRIPT_FAILED
. .
The current value of script parameters 0 to 9 are returned in param.
See also: pigpio site
VALUE pigpio_rbfn_script_status(VALUE self,VALUE pi, VALUE script_id){
This function closes the serial device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*].
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
See also: pigpio site
VALUE pigpio_rbfn_serial_close(VALUE self, VALUE pi, VALUE handle){
Returns the number of bytes available to be read from the device associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*].
. .
Returns the number of bytes of data available (>=0) if OK, otherwise PI_BAD_HANDLE.
See also: pigpio site
VALUE pigpio_rbfn_serial_data_available(VALUE self, VALUE pi, VALUE handle){
This function opens a serial device at a specified baud rate with specified flags. The device name must start with /dev/tty or /dev/serial.
. .
pi: >=0 (as returned by [*pigpio_start*]).
ser_tty: the serial device to open.
baud: the baud rate in bits per second, see below.
ser_flags: 0.
. .
Returns a handle (>=0) if OK, otherwise PI_NO_HANDLE, or PI_SER_OPEN_FAILED.
The baud rate must be one of 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200, or 230400.
No flags are currently defined. This parameter should be set to zero.
See also: pigpio site
VALUE pigpio_rbfn_serial_open(VALUE self, VALUE pi, VALUE ser_tty, VALUE baud, VALUE ser_flags){
This function reads up to count bytes from the the serial port associated with handle and writes them to buf.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*]. count: the maximum number of bytes to read.
. .
Returns to buf.ret_code attribute the number of bytes read (>=0) if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, PI_SER_READ_NO_DATA, or PI_SER_WRITE_FAILED.
The received data is get by the buf.to_s method.
See also: pigpio site
VALUE pigpio_rbfn_serial_read(VALUE self, VALUE pi, VALUE handle, VALUE count){
This function reads a byte from the serial port associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*].
. .
Returns the read byte (>=0) if OK, otherwise PI_BAD_HANDLE, PI_SER_READ_NO_DATA, or PI_SER_READ_FAILED.
If no data is ready PI_SER_READ_NO_DATA is returned.
See also: pigpio site
VALUE pigpio_rbfn_serial_read_byte(VALUE self, VALUE pi, VALUE handle){
This function writes count bytes from buf to the the serial port associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*]. buf: the array of bytes to write.
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_SER_WRITE_FAILED.
See also: pigpio site
VALUE pigpio_rbfn_serial_write(VALUE self, VALUE pi, VALUE handle, VALUE buf){
This function writes bVal to the serial port associated with handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*serial_open*].
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE, PI_BAD_PARAM, or PI_SER_WRITE_FAILED.
See also: pigpio site
VALUE pigpio_rbfn_serial_write_byte(VALUE self, VALUE pi, VALUE handle, VALUE bVal){
Start (non-zero dutycycle) or stop (0) PWM pulses on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31. dutycycle: 0-range (range defaults to 255).
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_DUTYCYCLE, or PI_NOT_PERMITTED. Notes
The [set_PWM_range] function may be used to change the default range of 255.
See also: pigpio site
VALUE pigpio_rbfn_set_PWM_dutycycle(VALUE self, VALUE pi, VALUE user_gpio, VALUE dutycycle){
Set the frequency (in Hz) of the PWM to be used on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31. frequency: >=0 (Hz).
. .
Returns the numerically closest frequency if OK, otherwise PI_BAD_USER_GPIO or PI_NOT_PERMITTED.
If PWM is currently active on the GPIO it will be switched off and then back on at the new frequency.
Each GPIO can be independently set to one of 18 different PWM frequencies.
The selectable frequencies depend upon the sample rate which may be 1, 2, 4, 5, 8, or 10 microseconds (default 5). The sample rate is set when the pigpio daemon is started.
The frequencies for each sample rate are:
. .
Hertz
1: 40000 20000 10000 8000 5000 4000 2500 2000 1600
1250 1000 800 500 400 250 200 100 50
2: 20000 10000 5000 4000 2500 2000 1250 1000 800
625 500 400 250 200 125 100 50 25
4: 10000 5000 2500 2000 1250 1000 625 500 400
313 250 200 125 100 63 50 25 13
sample
rate
(us) 5: 8000 4000 2000 1600 1000 800 500 400 320
250 200 160 100 80 50 40 20 10
8: 5000 2500 1250 1000 625 500 313 250 200
156 125 100 63 50 31 25 13 6
10: 4000 2000 1000 800 500 400 250 200 160
125 100 80 50 40 25 20 10 5
. .
See also: pigpio site
VALUE pigpio_rbfn_set_PWM_frequency(VALUE self, VALUE pi, VALUE user_gpio, VALUE frequency){
Set the range of PWM values to be used on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
range: 25-40000.
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_DUTYRANGE, or PI_NOT_PERMITTED.
Notes
If PWM is currently active on the GPIO its dutycycle will be scaled to reflect the new range.
The real range, the number of steps between fully off and fully on for each of the 18 available GPIO frequencies is
. .
25(#1), 50(#2), 100(#3), 125(#4), 200(#5), 250(#6), 400(#7), 500(#8), 625(#9), 800(#10), 1000(#11), 1250(#12), 2000(#13), 2500(#14), 4000(#15), 5000(#16), 10000(#17), 20000(#18)
. .
The real value set by ::set_PWM_range is (dutycycle * real range) / range.
See also: pigpio site
VALUE pigpio_rbfn_set_PWM_range(VALUE self, VALUE pi, VALUE user_gpio, VALUE range){
Sets GPIO 0-31 if the corresponding bit in bits is set.
. .
pi: >=0 (as returned by [*pigpio_start*]).
bits: a bit mask with 1 set if the corresponding GPIO is
to be set.
. .
Returns 0 if OK, otherwise PI_SOME_PERMITTED.
A status of PI_SOME_PERMITTED indicates that the user is not allowed to write to one or more of the GPIO.
See also: pigpio site
VALUE pigpio_rbfn_set_bank_1(VALUE self, VALUE pi, VALUE bits){
Sets GPIO 32-53 if the corresponding bit (0-21) in bits is set.
. .
pi: >=0 (as returned by [*pigpio_start*]).
bits: a bit mask with 1 set if the corresponding GPIO is
to be set.
. .
Returns 0 if OK, otherwise PI_SOME_PERMITTED.
A status of PI_SOME_PERMITTED indicates that the user is not allowed to write to one or more of the GPIO.
See also: pigpio site
VALUE pigpio_rbfn_set_bank_2(VALUE self, VALUE pi, VALUE bits){
Sets a glitch filter on a GPIO.
Level changes on the GPIO are not reported unless the level has been stable for at least [steady] microseconds. The level is then reported. Level changes of less than
- steady
-
microseconds are ignored.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31 steady: 0-300000
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, or PI_BAD_FILTER.
This filter affects the GPIO samples returned to callbacks set up with [callback], [callback_ex] and [wait_for_edge].
It does not affect levels read by [gpio_read], [read_bank_1], or [read_bank_2].
Each (stable) edge will be timestamped [steady] microseconds after it was first detected.
See also: pigpio site
VALUE pigpio_rbfn_set_glitch_filter(VALUE self,VALUE pi, VALUE user_gpio, VALUE steady){
Set the GPIO mode.
. .
pi: >=0 (as returned by [*pigpio_start*]).
gpio: 0-53.
mode: PI_INPUT, PI_OUTPUT, PI_ALT0, PI_ALT1,
PI_ALT2, PI_ALT3, PI_ALT4, PI_ALT5.
. .
Returns 0 if OK, otherwise PI_BAD_GPIO, PI_BAD_MODE, or PI_NOT_PERMITTED.
See also: pigpio site
VALUE pigpio_rbfn_set_mode(VALUE self,VALUE pi, VALUE gpio, VALUE mode){
Sets a noise filter on a GPIO.
Level changes on the GPIO are ignored until a level which has been stable for [steady] microseconds is detected. Level changes on the GPIO are then reported for [active] microseconds after which the process repeats.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31 steady: 0-300000 active: 0-1000000
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, or PI_BAD_FILTER.
This filter affects the GPIO samples returned to callbacks set up with [callback], [callback_ex] and [wait_for_edge].
It does not affect levels read by [gpio_read], [read_bank_1], or [read_bank_2].
Level changes before and after the active period may be reported. Your software must be designed to cope with such reports.
See also: pigpio site
VALUE pigpio_rbfn_set_noise_filter(VALUE self,VALUE pi, VALUE user_gpio, VALUE steady, VALUE active){
This function sets the pad drive strength in mA.
. .
pi: >=0 (as returned by [*pigpio_start*]).
pad: 0-2, the pad to set.
padStrength: 1-16 mA.
. .
Returns 0 if OK, otherwise PI_BAD_PAD, or PI_BAD_STRENGTH.
Pad @ GPIO 0 @ 0-27 1 @ 28-45 2 @ 46-53
…
set_pad_strength(pi, 0, 10); // set pad 0 strength to 10 mA
…
See also: pigpio site
VALUE pigpio_rbfn_set_pad_strength(VALUE self, VALUE pi, VALUE pad, VALUE padStrength){
Set or clear the GPIO pull-up/down resistor.
. .
pi: >=0 (as returned by [*pigpio_start*]). gpio: 0-53. pud: PI_PUD_UP, PI_PUD_DOWN, PI_PUD_OFF.
. .
Returns 0 if OK, otherwise PI_BAD_GPIO, PI_BAD_PUD, or PI_NOT_PERMITTED.
See also: pigpio site
VALUE pigpio_rbfn_set_pull_up_down(VALUE self,VALUE pi, VALUE gpio, VALUE pud){
Start (500-2500) or stop (0) servo pulses on the GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31. pulsewidth: 0 (off), 500 (anti-clockwise) - 2500 (clockwise).
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_PULSEWIDTH or PI_NOT_PERMITTED.
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. A value of 1500 should always be safe and represents the mid-point of rotation.
You can DAMAGE a servo if you command it to move beyond its limits.
OTHER UPDATE RATES:
This function updates servos at 50Hz. If you wish to use a different update frequency you will have to use the PWM functions.
. .
Update Rate (Hz) 50 100 200 400 500 1E6/Hz 20000 10000 5000 2500 2000
. .
Firstly set the desired PWM frequency using [set_PWM_frequency].
Then set the PWM range using [set_PWM_range] to 1E6/Hz. Doing this allows you to use units of microseconds when setting the servo pulsewidth.
E.g. If you want to update a servo connected to GPIO 25 at 400Hz
. .
set_PWM_frequency(25, 400); set_PWM_range(25, 2500);
. .
Thereafter use the [set_PWM_dutycycle] function to move the servo, e.g. ::set_PWM_dutycycle(25, 1500) will set a 1500 us pulse.
See also: pigpio site
VALUE pigpio_rbfn_set_servo_pulsewidth(VALUE self, VALUE pi, VALUE user_gpio, VALUE pulsewidth){
Sets a watchdog for a GPIO.
. .
pi: >=0 (as returned by [*pigpio_start*]). user_gpio: 0-31. timeout: 0-60000.
. .
Returns 0 if OK, otherwise PI_BAD_USER_GPIO or PI_BAD_WDOG_TIMEOUT.
The watchdog is nominally in milliseconds.
Only one watchdog may be registered per GPIO.
The watchdog may be cancelled by setting timeout to 0.
Once a watchdog has been started callbacks for the GPIO will be triggered every timeout interval after the last GPIO activity.
The callback will receive the special level PI_TIMEOUT.
See also: pigpio site
VALUE pigpio_rbfn_set_watchdog(VALUE self,VALUE pi, VALUE user_gpio, VALUE timeout){
This functions closes the SPI device identified by the handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*spi_open*].
. .
Returns 0 if OK, otherwise PI_BAD_HANDLE.
See also: pigpio site
VALUE pigpio_rbfn_spi_close(VALUE self, VALUE pi, VALUE handle){
This function returns a handle for the SPI device on channel. Data will be transferred at baud bits per second. The flags may be used to modify the default behaviour of 4-wire operation, mode 0, active low chip select.
An auxiliary SPI device is available on all models but the A and B and may be selected by setting the A bit in the flags. The auxiliary device has 3 chip selects and a selectable word size in bits.
. .
pi: >=0 (as returned by [*pigpio_start*]).
spi_channel: 0-1 (0-2 for the auxiliary device).
baud: 32K-125M (values above 30M are unlikely to work).
spi_flags: see below.
. .
Returns a handle (>=0) if OK, otherwise PI_BAD_SPI_CHANNEL, PI_BAD_SPI_SPEED, PI_BAD_FLAGS, PI_NO_AUX_SPI, or PI_SPI_OPEN_FAILED.
spi_flags consists of the least significant 22 bits.
. .
21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 b b b b b b R T n n n n W A u2 u1 u0 p2 p1 p0 m m
. .
mm defines the SPI mode.
Warning: modes 1 and 3 do not appear to work on the auxiliary device.
. .
Mode POL PHA 0 0 0 1 0 1 2 1 0 3 1 1
. .
px is 0 if CEx is active low (default) and 1 for active high.
ux is 0 if the CEx GPIO is reserved for SPI (default) and 1 otherwise.
A is 0 for the standard SPI device, 1 for the auxiliary SPI.
W is 0 if the device is not 3-wire, 1 if the device is 3-wire. Standard SPI device only.
nnnn defines the number of bytes (0-15) to write before switching the MOSI line to MISO to read data. This field is ignored if W is not set. Standard SPI device only.
T is 1 if the least significant bit is transmitted on MOSI first, the default (0) shifts the most significant bit out first. Auxiliary SPI device only.
R is 1 if the least significant bit is received on MISO first, the default (0) receives the most significant bit first. Auxiliary SPI device only.
bbbbbb defines the word size in bits (0-32). The default (0) sets 8 bits per word. Auxiliary SPI device only.
The [spi_read], [spi_write], and [spi_xfer] functions transfer data packed into 1, 2, or 4 bytes according to the word size in bits.
For bits 1-8 there will be one byte per character. For bits 9-16 there will be two bytes per character. For bits 17-32 there will be four bytes per character.
Multi-byte transfers are made in least significant byte first order.
E.g. to transfer 32 11-bit words buf should contain 64 bytes and count should be 64.
E.g. to transfer the 14 bit value 0x1ABC send the bytes 0xBC followed by 0x1A.
The other bits in flags should be set to zero.
See also: pigpio site
VALUE pigpio_rbfn_spi_open(VALUE self, VALUE pi, VALUE spi_channel, VALUE baud, VALUE spi_flags){
This function reads count bytes of data from the SPI device associated with the handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*spi_open*]. buf: an array to receive the read data bytes. count: the number of bytes to read.
. .
Returns the number of bytes transferred if OK, otherwise PI_BAD_HANDLE, PI_BAD_SPI_COUNT, or PI_SPI_XFER_FAILED.
See also: pigpio site
VALUE pigpio_rbfn_spi_read(VALUE self, VALUE pi, VALUE handle, VALUE count){
This function writes count bytes of data from buf to the SPI device associated with the handle.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*spi_open*]. buf: the data bytes to write.
. .
Returns the number of bytes transferred if OK, otherwise PI_BAD_HANDLE, PI_BAD_SPI_COUNT, or PI_SPI_XFER_FAILED.
See also: pigpio site
VALUE pigpio_rbfn_spi_write(VALUE self, VALUE pi, VALUE handle, VALUE buf){
This function transfers count bytes of data from txBuf to the SPI device associated with the handle. Simultaneously count bytes of data are read from the device and placed in rxBuf.
. .
pi: >=0 (as returned by [*pigpio_start*]). handle: >=0, as returned by a call to [*spi_open*]. txBuf: the data bytes to write. rxBuf: the received data bytes.
. .
Returns the number of bytes transferred if OK, otherwise PI_BAD_HANDLE, PI_BAD_SPI_COUNT, or PI_SPI_XFER_FAILED.
See also: pigpio site
VALUE pigpio_rbfn_spi_xfer(VALUE self, VALUE pi, VALUE handle, VALUE txBuf){
This function stops a running script.
. .
pi: >=0 (as returned by [*pigpio_start*]). script_id: >=0, as returned by [*store_script*].
. .
The function returns 0 if OK, otherwise PI_BAD_SCRIPT_ID.
See also: pigpio site
VALUE pigpio_rbfn_stop_script(VALUE self,VALUE pi, VALUE script_id){
This function stores a script for later execution.
See [[abyz.co.uk/rpi/pigpio/pigs.html#Scripts]] for details.
. .
pi: >=0 (as returned by [*pigpio_start*]). script: the text of the script.
. .
The function returns a script id if the script is valid, otherwise PI_BAD_SCRIPT.
See also: pigpio site
VALUE pigpio_rbfn_store_script(VALUE self,VALUE pi, VALUE script){
Return the current time in seconds since the Epoch.
See also: pigpio site
VALUE pigpio_rbfn_time_time(VALUE self){
This function waits for an edge on the GPIO for up to timeout seconds.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
edge: RISING_EDGE, FALLING_EDGE, or EITHER_EDGE.
timeout: >=0.
. .
The function returns when the edge occurs or after the timeout.
Do not use this function for precise timing purposes, the edge is only checked 20 times a second. Whenever you need to know the accurate time of GPIO events use a [callback] function.
The function returns 1 if the edge occurred, otherwise 0.
See also: pigpio site
VALUE pigpio_rbfn_wait_for_edge(VALUE self,VALUE pi, VALUE user_gpio, VALUE edge, VALUE timeout){
This function waits for an event for up to timeout seconds.
. .
pi: >=0 (as returned by [*pigpio_start*]). event: 0-31. timeout: >=0.
. .
The function returns when the event occurs or after the timeout.
The function returns 1 if the event occurred, otherwise 0.
See also: pigpio site
VALUE pigpio_rbfn_wait_for_event(VALUE self,VALUE pi, VALUE event, VALUE timeout){
This function adds a number of pulses to the current waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
numPulses: the number of pulses.
pulses: an array of pulses.
. .
Returns the new total number of pulses in the current waveform if OK, otherwise PI_TOO_MANY_PULSES.
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.
See also: pigpio site
VALUE pigpio_rbfn_wave_add_generic(VALUE self,VALUE pi, VALUE pulses){
This function starts a new empty waveform. You wouldn't normally need to call this function as it is automatically called after a waveform is created with the [wave_create] function.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns 0 if OK.
See also: pigpio site
VALUE pigpio_rbfn_wave_add_new(VALUE self,VALUE pi){
This function adds a waveform representing serial data to the existing waveform (if any). The serial data starts offset microseconds from the start of the waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
user_gpio: 0-31.
baud: 50-1000000
data_bits: number of data bits (1-32)
stop_bits: number of stop half bits (2-8)
offset: >=0
numBytes: >=1
str: an array of chars.
. .
Returns the new total number of pulses in the current waveform if OK, otherwise PI_BAD_USER_GPIO, PI_BAD_WAVE_BAUD, PI_BAD_DATABITS, PI_BAD_STOP_BITS, PI_TOO_MANY_CHARS, PI_BAD_SER_OFFSET, or PI_TOO_MANY_PULSES.
NOTES:
The serial data is formatted as one start bit, [data_bits] data bits, and [stop_bits]/2 stop bits.
It is legal to add serial data streams with different baud rates to the same waveform.
- numBytes
-
is the number of bytes of data in str.
The bytes required for each character depend upon [data_bits].
For [data_bits] 1-8 there will be one byte per character. For [data_bits] 9-16 there will be two bytes per character. For [data_bits] 17-32 there will be four bytes per character.
See also: pigpio site
VALUE pigpio_rbfn_wave_add_serial(VALUE self,VALUE pi, VALUE user_gpio, VALUE baud, VALUE data_bits, VALUE stop_bits, VALUE offset, VALUE str){
This function transmits a chain of waveforms.
NOTE: Any hardware PWM started by [hardware_PWM] will be cancelled.
The waves to be transmitted are specified by the contents of buf which contains an ordered list of [wave_id]s and optional command codes and related data.
. .
pi: >=0 (as returned by [*pigpio_start*]).
buf: pointer to the wave_ids and optional command codes
bufSize: the number of bytes in buf
. .
Returns 0 if OK, otherwise PI_CHAIN_NESTING, PI_CHAIN_LOOP_CNT, PI_BAD_CHAIN_LOOP, PI_BAD_CHAIN_CMD, PI_CHAIN_COUNTER, PI_BAD_CHAIN_DELAY, PI_CHAIN_TOO_BIG, or PI_BAD_WAVE_ID.
Each wave is transmitted in the order specified. A wave may occur multiple times per chain.
A blocks of waves may be transmitted multiple times by using the loop commands. The block is bracketed by loop start and end commands. Loops may be nested.
Delays between waves may be added with the delay command.
The following command codes are supported:
Name @ Cmd & Data @ Meaning Loop Start @ 255 0 @ Identify start of a wave block Loop Repeat @ 255 1 x y @ loop x + y*256 times Delay @ 255 2 x y @ delay x + y*256 microseconds Loop Forever @ 255 3 @ loop forever
If present Loop Forever must be the last entry in the chain.
The code is currently dimensioned to support a chain with roughly 600 entries and 20 loop counters.
The arg buf is binary stirng or integer array.
See also: pigpio site
VALUE pigpio_rbfn_wave_chain(VALUE self,VALUE pi, VALUE buf){
This function clears all waveforms and any data added by calls to the
- wave_add_*
-
functions.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns 0 if OK.
See also: pigpio site
VALUE pigpio_rbfn_wave_clear(VALUE self,VALUE pi){
This function creates a waveform from the data provided by the prior calls to the [wave_add_*] functions. Upon success a wave id greater than or equal to 0 is returned, otherwise PI_EMPTY_WAVEFORM, PI_TOO_MANY_CBS, PI_TOO_MANY_OOL, or PI_NO_WAVEFORM_ID.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
The data provided by the [wave_add_*] functions is consumed by this function.
As many waveforms may be created as there is space available. The wave id is passed to [wave_send_*] to specify the waveform to transmit.
Normal usage would be
Step 1. [wave_clear] to clear all waveforms and added data.
Step 2. [wave_add_*] calls to supply the waveform data.
Step 3. [wave_create] to create the waveform and get a unique id
Repeat steps 2 and 3 as needed.
Step 4. [wave_send_*] with the id of the waveform to transmit.
A waveform comprises one or more pulses. Each pulse consists of a PIGPIO::Pulse class.
The fields specify
1) the GPIO to be switched on at the start of the pulse. 2) the GPIO to be switched off at the start of the pulse. 3) the delay in microseconds before the next pulse.
Any or all the fields can be zero. It doesn't make any sense to set all the fields to zero (the pulse will be ignored).
When a waveform is started each pulse is executed in order with the specified delay between the pulse and the next.
Returns the new waveform id if OK, otherwise PI_EMPTY_WAVEFORM, PI_NO_WAVEFORM_ID, PI_TOO_MANY_CBS, or PI_TOO_MANY_OOL.
See also: pigpio site
VALUE pigpio_rbfn_wave_create(VALUE self,VALUE pi){
This function deletes the waveform with id wave_id.
. .
pi: >=0 (as returned by [*pigpio_start*]). wave_id: >=0, as returned by [*wave_create*].
. .
Wave ids are allocated in order, 0, 1, 2, etc.
Returns 0 if OK, otherwise PI_BAD_WAVE_ID.
See also: pigpio site
VALUE pigpio_rbfn_wave_delete(VALUE self,VALUE pi, VALUE wave_id){
This function returns the length in DMA control blocks of the current waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_cbs(VALUE self,VALUE pi){
This function returns the length in DMA control blocks of the longest waveform created since the pigpio daemon was started.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_high_cbs(VALUE self,VALUE pi){
This function returns the length in microseconds of the longest waveform created since the pigpio daemon was started.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_high_micros(VALUE self,VALUE pi){
This function returns the length in pulses of the longest waveform created since the pigpio daemon was started.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_high_pulses(VALUE self,VALUE pi){
This function returns the maximum possible size of a waveform in DMA control blocks.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_max_cbs(VALUE self,VALUE pi){
This function returns the maximum possible size of a waveform in microseconds.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_max_micros(VALUE self,VALUE pi){
This function returns the maximum possible size of a waveform in pulses.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_max_pulses(VALUE self,VALUE pi){
This function returns the length in microseconds of the current waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_micros(VALUE self,VALUE pi){
This function returns the length in pulses of the current waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
See also: pigpio site
VALUE pigpio_rbfn_wave_get_pulses(VALUE self,VALUE pi){
This function transmits the waveform with id wave_id. The waveform is sent once.
NOTE: Any hardware PWM started by [hardware_PWM] will be cancelled.
. .
pi: >=0 (as returned by [*pigpio_start*]). wave_id: >=0, as returned by [*wave_create*].
. .
Returns the number of DMA control blocks in the waveform if OK, otherwise PI_BAD_WAVE_ID, or PI_BAD_WAVE_MODE.
See also: pigpio site
VALUE pigpio_rbfn_wave_send_once(VALUE self,VALUE pi, VALUE wave_id){
This function transmits the waveform with id wave_id. The waveform cycles until cancelled (either by the sending of a new waveform or by [wave_tx_stop]).
NOTE: Any hardware PWM started by [hardware_PWM] will be cancelled.
. .
pi: >=0 (as returned by [*pigpio_start*]).
wave_id: >=0, as returned by [wave_create]. . .
Returns the number of DMA control blocks in the waveform if OK, otherwise PI_BAD_WAVE_ID, or PI_BAD_WAVE_MODE.
See also: pigpio site
VALUE pigpio_rbfn_wave_send_repeat(VALUE self,VALUE pi, VALUE wave_id){
Transmits the waveform with id wave_id using mode mode.
. .
pi: >=0 (as returned by [*pigpio_start*]).
wave_id: >=0, as returned by [*wave_create*].
mode: PI_WAVE_MODE_ONE_SHOT, PI_WAVE_MODE_REPEAT,
PI_WAVE_MODE_ONE_SHOT_SYNC, or PI_WAVE_MODE_REPEAT_SYNC.
. .
PI_WAVE_MODE_ONE_SHOT: same as [wave_send_once].
PI_WAVE_MODE_REPEAT same as [wave_send_repeat].
PI_WAVE_MODE_ONE_SHOT_SYNC same as [wave_send_once] but tries to sync with the previous waveform.
PI_WAVE_MODE_REPEAT_SYNC same as [wave_send_repeat] but tries to sync with the previous waveform.
WARNING: bad things may happen if you delete the previous waveform before it has been synced to the new waveform.
NOTE: Any hardware PWM started by [hardware_PWM] will be cancelled.
Returns the number of DMA control blocks in the waveform if OK, otherwise PI_BAD_WAVE_ID, or PI_BAD_WAVE_MODE.
See also: pigpio site
VALUE pigpio_rbfn_wave_send_using_mode(VALUE self,VALUE pi, VALUE wave_id, VALUE mode){
This function returns the id of the waveform currently being transmitted.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns the waveform id or one of the following special values:
PI_WAVE_NOT_FOUND (9998) - transmitted wave not found. PI_NO_TX_WAVE (9999) - no wave being transmitted.
See also: pigpio site
VALUE pigpio_rbfn_wave_tx_at(VALUE self,VALUE pi){
This function checks to see if a waveform is currently being transmitted.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns 1 if a waveform is currently being transmitted, otherwise 0.
See also: pigpio site
VALUE pigpio_rbfn_wave_tx_busy(VALUE self,VALUE pi){
This function stops the transmission of the current waveform.
. .
pi: >=0 (as returned by [*pigpio_start*]).
. .
Returns 0 if OK.
This function is intended to stop a waveform started with the repeat mode.
See also: pigpio site
VALUE pigpio_rbfn_wave_tx_stop(VALUE self,VALUE pi){