class I2C – a two-wire serial protocol

I2C is a two-wire protocol for communicating between devices. At the physical level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.

I2C objects are created attached to a specific bus. They can be initialized when created, or initialized later on.

Printing the i2c object gives you information about its configuration.

Please use pyb.I2C instead of this object if possible for high-speed I2C. This class is for low-speed software I2C done via bit-banging.

Constructors

class machine.I2C(scl, sda, *, freq=400000)

Construct and return a new I2C object. See the init method below for a description of the arguments.

General Methods

i2c.init(scl, sda, *, freq=400000)

Initialize the I2C bus with the given arguments:

  • scl is a pin object for the SCL line
  • sda is a pin object for the SDA line
  • freq is the SCL clock rate
i2c.scan()

Scan all I2C addresses between 0x08 and 0x77 inclusive and return a list of those that respond. A device responds if it pulls the SDA line low after its address (including a read bit) is sent on the bus.

Primitive I2C operations

The following methods implement the primitive I2C master bus operations and can be combined to make any I2C transaction. They are provided if you need more control over the bus, otherwise the standard methods (see below) can be used.

i2c.start()

Send a start bit on the bus (SDA transitions to low while SCL is high).

i2c.stop()

Send a stop bit on the bus (SDA transitions to high while SCL is high).

i2c.readinto(buf)

Reads bytes from the bus and stores them into buf. The number of bytes read is the length of buf. An ACK will be sent on the bus after receiving all but the last byte, and a NACK will be sent following the last byte.

i2c.write(buf)

Write all the bytes from buf to the bus. Checks that an ACK is received after each byte and raises an OSError if not.

Standard bus operations

The following methods implement the standard I2C master read and write operations that target a given slave device.

i2c.readfrom(addr, nbytes)

Read nbytes from the slave specified by addr. Returns a bytes object with the data read.

i2c.readfrom_into(addr, buf)

Read into buf from the slave specified by addr. The number of bytes read will be the length of buf.

i2c.writeto(addr, buf, *, stop=True)

Write the bytes from buf to the slave specified by addr.

The stop argument (only available on WiPy) tells if a stop bit should be sent at the end of the transfer. If False the transfer should be continued later on.

Memory operations

Some I2C devices act as a memory device (or set of registers) that can be read from and written to. In this case there are two addresses associated with an I2C transaction: the slave address and the memory address. The following methods are convenience functions to communicate with such devices.

i2c.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)

Read nbytes from the slave specified by addr starting from the memory address specified by memaddr. The argument addrsize specifies the address size in bits (on ESP8266 this argument is not recognized and the address size is always 8 bits). Returns a bytes object with the data read.

i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)

Read into buf from the slave specified by addr starting from the memory address specified by memaddr. The number of bytes read is the length of buf. The argument addrsize specifies the address size in bits (on ESP8266 this argument is not recognized and the address size is always 8 bits).

i2c.writeto_mem(addr, memaddr, buf, *, addrsize=8)

Write buf to the slave specified by addr starting from the memory address specified by memaddr. The argument addrsize specifies the address size in bits (on ESP8266 this argument is not recognized and the address size is always 8 bits).