uart.c 17.2 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
#include <stdio.h>
#include <string.h>
29
#include <stdarg.h>
30

31
32
#include "stm32f4xx_hal.h"

33
#include "mpconfig.h"
34
#include "nlr.h"
35
36
37
#include "misc.h"
#include "qstr.h"
#include "obj.h"
38
39
#include "runtime.h"
#include "bufhelper.h"
Damien George's avatar
Damien George committed
40
#include "uart.h"
41
#include "pybioctl.h"
42

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/// \moduleref pyb
/// \class UART - duplex serial communication bus
///
/// UART implements the standard UART/USART duplex serial communications protocol.  At
/// the physical level it consists of 2 lines: RX and TX.
///
/// See usage model of I2C.  UART is very similar.  Main difference is
/// parameters to init the UART bus:
///
///     from pyb import UART
///
///     uart = UART(1, 9600)                         # init with given baudrate
///     uart.init(9600, bits=8, stop=1, parity=None) # init with given parameters
///
/// Bits can be 8 or 9, stop can be 1 or 2, parity can be None, 0 (even), 1 (odd).
///
/// Extra method:
///
///     uart.any()               # returns True if any characters waiting
62

Damien George's avatar
Damien George committed
63
struct _pyb_uart_obj_t {
Dave Hylands's avatar
Dave Hylands committed
64
    mp_obj_base_t base;
Damien George's avatar
Damien George committed
65
    pyb_uart_t uart_id;
Dave Hylands's avatar
Dave Hylands committed
66
    bool is_enabled;
67
    UART_HandleTypeDef uart;
Dave Hylands's avatar
Dave Hylands committed
68
};
69

70
// assumes Init parameters have been set up correctly
Damien George's avatar
Damien George committed
71
72
bool uart_init2(pyb_uart_obj_t *uart_obj) {
    USART_TypeDef *UARTx = NULL;
73

74
    uint32_t GPIO_Pin = 0;
Damien George's avatar
Damien George committed
75
    uint8_t  GPIO_AF_UARTx = 0;
76
    GPIO_TypeDef* GPIO_Port = NULL;
77

Damien George's avatar
Damien George committed
78
79
80
81
82
    switch (uart_obj->uart_id) {
        // USART1 is on PA9/PA10 (CK on PA8), PB6/PB7
        case PYB_UART_1:
            UARTx = USART1;
            GPIO_AF_UARTx = GPIO_AF7_USART1;
83

Damien George's avatar
Damien George committed
84
#if defined (PYBV4) || defined(PYBV10)
85
86
87
            GPIO_Port = GPIOB;
            GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7;
#else
88
89
            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_9 | GPIO_PIN_10;
90
#endif
91
92
93

            __USART1_CLK_ENABLE();
            break;
94

Damien George's avatar
Damien George committed
95
96
97
98
        // USART2 is on PA2/PA3 (CK on PA4), PD5/PD6 (CK on PD7)
        case PYB_UART_2:
            UARTx = USART2;
            GPIO_AF_UARTx = GPIO_AF7_USART2;
99

Damien George's avatar
Damien George committed
100
101
            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_2 | GPIO_PIN_3;
102
103
104

            __USART2_CLK_ENABLE();
            break;
105

Damien George's avatar
Damien George committed
106
107
108
109
        // USART3 is on PB10/PB11 (CK on PB12), PC10/PC11 (CK on PC12), PD8/PD9 (CK on PD10)
        case PYB_UART_3:
            UARTx = USART3;
            GPIO_AF_UARTx = GPIO_AF7_USART3;
110

111
#if defined(PYBV3) || defined(PYBV4) | defined(PYBV10)
112
113
114
115
116
117
118
119
            GPIO_Port = GPIOB;
            GPIO_Pin = GPIO_PIN_10 | GPIO_PIN_11;
#else
            GPIO_Port = GPIOD;
            GPIO_Pin = GPIO_PIN_8 | GPIO_PIN_9;
#endif
            __USART3_CLK_ENABLE();
            break;
120

121
        // UART4 is on PA0/PA1, PC10/PC11
Damien George's avatar
Damien George committed
122
123
124
        case PYB_UART_4:
            UARTx = UART4;
            GPIO_AF_UARTx = GPIO_AF8_UART4;
125
126
127
128
129
130
131

            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_0 | GPIO_PIN_1;

            __UART4_CLK_ENABLE();
            break;

Damien George's avatar
Damien George committed
132
133
134
135
        // USART6 is on PC6/PC7 (CK on PC8)
        case PYB_UART_6:
            UARTx = USART6;
            GPIO_AF_UARTx = GPIO_AF8_USART6;
136
137
138
139
140
141

            GPIO_Port = GPIOC;
            GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7;

            __USART6_CLK_ENABLE();
            break;
142
143
144

        default:
            return false;
145
146
    }

147
    // init GPIO
148
149
150
151
152
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.Pin = GPIO_Pin;
    GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStructure.Pull = GPIO_PULLUP;
Damien George's avatar
Damien George committed
153
    GPIO_InitStructure.Alternate = GPIO_AF_UARTx;
154
155
    HAL_GPIO_Init(GPIO_Port, &GPIO_InitStructure);

Damien George's avatar
Damien George committed
156
157
158
    // init UARTx
    uart_obj->uart.Instance = UARTx;
    HAL_UART_Init(&uart_obj->uart);
159

Damien George's avatar
Damien George committed
160
    uart_obj->is_enabled = true;
161
162
163
164

    return true;
}

Damien George's avatar
Damien George committed
165
166
bool uart_init(pyb_uart_obj_t *uart_obj, uint32_t baudrate) {
    UART_HandleTypeDef *uh = &uart_obj->uart;
Dave Hylands's avatar
Dave Hylands committed
167
168
    memset(uh, 0, sizeof(*uh));
    uh->Init.BaudRate = baudrate;
169
170
171
172
    uh->Init.WordLength = UART_WORDLENGTH_8B;
    uh->Init.StopBits = UART_STOPBITS_1;
    uh->Init.Parity = UART_PARITY_NONE;
    uh->Init.Mode = UART_MODE_TX_RX;
Dave Hylands's avatar
Dave Hylands committed
173
174
    uh->Init.HwFlowCtl = UART_HWCONTROL_NONE;
    uh->Init.OverSampling = UART_OVERSAMPLING_16;
Damien George's avatar
Damien George committed
175
    return uart_init2(uart_obj);
176
}
177

Damien George's avatar
Damien George committed
178
179
180
void uart_deinit(pyb_uart_obj_t *uart_obj) {
    uart_obj->is_enabled = false;
    UART_HandleTypeDef *uart = &uart_obj->uart;
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
    HAL_UART_DeInit(uart);
    if (uart->Instance == USART1) {
        __USART1_FORCE_RESET();
        __USART1_RELEASE_RESET();
        __USART1_CLK_DISABLE();
    } else if (uart->Instance == USART2) {
        __USART2_FORCE_RESET();
        __USART2_RELEASE_RESET();
        __USART2_CLK_DISABLE();
    } else if (uart->Instance == USART3) {
        __USART3_FORCE_RESET();
        __USART3_RELEASE_RESET();
        __USART3_CLK_DISABLE();
    } else if (uart->Instance == UART4) {
        __UART4_FORCE_RESET();
        __UART4_RELEASE_RESET();
        __UART4_CLK_DISABLE();
    } else if (uart->Instance == USART6) {
        __USART6_FORCE_RESET();
        __USART6_RELEASE_RESET();
        __USART6_CLK_DISABLE();
    }
203
204
}

Damien George's avatar
Damien George committed
205
206
bool uart_rx_any(pyb_uart_obj_t *uart_obj) {
    return __HAL_UART_GET_FLAG(&uart_obj->uart, UART_FLAG_RXNE);
207
208
}

Damien George's avatar
Damien George committed
209
int uart_rx_char(pyb_uart_obj_t *uart_obj) {
210
    uint8_t ch;
Damien George's avatar
Damien George committed
211
    if (HAL_UART_Receive(&uart_obj->uart, &ch, 1, 0) != HAL_OK) {
212
213
214
215
216
        ch = 0;
    }
    return ch;
}

Damien George's avatar
Damien George committed
217
void uart_tx_char(pyb_uart_obj_t *uart_obj, int c) {
218
    uint8_t ch = c;
Damien George's avatar
Damien George committed
219
    HAL_UART_Transmit(&uart_obj->uart, &ch, 1, 100000);
220
221
}

Damien George's avatar
Damien George committed
222
223
void uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
    HAL_UART_Transmit(&uart_obj->uart, (uint8_t*)str, len, 100000);
224
225
}

Damien George's avatar
Damien George committed
226
void uart_tx_strn_cooked(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
227
228
    for (const char *top = str + len; str < top; str++) {
        if (*str == '\n') {
Damien George's avatar
Damien George committed
229
            uart_tx_char(uart_obj, '\r');
230
        }
Damien George's avatar
Damien George committed
231
        uart_tx_char(uart_obj, *str);
232
233
234
235
236
237
    }
}

/******************************************************************************/
/* Micro Python bindings                                                      */

Damien George's avatar
Damien George committed
238
239
STATIC void pyb_uart_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
    pyb_uart_obj_t *self = self_in;
240
    if (!self->is_enabled) {
Damien George's avatar
Damien George committed
241
        print(env, "UART(%lu)", self->uart_id);
242
    } else {
Damien George's avatar
Damien George committed
243
244
        print(env, "UART(%lu, baudrate=%u, bits=%u, stop=%u",
            self->uart_id, self->uart.Init.BaudRate,
245
246
247
248
249
250
251
252
            self->uart.Init.WordLength == UART_WORDLENGTH_8B ? 8 : 9,
            self->uart.Init.StopBits == UART_STOPBITS_1 ? 1 : 2);
        if (self->uart.Init.Parity == UART_PARITY_NONE) {
            print(env, ", parity=None)");
        } else {
            print(env, ", parity=%u)", self->uart.Init.Parity == UART_PARITY_EVEN ? 0 : 1);
        }
    }
253
254
}

255
256
257
258
259
260
261
262
/// \method init(baudrate, *, bits=8, stop=1, parity=None)
///
/// Initialise the SPI bus with the given parameters:
///
///   - `baudrate` is the clock rate.
///   - `bits` is the number of bits per byte, 8 or 9.
///   - `stop` is the number of stop bits, 1 or 2.
///   - `parity` is the parity, `None`, 0 (even) or 1 (odd).
263
264
265
266
267
STATIC const mp_arg_t pyb_uart_init_args[] = {
    { MP_QSTR_baudrate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 9600} },
    { MP_QSTR_bits,     MP_ARG_KW_ONLY | MP_ARG_INT,  {.u_int = 8} },
    { MP_QSTR_stop,     MP_ARG_KW_ONLY | MP_ARG_INT,  {.u_int = 1} },
    { MP_QSTR_parity,   MP_ARG_KW_ONLY | MP_ARG_OBJ,  {.u_obj = mp_const_none} },
268
};
269
#define PYB_UART_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_init_args)
270

271
STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
272
    // parse args
273
274
    mp_arg_val_t vals[PYB_UART_INIT_NUM_ARGS];
    mp_arg_parse_all(n_args, args, kw_args, PYB_UART_INIT_NUM_ARGS, pyb_uart_init_args, vals);
275

Damien George's avatar
Damien George committed
276
    // set the UART configuration values
277
278
279
280
281
282
283
284
285
286
287
    memset(&self->uart, 0, sizeof(self->uart));
    UART_InitTypeDef *init = &self->uart.Init;
    init->BaudRate = vals[0].u_int;
    init->WordLength = vals[1].u_int == 8 ? UART_WORDLENGTH_8B : UART_WORDLENGTH_9B;
    switch (vals[2].u_int) {
        case 1: init->StopBits = UART_STOPBITS_1; break;
        default: init->StopBits = UART_STOPBITS_2; break;
    }
    if (vals[3].u_obj == mp_const_none) {
        init->Parity = UART_PARITY_NONE;
    } else {
288
        mp_int_t parity = mp_obj_get_int(vals[3].u_obj);
289
290
291
292
293
294
        init->Parity = (parity & 1) ? UART_PARITY_ODD : UART_PARITY_EVEN;
    }
    init->Mode = UART_MODE_TX_RX;
    init->HwFlowCtl = UART_HWCONTROL_NONE;
    init->OverSampling = UART_OVERSAMPLING_16;

Damien George's avatar
Damien George committed
295
296
297
    // init UART (if it fails, it's because the port doesn't exist)
    if (!uart_init2(self)) {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART port %d does not exist", self->uart_id));
298
299
    }

300
301
302
    return mp_const_none;
}

303
304
305
306
307
308
309
/// \classmethod \constructor(bus, ...)
///
/// Construct a UART object on the given bus.  `bus` can be 1-6, or 'XA', 'XB', 'YA', or 'YB'.
/// With no additional parameters, the UART 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.
310
311
312
313
314
315
316
317
///
/// The physical pins of the UART busses are:
///
///   - `UART(4)` is on `XA`: `(TX, RX) = (X1, X2) = (PA0, PA1)`
///   - `UART(1)` is on `XB`: `(TX, RX) = (X9, X10) = (PB6, PB7)`
///   - `UART(6)` is on `YA`: `(TX, RX) = (Y1, Y2) = (PC6, PC7)`
///   - `UART(3)` is on `YB`: `(TX, RX) = (Y9, Y10) = (PB10, PB11)`
///   - `UART(2)` is on: `(TX, RX) = (X3, X4) = (PA2, PA3)`
318
STATIC mp_obj_t pyb_uart_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
319
320
321
    // check arguments
    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);

322
    // create object
Damien George's avatar
Damien George committed
323
324
    pyb_uart_obj_t *o = m_new_obj(pyb_uart_obj_t);
    o->base.type = &pyb_uart_type;
325

326
    // work out port
Damien George's avatar
Damien George committed
327
    o->uart_id = 0;
328
329
    if (MP_OBJ_IS_STR(args[0])) {
        const char *port = mp_obj_str_get_str(args[0]);
330
331
332
        if (0) {
#if defined(PYBV10)
        } else if (strcmp(port, "XA") == 0) {
Damien George's avatar
Damien George committed
333
            o->uart_id = PYB_UART_XA;
334
        } else if (strcmp(port, "XB") == 0) {
Damien George's avatar
Damien George committed
335
            o->uart_id = PYB_UART_XB;
336
        } else if (strcmp(port, "YA") == 0) {
Damien George's avatar
Damien George committed
337
            o->uart_id = PYB_UART_YA;
338
        } else if (strcmp(port, "YB") == 0) {
Damien George's avatar
Damien George committed
339
            o->uart_id = PYB_UART_YB;
340
#endif
341
        } else {
Damien George's avatar
Damien George committed
342
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART port %s does not exist", port));
343
        }
344
    } else {
Damien George's avatar
Damien George committed
345
        o->uart_id = mp_obj_get_int(args[0]);
346
347
    }

348
349
350
351
    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);
Damien George's avatar
Damien George committed
352
        pyb_uart_init_helper(o, n_args - 1, args + 1, &kw_args);
353
354
    }

355
356
357
    return o;
}

358
STATIC mp_obj_t pyb_uart_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
Damien George's avatar
Damien George committed
359
    return pyb_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
360
}
Damien George's avatar
Damien George committed
361
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
362

363
364
/// \method deinit()
/// Turn off the UART bus.
Damien George's avatar
Damien George committed
365
366
367
STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
    uart_deinit(self);
368
369
    return mp_const_none;
}
Damien George's avatar
Damien George committed
370
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_deinit_obj, pyb_uart_deinit);
371

372
373
/// \method any()
/// Return `True` if any characters waiting, else `False`.
Damien George's avatar
Damien George committed
374
375
376
STATIC mp_obj_t pyb_uart_any(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
    if (uart_rx_any(self)) {
377
378
379
380
381
        return mp_const_true;
    } else {
        return mp_const_false;
    }
}
Damien George's avatar
Damien George committed
382
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_any_obj, pyb_uart_any);
383

384
385
386
387
388
389
390
/// \method send(send, *, timeout=5000)
/// Send data on the bus:
///
///   - `send` is the data to send (an integer to send, or a buffer object).
///   - `timeout` is the timeout in milliseconds to wait for the send.
///
/// Return value: `None`.
391
392
393
STATIC const mp_arg_t pyb_uart_send_args[] = {
    { MP_QSTR_send,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
    { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
394
};
395
#define PYB_UART_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_send_args)
396

397
STATIC mp_obj_t pyb_uart_send(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
398
    // TODO assumes transmission size is 8-bits wide
399

Damien George's avatar
Damien George committed
400
    pyb_uart_obj_t *self = args[0];
401

402
    // parse args
403
404
    mp_arg_val_t vals[PYB_UART_SEND_NUM_ARGS];
    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_UART_SEND_NUM_ARGS, pyb_uart_send_args, vals);
405
406
407
408
409
410
411
412
413
414
415
416

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

    // send the data
    HAL_StatusTypeDef status = HAL_UART_Transmit(&self->uart, bufinfo.buf, bufinfo.len, vals[1].u_int);

    if (status != HAL_OK) {
        // TODO really need a HardwareError object, or something
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "HAL_UART_Transmit failed with code %d", status));
417
    }
418

419
420
    return mp_const_none;
}
Damien George's avatar
Damien George committed
421
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_send_obj, 1, pyb_uart_send);
422

423
424
425
426
427
428
429
430
431
432
/// \method recv(recv, *, 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.
///   - `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`.
433
434
435
STATIC const mp_arg_t pyb_uart_recv_args[] = {
    { MP_QSTR_recv,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
    { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
436
};
437
#define PYB_UART_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_recv_args)
438

439
STATIC mp_obj_t pyb_uart_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
440
    // TODO assumes transmission size is 8-bits wide
441

Damien George's avatar
Damien George committed
442
    pyb_uart_obj_t *self = args[0];
443

444
    // parse args
445
446
    mp_arg_val_t vals[PYB_UART_RECV_NUM_ARGS];
    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_UART_RECV_NUM_ARGS, pyb_uart_recv_args, vals);
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466

    // get the buffer to receive into
    mp_buffer_info_t bufinfo;
    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &bufinfo);

    // receive the data
    HAL_StatusTypeDef status = HAL_UART_Receive(&self->uart, bufinfo.buf, bufinfo.len, vals[1].u_int);

    if (status != HAL_OK) {
        // TODO really need a HardwareError object, or something
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "HAL_UART_Receive failed with code %d", status));
    }

    // return the received data
    if (o_ret == MP_OBJ_NULL) {
        return vals[0].u_obj;
    } else {
        return mp_obj_str_builder_end(o_ret);
    }
}
Damien George's avatar
Damien George committed
467
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_recv_obj, 1, pyb_uart_recv);
468

Damien George's avatar
Damien George committed
469
STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
470
    // instance methods
Damien George's avatar
Damien George committed
471
472
473
474
475
    { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pyb_uart_init_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit), (mp_obj_t)&pyb_uart_deinit_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_any), (mp_obj_t)&pyb_uart_any_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_send), (mp_obj_t)&pyb_uart_send_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_recv), (mp_obj_t)&pyb_uart_recv_obj },
476
477
};

Damien George's avatar
Damien George committed
478
STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
479

480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
mp_uint_t uart_ioctl(mp_obj_t self_in, mp_uint_t request, int *errcode, ...) {
    pyb_uart_obj_t *self = self_in;
    va_list vargs;
    va_start(vargs, errcode);
    mp_uint_t ret;
    if (request == MP_IOCTL_POLL) {
        mp_uint_t flags = va_arg(vargs, mp_uint_t);
        ret = 0;
        if (flags & MP_IOCTL_POLL_RD && uart_rx_any(self)) {
            ret |= MP_IOCTL_POLL_RD;
        }
        if (flags & MP_IOCTL_POLL_WR) {
            // TODO can we always write?
            ret |= MP_IOCTL_POLL_WR;
        }
    } else {
        *errcode = 1; // EPERM, operation not permitted
        ret = -1;
    }
    va_end(vargs);
    return ret;
}

STATIC const mp_stream_p_t uart_stream_p = {
    //.read = uart_read, // TODO
    //.write = uart_write, // TODO
    .ioctl = uart_ioctl,
    .is_text = false,
};

Damien George's avatar
Damien George committed
510
const mp_obj_type_t pyb_uart_type = {
511
    { &mp_type_type },
Damien George's avatar
Damien George committed
512
513
514
    .name = MP_QSTR_UART,
    .print = pyb_uart_print,
    .make_new = pyb_uart_make_new,
515
    .stream_p = &uart_stream_p,
Damien George's avatar
Damien George committed
516
    .locals_dict = (mp_obj_t)&pyb_uart_locals_dict,
517
};