uart.c 29.5 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
//TODO: Add UART7/8 support for STM32F7

41
42
43
44
/// \moduleref pyb
/// \class UART - duplex serial communication bus
///
/// UART implements the standard UART/USART duplex serial communications protocol.  At
45
46
47
/// 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.
48
///
49
/// UART objects can be created and initialised using:
50
51
52
53
///
///     from pyb import UART
///
///     uart = UART(1, 9600)                         # init with given baudrate
54
///     uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
55
///
56
/// Bits can be 8 or 9.  Parity can be None, 0 (even) or 1 (odd).  Stop can be 1 or 2.
57
///
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/// 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:
73
74
///
///     uart.any()               # returns True if any characters waiting
75

76
77
78
#define CHAR_WIDTH_8BIT (0)
#define CHAR_WIDTH_9BIT (1)

Damien George's avatar
Damien George committed
79
struct _pyb_uart_obj_t {
Dave Hylands's avatar
Dave Hylands committed
80
    mp_obj_base_t base;
81
    UART_HandleTypeDef uart;            // this is 17 words big
82
    IRQn_Type irqn;
83
84
85
86
    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
87
88
89
90
91
92
    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
93
};
94

95
96
97
STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in);

void uart_init0(void) {
98
99
    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;
100
101
102
103
104
    }
}

// unregister all interrupt sources
void uart_deinit(void) {
105
106
    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];
107
108
109
110
111
112
        if (uart_obj != NULL) {
            pyb_uart_deinit(uart_obj);
        }
    }
}

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

Damien George's avatar
Damien George committed
122
    switch (uart_obj->uart_id) {
123
        #if defined(MICROPY_HW_UART1_PORT) && defined(MICROPY_HW_UART1_PINS)
Damien George's avatar
Damien George committed
124
125
126
        // USART1 is on PA9/PA10 (CK on PA8), PB6/PB7
        case PYB_UART_1:
            UARTx = USART1;
127
            irqn = USART1_IRQn;
Damien George's avatar
Damien George committed
128
            GPIO_AF_UARTx = GPIO_AF7_USART1;
129
130
            GPIO_Port = MICROPY_HW_UART1_PORT;
            GPIO_Pin = MICROPY_HW_UART1_PINS;
131
132
            __USART1_CLK_ENABLE();
            break;
133
        #endif
134

135
        #if defined(MICROPY_HW_UART2_PORT) && defined(MICROPY_HW_UART2_PINS)
136
        // USART2 is on PA2/PA3 (CTS,RTS,CK on PA0,PA1,PA4), PD5/PD6 (CK on PD7)
Damien George's avatar
Damien George committed
137
138
        case PYB_UART_2:
            UARTx = USART2;
139
            irqn = USART2_IRQn;
Damien George's avatar
Damien George committed
140
            GPIO_AF_UARTx = GPIO_AF7_USART2;
141
142
143
            GPIO_Port = MICROPY_HW_UART2_PORT;
            GPIO_Pin = MICROPY_HW_UART2_PINS;
            #if defined(MICROPY_HW_UART2_RTS)
144
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
145
                GPIO_Pin |= MICROPY_HW_UART2_RTS;
146
            }
147
148
            #endif
            #if defined(MICROPY_HW_UART2_CTS)
149
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
150
                GPIO_Pin |= MICROPY_HW_UART2_CTS;
151
            }
152
            #endif
153
154
            __USART2_CLK_ENABLE();
            break;
155
        #endif
156

157
        #if defined(USART3) && defined(MICROPY_HW_UART3_PORT) && defined(MICROPY_HW_UART3_PINS)
158
        // 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
159
160
        case PYB_UART_3:
            UARTx = USART3;
161
            irqn = USART3_IRQn;
Damien George's avatar
Damien George committed
162
            GPIO_AF_UARTx = GPIO_AF7_USART3;
163
164
165
            GPIO_Port = MICROPY_HW_UART3_PORT;
            GPIO_Pin = MICROPY_HW_UART3_PINS;
            #if defined(MICROPY_HW_UART3_RTS)
166
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
167
                GPIO_Pin |= MICROPY_HW_UART3_RTS;
168
            }
169
170
            #endif
            #if defined(MICROPY_HW_UART3_CTS)
171
            if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
172
                GPIO_Pin |= MICROPY_HW_UART3_CTS;
173
            }
174
            #endif
175
176
            __USART3_CLK_ENABLE();
            break;
177
        #endif
178

179
        #if defined(UART4) && defined(MICROPY_HW_UART4_PORT) && defined(MICROPY_HW_UART4_PINS)
180
        // UART4 is on PA0/PA1, PC10/PC11
Damien George's avatar
Damien George committed
181
182
        case PYB_UART_4:
            UARTx = UART4;
183
            irqn = UART4_IRQn;
Damien George's avatar
Damien George committed
184
            GPIO_AF_UARTx = GPIO_AF8_UART4;
185
186
            GPIO_Port = MICROPY_HW_UART4_PORT;
            GPIO_Pin = MICROPY_HW_UART4_PINS;
187
188
            __UART4_CLK_ENABLE();
            break;
189
        #endif
190

Dave Hylands's avatar
Dave Hylands committed
191
192
193
194
195
196
197
198
199
200
        #if defined(UART5) && \
            defined(MICROPY_HW_UART5_TX_PORT) && \
            defined(MICROPY_HW_UART5_TX_PIN) && \
            defined(MICROPY_HW_UART5_RX_PORT) && \
            defined(MICROPY_HW_UART5_RX_PIN)
        case PYB_UART_5:
            UARTx = UART5;
            irqn = UART5_IRQn;
            GPIO_AF_UARTx = GPIO_AF8_UART5;
            GPIO_Port = MICROPY_HW_UART5_TX_PORT;
201
            GPIO_Port2 = MICROPY_HW_UART5_RX_PORT;
Dave Hylands's avatar
Dave Hylands committed
202
            GPIO_Pin = MICROPY_HW_UART5_TX_PIN;
203
            GPIO_Pin2 = MICROPY_HW_UART5_RX_PIN;
Dave Hylands's avatar
Dave Hylands committed
204
205
206
207
            __UART5_CLK_ENABLE();
            break;
        #endif

208
        #if defined(MICROPY_HW_UART6_PORT) && defined(MICROPY_HW_UART6_PINS)
Damien George's avatar
Damien George committed
209
210
211
        // USART6 is on PC6/PC7 (CK on PC8)
        case PYB_UART_6:
            UARTx = USART6;
212
            irqn = USART6_IRQn;
Damien George's avatar
Damien George committed
213
            GPIO_AF_UARTx = GPIO_AF8_USART6;
214
215
            GPIO_Port = MICROPY_HW_UART6_PORT;
            GPIO_Pin = MICROPY_HW_UART6_PINS;
216
217
            __USART6_CLK_ENABLE();
            break;
218
        #endif
219
220

        default:
221
            // UART does not exist or is not configured for this board
222
            return false;
223
224
    }

225
226
227
    uart_obj->irqn = irqn;
    uart_obj->uart.Instance = UARTx;

228
    // init GPIO
229
    mp_hal_gpio_clock_enable(GPIO_Port);
230
231
232
233
234
    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
235
    GPIO_InitStructure.Alternate = GPIO_AF_UARTx;
236
237
    HAL_GPIO_Init(GPIO_Port, &GPIO_InitStructure);

238
239
240
241
242
243
244
    // init GPIO for second pin if needed
    if (GPIO_Port2 != NULL) {
        mp_hal_gpio_clock_enable(GPIO_Port2);
        GPIO_InitStructure.Pin = GPIO_Pin2;
        HAL_GPIO_Init(GPIO_Port2, &GPIO_InitStructure);
    }

Damien George's avatar
Damien George committed
245
246
    // init UARTx
    HAL_UART_Init(&uart_obj->uart);
247

Damien George's avatar
Damien George committed
248
    uart_obj->is_enabled = true;
249
250
251
252

    return true;
}

253
/* obsolete and unused
Damien George's avatar
Damien George committed
254
255
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
256
257
    memset(uh, 0, sizeof(*uh));
    uh->Init.BaudRate = baudrate;
258
259
260
261
    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
262
263
    uh->Init.HwFlowCtl = UART_HWCONTROL_NONE;
    uh->Init.OverSampling = UART_OVERSAMPLING_16;
Damien George's avatar
Damien George committed
264
    return uart_init2(uart_obj);
265
}
266
*/
267

268
269
270
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;
271
272
}

273
274
275
276
277
278
279
280
281
282
283
284
285
286
// 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();
    }
287
288
}

289
290
291
292
293
294
295
296
297
298
299
300
301
302
// 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
303
304
305
        #if defined(STM32F7)
        return self->uart.Instance->RDR & self->char_mask;
        #else
306
        return self->uart.Instance->DR & self->char_mask;
307
        #endif
308
309
310
    }
}

311
STATIC void uart_tx_char(pyb_uart_obj_t *uart_obj, int c) {
312
    uint8_t ch = c;
313
    HAL_UART_Transmit(&uart_obj->uart, &ch, 1, uart_obj->timeout);
314
315
}

Damien George's avatar
Damien George committed
316
void uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
317
    HAL_UART_Transmit(&uart_obj->uart, (uint8_t*)str, len, uart_obj->timeout);
318
319
}

Damien George's avatar
Damien George committed
320
void uart_tx_strn_cooked(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
321
322
    for (const char *top = str + len; str < top; str++) {
        if (*str == '\n') {
Damien George's avatar
Damien George committed
323
            uart_tx_char(uart_obj, '\r');
324
        }
Damien George's avatar
Damien George committed
325
        uart_tx_char(uart_obj, *str);
326
327
328
    }
}

329
330
331
// this IRQ handler is set up to handle RXNE interrupts only
void uart_irq_handler(mp_uint_t uart_id) {
    // get the uart object
332
    pyb_uart_obj_t *self = MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1];
333
334
335
336
337
338
339
340

    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) {
341
342
343
        #if defined(STM32F7)
        int data = self->uart.Instance->RDR; // clears UART_FLAG_RXNE
        #else
344
        int data = self->uart.Instance->DR; // clears UART_FLAG_RXNE
345
        #endif
346
        data &= self->char_mask;
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
        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
        }
    }
}

364
365
366
/******************************************************************************/
/* Micro Python bindings                                                      */

367
STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
Damien George's avatar
Damien George committed
368
    pyb_uart_obj_t *self = self_in;
369
    if (!self->is_enabled) {
370
        mp_printf(print, "UART(%u)", self->uart_id);
371
    } else {
372
373
374
375
        mp_int_t bits = (self->uart.Init.WordLength == UART_WORDLENGTH_8B ? 8 : 9);
        if (self->uart.Init.Parity != UART_PARITY_NONE) {
            bits -= 1;
        }
376
        mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=",
377
            self->uart_id, self->uart.Init.BaudRate, bits);
378
        if (self->uart.Init.Parity == UART_PARITY_NONE) {
379
            mp_print_str(print, "None");
380
        } else {
381
            mp_printf(print, "%u", self->uart.Init.Parity == UART_PARITY_EVEN ? 0 : 1);
382
        }
383
        mp_printf(print, ", stop=%u, timeout=%u, timeout_char=%u, read_buf_len=%u)",
384
385
            self->uart.Init.StopBits == UART_STOPBITS_1 ? 1 : 2,
            self->timeout, self->timeout_char, self->read_buf_len);
386
    }
387
388
}

389
/// \method init(baudrate, bits=8, parity=None, stop=1, *, timeout=1000, timeout_char=0, read_buf_len=64)
390
///
391
/// Initialise the UART bus with the given parameters:
392
393
///
///   - `baudrate` is the clock rate.
394
///   - `bits` is the number of bits per byte, 7, 8 or 9.
395
///   - `parity` is the parity, `None`, 0 (even) or 1 (odd).
396
397
398
399
400
401
402
403
404
405
///   - `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} },
406
        { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_HWCONTROL_NONE} },
407
408
409
410
        { 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} },
    };
411
412

    // parse args
413
414
    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);
415

Damien George's avatar
Damien George committed
416
    // set the UART configuration values
417
418
    memset(&self->uart, 0, sizeof(self->uart));
    UART_InitTypeDef *init = &self->uart.Init;
419
420

    // baudrate
421
    init->BaudRate = args[0].u_int;
422
423
424

    // parity
    mp_int_t bits = args[1].u_int;
425
    if (args[2].u_obj == mp_const_none) {
426
427
        init->Parity = UART_PARITY_NONE;
    } else {
428
        mp_int_t parity = mp_obj_get_int(args[2].u_obj);
429
        init->Parity = (parity & 1) ? UART_PARITY_ODD : UART_PARITY_EVEN;
430
        bits += 1; // STs convention has bits including parity
431
    }
432
433
434
435
436
437
438
439
440
441
442

    // 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
443
444
445
446
    switch (args[3].u_int) {
        case 1: init->StopBits = UART_STOPBITS_1; break;
        default: init->StopBits = UART_STOPBITS_2; break;
    }
447
448

    // flow control
449
    init->HwFlowCtl = args[4].u_int;
450
451
452

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

Damien George's avatar
Damien George committed
455
456
    // init UART (if it fails, it's because the port doesn't exist)
    if (!uart_init2(self)) {
457
458
459
460
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", self->uart_id));
    }

    // set timeouts
461
462
    self->timeout = args[5].u_int;
    self->timeout_char = args[6].u_int;
463
464
465
466

    // 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) {
467
        self->char_mask = 0x1ff;
468
469
        self->char_width = CHAR_WIDTH_9BIT;
    } else {
470
471
472
473
474
        if (init->WordLength == UART_WORDLENGTH_9B || init->Parity == UART_PARITY_NONE) {
            self->char_mask = 0xff;
        } else {
            self->char_mask = 0x7f;
        }
475
476
477
478
        self->char_width = CHAR_WIDTH_8BIT;
    }
    self->read_buf_head = 0;
    self->read_buf_tail = 0;
479
    if (args[7].u_int <= 0) {
480
481
482
483
484
485
486
        // 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
487
488
        self->read_buf_len = args[7].u_int;
        self->read_buf = m_new(byte, args[7].u_int << self->char_width);
489
490
491
        __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);
492
493
    }

494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
    // compute actual baudrate that was configured
    // (this formula assumes UART_OVERSAMPLING_16)
    uint32_t actual_baudrate;
    if (self->uart.Instance == USART1 || self->uart.Instance == USART6) {
        actual_baudrate = HAL_RCC_GetPCLK2Freq();
    } else {
        actual_baudrate = HAL_RCC_GetPCLK1Freq();
    }
    actual_baudrate /= self->uart.Instance->BRR;

    // check we could set the baudrate within 5%
    uint32_t baudrate_diff;
    if (actual_baudrate > init->BaudRate) {
        baudrate_diff = actual_baudrate - init->BaudRate;
    } else {
        baudrate_diff = init->BaudRate - actual_baudrate;
    }
    init->BaudRate = actual_baudrate; // remember actual baudrate for printing
    if (20 * baudrate_diff > init->BaudRate) {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "set baudrate %d is not within 5%% of desired value", actual_baudrate));
    }

516
517
518
    return mp_const_none;
}

519
520
521
522
523
524
525
/// \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.
526
527
528
529
530
531
532
533
///
/// 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)`
534
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) {
535
536
537
    // check arguments
    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);

538
    // work out port
539
    int uart_id = 0;
540
541
    if (MP_OBJ_IS_STR(args[0])) {
        const char *port = mp_obj_str_get_str(args[0]);
542
        if (0) {
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
        #ifdef MICROPY_HW_UART1_NAME
        } else if (strcmp(port, MICROPY_HW_UART1_NAME) == 0) {
            uart_id = PYB_UART_1;
        #endif
        #ifdef MICROPY_HW_UART2_NAME
        } else if (strcmp(port, MICROPY_HW_UART2_NAME) == 0) {
            uart_id = PYB_UART_2;
        #endif
        #ifdef MICROPY_HW_UART3_NAME
        } else if (strcmp(port, MICROPY_HW_UART3_NAME) == 0) {
            uart_id = PYB_UART_3;
        #endif
        #ifdef MICROPY_HW_UART4_NAME
        } else if (strcmp(port, MICROPY_HW_UART4_NAME) == 0) {
            uart_id = PYB_UART_4;
        #endif
        #ifdef MICROPY_HW_UART5_NAME
        } else if (strcmp(port, MICROPY_HW_UART5_NAME) == 0) {
            uart_id = PYB_UART_5;
        #endif
        #ifdef MICROPY_HW_UART6_NAME
        } else if (strcmp(port, MICROPY_HW_UART6_NAME) == 0) {
            uart_id = PYB_UART_6;
        #endif
567
        } else {
568
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%s) does not exist", port));
569
        }
570
    } else {
571
        uart_id = mp_obj_get_int(args[0]);
572
        if (uart_id < 1 || uart_id > MP_ARRAY_SIZE(MP_STATE_PORT(pyb_uart_obj_all))) {
573
574
575
576
577
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id));
        }
    }

    pyb_uart_obj_t *self;
578
    if (MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1] == NULL) {
579
580
581
582
        // create new UART object
        self = m_new0(pyb_uart_obj_t, 1);
        self->base.type = &pyb_uart_type;
        self->uart_id = uart_id;
583
        MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1] = self;
584
585
    } else {
        // reference existing UART object
586
        self = MP_STATE_PORT(pyb_uart_obj_all)[uart_id - 1];
587
588
    }

589
590
591
592
    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);
593
        pyb_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
594
595
    }

596
    return self;
597
598
}

599
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
600
    return pyb_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
601
}
Damien George's avatar
Damien George committed
602
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
603

604
605
/// \method deinit()
/// Turn off the UART bus.
Damien George's avatar
Damien George committed
606
607
STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
608
609
610
611
612
613
614
615
616
617
618
619
620
    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();
621
    #if defined(USART3)
622
623
624
625
626
    } else if (uart->Instance == USART3) {
        HAL_NVIC_DisableIRQ(USART3_IRQn);
        __USART3_FORCE_RESET();
        __USART3_RELEASE_RESET();
        __USART3_CLK_DISABLE();
627
628
    #endif
    #if defined(UART4)
629
630
631
632
633
    } else if (uart->Instance == UART4) {
        HAL_NVIC_DisableIRQ(UART4_IRQn);
        __UART4_FORCE_RESET();
        __UART4_RELEASE_RESET();
        __UART4_CLK_DISABLE();
634
    #endif
Dave Hylands's avatar
Dave Hylands committed
635
636
637
638
639
640
641
    #if defined(UART5)
    } else if (uart->Instance == UART5) {
        HAL_NVIC_DisableIRQ(UART5_IRQn);
        __UART5_FORCE_RESET();
        __UART5_RELEASE_RESET();
        __UART5_CLK_DISABLE();
    #endif
642
643
644
645
646
647
    } else if (uart->Instance == USART6) {
        HAL_NVIC_DisableIRQ(USART6_IRQn);
        __USART6_FORCE_RESET();
        __USART6_RELEASE_RESET();
        __USART6_CLK_DISABLE();
    }
648
649
    return mp_const_none;
}
Damien George's avatar
Damien George committed
650
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_deinit_obj, pyb_uart_deinit);
651

652
653
/// \method any()
/// Return `True` if any characters waiting, else `False`.
Damien George's avatar
Damien George committed
654
655
656
STATIC mp_obj_t pyb_uart_any(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
    if (uart_rx_any(self)) {
657
658
659
660
661
        return mp_const_true;
    } else {
        return mp_const_false;
    }
}
Damien George's avatar
Damien George committed
662
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_any_obj, pyb_uart_any);
663

664
665
/// \method writechar(char)
/// Write a single character on the bus.  `char` is an integer to write.
666
/// Return value: `None`.
667
668
STATIC mp_obj_t pyb_uart_writechar(mp_obj_t self_in, mp_obj_t char_in) {
    pyb_uart_obj_t *self = self_in;
669

670
671
    // get the character to write (might be 9 bits)
    uint16_t data = mp_obj_get_int(char_in);
672

673
674
    // write the data
    HAL_StatusTypeDef status = HAL_UART_Transmit(&self->uart, (uint8_t*)&data, 1, self->timeout);
675
676

    if (status != HAL_OK) {
677
        mp_hal_raise(status);
678
    }
679

680
681
    return mp_const_none;
}
682
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_uart_writechar_obj, pyb_uart_writechar);
683

684
685
686
687
688
689
690
691
692
693
694
695
696
697
/// \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);

698
699
700
// uart.sendbreak()
STATIC mp_obj_t pyb_uart_sendbreak(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
701
702
703
    #if defined(STM32F7)
    self->uart.Instance->RQR = USART_RQR_SBKRQ; // write-only register
    #else
704
    self->uart.Instance->CR1 |= USART_CR1_SBK;
705
    #endif
706
707
708
709
    return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_sendbreak_obj, pyb_uart_sendbreak);

Damien George's avatar
Damien George committed
710
STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
711
    // instance methods
712

Damien George's avatar
Damien George committed
713
714
715
    { 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 },
716
717
718
719
720
721
722

    /// \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
723
724
    /// \method readinto(buf[, nbytes])
    { MP_OBJ_NEW_QSTR(MP_QSTR_readinto), (mp_obj_t)&mp_stream_readinto_obj },
725
726
727
728
729
    /// \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 },
730
    { MP_OBJ_NEW_QSTR(MP_QSTR_sendbreak), (mp_obj_t)&pyb_uart_sendbreak_obj },
731
732
733
734

    // 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) },
735
736
};

Damien George's avatar
Damien George committed
737
STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
738

739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
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 {
798
        *errcode = mp_hal_status_to_errno_table[status];
799
800
801
802
        return MP_STREAM_ERROR;
    }
}

803
STATIC mp_uint_t pyb_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
804
805
806
    pyb_uart_obj_t *self = self_in;
    mp_uint_t ret;
    if (request == MP_IOCTL_POLL) {
807
        mp_uint_t flags = arg;
808
        ret = 0;
809
        if ((flags & MP_IOCTL_POLL_RD) && uart_rx_any(self)) {
810
811
            ret |= MP_IOCTL_POLL_RD;
        }
812
        if ((flags & MP_IOCTL_POLL_WR) && __HAL_UART_GET_FLAG(&self->uart, UART_FLAG_TXE)) {
813
814
815
            ret |= MP_IOCTL_POLL_WR;
        }
    } else {
816
        *errcode = EINVAL;
817
        ret = MP_STREAM_ERROR;
818
819
820
821
822
    }
    return ret;
}

STATIC const mp_stream_p_t uart_stream_p = {
823
824
825
    .read = pyb_uart_read,
    .write = pyb_uart_write,
    .ioctl = pyb_uart_ioctl,
826
827
828
    .is_text = false,
};

Damien George's avatar
Damien George committed
829
const mp_obj_type_t pyb_uart_type = {
830
    { &mp_type_type },
Damien George's avatar
Damien George committed
831
832
833
    .name = MP_QSTR_UART,
    .print = pyb_uart_print,
    .make_new = pyb_uart_make_new,
834
835
    .getiter = mp_identity,
    .iternext = mp_stream_unbuffered_iter,
836
    .stream_p = &uart_stream_p,
Damien George's avatar
Damien George committed
837
    .locals_dict = (mp_obj_t)&pyb_uart_locals_dict,
838
};