WIP

Author: k0d

main.c

@@ -55,6 +55,7 @@
 #include "supervisor/shared/safe_mode.h"
 #include "supervisor/shared/status_leds.h"
 #include "supervisor/shared/stack.h"
+#include "supervisor/debug.h"
 #include "supervisor/serial.h"
 
 #include "boards/board.h"
@@ -219,6 +220,8 @@ bool run_code_py(safe_mode_t safe_mode) {
     }
     #endif
 
+    debug_reinit();
+
     pyexec_result_t result;
 
     result.return_code = 0;

ports/stm/Makefile

@@ -111,6 +111,7 @@ CFLAGS += $(MCU_FLAGS_$(MCU_SERIES))
 CFLAGS += -DSTM32_HAL_H='<stm32$(MCU_SERIES_LOWER)xx_hal.h>'
 
 CFLAGS += -DSTM32_SERIES_LOWER='"stm32$(MCU_SERIES_LOWER)"'
+CFLAGS += -DUSE_HAL_UART_REGISTER_CALLBACKS
 
 # Floating point settings
 ifeq ($(MCU_VARIANT),$(filter $(MCU_VARIANT),STM32F765xx STM32F767xx STM32F769xx STM32H743xx))

ports/stm/boards/nucleo_f746zg/mpconfigboard.h

@@ -34,3 +34,16 @@
 #define FLASH_PAGE_SIZE             (0x4000)
 
 #define BOARD_OSC_DIV (8)
+
+#define DEBUG_UART USART3
+#define DEBUG_UART_TX_CLK_ENABLE __HAL_RCC_GPIOD_CLK_ENABLE
+#define DEBUG_UART_TX_PORT GPIOD
+#define DEBUG_UART_TX_PIN GPIO_PIN_8
+#define DEBUG_UART_TX_AF GPIO_AF7_USART3
+#define DEBUG_UART_RX_CLK_ENABLE __HAL_RCC_GPIOD_CLK_ENABLE
+#define DEBUG_UART_RX_PORT GPIOD
+#define DEBUG_UART_RX_PIN GPIO_PIN_9
+#define DEBUG_UART_RX_AF GPIO_AF7_USART3
+#define DEBUG_UART_IRQn USART3_IRQn
+#define DEBUG_UART_CLK_ENABLE __HAL_RCC_USART3_CLK_ENABLE
+

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

@@ -29,11 +29,13 @@
 
 #include "mpconfigport.h"
 #include "lib/utils/interrupt_char.h"
+#include "lib/mp-readline/readline.h"
 #include "py/gc.h"
 #include "py/mperrno.h"
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "supervisor/shared/translate.h"
+#include "supervisor/debug.h"
 
 #include "tick.h"
 
@@ -64,12 +66,32 @@ STATIC USART_TypeDef * assign_uart_or_throw(busio_uart_obj_t* self, bool pin_eva
 
 void uart_reset(void) {
     for (uint8_t i = 0; i < MAX_UART; i++) {
-        reserved_uart[i] = false;
-        MP_STATE_PORT(cpy_uart_obj_all)[i] = NULL;
+        if (i != 2) {
+            reserved_uart[i] = false;
+            MP_STATE_PORT(cpy_uart_obj_all)[i] = NULL;
+        }
     }
     uart_clock_disable(ALL_UARTS);
 }
 
+void uart_rxcpltcallback(UART_HandleTypeDef *handle)
+{
+    for (int i = 0; i < 7; i++) {
+        //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];
+        if (handle == &context->handle) {
+            //check if transaction is ongoing
+            if ((HAL_UART_GetState(handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
+                return;
+            }
+            ringbuf_put_n(&context->rbuf, &context->rx_char, 1);
+            errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
+
+            return;
+        }
+    }
+}
+
 void common_hal_busio_uart_construct(busio_uart_obj_t *self,
     const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx,
     const mcu_pin_obj_t * rts, const mcu_pin_obj_t * cts,
@@ -234,6 +256,10 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
     HAL_NVIC_SetPriority(self->irq, UART_IRQPRI, UART_IRQSUB_PRI);
     HAL_NVIC_EnableIRQ(self->irq);
 
+    HAL_UART_RegisterCallback(&self->handle,
+        HAL_UART_RX_COMPLETE_CB_ID, uart_rxcpltcallback);
+
+
     errflag = HAL_OK;
 }
 
@@ -311,24 +337,6 @@ size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data,
     return len;
 }
 
-void HAL_UART_RxCpltCallback(UART_HandleTypeDef *handle)
-{
-    for (int i = 0; i < 7; i++) {
-        //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];
-        if (handle == &context->handle) {
-            //check if transaction is ongoing
-            if ((HAL_UART_GetState(handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
-                return;
-            }
-            ringbuf_put_n(&context->rbuf, &context->rx_char, 1);
-            errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
-
-            return;
-        }
-    }
-}
-
 void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle)
 {
     if (__HAL_UART_GET_FLAG(UartHandle, UART_FLAG_PE) != RESET) {
@@ -413,7 +421,8 @@ void USART2_IRQHandler(void) {
 }
 
 void USART3_IRQHandler(void) {
-    call_hal_irq(3);
+    // call_hal_irq(3);
+    debug_irq_handler();
 }
 
 void UART4_IRQHandler(void) {
@@ -444,11 +453,11 @@ STATIC void uart_clock_enable(uint16_t mask) {
     }
     #endif
     #ifdef USART3
-    if (mask & (1 << 2)) {
-        __HAL_RCC_USART3_FORCE_RESET();
-        __HAL_RCC_USART3_RELEASE_RESET();
-        __HAL_RCC_USART3_CLK_ENABLE();
-    }
+    // 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)) {
@@ -516,12 +525,12 @@ STATIC void uart_clock_disable(uint16_t mask) {
         __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();
-    }
+    #if defined(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)) {
@@ -586,9 +595,9 @@ STATIC void uart_assign_irq(busio_uart_obj_t *self, USART_TypeDef * USARTx) {
     }
     #endif
     #ifdef USART3
-    if (USARTx == USART3) {
-        self->irq = USART3_IRQn;
-    }
+    // if (USARTx == USART3) {
+    //     self->irq = USART3_IRQn;
+    // }
     #endif
     #ifdef UART4
     if (USARTx == UART4) {

ports/stm/supervisor/debug.c

@@ -0,0 +1,122 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Mark Olsson <[email protected]>
+ *
+ * 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 "py/mphal.h"
+#include <string.h>
+#include "supervisor/debug.h"
+#include "common-hal/microcontroller/Pin.h"
+#include "lib/utils/interrupt_char.h"
+#include "lib/mp-readline/readline.h"
+#include STM32_HAL_H
+
+UART_HandleTypeDef huart;
+
+void debug_rxcpltcallback(UART_HandleTypeDef *handle) {
+    if ((HAL_UART_GetState(handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
+        return;
+    }
+    uint8_t rx_char;
+    HAL_UART_Receive_IT(handle, &rx_char, 1);
+     if (rx_char == CHAR_CTRL_C) {
+        HAL_NVIC_DisableIRQ(DEBUG_UART_IRQn);
+        __HAL_UART_DISABLE_IT(handle, UART_IT_RXNE);
+        mp_keyboard_interrupt();
+    }
+}
+
+void debug_reinit(void) {
+    HAL_NVIC_EnableIRQ(DEBUG_UART_IRQn);
+    __HAL_UART_ENABLE_IT(&huart, UART_IT_RXNE);
+}
+
+void debug_init(void) {
+    GPIO_InitTypeDef GPIO_InitStruct;
+    RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
+
+    DEBUG_UART_CLK_ENABLE();
+    DEBUG_UART_TX_CLK_ENABLE();
+    DEBUG_UART_RX_CLK_ENABLE();
+
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3; // TODO
+    PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1; // TODO
+    HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
+
+    GPIO_InitStruct.Pin = DEBUG_UART_TX_PIN;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = DEBUG_UART_TX_AF;
+    HAL_GPIO_Init(DEBUG_UART_TX_PORT, &GPIO_InitStruct);
+    
+    GPIO_InitStruct.Pin = DEBUG_UART_RX_PIN;
+    GPIO_InitStruct.Alternate = DEBUG_UART_RX_AF;
+    HAL_GPIO_Init(DEBUG_UART_RX_PORT, &GPIO_InitStruct);
+
+    never_reset_pin_number(3, 8); // TODO
+    never_reset_pin_number(3, 9); // TODO
+
+    huart.Instance = DEBUG_UART;
+    huart.Init.BaudRate = 115200;
+    huart.Init.WordLength = UART_WORDLENGTH_8B;
+    huart.Init.StopBits = UART_STOPBITS_1;
+    huart.Init.Parity = UART_PARITY_NONE;
+    huart.Init.Mode = UART_MODE_TX_RX;
+    huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+    huart.Init.OverSampling = UART_OVERSAMPLING_16;
+    HAL_UART_Init(&huart);
+
+    HAL_UART_RegisterCallback(&huart,
+        HAL_UART_RX_COMPLETE_CB_ID, debug_rxcpltcallback);
+
+    HAL_NVIC_DisableIRQ(DEBUG_UART_IRQn); //prevent handle lock contention
+    uint8_t rx_char;
+    HAL_UART_Receive_IT(&huart, &rx_char, 1);
+    HAL_NVIC_SetPriority(DEBUG_UART_IRQn, 1, 0);
+    HAL_NVIC_EnableIRQ(DEBUG_UART_IRQn);
+    __HAL_UART_ENABLE_IT(&huart, UART_IT_RXNE);
+}
+
+char debug_read(void) {
+    uint8_t data;
+    HAL_UART_Receive(&huart, &data, 1, 500);
+    return data;
+}
+
+bool debug_bytes_available(void) {
+    return __HAL_UART_GET_FLAG(&huart, UART_FLAG_RXNE);
+}
+
+void debug_write_substring(const char *text, uint32_t len) {
+    if (len == 0) {
+        return;
+    }
+    HAL_UART_Transmit(&huart, (uint8_t*)text, len, 5000);
+}
+
+void debug_irq_handler(void) {
+    HAL_NVIC_ClearPendingIRQ(DEBUG_UART_IRQn);
+    HAL_UART_IRQHandler(&huart);
+}

ports/stm/supervisor/serial.c

@@ -28,24 +28,46 @@
 #include "py/mphal.h"
 #include <string.h>
 #include "supervisor/serial.h"
-#include "stm32f4xx_hal.h"
-#include "stm32f4/gpio.h"
+#include STM32_HAL_H
 
-UART_HandleTypeDef huart2;
+UART_HandleTypeDef huart;
+
+// TODO Make this file generic
 
 void serial_init(void) {
-    huart2.Instance = USART2;
-    huart2.Init.BaudRate = 115200;
-    huart2.Init.WordLength = UART_WORDLENGTH_8B;
-    huart2.Init.StopBits = UART_STOPBITS_1;
-    huart2.Init.Parity = UART_PARITY_NONE;
-    huart2.Init.Mode = UART_MODE_TX_RX;
-    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
-    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
-    if (HAL_UART_Init(&huart2) == HAL_OK)
-    {
-        stm32f4_peripherals_status_led(1,1);
-    }
+    GPIO_InitTypeDef GPIO_InitStruct;
+    RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
+
+    __HAL_RCC_USART3_CLK_ENABLE();
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3;
+    PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
+    HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
+
+    GPIO_InitStruct.Pin = CONSOLE_UART_TX_PIN;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = CONSOLE_UART_TX_AF;
+    HAL_GPIO_Init(CONSOLE_UART_TX_PORT, &GPIO_InitStruct);
+    
+    GPIO_InitStruct.Pin = CONSOLE_UART_RX_PIN;
+    GPIO_InitStruct.Alternate = CONSOLE_UART_RX_AF;
+    HAL_GPIO_Init(CONSOLE_UART_RX_PORT, &GPIO_InitStruct);
+
+    never_reset_pin_number(3, 8);
+    never_reset_pin_number(3, 9);
+
+    huart.Instance = CONSOLE_UART;
+    huart.Init.BaudRate = 115200;
+    huart.Init.WordLength = UART_WORDLENGTH_8B;
+    huart.Init.StopBits = UART_STOPBITS_1;
+    huart.Init.Parity = UART_PARITY_NONE;
+    huart.Init.Mode = UART_MODE_TX_RX;
+    huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+    huart.Init.OverSampling = UART_OVERSAMPLING_16;
+    HAL_UART_Init(&huart);
 }
 
 bool serial_connected(void) {
@@ -54,12 +76,12 @@ bool serial_connected(void) {
 
 char serial_read(void) {
     uint8_t data;
-    HAL_UART_Receive(&huart2, &data, 1,500);
+    HAL_UART_Receive(&huart, &data, 1, 500);
     return data;
 }
 
 bool serial_bytes_available(void) {
-    return __HAL_UART_GET_FLAG(&huart2, UART_FLAG_RXNE);
+    return __HAL_UART_GET_FLAG(&huart, UART_FLAG_RXNE);
 }
 
 void serial_write(const char* text) {
@@ -70,6 +92,6 @@ void serial_write_substring(const char *text, uint32_t len) {
     if (len == 0) {
         return;
     }
-    HAL_UART_Transmit(&huart2, (uint8_t*)text, len, 5000);
+    HAL_UART_Transmit(&huart, (uint8_t*)text, len, 5000);
 }