alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-07 20:00:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

docs: Sync CN translation and EN source for i2c.rst

Browse Source
This commit is contained in:
shenmengjing
2025-03-03 16:35:12 +08:00
parent cb9257dae7
commit c290d9490e
2 changed files with 108 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
docs/en/api-reference/peripherals/i2c.rst
View File

@@ -448,9 +448,9 @@ Not all I2C devices strictly adhere to the standard I2C protocol, as different m
.. note::
If you want to define your address in :cpp:type:`i2c_operation_job_t`, please set :cpp:member:`i2c_device_config_t::device_address` as I2C_DEVICE_ADDRESS_NOT_USED to skip internal address configuration in driver.
If you want to define your address in :cpp:type:`i2c_operation_job_t`, please set :cpp:member:`i2c_device_config_t::device_address` as ``I2C_DEVICE_ADDRESS_NOT_USED`` to skip internal address configuration in driver.
For address configuration of using defined transactions, given that a device address is 0x20, there are two situations, see following example:
For address configuration of user defined transactions, given that the device address is ``0x20``, there are two situations. See following example:
.. code:: c
@@ -472,7 +472,7 @@ For address configuration of using defined transactions, given that a device add
{ .command = I2C_MASTER_CMD_STOP },
};
// Situation one: The device should left shift one byte with carrying a write or read bit (official protocol)
// Situation one: The device address should be left shifted by one byte to include a write bit or a read bit (official protocol)
uint8_t address2 = (0x20 << 1 | 0); // (0x20 << 1 | 1)
i2c_operation_job_t i2c_ops2[] = {
{ .command = I2C_MASTER_CMD_START },
@@ -480,7 +480,7 @@ For address configuration of using defined transactions, given that a device add
{ .command = I2C_MASTER_CMD_STOP },
};
There are also some devices does not need an address, you can directly do transaction with data:
Some devices do not require an address, and allow direct transaction with data:
.. code:: c
@@ -494,7 +494,7 @@ There are also some devices does not need an address, you can directly do transa
i2c_master_execute_defined_operations(dev_handle, i2c_ops, sizeof(i2c_ops) / sizeof(i2c_operation_job_t), -1);
As for read direction, the theory is same but please always be aware the last byte of read before stop should always be nack. Example is as follows:
The principle of read operations is the same as that of write operations. Note to always ensure the last byte read before the stop condition is a ``NACK``. An example is as follows:
.. code:: c
@@ -505,7 +505,7 @@ As for read direction, the theory is same but please always be aware the last by
{ .command = I2C_MASTER_CMD_START },
{ .command = I2C_MASTER_CMD_WRITE, .write = { .ack_check = false, .data = (uint8_t *) &address, .total_bytes = 1 } },
{ .command = I2C_MASTER_CMD_READ, .read = { .ack_value = I2C_ACK_VAL, .data = (uint8_t *)rcv_data, .total_bytes = 9 } },
{ .command = I2C_MASTER_CMD_READ, .read = { .ack_value = I2C_NACK_VAL, .data = (uint8_t *)(rcv_data + 9), .total_bytes = 1 } }, // This must be nack.
{ .command = I2C_MASTER_CMD_READ, .read = { .ack_value = I2C_NACK_VAL, .data = (uint8_t *)(rcv_data + 9), .total_bytes = 1 } }, // This must be NACK
{ .command = I2C_MASTER_CMD_STOP },
};
@@ -516,14 +516,14 @@ I2C Slave Controller
After installing the I2C slave driver by :cpp:func:`i2c_new_slave_device`, {IDF_TARGET_NAME} is ready to communicate with other I2C masters as a slave.
The I2C slave is not as subjective as the I2C master which knows when it should send data and when it should receive data. The I2C slave is very passive in most cases, that means the I2C slave's ability to send and receive data is largely dependent on the master's actions. Therefore, we throw two callback functions in the driver that represent read requests and write requests from the I2C master.
The I2C slave is not as active as the I2C master, which knows when to send data and when to receive it. The I2C slave is very passive in most cases, meaning the I2C slave's ability to send and receive data is largely dependent on the master's actions. Therefore, we implement two callback functions in the driver to handle read and write requests from the I2C master.
I2C Slave Write
~~~~~~~~~~~~~~~
You can get I2C slave write event be register :cpp:member:`i2c_slave_event_callbacks_t::on_request` callback, and in a task when get the request event, you can call `i2c_slave_write` to send data.
You can get I2C slave write event by registering :cpp:member:`i2c_slave_event_callbacks_t::on_request` callback. Then, in a task where the request event is triggered, you can call ``i2c_slave_write`` to send data.
Simple example for transmitting data:
A simple example for transmitting data:
.. code:: c
@@ -542,7 +542,7 @@ Simple example for transmitting data:
};
ESP_ERROR_CHECK(i2c_slave_register_event_callbacks(context.handle, &cbs, &context));
// Waiting for request event and send data in a task
// Wait for request event and send data in a task
static void i2c_slave_task(void *arg)
{
uint8_t buffer_size = 64;
@@ -561,9 +561,9 @@ Simple example for transmitting data:
I2C Slave Read
~~~~~~~~~~~~~~
Same as write, you can get I2C slave read event be register :cpp:member:`i2c_slave_event_callbacks_t::on_receive` callback, and in a task when get the request event, you can save the data and do what you want.
Same as write event, you can get I2C slave read event by registering :cpp:member:`i2c_slave_event_callbacks_t::on_receive` callback. Then, in a task where the request event is triggered, you can save the data and do what you want.
Simple example for receiving data:
A simple example for receiving data:
.. code:: c