uart.c 25.6 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
#include <errno.h>
31

32
33
34
#include "py/nlr.h"
#include "py/runtime.h"
#include "py/stream.h"
Damien George's avatar
Damien George committed
35
#include "uart.h"
36
#include "pybioctl.h"
37
#include MICROPY_HAL_H
38

39
40
41
42
/// \moduleref pyb
/// \class UART - duplex serial communication bus
///
/// UART implements the standard UART/USART duplex serial communications protocol.  At
43
44
45
/// the physical level it consists of 2 lines: RX and TX.  The unit of communication
/// is a character (not to be confused with a string character) which can be 8 or 9
/// bits wide.
46
///
47
/// UART objects can be created and initialised using:
48
49
50
51
///
///     from pyb import UART
///
///     uart = UART(1, 9600)                         # init with given baudrate
52
///     uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
53
///
54
/// Bits can be 8 or 9.  Parity can be None, 0 (even) or 1 (odd).  Stop can be 1 or 2.
55
///
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/// A UART object acts like a stream object and reading and writing is done
/// using the standard stream methods:
///
///     uart.read(10)       # read 10 characters, returns a bytes object
///     uart.readall()      # read all available characters
///     uart.readline()     # read a line
///     uart.readinto(buf)  # read and store into the given buffer
///     uart.write('abc')   # write the 3 characters
///
/// Individual characters can be read/written using:
///
///     uart.readchar()     # read 1 character and returns it as an integer
///     uart.writechar(42)  # write 1 character
///
/// To check if there is anything to be read, use:
71
72
///
///     uart.any()               # returns True if any characters waiting
73

74
75
76
#define CHAR_WIDTH_8BIT (0)
#define CHAR_WIDTH_9BIT (1)

Damien George's avatar
Damien George committed
77
struct _pyb_uart_obj_t {
Dave Hylands's avatar
Dave Hylands committed
78
    mp_obj_base_t base;
79
    UART_HandleTypeDef uart;            // this is 17 words big
80
    IRQn_Type irqn;
81
82
83
84
    pyb_uart_t uart_id : 8;
    bool is_enabled : 1;
    byte char_width;                    // 0 for 7,8 bit chars, 1 for 9 bit chars
    uint16_t char_mask;                 // 0x7f for 7 bit, 0xff for 8 bit, 0x1ff for 9 bit
85
86
87
88
89
90
    uint16_t timeout;                   // timeout waiting for first char
    uint16_t timeout_char;              // timeout waiting between chars
    uint16_t read_buf_len;              // len in chars; buf can hold len-1 chars
    volatile uint16_t read_buf_head;    // indexes first empty slot
    uint16_t read_buf_tail;             // indexes first full slot (not full if equals head)
    byte *read_buf;                     // byte or uint16_t, depending on char size
Dave Hylands's avatar
Dave Hylands committed
91
};
92

93
94
95
STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in);

void uart_init0(void) {
96
97
    for (int i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_uart_obj_all)); i++) {
        MP_STATE_PORT(pyb_uart_obj_all)[i] = NULL;
98
99
100
101
102
    }
}

// unregister all interrupt sources
void uart_deinit(void) {
103
104
    for (int i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_uart_obj_all)); i++) {
        pyb_uart_obj_t *uart_obj = MP_STATE_PORT(pyb_uart_obj_all)[i];
105
106
107
108
109
110
        if (uart_obj != NULL) {
            pyb_uart_deinit(uart_obj);
        }
    }
}

111
// assumes Init parameters have been set up correctly
112
STATIC bool uart_init2(pyb_uart_obj_t *uart_obj) {
113
114
115
116
    USART_TypeDef *UARTx;
    IRQn_Type irqn;
    uint32_t GPIO_Pin;
    uint8_t GPIO_AF_UARTx = 0;
117
    GPIO_TypeDef* GPIO_Port = NULL;
118

Damien George's avatar
Damien George committed
119
120
121
122
    switch (uart_obj->uart_id) {
        // USART1 is on PA9/PA10 (CK on PA8), PB6/PB7
        case PYB_UART_1:
            UARTx = USART1;
123
            irqn = USART1_IRQn;
Damien George's avatar
Damien George committed
124
            GPIO_AF_UARTx = GPIO_AF7_USART1;
125

Damien George's avatar
Damien George committed
126
#if defined (PYBV4) || defined(PYBV10)
127
128
129
            GPIO_Port = GPIOB;
            GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7;
#else
130
131
            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_9 | GPIO_PIN_10;
132
#endif
133
134
135

            __USART1_CLK_ENABLE();
            break;
136

137
        // USART2 is on PA2/PA3 (CTS,RTS,CK on PA0,PA1,PA4), PD5/PD6 (CK on PD7)
Damien George's avatar
Damien George committed
138
139
        case PYB_UART_2:
            UARTx = USART2;
140
            irqn = USART2_IRQn;
Damien George's avatar
Damien George committed
141
            GPIO_AF_UARTx = GPIO_AF7_USART2;
142

Damien George's avatar
Damien George committed
143
144
            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_2 | GPIO_PIN_3;
145

146
147
148
149
150
151
152
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
                GPIO_Pin |= GPIO_PIN_1;
            }
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
                GPIO_Pin |= GPIO_PIN_0;
            }

153
154
            __USART2_CLK_ENABLE();
            break;
155

156
        // USART3 is on PB10/PB11 (CK,CTS,RTS on PB12,PB13,PB14), PC10/PC11 (CK on PC12), PD8/PD9 (CK on PD10)
Damien George's avatar
Damien George committed
157
158
        case PYB_UART_3:
            UARTx = USART3;
159
            irqn = USART3_IRQn;
Damien George's avatar
Damien George committed
160
            GPIO_AF_UARTx = GPIO_AF7_USART3;
161

162
#if defined(PYBV3) || defined(PYBV4) | defined(PYBV10)
163
164
            GPIO_Port = GPIOB;
            GPIO_Pin = GPIO_PIN_10 | GPIO_PIN_11;
165
166
167
168
169
170
171

            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
                GPIO_Pin |= GPIO_PIN_14;
            }
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
                GPIO_Pin |= GPIO_PIN_13;
            }
172
173
174
175
176
177
#else
            GPIO_Port = GPIOD;
            GPIO_Pin = GPIO_PIN_8 | GPIO_PIN_9;
#endif
            __USART3_CLK_ENABLE();
            break;
178

179
        // UART4 is on PA0/PA1, PC10/PC11
Damien George's avatar
Damien George committed
180
181
        case PYB_UART_4:
            UARTx = UART4;
182
            irqn = UART4_IRQn;
Damien George's avatar
Damien George committed
183
            GPIO_AF_UARTx = GPIO_AF8_UART4;
184
185
186
187
188
189
190

            GPIO_Port = GPIOA;
            GPIO_Pin = GPIO_PIN_0 | GPIO_PIN_1;

            __UART4_CLK_ENABLE();
            break;

Damien George's avatar
Damien George committed
191
192
193
        // USART6 is on PC6/PC7 (CK on PC8)
        case PYB_UART_6:
            UARTx = USART6;
194
            irqn = USART6_IRQn;
Damien George's avatar
Damien George committed
195
            GPIO_AF_UARTx = GPIO_AF8_USART6;
196
197
198
199
200
201

            GPIO_Port = GPIOC;
            GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7;

            __USART6_CLK_ENABLE();
            break;
202
203
204

        default:
            return false;
205
206
    }

207
208
209
    uart_obj->irqn = irqn;
    uart_obj->uart.Instance = UARTx;

210
    // init GPIO
211
212
213
214
215
    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
216
    GPIO_InitStructure.Alternate = GPIO_AF_UARTx;
217
218
    HAL_GPIO_Init(GPIO_Port, &GPIO_InitStructure);

Damien George's avatar
Damien George committed
219
220
    // init UARTx
    HAL_UART_Init(&uart_obj->uart);
221

Damien George's avatar
Damien George committed
222
    uart_obj->is_enabled = true;
223
224
225
226

    return true;
}

227
/* obsolete and unused
Damien George's avatar
Damien George committed
228
229
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
230
231
    memset(uh, 0, sizeof(*uh));
    uh->Init.BaudRate = baudrate;
232
233
234
235
    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
236
237
    uh->Init.HwFlowCtl = UART_HWCONTROL_NONE;
    uh->Init.OverSampling = UART_OVERSAMPLING_16;
Damien George's avatar
Damien George committed
238
    return uart_init2(uart_obj);
239
}
240
*/
241

242
243
244
bool uart_rx_any(pyb_uart_obj_t *self) {
    return self->read_buf_tail != self->read_buf_head
        || __HAL_UART_GET_FLAG(&self->uart, UART_FLAG_RXNE) != RESET;
245
246
}

247
248
249
250
251
252
253
254
255
256
257
258
259
260
// Waits at most timeout milliseconds for at least 1 char to become ready for
// reading (from buf or for direct reading).
// Returns true if something available, false if not.
STATIC bool uart_rx_wait(pyb_uart_obj_t *self, uint32_t timeout) {
    uint32_t start = HAL_GetTick();
    for (;;) {
        if (self->read_buf_tail != self->read_buf_head || __HAL_UART_GET_FLAG(&self->uart, UART_FLAG_RXNE) != RESET) {
            return true; // have at least 1 char ready for reading
        }
        if (HAL_GetTick() - start >= timeout) {
            return false; // timeout
        }
        __WFI();
    }
261
262
}

263
264
265
266
267
268
269
270
271
272
273
274
275
276
// assumes there is a character available
int uart_rx_char(pyb_uart_obj_t *self) {
    if (self->read_buf_tail != self->read_buf_head) {
        // buffering via IRQ
        int data;
        if (self->char_width == CHAR_WIDTH_9BIT) {
            data = ((uint16_t*)self->read_buf)[self->read_buf_tail];
        } else {
            data = self->read_buf[self->read_buf_tail];
        }
        self->read_buf_tail = (self->read_buf_tail + 1) % self->read_buf_len;
        return data;
    } else {
        // no buffering
277
        return self->uart.Instance->DR & self->char_mask;
278
279
280
    }
}

281
STATIC void uart_tx_char(pyb_uart_obj_t *uart_obj, int c) {
282
    uint8_t ch = c;
283
    HAL_UART_Transmit(&uart_obj->uart, &ch, 1, uart_obj->timeout);
284
285
}

Damien George's avatar
Damien George committed
286
void uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
287
    HAL_UART_Transmit(&uart_obj->uart, (uint8_t*)str, len, uart_obj->timeout);
288
289
}

Damien George's avatar
Damien George committed
290
void uart_tx_strn_cooked(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
291
292
    for (const char *top = str + len; str < top; str++) {
        if (*str == '\n') {
Damien George's avatar
Damien George committed
293
            uart_tx_char(uart_obj, '\r');
294
        }
Damien George's avatar
Damien George committed
295
        uart_tx_char(uart_obj, *str);
296
297
298
    }
}

299
300
301
// this IRQ handler is set up to handle RXNE interrupts only
void uart_irq_handler(mp_uint_t uart_id) {
    // get the uart object
302
    pyb_uart_obj_t *self = MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1];
303
304
305
306
307
308
309
310
311

    if (self == NULL) {
        // UART object has not been set, so we can't do anything, not
        // even disable the IRQ.  This should never happen.
        return;
    }

    if (__HAL_UART_GET_FLAG(&self->uart, UART_FLAG_RXNE) != RESET) {
        int data = self->uart.Instance->DR; // clears UART_FLAG_RXNE
312
        data &= self->char_mask;
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
        if (self->read_buf_len != 0) {
            uint16_t next_head = (self->read_buf_head + 1) % self->read_buf_len;
            if (next_head != self->read_buf_tail) {
                // only store data if room in buf
                if (self->char_width == CHAR_WIDTH_9BIT) {
                    ((uint16_t*)self->read_buf)[self->read_buf_head] = data;
                } else {
                    self->read_buf[self->read_buf_head] = data;
                }
                self->read_buf_head = next_head;
            }
        } else {
            // TODO set flag for buffer overflow
        }
    }
}

330
331
332
/******************************************************************************/
/* Micro Python bindings                                                      */

Damien George's avatar
Damien George committed
333
334
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;
335
    if (!self->is_enabled) {
336
        print(env, "UART(%u)", self->uart_id);
337
    } else {
338
339
340
341
        mp_int_t bits = (self->uart.Init.WordLength == UART_WORDLENGTH_8B ? 8 : 9);
        if (self->uart.Init.Parity != UART_PARITY_NONE) {
            bits -= 1;
        }
342
        print(env, "UART(%u, baudrate=%u, bits=%u, parity=",
343
            self->uart_id, self->uart.Init.BaudRate, bits);
344
        if (self->uart.Init.Parity == UART_PARITY_NONE) {
345
            print(env, "None");
346
        } else {
347
            print(env, "%u", self->uart.Init.Parity == UART_PARITY_EVEN ? 0 : 1);
348
        }
349
350
351
        print(env, ", stop=%u, timeout=%u, timeout_char=%u, read_buf_len=%u)",
            self->uart.Init.StopBits == UART_STOPBITS_1 ? 1 : 2,
            self->timeout, self->timeout_char, self->read_buf_len);
352
    }
353
354
}

355
/// \method init(baudrate, bits=8, parity=None, stop=1, *, timeout=1000, timeout_char=0, read_buf_len=64)
356
///
357
/// Initialise the UART bus with the given parameters:
358
359
///
///   - `baudrate` is the clock rate.
360
///   - `bits` is the number of bits per byte, 7, 8 or 9.
361
///   - `parity` is the parity, `None`, 0 (even) or 1 (odd).
362
363
364
365
366
367
368
369
370
371
///   - `stop` is the number of stop bits, 1 or 2.
///   - `timeout` is the timeout in milliseconds to wait for the first character.
///   - `timeout_char` is the timeout in milliseconds to wait between characters.
///   - `read_buf_len` is the character length of the read buffer (0 to disable).
STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_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_baudrate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 9600} },
        { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
        { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = mp_const_none} },
        { MP_QSTR_stop, MP_ARG_INT, {.u_int = 1} },
372
        { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_HWCONTROL_NONE} },
373
374
375
376
        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
        { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
        { MP_QSTR_read_buf_len, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 64} },
    };
377
378

    // parse args
379
380
    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);
381

Damien George's avatar
Damien George committed
382
    // set the UART configuration values
383
384
    memset(&self->uart, 0, sizeof(self->uart));
    UART_InitTypeDef *init = &self->uart.Init;
385
386

    // baudrate
387
    init->BaudRate = args[0].u_int;
388
389
390

    // parity
    mp_int_t bits = args[1].u_int;
391
    if (args[2].u_obj == mp_const_none) {
392
393
        init->Parity = UART_PARITY_NONE;
    } else {
394
        mp_int_t parity = mp_obj_get_int(args[2].u_obj);
395
        init->Parity = (parity & 1) ? UART_PARITY_ODD : UART_PARITY_EVEN;
396
        bits += 1; // STs convention has bits including parity
397
    }
398
399
400
401
402
403
404
405
406
407
408

    // number of bits
    if (bits == 8) {
        init->WordLength = UART_WORDLENGTH_8B;
    } else if (bits == 9) {
        init->WordLength = UART_WORDLENGTH_9B;
    } else {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "unsupported combination of bits and parity"));
    }

    // stop bits
409
410
411
412
    switch (args[3].u_int) {
        case 1: init->StopBits = UART_STOPBITS_1; break;
        default: init->StopBits = UART_STOPBITS_2; break;
    }
413
414

    // flow control
415
    init->HwFlowCtl = args[4].u_int;
416
417
418

    // extra config (not yet configurable)
    init->Mode = UART_MODE_TX_RX;
419
420
    init->OverSampling = UART_OVERSAMPLING_16;

Damien George's avatar
Damien George committed
421
422
    // init UART (if it fails, it's because the port doesn't exist)
    if (!uart_init2(self)) {
423
424
425
426
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", self->uart_id));
    }

    // set timeouts
427
428
    self->timeout = args[5].u_int;
    self->timeout_char = args[6].u_int;
429
430
431
432

    // setup the read buffer
    m_del(byte, self->read_buf, self->read_buf_len << self->char_width);
    if (init->WordLength == UART_WORDLENGTH_9B && init->Parity == UART_PARITY_NONE) {
433
        self->char_mask = 0x1ff;
434
435
        self->char_width = CHAR_WIDTH_9BIT;
    } else {
436
437
438
439
440
        if (init->WordLength == UART_WORDLENGTH_9B || init->Parity == UART_PARITY_NONE) {
            self->char_mask = 0xff;
        } else {
            self->char_mask = 0x7f;
        }
441
442
443
444
        self->char_width = CHAR_WIDTH_8BIT;
    }
    self->read_buf_head = 0;
    self->read_buf_tail = 0;
445
    if (args[7].u_int <= 0) {
446
447
448
449
450
451
452
        // no read buffer
        self->read_buf_len = 0;
        self->read_buf = NULL;
        HAL_NVIC_DisableIRQ(self->irqn);
        __HAL_UART_DISABLE_IT(&self->uart, UART_IT_RXNE);
    } else {
        // read buffer using interrupts
453
454
        self->read_buf_len = args[7].u_int;
        self->read_buf = m_new(byte, args[7].u_int << self->char_width);
455
456
457
        __HAL_UART_ENABLE_IT(&self->uart, UART_IT_RXNE);
        HAL_NVIC_SetPriority(self->irqn, 0xd, 0xd); // next-to-next-to lowest priority
        HAL_NVIC_EnableIRQ(self->irqn);
458
459
    }

460
461
462
    return mp_const_none;
}

463
464
465
466
467
468
469
/// \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.
470
471
472
473
474
475
476
477
///
/// 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)`
478
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) {
479
480
481
    // check arguments
    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);

482
    // work out port
483
    int uart_id = 0;
484
485
    if (MP_OBJ_IS_STR(args[0])) {
        const char *port = mp_obj_str_get_str(args[0]);
486
487
488
        if (0) {
#if defined(PYBV10)
        } else if (strcmp(port, "XA") == 0) {
489
            uart_id = PYB_UART_XA;
490
        } else if (strcmp(port, "XB") == 0) {
491
            uart_id = PYB_UART_XB;
492
        } else if (strcmp(port, "YA") == 0) {
493
            uart_id = PYB_UART_YA;
494
        } else if (strcmp(port, "YB") == 0) {
495
            uart_id = PYB_UART_YB;
496
#endif
497
        } else {
498
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%s) does not exist", port));
499
        }
500
    } else {
501
        uart_id = mp_obj_get_int(args[0]);
502
        if (uart_id < 1 || uart_id > MP_ARRAY_SIZE(MP_STATE_PORT(pyb_uart_obj_all))) {
503
504
505
506
507
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id));
        }
    }

    pyb_uart_obj_t *self;
508
    if (MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1] == NULL) {
509
510
511
512
        // create new UART object
        self = m_new0(pyb_uart_obj_t, 1);
        self->base.type = &pyb_uart_type;
        self->uart_id = uart_id;
513
        MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1] = self;
514
515
    } else {
        // reference existing UART object
516
        self = MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1];
517
518
    }

519
520
521
522
    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);
523
        pyb_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
524
525
    }

526
    return self;
527
528
}

529
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
530
    return pyb_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
531
}
Damien George's avatar
Damien George committed
532
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
533

534
535
/// \method deinit()
/// Turn off the UART bus.
Damien George's avatar
Damien George committed
536
537
STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
    self->is_enabled = false;
    UART_HandleTypeDef *uart = &self->uart;
    HAL_UART_DeInit(uart);
    if (uart->Instance == USART1) {
        HAL_NVIC_DisableIRQ(USART1_IRQn);
        __USART1_FORCE_RESET();
        __USART1_RELEASE_RESET();
        __USART1_CLK_DISABLE();
    } else if (uart->Instance == USART2) {
        HAL_NVIC_DisableIRQ(USART2_IRQn);
        __USART2_FORCE_RESET();
        __USART2_RELEASE_RESET();
        __USART2_CLK_DISABLE();
    } else if (uart->Instance == USART3) {
        HAL_NVIC_DisableIRQ(USART3_IRQn);
        __USART3_FORCE_RESET();
        __USART3_RELEASE_RESET();
        __USART3_CLK_DISABLE();
    } else if (uart->Instance == UART4) {
        HAL_NVIC_DisableIRQ(UART4_IRQn);
        __UART4_FORCE_RESET();
        __UART4_RELEASE_RESET();
        __UART4_CLK_DISABLE();
    } else if (uart->Instance == USART6) {
        HAL_NVIC_DisableIRQ(USART6_IRQn);
        __USART6_FORCE_RESET();
        __USART6_RELEASE_RESET();
        __USART6_CLK_DISABLE();
    }
567
568
    return mp_const_none;
}
Damien George's avatar
Damien George committed
569
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_deinit_obj, pyb_uart_deinit);
570

571
572
/// \method any()
/// Return `True` if any characters waiting, else `False`.
Damien George's avatar
Damien George committed
573
574
575
STATIC mp_obj_t pyb_uart_any(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
    if (uart_rx_any(self)) {
576
577
578
579
580
        return mp_const_true;
    } else {
        return mp_const_false;
    }
}
Damien George's avatar
Damien George committed
581
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_any_obj, pyb_uart_any);
582

583
584
/// \method writechar(char)
/// Write a single character on the bus.  `char` is an integer to write.
585
/// Return value: `None`.
586
587
STATIC mp_obj_t pyb_uart_writechar(mp_obj_t self_in, mp_obj_t char_in) {
    pyb_uart_obj_t *self = self_in;
588

589
590
    // get the character to write (might be 9 bits)
    uint16_t data = mp_obj_get_int(char_in);
591

592
593
    // write the data
    HAL_StatusTypeDef status = HAL_UART_Transmit(&self->uart, (uint8_t*)&data, 1, self->timeout);
594
595

    if (status != HAL_OK) {
596
        mp_hal_raise(status);
597
    }
598

599
600
    return mp_const_none;
}
601
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_uart_writechar_obj, pyb_uart_writechar);
602

603
604
605
606
607
608
609
610
611
612
613
614
615
616
/// \method readchar()
/// Receive a single character on the bus.
/// Return value: The character read, as an integer.  Returns -1 on timeout.
STATIC mp_obj_t pyb_uart_readchar(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
    if (uart_rx_wait(self, self->timeout)) {
        return MP_OBJ_NEW_SMALL_INT(uart_rx_char(self));
    } else {
        // return -1 on timeout
        return MP_OBJ_NEW_SMALL_INT(-1);
    }
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_readchar_obj, pyb_uart_readchar);

Damien George's avatar
Damien George committed
617
STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
618
    // instance methods
619

Damien George's avatar
Damien George committed
620
621
622
    { 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 },
623
624
625
626
627
628
629

    /// \method read([nbytes])
    { MP_OBJ_NEW_QSTR(MP_QSTR_read), (mp_obj_t)&mp_stream_read_obj },
    /// \method readall()
    { MP_OBJ_NEW_QSTR(MP_QSTR_readall), (mp_obj_t)&mp_stream_readall_obj },
    /// \method readline()
    { MP_OBJ_NEW_QSTR(MP_QSTR_readline), (mp_obj_t)&mp_stream_unbuffered_readline_obj},
Damien George's avatar
Damien George committed
630
631
    /// \method readinto(buf[, nbytes])
    { MP_OBJ_NEW_QSTR(MP_QSTR_readinto), (mp_obj_t)&mp_stream_readinto_obj },
632
633
634
635
636
    /// \method write(buf)
    { MP_OBJ_NEW_QSTR(MP_QSTR_write), (mp_obj_t)&mp_stream_write_obj },

    { MP_OBJ_NEW_QSTR(MP_QSTR_writechar), (mp_obj_t)&pyb_uart_writechar_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_readchar), (mp_obj_t)&pyb_uart_readchar_obj },
637
638
639
640

    // class constants
    { MP_OBJ_NEW_QSTR(MP_QSTR_RTS), MP_OBJ_NEW_SMALL_INT(UART_HWCONTROL_RTS) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_CTS), MP_OBJ_NEW_SMALL_INT(UART_HWCONTROL_CTS) },
641
642
};

Damien George's avatar
Damien George committed
643
STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
644

645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
    pyb_uart_obj_t *self = self_in;
    byte *buf = buf_in;

    // check that size is a multiple of character width
    if (size & self->char_width) {
        *errcode = EIO;
        return MP_STREAM_ERROR;
    }

    // convert byte size to char size
    size >>= self->char_width;

    // make sure we want at least 1 char
    if (size == 0) {
        return 0;
    }

    // wait for first char to become available
    if (!uart_rx_wait(self, self->timeout)) {
        // we can either return 0 to indicate EOF (then read() method returns b'')
        // or return EAGAIN error to indicate non-blocking (then read() method returns None)
        return 0;
    }

    // read the data
    byte *orig_buf = buf;
    for (;;) {
        int data = uart_rx_char(self);
        if (self->char_width == CHAR_WIDTH_9BIT) {
            *(uint16_t*)buf = data;
            buf += 2;
        } else {
            *buf++ = data;
        }
        if (--size == 0 || !uart_rx_wait(self, self->timeout_char)) {
            // return number of bytes read
            return buf - orig_buf;
        }
    }
}

STATIC mp_uint_t pyb_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
    pyb_uart_obj_t *self = self_in;
    const byte *buf = buf_in;

    // check that size is a multiple of character width
    if (size & self->char_width) {
        *errcode = EIO;
        return MP_STREAM_ERROR;
    }

    // write the data
    HAL_StatusTypeDef status = HAL_UART_Transmit(&self->uart, (uint8_t*)buf, size >> self->char_width, self->timeout);

    if (status == HAL_OK) {
        // return number of bytes written
        return size;
    } else {
704
        *errcode = mp_hal_status_to_errno_table[status];
705
706
707
708
        return MP_STREAM_ERROR;
    }
}

709
STATIC mp_uint_t pyb_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
710
711
712
    pyb_uart_obj_t *self = self_in;
    mp_uint_t ret;
    if (request == MP_IOCTL_POLL) {
713
        mp_uint_t flags = arg;
714
        ret = 0;
715
        if ((flags & MP_IOCTL_POLL_RD) && uart_rx_any(self)) {
716
717
            ret |= MP_IOCTL_POLL_RD;
        }
718
        if ((flags & MP_IOCTL_POLL_WR) && __HAL_UART_GET_FLAG(&self->uart, UART_FLAG_TXE)) {
719
720
721
            ret |= MP_IOCTL_POLL_WR;
        }
    } else {
722
        *errcode = EINVAL;
723
        ret = MP_STREAM_ERROR;
724
725
726
727
728
    }
    return ret;
}

STATIC const mp_stream_p_t uart_stream_p = {
729
730
731
    .read = pyb_uart_read,
    .write = pyb_uart_write,
    .ioctl = pyb_uart_ioctl,
732
733
734
    .is_text = false,
};

Damien George's avatar
Damien George committed
735
const mp_obj_type_t pyb_uart_type = {
736
    { &mp_type_type },
Damien George's avatar
Damien George committed
737
738
739
    .name = MP_QSTR_UART,
    .print = pyb_uart_print,
    .make_new = pyb_uart_make_new,
740
741
    .getiter = mp_identity,
    .iternext = mp_stream_unbuffered_iter,
742
    .stream_p = &uart_stream_p,
Damien George's avatar
Damien George committed
743
    .locals_dict = (mp_obj_t)&pyb_uart_locals_dict,
744
};