pyb.I2C.rst 5.09 KB
Newer Older
1
2
.. _pyb.I2C:

3
4
class I2C -- a two-wire serial protocol
=======================================
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

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 initialised
when created, or initialised later on::

    from pyb import I2C

    i2c = I2C(1)                         # create on bus 1
    i2c = I2C(1, I2C.MASTER)             # create and init as a master
    i2c.init(I2C.MASTER, baudrate=20000) # init as a master
    i2c.init(I2C.SLAVE, addr=0x42)       # init as a slave with given address
    i2c.deinit()                         # turn off the peripheral

Printing the i2c object gives you information about its configuration.

Basic methods for slave are send and recv::

    i2c.send('abc')      # send 3 bytes
    i2c.send(0x42)       # send a single byte, given by the number
    data = i2c.recv(3)   # receive 3 bytes

To receive inplace, first create a bytearray::

    data = bytearray(3)  # create a buffer
    i2c.recv(data)       # receive 3 bytes, writing them into data

You can specify a timeout (in ms)::

    i2c.send(b'123', timeout=2000)   # timout after 2 seconds

A master must specify the recipient's address::

    i2c.init(I2C.MASTER)
    i2c.send('123', 0x42)        # send 3 bytes to slave with address 0x42
    i2c.send(b'456', addr=0x42)  # keyword for address

Master also has other methods::

    i2c.is_ready(0x42)           # check if slave 0x42 is ready
    i2c.scan()                   # scan for slaves on the bus, returning
                                 #   a list of valid addresses
    i2c.mem_read(3, 0x42, 2)     # read 3 bytes from memory of slave 0x42,
                                 #   starting at address 2 in the slave
    i2c.mem_write('abc', 0x42, 2, timeout=1000)


Constructors
------------

.. class:: pyb.I2C(bus, ...)

   Construct an I2C object on the given bus.  ``bus`` can be 1 or 2.
   With no additional parameters, the I2C object is created but not
   initialised (it has the settings from the last initialisation of
   the bus, if any).  If extra arguments are given, the bus is initialised.
   See ``init`` for parameters of initialisation.
   
   The physical pins of the I2C busses are:
   
     - ``I2C(1)`` is on the X position: ``(SCL, SDA) = (X9, X10) = (PB6, PB7)``
     - ``I2C(2)`` is on the Y position: ``(SCL, SDA) = (Y9, Y10) = (PB10, PB11)``


Methods
-------

.. method:: i2c.deinit()

   Turn off the I2C bus.

.. method:: i2c.init(mode, \*, addr=0x12, baudrate=400000, gencall=False)

   Initialise the I2C bus with the given parameters:
   
     - ``mode`` must be either ``I2C.MASTER`` or ``I2C.SLAVE``
     - ``addr`` is the 7-bit address (only sensible for a slave)
     - ``baudrate`` is the SCL clock rate (only sensible for a master)
     - ``gencall`` is whether to support general call mode

.. method:: i2c.is_ready(addr)

   Check if an I2C device responds to the given address.  Only valid when in master mode.

.. method:: i2c.mem_read(data, addr, memaddr, timeout=5000, addr_size=8)

   Read from the memory of an I2C device:
   
     - ``data`` can be an integer or a buffer to read into
     - ``addr`` is the I2C device address
     - ``memaddr`` is the memory location within the I2C device
     - ``timeout`` is the timeout in milliseconds to wait for the read
     - ``addr_size`` selects width of memaddr: 8 or 16 bits
   
   Returns the read data.
   This is only valid in master mode.

.. method:: i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8)

   Write to the memory of an I2C device:
   
     - ``data`` can be an integer or a buffer to write from
     - ``addr`` is the I2C device address
     - ``memaddr`` is the memory location within the I2C device
     - ``timeout`` is the timeout in milliseconds to wait for the write
     - ``addr_size`` selects width of memaddr: 8 or 16 bits
   
   Returns ``None``.
   This is only valid in master mode.

.. method:: i2c.recv(recv, addr=0x00, timeout=5000)

   Receive data on the bus:
   
     - ``recv`` can be an integer, which is the number of bytes to receive,
       or a mutable buffer, which will be filled with received bytes
     - ``addr`` is the address to receive from (only required in master mode)
     - ``timeout`` is the timeout in milliseconds to wait for the receive
   
   Return value: if ``recv`` is an integer then a new buffer of the bytes received,
   otherwise the same buffer that was passed in to ``recv``.

.. method:: i2c.scan()

   Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.
   Only valid when in master mode.

.. method:: i2c.send(send, addr=0x00, timeout=5000)

   Send data on the bus:
   
     - ``send`` is the data to send (an integer to send, or a buffer object)
     - ``addr`` is the address to send to (only required in master mode)
     - ``timeout`` is the timeout in milliseconds to wait for the send
   
   Return value: ``None``.


Constants
---------

.. data:: I2C.MASTER

   for initialising the bus to master mode

.. data:: I2C.SLAVE

   for initialising the bus to slave mode