Communication Bus

[中文]

The communication bus component (Bus) is a set of application-layer code built on top of the ESP-IDF peripheral driver code, including i2c_bus, spi_bus and etc. It is mainly used for bus communication between ESP chips and external devices. From the point of application development, this component has the following features:

  1. Simplified peripheral initialization processes

  2. Thread-safe device operations

  3. Simple and flexible RW operations

This component abstracts the following concepts:

  1. Bus: the resource and configuration option shared between devices during communication

  2. Device: device specific resource and configuration option during communication

Each physical peripheral bus can mount one or more devices if the electrical condition allows, with the SPI bus addressing devices based on CS pins and the I2C bus addressing devices based on their addresses, thus achieving software independence between different devices on the same bus.

../_images/i2c_bus.png

i2c_bus Connection Diagram

../_images/spi_bus.png

spi_bus Connection Diagram

How to Use i2c_bus

  1. Create a bus: create a bus object using i2c_bus_create(). During the process, you need to specify the I2C port number and the bus configuration option i2c_config_t, which includes SDA and SCL pin numbers, pull-up and pull-down modes, as these are determined when the system is designed and normally will not be changed at runtime. The bus configuration option also includes the default clock frequency of the bus, which is used when the device does not specify a frequency.

  2. Create a device: use i2c_bus_device_create() to create a device on the bus object created in the first step. During the process, you need to specify bus handle, the I2C address of the device, and the clock frequency when the device is running. The frequency will be dynamically changed during I2C transmission based on device configuration options. The device clock frequency can be configured as 0, indicating the current bus frequency is used by default.

  3. Data reading: use i2c_bus_read_byte() or i2c_bus_read_bytes() to read Byte data; use i2c_bus_read_bit() or i2c_bus_read_bits() to read bit data. During the process, you only need to pass in the device handle, the device register address, a buffer to hold the read data, the read length, etc. The register address can be configured as NULL_I2C_MEM_ADDR for devices without internal registers.

  4. Data writing: use i2c_bus_write_byte() or i2c_bus_write_bytes() to write Byte data; use i2c_bus_write_bit() or i2c_bus_write_bits() to write bit data. During the process, you only need to pass in the device handle, the device register address, the data location to be written, the write length, etc. The register address can be configured as NULL_I2C_MEM_ADDR for devices without internal registers.

  5. Delete device and bus: if all i2c_bus communication has been completed, you can free your system resources by deleting devices and bus objects. Use i2c_bus_device_delete() to delete created devices respectively, then use i2c_bus_delete() to delete bus resources. If the bus is deleted with the device not being deleted yet, this operation will not take effect.

Example:

i2c_config_t conf = {
    .mode = I2C_MODE_MASTER,
    .sda_io_num = I2C_MASTER_SDA_IO,
    .sda_pullup_en = GPIO_PULLUP_ENABLE,
    .scl_io_num = I2C_MASTER_SCL_IO,
    .scl_pullup_en = GPIO_PULLUP_ENABLE,
    .master.clk_speed = 100000,
}; // i2c_bus configurations

uint8_t data_rd[2] = {0};
uint8_t data_wr[2] = {0x01, 0x21};

i2c_bus_handle_t i2c0_bus = i2c_bus_create(I2C_NUM_0, &conf); // create i2c_bus
i2c_bus_device_handle_t i2c_device1 = i2c_bus_device_create(i2c0_bus, 0x28, 400000); // create device1, address: 0x28 , clk_speed: 400000
i2c_bus_device_handle_t i2c_device2 = i2c_bus_device_create(i2c0_bus, 0x32, 0); // create device2, address: 0x32 , clk_speed: no-specified

i2c_bus_read_bytes(i2c_device1, NULL_I2C_MEM_ADDR, 2, data_rd); // read bytes from device1 with no register address
i2c_bus_write_bytes(i2c_device2, 0x10, 2, data_wr); // write bytes to device2 register 0x10

i2c_bus_device_delete(&i2c_device1); //delete device1
i2c_bus_device_delete(&i2c_device2); //delete device2
i2c_bus_delete(&i2c0_bus);  //delete i2c_bus

Note

For some special application scenarios:

  1. When the address of a register is 16-bit, you can use i2c_bus_read_reg16() or i2c_bus_write_reg16() to read or write its data;

  2. For devices that need to skip the address phase or need to add a command phase, you can operate using i2c_bus_cmd_begin() combined with I2C command link.

How to Use spi_bus

  1. Create a bus: use spi_bus_create() to create a bus object. During the process, you need to specify the SPI port number (can choose between SPI2_HOST and SPI3_HOST) and the bus configuration option spi_config_t, which includes the pin numbers of MOSI, MISO and SCLK, as these are determined when the system is designed and normally will not be changed at runtime. The bus configuration option also includes max_transfer_sz to configure the maximum data size during a transmission. When max_transfer_sz is configured to 0, it means the maximum size will be the default value 4096.

  2. Create a device: use spi_bus_device_create() to create a device on the bus object created in the first step. During the process, you need to specify the bus handle, the CS pin number of the device, device operation mode, the clock frequency when the device is running. The device mode and frequency will be dynamically changed during SPI transmissions based on device configuration options.

  3. Data transmission: use spi_bus_transfer_byte(), spi_bus_transfer_bytes(), spi_bus_transfer_reg16() or spi_bus_transfer_reg32() to transfer data directly. Data send and receive can be operated at the same time since SPI communication is a full-duplex communication. During the process, you only need to pass in the device handle, data to be transmitted, a buffer to hold the read data, transmission length, etc.

  4. Delete device and bus: if all spi_bus communication has been completed, you can free your system resources by deleting devices and bus objects. Use spi_bus_device_delete() to delete created devices respectively, then use spi_bus_delete() to delete bus resources. If the bus is deleted with the device not being deleted yet, this operation will not take effect.

Example:

spi_bus_handle_t bus_handle = NULL;
spi_bus_device_handle_t device_handle = NULL;
uint8_t data8_in = 0;
uint8_t data8_out = 0xff;
uint16_t data16_in = 0;
uint32_t data32_in = 0;

spi_config_t bus_conf = {
    .miso_io_num = 19,
    .mosi_io_num = 23,
    .sclk_io_num = 18,
}; // spi_bus configurations

spi_device_config_t device_conf = {
    .cs_io_num = 19,
    .mode = 0,
    .clock_speed_hz = 20 * 1000 * 1000,
}; // spi_device configurations

bus_handle = spi_bus_create(SPI2_HOST, &bus_conf); // create spi bus
device_handle = spi_bus_device_create(bus_handle, &device_conf); // create spi device

spi_bus_transfer_bytes(device_handle, &data8_out, &data8_in, 1); // transfer 1 byte with spi device
spi_bus_transfer_bytes(device_handle, NULL, &data8_in, 1); // only read 1 byte with spi device
spi_bus_transfer_bytes(device_handle, &data8_out, NULL, 1); // only write 1 byte with spi device
spi_bus_transfer_reg16(device_handle, 0x1020, &data16_in); // transfer 16-bit value with the device
spi_bus_transfer_reg32(device_handle, 0x10203040, &data32_in); // transfer 32-bit value with the device

spi_bus_device_delete(&device_handle);
spi_bus_delete(&bus_handle);

Note

For some special application scenarios, you can operate using spi_bus_transmit_begin() combined with spi_transaction_t directly.

Adapted IDF Versions

  • ESP-IDF v4.0 and later versions.

Supported Chips

  • ESP32

  • ESP32-S2

API Reference

i2c_bus API Reference

Header File

Functions

i2c_bus_handle_t i2c_bus_create(i2c_port_t port, const i2c_config_t *conf)

Create an I2C bus instance then return a handle if created successfully. Each I2C bus works in a singleton mode, which means for an i2c port only one group parameter works. When i2c_bus_create is called more than one time for the same i2c port, following parameter will override the previous one.

Return

i2c_bus_handle_t Return the I2C bus handle if created successfully, return NULL if failed.

Parameters
  • port: I2C port number

  • conf: Pointer to I2C bus configuration

esp_err_t i2c_bus_delete(i2c_bus_handle_t *p_bus_handle)

Delete and release the I2C bus resource.

Return

  • ESP_OK Success

  • ESP_FAIL Fail

Parameters
  • p_bus_handle: Point to the I2C bus handle, if delete succeed handle will set to NULL.

uint8_t i2c_bus_scan(i2c_bus_handle_t bus_handle, uint8_t *buf, uint8_t num)

Scan i2c devices attached on i2c bus.

Return

uint8_t Total number of devices found on the I2C bus

Parameters
  • bus_handle: I2C bus handle

  • buf: Pointer to a buffer to save devices’ address, if NULL no address will be saved.

  • num: Maximum number of addresses to save, invalid if buf set to NULL, higer addresses will be discarded if num less-than the total number found on the I2C bus.

uint32_t i2c_bus_get_current_clk_speed(i2c_bus_handle_t bus_handle)

Get current active clock speed.

Return

uint32_t current clock speed

Parameters
  • bus_handle: I2C bus handle

uint8_t i2c_bus_get_created_device_num(i2c_bus_handle_t bus_handle)

Get created device number of the bus.

Return

uint8_t created device number of the bus

Parameters
  • bus_handle: I2C bus handle

i2c_bus_device_handle_t i2c_bus_device_create(i2c_bus_handle_t bus_handle, uint8_t dev_addr, uint32_t clk_speed)

Create an I2C device on specific bus. Dynamic configuration must be enable to achieve multiple devices with different configs on a single bus. menuconfig:Bus Options->I2C Bus Options->enable dynamic configuration.

Return

i2c_bus_device_handle_t return a device handle if created successfully, return NULL if failed.

Parameters
  • bus_handle: Point to the I2C bus handle

  • dev_addr: i2c device address

  • clk_speed: device specified clock frequency the i2c_bus will switch to during each transfer. 0 if use current bus speed.

esp_err_t i2c_bus_device_delete(i2c_bus_device_handle_t *p_dev_handle)

Delete and release the I2C device resource, i2c_bus_device_delete should be used in pairs with i2c_bus_device_create.

Return

  • ESP_OK Success

  • ESP_FAIL Fail

Parameters
  • p_dev_handle: Point to the I2C device handle, if delete succeed handle will set to NULL.

uint8_t i2c_bus_device_get_address(i2c_bus_device_handle_t dev_handle)

Get device’s I2C address.

Return

uint8_t I2C address, return NULL_I2C_DEV_ADDR if dev_handle is invalid.

Parameters
  • dev_handle: I2C device handle

esp_err_t i2c_bus_read_byte(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t *data)

Read single byte from i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to read from, set to NULL_I2C_MEM_ADDR if no internal address.

  • data: Pointer to a buffer to save the data that was read

esp_err_t i2c_bus_read_bytes(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, size_t data_len, uint8_t *data)

Read multiple bytes from i2c device with 8-bit internal register/memory address. If internal reg/mem address is 16-bit, please refer i2c_bus_read_reg16.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to read from, set to NULL_I2C_MEM_ADDR if no internal address.

  • data_len: Number of bytes to read

  • data: Pointer to a buffer to save the data that was read

esp_err_t i2c_bus_read_bit(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t bit_num, uint8_t *data)

Read single bit of a byte from i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to read from, set to NULL_I2C_MEM_ADDR if no internal address.

  • bit_num: The bit number 0 - 7 to read

  • data: Pointer to a buffer to save the data that was read. *data == 0 -> bit = 0, *data !=0 -> bit = 1.

esp_err_t i2c_bus_read_bits(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t bit_start, uint8_t length, uint8_t *data)

Read multiple bits of a byte from i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to read from, set to NULL_I2C_MEM_ADDR if no internal address.

  • bit_start: The bit to start from, 0 - 7, MSB at 0

  • length: The number of bits to read, 1 - 8

  • data: Pointer to a buffer to save the data that was read

esp_err_t i2c_bus_write_byte(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t data)

Write single byte to i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to write to, set to NULL_I2C_MEM_ADDR if no internal address.

  • data: The byte to write.

esp_err_t i2c_bus_write_bytes(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, size_t data_len, const uint8_t *data)

Write multiple byte to i2c device with 8-bit internal register/memory address If internal reg/mem address is 16-bit, please refer i2c_bus_write_reg16.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to write to, set to NULL_I2C_MEM_ADDR if no internal address.

  • data_len: Number of bytes to write

  • data: Pointer to the bytes to write.

esp_err_t i2c_bus_write_bit(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t bit_num, uint8_t data)

Write single bit of a byte to an i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to write to, set to NULL_I2C_MEM_ADDR if no internal address.

  • bit_num: The bit number 0 - 7 to write

  • data: The bit to write, data == 0 means set bit = 0, data !=0 means set bit = 1.

esp_err_t i2c_bus_write_bits(i2c_bus_device_handle_t dev_handle, uint8_t mem_address, uint8_t bit_start, uint8_t length, uint8_t data)

Write multiple bits of a byte to an i2c device with 8-bit internal register/memory address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal reg/mem address to write to, set to NULL_I2C_MEM_ADDR if no internal address.

  • bit_start: The bit to start from, 0 - 7, MSB at 0

  • length: The number of bits to write, 1 - 8

  • data: The bits to write.

esp_err_t i2c_bus_cmd_begin(i2c_bus_device_handle_t dev_handle, i2c_cmd_handle_t cmd)

I2C master send queued commands create by i2c_cmd_link_create . This function will trigger sending all queued commands. The task will be blocked until all the commands have been sent out. If I2C_BUS_DYNAMIC_CONFIG enable, i2c_bus will dynamically check configs and re-install i2c driver before each transfer, hence multiple devices with different configs on a single bus can be supported.

Note

Only call this function when i2c_bus_read/write_xx do not meet the requirements

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • cmd: I2C command handler

esp_err_t i2c_bus_write_reg16(i2c_bus_device_handle_t dev_handle, uint16_t mem_address, size_t data_len, const uint8_t *data)

Write date to an i2c device with 16-bit internal reg/mem address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal 16-bit reg/mem address to write to, set to NULL_I2C_MEM_ADDR if no internal address.

  • data_len: Number of bytes to write

  • data: Pointer to the bytes to write.

esp_err_t i2c_bus_read_reg16(i2c_bus_device_handle_t dev_handle, uint16_t mem_address, size_t data_len, uint8_t *data)

Read date from i2c device with 16-bit internal reg/mem address.

Return

esp_err_t

  • ESP_OK Success

  • ESP_ERR_INVALID_ARG Parameter error

  • ESP_FAIL Sending command error, slave doesn’t ACK the transfer.

  • ESP_ERR_INVALID_STATE I2C driver not installed or not in master mode.

  • ESP_ERR_TIMEOUT Operation timeout because the bus is busy.

Parameters
  • dev_handle: I2C device handle

  • mem_address: The internal 16-bit reg/mem address to read from, set to NULL_I2C_MEM_ADDR if no internal address.

  • data_len: Number of bytes to read

  • data: Pointer to a buffer to save the data that was read

Macros

NULL_I2C_MEM_ADDR

set mem_address to NULL_I2C_MEM_ADDR if i2c device has no internal address during read/write

NULL_I2C_DEV_ADDR

invalid i2c device address

Type Definitions

typedef void *i2c_bus_handle_t

i2c bus handle

typedef void *i2c_bus_device_handle_t

i2c device handle

spi_bus API Reference

Header File

Functions

spi_bus_handle_t spi_bus_create(spi_host_device_t host_id, const spi_config_t *bus_conf)

Create and initialize a spi bus and return the spi bus handle.

Return

spi_bus_handle_t handle for spi bus operation, NULL if failed.

Parameters
  • host_id: SPI peripheral that controls this bus, SPI2_HOST or SPI3_HOST

  • bus_conf: spi bus configurations details in spi_config_t

esp_err_t spi_bus_delete(spi_bus_handle_t *p_bus_handle)

Deinitialize and delete the spi bus.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_FAIL Fail

  • ESP_OK Success

Parameters
  • p_bus_handle: pointer to spi bus handle, if delete succeed handle will set to NULL.

spi_bus_device_handle_t spi_bus_device_create(spi_bus_handle_t bus_handle, const spi_device_config_t *device_conf)

Create and add a device on the spi bus.

Return

spi_bus_device_handle_t handle for device operation, NULL if failed.

Parameters
  • bus_handle: handle for spi bus operation.

  • device_conf: spi device configurations details in spi_device_config_t

esp_err_t spi_bus_device_delete(spi_bus_device_handle_t *p_dev_handle)

Deinitialize and remove the device from spi bus.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_FAIL Fail

  • ESP_OK Success

Parameters
  • p_dev_handle: pointer to device handle, if delete succeed handle will set to NULL.

esp_err_t spi_bus_transfer_byte(spi_bus_device_handle_t dev_handle, uint8_t data_out, uint8_t *data_in)

Transfer one byte with the device.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_ERR_TIMEOUT if bus is busy

  • ESP_OK on success

Parameters
  • dev_handle: handle for device operation.

  • data_out: data will send to device.

  • data_in: pointer to receive buffer, set NULL to skip receive phase.

esp_err_t spi_bus_transfer_bytes(spi_bus_device_handle_t dev_handle, const uint8_t *data_out, uint8_t *data_in, uint32_t data_len)

Transfer multi-bytes with the device.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_ERR_TIMEOUT if bus is busy

  • ESP_OK on success

Parameters
  • dev_handle: handle for device operation.

  • data_out: pointer to sent buffer, set NULL to skip sent phase.

  • data_in: pointer to receive buffer, set NULL to skip receive phase.

  • data_len: number of bytes will transfer.

esp_err_t spi_bus_transmit_begin(spi_bus_device_handle_t dev_handle, spi_transaction_t *p_trans)

Send a polling transaction, wait for it to complete, and return the result.

Note

Only call this function when spi_bus_transfer_xx do not meet the requirements

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_ERR_TIMEOUT if bus is busy

  • ESP_OK on success

Parameters
  • dev_handle: handle for device operation.

  • p_trans: Description of transaction to execute

esp_err_t spi_bus_transfer_reg16(spi_bus_device_handle_t dev_handle, uint16_t data_out, uint16_t *data_in)

Transfer one 16-bit value with the device. using msb by default. For example 0x1234, 0x12 will send first then 0x34.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_ERR_TIMEOUT if bus is busy

  • ESP_OK on success

Parameters
  • dev_handle: handle for device operation.

  • data_out: data will send to device.

  • data_in: pointer to receive buffer, set NULL to skip receive phase.

esp_err_t spi_bus_transfer_reg32(spi_bus_device_handle_t dev_handle, uint32_t data_out, uint32_t *data_in)

Transfer one 32-bit value with the device. using msb by default. For example 0x12345678, 0x12 will send first, 0x78 will send in the end.

Return

esp_err_t

  • ESP_ERR_INVALID_ARG if parameter is invalid

  • ESP_ERR_TIMEOUT if bus is busy

  • ESP_OK on success

Parameters
  • dev_handle: handle for device operation.

  • data_out: data will send to device.

  • data_in: pointer to receive buffer, set NULL to skip receive phase.

Structures

struct spi_config_t

spi bus initialization parameters.

Public Members

gpio_num_t miso_io_num

GPIO pin for Master In Slave Out (=spi_q) signal, or -1 if not used.

gpio_num_t mosi_io_num

GPIO pin for Master Out Slave In (=spi_d) signal, or -1 if not used.

gpio_num_t sclk_io_num

GPIO pin for Spi CLocK signal, or -1 if not used

int max_transfer_sz

<Maximum length of bytes available to send, if < 4096, 4096 will be set

struct spi_device_config_t

spi device initialization parameters.

Public Members

gpio_num_t cs_io_num

GPIO pin to select this device (CS), or -1 if not used

uint8_t mode

modes (0,1,2,3) that correspond to the four possible clocking configurations

int clock_speed_hz

spi clock speed, divisors of 80MHz, in Hz. See `SPI_MASTER_FREQ_*

Macros

NULL_SPI_CS_PIN

set cs_io_num to NULL_SPI_CS_PIN if spi device has no CP pin

Type Definitions

typedef void *spi_bus_handle_t

spi bus handle

typedef void *spi_bus_device_handle_t

spi device handle