Help on module pigpio: NAME pigpio FILE /mnt/d/Users/guy/Projects/pigpio/pigpio.py DESCRIPTION pigpio is a Python module for the Raspberry which talks to the pigpio daemon to allow control of the general purpose input outputs (GPIO). [http://abyz.me.uk/rpi/pigpio/python.html] *Features* o the pigpio Python module can run on Windows, Macs, or Linux o controls one or more Pi's o hardware timed PWM on any of GPIO 0-31 o hardware timed servo pulses on any of GPIO 0-31 o callbacks when any of GPIO 0-31 change state o creating and transmitting precisely timed waveforms o reading/writing GPIO and setting their modes o wrappers for I2C, SPI, and serial links o creating and running scripts on the pigpio daemon *GPIO* ALL GPIO are identified by their Broadcom number. *Notes* Transmitted waveforms are accurate to a microsecond. Callback level changes are time-stamped and will be accurate to within a few microseconds. *Settings* A number of settings are determined when the pigpio daemon is started. o the sample rate (1, 2, 4, 5, 8, or 10 us, default 5 us). o the set of GPIO which may be updated (generally written to). The default set is those available on the Pi board revision. o the available PWM frequencies (see [*set_PWM_frequency*]). *Exceptions* By default a fatal exception is raised if you pass an invalid argument to a pigpio function. If you wish to handle the returned status yourself you should set pigpio.exceptions to False. You may prefer to check the returned status in only a few parts of your code. In that case do the following: ... pigpio.exceptions = False # Code where you want to test the error status. pigpio.exceptions = True ... *Usage* This module uses the services of the C pigpio library. pigpio must be running on the Pi(s) whose GPIO are to be manipulated. The normal way to start pigpio is as a daemon (during system start). sudo pigpiod Your Python program must import pigpio and create one or more instances of the pigpio.pi class. This class gives access to a specified Pi's GPIO. ... pi1 = pigpio.pi() # pi1 accesses the local Pi's GPIO pi2 = pigpio.pi('tom') # pi2 accesses tom's GPIO pi3 = pigpio.pi('dick') # pi3 accesses dick's GPIO pi1.write(4, 0) # set local Pi's GPIO 4 low pi2.write(4, 1) # set tom's GPIO 4 to high pi3.read(4) # get level of dick's GPIO 4 ... The later example code snippets assume that pi is an instance of the pigpio.pi class. OVERVIEW ESSENTIAL pigpio.pi Initialise Pi connection stop Stop a Pi connection BASIC set_mode Set a GPIO mode get_mode Get a GPIO mode set_pull_up_down Set/clear GPIO pull up/down resistor read Read a GPIO write Write a GPIO PWM_(overrides_servo_commands_on_same_GPIO) set_PWM_dutycycle Start/stop PWM pulses on a GPIO set_PWM_frequency Set PWM frequency of a GPIO set_PWM_range Configure PWM range of a GPIO get_PWM_dutycycle Get PWM dutycycle set on a GPIO get_PWM_frequency Get PWM frequency of a GPIO get_PWM_range Get configured PWM range of a GPIO get_PWM_real_range Get underlying PWM range for a GPIO Servo_(overrides_PWM_commands_on_same_GPIO) set_servo_pulsewidth Start/Stop servo pulses on a GPIO get_servo_pulsewidth Get servo pulsewidth set on a GPIO INTERMEDIATE gpio_trigger Send a trigger pulse to a GPIO set_watchdog Set a watchdog on a GPIO read_bank_1 Read all bank 1 GPIO read_bank_2 Read all bank 2 GPIO clear_bank_1 Clear selected GPIO in bank 1 clear_bank_2 Clear selected GPIO in bank 2 set_bank_1 Set selected GPIO in bank 1 set_bank_2 Set selected GPIO in bank 2 callback Create GPIO level change callback wait_for_edge Wait for GPIO level change ADVANCED notify_open Request a notification handle notify_begin Start notifications for selected GPIO notify_pause Pause notifications notify_close Close a notification hardware_clock Start hardware clock on supported GPIO hardware_PWM Start hardware PWM on supported GPIO set_glitch_filter Set a glitch filter on a GPIO set_noise_filter Set a noise filter on a GPIO set_pad_strength Sets a pads drive strength get_pad_strength Gets a pads drive strength shell Executes a shell command Custom custom_1 User custom function 1 custom_2 User custom function 2 Events event_callback Sets a callback for an event event_trigger Triggers an event wait_for_event Wait for an event Scripts store_script Store a script run_script Run a stored script update_script Set a scripts parameters script_status Get script status and parameters stop_script Stop a running script delete_script Delete a stored script I2C i2c_open Opens an I2C device i2c_close Closes an I2C device i2c_write_quick SMBus write quick i2c_read_byte SMBus read byte i2c_write_byte SMBus write byte i2c_read_byte_data SMBus read byte data i2c_write_byte_data SMBus write byte data i2c_read_word_data SMBus read word data i2c_write_word_data SMBus write word data i2c_read_block_data SMBus read block data i2c_write_block_data SMBus write block data i2c_read_i2c_block_data SMBus read I2C block data i2c_write_i2c_block_data SMBus write I2C block data i2c_read_device Reads the raw I2C device i2c_write_device Writes the raw I2C device i2c_process_call SMBus process call i2c_block_process_call SMBus block process call i2c_zip Performs multiple I2C transactions I2C_BIT_BANG bb_i2c_open Opens GPIO for bit banging I2C bb_i2c_close Closes GPIO for bit banging I2C bb_i2c_zip Performs multiple bit banged I2C transactions I2C/SPI_SLAVE bsc_xfer I2C/SPI as slave transfer bsc_i2c I2C as slave transfer SERIAL serial_open Opens a serial device serial_close Closes a serial device serial_read_byte Reads a byte from a serial device serial_write_byte Writes a byte to a serial device serial_read Reads bytes from a serial device serial_write Writes bytes to a serial device serial_data_available Returns number of bytes ready to be read SERIAL_BIT_BANG_(read_only) bb_serial_read_open Open a GPIO for bit bang serial reads bb_serial_read_close Close a GPIO for bit bang serial reads bb_serial_invert Invert serial logic (1 invert, 0 normal) bb_serial_read Read bit bang serial data from a GPIO SPI spi_open Opens a SPI device spi_close Closes a SPI device spi_read Reads bytes from a SPI device spi_write Writes bytes to a SPI device spi_xfer Transfers bytes with a SPI device SPI_BIT_BANG bb_spi_open Opens GPIO for bit banging SPI bb_spi_close Closes GPIO for bit banging SPI bb_spi_xfer Transfers bytes with bit banging SPI FILES file_open Opens a file file_close Closes a file file_read Reads bytes from a file file_write Writes bytes to a file file_seek Seeks to a position within a file file_list List files which match a pattern WAVES wave_clear Deletes all waveforms wave_add_new Starts a new waveform wave_add_generic Adds a series of pulses to the waveform wave_add_serial Adds serial data to the waveform wave_create Creates a waveform from added data wave_create_and_pad Creates a waveform of fixed size from added data wave_delete Deletes a waveform wave_send_once Transmits a waveform once wave_send_repeat Transmits a waveform repeatedly wave_send_using_mode Transmits a waveform in the chosen mode wave_chain Transmits a chain of waveforms wave_tx_at Returns the current transmitting waveform wave_tx_busy Checks to see if a waveform has ended wave_tx_stop Aborts the current waveform wave_get_cbs Length in cbs of the current waveform wave_get_max_cbs Absolute maximum allowed cbs wave_get_micros Length in microseconds of the current waveform wave_get_max_micros Absolute maximum allowed micros wave_get_pulses Length in pulses of the current waveform wave_get_max_pulses Absolute maximum allowed pulses UTILITIES get_current_tick Get current tick (microseconds) get_hardware_revision Get hardware revision get_pigpio_version Get the pigpio version pigpio.error_text Gets error text from error number pigpio.tickDiff Returns difference between two ticks CLASSES exceptions.Exception(exceptions.BaseException) error pi pulse class error(exceptions.Exception) | pigpio module exception | | Method resolution order: | error | exceptions.Exception | exceptions.BaseException | __builtin__.object | | Methods defined here: | | __init__(self, value) | | __str__(self) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Data and other attributes inherited from exceptions.Exception: | | __new__ = | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from exceptions.BaseException: | | __delattr__(...) | x.__delattr__('name') <==> del x.name | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __setattr__(...) | x.__setattr__('name', value) <==> x.name = value | | __setstate__(...) | | __unicode__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from exceptions.BaseException: | | __dict__ | | args | | message class pi | Methods defined here: | | __init__(self, host='localhost', port=8888, show_errors=True) | Grants access to a Pi's GPIO. | | host:= the host name of the Pi on which the pigpio daemon is | running. The default is localhost unless overridden by | the PIGPIO_ADDR environment variable. | | port:= the port number on which the pigpio daemon is listening. | The default is 8888 unless overridden by the PIGPIO_PORT | environment variable. The pigpio daemon must have been | started with the same port number. | | This connects to the pigpio daemon and reserves resources | to be used for sending commands and receiving notifications. | | An instance attribute [*connected*] may be used to check the | success of the connection. If the connection is established | successfully [*connected*] will be True, otherwise False. | | ... | pi = pigio.pi() # use defaults | pi = pigpio.pi('mypi') # specify host, default port | pi = pigpio.pi('mypi', 7777) # specify host and port | | pi = pigpio.pi() # exit script if no connection | if not pi.connected: | exit() | ... | | __repr__(self) | | bb_i2c_close(self, SDA) | This function stops bit banging I2C on a pair of GPIO | previously opened with [*bb_i2c_open*]. | | 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. | | ... | pi.bb_i2c_close(SDA) | ... | | bb_i2c_open(self, SDA, SCL, baud=100000) | 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. | | o baud rates as low as 50 | o repeated starts | o clock stretching | o I2C on any pair of spare GPIO | | 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. | | ... | h = pi.bb_i2c_open(4, 5, 50000) # bit bang on GPIO 4/5 at 50kbps | ... | | bb_i2c_zip(self, SDA, data) | This function executes a sequence of bit banged I2C operations. | The operations to be performed are specified by the contents | of data which contains the concatenated command codes and | associated data. | | SDA:= 0-31 (as used in a prior call to [*bb_i2c_open*]) | data:= the concatenated I2C commands, see below | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (count, data) = pi.bb_i2c_zip( | SDA, [4, 0x53, 2, 7, 1, 0x32, 2, 6, 6, 3, 0]) | ... | | 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. | | Any read I2C data is concatenated in the returned bytearray. | | ... | 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 | ... | | bb_serial_invert(self, user_gpio, invert) | Invert serial logic. | | user_gpio:= 0-31 (opened in a prior call to [*bb_serial_read_open*]) | invert:= 0-1 (1 invert, 0 normal) | | ... | status = pi.bb_serial_invert(17, 1) | ... | | bb_serial_read(self, user_gpio) | Returns data from the bit bang serial cyclic buffer. | | user_gpio:= 0-31 (opened in a prior call to [*bb_serial_read_open*]) | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | The bytes returned for each character depend upon the number of | data bits [*bb_bits*] specified in the [*bb_serial_read_open*] | command. | | For [*bb_bits*] 1-8 there will be one byte per character. | For [*bb_bits*] 9-16 there will be two bytes per character. | For [*bb_bits*] 17-32 there will be four bytes per character. | | ... | (count, data) = pi.bb_serial_read(4) | ... | | bb_serial_read_close(self, user_gpio) | Closes a GPIO for bit bang reading of serial data. | | user_gpio:= 0-31 (opened in a prior call to [*bb_serial_read_open*]) | | ... | status = pi.bb_serial_read_close(17) | ... | | bb_serial_read_open(self, user_gpio, baud, bb_bits=8) | Opens a GPIO for bit bang reading of serial data. | | user_gpio:= 0-31, the GPIO to use. | baud:= 50-250000, the baud rate. | bb_bits:= 1-32, the number of bits per word, default 8. | | The serial data is held 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. | | ... | status = pi.bb_serial_read_open(4, 19200) | status = pi.bb_serial_read_open(17, 9600) | ... | | bb_spi_close(self, CS) | This function stops bit banging SPI on a set of GPIO | opened with [*bb_spi_open*]. | | 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. | | ... | pi.bb_spi_close(CS) | ... | | bb_spi_open(self, CS, MISO, MOSI, SCLK, baud=100000, spi_flags=0) | This function selects a set of GPIO for bit banging SPI at a | specified baud rate. | | CS := 0-31 | MISO := 0-31 | MOSI := 0-31 | SCLK := 0-31 | baud := 50-250000 | spiFlags := see below | | spiFlags 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 | . . | | The following constants may be used to set the mode: | | . . | pigpio.SPI_MODE_0 | pigpio.SPI_MODE_1 | pigpio.SPI_MODE_2 | pigpio.SPI_MODE_3 | . . | | Alternatively pigpio.SPI_CPOL and/or pigpio.SPI_CPHA | may be used. | | p is 0 if CS is active low (default) and 1 for active high. | pigpio.SPI_CS_HIGH_ACTIVE may be used to set this flag. | | T is 1 if the least significant bit is transmitted on MOSI first, | the default (0) shifts the most significant bit out first. | pigpio.SPI_TX_LSBFIRST may be used to set this flag. | | R is 1 if the least significant bit is received on MISO first, | the default (0) receives the most significant bit first. | pigpio.SPI_RX_LSBFIRST may be used to set this flag. | | The other bits in spiFlags 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(10, MISO, MOSI, SCLK, 10000, 0); // device 1 | bb_spi_open(11, MISO, MOSI, SCLK, 20000, 3); // device 2 | ... | | bb_spi_xfer(self, CS, data) | This function executes a bit banged SPI transfer. | | CS:= 0-31 (as used in a prior call to [*bb_spi_open*]) | data:= data to be sent | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | #!/usr/bin/env python | | import pigpio | | CE0=5 | CE1=6 | MISO=13 | MOSI=19 | SCLK=12 | | pi = pigpio.pi() | if not pi.connected: | exit() | | pi.bb_spi_open(CE0, MISO, MOSI, SCLK, 10000, 0) # MCP4251 DAC | pi.bb_spi_open(CE1, MISO, MOSI, SCLK, 20000, 3) # MCP3008 ADC | | for i in range(256): | | count, data = pi.bb_spi_xfer(CE0, [0, i]) # Set DAC value | | if count == 2: | | count, data = pi.bb_spi_xfer(CE0, [12, 0]) # Read back DAC | | if count == 2: | | set_val = data[1] | | count, data = pi.bb_spi_xfer(CE1, [1, 128, 0]) # Read ADC | | if count == 3: | | read_val = ((data[1]&3)<<8) | data[2] | | print("{} {}".format(set_val, read_val)) | | pi.bb_spi_close(CE0) | pi.bb_spi_close(CE1) | | pi.stop() | ... | | bsc_i2c(self, i2c_address, data=[]) | This function allows the Pi to act as a slave I2C device. | | This function is not available on the BCM2711 (e.g. as | used in the Pi4B). | | The data bytes (if any) are written to the BSC transmit | FIFO and the bytes in the BSC receive FIFO are returned. | | i2c_address:= the I2C slave address. | data:= the data bytes to transmit. | | The returned value is a tuple of the status, the number | of bytes read, and a bytearray containing the read bytes. | | See [*bsc_xfer*] for details of the 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 as inputs. | | This example assumes GPIO 2/3 are connected to GPIO 18/19 | (GPIO 10/11 on the BCM2711). | | ... | #!/usr/bin/env python | import time | import pigpio | | I2C_ADDR=0x13 | | def i2c(id, tick): | global pi | | s, b, d = pi.bsc_i2c(I2C_ADDR) | if b: | if d[0] == ord('t'): # 116 send 'HH:MM:SS*' | | print("sent={} FR={} received={} [{}]". | format(s>>16, s&0xfff,b,d)) | | s, b, d = pi.bsc_i2c(I2C_ADDR, | "{}*".format(time.asctime()[11:19])) | | elif d[0] == ord('d'): # 100 send 'Sun Oct 30*' | | print("sent={} FR={} received={} [{}]". | format(s>>16, s&0xfff,b,d)) | | s, b, d = pi.bsc_i2c(I2C_ADDR, | "{}*".format(time.asctime()[:10])) | | pi = pigpio.pi() | | if not pi.connected: | exit() | | # Respond to BSC slave activity | | e = pi.event_callback(pigpio.EVENT_BSC, i2c) | | pi.bsc_i2c(I2C_ADDR) # Configure BSC as I2C slave | | time.sleep(600) | | e.cancel() | | pi.bsc_i2c(0) # Disable BSC peripheral | | pi.stop() | ... | | While running the above. | | . . | $ i2cdetect -y 1 | 0 1 2 3 4 5 6 7 8 9 a b c d e f | 00: -- -- -- -- -- -- -- -- -- -- -- -- -- | 10: -- -- -- 13 -- -- -- -- -- -- -- -- -- -- -- -- | 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- | 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- | 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- | 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- | 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- | 70: -- -- -- -- -- -- -- -- | | $ pigs i2co 1 0x13 0 | 0 | | $ pigs i2cwd 0 116 | $ pigs i2crd 0 9 -a | 9 10:13:58* | | $ pigs i2cwd 0 116 | $ pigs i2crd 0 9 -a | 9 10:14:29* | | $ pigs i2cwd 0 100 | $ pigs i2crd 0 11 -a | 11 Sun Oct 30* | | $ pigs i2cwd 0 100 | $ pigs i2crd 0 11 -a | 11 Sun Oct 30* | | $ pigs i2cwd 0 116 | $ pigs i2crd 0 9 -a | 9 10:23:16* | | $ pigs i2cwd 0 100 | $ pigs i2crd 0 11 -a | 11 Sun Oct 30* | . . | | bsc_xfer(self, bsc_control, data) | This function provides a low-level interface to the SPI/I2C Slave | peripheral on the BCM chip. | | This peripheral allows the Pi to act as a hardware slave device | on an I2C or SPI bus. | | This is not a bit bang version and as such is OS timing | independent. The bus timing is handled directly by the chip. | | The output process is simple. You simply append data to the FIFO | buffer on the chip. This works like a queue, you add data to the | queue and the master removes it. | | 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. | | bsc_control:= see below | data:= the data bytes to place in the transmit FIFO. | | The returned value is a tuple of the status (see below), | the number of bytes read, and a bytearray containing the | read bytes. If there was an error the status will be less | than zero (and will contain the error code). | | Note that the control word sets the BSC mode. The BSC will | stay in that mode until a different control word is sent. | | GPIO used for models other than those based on the BCM2711. | | @ SDA @ SCL @ MOSI @ SCLK @ MISO @ CE | I2C @ 18 @ 19 @ - @ - @ - @ - | SPI @ - @ - @ 18 @ 19 @ 20 @ 21 | | GPIO used for models based on the BCM2711 (e.g. the Pi4B). | | @ SDA @ SCL @ MOSI @ SCLK @ MISO @ CE | I2C @ 10 @ 11 @ - @ - @ - @ - | SPI @ - @ - @ 10 @ 11 @ 9 @ 8 | | When a zero control word is received the used GPIO will be reset | to INPUT mode. | | bsc_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 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 | | ... | (status, count, data) = pi.bsc_xfer(0x330305, "Hello!") | ... | | callback(self, user_gpio, edge=0, func=None) | Calls a user supplied function (a callback) whenever the | specified GPIO edge is detected. | | user_gpio:= 0-31. | edge:= EITHER_EDGE, RISING_EDGE (default), or FALLING_EDGE. | func:= user supplied callback function. | | The user supplied callback receives three parameters, the GPIO, | the level, and the tick. | | . . | Parameter Value Meaning | | GPIO 0-31 The GPIO which has changed state | | level 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 a user callback is not specified a default tally callback is | provided which simply counts edges. The count may be retrieved | by calling the tally function. The count may be reset to zero | by calling the reset_tally function. | | The callback may be cancelled by calling the cancel function. | | A GPIO may have multiple callbacks (although I can't think of | a reason to do so). | | The GPIO are sampled at a rate set when the pigpio daemon | is started (default 5 us). | | The number of samples per second is given in the following table. | | . . | samples | per sec | | 1 1,000,000 | 2 500,000 | sample 4 250,000 | rate 5 200,000 | (us) 8 125,000 | 10 100,000 | . . | | GPIO level changes shorter than the sample rate may be missed. | | The daemon software which generates the callbacks is triggered | 1000 times per second. The callbacks will be called once per | level change since the last time they were called. | i.e. The callbacks will get all level changes but there will | be a latency. | | If you want to track the level of more than one GPIO do so by | maintaining the state in the callback. Do not use [*read*]. | Remember the event that triggered the callback may have | happened several milliseconds before and the GPIO may have | changed level many times since then. | | ... | def cbf(gpio, level, tick): | print(gpio, level, tick) | | cb1 = pi.callback(22, pigpio.EITHER_EDGE, cbf) | | cb2 = pi.callback(4, pigpio.EITHER_EDGE) | | cb3 = pi.callback(17) | | print(cb3.tally()) | | cb3.reset_tally() | | cb1.cancel() # To cancel callback cb1. | ... | | clear_bank_1(self, bits) | Clears GPIO 0-31 if the corresponding bit in bits is set. | | bits:= a 32 bit mask with 1 set if the corresponding GPIO is | to be cleared. | | A returned status of PI_SOME_PERMITTED indicates that the user | is not allowed to write to one or more of the GPIO. | | ... | pi.clear_bank_1(int("111110010000",2)) | ... | | clear_bank_2(self, bits) | Clears GPIO 32-53 if the corresponding bit (0-21) in bits is set. | | bits:= a 32 bit mask with 1 set if the corresponding GPIO is | to be cleared. | | A returned status of PI_SOME_PERMITTED indicates that the user | is not allowed to write to one or more of the GPIO. | | ... | pi.clear_bank_2(0x1010) | ... | | custom_1(self, arg1=0, arg2=0, argx=[]) | Calls a pigpio function customised by the user. | | arg1:= >=0, default 0. | arg2:= >=0, default 0. | argx:= extra arguments (each 0-255), default empty. | | The returned value is an integer which by convention | should be >=0 for OK and <0 for error. | | ... | value = pi.custom_1() | | value = pi.custom_1(23) | | value = pi.custom_1(0, 55) | | value = pi.custom_1(23, 56, [1, 5, 7]) | | value = pi.custom_1(23, 56, b"hello") | | value = pi.custom_1(23, 56, "hello") | ... | | custom_2(self, arg1=0, argx=[], retMax=8192) | Calls a pigpio function customised by the user. | | arg1:= >=0, default 0. | argx:= extra arguments (each 0-255), default empty. | retMax:= >=0, maximum number of bytes to return, default 8192. | | The returned value is a tuple of the number of bytes | returned and a bytearray containing the bytes. If | there was an error the number of bytes read will be | less than zero (and will contain the error code). | | ... | (count, data) = pi.custom_2() | | (count, data) = pi.custom_2(23) | | (count, data) = pi.custom_2(23, [1, 5, 7]) | | (count, data) = pi.custom_2(23, b"hello") | | (count, data) = pi.custom_2(23, "hello", 128) | ... | | delete_script(self, script_id) | Deletes a stored script. | | script_id:= id of stored script. | | ... | status = pi.delete_script(sid) | ... | | event_callback(self, event, func=None) | Calls a user supplied function (a callback) whenever the | specified event is signalled. | | event:= 0-31. | func:= user supplied callback function. | | The user supplied callback receives two parameters, the event id, | and the tick. | | If a user callback is not specified a default tally callback is | provided which simply counts events. The count may be retrieved | by calling the tally function. The count may be reset to zero | by calling the reset_tally function. | | The callback may be cancelled by calling the event_cancel function. | | An event may have multiple callbacks (although I can't think of | a reason to do so). | | ... | def cbf(event, tick): | print(event, tick) | | cb1 = pi.event_callback(22, cbf) | | cb2 = pi.event_callback(4) | | print(cb2.tally()) | | cb2.reset_tally() | | cb1.event_cancel() # To cancel callback cb1. | ... | | event_trigger(self, event) | This function signals the occurrence of an event. | | event:= 0-31, the event | | 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, 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. | | ... | pi.event_trigger(23) | ... | | file_close(self, handle) | Closes the file associated with handle. | | handle:= >=0 (as returned by a prior call to [*file_open*]). | | ... | pi.file_close(handle) | ... | | file_list(self, fpattern) | Returns a list of files which match a pattern. | | fpattern:= file pattern to match. | | Returns the number of returned bytes if OK, otherwise | PI_NO_FILE_ACCESS, or PI_NO_FILE_MATCH. | | The pattern must match an entry in /opt/pigpio/access. The | pattern may contain wildcards. See [*file_open*]. | | NOTE | | The returned value is not the number of files, it is the number | of bytes in the buffer. The file names are separated by newline | characters. | | ... | #!/usr/bin/env python | | import pigpio | | pi = pigpio.pi() | | if not pi.connected: | exit() | | # Assumes /opt/pigpio/access contains the following line: | # /ram/*.c r | | c, d = pi.file_list("/ram/p*.c") | if c > 0: | print(d) | | pi.stop() | ... | | file_open(self, file_name, file_mode) | This function returns a handle to a file opened in a specified mode. | | file_name:= the file to open. | file_mode:= the file open mode. | | Returns a handle (>=0) if OK, otherwise PI_NO_HANDLE, | PI_NO_FILE_ACCESS, PI_BAD_FILE_MODE, | PI_FILE_OPEN_FAILED, or PI_FILE_IS_A_DIR. | | ... | h = pi.file_open("/home/pi/shared/dir_3/file.txt", | pigpio.FILE_WRITE | pigpio.FILE_CREATE) | | pi.file_write(h, "Hello world") | | pi.file_close(h) | ... | | File | | A file may only be opened if permission is granted by an entry | in /opt/pigpio/access. This is intended to allow remote access | to files in a more or less controlled manner. | | Each entry in /opt/pigpio/access takes the form of a file path | which may contain wildcards followed by a single letter permission. | The permission may be R for read, W for write, U for read/write, | and N for no access. | | Where more than one entry matches a file the most specific rule | applies. If no entry matches a file then access is denied. | | Suppose /opt/pigpio/access contains the following entries: | | . . | /home/* n | /home/pi/shared/dir_1/* w | /home/pi/shared/dir_2/* r | /home/pi/shared/dir_3/* u | /home/pi/shared/dir_1/file.txt n | . . | | Files may be written in directory dir_1 with the exception | of file.txt. | | Files may be read in directory dir_2. | | Files may be read and written in directory dir_3. | | If a directory allows read, write, or read/write access then files | may be created in that directory. | | In an attempt to prevent risky permissions the following paths are | ignored in /opt/pigpio/access: | | . . | a path containing .. | a path containing only wildcards (*?) | a path containing less than two non-wildcard parts | . . | | Mode | | The mode may have the following values: | | Constant @ Value @ Meaning | FILE_READ @ 1 @ open file for reading | FILE_WRITE @ 2 @ open file for writing | FILE_RW @ 3 @ open file for reading and writing | | The following values may be or'd into the mode: | | Name @ Value @ Meaning | FILE_APPEND @ 4 @ All writes append data to the end of the file | FILE_CREATE @ 8 @ The file is created if it doesn't exist | FILE_TRUNC @ 16 @ The file is truncated | | Newly created files are owned by root with permissions owner | read and write. | | ... | #!/usr/bin/env python | | import pigpio | | pi = pigpio.pi() | | if not pi.connected: | exit() | | # Assumes /opt/pigpio/access contains the following line: | # /ram/*.c r | | handle = pi.file_open("/ram/pigpio.c", pigpio.FILE_READ) | | done = False | | while not done: | c, d = pi.file_read(handle, 60000) | if c > 0: | print(d) | else: | done = True | | pi.file_close(handle) | | pi.stop() | ... | | file_read(self, handle, count) | Reads up to count bytes from the file associated with handle. | | handle:= >=0 (as returned by a prior call to [*file_open*]). | count:= >0, the number of bytes to read. | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (b, d) = pi.file_read(h2, 100) | if b > 0: | # process read data | ... | | file_seek(self, handle, seek_offset, seek_from) | Seeks to a position relative to the start, current position, | or end of the file. Returns the new position. | | handle:= >=0 (as returned by a prior call to [*file_open*]). | seek_offset:= byte offset. | seek_from:= FROM_START, FROM_CURRENT, or FROM_END. | | ... | new_pos = pi.file_seek(h, 100, pigpio.FROM_START) | | cur_pos = pi.file_seek(h, 0, pigpio.FROM_CURRENT) | | file_size = pi.file_seek(h, 0, pigpio.FROM_END) | ... | | file_write(self, handle, data) | Writes the data bytes to the file associated with handle. | | handle:= >=0 (as returned by a prior call to [*file_open*]). | data:= the bytes to write. | | ... | pi.file_write(h1, b'\x02\x03\x04') | | pi.file_write(h2, b'help') | | pi.file_write(h2, "hello") | | pi.file_write(h1, [2, 3, 4]) | ... | | get_PWM_dutycycle(self, user_gpio) | Returns the PWM dutycycle being used on the GPIO. | | user_gpio:= 0-31. | | Returns the PWM dutycycle. | | | 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). | | ... | pi.set_PWM_dutycycle(4, 25) | print(pi.get_PWM_dutycycle(4)) | 25 | | pi.set_PWM_dutycycle(4, 203) | print(pi.get_PWM_dutycycle(4)) | 203 | ... | | get_PWM_frequency(self, user_gpio) | Returns the frequency of PWM being used on the GPIO. | | user_gpio:= 0-31. | | Returns the frequency (in Hz) used for the GPIO. | | 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*]. | | ... | pi.set_PWM_frequency(4,0) | print(pi.get_PWM_frequency(4)) | 10 | | pi.set_PWM_frequency(4, 800) | print(pi.get_PWM_frequency(4)) | 800 | ... | | get_PWM_range(self, user_gpio) | Returns the range of PWM values being used on the GPIO. | | user_gpio:= 0-31. | | If a hardware clock or hardware PWM is active on the GPIO | the reported range will be 1000000 (1M). | | ... | pi.set_PWM_range(9, 500) | print(pi.get_PWM_range(9)) | 500 | ... | | get_PWM_real_range(self, user_gpio) | Returns the real (underlying) range of PWM values being | used on the GPIO. | | user_gpio:= 0-31. | | 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. | | ... | pi.set_PWM_frequency(4, 800) | print(pi.get_PWM_real_range(4)) | 250 | ... | | get_current_tick(self) | Returns the current system tick. | | Tick is the number of microseconds since system boot. As an | unsigned 32 bit quantity tick wraps around approximately | every 71.6 minutes. | | ... | t1 = pi.get_current_tick() | time.sleep(1) | t2 = pi.get_current_tick() | ... | | get_hardware_revision(self) | Returns the Pi's hardware revision number. | | The hardware revision is the last few characters on the | Revision line of /proc/cpuinfo. | | 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. | | If the hardware revision can not be found or is not a valid | hexadecimal number the function returns 0. | | ... | print(pi.get_hardware_revision()) | 2 | ... | | get_mode(self, gpio) | Returns the GPIO mode. | | gpio:= 0-53. | | Returns a value as follows | | . . | 0 = INPUT | 1 = OUTPUT | 2 = ALT5 | 3 = ALT4 | 4 = ALT0 | 5 = ALT1 | 6 = ALT2 | 7 = ALT3 | . . | | ... | print(pi.get_mode(0)) | 4 | ... | | get_pad_strength(self, pad) | This function returns the pad drive strength in mA. | | 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 = pi.get_pad_strength(0) # Get pad 0 strength. | ... | | get_pigpio_version(self) | Returns the pigpio software version. | | ... | v = pi.get_pigpio_version() | ... | | get_servo_pulsewidth(self, user_gpio) | Returns the servo pulsewidth being used on the GPIO. | | user_gpio:= 0-31. | | Returns the servo pulsewidth. | | ... | pi.set_servo_pulsewidth(4, 525) | print(pi.get_servo_pulsewidth(4)) | 525 | | pi.set_servo_pulsewidth(4, 2130) | print(pi.get_servo_pulsewidth(4)) | 2130 | ... | | gpio_trigger(self, user_gpio, pulse_len=10, level=1) | Send a trigger pulse to a GPIO. The GPIO is set to | level for pulse_len microseconds and then reset to not level. | | user_gpio:= 0-31 | pulse_len:= 1-100 | level:= 0-1 | | ... | pi.gpio_trigger(23, 10, 1) | ... | | hardware_PWM(self, gpio, PWMfreq, PWMduty) | 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_once*], | [*wave_send_repeat*], 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). | | gpio:= see descripton | PWMfreq:= 0 (off) or 1-125M (1-187.5M for the BCM2711). | 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. | | 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 250M/PWMfreq (375M/PWMfreq for the BCM2711). | | The actual frequency set is 250M/steps (375M/steps | for the BCM2711). | | There will only be a million steps for a PWMfreq of 250 | (375 for the BCM2711). Lower frequencies will have more | steps and higher frequencies will have fewer steps. | PWMduty is automatically scaled to take this into account. | | ... | pi.hardware_PWM(18, 800, 250000) # 800Hz 25% dutycycle | | pi.hardware_PWM(18, 2000, 750000) # 2000Hz 75% dutycycle | ... | | hardware_clock(self, gpio, clkfreq) | Starts a hardware clock on a GPIO at the specified frequency. | Frequencies above 30MHz are unlikely to work. | | gpio:= see description | clkfreq:= 0 (off) or 4689-250M (13184-375M for the BCM2711) | | | 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. | | ... | pi.hardware_clock(4, 5000) # 5 KHz clock on GPIO 4 | | pi.hardware_clock(4, 40000000) # 40 MHz clock on GPIO 4 | ... | | i2c_block_process_call(self, handle, reg, data) | 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. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | data:= the bytes to write. | | 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. | | SMBus 2.0 5.5.8 - Block write-block read. | . . | S Addr Wr [A] reg [A] len(data) [A] data0 [A] ... datan [A] | S Addr Rd [A] [Count] A [Data] ... A P | . . | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (b, d) = pi.i2c_block_process_call(h, 10, b'\x02\x05\x00') | | (b, d) = pi.i2c_block_process_call(h, 10, b'abcdr') | | (b, d) = pi.i2c_block_process_call(h, 10, "abracad") | | (b, d) = pi.i2c_block_process_call(h, 10, [2, 5, 16]) | ... | | i2c_close(self, handle) | Closes the I2C device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | | ... | pi.i2c_close(h) | ... | | i2c_open(self, i2c_bus, i2c_address, i2c_flags=0) | Returns a handle (>=0) for the device at the I2C bus address. | | i2c_bus:= >=0. | i2c_address:= 0-0x7F. | i2c_flags:= 0, no flags are currently defined. | | 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. | | The GPIO used are given in the following table. | | @ SDA @ SCL | I2C 0 @ 0 @ 1 | I2C 1 @ 2 @ 3 | | 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. | reg (8 bits): Command 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. | . . | | ... | h = pi.i2c_open(1, 0x53) # open device at address 0x53 on bus 1 | ... | | i2c_process_call(self, handle, reg, word_val) | Writes 16 bits of data to the specified register of the device | associated with handle and reads 16 bits of data in return. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | word_val:= 0-65535, the value to write. | | SMBus 2.0 5.5.6 - Process call. | . . | S Addr Wr [A] reg [A] word_val_Low [A] word_val_High [A] | S Addr Rd [A] [DataLow] A [DataHigh] NA P | . . | | ... | r = pi.i2c_process_call(h, 4, 0x1231) | r = pi.i2c_process_call(h, 6, 0) | ... | | i2c_read_block_data(self, handle, reg) | Reads a block of up to 32 bytes from the specified register of | the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | | SMBus 2.0 5.5.7 - Block read. | . . | S Addr Wr [A] reg [A] | S Addr Rd [A] [Count] A [Data] A [Data] A ... A [Data] NA P | . . | | The amount of returned data is set by the device. | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (b, d) = pi.i2c_read_block_data(h, 10) | if b >= 0: | # process data | else: | # process read failure | ... | | i2c_read_byte(self, handle) | Reads a single byte from the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | | SMBus 2.0 5.5.3 - Receive byte. | . . | S Addr Rd [A] [Data] NA P | . . | | ... | b = pi.i2c_read_byte(2) # read a byte from device 2 | ... | | i2c_read_byte_data(self, handle, reg) | Reads a single byte from the specified register of the device | associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | | SMBus 2.0 5.5.5 - Read byte. | . . | S Addr Wr [A] reg [A] S Addr Rd [A] [Data] NA P | . . | | ... | # read byte from reg 17 of device 2 | b = pi.i2c_read_byte_data(2, 17) | | # read byte from reg 1 of device 0 | b = pi.i2c_read_byte_data(0, 1) | ... | | i2c_read_device(self, handle, count) | Returns count bytes read from the raw device associated | with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | count:= >0, the number of bytes to read. | | . . | S Addr Rd [A] [Data] A [Data] A ... A [Data] NA P | . . | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (count, data) = pi.i2c_read_device(h, 12) | ... | | i2c_read_i2c_block_data(self, handle, reg, count) | Reads count bytes from the specified register of the device | associated with handle . The count may be 1-32. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | count:= >0, the number of bytes to read. | | . . | S Addr Wr [A] reg [A] | S Addr Rd [A] [Data] A [Data] A ... A [Data] NA P | . . | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (b, d) = pi.i2c_read_i2c_block_data(h, 4, 32) | if b >= 0: | # process data | else: | # process read failure | ... | | i2c_read_word_data(self, handle, reg) | Reads a single 16 bit word from the specified register of the | device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | | SMBus 2.0 5.5.5 - Read word. | . . | S Addr Wr [A] reg [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P | . . | | ... | # read word from reg 2 of device 3 | w = pi.i2c_read_word_data(3, 2) | | # read word from reg 7 of device 2 | w = pi.i2c_read_word_data(2, 7) | ... | | i2c_write_block_data(self, handle, reg, data) | Writes up to 32 bytes to the specified register of the device | associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | data:= the bytes to write. | | SMBus 2.0 5.5.7 - Block write. | . . | S Addr Wr [A] reg [A] len(data) [A] data0 [A] data1 [A] ... [A] | datan [A] P | . . | | ... | pi.i2c_write_block_data(4, 5, b'hello') | | pi.i2c_write_block_data(4, 5, "data bytes") | | pi.i2c_write_block_data(5, 0, b'\x00\x01\x22') | | pi.i2c_write_block_data(6, 2, [0, 1, 0x22]) | ... | | i2c_write_byte(self, handle, byte_val) | Sends a single byte to the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | byte_val:= 0-255, the value to write. | | SMBus 2.0 5.5.2 - Send byte. | . . | S Addr Wr [A] byte_val [A] P | . . | | ... | pi.i2c_write_byte(1, 17) # send byte 17 to device 1 | pi.i2c_write_byte(2, 0x23) # send byte 0x23 to device 2 | ... | | i2c_write_byte_data(self, handle, reg, byte_val) | Writes a single byte to the specified register of the device | associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | byte_val:= 0-255, the value to write. | | SMBus 2.0 5.5.4 - Write byte. | . . | S Addr Wr [A] reg [A] byte_val [A] P | . . | | ... | # send byte 0xC5 to reg 2 of device 1 | pi.i2c_write_byte_data(1, 2, 0xC5) | | # send byte 9 to reg 4 of device 2 | pi.i2c_write_byte_data(2, 4, 9) | ... | | i2c_write_device(self, handle, data) | Writes the data bytes to the raw device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | data:= the bytes to write. | | . . | S Addr Wr [A] data0 [A] data1 [A] ... [A] datan [A] P | . . | | ... | pi.i2c_write_device(h, b"\x12\x34\xA8") | | pi.i2c_write_device(h, b"help") | | pi.i2c_write_device(h, 'help') | | pi.i2c_write_device(h, [23, 56, 231]) | ... | | i2c_write_i2c_block_data(self, handle, reg, data) | Writes data bytes to the specified register of the device | associated with handle . 1-32 bytes may be written. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | data:= the bytes to write. | | . . | S Addr Wr [A] reg [A] data0 [A] data1 [A] ... [A] datan [NA] P | . . | | ... | pi.i2c_write_i2c_block_data(4, 5, 'hello') | | pi.i2c_write_i2c_block_data(4, 5, b'hello') | | pi.i2c_write_i2c_block_data(5, 0, b'\x00\x01\x22') | | pi.i2c_write_i2c_block_data(6, 2, [0, 1, 0x22]) | ... | | i2c_write_quick(self, handle, bit) | Sends a single bit to the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | bit:= 0 or 1, the value to write. | | SMBus 2.0 5.5.1 - Quick command. | . . | S Addr bit [A] P | . . | | ... | pi.i2c_write_quick(0, 1) # send 1 to device 0 | pi.i2c_write_quick(3, 0) # send 0 to device 3 | ... | | i2c_write_word_data(self, handle, reg, word_val) | Writes a single 16 bit word to the specified register of the | device associated with handle. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | reg:= >=0, the device register. | word_val:= 0-65535, the value to write. | | SMBus 2.0 5.5.4 - Write word. | . . | S Addr Wr [A] reg [A] word_val_Low [A] word_val_High [A] P | . . | | ... | # send word 0xA0C5 to reg 5 of device 4 | pi.i2c_write_word_data(4, 5, 0xA0C5) | | # send word 2 to reg 2 of device 5 | pi.i2c_write_word_data(5, 2, 23) | ... | | i2c_zip(self, handle, data) | This function executes a sequence of I2C operations. The | operations to be performed are specified by the contents of data | which contains the concatenated command codes and associated data. | | handle:= >=0 (as returned by a prior call to [*i2c_open*]). | data:= the concatenated I2C commands, see below | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (count, data) = pi.i2c_zip(h, [4, 0x53, 7, 1, 0x32, 6, 6, 0]) | ... | | 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. | | Any read I2C data is concatenated in the returned bytearray. | | ... | 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 | ... | | notify_begin(self, handle, bits) | Starts notifications on a handle. | | handle:= >=0 (as returned by a prior call to [*notify_open*]) | bits:= a 32 bit mask indicating the GPIO to be notified. | | The notification sends state changes for each GPIO whose | corresponding bit in bits is set. | | The following code starts notifications for GPIO 1, 4, | 6, 7, and 10 (1234 = 0x04D2 = 0b0000010011010010). | | ... | h = pi.notify_open() | if h >= 0: | pi.notify_begin(h, 1234) | ... | | notify_close(self, handle) | Stops notifications on a handle and releases the handle for reuse. | | handle:= >=0 (as returned by a prior call to [*notify_open*]) | | ... | h = pi.notify_open() | if h >= 0: | pi.notify_begin(h, 1234) | ... | pi.notify_close(h) | ... | ... | | notify_open(self) | 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. 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. | | Notifications have the following structure: | | . . | H seqno | H flags | I tick | I level | . . | | 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<= 0: | pi.notify_begin(h, 1234) | ... | | notify_pause(self, handle) | Pauses notifications on a handle. | | handle:= >=0 (as returned by a prior call to [*notify_open*]) | | Notifications for the handle are suspended until | [*notify_begin*] is called again. | | ... | h = pi.notify_open() | if h >= 0: | pi.notify_begin(h, 1234) | ... | pi.notify_pause(h) | ... | pi.notify_begin(h, 1234) | ... | ... | | read(self, gpio) | Returns the GPIO level. | | gpio:= 0-53. | | ... | pi.set_mode(23, pigpio.INPUT) | | pi.set_pull_up_down(23, pigpio.PUD_DOWN) | print(pi.read(23)) | 0 | | pi.set_pull_up_down(23, pigpio.PUD_UP) | print(pi.read(23)) | 1 | ... | | read_bank_1(self) | Returns the levels of the bank 1 GPIO (GPIO 0-31). | | The returned 32 bit integer has a bit set if the corresponding | GPIO is high. GPIO n has bit value (1<=0 (as returned by a prior call to [*serial_open*]). | | ... | pi.serial_close(h1) | ... | | serial_data_available(self, handle) | Returns the number of bytes available to be read from the | device associated with handle. | | handle:= >=0 (as returned by a prior call to [*serial_open*]). | | ... | rdy = pi.serial_data_available(h1) | | if rdy > 0: | (b, d) = pi.serial_read(h1, rdy) | ... | | serial_open(self, tty, baud, ser_flags=0) | Returns a handle for the serial tty device opened | at baud bits per second. The device name must start | with /dev/tty or /dev/serial. | | tty:= the serial device to open. | baud:= baud rate in bits per second, see below. | ser_flags:= 0, no flags are currently defined. | | Normally you would only use the [*serial_**] functions if | you are or will be connecting to the Pi over a network. If | you will always run on the local Pi use the standard serial | module instead. | | 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. | | ... | h1 = pi.serial_open("/dev/ttyAMA0", 300) | | h2 = pi.serial_open("/dev/ttyUSB1", 19200, 0) | | h3 = pi.serial_open("/dev/serial0", 9600) | ... | | serial_read(self, handle, count=1000) | Reads up to count bytes from the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*serial_open*]). | count:= >0, the number of bytes to read (defaults to 1000). | | The returned value is a tuple of the number of bytes read and | a bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | If no data is ready a bytes read of zero is returned. | ... | (b, d) = pi.serial_read(h2, 100) | if b > 0: | # process read data | ... | | serial_read_byte(self, handle) | Returns a single byte from the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*serial_open*]). | | If no data is ready a negative error code will be returned. | | ... | b = pi.serial_read_byte(h1) | ... | | serial_write(self, handle, data) | Writes the data bytes to the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*serial_open*]). | data:= the bytes to write. | | ... | pi.serial_write(h1, b'\x02\x03\x04') | | pi.serial_write(h2, b'help') | | pi.serial_write(h2, "hello") | | pi.serial_write(h1, [2, 3, 4]) | ... | | serial_write_byte(self, handle, byte_val) | Writes a single byte to the device associated with handle. | | handle:= >=0 (as returned by a prior call to [*serial_open*]). | byte_val:= 0-255, the value to write. | | ... | pi.serial_write_byte(h1, 23) | | pi.serial_write_byte(h1, ord('Z')) | ... | | set_PWM_dutycycle(self, user_gpio, dutycycle) | Starts (non-zero dutycycle) or stops (0) PWM pulses on the GPIO. | | user_gpio:= 0-31. | dutycycle:= 0-range (range defaults to 255). | | The [*set_PWM_range*] function can change the default range of 255. | | ... | pi.set_PWM_dutycycle(4, 0) # PWM off | pi.set_PWM_dutycycle(4, 64) # PWM 1/4 on | pi.set_PWM_dutycycle(4, 128) # PWM 1/2 on | pi.set_PWM_dutycycle(4, 192) # PWM 3/4 on | pi.set_PWM_dutycycle(4, 255) # PWM full on | ... | | set_PWM_frequency(self, user_gpio, frequency) | Sets the frequency (in Hz) of the PWM to be used on the GPIO. | | 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 | . . | | ... | pi.set_PWM_frequency(4,0) | print(pi.get_PWM_frequency(4)) | 10 | | pi.set_PWM_frequency(4,100000) | print(pi.get_PWM_frequency(4)) | 8000 | ... | | set_PWM_range(self, user_gpio, range_) | Sets the range of PWM values to be used on the GPIO. | | user_gpio:= 0-31. | range_:= 25-40000. | | ... | pi.set_PWM_range(9, 100) # now 25 1/4, 50 1/2, 75 3/4 on | pi.set_PWM_range(9, 500) # now 125 1/4, 250 1/2, 375 3/4 on | pi.set_PWM_range(9, 3000) # now 750 1/4, 1500 1/2, 2250 3/4 on | ... | | set_bank_1(self, bits) | Sets GPIO 0-31 if the corresponding bit in bits is set. | | bits:= a 32 bit mask with 1 set if the corresponding GPIO is | to be set. | | A returned status of PI_SOME_PERMITTED indicates that the user | is not allowed to write to one or more of the GPIO. | | ... | pi.set_bank_1(int("111110010000",2)) | ... | | set_bank_2(self, bits) | Sets GPIO 32-53 if the corresponding bit (0-21) in bits is set. | | bits:= a 32 bit mask with 1 set if the corresponding GPIO is | to be set. | | A returned status of PI_SOME_PERMITTED indicates that the user | is not allowed to write to one or more of the GPIO. | | ... | pi.set_bank_2(0x303) | ... | | set_glitch_filter(self, user_gpio, steady) | 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. | | 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*] and [*wait_for_edge*]. | | It does not affect levels read by [*read*], | [*read_bank_1*], or [*read_bank_2*]. | | Each (stable) edge will be timestamped [*steady*] | microseconds after it was first detected. | | ... | pi.set_glitch_filter(23, 100) | ... | | set_mode(self, gpio, mode) | Sets the GPIO mode. | | gpio:= 0-53. | mode:= INPUT, OUTPUT, ALT0, ALT1, ALT2, ALT3, ALT4, ALT5. | | ... | pi.set_mode( 4, pigpio.INPUT) # GPIO 4 as input | pi.set_mode(17, pigpio.OUTPUT) # GPIO 17 as output | pi.set_mode(24, pigpio.ALT2) # GPIO 24 as ALT2 | ... | | set_noise_filter(self, user_gpio, steady, active) | 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. | | 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*] and [*wait_for_edge*]. | | It does not affect levels read by [*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. | | ... | pi.set_noise_filter(23, 1000, 5000) | ... | | set_pad_strength(self, pad, pad_strength) | This function sets the pad drive strength in mA. | | | pad:= 0-2, the pad to set. | pad_strength:= 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 | | ... | pi.set_pad_strength(2, 14) # Set pad 2 to 14 mA. | ... | | set_pull_up_down(self, gpio, pud) | Sets or clears the internal GPIO pull-up/down resistor. | | gpio:= 0-53. | pud:= PUD_UP, PUD_DOWN, PUD_OFF. | | ... | pi.set_pull_up_down(17, pigpio.PUD_OFF) | pi.set_pull_up_down(23, pigpio.PUD_UP) | pi.set_pull_up_down(24, pigpio.PUD_DOWN) | ... | | set_servo_pulsewidth(self, user_gpio, pulsewidth) | Starts (500-2500) or stops (0) servo pulses on the GPIO. | | user_gpio:= 0-31. | pulsewidth:= 0 (off), | 500 (most anti-clockwise) - 2500 (most clockwise). | | 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. | | ... | pi.set_servo_pulsewidth(17, 0) # off | pi.set_servo_pulsewidth(17, 1000) # safe anti-clockwise | pi.set_servo_pulsewidth(17, 1500) # centre | pi.set_servo_pulsewidth(17, 2000) # safe clockwise | ... | | set_watchdog(self, user_gpio, wdog_timeout) | Sets a watchdog timeout for a GPIO. | | user_gpio:= 0-31. | wdog_timeout:= 0-60000. | | 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 TIMEOUT. | | ... | pi.set_watchdog(23, 1000) # 1000 ms watchdog on GPIO 23 | pi.set_watchdog(23, 0) # cancel watchdog on GPIO 23 | ... | | shell(self, shellscr, pstring='') | This function uses the system call to execute a shell script | with the given string as its parameter. | | shellscr:= the name of the script, only alphanumerics, | '-' and '_' are allowed in the name | pstring := the parameter string to pass to the script | | The exit status of the system call is returned if OK, | otherwise PI_BAD_SHELL_STATUS. | | [*shellscr*] must exist in /opt/pigpio/cgi and must be executable. | | The returned exit status is normally 256 times that set by | the shell script exit function. If the script can't be | found 32512 will be returned. | | The following table gives some example returned statuses: | | Script exit status @ Returned system call status | 1 @ 256 | 5 @ 1280 | 10 @ 2560 | 200 @ 51200 | script not found @ 32512 | | ... | // pass two parameters, hello and world | status = pi.shell("scr1", "hello world"); | | // pass three parameters, hello, string with spaces, and world | status = pi.shell("scr1", "hello 'string with spaces' world"); | | // pass one parameter, hello string with spaces world | status = pi.shell("scr1", "\"hello string with spaces world\""); | ... | | spi_close(self, handle) | Closes the SPI device associated with handle. | | handle:= >=0 (as returned by a prior call to [*spi_open*]). | | ... | pi.spi_close(h) | ... | | spi_open(self, spi_channel, baud, spi_flags=0) | Returns a handle for the SPI device on the 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. | | The Pi has two SPI peripherals: main and auxiliary. | | The main SPI has two chip selects (channels), the auxiliary | has three. | | The auxiliary SPI is available on all models but the A and B. | | The GPIO used are given in the following table. | | @ MISO @ MOSI @ SCLK @ CE0 @ CE1 @ CE2 | Main SPI @ 9 @ 10 @ 11 @ 8 @ 7 @ - | Aux SPI @ 19 @ 20 @ 21 @ 18 @ 17 @ 16 | | spi_channel:= 0-1 (0-2 for the auxiliary SPI). | baud:= 32K-125M (values above 30M are unlikely to work). | 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 | 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 SPI. | | . . | 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 main SPI, 1 for the auxiliary SPI. | | W is 0 if the device is not 3-wire, 1 if the device is 3-wire. | Main SPI 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. Main SPI 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 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 only. | | bbbbbb defines the word size in bits (0-32). The default (0) | sets 8 bits per word. Auxiliary SPI 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 data should | contain 64 bytes. | | 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. | | ... | # open SPI device on channel 1 in mode 3 at 50000 bits per second | | h = pi.spi_open(1, 50000, 3) | ... | | spi_read(self, handle, count) | Reads count bytes from the SPI device associated with handle. | | handle:= >=0 (as returned by a prior call to [*spi_open*]). | count:= >0, the number of bytes to read. | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (b, d) = pi.spi_read(h, 60) # read 60 bytes from device h | if b == 60: | # process read data | else: | # error path | ... | | spi_write(self, handle, data) | Writes the data bytes to the SPI device associated with handle. | | handle:= >=0 (as returned by a prior call to [*spi_open*]). | data:= the bytes to write. | | ... | pi.spi_write(0, b'\x02\xc0\x80') # write 3 bytes to device 0 | | pi.spi_write(0, b'defgh') # write 5 bytes to device 0 | | pi.spi_write(0, "def") # write 3 bytes to device 0 | | pi.spi_write(1, [2, 192, 128]) # write 3 bytes to device 1 | ... | | spi_xfer(self, handle, data) | Writes the data bytes to the SPI device associated with handle, | returning the data bytes read from the device. | | handle:= >=0 (as returned by a prior call to [*spi_open*]). | data:= the bytes to write. | | The returned value is a tuple of the number of bytes read and a | bytearray containing the bytes. If there was an error the | number of bytes read will be less than zero (and will contain | the error code). | | ... | (count, rx_data) = pi.spi_xfer(h, b'\x01\x80\x00') | | (count, rx_data) = pi.spi_xfer(h, [1, 128, 0]) | | (count, rx_data) = pi.spi_xfer(h, b"hello") | | (count, rx_data) = pi.spi_xfer(h, "hello") | ... | | stop(self) | Release pigpio resources. | | ... | pi.stop() | ... | | stop_script(self, script_id) | Stops a running script. | | script_id:= id of stored script. | | ... | status = pi.stop_script(sid) | ... | | store_script(self, script) | Store a script for later execution. | | See [[http://abyz.me.uk/rpi/pigpio/pigs.html#Scripts]] for | details. | | script:= the script text as a series of bytes. | | Returns a >=0 script id if OK. | | ... | sid = pi.store_script( | b'tag 0 w 22 1 mils 100 w 22 0 mils 100 dcr p0 jp 0') | ... | | update_script(self, script_id, params=None) | Sets the parameters of a script. The script may or | may not be running. The first parameters of the script are | overwritten with the new values. | | script_id:= id of stored script. | params:= up to 10 parameters required by the script. | | ... | s = pi.update_script(sid, [par1, par2]) | | s = pi.update_script(sid, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) | ... | | wait_for_edge(self, user_gpio, edge=0, wait_timeout=60.0) | Wait for an edge event on a GPIO. | | user_gpio:= 0-31. | edge:= EITHER_EDGE, RISING_EDGE (default), or | FALLING_EDGE. | wait_timeout:= >=0.0 (default 60.0). | | The function returns when the edge is detected or after | the number of seconds specified by timeout has expired. | | 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 True if the edge is detected, | otherwise False. | | ... | if pi.wait_for_edge(23): | print("Rising edge detected") | else: | print("wait for edge timed out") | | if pi.wait_for_edge(23, pigpio.FALLING_EDGE, 5.0): | print("Falling edge detected") | else: | print("wait for falling edge timed out") | ... | | wait_for_event(self, event, wait_timeout=60.0) | Wait for an event. | | event:= 0-31. | wait_timeout:= >=0.0 (default 60.0). | | The function returns when the event is signalled or after | the number of seconds specified by timeout has expired. | | The function returns True if the event is detected, | otherwise False. | | ... | if pi.wait_for_event(23): | print("event detected") | else: | print("wait for event timed out") | ... | | wave_add_generic(self, pulses) | Adds a list of pulses to the current waveform. | | pulses:= list of pulses to add to the 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. | | ... | G1=4 | G2=24 | | pi.set_mode(G1, pigpio.OUTPUT) | pi.set_mode(G2, pigpio.OUTPUT) | | flash_500=[] # flash every 500 ms | flash_100=[] # flash every 100 ms | | # ON OFF DELAY | | flash_500.append(pigpio.pulse(1<=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. | 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. | | A pulse specifies | | 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. | | ... | wid = pi.wave_create() | ... | | wave_create_and_pad(self, percent) | This function creates a waveform like [*wave_create*] but pads the consumed | resources. Where percent gives the percentage of the resources to use | (in terms of the theoretical maximum, not the current amount free). | This allows the reuse of deleted waves while a transmission is active. | | 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. | | . . | percent: 0-100, size of waveform as percentage of maximum available. | . . | | The data provided by the [*wave_add_**] functions are 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. | | A usage would be the creation of two waves where one is filled while the | other is being transmitted. Each wave is assigned 50% of the resources. | This buffer structure allows the transmission of infinite wave sequences. | | Normal usage: | | 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_and_pad*] to create a waveform of uniform size. | | Step 4. [*wave_send_**] with the id of the waveform to transmit. | | Repeat steps 2-4 as needed. | | Step 5. Any wave id can now be deleted and another wave of the same size | can be created in its place. | | ... | wid = pi.wave_create_and_pad(50) | ... | | wave_delete(self, wave_id) | This function deletes the waveform with id wave_id. | | wave_id:= >=0 (as returned by a prior call to [*wave_create*]). | | Wave ids are allocated in order, 0, 1, 2, etc. | | The wave is flagged for deletion. The resources used by the wave | will only be reused when either of the following apply. | | - all waves with higher numbered wave ids have been deleted or have | been flagged for deletion. | | - a new wave is created which uses exactly the same resources as | the current wave (see the C source for gpioWaveCreate for details). | | ... | pi.wave_delete(6) # delete waveform with id 6 | | pi.wave_delete(0) # delete waveform with id 0 | ... | | wave_get_cbs(self) | Returns the length in DMA control blocks of the current | waveform. | | ... | cbs = pi.wave_get_cbs() | ... | | wave_get_max_cbs(self) | Returns the maximum possible size of a waveform in DMA | control blocks. | | ... | cbs = pi.wave_get_max_cbs() | ... | | wave_get_max_micros(self) | Returns the maximum possible size of a waveform in microseconds. | | ... | micros = pi.wave_get_max_micros() | ... | | wave_get_max_pulses(self) | Returns the maximum possible size of a waveform in pulses. | | ... | pulses = pi.wave_get_max_pulses() | ... | | wave_get_micros(self) | Returns the length in microseconds of the current waveform. | | ... | micros = pi.wave_get_micros() | ... | | wave_get_pulses(self) | Returns the length in pulses of the current waveform. | | ... | pulses = pi.wave_get_pulses() | ... | | wave_send_once(self, wave_id) | Transmits the waveform with id wave_id. The waveform is sent | once. | | NOTE: Any hardware PWM started by [*hardware_PWM*] will | be cancelled. | | wave_id:= >=0 (as returned by a prior call to [*wave_create*]). | | Returns the number of DMA control blocks used in the waveform. | | ... | cbs = pi.wave_send_once(wid) | ... | | wave_send_repeat(self, wave_id) | Transmits the waveform with id wave_id. The waveform repeats | until wave_tx_stop is called or another call to [*wave_send_**] | is made. | | NOTE: Any hardware PWM started by [*hardware_PWM*] will | be cancelled. | | wave_id:= >=0 (as returned by a prior call to [*wave_create*]). | | Returns the number of DMA control blocks used in the waveform. | | ... | cbs = pi.wave_send_repeat(wid) | ... | | wave_send_using_mode(self, wave_id, mode) | Transmits the waveform with id wave_id using mode mode. | | wave_id:= >=0 (as returned by a prior call to [*wave_create*]). | mode:= WAVE_MODE_ONE_SHOT, WAVE_MODE_REPEAT, | WAVE_MODE_ONE_SHOT_SYNC, or WAVE_MODE_REPEAT_SYNC. | | WAVE_MODE_ONE_SHOT: same as [*wave_send_once*]. | | WAVE_MODE_REPEAT same as [*wave_send_repeat*]. | | WAVE_MODE_ONE_SHOT_SYNC same as [*wave_send_once*] but tries | to sync with the previous waveform. | | 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. | | wave_id:= >=0 (as returned by a prior call to [*wave_create*]). | | Returns the number of DMA control blocks used in the waveform. | | ... | cbs = pi.wave_send_using_mode(wid, WAVE_MODE_REPEAT_SYNC) | ... | | wave_tx_at(self) | Returns the id of the waveform currently being | transmitted. | | Returns the waveform id or one of the following special | values: | | WAVE_NOT_FOUND (9998) - transmitted wave not found. | NO_TX_WAVE (9999) - no wave being transmitted. | | ... | wid = pi.wave_tx_at() | ... | | wave_tx_busy(self) | Returns 1 if a waveform is currently being transmitted, | otherwise 0. | | ... | pi.wave_send_once(0) # send first waveform | | while pi.wave_tx_busy(): # wait for waveform to be sent | time.sleep(0.1) | | pi.wave_send_once(1) # send next waveform | ... | | wave_tx_repeat(self) | This function is deprecated and has beeen removed. | | Use [*wave_create*]/[*wave_send_**] instead. | | wave_tx_start(self) | This function is deprecated and has been removed. | | Use [*wave_create*]/[*wave_send_**] instead. | | wave_tx_stop(self) | Stops the transmission of the current waveform. | | This function is intended to stop a waveform started with | wave_send_repeat. | | ... | pi.wave_send_repeat(3) | | time.sleep(5) | | pi.wave_tx_stop() | ... | | write(self, gpio, level) | Sets the GPIO level. | | GPIO:= 0-53. | level:= 0, 1. | | If PWM or servo pulses are active on the GPIO they are | switched off. | | ... | pi.set_mode(17, pigpio.OUTPUT) | | pi.write(17,0) | print(pi.read(17)) | 0 | | pi.write(17,1) | print(pi.read(17)) | 1 | ... class pulse | A class to store pulse information. | | Methods defined here: | | __init__(self, gpio_on, gpio_off, delay) | Initialises a pulse. | | gpio_on:= the GPIO to switch on at the start of the pulse. | gpio_off:= the GPIO to switch off at the start of the pulse. | delay:= the delay in microseconds before the next pulse. FUNCTIONS error_text(errnum) Returns a text description of a pigpio error. errnum:= <0, the error number ... print(pigpio.error_text(-5)) level not 0-1 ... tickDiff(t1, t2) Returns the microsecond difference between two ticks. t1:= the earlier tick t2:= the later tick ... print(pigpio.tickDiff(4294967272, 12)) 36 ... u2i(uint32) Converts a 32 bit unsigned number to signed. uint32:= an unsigned 32 bit number ... print(u2i(4294967272)) -24 print(u2i(37)) 37 ... xref() active: 0-1000000 The number of microseconds level changes are reported for once a noise filter has been triggered (by [*steady*] microseconds of a stable level). arg1: An unsigned argument passed to a user customised function. Its meaning is defined by the customiser. arg2: An unsigned argument passed to a user customised function. Its meaning is defined by the customiser. argx: An array of bytes passed to a user customised function. Its meaning and content is defined by the customiser. baud: The speed of serial communication (I2C, SPI, serial link, waves) in bits per second. bb_bits: 1-32 The number of data bits to be used when adding serial data to a waveform. bb_stop: 2-8 The number of (half) stop bits to be used when adding serial data to a waveform. bit: 0-1 A value of 0 or 1. bits: 32 bit number A mask used to select GPIO to be operated on. If bit n is set then GPIO n is selected. A convenient way of setting bit n is to bit or in the value (1<=1 The length of a pulse in microseconds. dutycycle: 0-range_ A number between 0 and range_. The dutycycle sets the proportion of time on versus time off during each PWM cycle. Dutycycle @ On time 0 @ Off range_ * 0.25 @ 25% On range_ * 0.50 @ 50% On range_ * 0.75 @ 75% On range_ @ Fully On edge: 0-2 . . EITHER_EDGE = 2 FALLING_EDGE = 1 RISING_EDGE = 0 . . errnum: <0 . . PI_BAD_USER_GPIO = -2 PI_BAD_GPIO = -3 PI_BAD_MODE = -4 PI_BAD_LEVEL = -5 PI_BAD_PUD = -6 PI_BAD_PULSEWIDTH = -7 PI_BAD_DUTYCYCLE = -8 PI_BAD_WDOG_TIMEOUT = -15 PI_BAD_DUTYRANGE = -21 PI_NO_HANDLE = -24 PI_BAD_HANDLE = -25 PI_BAD_WAVE_BAUD = -35 PI_TOO_MANY_PULSES = -36 PI_TOO_MANY_CHARS = -37 PI_NOT_SERIAL_GPIO = -38 PI_NOT_PERMITTED = -41 PI_SOME_PERMITTED = -42 PI_BAD_WVSC_COMMND = -43 PI_BAD_WVSM_COMMND = -44 PI_BAD_WVSP_COMMND = -45 PI_BAD_PULSELEN = -46 PI_BAD_SCRIPT = -47 PI_BAD_SCRIPT_ID = -48 PI_BAD_SER_OFFSET = -49 PI_GPIO_IN_USE = -50 PI_BAD_SERIAL_COUNT = -51 PI_BAD_PARAM_NUM = -52 PI_DUP_TAG = -53 PI_TOO_MANY_TAGS = -54 PI_BAD_SCRIPT_CMD = -55 PI_BAD_VAR_NUM = -56 PI_NO_SCRIPT_ROOM = -57 PI_NO_MEMORY = -58 PI_SOCK_READ_FAILED = -59 PI_SOCK_WRIT_FAILED = -60 PI_TOO_MANY_PARAM = -61 PI_SCRIPT_NOT_READY = -62 PI_BAD_TAG = -63 PI_BAD_MICS_DELAY = -64 PI_BAD_MILS_DELAY = -65 PI_BAD_WAVE_ID = -66 PI_TOO_MANY_CBS = -67 PI_TOO_MANY_OOL = -68 PI_EMPTY_WAVEFORM = -69 PI_NO_WAVEFORM_ID = -70 PI_I2C_OPEN_FAILED = -71 PI_SER_OPEN_FAILED = -72 PI_SPI_OPEN_FAILED = -73 PI_BAD_I2C_BUS = -74 PI_BAD_I2C_ADDR = -75 PI_BAD_SPI_CHANNEL = -76 PI_BAD_FLAGS = -77 PI_BAD_SPI_SPEED = -78 PI_BAD_SER_DEVICE = -79 PI_BAD_SER_SPEED = -80 PI_BAD_PARAM = -81 PI_I2C_WRITE_FAILED = -82 PI_I2C_READ_FAILED = -83 PI_BAD_SPI_COUNT = -84 PI_SER_WRITE_FAILED = -85 PI_SER_READ_FAILED = -86 PI_SER_READ_NO_DATA = -87 PI_UNKNOWN_COMMAND = -88 PI_SPI_XFER_FAILED = -89 PI_NO_AUX_SPI = -91 PI_NOT_PWM_GPIO = -92 PI_NOT_SERVO_GPIO = -93 PI_NOT_HCLK_GPIO = -94 PI_NOT_HPWM_GPIO = -95 PI_BAD_HPWM_FREQ = -96 PI_BAD_HPWM_DUTY = -97 PI_BAD_HCLK_FREQ = -98 PI_BAD_HCLK_PASS = -99 PI_HPWM_ILLEGAL = -100 PI_BAD_DATABITS = -101 PI_BAD_STOPBITS = -102 PI_MSG_TOOBIG = -103 PI_BAD_MALLOC_MODE = -104 PI_BAD_SMBUS_CMD = -107 PI_NOT_I2C_GPIO = -108 PI_BAD_I2C_WLEN = -109 PI_BAD_I2C_RLEN = -110 PI_BAD_I2C_CMD = -111 PI_BAD_I2C_BAUD = -112 PI_CHAIN_LOOP_CNT = -113 PI_BAD_CHAIN_LOOP = -114 PI_CHAIN_COUNTER = -115 PI_BAD_CHAIN_CMD = -116 PI_BAD_CHAIN_DELAY = -117 PI_CHAIN_NESTING = -118 PI_CHAIN_TOO_BIG = -119 PI_DEPRECATED = -120 PI_BAD_SER_INVERT = -121 PI_BAD_FOREVER = -124 PI_BAD_FILTER = -125 PI_BAD_PAD = -126 PI_BAD_STRENGTH = -127 PI_FIL_OPEN_FAILED = -128 PI_BAD_FILE_MODE = -129 PI_BAD_FILE_FLAG = -130 PI_BAD_FILE_READ = -131 PI_BAD_FILE_WRITE = -132 PI_FILE_NOT_ROPEN = -133 PI_FILE_NOT_WOPEN = -134 PI_BAD_FILE_SEEK = -135 PI_NO_FILE_MATCH = -136 PI_NO_FILE_ACCESS = -137 PI_FILE_IS_A_DIR = -138 PI_BAD_SHELL_STATUS = -139 PI_BAD_SCRIPT_NAME = -140 PI_BAD_SPI_BAUD = -141 PI_NOT_SPI_GPIO = -142 PI_BAD_EVENT_ID = -143 PI_CMD_INTERRUPTED = -144 PI_NOT_ON_BCM2711 = -145 PI_ONLY_ON_BCM2711 = -146 . . event:0-31 An event is a signal used to inform one or more consumers to start an action. file_mode: The mode may have the following values . . FILE_READ 1 FILE_WRITE 2 FILE_RW 3 . . The following values can be or'd into the file open mode . . FILE_APPEND 4 FILE_CREATE 8 FILE_TRUNC 16 . . file_name: A full file path. To be accessible the path must match an entry in /opt/pigpio/access. fpattern: A file path which may contain wildcards. To be accessible the path must match an entry in /opt/pigpio/access. frequency: 0-40000 Defines the frequency to be used for PWM on a GPIO. The closest permitted frequency will be used. func: A user supplied callback function. gpio: 0-53 A Broadcom numbered GPIO. All the user GPIO are in the range 0-31. There are 54 General Purpose Input Outputs (GPIO) named GPIO0 through GPIO53. They are split into two banks. Bank 1 consists of GPIO0 through GPIO31. Bank 2 consists of GPIO32 through GPIO53. All the GPIO which are safe for the user to read and write are in bank 1. Not all GPIO in bank 1 are safe though. Type 1 boards have 17 safe GPIO. Type 2 boards have 21. Type 3 boards have 26. See [*get_hardware_revision*]. The user GPIO are marked with an X in the following table . . 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Type 1 X X - - X - - X X X X X - - X X Type 2 - - X X X - - X X X X X - - X X Type 3 X X X X X X X X X X X X X X 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 Type 1 - X X - - X X X X X - - - - - - Type 2 - X X - - - X X X X - X X X X X Type 3 X X X X X X X X X X X X - - - - . . gpio_off: A mask used to select GPIO to be operated on. See [*bits*]. This mask selects the GPIO to be switched off at the start of a pulse. gpio_on: A mask used to select GPIO to be operated on. See [*bits*]. This mask selects the GPIO to be switched on at the start of a pulse. handle: >=0 A number referencing an object opened by one of the following [*file_open*] [*i2c_open*] [*notify_open*] [*serial_open*] [*spi_open*] host: The name or IP address of the Pi running the pigpio daemon. i2c_address: 0-0x7F The address of a device on the I2C bus. i2c_bus: >=0 An I2C bus number. i2c_flags: 0 No I2C flags are currently defined. invert: 0-1 A flag used to set normal or inverted bit bang serial data level logic. level: 0-1 (2) . . CLEAR = 0 HIGH = 1 LOW = 0 OFF = 0 ON = 1 SET = 1 TIMEOUT = 2 # only returned for a watchdog timeout . . MISO: The GPIO used for the MISO signal when bit banging SPI. mode: 1.The operational mode of a GPIO, normally INPUT or OUTPUT. . . ALT0 = 4 ALT1 = 5 ALT2 = 6 ALT3 = 7 ALT4 = 3 ALT5 = 2 INPUT = 0 OUTPUT = 1 . . 2. The mode of waveform transmission. . . WAVE_MODE_ONE_SHOT = 0 WAVE_MODE_REPEAT = 1 WAVE_MODE_ONE_SHOT_SYNC = 2 WAVE_MODE_REPEAT_SYNC = 3 . . MOSI: The GPIO used for the MOSI signal when bit banging SPI. offset: >=0 The offset wave data starts from the beginning of the waveform being currently defined. pad: 0-2 A set of GPIO which share common drivers. Pad @ GPIO 0 @ 0-27 1 @ 28-45 2 @ 46-53 pad_strength: 1-16 The mA which may be drawn from each GPIO whilst still guaranteeing the high and low levels. params: 32 bit number When scripts are started they can receive up to 10 parameters to define their operation. percent:: 0-100 The size of waveform as percentage of maximum available. port: The port used by the pigpio daemon, defaults to 8888. pstring: The string to be passed to a [*shell*] script to be executed. pud: 0-2 . . PUD_DOWN = 1 PUD_OFF = 0 PUD_UP = 2 . . pulse_len: 1-100 The length of the trigger pulse in microseconds. pulses: A list of class pulse objects defining the characteristics of a waveform. pulsewidth: The servo pulsewidth in microseconds. 0 switches pulses off. PWMduty: 0-1000000 (1M) The hardware PWM dutycycle. PWMfreq: 1-125M (1-187.5M for the BCM2711) The hardware PWM frequency. range_: 25-40000 Defines the limits for the [*dutycycle*] parameter. range_ defaults to 255. reg: 0-255 An I2C device register. The usable registers depend on the actual device. retMax: >=0 The maximum number of bytes a user customised function should return, default 8192. SCL: The user GPIO to use for the clock when bit banging I2C. SCLK:: The GPIO used for the SCLK signal when bit banging SPI. script: The text of a script to store on the pigpio daemon. script_id: >=0 A number referencing a script created by [*store_script*]. SDA: The user GPIO to use for data when bit banging I2C. seek_from: 0-2 Direction to seek for [*file_seek*]. . . FROM_START=0 FROM_CURRENT=1 FROM_END=2 . . seek_offset: The number of bytes to move forward (positive) or backwards (negative) from the seek position (start, current, or end of file). ser_flags: 32 bit No serial flags are currently defined. serial_*: One of the serial_ functions. shellscr: The name of a shell script. The script must exist in /opt/pigpio/cgi and must be executable. show_errors: Controls the display of pigpio daemon connection failures. The default of True prints the probable failure reasons to standard output. spi_channel: 0-2 A SPI channel. spi_flags: 32 bit See [*spi_open*]. steady: 0-300000 The number of microseconds level changes must be stable for before reporting the level changed ([*set_glitch_filter*]) or triggering the active part of a noise filter ([*set_noise_filter*]). t1: A tick (earlier). t2: A tick (later). tty: A Pi serial tty device, e.g. /dev/ttyAMA0, /dev/ttyUSB0 uint32: An unsigned 32 bit number. user_gpio: 0-31 A Broadcom numbered GPIO. All the user GPIO are in the range 0-31. Not all the GPIO within this range are usable, some are reserved for system use. See [*gpio*]. wait_timeout: 0.0 - The number of seconds to wait in [*wait_for_edge*] before timing out. wave_add_*: One of the following [*wave_add_new*] [*wave_add_generic*] [*wave_add_serial*] wave_id: >=0 A number referencing a wave created by [*wave_create*]. wave_send_*: One of the following [*wave_send_once*] [*wave_send_repeat*] wdog_timeout: 0-60000 Defines a GPIO watchdog timeout in milliseconds. If no level change is detected on the GPIO for timeout millisecond a watchdog timeout report is issued (with level TIMEOUT). word_val: 0-65535 A whole number. DATA ALT0 = 4 ALT1 = 5 ALT2 = 6 ALT3 = 7 ALT4 = 3 ALT5 = 2 CLEAR = 0 EITHER_EDGE = 2 EVENT_BSC = 31 FALLING_EDGE = 1 FILE_APPEND = 4 FILE_CREATE = 8 FILE_READ = 1 FILE_RW = 3 FILE_TRUNC = 16 FILE_WRITE = 2 FROM_CURRENT = 1 FROM_END = 2 FROM_START = 0 HIGH = 1 INPUT = 0 LOW = 0 NO_TX_WAVE = 9999 NTFY_FLAGS_ALIVE = 64 NTFY_FLAGS_EVENT = 128 NTFY_FLAGS_GPIO = 31 NTFY_FLAGS_WDOG = 32 OFF = 0 ON = 1 OUTPUT = 1 PI_BAD_CHAIN_CMD = -116 PI_BAD_CHAIN_DELAY = -117 PI_BAD_CHAIN_LOOP = -114 PI_BAD_DATABITS = -101 PI_BAD_DUTYCYCLE = -8 PI_BAD_DUTYRANGE = -21 PI_BAD_EVENT_ID = -143 PI_BAD_FILE_FLAG = -130 PI_BAD_FILE_MODE = -129 PI_BAD_FILE_READ = -131 PI_BAD_FILE_SEEK = -135 PI_BAD_FILE_WRITE = -132 PI_BAD_FILTER = -125 PI_BAD_FLAGS = -77 PI_BAD_FOREVER = -124 PI_BAD_GPIO = -3 PI_BAD_HANDLE = -25 PI_BAD_HCLK_FREQ = -98 PI_BAD_HCLK_PASS = -99 PI_BAD_HPWM_DUTY = -97 PI_BAD_HPWM_FREQ = -96 PI_BAD_I2C_ADDR = -75 PI_BAD_I2C_BAUD = -112 PI_BAD_I2C_BUS = -74 PI_BAD_I2C_CMD = -111 PI_BAD_I2C_RLEN = -110 PI_BAD_I2C_WLEN = -109 PI_BAD_LEVEL = -5 PI_BAD_MALLOC_MODE = -104 PI_BAD_MICS_DELAY = -64 PI_BAD_MILS_DELAY = -65 PI_BAD_MODE = -4 PI_BAD_PAD = -126 PI_BAD_PARAM = -81 PI_BAD_PARAM_NUM = -52 PI_BAD_PUD = -6 PI_BAD_PULSELEN = -46 PI_BAD_PULSEWIDTH = -7 PI_BAD_SCRIPT = -47 PI_BAD_SCRIPT_CMD = -55 PI_BAD_SCRIPT_ID = -48 PI_BAD_SCRIPT_NAME = -140 PI_BAD_SERIAL_COUNT = -51 PI_BAD_SER_DEVICE = -79 PI_BAD_SER_INVERT = -121 PI_BAD_SER_OFFSET = -49 PI_BAD_SER_SPEED = -80 PI_BAD_SHELL_STATUS = -139 PI_BAD_SMBUS_CMD = -107 PI_BAD_SPI_BAUD = -141 PI_BAD_SPI_CHANNEL = -76 PI_BAD_SPI_COUNT = -84 PI_BAD_SPI_SPEED = -78 PI_BAD_STOPBITS = -102 PI_BAD_STRENGTH = -127 PI_BAD_TAG = -63 PI_BAD_USER_GPIO = -2 PI_BAD_VAR_NUM = -56 PI_BAD_WAVE_BAUD = -35 PI_BAD_WAVE_ID = -66 PI_BAD_WDOG_TIMEOUT = -15 PI_BAD_WVSC_COMMND = -43 PI_BAD_WVSM_COMMND = -44 PI_BAD_WVSP_COMMND = -45 PI_CHAIN_COUNTER = -115 PI_CHAIN_LOOP_CNT = -113 PI_CHAIN_NESTING = -118 PI_CHAIN_TOO_BIG = -119 PI_CMD_INTERRUPTED = -144 PI_DEPRECATED = -120 PI_DUP_TAG = -53 PI_EMPTY_WAVEFORM = -69 PI_FILE_IS_A_DIR = -138 PI_FILE_NOT_ROPEN = -133 PI_FILE_NOT_WOPEN = -134 PI_FIL_OPEN_FAILED = -128 PI_GPIO_IN_USE = -50 PI_HPWM_ILLEGAL = -100 PI_I2C_OPEN_FAILED = -71 PI_I2C_READ_FAILED = -83 PI_I2C_WRITE_FAILED = -82 PI_MSG_TOOBIG = -103 PI_NOT_HCLK_GPIO = -94 PI_NOT_HPWM_GPIO = -95 PI_NOT_I2C_GPIO = -108 PI_NOT_ON_BCM2711 = -145 PI_NOT_PERMITTED = -41 PI_NOT_PWM_GPIO = -92 PI_NOT_SERIAL_GPIO = -38 PI_NOT_SERVO_GPIO = -93 PI_NOT_SPI_GPIO = -142 PI_NO_AUX_SPI = -91 PI_NO_FILE_ACCESS = -137 PI_NO_FILE_MATCH = -136 PI_NO_HANDLE = -24 PI_NO_MEMORY = -58 PI_NO_SCRIPT_ROOM = -57 PI_NO_WAVEFORM_ID = -70 PI_ONLY_ON_BCM2711 = -146 PI_SCRIPT_FAILED = 4 PI_SCRIPT_HALTED = 1 PI_SCRIPT_INITING = 0 PI_SCRIPT_NOT_READY = -62 PI_SCRIPT_RUNNING = 2 PI_SCRIPT_WAITING = 3 PI_SER_OPEN_FAILED = -72 PI_SER_READ_FAILED = -86 PI_SER_READ_NO_DATA = -87 PI_SER_WRITE_FAILED = -85 PI_SOCK_READ_FAILED = -59 PI_SOCK_WRIT_FAILED = -60 PI_SOME_PERMITTED = -42 PI_SPI_OPEN_FAILED = -73 PI_SPI_XFER_FAILED = -89 PI_TOO_MANY_CBS = -67 PI_TOO_MANY_CHARS = -37 PI_TOO_MANY_OOL = -68 PI_TOO_MANY_PARAM = -61 PI_TOO_MANY_PULSES = -36 PI_TOO_MANY_TAGS = -54 PI_UNKNOWN_COMMAND = -88 PUD_DOWN = 1 PUD_OFF = 0 PUD_UP = 2 RISING_EDGE = 0 SET = 1 SPI_CPHA = 1 SPI_CPOL = 2 SPI_CS_HIGH_ACTIVE = 4 SPI_MODE_0 = 0 SPI_MODE_1 = 1 SPI_MODE_2 = 2 SPI_MODE_3 = 3 SPI_RX_LSBFIRST = 32768 SPI_TX_LSBFIRST = 16384 TIMEOUT = 2 VERSION = '1.46' WAVE_MODE_ONE_SHOT = 0 WAVE_MODE_ONE_SHOT_SYNC = 2 WAVE_MODE_REPEAT = 1 WAVE_MODE_REPEAT_SYNC = 3 WAVE_NOT_FOUND = 9998 exceptions = True