 |
 |
 |
| lg lgpio C lgpio Python Daemon rgpio C rgpio Python rgs Download Examples FAQ Site Map | lgpio C API (local)lgpio is a C library for Linux Single Board Computers which allows control of the General Purpose Input Output pins. Features
UsageInclude <lgpio.h> in your source files.Assuming your source is in a single file called prog.c use the following command to build and run the executable. gcc -Wall -o prog prog.c -llgpioFor examples of usage see the C programs within the lg archive file. NotesAll the functions which return an int return < 0 on error.OVERVIEW
FUNCTIONSint lgGpiochipOpen(int gpioDev)This returns a handle to a gpiochip device.gpioDev: >= 0If OK returns a handle (>= 0). On failure returns a negative error code. Example h = lgGpiochipOpen(0); // open /dev/gpiochip0int lgGpiochipClose(int handle)This closes an opened gpiochip device.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. Example status = lgGpiochipClose(h); // close gpiochipint lgGpioGetChipInfo(int handle, lgChipInfo_p chipInfo)This returns information about a gpiochip. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0 and updates chipInfo. On failure returns a negative error code. This command gets the number of GPIO on the gpiochip, its name, and its usage. Example lgChipInfo_t cInfo;int lgGpioGetLineInfo(int handle, int gpio, lgLineInfo_p lineInfo)Returns information about a GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0 and updates lineInfo. On failure returns a negative error code. This command gets information for a GPIO of a gpiochip. In particular it gets the GPIO number, kernel usage flags, its user, and its purpose. The usage flags are bits.
The user and purpose fields are filled in by the software which has claimed the GPIO and may be blank. Example lgLineInfo_t lInfo;int lgGpioGetMode(int handle, int gpio)Returns the GPIO mode. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the GPIO mode. On failure returns a negative error code.
int lgGpioSetUser(int handle, const char *gpiouser)This sets the user string to be associated with each claimed GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. Example status = lgGpioSetUser(h, "my_title");int lgGpioClaimInput(int handle, int lFlags, int gpio)This claims a GPIO for input.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The line flags may be used to set the GPIO as active low, open drain, or open source. Example // open GPIO 23 for inputint lgGpioClaimOutput(int handle, int lFlags, int gpio, int level)This claims a GPIO for output.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The line flags may be used to set the GPIO as active low, open drain, or open source. If level is zero the GPIO will be initialised low. If any other value is used the GPIO will be initialised high. Example // open GPIO 31 for high outputint lgGpioClaimAlert(int handle, int lFlags, int eFlags, int gpio, int nfyHandle)This claims a GPIO for alerts on level changes. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The line flags may be used to set the GPIO as active low, open drain, or open source. The event flags are used to specify alerts for a rising edge, falling edge, or both edges. The alerts will be sent to a previously opened notification. If you don't want them sent to a notification set nfyHandle to -1. The alerts will also be sent to any callback registered for the GPIO by lgGpioSetAlertsFunc. All GPIO alerts are also sent to a callback registered by lgGpioSetSamplesFunc. Example status = lgGpioClaimAlert(h, 0, LG_BOTH_EDGES, 16, -1);int lgGpioFree(int handle, int gpio)This frees a GPIO.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The GPIO may now be claimed by another user or for a different purpose. Example status = lgGpioFree(h, 16);int lgGroupClaimInput(int handle, int lFlags, int count, const int *gpios)This claims a group of GPIO for inputs.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The line flags may be used to set the group as active low, open drain, or open source. gpios is an array of one or more GPIO. The first GPIO is called the group leader and is used to reference the group as a whole. Example int buttons[4] = {9, 7, 2, 6};int lgGroupClaimOutput(int handle, int lFlags, int count, const int *gpios, const int *levels)This claims a group of GPIO for outputs.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The line flags may be used to set the group as active low, open drain, or open source. gpios is an array of one or more GPIO. The first GPIO is called the group leader and is used to reference the group as a whole. levels is an array of initialisation values for the GPIO. If a value is zero the corresponding GPIO will be initialised low. If any other value is used the corresponding GPIO will be initialised high. Example int leds[7] = {15, 16, 17, 8, 12, 13, 14};int lgGroupFree(int handle, int gpio)This frees all the GPIO associated with a group.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The GPIO may now be claimed by another user or for a different purpose. Example status = lgGroupFree(9); // free buttonsint lgGpioRead(int handle, int gpio)This returns the level of a GPIO.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0 (low) or 1 (high). On failure returns a negative error code. This command will work for any claimed GPIO (even if a member of a group). For an output GPIO the value returned will be that last written to the GPIO. Example level = lgGpioRead(h, 15); // get level of GPIO 15int lgGpioWrite(int handle, int gpio, int level)This sets the level of an output GPIO.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. This command will work for any GPIO claimed as an output (even if a member of a group). If level is zero the GPIO will be set low (0). If any other value is used the GPIO will be set high (1). Example status = lgGpioWrite(h, 23, 1); // set GPIO 23 highint lgGroupRead(int handle, int gpio, uint64_t *groupBits)This returns the levels read from a group. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the group size and updates groupBits. On failure returns a negative error code. This command will work for an output group as well as an input group. For an output group the value returned will be that last written to the group GPIO. Note that this command will also work on an individual GPIO claimed as an input or output as that is treated as a group with one member. After a successful read groupBits is set as follows. Bit 0 is the level of the group leader. Bit 1 is the level of the second GPIO in the group. Bit x is the level of GPIO x+1 of the group. Example // assuming a read group of 4 buttons: 9, 7, 2, 6.int lgGroupWrite(int handle, int gpio, uint64_t groupBits, uint64_t groupMask)This sets the levels of an output group. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. The values of each GPIO of the group are set according to the bits of groupBits. Bit 0 sets the level of the group leader. Bit 1 sets the level of the second GPIO in the group. Bit x sets the level of GPIO x+1 in the group. However this may be modified by the groupMask. A GPIO is only updated if the corresponding bit in the mask is 1. Example // assuming an output group of 7 LEDs: 15, 16, 17, 8, 12, 13, 14.int lgTxPulse(int handle, int gpio, int pulseOn, int pulseOff, int pulseOffset, int pulseCycles)This starts software timed pulses on an output GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the number of entries left in the PWM queue for the GPIO. On failure returns a negative error code. If both pulseOn and pulseOff are zero pulses will be switched off for that GPIO. The active pulse, if any, will be stopped and any queued pulses will be deleted. Each successful call to this function consumes one PWM queue entry. pulseCycles cycles are transmitted (0 means infinite). Each cycle consists of pulseOn microseconds of GPIO high followed by pulseOff microseconds of GPIO low. PWM is characterised by two values, its frequency (number of cycles per second) and its duty cycle (percentage of high time per cycle). The set frequency will be 1000000 / (pulseOn + pulseOff) Hz. The set duty cycle will be pulseOn / (pulseOn + pulseOff) * 100 %. E.g. if pulseOn is 50 and pulseOff is 100 the frequency will be 6666.67 Hz and the duty cycle will be 33.33 %. pulseOffset is a microsecond offset from the natural start of the PWM cycle. For instance if the PWM frequency is 10 Hz the natural start of each cycle is at seconds 0, then 0.1, 0.2, 0.3 etc. In this case if the offset is 20000 microseconds the cycle will start at seconds 0.02, 0.12, 0.22, 0.32 etc. Another pulse command may be issued to the GPIO before the last has finished. If the last pulse had infinite cycles then it will be replaced by the new settings at the end of the current cycle. Otherwise it will be replaced by the new settings when all its cycles are compete. Multiple pulse settings may be queued in this way. Example slots_left = lgTxPulse(h, 8, 100000, 100000, 0, 0); // flash LED at 5 Hzint lgTxPwm(int handle, int gpio, float pwmFrequency, float pwmDutyCycle, int pwmOffset, int pwmCycles)This starts software timed PWM on an output GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the number of entries left in the PWM queue for the GPIO. On failure returns a negative error code. Each successful call to this function consumes one PWM queue entry. PWM is characterised by two values, its frequency (number of cycles per second) and its duty cycle (percentage of high time per cycle). Another PWM command may be issued to the GPIO before the last has finished. If the last pulse had infinite cycles then it will be replaced by the new settings at the end of the current cycle. Otherwise it will be replaced by the new settings when all its cycles are complete. Multiple PWM settings may be queued in this way. int lgTxServo(int handle, int gpio, int pulseWidth, int servoFrequency, int servoOffset, int servoCycles)This starts software timed servo pulses on an output GPIO.I would only use software timed servo pulses for testing purposes. The timing jitter will cause the servo to fidget. This may cause it to overheat and wear out prematurely. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the number of entries left in the PWM queue for the GPIO. On failure returns a negative error code. Each successful call to this function consumes one PWM queue entry. Another servo command may be issued to the GPIO before the last has finished. If the last pulse had infinite cycles then it will be replaced by the new settings at the end of the current cycle. Otherwise it will be replaced by the new settings when all its cycles are compete. Multiple servo settings may be queued in this way. int lgTxWave(int handle, int gpio, int count, lgPulse_p pulses)This starts a wave on an output group of GPIO.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the number of entries left in the wave queue for the group. On failure returns a negative error code. Each successful call to this function consumes one queue entry. This command starts a wave of pulses. pulses is an array of pulses to be transmitted on the group. Each pulse is defined by the following triplet: bits: the levels to set for the selected GPIO mask: the GPIO to select delay: the delay in microseconds before the next pulse Another wave command may be issued to the group before the last has finished transmission. The new wave will start when the previous wave has competed. Multiple waves may be queued in this way. Example #include <stdio.h>int lgTxBusy(int handle, int gpio, int kind)This returns true if transmissions of the specified kind are active on the GPIO or group.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 1 for busy and 0 for not busy. On failure returns a negative error code. Example while (lgTxBusy(h, 15, LG_TX_PWM)) // wait for PWM to finish on GPIO 15int lgTxRoom(int handle, int gpio, int kind)This returns the number of entries available for queueing transmissions of the specified kind on the GPIO or group.handle: >= 0 (as returned by lgGpiochipOpen)If OK returns the number of free entries (0 if none). On failure returns a negative error code. Example while (lgTxRoom(h, 17, LG_TX_WAVE) > 0))int lgGpioSetDebounce(int handle, int gpio, int debounce_us)This sets the debounce time for a GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. This only affects alerts. An alert will only be issued if the edge has been stable for at least debounce microseconds. Generally this is used to debounce mechanical switches (e.g. contact bounce). Suppose that a square wave at 5 Hz is being generated on a GPIO. Each edge will last 100000 microseconds. If a debounce time of 100001 is set no alerts will be generated, If a debounce time of 99999 is set 10 alerts will be generated per second. Note that level changes will be timestamped debounce microseconds after the actual level change. Example lgSetDebounceTime(h, 16, 1000); // set a millisecond of debounceint lgGpioSetWatchdog(int handle, int gpio, int watchdog_us)This sets the watchdog time for a GPIO. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. This only affects alerts. A watchdog alert will be sent if no edge alert has been issued for that GPIO in the previous watchdog microseconds. Note that only one watchdog alert will be sent per stream of edge alerts. The watchdog is reset by the sending of a new edge alert. The level is set to LG_TIMEOUT (2) for a watchdog alert. Example lgSetWatchdogTime(h, 17, 200000); // alert if nothing for 0.2 secondsint lgGpioSetAlertsFunc(int handle, int gpio, lgGpioAlertsFunc_t cbf, void *userdata)This sets up a callback to be called when an alert GPIO changes state. handle: >= 0 (as returned by lgGpiochipOpen)If OK returns 0. On failure returns a negative error code. Example #include <stdio.h>Assuming square wave at 800 Hz is being received at GPIO 23. u=123 ts=1602089980691229623 c=0 g=23 l=1 f=0 (1 of 1)void lgGpioSetSamplesFunc(lgGpioAlertsFunc_t cbf, void *userdata)This sets up a callback to be called when any alert GPIO changes state. cbf: the callback functionIf OK returns 0. On failure returns a negative error code. Note that no handle or gpio is specified. The callback function will receive alerts for all gpiochips and gpio. Example #include <stdio.h>Assuming square wave at 800 Hz is being received at GPIO 23, 24, 25. u=456 ts=1602090898869011679 c=0 g=24 l=1 f=0 (1 of 3)int lgNotifyOpen(void)This function requests a free notification.If OK returns a handle (>= 0). On failure returns a negative error code. A notification is a method for being notified of GPIO state changes via a pipe or socket. The notification pipes are created in the library working directory (see lguGetWorkDir). Pipe notifications for handle x will be available at the pipe named .lgd-nfy* (where * is the handle number). E.g. if the function returns 15 then the notifications must be read from .lgd-nfy15. Socket notifications are returned to the socket which requested the handle. Example h = lgNotifyOpen();int lgNotifyResume(int handle)This function restarts notifications on a paused notification.handle: >= 0 (as returned by lgNotifyOpen)If OK returns 0. On failure returns a negative error code. The notification gets state changes for each associated GPIO. Each notification occupies 16 bytes in the fifo and has the following structure. typedef structtimestamp: the number of nanoseconds since the epoch (start of 1970) level: indicates the level of the GPIO flags: no flags are currently defined For future proofing it is probably best to ignore any notification with non-zero flags. Example // Start notifications for associated GPIO.int lgNotifyPause(int handle)This function pauses notifications.handle: >= 0 (as returned by lgNotifyOpen)If OK returns 0. On failure returns a negative error code. Notifications are suspended until lgNotifyResume is called. Example lgNotifyPause(h);int lgNotifyClose(int handle)This function stops notifications and frees the handle for reuse.handle: >= 0 (as returned by lgNotifyOpen)If OK returns 0. On failure returns a negative error code. Example lgNotifyClose(h);int lgI2cOpen(int i2cDev, int i2cAddr, int i2cFlags)This returns a handle for the device at the address on the I2C bus. i2cDev: >= 0If OK returns a handle (>= 0). On failure returns a negative error code. No flags are currently defined. This parameter should be set to zero. 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 bitint lgI2cClose(int handle)This closes the I2C device.handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. int lgI2cWriteQuick(int handle, int bitVal)This sends a single bit (in the Rd/Wr bit) to the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. Quick command. SMBus 2.0 5.5.1 S Addr bit [A] Pint lgI2cWriteByte(int handle, int byteVal)This sends a single byte to the device. handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. Send byte. SMBus 2.0 5.5.2 S Addr Wr [A] bVal [A] Pint lgI2cReadByte(int handle)This reads a single byte from the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns the byte read (0-255). On failure returns a negative error code. Receive byte. SMBus 2.0 5.5.3 S Addr Rd [A] [Data] NA Pint lgI2cWriteByteData(int handle, int i2cReg, int byteVal)This writes a single byte to the specified register of the device. handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. Write byte. SMBus 2.0 5.5.4 S Addr Wr [A] i2cReg [A] bVal [A] Pint lgI2cWriteWordData(int handle, int i2cReg, int wordVal)This writes a single 16 bit word to the specified register of the device. handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. Write word. SMBus 2.0 5.5.4 S Addr Wr [A] i2cReg [A] wValLow [A] wValHigh [A] Pint lgI2cReadByteData(int handle, int i2cReg)This reads a single byte from the specified register of the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns the byte read (0-255). On failure returns a negative error code. Read byte. SMBus 2.0 5.5.5 S Addr Wr [A] i2cReg [A] S Addr Rd [A] [Data] NA Pint lgI2cReadWordData(int handle, int i2cReg)This reads a single 16 bit word from the specified register of the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns the word read (0-65535). On failure returns a negative error code. Read word. SMBus 2.0 5.5.5 S Addr Wr [A] i2cReg [A] S Addr Rd [A] [DataLow] A [DataHigh] NA Pint lgI2cProcessCall(int handle, int i2cReg, int wordVal)This writes 16 bits of data to the specified register of the device and reads 16 bits of data in return. handle: >= 0 (as returned by lgI2cOpen)If OK returns the word read (0-65535). On failure returns a negative error code. Process call. SMBus 2.0 5.5.6 S Addr Wr [A] i2cReg [A] wValLow [A] wValHigh [A]int lgI2cWriteBlockData(int handle, int i2cReg, const char *txBuf, int count)This writes up to 32 bytes to the specified register of the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. Block write. SMBus 2.0 5.5.7 S Addr Wr [A] i2cReg [A] count [A]int lgI2cReadBlockData(int handle, int i2cReg, char *rxBuf)This reads a block of up to 32 bytes from the specified register of the device.handle: >= 0 (as returned by lgI2cOpen)The amount of returned data is set by the device. If OK returns the count of bytes read (0-32) and updates rxBuf. On failure returns a negative error code. Block read. SMBus 2.0 5.5.7 S Addr Wr [A] i2cReg [A]int lgI2cBlockProcessCall(int handle, int i2cReg, char *ioBuf, int count)This writes data bytes to the specified register of the device and reads a device specified number of bytes of data in return.handle: >= 0 (as returned by lgI2cOpen)If OK returns the count of bytes read (0-32) and updates ioBuf. On failure returns a negative error code. The SMBus 2.0 documentation states that a minimum of 1 byte may be sent and a minimum of 1 byte may be received. The total number of bytes sent/received must be 32 or less. Block write-block read. SMBus 2.0 5.5.8 S Addr Wr [A] i2cReg [A] count [A] ioBuf0 [A] ... ioBufn [A]int lgI2cReadI2CBlockData(int handle, int i2cReg, char *rxBuf, int count)This reads count bytes from the specified register of the device. The count may be 1-32.handle: >= 0 (as returned by lgI2cOpen)If OK returns the count of bytes read (0-32) and updates rxBuf. On failure returns a negative error code. S Addr Wr [A] i2cReg [A]int lgI2cWriteI2CBlockData(int handle, int i2cReg, const char *txBuf, int count)This writes 1 to 32 bytes to the specified register of the device.handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. S Addr Wr [A] i2cReg [A] txBuf0 [A] txBuf1 [A] ... [A] txBufn [A] Pint lgI2cReadDevice(int handle, char *rxBuf, int count)This reads count bytes from the raw device into rxBuf.handle: >= 0 (as returned by lgI2cOpen)If OK returns count (>0) and updates rxBuf. On failure returns a negative error code. S Addr Rd [A] [rxBuf0] A [rxBuf1] A ... A [rxBufn] NA Pint lgI2cWriteDevice(int handle, const char *txBuf, int count)This writes count bytes from txBuf to the raw device.handle: >= 0 (as returned by lgI2cOpen)If OK returns 0. On failure returns a negative error code. S Addr Wr [A] txBuf0 [A] txBuf1 [A] ... [A] txBufn [A] Pint lgI2cSegments(int handle, lgI2cMsg_t *segs, int count)This function executes multiple I2C segments in one transaction by calling the I2C_RDWR ioctl.handle: >= 0 (as returned by lgI2cOpen)If OK returns the number of segments executed. On failure returns a negative error code. int lgI2cZip(int handle, const char *txBuf, int txCount, char *rxBuf, int rxCount)This function executes a sequence of I2C operations. The operations to be performed are specified by the contents of txBuf which contains the concatenated command codes and associated data. handle: >= 0 (as returned by lgI2cOpen)If OK returns the count of bytes read (which may be 0) and updates rxBuf. On failure returns a negative error code. 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. The returned I2C data is stored in consecutive locations of rxBuf. Example Set address 0x53, write 0x32, read 6 bytesint lgSerialOpen(const char *serDev, int serBaud, int serFlags)This function opens a serial device at a specified baud rate and with specified flags. The device must be present in /dev. serDev: the serial device to openIf OK returns a handle (>= 0). On failure returns a negative error code. The baud rate must be one of 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200, or 230400. No flags are currently defined. This parameter should be set to zero. int lgSerialClose(int handle)This function closes the serial device.handle: >= 0 (as returned by lgSerialOpen)If OK returns 0. On failure returns a negative error code. int lgSerialWriteByte(int handle, int byteVal)This function writes the byte to the serial device. handle: >= 0 (as returned by lgSerialOpen)If OK returns 0. On failure returns a negative error code. int lgSerialReadByte(int handle)This function reads a byte from the serial device.handle: >= 0 (as returned by lgSerialOpen)If OK returns the byte read (0-255). On failure returns a negative error code. int lgSerialWrite(int handle, const char *txBuf, int count)This function writes count bytes from txBuf to the the serial device.handle: >= 0 (as returned by lgSerialOpen)If OK returns 0. On failure returns a negative error code. int lgSerialRead(int handle, char *rxBuf, int count)This function reads up count bytes from the the serial device and writes them to rxBuf.handle: >= 0 (as returned by lgSerialOpen)If OK returns the count of bytes read (>= 0) and updates rxBuf. On failure returns a negative error code. int lgSerialDataAvailable(int handle)This function returns the count of bytes available to be read from the device.handle: >= 0 (as returned by lgSerialOpen)If OK returns the count of bytes available(>= 0). On failure returns a negative error code. int lgSpiOpen(int spiDev, int spiChan, int spiBaud, int spiFlags)This function returns a handle for the SPI device on the channel. spiDev: >= 0If OK returns a handle (>= 0). On failure returns a negative error code. The flags may be used to modify the default behaviour. spiFlags consists of the least significant 2 bits. 1 0mm defines the SPI mode. Mode POL PHAThe other bits in flags should be set to zero. int lgSpiClose(int handle)This functions closes the SPI device.handle: >= 0 (as returned by lgSpiOpen)If OK returns 0. On failure returns a negative error code. int lgSpiRead(int handle, char *rxBuf, int count)This function reads count bytes of data from the SPI device.handle: >= 0 (as returned by lgSpiOpen)If OK returns the count of bytes read and updates rxBuf. On failure returns a negative error code. int lgSpiWrite(int handle, const char *txBuf, int count)This function writes count bytes of data from txBuf to the SPI device.handle: >= 0 (as returned by lgSpiOpen)If OK returns the count of bytes written. On failure returns a negative error code. int lgSpiXfer(int handle, const char *txBuf, char *rxBuf, int count)This function transfers count bytes of data from txBuf to the SPI device. Simultaneously count bytes of data are read from the device and placed in rxBuf.handle: >= 0 (as returned by lgSpiOpen)If OK returns the count of bytes transferred and updates rxBuf. On failure returns a negative error code. pthread_t *lgThreadStart(lgThreadFunc_t f, void *userdata)Starts a new thread of execution with f as the main routine. f: the main function for the new threadIf OK returns a pointer to a pthread_t. On failure returns NULL. The function is passed the single argument arg. The thread can be cancelled by passing the pointer to pthread_t to lgThreadStop. Example #include <stdio.h>void lgThreadStop(pthread_t *pth)Cancels the thread pointed at by pth.pth: a thread pointer (as returned by lgThreadStart)No value is returned. The thread to be stopped should have been started with lgThreadStart. uint64_t lguTimestamp(void)Returns the current timestamp.The timestamp is the number of nanoseconds since the epoch (start of 1970). double lguTime(void)Returns the current time.The time is the number of seconds since the epoch (start of 1970). void lguSleep(double sleepSecs)Sleeps for the specified number of seconds.sleepSecs: how long to sleep in secondsint lguSbcName(char *rxBuf, int count)Copies the host name of the machine running the lgpio library to the supplied buffer. Up to count characters are copied.rxBuf: a buffer to receive the host nameIf OK returns the count of bytes copied and updates rxBuf. On failure returns a negative error code. int lguVersion(void)Returns the lgpiolibrary version number.int lguGetInternal(int cfgId, uint64_t *cfgVal)Get an internal configuration value. cfgId: the item.If OK returns 0 and updates cfgVal. On failure returns a negative error code. int lguSetInternal(int cfgId, uint64_t cfgVal)Set an internal configuration value. cfgId: the itemIf OK returns 0. On failure returns a negative error code. const char *lguErrorText(int error)Returns the error text for an error code.error: the error codevoid lguSetWorkDir(const char *dirPath)Sets the library working directory.This function has no affect if the working directory has already been set. dirPath: the directory to set as the working directoryIf dirPath does not start with a / the directory is relative to the library launch directory. const char *lguGetWorkDir(void)Returns the library working directory.PARAMETERSbitValA value of 0 or 1.byteVal: 0-255An 8-bit byte value.cbfAn alerts callback function.cfgIdA number identifying a configuration item.LG_CFG_ID_DEBUG_LEVEL 0cfgValThe value of a configuration item.*cfgValThe value of a configuration item.charA single character, an 8 bit quantity able to store 0-255.chipInfoA pointer to a lgChipInfo_t object.countThe number of items.debounce_usThe debounce time in microseconds.*dirPathA directory path which.doubleA floating point number.eFlagsThe type of GPIO edge to generate an alert. See lgGpioClaimAlert. LG_RISING_EDGEerrorAn error code. All error codes are negative.fA function.floatA floating point numbergpioA GPIO number, the offset of the GPIO from the base of the gpiochip. Offsets start at 0.gpioDev: >= 0The device number of a gpiochip.*gpiosAn array of GPIO numbers.*gpiouserA string of up to 32 characters denoting the user of a GPIO.groupBitsA 64-bit value used to set the levels of a group.Set bit x to set GPIO x of the group high. Clear bit x to set GPIO x of the group low. *groupBitsA 64-bit value denoting the levels of a group.If bit x is set then GPIO x of the group is high. groupMaskA 64-bit value used to determine which members of a group should be updated.Set bit x to update GPIO x of the group. Clear bit x to leave GPIO x of the group unaltered. handle: >= 0A number referencing an object opened by one of lgGpiochipOpen lgI2cOpen lgNotifyOpen lgSerialOpen lgSpiOpen i2cAddr: 0-0x7FThe address of a device on the I2C bus.i2cDev: >= 0An I2C device number.i2cFlags: 0Flags which modify an I2C open command. None are currently defined.i2cReg: 0-255A register of an I2C device.intA whole number, negative or positive.*ioBufA pointer to a buffer used to hold data to send and the data received.kind: LG_TX_PWM or LG_TX_WAVEA type of transmission: PWM or wave.levelA GPIO level (0 or 1).*levelsAn array of GPIO levels.lFlagsline flags for the GPIO. The following values may be or'd to form the value. LG_SET_ACTIVE_LOWlgChipInfo_pA pointer to a lgChipInfo_t object.typedef struct lgChipInfo_slgGpioAlert_ttypedef struct lgGpioAlert_sSee lgGpioReport_t. lgGpioAlertsFunc_ttypedef void (*lgGpioAlertsFunc_t)See lgGpioAlert_t. lgGpioReport_ttypedef structlgI2cMsg_ttypedef structlgLineInfo_pA pointer to a lgLineInfo_t object.typedef struct lgLine_slgPulse_pA pointer to a lgPulse_t object.typedef struct lgPulse_slgThreadFunc_ttypedef void *(lgThreadFunc_t) (void *);lineInfoA pointer to a lgLineInfo_t object.nfyHandle: >= 0This associates a notification with a GPIO alert.*pthA thread identifier, returned by lgGpioStartThread.pthread_tA thread identifier.pulseCycles: >= 0The number of PWM pulses to generate. A value of 0 means infinite.pulseOff: >= 0The off period for a PWM pulse in microseconds.pulseOffset: >= 0The offset in microseconds from the nominal PWM pulse start.pulseOn: >= 0The on period for a PWM pulse in microseconds.pulsesAn pointer to an array of lgPulse_t objects.pulseWidth: 0, 500-2500 microsecondsServo pulse widthpwmCycles: >= 0The number of PWM pulses to generate. A value of 0 means infinite.pwmDutyCycle: 0-100 %PWM duty cycle %pwmFrequency: 0.1-10000 HzPWM frequencypwmOffset: >= 0The offset in microseconds from the nominal PWM pulse start.*rxBufA pointer to a buffer used to receive data.rxCountThe size of an input buffer.*segsAn array of segments which make up a combined I2C transaction.serBaudThe speed of serial communication in bits per second.*serDevThe name of a serial tty device, e.g. /dev/ttyAMA0, /dev/ttyUSB0, /dev/tty1.serFlagsFlags which modify a serial open command. None are currently defined.servoCycles: >= 0The number of servo pulses to generate. A value of 0 means infinite.servoFrequency: 40-500 HzServo pulse frequencyservoOffset: >= 0The offset in microseconds from the nominal servo pulse start.sleepSecs: >= 0.0The number of seconds to sleep (may be fractional).spiBaudThe speed of serial communication in bits per second.spiChanA SPI channel, >= 0.spiDevA SPI device, >= 0.spiFlagsSee lgSpiOpen.*txBufAn pointer to a buffer of data to transmit.txCountThe size of an output buffer.uint64_tA 64-bit unsigned value.*userdataA pointer to arbitrary user data. This may be used to identify the instance.You must ensure that the pointer is in scope at the time it is processed. If it is a pointer to a global this is automatic. Do not pass the address of a local variable. If you want to pass a transient object then use the following technique. In the calling function: user_type *userdata;In the receiving function: user_type my_userdata = *(user_type*)userdata;voidDenoting no parameter is required.watchdog_usThe watchdog time in microseconds.wordVal: 0-65535A 16-bit value.Error Codes |
[lg]
[lgpio C]
[lgpio Python]
[Daemon]
[rgpio C]
[rgpio Python]
[rgs]
[Download]
[Examples]
[FAQ]
[Site Map]
© 2020-2021 |
(2021-01-16 21:12) |