Since | Origin / Contributor | Maintainer | Source |
---|---|---|---|
2014-12-22 | Zeroday | Zeroday | i2c.c |
This module supports different interfaces for communicating via I²C protocol. All interfaces can be assigned to arbitrary GPIOs for SCL and SDA and can be operated concurrently.
i2c.SW
software based bitbanging, master mode only, synchronous operationi2c.HW0
ESP32 hardware port 0, master or slave mode, synchronous or asynchronous operationi2c.HW1
ESP32 hardware port 1, master or slave mode, synchronous or asynchronous operationThe hardware master interfaces differ from the SW interface as the commands (start, stop, read, write) are queued up to an internal command list. Actual I²C communication is initiated afterwards using the i2c.transfer()
function. Commands for the i2c.SW
interface are immediately effective on the I²C bus and read data is also instantly available.
Send (SW
) or queue (HWx
) I²C address and read/write mode for the next transfer.
Communication stops when the slave answers with NACK to the address byte. This can be avoided with parameter ack_check_en
on false
.
i2c.address(id, device_addr, direction[, ack_check_en])
id
interface iddevice_addr
device addressdirection
i2c.TRANSMITTER
for writing mode , i2c.RECEIVER
for reading modeack_check_en
enable check for slave ACK with true
(default), disable with false
true
if ack received (always for ids i2c.HW0
and i2c.HW1
), false
if no ack received (only possible for i2c.SW
).
Read (SW
) or queue (HWx
) data for variable number of bytes.
i2c.read(id, len)
id
interface idlen
number of data bytesstring
of received data for interface i2c.SW
nil
for ids i2c.HW0
and i2c.HW1
id = i2c.SW
sda = 1
scl = 2
-- initialize i2c, set pin1 as sda, set pin2 as scl
i2c.setup(id, sda, scl, i2c.SLOW)
-- user defined function: read from reg_addr content of dev_addr
function read_reg(dev_addr, reg_addr)
i2c.start(id)
i2c.address(id, dev_addr, i2c.TRANSMITTER)
i2c.write(id, reg_addr)
i2c.stop(id)
i2c.start(id)
i2c.address(id, dev_addr, i2c.RECEIVER)
c = i2c.read(id, 1)
i2c.stop(id)
return c
end
-- get content of register 0xAA of device 0x77
reg = read_reg(0x77, 0xAA)
print(string.byte(reg))
####See also i2c.write()
Initialize the I²C interface for master mode.
i2c.setup(id, pinSDA, pinSCL, speed)
####Parameters
id
interface idpinSDA
IO index, see GPIO OverviewpinSCL
IO index, see GPIO Overviewspeed
bit rate in Hz, positive integer
i2c.SLOW
for 100000 Hz, max for i2c.SW
i2c.FAST
for 400000 Hzi2c.FASTPLUS
for 1000000 Hzspeed
the selected speed
####See also i2c.read()
Send (SW
) or queue (HWx
) an I²C start condition.
i2c.start(id)
id
interface id
nil
####See also i2c.read()
Send (SW
) or queue (HWx
) an I²C stop condition.
i2c.stop(id)
####Parameters
id
interface id
nil
####See also i2c.read()
Starts a transfer for the specified hardware module. Providing a callback function allows the transfer to be started asynchronously in the background and i2c.transfer()
finishes immediately. Without a callback function, the transfer is executed synchronously and i2c.transfer()
comes back when the transfer completed. Data from a read operation is returned from i2c.transfer()
in this case.
First argument to the callback is a string with data obtained from a read operation during the transfer or nil
, followed by the ack flag (true = ACK received).
i2c.transfer(id[, cb_fn][, to_ms])
id
interface id, i2c.SW
not allowedcb_fn(data, ack)
function to be called when transfer finishedto_ms
timeout for the transfer in ms, defaults to 0=infinitedata
string of received data (nil
if no read or NACK)ack
true if ACK received, false for NACKnil
for asynchronous operationWrite (SW
) or queue (HWx
) data to I²C bus. Data items can be multiple numbers, strings or lua tables.
Communication stops when the slave answers with NACK to a written byte. This can be avoided with parameter ack_check_en
on false
.
####Syntax
i2c.write(id, data1[, data2[, ..., datan]][, ack_check_en])
####Parameters
id
interface iddata
data can be numbers, string or lua table.ack_check_en
enable check for slave ACK with true
(default), disable with false
number
number of bytes written
i2c.write(0, "hello", "world")
The I²C slave mode is only available for the hardware interfaces i2c.HW0
and i2c.HW1
.
Registers or unregisters an event callback handler.
i2c.slave.on(id, event[, cb_fn])
id
interface id, i2c.HW0
or i2c.HW1
event
one of
cb_fn(err, data)
function to be called when data was received from the master. Unregisters previous callback for event
when omitted.nil
Initialize the I²C interface for slave mode.
i2c.slave.setup(id, slave_config)
id
interface id, i2c.HW0
or i2c.HW1
slave_config
table containing slave configuration information
sda
IO index, see GPIO Overviewscl
IO index, see GPIO Overviewaddr
slave address (7bit or 10bit)10bit
enable 10bit addressing with true
, use 7bit with false
(optional, defaults to false
is omitted)rxbuf_len
length of receive buffer (optional, defaults to 128 if omitted)txbuf_len
length of transmit buffer (optional, defaults to 128 if omitted)nil
Writes send data for the master into the transmit buffer. This function returns immediately if there’s enough room left in the buffer. It blocks if the buffer is doesn’t provide enough space.
Data items can be multiple numbers, strings or lua tables.
i2c.slave.send(id, data1[, data2[, ..., datan]])
id
interface id, i2c.HW0
or i2c.HW1
data
data can be numbers, string or lua table.number
number of bytes written