i2c.c 27.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

27
28
29
#include <stdio.h>
#include <string.h>

30
31
#include "py/nlr.h"
#include "py/runtime.h"
32
#include "irq.h"
33
34
#include "pin.h"
#include "genhdr/pins.h"
35
#include "bufhelper.h"
36
#include "dma.h"
37
#include "i2c.h"
38
#include MICROPY_HAL_H
39

40
41
42
43
#if !defined(STM32F7)
// The STM32F7 has Timing, where the F4 has ClockSpeed and DutyCycle, so we
// need to figure that out before we can enable i2c

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
/// \moduleref pyb
/// \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 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)
92

93
94
95
96
97
98
99
100
// Possible DMA configurations for I2C busses:
// I2C1_TX: DMA1_Stream6.CHANNEL_1 or DMA1_Stream7.CHANNEL_1
// I2C1_RX: DMA1_Stream0.CHANNEL_1 or DMA1_Stream5.CHANNEL_1
// I2C2_TX: DMA1_Stream7.CHANNEL_7
// I2C2_RX: DMA1_Stream2.CHANNEL_7 or DMA1_Stream3.CHANNEL_7
// I2C3_TX: DMA1_Stream4.CHANNEL_3
// I2C3_RX: DMA1_Stream2.CHANNEL_3

101
102
103
#define PYB_I2C_MASTER (0)
#define PYB_I2C_SLAVE  (1)

104
105
106
107
108
109
110
111
112
typedef struct _pyb_i2c_obj_t {
    mp_obj_base_t base;
    I2C_HandleTypeDef *i2c;
    DMA_Stream_TypeDef *tx_dma_stream;
    uint32_t tx_dma_channel;
    DMA_Stream_TypeDef *rx_dma_stream;
    uint32_t rx_dma_channel;
} pyb_i2c_obj_t;

113
#if defined(MICROPY_HW_I2C1_SCL)
114
I2C_HandleTypeDef I2CHandle1 = {.Instance = NULL};
115
#endif
116
#if defined(MICROPY_HW_I2C2_SCL)
117
I2C_HandleTypeDef I2CHandle2 = {.Instance = NULL};
118
119
120
121
#endif
#if defined(MICROPY_HW_I2C3_SCL)
I2C_HandleTypeDef I2CHandle3 = {.Instance = NULL};
#endif
122

123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
STATIC const pyb_i2c_obj_t pyb_i2c_obj[] = {
    #if defined(MICROPY_HW_I2C1_SCL)
    {{&pyb_i2c_type}, &I2CHandle1, DMA1_Stream7, DMA_CHANNEL_1, DMA1_Stream0, DMA_CHANNEL_1},
    #else
    {{&pyb_i2c_type}, NULL, NULL, 0, NULL, 0},
    #endif
    #if defined(MICROPY_HW_I2C2_SCL)
    {{&pyb_i2c_type}, &I2CHandle2, DMA1_Stream7, DMA_CHANNEL_7, DMA1_Stream2, DMA_CHANNEL_7},
    #else
    {{&pyb_i2c_type}, NULL, NULL, 0, NULL, 0},
    #endif
    #if defined(MICROPY_HW_I2C3_SCL)
    {{&pyb_i2c_type}, &I2CHandle3, DMA1_Stream4, DMA_CHANNEL_3, DMA1_Stream2, DMA_CHANNEL_3},
    #else
    {{&pyb_i2c_type}, NULL, NULL, 0, NULL, 0},
    #endif
};

141
142
void i2c_init0(void) {
    // reset the I2C1 handles
143
    #if defined(MICROPY_HW_I2C1_SCL)
144
145
    memset(&I2CHandle1, 0, sizeof(I2C_HandleTypeDef));
    I2CHandle1.Instance = I2C1;
146
147
    #endif
    #if defined(MICROPY_HW_I2C2_SCL)
148
149
    memset(&I2CHandle2, 0, sizeof(I2C_HandleTypeDef));
    I2CHandle2.Instance = I2C2;
150
151
152
153
154
    #endif
    #if defined(MICROPY_HW_I2C3_SCL)
    memset(&I2CHandle3, 0, sizeof(I2C_HandleTypeDef));
    I2CHandle3.Instance = I2C3;
    #endif
155
156
}

157
void i2c_init(I2C_HandleTypeDef *i2c) {
158
    // init the GPIO lines
159
    GPIO_InitTypeDef GPIO_InitStructure;
160
161
162
163
    GPIO_InitStructure.Mode = GPIO_MODE_AF_OD;
    GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
    GPIO_InitStructure.Pull = GPIO_NOPULL; // have external pull-up resistors on both lines

164
    const pyb_i2c_obj_t *self;
165
    const pin_obj_t *pins[2];
166

167
    if (0) {
168
    #if defined(MICROPY_HW_I2C1_SCL)
169
    } else if (i2c == &I2CHandle1) {
170
        self = &pyb_i2c_obj[0];
171
172
        pins[0] = &MICROPY_HW_I2C1_SCL;
        pins[1] = &MICROPY_HW_I2C1_SDA;
173
174
        GPIO_InitStructure.Alternate = GPIO_AF4_I2C1;
        __I2C1_CLK_ENABLE();
175
176
    #endif
    #if defined(MICROPY_HW_I2C2_SCL)
177
    } else if (i2c == &I2CHandle2) {
178
        self = &pyb_i2c_obj[1];
179
180
        pins[0] = &MICROPY_HW_I2C2_SCL;
        pins[1] = &MICROPY_HW_I2C2_SDA;
181
182
        GPIO_InitStructure.Alternate = GPIO_AF4_I2C2;
        __I2C2_CLK_ENABLE();
183
184
185
    #endif
    #if defined(MICROPY_HW_I2C3_SCL)
    } else if (i2c == &I2CHandle3) {
186
        self = &pyb_i2c_obj[2];
187
188
189
190
191
        pins[0] = &MICROPY_HW_I2C3_SCL;
        pins[1] = &MICROPY_HW_I2C3_SDA;
        GPIO_InitStructure.Alternate = GPIO_AF4_I2C3;
        __I2C3_CLK_ENABLE();
    #endif
192
193
194
    } else {
        // I2C does not exist for this board (shouldn't get here, should be checked by caller)
        return;
195
196
    }

197
198
    // init the GPIO lines
    for (uint i = 0; i < 2; i++) {
199
        mp_hal_gpio_clock_enable(pins[i]->gpio);
200
201
202
203
        GPIO_InitStructure.Pin = pins[i]->pin_mask;
        HAL_GPIO_Init(pins[i]->gpio, &GPIO_InitStructure);
    }

204
    // init the I2C device
205
    if (HAL_I2C_Init(i2c) != HAL_OK) {
206
        // init error
207
208
        // TODO should raise an exception, but this function is not necessarily going to be
        // called via Python, so may not be properly wrapped in an NLR handler
209
        printf("OSError: HAL_I2C_Init failed\n");
210
211
        return;
    }
212
213
214
215

    // invalidate the DMA channels so they are initialised on first use
    dma_invalidate_channel(self->tx_dma_stream, self->tx_dma_channel);
    dma_invalidate_channel(self->rx_dma_stream, self->rx_dma_channel);
216
217
}

218
219
220
void i2c_deinit(I2C_HandleTypeDef *i2c) {
    HAL_I2C_DeInit(i2c);
    if (0) {
221
    #if defined(MICROPY_HW_I2C1_SCL)
222
223
224
225
    } else if (i2c->Instance == I2C1) {
        __I2C1_FORCE_RESET();
        __I2C1_RELEASE_RESET();
        __I2C1_CLK_DISABLE();
226
227
    #endif
    #if defined(MICROPY_HW_I2C2_SCL)
228
229
230
231
    } else if (i2c->Instance == I2C2) {
        __I2C2_FORCE_RESET();
        __I2C2_RELEASE_RESET();
        __I2C2_CLK_DISABLE();
232
233
234
235
236
237
238
    #endif
    #if defined(MICROPY_HW_I2C3_SCL)
    } else if (i2c->Instance == I2C3) {
        __I2C3_FORCE_RESET();
        __I2C3_RELEASE_RESET();
        __I2C3_CLK_DISABLE();
    #endif
239
240
241
    }
}

242
243
244
245
246
247
248
249
250
251
252
253
254
STATIC HAL_StatusTypeDef i2c_wait_dma_finished(I2C_HandleTypeDef *i2c, uint32_t timeout) {
    // Note: we can't use WFI to idle in this loop because the DMA completion
    // interrupt may occur before the WFI.  Hence we miss it and have to wait
    // until the next sys-tick (up to 1ms).
    uint32_t start = HAL_GetTick();
    while (HAL_I2C_GetState(i2c) != HAL_I2C_STATE_READY) {
        if (HAL_GetTick() - start >= timeout) {
            return HAL_TIMEOUT;
        }
    }
    return HAL_OK;
}

255
256
257
/******************************************************************************/
/* Micro Python bindings                                                      */

258
259
STATIC inline bool in_master_mode(pyb_i2c_obj_t *self) { return self->i2c->Init.OwnAddress1 == PYB_I2C_MASTER_ADDRESS; }

260
STATIC void pyb_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
261
262
    pyb_i2c_obj_t *self = self_in;

263
264
265
266
267
268
269
270
271
272
273
    uint i2c_num = 0;
    if (0) { }
    #if defined(MICROPY_HW_I2C1_SCL)
    else if (self->i2c->Instance == I2C1) { i2c_num = 1; }
    #endif
    #if defined(MICROPY_HW_I2C2_SCL)
    else if (self->i2c->Instance == I2C2) { i2c_num = 2; }
    #endif
    #if defined(MICROPY_HW_I2C3_SCL)
    else if (self->i2c->Instance == I2C3) { i2c_num = 3; }
    #endif
274
275

    if (self->i2c->State == HAL_I2C_STATE_RESET) {
276
        mp_printf(print, "I2C(%u)", i2c_num);
277
278
    } else {
        if (in_master_mode(self)) {
279
            mp_printf(print, "I2C(%u, I2C.MASTER, baudrate=%u)", i2c_num, self->i2c->Init.ClockSpeed);
280
        } else {
281
            mp_printf(print, "I2C(%u, I2C.SLAVE, addr=0x%02x)", i2c_num, (self->i2c->Instance->OAR1 >> 1) & 0x7f);
282
283
284
285
        }
    }
}

286
287
288
289
290
291
292
293
/// \method 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
294
295
296
297
298
299
300
STATIC mp_obj_t pyb_i2c_init_helper(const pyb_i2c_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    static const mp_arg_t allowed_args[] = {
        { MP_QSTR_mode,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
        { MP_QSTR_addr,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0x12} },
        { MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
        { MP_QSTR_gencall,  MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
    };
301
302

    // parse args
303
304
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
305
306
307
308

    // set the I2C configuration values
    I2C_InitTypeDef *init = &self->i2c->Init;

309
    if (args[0].u_int == PYB_I2C_MASTER) {
310
311
312
        // use a special address to indicate we are a master
        init->OwnAddress1 = PYB_I2C_MASTER_ADDRESS;
    } else {
313
        init->OwnAddress1 = (args[1].u_int << 1) & 0xfe;
314
315
316
    }

    init->AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
317
    init->ClockSpeed      = MIN(args[2].u_int, 400000);
318
319
    init->DualAddressMode = I2C_DUALADDRESS_DISABLED;
    init->DutyCycle       = I2C_DUTYCYCLE_16_9;
320
    init->GeneralCallMode = args[3].u_bool ? I2C_GENERALCALL_ENABLED : I2C_GENERALCALL_DISABLED;
321
322
323
324
325
326
327
328
329
    init->NoStretchMode   = I2C_NOSTRETCH_DISABLED;
    init->OwnAddress2     = 0xfe; // unused

    // init the I2C bus
    i2c_init(self->i2c);

    return mp_const_none;
}

330
331
332
333
334
335
336
/// \classmethod \constructor(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.
337
338
339
340
341
///
/// 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)`
342
STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
343
    // check arguments
344
    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
345

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
    // work out i2c bus
    int i2c_id = 0;
    if (MP_OBJ_IS_STR(args[0])) {
        const char *port = mp_obj_str_get_str(args[0]);
        if (0) {
        #ifdef MICROPY_HW_I2C1_NAME
        } else if (strcmp(port, MICROPY_HW_I2C1_NAME) == 0) {
            i2c_id = 1;
        #endif
        #ifdef MICROPY_HW_I2C2_NAME
        } else if (strcmp(port, MICROPY_HW_I2C2_NAME) == 0) {
            i2c_id = 2;
        #endif
        #ifdef MICROPY_HW_I2C3_NAME
        } else if (strcmp(port, MICROPY_HW_I2C3_NAME) == 0) {
            i2c_id = 3;
        #endif
        } else {
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
                "I2C(%s) does not exist", port));
        }
    } else {
        i2c_id = mp_obj_get_int(args[0]);
        if (i2c_id < 1 || i2c_id > MP_ARRAY_SIZE(pyb_i2c_obj)
370
            || pyb_i2c_obj[i2c_id - 1].i2c == NULL) {
371
372
373
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
                "I2C(%d) does not exist", i2c_id));
        }
374
375
    }

376
    // get I2C object
377
    const pyb_i2c_obj_t *i2c_obj = &pyb_i2c_obj[i2c_id - 1];
378

379
380
381
382
383
384
    if (n_args > 1 || n_kw > 0) {
        // start the peripheral
        mp_map_t kw_args;
        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
        pyb_i2c_init_helper(i2c_obj, n_args - 1, args + 1, &kw_args);
    }
385

386
    return (mp_obj_t)i2c_obj;
387
388
}

389
STATIC mp_obj_t pyb_i2c_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
390
391
392
393
    return pyb_i2c_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_init_obj, 1, pyb_i2c_init);

394
395
/// \method deinit()
/// Turn off the I2C bus.
396
397
398
399
400
401
402
STATIC mp_obj_t pyb_i2c_deinit(mp_obj_t self_in) {
    pyb_i2c_obj_t *self = self_in;
    i2c_deinit(self->i2c);
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_deinit_obj, pyb_i2c_deinit);

403
404
/// \method is_ready(addr)
/// Check if an I2C device responds to the given address.  Only valid when in master mode.
405
406
STATIC mp_obj_t pyb_i2c_is_ready(mp_obj_t self_in, mp_obj_t i2c_addr_o) {
    pyb_i2c_obj_t *self = self_in;
407
408
409
410
411

    if (!in_master_mode(self)) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "I2C must be a master"));
    }

412
    mp_uint_t i2c_addr = mp_obj_get_int(i2c_addr_o) << 1;
413
414

    for (int i = 0; i < 10; i++) {
415
        HAL_StatusTypeDef status = HAL_I2C_IsDeviceReady(self->i2c, i2c_addr, 10, 200);
416
417
418
419
420
421
422
423
424
        if (status == HAL_OK) {
            return mp_const_true;
        }
    }

    return mp_const_false;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_is_ready_obj, pyb_i2c_is_ready);

425
426
427
/// \method scan()
/// Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.
/// Only valid when in master mode.
428
429
430
STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) {
    pyb_i2c_obj_t *self = self_in;

431
432
433
434
    if (!in_master_mode(self)) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "I2C must be a master"));
    }

435
436
437
438
    mp_obj_t list = mp_obj_new_list(0, NULL);

    for (uint addr = 1; addr <= 127; addr++) {
        for (int i = 0; i < 10; i++) {
439
            HAL_StatusTypeDef status = HAL_I2C_IsDeviceReady(self->i2c, addr << 1, 10, 200);
440
441
442
443
444
445
446
447
448
449
450
            if (status == HAL_OK) {
                mp_obj_list_append(list, mp_obj_new_int(addr));
                break;
            }
        }
    }

    return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_scan_obj, pyb_i2c_scan);

451
452
453
454
455
456
457
458
/// \method 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`.
459
460
461
462
463
464
STATIC mp_obj_t pyb_i2c_send(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    static const mp_arg_t allowed_args[] = {
        { MP_QSTR_send,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
        { MP_QSTR_addr,    MP_ARG_INT, {.u_int = PYB_I2C_MASTER_ADDRESS} },
        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
    };
465
466

    // parse args
467
468
469
    pyb_i2c_obj_t *self = pos_args[0];
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
470
471
472
473

    // get the buffer to send from
    mp_buffer_info_t bufinfo;
    uint8_t data[1];
474
    pyb_buf_get_for_send(args[0].u_obj, &bufinfo, data);
475

476
477
478
    // if IRQs are enabled then we can use DMA
    DMA_HandleTypeDef tx_dma;
    if (query_irq() == IRQ_STATE_ENABLED) {
479
        dma_init(&tx_dma, self->tx_dma_stream, &dma_init_struct_spi_i2c, self->tx_dma_channel, DMA_MEMORY_TO_PERIPH, self->i2c);
480
481
482
483
        self->i2c->hdmatx = &tx_dma;
        self->i2c->hdmarx = NULL;
    }

484
485
486
    // send the data
    HAL_StatusTypeDef status;
    if (in_master_mode(self)) {
487
        if (args[1].u_int == PYB_I2C_MASTER_ADDRESS) {
488
489
490
            if (query_irq() == IRQ_STATE_ENABLED) {
                dma_deinit(&tx_dma);
            }
491
492
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "addr argument required"));
        }
493
        mp_uint_t i2c_addr = args[1].u_int << 1;
494
        if (query_irq() == IRQ_STATE_DISABLED) {
495
            status = HAL_I2C_Master_Transmit(self->i2c, i2c_addr, bufinfo.buf, bufinfo.len, args[2].u_int);
496
497
498
        } else {
            status = HAL_I2C_Master_Transmit_DMA(self->i2c, i2c_addr, bufinfo.buf, bufinfo.len);
        }
499
    } else {
500
        if (query_irq() == IRQ_STATE_DISABLED) {
501
            status = HAL_I2C_Slave_Transmit(self->i2c, bufinfo.buf, bufinfo.len, args[2].u_int);
502
503
504
505
506
507
508
509
        } else {
            status = HAL_I2C_Slave_Transmit_DMA(self->i2c, bufinfo.buf, bufinfo.len);
        }
    }

    // if we used DMA, wait for it to finish
    if (query_irq() == IRQ_STATE_ENABLED) {
        if (status == HAL_OK) {
510
            status = i2c_wait_dma_finished(self->i2c, args[2].u_int);
511
512
        }
        dma_deinit(&tx_dma);
513
    }
514
515

    if (status != HAL_OK) {
516
        mp_hal_raise(status);
517
518
    }

519
    return mp_const_none;
520
}
521
522
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_send_obj, 1, pyb_i2c_send);

523
/// \method recv(recv, addr=0x00, timeout=5000)
524
525
526
527
528
529
530
531
532
533
///
/// 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`.
534
535
536
537
538
539
STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    static const mp_arg_t allowed_args[] = {
        { MP_QSTR_recv,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
        { MP_QSTR_addr,    MP_ARG_INT, {.u_int = PYB_I2C_MASTER_ADDRESS} },
        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
    };
540

541
    // parse args
542
543
544
    pyb_i2c_obj_t *self = pos_args[0];
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
545
546

    // get the buffer to receive into
547
    vstr_t vstr;
548
    mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr);
549

550
551
552
    // if IRQs are enabled then we can use DMA
    DMA_HandleTypeDef rx_dma;
    if (query_irq() == IRQ_STATE_ENABLED) {
553
        dma_init(&rx_dma, self->rx_dma_stream, &dma_init_struct_spi_i2c, self->rx_dma_channel, DMA_PERIPH_TO_MEMORY, self->i2c);
554
555
556
557
        self->i2c->hdmatx = NULL;
        self->i2c->hdmarx = &rx_dma;
    }

558
    // receive the data
559
    HAL_StatusTypeDef status;
560
    if (in_master_mode(self)) {
561
        if (args[1].u_int == PYB_I2C_MASTER_ADDRESS) {
562
563
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "addr argument required"));
        }
564
        mp_uint_t i2c_addr = args[1].u_int << 1;
565
        if (query_irq() == IRQ_STATE_DISABLED) {
566
            status = HAL_I2C_Master_Receive(self->i2c, i2c_addr, (uint8_t*)vstr.buf, vstr.len, args[2].u_int);
567
568
569
        } else {
            status = HAL_I2C_Master_Receive_DMA(self->i2c, i2c_addr, (uint8_t*)vstr.buf, vstr.len);
        }
570
    } else {
571
        if (query_irq() == IRQ_STATE_DISABLED) {
572
            status = HAL_I2C_Slave_Receive(self->i2c, (uint8_t*)vstr.buf, vstr.len, args[2].u_int);
573
574
575
576
577
578
579
580
        } else {
            status = HAL_I2C_Slave_Receive_DMA(self->i2c, (uint8_t*)vstr.buf, vstr.len);
        }
    }

    // if we used DMA, wait for it to finish
    if (query_irq() == IRQ_STATE_ENABLED) {
        if (status == HAL_OK) {
581
            status = i2c_wait_dma_finished(self->i2c, args[2].u_int);
582
583
        }
        dma_deinit(&rx_dma);
584
585
586
    }

    if (status != HAL_OK) {
587
        mp_hal_raise(status);
588
589
    }

590
    // return the received data
591
592
    if (o_ret != MP_OBJ_NULL) {
        return o_ret;
593
    } else {
594
        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
595
    }
596
}
597
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_recv_obj, 1, pyb_i2c_recv);
598

599
/// \method mem_read(data, addr, memaddr, timeout=5000, addr_size=8)
600
601
602
603
604
605
606
///
/// 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
607
///   - `addr_size` selects width of memaddr: 8 or 16 bits
608
609
610
///
/// Returns the read data.
/// This is only valid in master mode.
611
STATIC const mp_arg_t pyb_i2c_mem_read_allowed_args[] = {
612
613
614
615
    { MP_QSTR_data,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
    { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
    { MP_QSTR_memaddr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
    { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
616
    { MP_QSTR_addr_size, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 8} },
617
};
618

619
620
621
622
623
STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    // parse args
    pyb_i2c_obj_t *self = pos_args[0];
    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args)];
    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args), pyb_i2c_mem_read_allowed_args, args);
624

625
626
627
628
629
    if (!in_master_mode(self)) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "I2C must be a master"));
    }

    // get the buffer to read into
630
    vstr_t vstr;
631
    mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr);
632

633
    // get the addresses
634
635
    mp_uint_t i2c_addr = args[1].u_int << 1;
    mp_uint_t mem_addr = args[2].u_int;
636
    // determine width of mem_addr; default is 8 bits, entering any other value gives 16 bit width
637
    mp_uint_t mem_addr_size = I2C_MEMADD_SIZE_8BIT;
638
    if (args[4].u_int != 8) {
639
        mem_addr_size = I2C_MEMADD_SIZE_16BIT;
640
    }
641

642
643
    HAL_StatusTypeDef status;
    if (query_irq() == IRQ_STATE_DISABLED) {
644
        status = HAL_I2C_Mem_Read(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t*)vstr.buf, vstr.len, args[3].u_int);
645
646
    } else {
        DMA_HandleTypeDef rx_dma;
647
        dma_init(&rx_dma, self->rx_dma_stream, &dma_init_struct_spi_i2c, self->rx_dma_channel, DMA_PERIPH_TO_MEMORY, self->i2c);
648
649
650
651
        self->i2c->hdmatx = NULL;
        self->i2c->hdmarx = &rx_dma;
        status = HAL_I2C_Mem_Read_DMA(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t*)vstr.buf, vstr.len);
        if (status == HAL_OK) {
652
            status = i2c_wait_dma_finished(self->i2c, args[3].u_int);
653
654
655
        }
        dma_deinit(&rx_dma);
    }
656
657

    if (status != HAL_OK) {
658
        mp_hal_raise(status);
659
660
    }

661
    // return the read data
662
663
    if (o_ret != MP_OBJ_NULL) {
        return o_ret;
664
    } else {
665
        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
666
    }
667
}
668
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_read_obj, 1, pyb_i2c_mem_read);
669

670
/// \method mem_write(data, addr, memaddr, timeout=5000, addr_size=8)
671
672
673
674
675
676
677
///
/// 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
678
///   - `addr_size` selects width of memaddr: 8 or 16 bits
679
680
681
///
/// Returns `None`.
/// This is only valid in master mode.
682
683
684
685
686
STATIC mp_obj_t pyb_i2c_mem_write(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    // parse args (same as mem_read)
    pyb_i2c_obj_t *self = pos_args[0];
    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args)];
    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args), pyb_i2c_mem_read_allowed_args, args);
687
688
689

    if (!in_master_mode(self)) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "I2C must be a master"));
690
691
    }

692
693
694
    // get the buffer to write from
    mp_buffer_info_t bufinfo;
    uint8_t data[1];
695
    pyb_buf_get_for_send(args[0].u_obj, &bufinfo, data);
696
697

    // get the addresses
698
699
    mp_uint_t i2c_addr = args[1].u_int << 1;
    mp_uint_t mem_addr = args[2].u_int;
700
    // determine width of mem_addr; default is 8 bits, entering any other value gives 16 bit width
701
    mp_uint_t mem_addr_size = I2C_MEMADD_SIZE_8BIT;
702
    if (args[4].u_int != 8) {
703
        mem_addr_size = I2C_MEMADD_SIZE_16BIT;
704
    }
705

706
707
    HAL_StatusTypeDef status;
    if (query_irq() == IRQ_STATE_DISABLED) {
708
        status = HAL_I2C_Mem_Write(self->i2c, i2c_addr, mem_addr, mem_addr_size, bufinfo.buf, bufinfo.len, args[3].u_int);
709
710
    } else {
        DMA_HandleTypeDef tx_dma;
711
        dma_init(&tx_dma, self->tx_dma_stream, &dma_init_struct_spi_i2c, self->tx_dma_channel, DMA_MEMORY_TO_PERIPH, self->i2c);
712
713
714
715
        self->i2c->hdmatx = &tx_dma;
        self->i2c->hdmarx = NULL;
        status = HAL_I2C_Mem_Write_DMA(self->i2c, i2c_addr, mem_addr, mem_addr_size, bufinfo.buf, bufinfo.len);
        if (status == HAL_OK) {
716
            status = i2c_wait_dma_finished(self->i2c, args[3].u_int);
717
718
719
        }
        dma_deinit(&tx_dma);
    }
720
721

    if (status != HAL_OK) {
722
        mp_hal_raise(status);
723
724
725
726
    }

    return mp_const_none;
}
727
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_write_obj, 1, pyb_i2c_mem_write);
728

729
STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = {
730
731
732
    // instance methods
    { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pyb_i2c_init_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit), (mp_obj_t)&pyb_i2c_deinit_obj },
733
    { MP_OBJ_NEW_QSTR(MP_QSTR_is_ready), (mp_obj_t)&pyb_i2c_is_ready_obj },
734
    { MP_OBJ_NEW_QSTR(MP_QSTR_scan), (mp_obj_t)&pyb_i2c_scan_obj },
735
736
    { MP_OBJ_NEW_QSTR(MP_QSTR_send), (mp_obj_t)&pyb_i2c_send_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_recv), (mp_obj_t)&pyb_i2c_recv_obj },
737
738
    { MP_OBJ_NEW_QSTR(MP_QSTR_mem_read), (mp_obj_t)&pyb_i2c_mem_read_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_mem_write), (mp_obj_t)&pyb_i2c_mem_write_obj },
739
740

    // class constants
741
742
    /// \constant MASTER - for initialising the bus to master mode
    /// \constant SLAVE - for initialising the bus to slave mode
743
744
    { MP_OBJ_NEW_QSTR(MP_QSTR_MASTER),       MP_OBJ_NEW_SMALL_INT(PYB_I2C_MASTER) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_SLAVE),        MP_OBJ_NEW_SMALL_INT(PYB_I2C_SLAVE) },
745
746
};

747
748
STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);

749
750
751
const mp_obj_type_t pyb_i2c_type = {
    { &mp_type_type },
    .name = MP_QSTR_I2C,
752
    .print = pyb_i2c_print,
753
    .make_new = pyb_i2c_make_new,
754
    .locals_dict = (mp_obj_t)&pyb_i2c_locals_dict,
755
};
756
757

#endif // STM32F7