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
199
200
201
202
    // init the GPIO lines
    for (uint i = 0; i < 2; i++) {
        GPIO_InitStructure.Pin = pins[i]->pin_mask;
        HAL_GPIO_Init(pins[i]->gpio, &GPIO_InitStructure);
    }

203
    // init the I2C device
204
    if (HAL_I2C_Init(i2c) != HAL_OK) {
205
        // init error
206
207
        // 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
208
        printf("OSError: HAL_I2C_Init failed\n");
209
210
        return;
    }
211
212
213
214

    // 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);
215
216
}

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

241
242
243
244
245
246
247
248
249
250
251
252
253
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;
}

254
255
256
/******************************************************************************/
/* Micro Python bindings                                                      */

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

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

262
263
264
265
266
267
268
269
270
271
272
    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
273
274

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

285
286
287
288
289
290
291
292
/// \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
293
294
295
296
297
298
299
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} },
    };
300
301

    // parse args
302
303
    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);
304
305
306
307

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

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

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

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

    return mp_const_none;
}

329
330
331
332
333
334
335
/// \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.
336
337
338
339
340
///
/// 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)`
341
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) {
342
    // check arguments
343
    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
344

345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
    // 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)
369
            || pyb_i2c_obj[i2c_id - 1].i2c == NULL) {
370
371
372
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
                "I2C(%d) does not exist", i2c_id));
        }
373
374
    }

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

378
379
380
381
382
383
    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);
    }
384

385
    return (mp_obj_t)i2c_obj;
386
387
}

388
STATIC mp_obj_t pyb_i2c_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
389
390
391
392
    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);

393
394
/// \method deinit()
/// Turn off the I2C bus.
395
396
397
398
399
400
401
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);

402
403
/// \method is_ready(addr)
/// Check if an I2C device responds to the given address.  Only valid when in master mode.
404
405
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;
406
407
408
409
410

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

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

    for (int i = 0; i < 10; i++) {
414
        HAL_StatusTypeDef status = HAL_I2C_IsDeviceReady(self->i2c, i2c_addr, 10, 200);
415
416
417
418
419
420
421
422
423
        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);

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

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

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

    for (uint addr = 1; addr <= 127; addr++) {
        for (int i = 0; i < 10; i++) {
438
            HAL_StatusTypeDef status = HAL_I2C_IsDeviceReady(self->i2c, addr << 1, 10, 200);
439
440
441
442
443
444
445
446
447
448
449
            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);

450
451
452
453
454
455
456
457
/// \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`.
458
459
460
461
462
463
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} },
    };
464
465

    // parse args
466
467
468
    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);
469
470
471
472

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

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

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

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

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

522
/// \method recv(recv, addr=0x00, timeout=5000)
523
524
525
526
527
528
529
530
531
532
///
/// 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`.
533
534
535
536
537
538
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} },
    };
539

540
    // parse args
541
542
543
    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);
544
545

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

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

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

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

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

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

618
619
620
621
622
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);
623

624
625
626
627
628
    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
629
    vstr_t vstr;
630
    mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr);
631

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

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

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

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

669
/// \method mem_write(data, addr, memaddr, timeout=5000, addr_size=8)
670
671
672
673
674
675
676
///
/// 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
677
///   - `addr_size` selects width of memaddr: 8 or 16 bits
678
679
680
///
/// Returns `None`.
/// This is only valid in master mode.
681
682
683
684
685
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);
686
687
688

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

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

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

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

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

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

728
STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = {
729
730
731
    // 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 },
732
    { MP_OBJ_NEW_QSTR(MP_QSTR_is_ready), (mp_obj_t)&pyb_i2c_is_ready_obj },
733
    { MP_OBJ_NEW_QSTR(MP_QSTR_scan), (mp_obj_t)&pyb_i2c_scan_obj },
734
735
    { 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 },
736
737
    { 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 },
738
739

    // class constants
740
741
    /// \constant MASTER - for initialising the bus to master mode
    /// \constant SLAVE - for initialising the bus to slave mode
742
743
    { 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) },
744
745
};

746
747
STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);

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

#endif // STM32F7