circuitpython/ports/stm/common-hal/busio/UART.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

684 lines
22 KiB
C
Raw Normal View History

2020-03-11 18:13:06 -04:00
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Lucian Copeland for Adafruit Industries
*
* 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.
*/
#include "shared-bindings/microcontroller/__init__.h"
#include "shared-bindings/microcontroller/Pin.h"
2020-03-11 18:13:06 -04:00
#include "shared-bindings/busio/UART.h"
#include "mpconfigport.h"
Merge tag 'v1.17' into merge-1.17 F-strings, new machine.I2S class, ESP32-C3 support and LEGO_HUB_NO6 board This release of MicroPython adds support for f-strings (PEP-498), with a few limitations compared to normal Python. F-strings are essentially syntactic sugar for "".format() and make formatting strings a lot more convenient. Other improvements to the core runtime include pretty printing OSError when it has two arguments (an errno code and a string), scheduling of KeyboardInterrupt on the main thread, and support for a single argument to the optimised form of StopIteration. In the machine module a new I2S class has been added, with support for esp32 and stm32 ports. This provides a consistent API for transmit and receive of audio data in blocking, non-blocking and asyncio-based operation. Also, the json module has support for the "separators" argument in the dump and dumps functions, and framebuf now includes a way to blit between frame buffers of different formats using a palette. A new, portable machine.bitstream function is also added which can output a stream of bits with configurable timing, and is used as the basis for driving WS2812 LEDs in a common way across ports. There has been some restructuring of the repository directory layout, with all third-party code now in the lib/ directory. And a new top-level directory shared/ has been added with first-party code that was previously in lib/ moved there. The docs have seen further improvement with enhancements and additions to the rp2 parts, as well as a new quick reference for the zephyr port. The terms master/slave have been replaced with controller/peripheral, mainly relating to I2C and SPI usage. And u-module references have been replaced with just the module name without the u-prefix to help clear up the intended usage of modules in MicroPython. For the esp8266 and esp32 ports, hidden networks are now included in WLAN scan results. On the esp32 the RMT class is enhanced with idle_level and write_pulses modes. There is initial support for ESP32-C3 chips with GENERIC_C3 and GENERIC_C3_USB boards. The javascript port has had its Makefile and garbage collector implementation reworked so it compiles and runs with latest the Emscripten using asyncify. The mimxrt port sees the addition of hardware I2C and SPI support, as well as some additional methods to the machine module. There is also support for Hyperflash chips. The nrf port now has full VFS storage support, enables source-line on traceback, and has .mpy features consistent with other ports. For the rp2 port there is now more configurability for boards, and more boards added. The stm32 port has a new LEGO_HUB_NO6 board definition with detailed information how to get this LEGO Hub running stock MicroPython. There is also now support to change the CPU frequency on STM32WB MCUs. And USBD_xxx descriptor options have been renamed to MICROPY_HW_USB_xxx. Thanks to everyone who contributed to this release: Amir Gonnen, Andrew Scheller, Bryan Tong Minh, Chris Wilson, Damien George, Daniel Mizyrycki, David Lechner, David P, Fernando, finefoot, Frank Pilhofer, Glenn Ruben Bakke, iabdalkader, Jeff Epler, Jim Mussared, Jonathan Hogg, Josh Klar, Josh Lloyd, Julia Hathaway, Krzysztof Adamski, Matúš Olekšák, Michael Weiss, Michel Bouwmans, Mike Causer, Mike Teachman, Ned Konz, NitiKaur, oclyke, Patrick Van Oosterwijck, Peter Hinch, Peter Züger, Philipp Ebensberger, robert-hh, Roberto Colistete Jr, Sashkoiv, Seon Rozenblum, Tobias Thyrrestrup, Tom McDermott, Will Sowerbutts, Yonatan Goldschmidt. What follows is a detailed list of changes, generated from the git commit history, and organised into sections. Main components =============== all: - fix signed shifts and NULL access errors from -fsanitize=undefined - update to point to files in new shared/ directory py core: - mpstate: make exceptions thread-local - mpstate: schedule KeyboardInterrupt on main thread - mperrno: add MP_ECANCELED error code - makeqstrdefs.py: don't include .h files explicitly in preprocessing - mark unused arguments from bytecode decoding macros - objexcept: pretty print OSError also when it has 2 arguments - makeversionhdr: add --tags arg to git describe - vm: simplify handling of MP_OBJ_STOP_ITERATION in yield-from opcode - objexcept: make mp_obj_exception_get_value support subclassed excs - support single argument to optimised MP_OBJ_STOP_ITERATION - introduce and use mp_raise_type_arg helper - modsys: optimise sys.exit for code size by using exception helpers - objexcept: make mp_obj_new_exception_arg1 inline - obj: fix formatting of comment for mp_obj_is_integer - emitnative: reuse need_reg_all func in need_stack_settled - emitnative: ensure stack settling is safe mid-branch - runtime: fix bool unary op for subclasses of native types - builtinimport: fix condition for including do_execute_raw_code() - mkrules: automatically build mpy-cross if it doesn't exist - implement partial PEP-498 (f-string) support - lexer: clear fstring_args vstr on lexer free - mkrules.mk: do submodule sync in "make submodules" extmod: - btstack: add missing call to mp_bluetooth_hci_uart_deinit - btstack: check that BLE is active before performing operations - uasyncio: get addr and bind server socket before creating task - axtls-include: add axtls_os_port.h to customise axTLS - update for move of crypto-algorithms, re1.5, uzlib to lib - moduselect: conditionally compile select() - nimble: fix leak in l2cap_send if send-while-stalled - btstack/btstack.mk: use -Wno-implicit-fallthrough, not =0 - utime: always invoke mp_hal_delay_ms when >= to 0ms - modbluetooth: clamp MTU values to 32->UINT16_MAX - nimble: allow modbluetooth binding to hook "sent HCI packet" - nimble: add "memory stalling" mechanism for l2cap_send - uasyncio: in open_connection use address info in socket creation - modujson: add support for dump/dumps separators keyword-argument - modlwip: fix close and clean up of UDP and raw sockets - modbluetooth: add send_update arg to gatts_write - add machine.bitstream - modframebuf: enable blit between different formats via a palette lib: - tinyusb: update to version 0.10.1 - pico-sdk: update to version 1.2.0 - utils/stdout_helpers: make mp_hal_stdout_tx_strn_cooked efficient - axtls: switch to repo at micropython/axtls - axtls: update to latest axtls 2.1.5 wih additional commits - re1.5: move re1.5 code from extmod to lib - uzlib: move uzlib code from extmod to lib - crypto-algorithms: move crypto-algorithms code from extmod to lib - update README's based on contents of these dirs drivers: - neopixel: add common machine.bitstream-based neopixel module - neopixel: optimize fill() for speed - neopixel: reduce code size of driver - cyw43: fix cyw43_deinit so it can be called many times in a row - cyw43: make wifi join fail if interface is not active mpy-cross: - disable stack check when building with Emscripten Support components ================== docs: - library: document new esp32.RMT features and fix wait_done - library: warn that ustruct doesn't handle spaces in format strings - esp8266/tutorial: change flash mode from dio to dout - replace master/slave with controller/peripheral in I2C and SPI - rp2: enhance quickref and change image to Pico pinout - rp2: update general section to give a brief technical overview - library/utime.rst: clarify behaviour and precision of sleep ms/us - library/uasyncio.rst: document stream readexactly() method - library/machine.I2S.rst: fix use of sd pin in examples - zephyr: add quick reference for the Zephyr port - library/zephyr: add libraries specific to the Zephyr port - templates: add unix and zephyr quickref links to top-index - rename ufoo.rst to foo.rst - replace ufoo with foo in all docs - library/index.rst: clarify module naming and purpose - library/builtins.rst: add module title - library/network.rst: simplify socket import - add docs for machine.bitstream and neopixel module - library: fix usage of :term: for frozen module reference - esp8266: use monospace for software tools - reference: mention that slicing a memoryview causes allocation examples: no changes specific to this component/port tests: - extmod: make uasyncio_heaplock test more deterministic - cpydiff/modules_struct_whitespace_in_format: run black - extmod/ujson: add tests for dump/dumps separators argument - run-multitests.py: add broadcast and wait facility - multi_bluetooth/ble_subscribe.py: add test for subscription - extmod/vfs_fat_finaliser.py: ensure alloc at never-used GC blocks - basics: split f-string debug printing to separate file with .exp - pybnative: make while.py test run on boards without pyb.delay tools: - autobuild: add scripts to build release firmware - remove obsolete build-stm-latest.sh script - ci.sh: run apt-get update in ci_powerpc_setup - makemanifest.py: allow passing flags to mpy-tool.py - autobuild: add mimxrt port to build scripts for nightly builds - pyboard.py: add cmd-line option to make soft reset configurable - mpremote: swap order of PID and VID in connect-list output - ci.sh: build unix dev variant as part of macOS CI - ci.sh: build GENERIC_C3 board as part of esp32 CI - autobuild: use separate IDF version to build newer esp32 SoCs - autobuild: add FeatherS2 and TinyS2 to esp32 auto builds - mpremote: add seek whence for mounted files - mpremote: raise OSError on unsupported RemoteFile.seek - autobuild: add the MIMXRT1050_EVKB board to the daily builds - ci.sh: add mpy-cross build to nrf port - codeformat.py: include ports/nrf/modules/nrf in code formatting - gen-cpydiff.py: don't rename foo to ufoo in diff output - autobuild: add auto build for Silicognition wESP32 - mpremote: fix connect-list in case VID/PID are None - mpremote: add "devs" shortcut for "connect list" - mpremote: remove support for pyb.USB_VCP in/out specialisation - autobuild: don't use "-B" for make, it's already a fresh build - pyboard.py: move --no-exclusive/--soft-reset out of mutex group - pyboard.py: make --no-follow use same variable as --follow - pyboard.py: add --exclusive to match --no-exclusive - pyboard.py: make --no-soft-reset consistent with other args - uncrustify: force 1 newline at end of file - mpremote: bump version to 0.0.6 CI: - workflows: add workflow to build and test javascript port - workflows: switch from Coveralls to Codecov - workflows: switch from lcov to gcov - workflows: add workflow to build and test unix dev variant The ports ========= all ports: - use common mp_hal_stdout_tx_strn_cooked instead of custom one - update for move of crypto-algorithms, uzlib to lib - rename USBD_VID/PID config macros to MICROPY_HW_USB_VID/PID bare-arm port: no changes specific to this component/port cc3200 port: no changes specific to this component/port esp8266 port: - add __len__ to NeoPixel driver to support iterating - Makefile: add more libm files to build - include hidden networks in WLAN.scan results - replace esp.neopixel with machine.bitstream - remove dead code for end_ticks in machine_bitstream esp32 port: - boards/sdkconfig.base: disable MEMPROT_FEATURE to alloc from IRAM - add __len__ to NeoPixel driver to support iterating - main: allow MICROPY_DIR to be overridden - esp32_rmt: fix RMT looping in newer IDF versions - esp32_rmt: enhance RMT with idle_level and write_pulses modes - add new machine.I2S class for I2S protocol support - machine_spi: calculate actual attained baudrate - machine_hw_spi: use a 2 item SPI queue for long transfers - machine_dac: add MICROPY_PY_MACHINE_DAC option, enable by default - machine_i2s: add MICROPY_PY_MACHINE_I2S option, enable by default - fix use of mp_int_t, size_t and uintptr_t - add initial support for ESP32C3 SoCs - boards/GENERIC_C3: add generic C3-based board - modmachine: release the GIL in machine.idle() - mphalport: always yield at least once in delay_ms - machine_uart: add flow kw-arg to enable hardware flow control - boards: add Silicognition wESP32 board configuration - mpconfigport.h: enable reverse and inplace special methods - include hidden networks in WLAN.scan results - makeimg.py: get bootloader and partition offset from sdkconfig - enable MICROPY_PY_FSTRINGS by default - machine_hw_spi: release GIL during transfers - machine_pin: make check for non-output pins respect chip variant - replace esp.neopixel with machine.bitstream - remove dead code for end_ticks in machine_bitstream - boards: add GENERIC_C3_USB board with USB serial/JTAG support javascript port: - rework Makefile and GC so it works with latest Emscripten - Makefile: suppress compiler errors from array bounds - Makefile: change variable to EXPORTED_RUNTIME_METHODS mimxrt port: - move calc_weekday helper function to timeutils - machine_spi: add the SPI class to the machine module - moduos: seed the PRNG on boot using the TRNG - boards: set vfs partition start to 1 MBbyte - main: skip running main.py if boot.py failed - main: extend the information returned by help() - mimxrt_flash: remove commented-out code - modmachine: add a few minor methods to the machine module - machine_led: use mp_raise_msg_varg helper - machine_i2c: add hardware-based machine.I2C to machine module - add support for Hyperflash chips - boards: add support for the MIMXRT1050_EVKB board - machine_pin: implement ioctl for Pin minimal port: - Makefile: add support for building with user C modules nrf port: - modules: replace master/slave with controller/peripheral in SPI - boards/common.ld: calculate unused flash region - modules/nrf: add new nrf module with flash block device - drivers: add support for using flash block device with SoftDevice - mpconfigport.h: expose nrf module when MICROPY_PY_NRF is set - README: update README.md to reflect internal file systems - mpconfigport.h: tune FAT FS configuration - Makefile: add _fs_size linker script override from make - modules/uos: allow a board to configure MICROPY_VFS_FAT/LFS1/LFS2 - mpconfigport.h: enable MICROPY_PY_IO_FILEIO when an FS is enabled - qstrdefsport.h: add entries for in-built FS mount points - main: add auto mount and auto format hook for internal flash FS - boards: enable needed features for FAT/LFS1/LFS2 - facilitate use of freeze manifest - boards: set FROZEN_MANIFEST blank when SD present on nrf51 targets - modules/scripts: add file system formatting script - Makefile: set default manifest file for all targets - mphalport: add dummy function for mp_hal_time_ns() - boards: enable MICROPY_VFS_LFS2 for all target boards - modules/uos: add ilistdir to uos module - modules/nrf: add function to enable/disable DCDC - enable source line on tracebacks - set .mpy features consistent with documentation and other ports pic16bit port: no changes specific to this component/port powerpc port: no changes specific to this component/port qemu-arm port: no changes specific to this component/port rp2 port: - use 0=Monday datetime convention in RTC - machine_rtc: in RTC.datetime, compute weekday automatically - CMakeLists.txt: suppress compiler errors for pico-sdk and tinyusb - tusb_config.h: set CFG_TUD_CDC_EP_BUFSIZE to 256 - machine_uart: add hardware flow control support - machine_uart: allow overriding default machine UART pins - machine_i2c: allow boards to configure I2C pins using new macros - machine_spi: allow boards to configure SPI pins using new macros - machine_uart: fix poll ioctl to also check hardware FIFO - machine_uart: fix read when FIFO has chars but ringbuf doesn't - tusb_port: allow boards to configure USB VID and PID - boards/ADAFRUIT_FEATHER_RP2040: configure custom VID/PID - boards/ADAFRUIT_FEATHER_RP2040: configure I2C/SPI default pins - boards/SPARKFUN_PROMICRO: configure UART/I2C/SPI default pins - boards/SPARKFUN_THINGPLUS: configure I2C/SPI default pins - boards: add Adafruit ItsyBitsy RP2040 - boards: add Adafruit QT Py RP2040 - boards: add Pimoroni Pico LiPo 4MB - boards: add Pimoroni Pico LiPo 16MB - boards: add Pimoroni Tiny 2040 - CMakeLists.txt: allow a board's cmake to set the manifest path - enable MICROPY_PY_FSTRINGS by default - Makefile: add "submodules" target, to match other ports - rp2_flash: disable IRQs while calling flash_erase/program - CMakeLists.txt: add option to enable double tap reset to bootrom - mpconfigport.h: allow boards to add root pointers samd port: - add support for building with user C modules stm32 port: - softtimer: add soft_timer_reinsert() helper function - mpbthciport: change from systick to soft-timer for BT scheduling - provide a custom BTstack runloop that integrates with soft timer - usb: make irq's default trigger enable all events - boardctrl: skip running main.py if boot.py had an error - sdio: fix undefined reference to DMA stream on H7 - dma: add DMAMUX configuration for H7 to fix dma_nohal_init - main: call mp_deinit() at end of main - adc: allow using ADC12 and ADC3 for H7 - adc: define the ADC instance used for internal channels - adc: simplify and generalise how pin_adcX table is defined - add new machine.I2S class for I2S protocol support - boards/NUCLEO_F446RE: fix I2C1 pin assignment to match datasheet - replace master/slave with controller/peripheral in I2C and SPI - systick: always POLL_HOOK when delaying for milliseconds - sdram: make SDRAM test cache aware, and optional failure with msg - boards/NUCLEO_F446RE: enable CAN bus support - boards: add support for SparkFun STM32 MicroMod Processor board - uart: fix LPUART1 baudrate set/get - uart: support low baudrates on LPUART1 - boards/STM32F429DISC: set correct UART2 pins and add UART3/6 - boards/NUCLEO_F439ZI: add board definition for NUCLEO_F439ZI - boards/LEGO_HUB_NO6: add board definition for LEGO_HUB_NO6 - Makefile: update to only pull in used Bluetooth library - README.md: update supported MCUs, and submodule and mboot use - usbd_desc: rename USBD_xxx descriptor opts to MICROPY_HW_USB_xxx - usbd_cdc_interface: rename USBD_CDC_xx opts to MICROPY_HW_USB_xx - powerctrl: support changing frequency on WB MCUs - boards/NUCLEO_H743ZI2: add modified version of NUCLEO_H743ZI - mbedtls: fix compile warning about uninitialized val - enable MICROPY_PY_FSTRINGS by default - add implementation of machine.bitstream - Makefile: allow GIT_SUBMODULES and LIBS to be extended - stm32_it: support TIM17 IRQs on WB MCUs - disable computed goto on constrained boards - storage: make extended-block-device more configurable - boards/LEGO_HUB_NO6: change SPI flash storage to use hardware SPI - boards/LEGO_HUB_NO6: skip first 1MiB of SPI flash for storage - boards/LEGO_HUB_NO6: add make commands to backup/restore firmware teensy port: no changes specific to this component/port unix port: - modffi: add option to lock GC in callback, and cfun access - Makefile: add back LIB_SRC_C to list of object files - variants: enable help and help("modules") on standard and dev - Makefile: disable error compression on arm-linux-gnueabi-gcc windows port: - Makefile: add .exe extension to executables name - appveyor: update to VS 2017 and use Python 3.8 for build/test zephyr port: - machine_spi: add support for hardware SPI
2021-10-14 15:38:41 -04:00
#include "shared/readline/readline.h"
#include "shared/runtime/interrupt_char.h"
2020-03-11 18:13:06 -04:00
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/runtime.h"
#include "py/stream.h"
2022-05-27 15:59:54 -04:00
#include "supervisor/shared/translate/translate.h"
2020-03-11 18:13:06 -04:00
#define ALL_UARTS 0xFFFF
2021-03-15 09:57:36 -04:00
// arrays use 0 based numbering: UART1 is stored at index 0
2020-03-11 18:13:06 -04:00
STATIC bool reserved_uart[MAX_UART];
STATIC bool never_reset_uart[MAX_UART];
2021-03-15 09:57:36 -04:00
int errflag; // Used to restart read halts
2020-03-11 18:13:06 -04:00
STATIC void uart_clock_enable(uint16_t mask);
STATIC void uart_clock_disable(uint16_t mask);
2021-03-15 09:57:36 -04:00
STATIC void uart_assign_irq(busio_uart_obj_t *self, USART_TypeDef *USARTx);
2020-03-11 18:13:06 -04:00
2021-03-15 09:57:36 -04:00
STATIC USART_TypeDef *assign_uart_or_throw(busio_uart_obj_t *self, bool pin_eval,
int periph_index, bool uart_taken) {
2020-03-11 18:13:06 -04:00
if (pin_eval) {
2021-03-15 09:57:36 -04:00
// assign a root pointer pointer for IRQ
MP_STATE_PORT(cpy_uart_obj_all)[periph_index] = self;
return mcu_uart_banks[periph_index];
2020-03-11 18:13:06 -04:00
} else {
if (uart_taken) {
mp_raise_ValueError(translate("Hardware in use, try alternative pins"));
} else {
raise_ValueError_invalid_pin();
2020-03-11 18:13:06 -04:00
}
}
}
void uart_reset(void) {
uint16_t never_reset_mask = 0x00;
2020-03-11 18:13:06 -04:00
for (uint8_t i = 0; i < MAX_UART; i++) {
if (!never_reset_uart[i]) {
reserved_uart[i] = false;
MP_STATE_PORT(cpy_uart_obj_all)[i] = NULL;
} else {
never_reset_mask |= 1 << i;
}
2020-03-11 18:13:06 -04:00
}
uart_clock_disable(ALL_UARTS & ~(never_reset_mask));
2020-03-11 18:13:06 -04:00
}
void common_hal_busio_uart_construct(busio_uart_obj_t *self,
2021-03-15 09:57:36 -04:00
const mcu_pin_obj_t *tx, const mcu_pin_obj_t *rx,
const mcu_pin_obj_t *rts, const mcu_pin_obj_t *cts,
const mcu_pin_obj_t *rs485_dir, bool rs485_invert,
2020-06-09 21:28:02 -04:00
uint32_t baudrate, uint8_t bits, busio_uart_parity_t parity, uint8_t stop,
2021-03-15 09:57:36 -04:00
mp_float_t timeout, uint16_t receiver_buffer_size, byte *receiver_buffer,
bool sigint_enabled) {
2020-03-11 18:13:06 -04:00
2021-03-15 09:57:36 -04:00
// match pins to UART objects
USART_TypeDef *USARTx;
2020-03-11 18:13:06 -04:00
uint8_t tx_len = MP_ARRAY_SIZE(mcu_uart_tx_list);
uint8_t rx_len = MP_ARRAY_SIZE(mcu_uart_rx_list);
bool uart_taken = false;
2021-03-15 09:57:36 -04:00
uint8_t periph_index = 0; // origin 0 corrected
2020-03-11 18:13:06 -04:00
if ((rts != NULL) || (cts != NULL) || (rs485_dir != NULL) || (rs485_invert == true)) {
mp_raise_NotImplementedError(translate("RS485"));
2020-03-11 18:13:06 -04:00
}
2021-03-15 09:57:36 -04:00
// Can have both pins, or either
2020-03-11 18:13:06 -04:00
if ((tx != NULL) && (rx != NULL)) {
2021-03-15 09:57:36 -04:00
// normal find loop if both pins exist
2020-03-11 18:13:06 -04:00
for (uint i = 0; i < tx_len; i++) {
if (mcu_uart_tx_list[i].pin == tx) {
2021-03-15 09:57:36 -04:00
// rx
2020-03-11 18:13:06 -04:00
for (uint j = 0; j < rx_len; j++) {
if (mcu_uart_rx_list[j].pin == rx
&& mcu_uart_rx_list[j].periph_index == mcu_uart_tx_list[i].periph_index) {
2021-03-15 09:57:36 -04:00
// keep looking if the UART is taken, edge case
if (reserved_uart[mcu_uart_tx_list[i].periph_index - 1]) {
2020-03-11 18:13:06 -04:00
uart_taken = true;
continue;
}
2021-03-15 09:57:36 -04:00
// store pins if not
2020-03-11 18:13:06 -04:00
self->tx = &mcu_uart_tx_list[i];
self->rx = &mcu_uart_rx_list[j];
break;
}
}
2020-04-13 12:03:05 -04:00
if (self->tx != NULL) {
2020-04-06 19:13:55 -04:00
break;
}
2020-03-11 18:13:06 -04:00
}
}
periph_index = self->tx->periph_index - 1;
2020-03-11 18:13:06 -04:00
USARTx = assign_uart_or_throw(self, (self->tx != NULL && self->rx != NULL),
periph_index, uart_taken);
2020-03-11 18:13:06 -04:00
} else if (tx == NULL) {
2021-03-15 09:57:36 -04:00
// If there is no tx, run only rx
2020-03-11 18:13:06 -04:00
for (uint i = 0; i < rx_len; i++) {
if (mcu_uart_rx_list[i].pin == rx) {
2021-03-15 09:57:36 -04:00
// keep looking if the UART is taken, edge case
if (reserved_uart[mcu_uart_rx_list[i].periph_index - 1]) {
2020-03-11 18:13:06 -04:00
uart_taken = true;
continue;
}
2021-03-15 09:57:36 -04:00
// store pins if not
2020-03-11 18:13:06 -04:00
self->rx = &mcu_uart_rx_list[i];
break;
}
}
periph_index = self->rx->periph_index - 1;
2020-03-11 18:13:06 -04:00
USARTx = assign_uart_or_throw(self, (self->rx != NULL),
periph_index, uart_taken);
2020-03-11 18:13:06 -04:00
} else if (rx == NULL) {
2021-03-15 09:57:36 -04:00
// If there is no rx, run only tx
2020-03-11 18:13:06 -04:00
for (uint i = 0; i < tx_len; i++) {
if (mcu_uart_tx_list[i].pin == tx) {
2021-03-15 09:57:36 -04:00
// keep looking if the UART is taken, edge case
if (reserved_uart[mcu_uart_tx_list[i].periph_index - 1]) {
2020-03-11 18:13:06 -04:00
uart_taken = true;
continue;
}
2021-03-15 09:57:36 -04:00
// store pins if not
2020-03-11 18:13:06 -04:00
self->tx = &mcu_uart_tx_list[i];
break;
}
}
periph_index = self->tx->periph_index - 1;
2020-03-11 18:13:06 -04:00
USARTx = assign_uart_or_throw(self, (self->tx != NULL),
periph_index, uart_taken);
2020-03-11 18:13:06 -04:00
} else {
2021-03-15 09:57:36 -04:00
// both pins cannot be empty
2020-03-11 18:13:06 -04:00
mp_raise_ValueError(translate("Supply at least one UART pin"));
}
2021-03-15 09:57:36 -04:00
// Other errors
mp_arg_validate_length_min(receiver_buffer_size, 1, MP_QSTR_receiver_buffer_size);
mp_arg_validate_int_range(bits, 8, 9, MP_QSTR_bits);
2021-03-15 09:57:36 -04:00
if (USARTx == NULL) { // this can only be hit if the periph file is wrong
mp_raise_RuntimeError(translate("Internal define error"));
2020-03-11 18:13:06 -04:00
}
2021-03-15 09:57:36 -04:00
// GPIO Init
2020-03-11 18:13:06 -04:00
GPIO_InitTypeDef GPIO_InitStruct = {0};
if (self->tx != NULL) {
GPIO_InitStruct.Pin = pin_mask(tx->number);
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = self->tx->altfn_index;
HAL_GPIO_Init(pin_port(tx->port), &GPIO_InitStruct);
}
if (self->rx != NULL) {
GPIO_InitStruct.Pin = pin_mask(rx->number);
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = self->rx->altfn_index;
HAL_GPIO_Init(pin_port(rx->port), &GPIO_InitStruct);
}
2021-03-15 09:57:36 -04:00
// reserve uart and enable the peripheral
reserved_uart[periph_index] = true;
uart_clock_enable(1 << (periph_index));
2020-03-11 18:13:06 -04:00
uart_assign_irq(self, USARTx);
self->handle.Instance = USARTx;
self->handle.Init.BaudRate = baudrate;
self->handle.Init.WordLength = (bits == 9) ? UART_WORDLENGTH_9B : UART_WORDLENGTH_8B;
self->handle.Init.StopBits = (stop > 1) ? UART_STOPBITS_2 : UART_STOPBITS_1;
2020-06-09 21:28:02 -04:00
self->handle.Init.Parity = (parity == BUSIO_UART_PARITY_ODD) ? UART_PARITY_ODD :
2021-03-15 09:57:36 -04:00
(parity == BUSIO_UART_PARITY_EVEN) ? UART_PARITY_EVEN :
UART_PARITY_NONE;
2020-03-11 18:13:06 -04:00
self->handle.Init.Mode = (self->tx != NULL && self->rx != NULL) ? UART_MODE_TX_RX :
2021-03-15 09:57:36 -04:00
(self->tx != NULL) ? UART_MODE_TX :
UART_MODE_RX;
2020-03-11 18:13:06 -04:00
self->handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
self->handle.Init.OverSampling = UART_OVERSAMPLING_16;
2021-03-15 09:57:36 -04:00
if (HAL_UART_Init(&self->handle) != HAL_OK) {
mp_raise_RuntimeError(translate("UART init"));
2020-03-11 18:13:06 -04:00
}
// Init buffer for rx and claim pins
if (self->rx != NULL) {
2022-09-16 18:46:02 -04:00
// Use the provided buffer when given.
if (receiver_buffer != NULL) {
2022-09-16 18:46:02 -04:00
ringbuf_init(&self->ringbuf, receiver_buffer, receiver_buffer_size);
} else {
2022-09-16 18:46:02 -04:00
// Initially allocate the UART's buffer in the long-lived part of the
// heap. UARTs are generally long-lived objects, but the "make long-
// lived" machinery is incapable of moving internal pointers like
// self->buffer, so do it manually. (However, as long as internal
// pointers like this are NOT moved, allocating the buffer
// in the long-lived pool is not strictly necessary)
if (!ringbuf_alloc(&self->ringbuf, receiver_buffer_size, true)) {
m_malloc_fail(receiver_buffer_size);
}
2020-03-11 18:13:06 -04:00
}
common_hal_mcu_pin_claim(rx);
2020-03-11 18:13:06 -04:00
}
if (self->tx != NULL) {
common_hal_mcu_pin_claim(tx);
2020-03-11 18:13:06 -04:00
}
self->baudrate = baudrate;
self->timeout_ms = timeout * 1000;
self->sigint_enabled = sigint_enabled;
2020-03-11 18:13:06 -04:00
2021-03-15 09:57:36 -04:00
// start the interrupt series
2020-03-11 18:13:06 -04:00
if ((HAL_UART_GetState(&self->handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
mp_raise_RuntimeError(translate("Could not start interrupt, RX busy"));
2020-03-11 18:13:06 -04:00
}
2021-03-15 09:57:36 -04:00
// start the receive interrupt chain
HAL_NVIC_DisableIRQ(self->irq); // prevent handle lock contention
2020-03-11 18:13:06 -04:00
HAL_UART_Receive_IT(&self->handle, &self->rx_char, 1);
HAL_NVIC_SetPriority(self->irq, UART_IRQPRI, UART_IRQSUB_PRI);
HAL_NVIC_EnableIRQ(self->irq);
errflag = HAL_OK;
}
void common_hal_busio_uart_never_reset(busio_uart_obj_t *self) {
for (size_t i = 0; i < MP_ARRAY_SIZE(mcu_uart_banks); i++) {
if (mcu_uart_banks[i] == self->handle.Instance) {
never_reset_uart[i] = true;
never_reset_pin_number(self->tx->pin->port, self->tx->pin->number);
never_reset_pin_number(self->rx->pin->port, self->rx->pin->number);
break;
}
}
}
2020-03-11 18:13:06 -04:00
bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) {
return self->tx == NULL && self->rx == NULL;
2020-03-11 18:13:06 -04:00
}
void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
2021-03-15 09:57:36 -04:00
if (common_hal_busio_uart_deinited(self)) {
return;
}
2020-03-11 18:13:06 -04:00
for (size_t i = 0; i < MP_ARRAY_SIZE(mcu_uart_banks); i++) {
if (mcu_uart_banks[i] == self->handle.Instance) {
2021-03-11 11:02:13 -05:00
reserved_uart[i] = false;
never_reset_uart[i] = false;
break;
}
}
if (self->tx) {
reset_pin_number(self->tx->pin->port,self->tx->pin->number);
self->tx = NULL;
}
if (self->rx) {
reset_pin_number(self->rx->pin->port,self->rx->pin->number);
self->rx = NULL;
}
2022-09-16 18:46:02 -04:00
ringbuf_deinit(&self->ringbuf);
2020-03-11 18:13:06 -04:00
}
size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t len, int *errcode) {
if (self->rx == NULL) {
mp_raise_ValueError(translate("No RX pin"));
}
uint64_t start_ticks = supervisor_ticks_ms64();
// Wait for all bytes received or timeout, same as nrf
2021-03-15 09:57:36 -04:00
while ((ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
2020-03-11 18:13:06 -04:00
RUN_BACKGROUND_TASKS;
2021-03-15 09:57:36 -04:00
// restart if it failed in the callback
2020-03-11 18:13:06 -04:00
if (errflag != HAL_OK) {
errflag = HAL_UART_Receive_IT(&self->handle, &self->rx_char, 1);
}
// Allow user to break out of a timeout with a KeyboardInterrupt.
2021-03-15 09:57:36 -04:00
if (mp_hal_is_interrupted()) {
2020-03-11 18:13:06 -04:00
return 0;
}
}
// Halt reception
HAL_NVIC_DisableIRQ(self->irq);
2020-04-21 17:37:22 -04:00
// Copy as much received data as available, up to len bytes.
2020-04-21 22:40:12 -04:00
size_t rx_bytes = ringbuf_get_n(&self->ringbuf, data, len);
2020-03-11 18:13:06 -04:00
HAL_NVIC_EnableIRQ(self->irq);
if (rx_bytes == 0) {
*errcode = EAGAIN;
return MP_STREAM_ERROR;
}
return rx_bytes;
}
// Write characters.
size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
if (self->tx == NULL) {
mp_raise_ValueError(translate("No TX pin"));
}
// Disable UART IRQ to avoid resource hazards in Rx IRQ handler
2020-03-11 18:13:06 -04:00
HAL_NVIC_DisableIRQ(self->irq);
HAL_StatusTypeDef ret = HAL_UART_Transmit_IT(&self->handle, (uint8_t *)data, len);
2020-03-11 18:13:06 -04:00
HAL_NVIC_EnableIRQ(self->irq);
if (HAL_OK == ret) {
HAL_UART_StateTypeDef Status = HAL_UART_GetState(&self->handle);
while ((Status & HAL_UART_STATE_BUSY_TX) == HAL_UART_STATE_BUSY_TX) {
RUN_BACKGROUND_TASKS;
Status = HAL_UART_GetState(&self->handle);
}
2022-02-13 02:46:24 -05:00
} else {
mp_raise_RuntimeError(translate("UART write"));
2020-03-11 18:13:06 -04:00
}
2020-03-11 18:13:06 -04:00
return len;
}
2021-03-15 09:57:36 -04:00
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *handle) {
2020-03-11 18:13:06 -04:00
for (int i = 0; i < 7; i++) {
2021-03-15 09:57:36 -04:00
// get context pointer and cast it as struct pointer
busio_uart_obj_t *context = (busio_uart_obj_t *)MP_STATE_PORT(cpy_uart_obj_all)[i];
2020-03-11 18:13:06 -04:00
if (handle == &context->handle) {
2021-03-15 09:57:36 -04:00
// check if transaction is ongoing
2020-03-11 18:13:06 -04:00
if ((HAL_UART_GetState(handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
return;
}
2020-04-21 22:40:12 -04:00
ringbuf_put_n(&context->ringbuf, &context->rx_char, 1);
2020-03-11 18:13:06 -04:00
errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
if (context->sigint_enabled) {
if (context->rx_char == CHAR_CTRL_C) {
common_hal_busio_uart_clear_rx_buffer(context);
2021-06-18 12:15:51 -04:00
mp_sched_keyboard_interrupt();
}
}
2020-03-11 18:13:06 -04:00
2022-02-13 02:46:24 -05:00
#if (1)
// TODO: Implement error handling here
#else
while (HAL_BUSY == errflag) {
errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
}
2022-02-13 02:46:24 -05:00
#endif
2020-03-11 18:13:06 -04:00
return;
}
}
}
2021-03-15 09:57:36 -04:00
void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle) {
2020-03-11 18:13:06 -04:00
if (__HAL_UART_GET_FLAG(UartHandle, UART_FLAG_PE) != RESET) {
__HAL_UART_CLEAR_PEFLAG(UartHandle);
} else if (__HAL_UART_GET_FLAG(UartHandle, UART_FLAG_FE) != RESET) {
__HAL_UART_CLEAR_FEFLAG(UartHandle);
} else if (__HAL_UART_GET_FLAG(UartHandle, UART_FLAG_NE) != RESET) {
__HAL_UART_CLEAR_NEFLAG(UartHandle);
} else if (__HAL_UART_GET_FLAG(UartHandle, UART_FLAG_ORE) != RESET) {
__HAL_UART_CLEAR_OREFLAG(UartHandle);
}
2021-03-15 09:57:36 -04:00
// restart serial read after an error
2020-03-11 18:13:06 -04:00
for (int i = 0; i < 7; i++) {
2021-03-15 09:57:36 -04:00
busio_uart_obj_t *context = (busio_uart_obj_t *)MP_STATE_PORT(cpy_uart_obj_all)[i];
2020-03-11 18:13:06 -04:00
if (UartHandle == &context->handle) {
HAL_UART_Receive_IT(UartHandle, &context->rx_char, 1);
return;
}
}
}
uint32_t common_hal_busio_uart_get_baudrate(busio_uart_obj_t *self) {
return self->baudrate;
}
void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrate) {
2021-03-15 09:57:36 -04:00
// Don't reset if it's the same value
if (baudrate == self->baudrate) {
return;
}
2020-03-11 18:13:06 -04:00
2021-03-15 09:57:36 -04:00
// Otherwise de-init and set new rate
2020-03-11 18:13:06 -04:00
if (HAL_UART_DeInit(&self->handle) != HAL_OK) {
mp_raise_RuntimeError(translate("UART de-init"));
2020-03-11 18:13:06 -04:00
}
self->handle.Init.BaudRate = baudrate;
if (HAL_UART_Init(&self->handle) != HAL_OK) {
mp_raise_RuntimeError(translate("UART re-init"));
2020-03-11 18:13:06 -04:00
}
self->baudrate = baudrate;
}
mp_float_t common_hal_busio_uart_get_timeout(busio_uart_obj_t *self) {
2021-03-15 09:57:36 -04:00
return (mp_float_t)(self->timeout_ms / 1000.0f);
2020-03-11 18:13:06 -04:00
}
void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeout) {
self->timeout_ms = timeout * 1000;
}
uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) {
2020-04-21 22:40:12 -04:00
return ringbuf_num_filled(&self->ringbuf);
2020-03-11 18:13:06 -04:00
}
void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self) {
// Halt reception
HAL_NVIC_DisableIRQ(self->irq);
2020-04-21 22:40:12 -04:00
ringbuf_clear(&self->ringbuf);
2020-03-11 18:13:06 -04:00
HAL_NVIC_EnableIRQ(self->irq);
}
bool common_hal_busio_uart_ready_to_tx(busio_uart_obj_t *self) {
return __HAL_UART_GET_FLAG(&self->handle, UART_FLAG_TXE);
}
STATIC void call_hal_irq(int uart_num) {
2021-03-15 09:57:36 -04:00
// Create casted context pointer
busio_uart_obj_t *context = (busio_uart_obj_t *)MP_STATE_PORT(cpy_uart_obj_all)[uart_num - 1];
2020-03-11 18:13:06 -04:00
if (context != NULL) {
HAL_NVIC_ClearPendingIRQ(context->irq);
HAL_UART_IRQHandler(&context->handle);
if (HAL_UART_ERROR_NONE != context->handle.ErrorCode) {
2022-02-13 02:46:24 -05:00
// TODO: Implement error handling here
}
2020-03-11 18:13:06 -04:00
}
}
// UART/USART IRQ handlers
void USART1_IRQHandler(void) {
call_hal_irq(1);
}
void USART2_IRQHandler(void) {
call_hal_irq(2);
}
void USART3_IRQHandler(void) {
call_hal_irq(3);
}
void UART4_IRQHandler(void) {
call_hal_irq(4);
}
void UART5_IRQHandler(void) {
call_hal_irq(5);
}
void USART6_IRQHandler(void) {
call_hal_irq(6);
}
STATIC void uart_clock_enable(uint16_t mask) {
#ifdef USART1
if (mask & (1 << 0)) {
__HAL_RCC_USART1_FORCE_RESET();
__HAL_RCC_USART1_RELEASE_RESET();
__HAL_RCC_USART1_CLK_ENABLE();
}
#endif
#ifdef USART2
if (mask & (1 << 1)) {
__HAL_RCC_USART2_FORCE_RESET();
__HAL_RCC_USART2_RELEASE_RESET();
__HAL_RCC_USART2_CLK_ENABLE();
}
#endif
#ifdef USART3
if (mask & (1 << 2)) {
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
__HAL_RCC_USART3_CLK_ENABLE();
}
#endif
#ifdef UART4
if (mask & (1 << 3)) {
__HAL_RCC_UART4_FORCE_RESET();
__HAL_RCC_UART4_RELEASE_RESET();
__HAL_RCC_UART4_CLK_ENABLE();
}
#endif
#ifdef UART5
if (mask & (1 << 4)) {
__HAL_RCC_UART5_FORCE_RESET();
__HAL_RCC_UART5_RELEASE_RESET();
__HAL_RCC_UART5_CLK_ENABLE();
}
#endif
#ifdef USART6
if (mask & (1 << 5)) {
__HAL_RCC_USART6_FORCE_RESET();
__HAL_RCC_USART6_RELEASE_RESET();
__HAL_RCC_USART6_CLK_ENABLE();
}
#endif
#ifdef UART7
if (mask & (1 << 6)) {
__HAL_RCC_UART7_FORCE_RESET();
__HAL_RCC_UART7_RELEASE_RESET();
__HAL_RCC_UART7_CLK_ENABLE();
}
#endif
#ifdef UART8
if (mask & (1 << 7)) {
__HAL_RCC_UART8_FORCE_RESET();
__HAL_RCC_UART8_RELEASE_RESET();
__HAL_RCC_UART8_CLK_ENABLE();
}
#endif
#ifdef UART9
if (mask & (1 << 8)) {
__HAL_RCC_UART9_FORCE_RESET();
__HAL_RCC_UART9_RELEASE_RESET();
__HAL_RCC_UART9_CLK_ENABLE();
}
#endif
#ifdef UART10
if (mask & (1 << 9)) {
__HAL_RCC_UART10_FORCE_RESET();
__HAL_RCC_UART10_RELEASE_RESET();
__HAL_RCC_UART10_CLK_ENABLE();
}
#endif
}
STATIC void uart_clock_disable(uint16_t mask) {
#ifdef USART1
if (mask & (1 << 0)) {
__HAL_RCC_USART1_FORCE_RESET();
__HAL_RCC_USART1_RELEASE_RESET();
__HAL_RCC_USART1_CLK_DISABLE();
}
#endif
#ifdef USART2
if (mask & (1 << 1)) {
__HAL_RCC_USART2_FORCE_RESET();
__HAL_RCC_USART2_RELEASE_RESET();
__HAL_RCC_USART2_CLK_DISABLE();
}
#endif
#ifdef USART3
if (mask & (1 << 2)) {
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
__HAL_RCC_USART3_CLK_DISABLE();
}
#endif
#ifdef UART4
if (mask & (1 << 3)) {
__HAL_RCC_UART4_FORCE_RESET();
__HAL_RCC_UART4_RELEASE_RESET();
__HAL_RCC_UART4_CLK_DISABLE();
}
#endif
#ifdef UART5
if (mask & (1 << 4)) {
__HAL_RCC_UART5_FORCE_RESET();
__HAL_RCC_UART5_RELEASE_RESET();
__HAL_RCC_UART5_CLK_DISABLE();
}
#endif
#ifdef USART6
if (mask & (1 << 5)) {
__HAL_RCC_USART6_FORCE_RESET();
__HAL_RCC_USART6_RELEASE_RESET();
__HAL_RCC_USART6_CLK_DISABLE();
}
#endif
#ifdef UART7
if (mask & (1 << 6)) {
__HAL_RCC_UART7_FORCE_RESET();
__HAL_RCC_UART7_RELEASE_RESET();
__HAL_RCC_UART7_CLK_DISABLE();
}
#endif
#ifdef UART8
if (mask & (1 << 7)) {
__HAL_RCC_UART8_FORCE_RESET();
__HAL_RCC_UART8_RELEASE_RESET();
__HAL_RCC_UART8_CLK_DISABLE();
}
#endif
#ifdef UART9
if (mask & (1 << 8)) {
__HAL_RCC_UART9_FORCE_RESET();
__HAL_RCC_UART9_RELEASE_RESET();
__HAL_RCC_UART9_CLK_DISABLE();
}
#endif
#ifdef UART10
if (mask & (1 << 9)) {
__HAL_RCC_UART10_FORCE_RESET();
__HAL_RCC_UART10_RELEASE_RESET();
__HAL_RCC_UART10_CLK_DISABLE();
}
#endif
}
2021-03-15 09:57:36 -04:00
STATIC void uart_assign_irq(busio_uart_obj_t *self, USART_TypeDef *USARTx) {
2020-03-11 18:13:06 -04:00
#ifdef USART1
if (USARTx == USART1) {
self->irq = USART1_IRQn;
}
#endif
#ifdef USART2
if (USARTx == USART2) {
self->irq = USART2_IRQn;
}
#endif
#ifdef USART3
if (USARTx == USART3) {
self->irq = USART3_IRQn;
}
#endif
#ifdef UART4
if (USARTx == UART4) {
self->irq = UART4_IRQn;
}
#endif
#ifdef UART5
if (USARTx == UART5) {
self->irq = UART5_IRQn;
}
#endif
#ifdef USART6
if (USARTx == USART6) {
self->irq = USART6_IRQn;
}
#endif
#ifdef UART7
if (USARTx == UART7) {
self->irq = UART7_IRQn;
}
#endif
#ifdef UART8
if (USARTx == UART8) {
self->irq = UART8_IRQn;
}
#endif
#ifdef UART9
if (USARTx == UART9) {
self->irq = UART9_IRQn;
}
#endif
#ifdef UART10
if (USARTx == UART10) {
self->irq = UART10_IRQn;
}
#endif
}