 |
 |
 |
| pigpio pigpio C I/F pigpiod pigpiod C I/F Python pigs piscope Misc Examples Download FAQ Site Map | Python InterfaceFeatureso the pigpio Python module can run on Windows, Macs, or Linuxo 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 GPIOALL GPIO are identified by their Broadcom number.NotesTransmitted waveforms are accurate to a microsecond.Callback level changes are time-stamped and will be accurate to within a few microseconds. SettingsA 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). ExceptionsBy 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: Example pigpio.exceptions = FalseUsageThis 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. Example pi1 = pigpio.pi() # pi1 accesses the local Pi's GPIOThe later example code snippets assume that pi is an instance of the pigpio.pi class. OVERVIEW
class pipigpio.pi(host, port, show_errors)Grants access to a Pi's GPIO.Parameters 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. Parameters 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. Example pi = pigio.pi() # use defaults__repr__()bb_i2c_close(SDA)This function stops bit banging I2C on a pair of GPIO previously opened with bb_i2c_open.Parameters 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. Example pi.bb_i2c_close(SDA)bb_i2c_open(SDA, SCL, baud)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 Parameters 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. Example h = pi.bb_i2c_open(4, 5, 50000) # bit bang on GPIO 4/5 at 50kbpsbb_i2c_zip(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.Parameters 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). Example (count, data) = pi.bb_i2c_zip(The following command codes are supported:
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. Example Set address 0x53bb_serial_invert(user_gpio, invert)Invert serial logic.Parameters user_gpio:= 0-31 (opened in a prior call to bb_serial_read_open) invert:= 0-1 (1 invert, 0 normal) Example status = pi.bb_serial_invert(17, 1)bb_serial_read(user_gpio)Returns data from the bit bang serial cyclic buffer.Parameters 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. Example (count, data) = pi.bb_serial_read(4)bb_serial_read_close(user_gpio)Closes a GPIO for bit bang reading of serial data.Parameters user_gpio:= 0-31 (opened in a prior call to bb_serial_read_open) Example status = pi.bb_serial_read_close(17)bb_serial_read_open(user_gpio, baud, bb_bits)Opens a GPIO for bit bang reading of serial data.Parameters 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. Example status = pi.bb_serial_read_open(4, 19200)bb_spi_close(CS)This function stops bit banging SPI on a set of GPIO opened with bb_spi_open.Parameters 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. Example pi.bb_spi_close(CS)bb_spi_open(CS, MISO, MOSI, SCLK, baud, spi_flags)This function selects a set of GPIO for bit banging SPI at a specified baud rate.Parameters 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 0mm defines the SPI mode, defaults to 0 Mode CPOL CPHAThe following constants may be used to set the mode: pigpio.SPI_MODE_0Alternatively 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. Example bb_spi_open(10, MISO, MOSI, SCLK, 10000, 0); // device 1bb_spi_xfer(CS, data)This function executes a bit banged SPI transfer.Parameters 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). Example #!/usr/bin/env pythonbsc_i2c(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. Parameters 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). Example #!/usr/bin/env pythonWhile running the above. $ i2cdetect -y 1bsc_xfer(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. Parameters 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.
GPIO used for models based on the BCM2711 (e.g. the Pi4B).
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 0Bits 0-13 are copied unchanged to the BSC CR register. See pages 163-165 of the Broadcom peripherals document for full details.
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 0Bits 0-15 are copied unchanged from the BSC FR register. See pages 165-166 of the Broadcom peripherals document for full details.
Example (status, count, data) = pi.bsc_xfer(0x330305, "Hello!")callback(user_gpio, edge, func)Calls a user supplied function (a callback) whenever the specified GPIO edge is detected.Parameters 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 MeaningIf 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. samplesGPIO 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. Example def cbf(gpio, level, tick):clear_bank_1(bits)Clears GPIO 0-31 if the corresponding bit in bits is set.Parameters 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. Example pi.clear_bank_1(int("111110010000",2))clear_bank_2(bits)Clears GPIO 32-53 if the corresponding bit (0-21) in bits is set.Parameters 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. Example pi.clear_bank_2(0x1010)custom_1(arg1, arg2, argx)Calls a pigpio function customised by the user.Parameters 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. Example value = pi.custom_1()custom_2(arg1, argx, retMax)Calls a pigpio function customised by the user.Parameters 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). Example (count, data) = pi.custom_2()delete_script(script_id)Deletes a stored script.Parameters script_id:= id of stored script. Example status = pi.delete_script(sid)event_callback(event, func)Calls a user supplied function (a callback) whenever the specified event is signalled.Parameters 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). Example def cbf(event, tick):event_trigger(event)This function signals the occurrence of an event.Parameters 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. Example pi.event_trigger(23)file_close(handle)Closes the file associated with handle.Parameters handle:= >=0 (as returned by a prior call to file_open). Example pi.file_close(handle)file_list(fpattern)Returns a list of files which match a pattern.Parameters 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. Example #!/usr/bin/env pythonfile_open(file_name, file_mode)This function returns a handle to a file opened in a specified mode.Parameters 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. Example h = pi.file_open("/home/pi/shared/dir_3/file.txt",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/* nFiles 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 ..Mode The mode may have the following values:
The following values may be or'd into the mode:
Newly created files are owned by root with permissions owner read and write. Example #!/usr/bin/env pythonfile_read(handle, count)Reads up to count bytes from the file associated with handle.Parameters 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). Example (b, d) = pi.file_read(h2, 100)file_seek(handle, seek_offset, seek_from)Seeks to a position relative to the start, current position, or end of the file. Returns the new position.Parameters handle:= >=0 (as returned by a prior call to file_open). seek_offset:= byte offset. seek_from:= FROM_START, FROM_CURRENT, or FROM_END. Example new_pos = pi.file_seek(h, 100, pigpio.FROM_START)file_write(handle, data)Writes the data bytes to the file associated with handle.Parameters handle:= >=0 (as returned by a prior call to file_open). data:= the bytes to write. Example pi.file_write(h1, b'\x02\x03\x04')get_PWM_dutycycle(user_gpio)Returns the PWM dutycycle being used on the GPIO.Parameters 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). Example pi.set_PWM_dutycycle(4, 25)get_PWM_frequency(user_gpio)Returns the frequency of PWM being used on the GPIO.Parameters 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. Example pi.set_PWM_frequency(4,0)get_PWM_range(user_gpio)Returns the range of PWM values being used on the GPIO.Parameters user_gpio:= 0-31. If a hardware clock or hardware PWM is active on the GPIO the reported range will be 1000000 (1M). Example pi.set_PWM_range(9, 500)get_PWM_real_range(user_gpio)Returns the real (underlying) range of PWM values being used on the GPIO.Parameters 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. Example pi.set_PWM_frequency(4, 800)get_current_tick()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. Example t1 = pi.get_current_tick()get_hardware_revision()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. Example print(pi.get_hardware_revision())get_mode(gpio)Returns the GPIO mode.Parameters gpio:= 0-53. Returns a value as follows 0 = INPUTExample print(pi.get_mode(0))get_pad_strength(pad)This function returns the pad drive strength in mA.Parameters pad:= 0-2, the pad to get. Returns the pad drive strength if OK, otherwise PI_BAD_PAD.
Example strength = pi.get_pad_strength(0) # Get pad 0 strength.get_pigpio_version()Returns the pigpio software version.Example v = pi.get_pigpio_version()get_servo_pulsewidth(user_gpio)Returns the servo pulsewidth being used on the GPIO.Parameters user_gpio:= 0-31. Returns the servo pulsewidth. Example pi.set_servo_pulsewidth(4, 525)gpio_trigger(user_gpio, pulse_len, level)Send a trigger pulse to a GPIO. The GPIO is set to level for pulse_len microseconds and then reset to not level.Parameters user_gpio:= 0-31 pulse_len:= 1-100 level:= 0-1 Example pi.gpio_trigger(23, 10, 1)hardware_PWM(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). Parameters 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 BThe 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. Example pi.hardware_PWM(18, 800, 250000) # 800Hz 25% dutycyclehardware_clock(gpio, clkfreq)Starts a hardware clock on a GPIO at the specified frequency. Frequencies above 30MHz are unlikely to work.Parameters 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 modelsAccess 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. Example pi.hardware_clock(4, 5000) # 5 KHz clock on GPIO 4i2c_block_process_call(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.Parameters 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]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). Example (b, d) = pi.i2c_block_process_call(h, 10, b'\x02\x05\x00')i2c_close(handle)Closes the I2C device associated with handle.Parameters handle:= >=0 (as returned by a prior call to i2c_open). Example pi.i2c_close(h)i2c_open(i2c_bus, i2c_address, i2c_flags)Returns a handle (>=0) for the device at the I2C bus address.Parameters 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.
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 bitExample h = pi.i2c_open(1, 0x53) # open device at address 0x53 on bus 1i2c_process_call(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.Parameters 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]Example r = pi.i2c_process_call(h, 4, 0x1231)i2c_read_block_data(handle, reg)Reads a block of up to 32 bytes from the specified register of the device associated with handle.Parameters 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]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). Example (b, d) = pi.i2c_read_block_data(h, 10)i2c_read_byte(handle)Reads a single byte from the device associated with handle.Parameters 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 PExample b = pi.i2c_read_byte(2) # read a byte from device 2i2c_read_byte_data(handle, reg)Reads a single byte from the specified register of the device associated with handle.Parameters 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 PExample # read byte from reg 17 of device 2i2c_read_device(handle, count)Returns count bytes read from the raw device associated with handle.Parameters 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 PThe 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). Example (count, data) = pi.i2c_read_device(h, 12)i2c_read_i2c_block_data(handle, reg, count)Reads count bytes from the specified register of the device associated with handle . The count may be 1-32.Parameters 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]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). Example (b, d) = pi.i2c_read_i2c_block_data(h, 4, 32)i2c_read_word_data(handle, reg)Reads a single 16 bit word from the specified register of the device associated with handle.Parameters 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 PExample # read word from reg 2 of device 3i2c_write_block_data(handle, reg, data)Writes up to 32 bytes to the specified register of the device associated with handle.Parameters 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]Example pi.i2c_write_block_data(4, 5, b'hello')i2c_write_byte(handle, byte_val)Sends a single byte to the device associated with handle.Parameters 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] PExample pi.i2c_write_byte(1, 17) # send byte 17 to device 1i2c_write_byte_data(handle, reg, byte_val)Writes a single byte to the specified register of the device associated with handle.Parameters 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] PExample # send byte 0xC5 to reg 2 of device 1i2c_write_device(handle, data)Writes the data bytes to the raw device associated with handle.Parameters 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] PExample pi.i2c_write_device(h, b"\x12\x34\xA8")i2c_write_i2c_block_data(handle, reg, data)Writes data bytes to the specified register of the device associated with handle . 1-32 bytes may be written.Parameters 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] PExample pi.i2c_write_i2c_block_data(4, 5, 'hello')i2c_write_quick(handle, bit)Sends a single bit to the device associated with handle.Parameters 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] PExample pi.i2c_write_quick(0, 1) # send 1 to device 0i2c_write_word_data(handle, reg, word_val)Writes a single 16 bit word to the specified register of the device associated with handle.Parameters 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] PExample # send word 0xA0C5 to reg 5 of device 4i2c_zip(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.Parameters 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). Example (count, data) = pi.i2c_zip(h, [4, 0x53, 7, 1, 0x32, 6, 6, 0])The following command codes are supported:
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. Example Set address 0x53, write 0x32, read 6 bytesnotify_begin(handle, bits)Starts notifications on a handle.Parameters 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). Example h = pi.notify_open()notify_close(handle)Stops notifications on a handle and releases the handle for reuse.Parameters handle:= >=0 (as returned by a prior call to notify_open) Example h = pi.notify_open()notify_open()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 seqnoseqno: starts at 0 each time the handle is opened and then increments by one for each report. flags: three flags are defined, PI_NTFY_FLAGS_WDOG, PI_NTFY_FLAGS_ALIVE, and PI_NTFY_FLAGS_EVENT. If bit 5 is set (PI_NTFY_FLAGS_WDOG) then bits 0-4 of the flags indicate a GPIO which has had a watchdog timeout. If bit 6 is set (PI_NTFY_FLAGS_ALIVE) this indicates a keep alive signal on the pipe/socket and is sent once a minute in the absence of other notification activity. If bit 7 is set (PI_NTFY_FLAGS_EVENT) then bits 0-4 of the flags indicate an event which has been triggered. tick: the number of microseconds since system boot. It wraps around after 1h12m. level: indicates the level of each GPIO. If bit 1<<x is set then GPIO x is high. Example h = pi.notify_open()notify_pause(handle)Pauses notifications on a handle.Parameters handle:= >=0 (as returned by a prior call to notify_open) Notifications for the handle are suspended until notify_begin is called again. Example h = pi.notify_open()read(gpio)Returns the GPIO level.Parameters gpio:= 0-53. Example pi.set_mode(23, pigpio.INPUT)read_bank_1()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<<n). Example print(bin(pi.read_bank_1()))read_bank_2()Returns the levels of the bank 2 GPIO (GPIO 32-53).The returned 32 bit integer has a bit set if the corresponding GPIO is high. GPIO n has bit value (1<<(n-32)). Example print(bin(pi.read_bank_2()))run_script(script_id, params)Runs a stored script.Parameters script_id:= id of stored script. params:= up to 10 parameters required by the script. Example s = pi.run_script(sid, [par1, par2])script_status(script_id)Returns the run status of a stored script as well as the current values of parameters 0 to 9.Parameters script_id:= id of stored script. The run status may be PI_SCRIPT_INITINGThe return value is a tuple of run status and a list of the 10 parameters. On error the run status will be negative and the parameter list will be empty. Example (s, pars) = pi.script_status(sid)serial_close(handle)Closes the serial device associated with handle.Parameters handle:= >=0 (as returned by a prior call to serial_open). Example pi.serial_close(h1)serial_data_available(handle)Returns the number of bytes available to be read from the device associated with handle.Parameters handle:= >=0 (as returned by a prior call to serial_open). Example rdy = pi.serial_data_available(h1)serial_open(tty, baud, ser_flags)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.Parameters 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. Example h1 = pi.serial_open("/dev/ttyAMA0", 300)serial_read(handle, count)Reads up to count bytes from the device associated with handle.Parameters 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. Example (b, d) = pi.serial_read(h2, 100)serial_read_byte(handle)Returns a single byte from the device associated with handle.Parameters handle:= >=0 (as returned by a prior call to serial_open). If no data is ready a negative error code will be returned. Example b = pi.serial_read_byte(h1)serial_write(handle, data)Writes the data bytes to the device associated with handle.Parameters handle:= >=0 (as returned by a prior call to serial_open). data:= the bytes to write. Example pi.serial_write(h1, b'\x02\x03\x04')serial_write_byte(handle, byte_val)Writes a single byte to the device associated with handle.Parameters handle:= >=0 (as returned by a prior call to serial_open). byte_val:= 0-255, the value to write. Example pi.serial_write_byte(h1, 23)set_PWM_dutycycle(user_gpio, dutycycle)Starts (non-zero dutycycle) or stops (0) PWM pulses on the GPIO.Parameters user_gpio:= 0-31. dutycycle:= 0-range (range defaults to 255). The set_PWM_range function can change the default range of 255. Example pi.set_PWM_dutycycle(4, 0) # PWM offset_PWM_frequency(user_gpio, frequency)Sets the frequency (in Hz) of the PWM to be used on the GPIO.Parameters 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: HertzExample pi.set_PWM_frequency(4,0)set_PWM_range(user_gpio, range_)Sets the range of PWM values to be used on the GPIO.Parameters user_gpio:= 0-31. range_:= 25-40000. Example pi.set_PWM_range(9, 100) # now 25 1/4, 50 1/2, 75 3/4 onset_bank_1(bits)Sets GPIO 0-31 if the corresponding bit in bits is set.Parameters 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. Example pi.set_bank_1(int("111110010000",2))set_bank_2(bits)Sets GPIO 32-53 if the corresponding bit (0-21) in bits is set.Parameters 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. Example pi.set_bank_2(0x303)set_glitch_filter(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. Parameters 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. Example pi.set_glitch_filter(23, 100)set_mode(gpio, mode)Sets the GPIO mode.Parameters gpio:= 0-53. mode:= INPUT, OUTPUT, ALT0, ALT1, ALT2, ALT3, ALT4, ALT5. Example pi.set_mode( 4, pigpio.INPUT) # GPIO 4 as inputset_noise_filter(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. Parameters 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. Example pi.set_noise_filter(23, 1000, 5000)set_pad_strength(pad, pad_strength)This function sets the pad drive strength in mA.Parameters pad:= 0-2, the pad to set. pad_strength:= 1-16 mA. Returns 0 if OK, otherwise PI_BAD_PAD, or PI_BAD_STRENGTH.
Example pi.set_pad_strength(2, 14) # Set pad 2 to 14 mA.set_pull_up_down(gpio, pud)Sets or clears the internal GPIO pull-up/down resistor.Parameters gpio:= 0-53. pud:= PUD_UP, PUD_DOWN, PUD_OFF. Example pi.set_pull_up_down(17, pigpio.PUD_OFF)set_servo_pulsewidth(user_gpio, pulsewidth)Starts (500-2500) or stops (0) servo pulses on the GPIO.Parameters 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. Example pi.set_servo_pulsewidth(17, 0) # offset_watchdog(user_gpio, wdog_timeout)Sets a watchdog timeout for a GPIO.Parameters 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. Example pi.set_watchdog(23, 1000) # 1000 ms watchdog on GPIO 23shell(shellscr, pstring)This function uses the system call to execute a shell script with the given string as its parameter.Parameters 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:
Example // pass two parameters, hello and worldspi_close(handle)Closes the SPI device associated with handle.Parameters handle:= >=0 (as returned by a prior call to spi_open). Example pi.spi_close(h)spi_open(spi_channel, baud, spi_flags)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.
Parameters 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 0mm defines the SPI mode. WARNING: modes 1 and 3 do not appear to work on the auxiliary SPI. Mode POL PHApx 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. Example # open SPI device on channel 1 in mode 3 at 50000 bits per secondspi_read(handle, count)Reads count bytes from the SPI device associated with handle.Parameters 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). Example (b, d) = pi.spi_read(h, 60) # read 60 bytes from device hspi_write(handle, data)Writes the data bytes to the SPI device associated with handle.Parameters handle:= >=0 (as returned by a prior call to spi_open). data:= the bytes to write. Example pi.spi_write(0, b'\x02\xc0\x80') # write 3 bytes to device 0spi_xfer(handle, data)Writes the data bytes to the SPI device associated with handle, returning the data bytes read from the device.Parameters 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). Example (count, rx_data) = pi.spi_xfer(h, b'\x01\x80\x00')stop()Release pigpio resources.Example pi.stop()stop_script(script_id)Stops a running script.Parameters script_id:= id of stored script. Example status = pi.stop_script(sid)store_script(script)Store a script for later execution.See http://abyz.me.uk/rpi/pigpio/pigs.html#Scripts for details. Parameters script:= the script text as a series of bytes. Returns a >=0 script id if OK. Example sid = pi.store_script(update_script(script_id, params)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.Parameters script_id:= id of stored script. params:= up to 10 parameters required by the script. Example s = pi.update_script(sid, [par1, par2])wait_for_edge(user_gpio, edge, wait_timeout)Wait for an edge event on a GPIO.Parameters 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. Example if pi.wait_for_edge(23):wait_for_event(event, wait_timeout)Wait for an event.Parameters 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. Example if pi.wait_for_event(23):wave_add_generic(pulses)Adds a list of pulses to the current waveform.Parameters 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. Example G1=4wave_add_new()Starts a new empty waveform.You would not normally need to call this function as it is automatically called after a waveform is created with the wave_create function. Example pi.wave_add_new()wave_add_serial(user_gpio, baud, data, offset, bb_bits, bb_stop)Adds a waveform representing serial data to the existing waveform (if any). The serial data starts offset microseconds from the start of the waveform.Parameters user_gpio:= GPIO to transmit data. You must set the GPIO mode to output. baud:= 50-1000000 bits per second. data:= the bytes to write. offset:= number of microseconds from the start of the waveform, default 0. bb_bits:= number of data bits, default 8. bb_stop:= number of stop half bits, default 2. Returns the new total number of pulses in the current waveform. The serial data is formatted as one start bit, bb_bits data bits, and bb_stop/2 stop bits. It is legal to add serial data streams with different baud rates to the same waveform. The bytes required for each character depend upon bb_bits. 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. Example pi.wave_add_serial(4, 300, 'Hello world')wave_chain(data)This function transmits a chain of waveforms.NOTE: Any hardware PWM started by hardware_PWM will be cancelled. The waves to be transmitted are specified by the contents of data which contains an ordered list of wave_ids and optional command codes and related data. Returns 0 if OK, otherwise PI_CHAIN_NESTING, PI_CHAIN_LOOP_CNT, PI_BAD_CHAIN_LOOP, PI_BAD_CHAIN_CMD, PI_CHAIN_COUNTER, PI_BAD_CHAIN_DELAY, PI_CHAIN_TOO_BIG, or PI_BAD_WAVE_ID. Each wave is transmitted in the order specified. A wave may occur multiple times per chain. A blocks of waves may be transmitted multiple times by using the loop commands. The block is bracketed by loop start and end commands. Loops may be nested. Delays between waves may be added with the delay command. The following command codes are supported:
If present Loop Forever must be the last entry in the chain. The code is currently dimensioned to support a chain with roughly 600 entries and 20 loop counters. Example #!/usr/bin/env pythonwave_clear()Clears all waveforms and any data added by calls to the wave_add_* functions.Example pi.wave_clear()wave_create()Creates a waveform from the data provided by the prior calls to the wave_add_* functions.Returns a wave id (>=0) if OK, otherwise PI_EMPTY_WAVEFORM, PI_TOO_MANY_CBS, PI_TOO_MANY_OOL, or PI_NO_WAVEFORM_ID. The data provided by the wave_add_* functions is consumed by this function. As many waveforms may be created as there is space available. 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. Example wid = pi.wave_create()wave_create_and_pad(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. pi: >=0 (as returned by pigpio_start).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 available 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. Example wid = pi.wave_create(50)wave_delete(wave_id)This function deletes the waveform with id wave_id.Parameters 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). Example pi.wave_delete(6) # delete waveform with id 6wave_get_cbs()Returns the length in DMA control blocks of the current waveform.Example cbs = pi.wave_get_cbs()wave_get_max_cbs()Returns the maximum possible size of a waveform in DMA control blocks.Example cbs = pi.wave_get_max_cbs()wave_get_max_micros()Returns the maximum possible size of a waveform in microseconds.Example micros = pi.wave_get_max_micros()wave_get_max_pulses()Returns the maximum possible size of a waveform in pulses.Example pulses = pi.wave_get_max_pulses()wave_get_micros()Returns the length in microseconds of the current waveform.Example micros = pi.wave_get_micros()wave_get_pulses()Returns the length in pulses of the current waveform.Example pulses = pi.wave_get_pulses()wave_send_once(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. Parameters wave_id:= >=0 (as returned by a prior call to wave_create). Returns the number of DMA control blocks used in the waveform. Example cbs = pi.wave_send_once(wid)wave_send_repeat(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. Parameters wave_id:= >=0 (as returned by a prior call to wave_create). Returns the number of DMA control blocks used in the waveform. Example cbs = pi.wave_send_repeat(wid)wave_send_using_mode(wave_id, mode)Transmits the waveform with id wave_id using mode mode.Parameters 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. Parameters wave_id:= >=0 (as returned by a prior call to wave_create). Returns the number of DMA control blocks used in the waveform. Example cbs = pi.wave_send_using_mode(wid, WAVE_MODE_REPEAT_SYNC)wave_tx_at()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. Example wid = pi.wave_tx_at()wave_tx_busy()Returns 1 if a waveform is currently being transmitted, otherwise 0.Example pi.wave_send_once(0) # send first waveformwave_tx_repeat()This function is deprecated and has beeen removed.Use wave_create/wave_send_* instead. wave_tx_start()This function is deprecated and has been removed.Use wave_create/wave_send_* instead. wave_tx_stop()Stops the transmission of the current waveform.This function is intended to stop a waveform started with wave_send_repeat. Example pi.wave_send_repeat(3)write(gpio, level)Sets the GPIO level.Parameters GPIO:= 0-53. level:= 0, 1. If PWM or servo pulses are active on the GPIO they are switched off. Example pi.set_mode(17, pigpio.OUTPUT)class pulsepigpio.pulse(gpio_on, gpio_off, delay)Initialises a pulse.Parameters 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. FUNCTIONSpigpio.error_text(errnum)Returns a text description of a pigpio error.Parameters errnum:= <0, the error number Example print(pigpio.error_text(-5))pigpio.tickDiff(t1, t2)Returns the microsecond difference between two ticks.Parameters t1:= the earlier tick t2:= the later tick Example print(pigpio.tickDiff(4294967272, 12))pigpio.u2i(uint32)Converts a 32 bit unsigned number to signed.Parameters uint32:= an unsigned 32 bit number Example print(u2i(4294967272))PARAMETERSactive: 0-1000000The 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-32The number of data bits to be used when adding serial data to a waveform.bb_stop: 2-8The number of (half) stop bits to be used when adding serial data to a waveform.bit: 0-1A value of 0 or 1.bits: 32 bit numberA 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<<n).To select GPIO 1, 7, 23 bits = (1<<1) | (1<<7) | (1<<23) bsc_control:22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0aaaaaaa defines the I2C slave address (only relevant in I2C mode) Bits 0-13 are copied unchanged to the BSC CR register. See pages 163-165 of the Broadcom peripherals document. byte_val: 0-255A whole number.clkfreq: 4689-250M (13184-375M for the BCM2711)The hardware clock frequency.connected:True if a connection was established, False otherwise.count:The number of bytes of data to be transferred.CS:The GPIO used for the slave select signal when bit banging SPI.data:Data to be transmitted, a series of bytes.delay: >=1The 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.
edge: 0-2EITHER_EDGE = 2errnum: <0PI_BAD_USER_GPIO = -2event: 0-31An event is a signal used to inform one or more consumers to start an action.file_mode:The mode may have the following valuesFILE_READ 1The following values can be or'd into the file open mode FILE_APPEND 4file_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-40000Defines 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-53A 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 15gpio_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: >=0A number referencing an object opened by one of the followingfile_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-0x7FThe address of a device on the I2C bus.i2c_bus: >=0An I2C bus number.i2c_flags: 0No I2C flags are currently defined.invert: 0-1A flag used to set normal or inverted bit bang serial data level logic.level: 0-1 (2)CLEAR = 0MISO:The GPIO used for the MISO signal when bit banging SPI.mode:1.The operational mode of a GPIO, normally INPUT or OUTPUT.ALT0 = 42. The mode of waveform transmission. WAVE_MODE_ONE_SHOT = 0MOSI:The GPIO used for the MOSI signal when bit banging SPI.offset: >=0The offset wave data starts from the beginning of the waveform being currently defined.pad: 0-2A set of GPIO which share common drivers.
pad_strength: 1-16The mA which may be drawn from each GPIO whilst still guaranteeing the high and low levels.params: 32 bit numberWhen scripts are started they can receive up to 10 parameters to define their operation.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-2PUD_DOWN = 1pulse_len: 1-100The 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-40000Defines the limits for the dutycycle parameter.range_ defaults to 255. reg: 0-255An I2C device register. The usable registers depend on the actual device.retMax: >=0The 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: >=0A number referencing a script created by store_script.SDA:The user GPIO to use for data when bit banging I2C.seek_from: 0-2Direction to seek for file_seek.FROM_START=0seek_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 bitNo 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-2A SPI channel.spi_flags: 32 bitSee spi_open.steady: 0-300000The 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/ttyUSB0uint32:An unsigned 32 bit number.user_gpio: 0-31A 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 followingwave_add_new wave_add_generic wave_add_serial wave_id: >=0A number referencing a wave created by wave_create.wave_send_*:One of the followingwave_send_once wave_send_repeat wdog_timeout: 0-60000Defines 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-65535A whole number. |
[pigpio]
[pigpio C I/F]
[pigpiod]
[pigpiod C I/F]
[Python]
[pigs]
[piscope]
[Misc]
[Examples]
[Download]
[FAQ]
[Site Map]
© 2012-2020 |
e-mail: pigpio @ abyz.me.uk |
Updated: 29/04/2020 |